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 <script> tags, which is a no-no
      return false
    end

    @card.save_with_optional_image!
  end

  def attempt_opengraph
    return if html.nil?

    link_details_extractor = LinkDetailsExtractor.new(@url, @html, @html_charset)

    @card = PreviewCard.find_or_initialize_by(url: link_details_extractor.canonical_url) if link_details_extractor.canonical_url != @card.url
    @card.assign_attributes(link_details_extractor.to_preview_card_attributes)
    @card.save_with_optional_image! unless @card.title.blank? && @card.html.blank?
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe FetchLinkCardService, type: :service do
  subject { described_class.new }

  let(:html) { '<!doctype html><title>Hello world</title>' }
  let(:oembed_cache) { nil }

  before do
    stub_request(:get, 'http://example.com/html').to_return(headers: { 'Content-Type' => 'text/html' }, body: html)
    stub_request(:get, 'http://example.com/not-found').to_return(status: 404, headers: { 'Content-Type' => 'text/html' }, body: html)
    stub_request(:get, 'http://example.com/text').to_return(status: 404, headers: { 'Content-Type' => 'text/plain' }, body: 'Hello')
    stub_request(:get, 'http://example.com/redirect').to_return(status: 302, headers: { 'Location' => 'http://example.com/html' })
    stub_request(:get, 'http://example.com/redirect-to-404').to_return(status: 302, headers: { 'Location' => 'http://example.com/not-found' })
    stub_request(:get, 'http://example.com/oembed?url=http://example.com/html').to_return(headers: { 'Content-Type' => 'application/json' }, body: '{ ""version"": ""1.0"", ""type"": ""link"", ""title"": ""oEmbed title"" }')
    stub_request(:get, 'http://example.com/oembed?format=json&url=http://example.com/html').to_return(headers: { 'Content-Type' => 'application/json' }, body: '{ ""version"": ""1.0"", ""type"": ""link"", ""title"": ""oEmbed title"" }')

    stub_request(:get, 'http://example.xn--fiqs8s')
    stub_request(:get, 'http://example.com/日本語')
    stub_request(:get, 'http://example.com/test?data=file.gpx%5E1')
    stub_request(:get, 'http://example.com/test-')

    stub_request(:get, 'http://example.com/sjis').to_return(request_fixture('sjis.txt'))
    stub_request(:get, 'http://example.com/sjis_with_wrong_charset').to_return(request_fixture('sjis_with_wrong_charset.txt'))
    stub_request(:get, 'http://example.com/koi8-r').to_return(request_fixture('koi8-r.txt'))
    stub_request(:get, 'http://example.com/windows-1251').to_return(request_fixture('windows-1251.txt'))

    Rails.cache.write('oembed_endpoint:example.com', oembed_cache) if oembed_cache

    subject.call(status)
  end

  context 'with a local status' do
    context 'with URL of a regular HTML page' do
      let(:status) { Fabricate(:status, text: 'http://example.com/html') }

      it 'creates preview card' do
        expect(status.preview_card).to_not be_nil
        expect(status.preview_card.url).to eq 'http://example.com/html'
        expect(status.preview_card.title).to eq 'Hello world'
      end
    end

    context 'with URL of a page with no title' do
      let(:status) { Fabricate(:status, text: 'http://example.com/html') }
      let(:html) { '<!doctype html><title></title>' }

      it 'does not create a preview card' do
        expect(status.preview_card).to be_nil
      end
    end

    context 'with a URL of a plain-text page' do
      let(:status) { Fabricate(:status, text: 'http://example.com/text') }

      it 'does not create a preview card' do
        expect(status.preview_card).to be_nil
      end
    end

    context 'with multiple URLs' do
      let(:status) { Fabricate(:status, text: 'ftp://example.com http://example.com/html http://example.com/text') }

      it 'fetches the first valid URL' do
        expect(a_request(:get, 'http://example.com/html')).to have_been_made
      end

      it 'does not fetch the second valid URL' do
        expect(a_request(:get, 'http://example.com/text/')).to_not have_been_made
      end
    end

    context 'with a redirect URL' do
      let(:status) { Fabricate(:status, text: 'http://example.com/redirect') }

      it 'follows redirect' do
        expect(a_request(:get, 'http://example.com/redirect')).to have_been_made.once
        expect(a_request(:get, 'http://example.com/html')).to have_been_made.once
      end

      it 'creates preview card' do
        expect(status.preview_card).to_not be_nil
        expect(status.preview_card.url).to eq 'http://example.com/html'
        expect(status.preview_card.title).to eq 'Hello world'
      end
    end

    context 'with a broken redirect URL' do
      let(:status) { Fabricate(:status, text: 'http://example.com/redirect-to-404') }

      it 'follows redirect' do
        expect(a_request(:get, 'http://example.com/redirect-to-404')).to have_been_made.once
        expect(a_request(:get, 'http://example.com/not-found')).to have_been_made.once
      end

      it 'does not create a preview card' do
        expect(status.preview_card).to be_nil
      end
    end

    context 'with a 404 URL' do
      let(:status) { Fabricate(:status, text: 'http://example.com/not-found') }

      it 'does not create a preview card' do
        expect(status.preview_card).to be_nil
      end
    end

    context 'with an IDN URL' do
      let(:status) { Fabricate(:status, text: 'Check out http://example.中国') }

      it 'fetches the URL' do
        expect(a_request(:get, 'http://example.xn--fiqs8s/')).to have_been_made.once
      end
    end

    context 'with a URL of a page in Shift JIS encoding' do
      let(:status) { Fabricate(:status, text: 'Check out http://example.com/sjis') }

      it 'decodes the HTML' do
        expect(status.preview_card.title).to eq('SJISのページ')
      end
    end

    context 'with a URL of a page in Shift JIS encoding labeled as UTF-8' do
      let(:status) { Fabricate(:status, text: 'Check out http://example.com/sjis_with_wrong_charset') }

      it 'decodes the HTML despite the wrong charset header' do
        expect(status.preview_card.title).to eq('SJISのページ')
      end
    end

    context 'with a URL of a page in KOI8-R encoding' do
      let(:status) { Fabricate(:status, text: 'Check out http://example.com/koi8-r') }

      it 'decodes the HTML' do
        expect(status.preview_card.title).to eq('Московя начинаетъ только въ XVI ст. привлекать внимане иностранцевъ.')
      end
    end

    context 'with a URL of a page in Windows-1251 encoding' do
      let(:status) { Fabricate(:status, text: 'Check out http://example.com/windows-1251') }

      it 'decodes the HTML' do
        expect(status.preview_card.title).to eq('сэмпл текст')
      end
    end

    context 'with a Japanese path URL' do
      let(:status) { Fabricate(:status, text: 'テストhttp://example.com/日本語') }

      it 'fetches the URL' do
        expect(a_request(:get, 'http://example.com/日本語')).to have_been_made.once
      end
    end

    context 'with a hyphen-suffixed URL' do
      let(:status) { Fabricate(:status, text: 'test http://example.com/test-') }

      it 'fetches the URL' do
        expect(a_request(:get, 'http://example.com/test-')).to have_been_made.once
      end
    end

    context 'with a caret-suffixed URL' do
      let(:status) { Fabricate(:status, text: 'test http://example.com/test?data=file.gpx^1') }

      it 'fetches the URL' do
        expect(a_request(:get, 'http://example.com/test?data=file.gpx%5E1')).to have_been_made.once
      end

      it 'does not strip the caret before fetching' do
        expect(a_request(:get, 'http://example.com/test?data=file.gpx')).to_not have_been_made
      end
    end

    context 'with a non-isolated URL' do
      let(:status) { Fabricate(:status, text: 'testhttp://example.com/sjis') }

      it 'does not fetch URLs not isolated from their surroundings' do
        expect(a_request(:get, 'http://example.com/sjis')).to_not have_been_made
      end
    end

    context 'with a URL of a page with oEmbed support' do
      let(:html) { '<!doctype html><title>Hello world</title><link rel=""alternate"" type=""application/json+oembed"" href=""http://example.com/oembed?url=http://example.com/html"">' }
      let(:status) { Fabricate(:status, text: 'http://example.com/html') }

      it 'fetches the oEmbed URL' do
        expect(a_request(:get, 'http://example.com/oembed?url=http://example.com/html')).to have_been_made.once
      end

      it 'creates preview card' do
        expect(status.preview_card).to_not be_nil
        expect(status.preview_card.url).to eq 'http://example.com/html'
        expect(status.preview_card.title).to eq 'oEmbed title'
      end

      context 'when oEmbed endpoint cache populated' do
        let(:oembed_cache) { { endpoint: 'http://example.com/oembed?format=json&url={url}', format: :json } }

        it 'uses the cached oEmbed response' do
          expect(a_request(:get, 'http://example.com/oembed?url=http://example.com/html')).to_not have_been_made
          expect(a_request(:get, 'http://example.com/oembed?format=json&url=http://example.com/html')).to have_been_made
        end

        it 'creates preview card' do
          expect(status.preview_card).to_not be_nil
          expect(status.preview_card.url).to eq 'http://example.com/html'
          expect(status.preview_card.title).to eq 'oEmbed title'
        end
      end

      # If the original HTML URL for whatever reason (e.g. DOS protection) redirects to
      # an error page, we can still use the cached oEmbed but should not use the
      # redirect URL on the card.
      context 'when oEmbed endpoint cache populated but page returns 404' do
        let(:status) { Fabricate(:status, text: 'http://example.com/redirect-to-404') }
        let(:oembed_cache) { { endpoint: 'http://example.com/oembed?url=http://example.com/html', format: :json } }

        it 'uses the cached oEmbed response' do
          expect(a_request(:get, 'http://example.com/oembed?url=http://example.com/html')).to have_been_made
        end

        it 'creates preview card' do
          expect(status.preview_card).to_not be_nil
          expect(status.preview_card.title).to eq 'oEmbed title'
        end

        it 'uses the original URL' do
          expect(status.preview_card&.url).to eq 'http://example.com/redirect-to-404'
        end
      end
    end
  end

  context 'with a remote status' do
    let(:status) do
      Fabricate(:status, account: Fabricate(:account, domain: 'example.com'), text: <<-TEXT)
      Habt ihr ein paar gute Links zu <a>foo</a>
      #<span class=""tag""><a href=""https://quitter.se/tag/wannacry"" target=""_blank"" rel=""tag noopener noreferrer"" title=""https://quitter.se/tag/wannacry"">Wannacry</a></span> herumfliegen?
      Ich will mal unter <br> <a href=""http://example.com/not-found"" target=""_blank"" rel=""noopener noreferrer"" title=""http://example.com/not-found"">http://example.com/not-found</a> was sammeln. !
      <a href=""http://sn.jonkman.ca/group/416/id"" target=""_blank"" rel=""noopener noreferrer"" title=""http://sn.jonkman.ca/group/416/id"">security</a>&nbsp;
      TEXT
    end

    it 'parses out URLs' do
      expect(a_request(:get, 'http://example.com/not-found')).to have_been_made.once
    end

    it 'ignores URLs to hashtags' do
      expect(a_request(:get, 'https://quitter.se/tag/wannacry')).to_not have_been_made
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class UpdateAccountService < BaseService
  def call(account, params, raise_error: false)
    was_locked    = account.locked
    update_method = raise_error ? :update! : :update

    account.send(update_method, params).tap do |ret|
      next unless ret

      authorize_all_follow_requests(account) if was_locked && !account.locked
      check_links(account)
      process_hashtags(account)
    end
  rescue Mastodon::DimensionsValidationError, Mastodon::StreamValidationError => e
    account.errors.add(:avatar, e.message)
    false
  end

  private

  def authorize_all_follow_requests(account)
    follow_requests = FollowRequest.where(target_account: account)
    follow_requests = follow_requests.preload(:account).select { |req| !req.account.silenced? }
    AuthorizeFollowWorker.push_bulk(follow_requests, limit: 1_000) do |req|
      [req.account_id, req.target_account_id]
    end
  end

  def check_links(account)
    return unless account.fields.any?(&:requires_verification?)

    VerifyAccountLinksWorker.perform_async(account.id)
  end

  def process_hashtags(account)
    account.tags_as_strings = Extractor.extract_hashtags(account.note)
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe UpdateAccountService, type: :service do
  subject { described_class.new }

  describe 'switching form locked to unlocked accounts' do
    let(:account) { Fabricate(:account, locked: true) }
    let(:alice)   { Fabricate(:account) }
    let(:bob)     { Fabricate(:account) }
    let(:eve)     { Fabricate(:account) }

    before do
      bob.touch(:silenced_at)
      account.mute!(eve)

      FollowService.new.call(alice, account)
      FollowService.new.call(bob, account)
      FollowService.new.call(eve, account)

      subject.call(account, { locked: false })
    end

    it 'auto-accepts pending follow requests' do
      expect(alice.following?(account)).to be true
      expect(alice.requested?(account)).to be false
    end

    it 'does not auto-accept pending follow requests from silenced users' do
      expect(bob.following?(account)).to be false
      expect(bob.requested?(account)).to be true
    end

    it 'auto-accepts pending follow requests from muted users so as to not leak mute' do
      expect(eve.following?(account)).to be true
      expect(eve.requested?(account)).to be false
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class ReblogService < BaseService
  include Authorization
  include Payloadable

  # Reblog a status and notify its remote author
  # @param [Account] account Account to reblog from
  # @param [Status] reblogged_status Status to be reblogged
  # @param [Hash] options
  # @option [String]  :visibility
  # @option [Boolean] :with_rate_limit
  # @return [Status]
  def call(account, reblogged_status, options = {})
    reblogged_status = reblogged_status.reblog if reblogged_status.reblog?

    authorize_with account, reblogged_status, :reblog?

    reblog = account.statuses.find_by(reblog: reblogged_status)

    return reblog unless reblog.nil?

    visibility = if reblogged_status.hidden?
                   reblogged_status.visibility
                 else
                   options[:visibility] || account.user&.setting_default_privacy
                 end

    reblog = account.statuses.create!(reblog: reblogged_status, text: '', visibility: visibility, rate_limit: options[:with_rate_limit])

    Trends.register!(reblog)
    DistributionWorker.perform_async(reblog.id)
    ActivityPub::DistributionWorker.perform_async(reblog.id)

    create_notification(reblog)
    bump_potential_friendship(account, reblog)

    reblog
  end

  private

  def create_notification(reblog)
    reblogged_status = reblog.reblog

    if reblogged_status.account.local?
      LocalNotificationWorker.perform_async(reblogged_status.account_id, reblog.id, reblog.class.name, 'reblog')
    elsif reblogged_status.account.activitypub? && !reblogged_status.account.following?(reblog.account)
      ActivityPub::DeliveryWorker.perform_async(build_json(reblog), reblog.account_id, reblogged_status.account.inbox_url)
    end
  end

  def bump_potential_friendship(account, reblog)
    ActivityTracker.increment('activity:interactions')

    return if account.following?(reblog.reblog.account_id)

    PotentialFriendshipTracker.record(account.id, reblog.reblog.account_id, :reblog)
  end

  def build_json(reblog)
    Oj.dump(serialize_payload(ActivityPub::ActivityPresenter.from_status(reblog), ActivityPub::ActivitySerializer, signer: reblog.account))
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe ReblogService, type: :service do
  let(:alice)  { Fabricate(:account, username: 'alice') }

  context 'when creates a reblog with appropriate visibility' do
    subject { described_class.new }

    let(:visibility)        { :public }
    let(:reblog_visibility) { :public }
    let(:status)            { Fabricate(:status, account: alice, visibility: visibility) }

    before do
      subject.call(alice, status, visibility: reblog_visibility)
    end

    describe 'boosting privately' do
      let(:reblog_visibility) { :private }

      it 'reblogs privately' do
        expect(status.reblogs.first.visibility).to eq 'private'
      end
    end

    describe 'public reblogs of private toots should remain private' do
      let(:visibility)        { :private }
      let(:reblog_visibility) { :public }

      it 'reblogs privately' do
        expect(status.reblogs.first.visibility).to eq 'private'
      end
    end
  end

  context 'when the reblogged status is discarded in the meantime' do
    let(:status) { Fabricate(:status, account: alice, visibility: :public, text: 'discard-status-text') }

    # Add a callback to discard the status being reblogged after the
    # validations pass but before the database commit is executed.
    before do
      Status.class_eval do
        before_save :discard_status
        def discard_status
          Status
            .where(id: reblog_of_id)
            .where(text: 'discard-status-text')
            .update_all(deleted_at: Time.now.utc) # rubocop:disable Rails/SkipsModelValidations
        end
      end
    end

    # Remove race condition simulating `discard_status` callback.
    after do
      Status._save_callbacks.delete(:discard_status)
    end

    it 'raises an exception' do
      expect { subject.call(alice, status) }.to raise_error ActiveRecord::ActiveRecordError
    end
  end

  context 'with ActivityPub' do
    subject { described_class.new }

    let(:bob)    { Fabricate(:account, username: 'bob', protocol: :activitypub, domain: 'example.com', inbox_url: 'http://example.com/inbox') }
    let(:status) { Fabricate(:status, account: bob) }

    before do
      stub_request(:post, bob.inbox_url)
      allow(ActivityPub::DistributionWorker).to receive(:perform_async)
      subject.call(alice, status)
    end

    it 'creates a reblog' do
      expect(status.reblogs.count).to eq 1
    end

    describe 'after_create_commit :store_uri' do
      it 'keeps consistent reblog count' do
        expect(status.reblogs.count).to eq 1
      end
    end

    it 'distributes to followers' do
      expect(ActivityPub::DistributionWorker).to have_received(:perform_async)
    end

    it 'sends an announce activity to the author' 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 ProcessMentionsService < BaseService
  include Payloadable

  # Scan status for mentions and fetch remote mentioned users,
  # and create local mention pointers
  # @param [Status] status
  # @param [Boolean] save_records Whether to save records in database
  def call(status, save_records: true)
    @status = status
    @save_records = save_records

    return unless @status.local?

    @previous_mentions = @status.active_mentions.includes(:account).to_a
    @current_mentions  = []

    Status.transaction do
      scan_text!
      assign_mentions!
    end
  end

  private

  def scan_text!
    @status.text = @status.text.gsub(Account::MENTION_RE) do |match|
      username, domain = Regexp.last_match(1).split('@')

      domain = if TagManager.instance.local_domain?(domain)
                 nil
               else
                 TagManager.instance.normalize_domain(domain)
               end

      mentioned_account = Account.find_remote(username, domain)

      # Unapproved and unconfirmed accounts should not be mentionable
      next match if mentioned_account&.local? && !(mentioned_account.user_confirmed? && mentioned_account.user_approved?)

      # If the account cannot be found or isn't the right protocol,
      # first try to resolve it
      if mention_undeliverable?(mentioned_account)
        begin
          mentioned_account = ResolveAccountService.new.call(Regexp.last_match(1))
        rescue Webfinger::Error, HTTP::Error, OpenSSL::SSL::SSLError, Mastodon::UnexpectedResponseError
          mentioned_account = nil
        end
      end

      # If after resolving it still isn't found or isn't the right
      # protocol, then give up
      next match if mention_undeliverable?(mentioned_account) || mentioned_account&.unavailable?

      mention   = @previous_mentions.find { |x| x.account_id == mentioned_account.id }
      mention ||= @current_mentions.find  { |x| x.account_id == mentioned_account.id }
      mention ||= @status.mentions.new(account: mentioned_account)

      @current_mentions << mention

      ""@#{mentioned_account.acct}""
    end

    @status.save! if @save_records
  end

  def assign_mentions!
    # Make sure we never mention blocked accounts
    unless @current_mentions.empty?
      mentioned_domains = @current_mentions.filter_map { |m| m.account.domain }.uniq
      blocked_domains   = Set.new(mentioned_domains.empty? ? [] : AccountDomainBlock.where(account_id: @status.account_id, domain: mentioned_domains))
      mentioned_account_ids = @current_mentions.map(&:account_id)
      blocked_account_ids = Set.new(@status.account.block_relationships.where(target_account_id: mentioned_account_ids).pluck(:target_account_id))

      dropped_mentions, @current_mentions = @current_mentions.partition { |mention| blocked_account_ids.include?(mention.account_id) || blocked_domains.include?(mention.account.domain) }
      dropped_mentions.each(&:destroy)
    end

    @current_mentions.each do |mention|
      mention.save if mention.new_record? && @save_records
    end

    # If previous mentions are no longer contained in the text, convert them
    # to silent mentions, since withdrawing access from someone who already
    # received a notification might be more confusing
    removed_mentions = @previous_mentions - @current_mentions

    Mention.where(id: removed_mentions.map(&:id)).update_all(silent: true) unless removed_mentions.empty?
  end

  def mention_undeliverable?(mentioned_account)
    mentioned_account.nil? || (!mentioned_account.local? && !mentioned_account.activitypub?)
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe ProcessMentionsService, type: :service do
  subject { described_class.new }

  let(:account) { Fabricate(:account, username: 'alice') }

  context 'when mentions contain blocked accounts' do
    let(:non_blocked_account)          { Fabricate(:account) }
    let(:individually_blocked_account) { Fabricate(:account) }
    let(:domain_blocked_account)       { Fabricate(:account, domain: 'evil.com') }
    let(:status) { Fabricate(:status, account: account, text: ""Hello @#{non_blocked_account.acct} @#{individually_blocked_account.acct} @#{domain_blocked_account.acct}"", visibility: :public) }

    before do
      account.block!(individually_blocked_account)
      account.domain_blocks.create!(domain: domain_blocked_account.domain)

      subject.call(status)
    end

    it 'creates a mention to the non-blocked account' do
      expect(non_blocked_account.mentions.where(status: status).count).to eq 1
    end

    it 'does not create a mention to the individually blocked account' do
      expect(individually_blocked_account.mentions.where(status: status).count).to eq 0
    end

    it 'does not create a mention to the domain-blocked account' do
      expect(domain_blocked_account.mentions.where(status: status).count).to eq 0
    end
  end

  context 'with resolving a mention to a remote account' do
    let(:status) { Fabricate(:status, account: account, text: ""Hello @#{remote_user.acct}"", visibility: :public) }

    context 'with ActivityPub' do
      context 'with a valid remote user' do
        let!(:remote_user) { Fabricate(:account, username: 'remote_user', protocol: :activitypub, domain: 'example.com', inbox_url: 'http://example.com/inbox') }

        before do
          subject.call(status)
        end

        it 'creates a mention' do
          expect(remote_user.mentions.where(status: status).count).to eq 1
        end
      end

      context 'when mentioning a user several times when not saving records' do
        let!(:remote_user) { Fabricate(:account, username: 'remote_user', protocol: :activitypub, domain: 'example.com', inbox_url: 'http://example.com/inbox') }
        let(:status)       { Fabricate(:status, account: account, text: ""Hello @#{remote_user.acct} @#{remote_user.acct} @#{remote_user.acct}"", visibility: :public) }

        before do
          subject.call(status, save_records: false)
        end

        it 'creates exactly one mention' do
          expect(status.mentions.size).to eq 1
        end
      end

      context 'with an IDN domain' do
        let!(:remote_user) { Fabricate(:account, username: 'sneak', protocol: :activitypub, domain: 'xn--hresiar-mxa.ch', inbox_url: 'http://example.com/inbox') }
        let!(:status) { Fabricate(:status, account: account, text: 'Hello @sneak@hæresiar.ch') }

        before do
          subject.call(status)
        end

        it 'creates a mention' do
          expect(remote_user.mentions.where(status: status).count).to eq 1
        end
      end

      context 'with an IDN TLD' do
        let!(:remote_user) { Fabricate(:account, username: 'foo', protocol: :activitypub, domain: 'xn--y9a3aq.xn--y9a3aq', inbox_url: 'http://example.com/inbox') }
        let!(:status) { Fabricate(:status, account: account, text: 'Hello @foo@հայ.հայ') }

        before do
          subject.call(status)
        end

        it 'creates a mention' do
          expect(remote_user.mentions.where(status: status).count).to eq 1
        end
      end
    end

    context 'with a Temporarily-unreachable ActivityPub user' do
      let!(:remote_user) { Fabricate(:account, username: 'remote_user', protocol: :activitypub, domain: 'example.com', inbox_url: 'http://example.com/inbox', last_webfingered_at: nil) }

      before do
        stub_request(:get, 'https://example.com/.well-known/host-meta').to_return(status: 404)
        stub_request(:get, 'https://example.com/.well-known/webfinger?resource=acct:remote_user@example.com').to_return(status: 500)
        subject.call(status)
      end

      it 'creates a mention' do
        expect(remote_user.mentions.where(status: status).count).to eq 1
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class BatchedRemoveStatusService < BaseService
  include Redisable

  # Delete multiple statuses and reblogs of them as efficiently as possible
  # @param [Enumerable<Status>] statuses An array of statuses
  # @param [Hash] options
  # @option [Boolean] :skip_side_effects Do not modify feeds and send updates to streaming API
  def call(statuses, **options)
    ActiveRecord::Associations::Preloader.new(
      records: statuses,
      associations: options[:skip_side_effects] ? :reblogs : [:account, :tags, reblogs: :account]
    )

    statuses_and_reblogs = statuses.flat_map { |status| [status] + status.reblogs }

    # The conversations for direct visibility statuses also need
    # to be manually updated. This part is not efficient but we
    # rely on direct visibility statuses being relatively rare.
    statuses_with_account_conversations = statuses.select(&:direct_visibility?)

    ActiveRecord::Associations::Preloader.new(
      records: statuses_with_account_conversations,
      associations: [mentions: :account]
    )

    statuses_with_account_conversations.each(&:unlink_from_conversations!)

    # We do not batch all deletes into one to avoid having a long-running
    # transaction lock the database, but we use the delete method instead
    # of destroy to avoid all callbacks. We rely on foreign keys to
    # cascade the delete faster without loading the associations.
    statuses_and_reblogs.each_slice(50) { |slice| Status.where(id: slice.map(&:id)).delete_all }

    # Since we skipped all callbacks, we also need to manually
    # deindex the statuses
    if Chewy.enabled?
      Chewy.strategy.current.update(StatusesIndex, statuses_and_reblogs)
      Chewy.strategy.current.update(PublicStatusesIndex, statuses_and_reblogs)
    end

    return if options[:skip_side_effects]

    # Batch by source account
    statuses_and_reblogs.group_by(&:account_id).each_value do |account_statuses|
      account = account_statuses.first.account

      next unless account

      unpush_from_home_timelines(account, account_statuses)
      unpush_from_list_timelines(account, account_statuses)
    end

    # Cannot be batched
    @status_id_cutoff = Mastodon::Snowflake.id_at(2.weeks.ago)
    redis.pipelined do |pipeline|
      statuses.each do |status|
        unpush_from_public_timelines(status, pipeline)
      end
    end
  end

  private

  def unpush_from_home_timelines(account, statuses)
    account.followers_for_local_distribution.includes(:user).reorder(nil).find_each do |follower|
      statuses.each do |status|
        FeedManager.instance.unpush_from_home(follower, status)
      end
    end
  end

  def unpush_from_list_timelines(account, statuses)
    account.lists_for_local_distribution.select(:id, :account_id).includes(account: :user).reorder(nil).find_each do |list|
      statuses.each do |status|
        FeedManager.instance.unpush_from_list(list, status)
      end
    end
  end

  def unpush_from_public_timelines(status, pipeline)
    return unless status.public_visibility? && status.id > @status_id_cutoff

    payload = Oj.dump(event: :delete, payload: status.id.to_s)

    pipeline.publish('timeline:public', payload)
    pipeline.publish(status.local? ? 'timeline:public:local' : 'timeline:public:remote', payload)

    if status.media_attachments.any?
      pipeline.publish('timeline:public:media', payload)
      pipeline.publish(status.local? ? 'timeline:public:local:media' : 'timeline:public:remote:media', payload)
    end

    status.tags.map { |tag| tag.name.mb_chars.downcase }.each do |hashtag|
      pipeline.publish(""timeline:hashtag:#{hashtag}"", payload)
      pipeline.publish(""timeline:hashtag:#{hashtag}:local"", payload) if status.local?
    end
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe BatchedRemoveStatusService, type: :service do
  subject { described_class.new }

  let!(:alice)  { Fabricate(:account) }
  let!(:bob)    { Fabricate(:account, username: 'bob', domain: 'example.com') }
  let!(:jeff)   { Fabricate(:account) }
  let!(:hank)   { Fabricate(:account, username: 'hank', protocol: :activitypub, domain: 'example.com', inbox_url: 'http://example.com/inbox') }

  let(:status_alice_hello) { PostStatusService.new.call(alice, text: 'Hello @bob@example.com') }
  let(:status_alice_other) { PostStatusService.new.call(alice, text: 'Another status') }

  before do
    allow(redis).to receive_messages(publish: nil)

    stub_request(:post, 'http://example.com/inbox').to_return(status: 200)

    jeff.user.update(current_sign_in_at: Time.zone.now)
    jeff.follow!(alice)
    hank.follow!(alice)

    status_alice_hello
    status_alice_other

    subject.call([status_alice_hello, status_alice_other])
  end

  it 'removes statuses' do
    expect { Status.find(status_alice_hello.id) }.to raise_error ActiveRecord::RecordNotFound
    expect { Status.find(status_alice_other.id) }.to raise_error ActiveRecord::RecordNotFound
  end

  it 'removes statuses from author\'s home feed' do
    expect(HomeFeed.new(alice).get(10).pluck(:id)).to_not include(status_alice_hello.id, status_alice_other.id)
  end

  it 'removes statuses from local follower\'s home feed' do
    expect(HomeFeed.new(jeff).get(10).pluck(:id)).to_not include(status_alice_hello.id, status_alice_other.id)
  end

  it 'notifies streaming API of followers' do
    expect(redis).to have_received(:publish).with(""timeline:#{jeff.id}"", any_args).at_least(:once)
  end

  it 'notifies streaming API of public timeline' do
    expect(redis).to have_received(:publish).with('timeline:public', any_args).at_least(:once)
  end

  it 'sends delete activity to followers' do
    expect(a_request(:post, 'http://example.com/inbox')).to have_been_made.at_least_once
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class FetchRemoteStatusService < BaseService
  def call(url, prefetched_body: nil, request_id: nil)
    if prefetched_body.nil?
      resource_url, resource_options = FetchResourceService.new.call(url)
    else
      resource_url     = url
      resource_options = { prefetched_body: prefetched_body }
    end

    ActivityPub::FetchRemoteStatusService.new.call(resource_url, **resource_options.merge(request_id: request_id)) unless resource_url.nil?
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe FetchRemoteStatusService, type: :service do
  let(:account) { Fabricate(:account, domain: 'example.org', uri: 'https://example.org/foo') }
  let(:prefetched_body) { nil }

  let(:note) do
    {
      '@context': 'https://www.w3.org/ns/activitystreams',
      id: 'https://example.org/@foo/1234',
      type: 'Note',
      content: 'Lorem ipsum',
      attributedTo: ActivityPub::TagManager.instance.uri_for(account),
    }
  end

  context 'when protocol is :activitypub' do
    subject { described_class.new.call(note[:id], prefetched_body: prefetched_body) }

    let(:prefetched_body) { Oj.dump(note) }

    before do
      subject
    end

    it 'creates status' do
      status = account.statuses.first

      expect(status).to_not be_nil
      expect(status.text).to eq 'Lorem ipsum'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class SearchService < BaseService
  QUOTE_EQUIVALENT_CHARACTERS = /[“”„«»「」『』《》]/

  def call(query, account, limit, options = {})
    @query     = query&.strip&.gsub(QUOTE_EQUIVALENT_CHARACTERS, '""')
    @account   = account
    @options   = options
    @limit     = limit.to_i
    @offset    = options[:type].blank? ? 0 : options[:offset].to_i
    @resolve   = options[:resolve] || false
    @following = options[:following] || false

    default_results.tap do |results|
      next if @query.blank? || @limit.zero?

      if url_query?
        results.merge!(url_resource_results) unless url_resource.nil? || @offset.positive? || (@options[:type].present? && url_resource_symbol != @options[:type].to_sym)
      elsif @query.present?
        results[:accounts] = perform_accounts_search! if account_searchable?
        results[:statuses] = perform_statuses_search! if status_searchable?
        results[:hashtags] = perform_hashtags_search! if hashtag_searchable?
      end
    end
  end

  private

  def perform_accounts_search!
    AccountSearchService.new.call(
      @query,
      @account,
      limit: @limit,
      resolve: @resolve,
      offset: @offset,
      use_searchable_text: true,
      following: @following,
      start_with_hashtag: @query.start_with?('#')
    )
  end

  def perform_statuses_search!
    StatusesSearchService.new.call(
      @query,
      @account,
      limit: @limit,
      offset: @offset,
      account_id: @options[:account_id],
      min_id: @options[:min_id],
      max_id: @options[:max_id]
    )
  end

  def perform_hashtags_search!
    TagSearchService.new.call(
      @query,
      limit: @limit,
      offset: @offset,
      exclude_unreviewed: @options[:exclude_unreviewed]
    )
  end

  def default_results
    { accounts: [], hashtags: [], statuses: [] }
  end

  def url_query?
    @resolve && %r{\Ahttps?://}.match?(@query)
  end

  def url_resource_results
    { url_resource_symbol => [url_resource] }
  end

  def url_resource
    @url_resource ||= ResolveURLService.new.call(@query, on_behalf_of: @account)
  end

  def url_resource_symbol
    url_resource.class.name.downcase.pluralize.to_sym
  end

  def status_searchable?
    Chewy.enabled? && status_search? && @account.present?
  end

  def account_searchable?
    account_search?
  end

  def hashtag_searchable?
    hashtag_search?
  end

  def account_search?
    @options[:type].blank? || @options[:type] == 'accounts'
  end

  def hashtag_search?
    @options[:type].blank? || @options[:type] == 'hashtags'
  end

  def status_search?
    @options[:type].blank? || @options[:type] == 'statuses'
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

describe SearchService, type: :service do
  subject { described_class.new }

  describe '#call' do
    describe 'with a blank query' do
      it 'returns empty results without searching' do
        allow(AccountSearchService).to receive(:new)
        allow(Tag).to receive(:search_for)
        results = subject.call('', nil, 10)

        expect(results).to eq(empty_results)
        expect(AccountSearchService).to_not have_received(:new)
        expect(Tag).to_not have_received(:search_for)
      end
    end

    describe 'with an url query' do
      let(:query) { 'http://test.host/query' }

      context 'when it does not find anything' do
        it 'returns the empty results' do
          service = instance_double(ResolveURLService, call: nil)
          allow(ResolveURLService).to receive(:new).and_return(service)
          results = subject.call(query, nil, 10, resolve: true)

          expect(service).to have_received(:call).with(query, on_behalf_of: nil)
          expect(results).to eq empty_results
        end
      end

      context 'when it finds an account' do
        it 'includes the account in the results' do
          account = Account.new
          service = instance_double(ResolveURLService, call: account)
          allow(ResolveURLService).to receive(:new).and_return(service)

          results = subject.call(query, nil, 10, resolve: true)
          expect(service).to have_received(:call).with(query, on_behalf_of: nil)
          expect(results).to eq empty_results.merge(accounts: [account])
        end
      end

      context 'when it finds a status' do
        it 'includes the status in the results' do
          status = Status.new
          service = instance_double(ResolveURLService, call: status)
          allow(ResolveURLService).to receive(:new).and_return(service)

          results = subject.call(query, nil, 10, resolve: true)
          expect(service).to have_received(:call).with(query, on_behalf_of: nil)
          expect(results).to eq empty_results.merge(statuses: [status])
        end
      end
    end

    describe 'with a non-url query' do
      context 'when it matches an account' do
        it 'includes the account in the results' do
          query = 'username'
          account = Account.new
          service = instance_double(AccountSearchService, call: [account])
          allow(AccountSearchService).to receive(:new).and_return(service)

          results = subject.call(query, nil, 10)
          expect(service).to have_received(:call).with(query, nil, limit: 10, offset: 0, resolve: false, start_with_hashtag: false, use_searchable_text: true, following: false)
          expect(results).to eq empty_results.merge(accounts: [account])
        end
      end

      context 'when it matches a tag' do
        it 'includes the tag in the results' do
          query = '#tag'
          tag = Tag.new
          allow(Tag).to receive(:search_for).with('tag', 10, 0, { exclude_unreviewed: nil }).and_return([tag])

          results = subject.call(query, nil, 10)
          expect(Tag).to have_received(:search_for).with('tag', 10, 0, exclude_unreviewed: nil)
          expect(results).to eq empty_results.merge(hashtags: [tag])
        end
      end
    end
  end

  def empty_results
    { accounts: [], hashtags: [], statuses: [] }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class VerifyLinkService < BaseService
  def call(field)
    @link_back = ActivityPub::TagManager.instance.url_for(field.account)
    @url       = field.value_for_verification

    perform_request!

    return unless link_back_present?

    field.mark_verified!
  rescue OpenSSL::SSL::SSLError, HTTP::Error, Addressable::URI::InvalidURIError, Mastodon::HostValidationError, Mastodon::LengthValidationError, IPAddr::AddressFamilyError => e
    Rails.logger.debug { ""Error fetching link #{@url}: #{e}"" }
    nil
  end

  private

  def perform_request!
    @body = Request.new(:get, @url).add_headers('Accept' => 'text/html').perform do |res|
      res.code == 200 ? res.body_with_limit : nil
    end
  end

  def link_back_present?
    return false if @body.blank?

    links = Nokogiri::HTML5(@body).xpath('//a[contains(concat("" "", normalize-space(@rel), "" ""), "" me "")]|//link[contains(concat("" "", normalize-space(@rel), "" ""), "" me "")]')

    if links.any? { |link| link['href']&.downcase == @link_back.downcase }
      true
    elsif links.empty?
      false
    else
      link_redirects_back?(links.first['href'])
    end
  end

  def link_redirects_back?(test_url)
    return false if test_url.blank?

    redirect_to_url = Request.new(:head, test_url, follow: false).perform do |res|
      res.headers['Location']
    end

    redirect_to_url == @link_back
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe VerifyLinkService, type: :service do
  subject { described_class.new }

  context 'when given a local account' do
    let(:account) { Fabricate(:account, username: 'alice') }
    let(:field)   { Account::Field.new(account, 'name' => 'Website', 'value' => 'http://example.com') }

    before do
      stub_request(:head, 'https://redirect.me/abc').to_return(status: 301, headers: { 'Location' => ActivityPub::TagManager.instance.url_for(account) })
      stub_request(:get, 'http://example.com').to_return(status: 200, body: html)
      subject.call(field)
    end

    context 'when a link contains an <a> back' do
      let(:html) do
        <<-HTML
          <!doctype html>
          <body>
            <a href=""#{ActivityPub::TagManager.instance.url_for(account)}"" rel=""me"">Follow me on Mastodon</a>
          </body>
        HTML
      end

      it 'marks the field as verified' do
        expect(field.verified?).to be true
      end
    end

    context 'when a link contains an <a rel=""noopener noreferrer""> back' do
      let(:html) do
        <<-HTML
          <!doctype html>
          <body>
            <a href=""#{ActivityPub::TagManager.instance.url_for(account)}"" rel=""me noopener noreferrer"" target=""_blank"">Follow me on Mastodon</a>
          </body>
        HTML
      end

      it 'marks the field as verified' do
        expect(field.verified?).to be true
      end
    end

    context 'when a link contains a <link> back' do
      let(:html) do
        <<-HTML
          <!doctype html>
          <head>
            <link type=""text/html"" href=""#{ActivityPub::TagManager.instance.url_for(account)}"" rel=""me"" />
          </head>
        HTML
      end

      it 'marks the field as verified' do
        expect(field.verified?).to be true
      end
    end

    context 'when a link goes through a redirect back' do
      let(:html) do
        <<-HTML
          <!doctype html>
          <head>
            <link type=""text/html"" href=""https://redirect.me/abc"" rel=""me"" />
          </head>
        HTML
      end

      it 'marks the field as verified' do
        expect(field.verified?).to be true
      end
    end

    context 'when a document is truncated but the link back is valid' do
      let(:html) do
        ""
          <!doctype html>
          <body>
            <a rel=\""me\"" href=\""#{ActivityPub::TagManager.instance.url_for(account)}\""
        ""
      end

      it 'marks the field as not verified' do
        expect(field.verified?).to be false
      end
    end

    context 'when a link back might be truncated' do
      let(:html) do
        ""
          <!doctype html>
          <body>
            <a rel=\""me\"" href=\""#{ActivityPub::TagManager.instance.url_for(account)}""
      end

      it 'does not mark the field as verified' do
        expect(field.verified?).to be false
      end
    end

    context 'when a link does not contain a link back' do
      let(:html) { '' }

      it 'does not mark the field as verified' do
        expect(field.verified?).to be false
      end
    end

    context 'when link has no `href` attribute' do
      let(:html) do
        <<-HTML
          <!doctype html>
          <head>
            <link type=""text/html"" rel=""me"" />
          </head>
          <body>
            <a rel=""me"" target=""_blank"">Follow me on Mastodon</a>
          </body>
        HTML
      end

      it 'does not mark the field as verified' do
        expect(field.verified?).to be false
      end
    end
  end

  context 'when given a remote account' do
    let(:account) { Fabricate(:account, username: 'alice', domain: 'example.com', url: 'https://profile.example.com/alice') }
    let(:field)   { Account::Field.new(account, 'name' => 'Website', 'value' => '<a href=""http://example.com"" rel=""me""><span class=""invisible"">http://</span><span class="""">example.com</span><span class=""invisible""></span></a>') }

    before do
      stub_request(:get, 'http://example.com').to_return(status: 200, body: html)
      subject.call(field)
    end

    context 'when a link contains an <a> back' do
      let(:html) do
        <<-HTML
          <!doctype html>
          <body>
            <a href=""https://profile.example.com/alice"" rel=""me"">Follow me on Mastodon</a>
          </body>
        HTML
      end

      it 'marks the field as verified' do
        expect(field.verified?).to be true
      end
    end

    context 'when the link contains a link with a missing protocol slash' do
      # This was seen in the wild where a user had three pages:
      # 1. their mastodon profile, which linked to github and the personal website
      # 2. their personal website correctly linking back to mastodon
      # 3. a github profile that was linking to the personal website, but with
      #    a malformed protocol of http:/
      #
      # This caused link verification between the mastodon profile and the
      # website to fail.
      #
      # apparently github allows the user to enter website URLs with a single
      # slash and makes no attempts to correct that.
      let(:html) { '<a href=""http:/unrelated.example"">Hello</a>' }

      it 'does not crash' do
        # We could probably put more effort into perhaps auto-correcting the
        # link and following it anyway, but at the very least we shouldn't let
        # exceptions bubble up
        expect(field.verified?).to be false
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class FetchResourceService < BaseService
  include JsonLdHelper

  ACCEPT_HEADER = 'application/activity+json, application/ld+json; profile=""https://www.w3.org/ns/activitystreams"", text/html;q=0.1'
  ACTIVITY_STREAM_LINK_TYPES = ['application/activity+json', 'application/ld+json; profile=""https://www.w3.org/ns/activitystreams""'].freeze

  attr_reader :response_code

  def call(url)
    return if url.blank?

    process(url)
  rescue HTTP::Error, OpenSSL::SSL::SSLError, Addressable::URI::InvalidURIError, Mastodon::HostValidationError, Mastodon::LengthValidationError => e
    Rails.logger.debug { ""Error fetching resource #{@url}: #{e}"" }
    nil
  end

  private

  def process(url, terminal: false)
    @url = url

    perform_request { |response| process_response(response, terminal) }
  end

  def perform_request(&block)
    Request.new(:get, @url).tap do |request|
      request.add_headers('Accept' => ACCEPT_HEADER)

      # In a real setting we want to sign all outgoing requests,
      # in case the remote server has secure mode enabled and requires
      # authentication on all resources. However, during development,
      # sending request signatures with an inaccessible host is useless
      # and prevents even public resources from being fetched, so
      # don't do it

      request.on_behalf_of(Account.representative) unless Rails.env.development?
    end.perform(&block)
  end

  def process_response(response, terminal = false)
    @response_code = response.code
    return nil if response.code != 200

    if ['application/activity+json', 'application/ld+json'].include?(response.mime_type)
      body = response.body_with_limit
      json = body_to_json(body)

      [json['id'], { prefetched_body: body, id: true }] if supported_context?(json) && (equals_or_includes_any?(json['type'], ActivityPub::FetchRemoteActorService::SUPPORTED_TYPES) || expected_type?(json))
    elsif !terminal
      link_header = response['Link'] && parse_link_header(response)

      if link_header&.find_link(%w(rel alternate))
        process_link_headers(link_header)
      elsif response.mime_type == 'text/html'
        process_html(response)
      end
    end
  end

  def expected_type?(json)
    equals_or_includes_any?(json['type'], ActivityPub::Activity::Create::SUPPORTED_TYPES + ActivityPub::Activity::Create::CONVERTED_TYPES)
  end

  def process_html(response)
    page      = Nokogiri::HTML(response.body_with_limit)
    json_link = page.xpath('//link[@rel=""alternate""]').find { |link| ACTIVITY_STREAM_LINK_TYPES.include?(link['type']) }

    process(json_link['href'], terminal: true) unless json_link.nil?
  end

  def process_link_headers(link_header)
    json_link = link_header.find_link(%w(rel alternate), %w(type application/activity+json)) || link_header.find_link(%w(rel alternate), ['type', 'application/ld+json; profile=""https://www.w3.org/ns/activitystreams""'])

    process(json_link.href, terminal: true) unless json_link.nil?
  end

  def parse_link_header(response)
    LinkHeader.parse(response['Link'].is_a?(Array) ? response['Link'].first : response['Link'])
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe FetchResourceService, type: :service do
  describe '#call' do
    subject { described_class.new.call(url) }

    let(:url) { 'http://example.com' }

    context 'with blank url' do
      let(:url) { '' }

      it { is_expected.to be_nil }
    end

    context 'when request fails' do
      before do
        stub_request(:get, url).to_return(status: 500, body: '', headers: {})
      end

      it { is_expected.to be_nil }
    end

    context 'when OpenSSL::SSL::SSLError is raised' do
      before do
        request = instance_double(Request)
        allow(Request).to receive(:new).and_return(request)
        allow(request).to receive(:add_headers)
        allow(request).to receive(:on_behalf_of)
        allow(request).to receive(:perform).and_raise(OpenSSL::SSL::SSLError)
      end

      it { is_expected.to be_nil }
    end

    context 'when HTTP::ConnectionError is raised' do
      before do
        request = instance_double(Request)
        allow(Request).to receive(:new).and_return(request)
        allow(request).to receive(:add_headers)
        allow(request).to receive(:on_behalf_of)
        allow(request).to receive(:perform).and_raise(HTTP::ConnectionError)
      end

      it { is_expected.to be_nil }
    end

    context 'when request succeeds' do
      let(:body) { '' }

      let(:content_type) { 'application/json' }

      let(:headers) do
        { 'Content-Type' => content_type }
      end

      let(:json) do
        {
          id: 1,
          '@context': ActivityPub::TagManager::CONTEXT,
          type: 'Note',
        }.to_json
      end

      before do
        stub_request(:get, url).to_return(status: 200, body: body, headers: headers)
        stub_request(:get, 'http://example.com/foo').to_return(status: 200, body: json, headers: { 'Content-Type' => 'application/activity+json' })
      end

      it 'signs request' do
        subject
        expect(a_request(:get, url).with(headers: { 'Signature' => /keyId=""#{Regexp.escape(ActivityPub::TagManager.instance.key_uri_for(Account.representative))}""/ })).to have_been_made
      end

      context 'when content type is application/atom+xml' do
        let(:content_type) { 'application/atom+xml' }

        it { is_expected.to be_nil }
      end

      context 'when content type is activity+json' do
        let(:content_type) { 'application/activity+json; charset=utf-8' }
        let(:body) { json }

        it { is_expected.to eq [1, { prefetched_body: body, id: true }] }
      end

      context 'when content type is ld+json with profile' do
        let(:content_type) { 'application/ld+json; profile=""https://www.w3.org/ns/activitystreams""' }
        let(:body) { json }

        it { is_expected.to eq [1, { prefetched_body: body, id: true }] }
      end

      context 'when link header is present' do
        let(:headers) { { 'Link' => '<http://example.com/foo>; rel=""alternate""; type=""application/activity+json""' } }

        it { is_expected.to eq [1, { prefetched_body: json, id: true }] }
      end

      context 'when content type is text/html' do
        let(:content_type) { 'text/html' }
        let(:body) { '<html><head><link rel=""alternate"" href=""http://example.com/foo"" type=""application/activity+json""/></head></html>' }

        it { is_expected.to eq [1, { prefetched_body: json, id: true }] }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class AppSignUpService < BaseService
  include RegistrationHelper

  def call(app, remote_ip, params)
    @app       = app
    @remote_ip = remote_ip
    @params    = params

    raise Mastodon::NotPermittedError unless allowed_registration?(remote_ip, invite)

    ApplicationRecord.transaction do
      create_user!
      create_access_token!
    end

    @access_token
  end

  private

  def create_user!
    @user = User.create!(
      user_params.merge(created_by_application: @app, sign_up_ip: @remote_ip, password_confirmation: user_params[:password], account_attributes: account_params, invite_request_attributes: invite_request_params)
    )
  end

  def create_access_token!
    @access_token = Doorkeeper::AccessToken.create!(
      application: @app,
      resource_owner_id: @user.id,
      scopes: @app.scopes,
      expires_in: Doorkeeper.configuration.access_token_expires_in,
      use_refresh_token: Doorkeeper.configuration.refresh_token_enabled?
    )
  end

  def invite
    Invite.find_by(code: @params[:invite_code]) if @params[:invite_code].present?
  end

  def user_params
    @params.slice(:email, :password, :agreement, :locale, :time_zone, :invite_code)
  end

  def account_params
    @params.slice(:username)
  end

  def invite_request_params
    { text: @params[:reason] }
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe AppSignUpService, type: :service do
  subject { described_class.new }

  let(:app) { Fabricate(:application, scopes: 'read write') }
  let(:good_params) { { username: 'alice', password: '12345678', email: 'good@email.com', agreement: true } }
  let(:remote_ip) { IPAddr.new('198.0.2.1') }

  describe '#call' do
    let(:params) { good_params }

    shared_examples 'successful registration' do
      it 'creates an unconfirmed user with access token and the app\'s scope', :aggregate_failures do
        access_token = subject.call(app, remote_ip, params)
        expect(access_token).to_not be_nil
        expect(access_token.scopes.to_s).to eq 'read write'

        user = User.find_by(id: access_token.resource_owner_id)
        expect(user).to_not be_nil
        expect(user.confirmed?).to be false

        expect(user.account).to_not be_nil
        expect(user.invite_request).to be_nil
      end
    end

    context 'when registrations are closed' do
      around do |example|
        tmp = Setting.registrations_mode
        Setting.registrations_mode = 'none'

        example.run

        Setting.registrations_mode = tmp
      end

      it 'raises an error', :aggregate_failures do
        expect { subject.call(app, remote_ip, good_params) }.to raise_error Mastodon::NotPermittedError
      end

      context 'when using a valid invite' do
        let(:params) { good_params.merge({ invite_code: invite.code }) }
        let(:invite) { Fabricate(:invite) }

        before do
          invite.user.approve!
        end

        it_behaves_like 'successful registration'
      end

      context 'when using an invalid invite' do
        let(:params) { good_params.merge({ invite_code: invite.code }) }
        let(:invite) { Fabricate(:invite, uses: 1, max_uses: 1) }

        it 'raises an error', :aggregate_failures do
          expect { subject.call(app, remote_ip, params) }.to raise_error Mastodon::NotPermittedError
        end
      end
    end

    it 'raises an error when params are missing' do
      expect { subject.call(app, remote_ip, {}) }.to raise_error ActiveRecord::RecordInvalid
    end

    it_behaves_like 'successful registration'

    context 'when given an invite request text' do
      it 'creates an account with invite request text' do
        access_token = subject.call(app, remote_ip, good_params.merge(reason: 'Foo bar'))
        expect(access_token).to_not be_nil
        user = User.find_by(id: access_token.resource_owner_id)
        expect(user).to_not be_nil
        expect(user.invite_request&.text).to eq 'Foo bar'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class UnblockDomainService < BaseService
  attr_accessor :domain_block

  def call(domain_block)
    @domain_block = domain_block
    process_retroactive_updates
    domain_block.destroy
  end

  def process_retroactive_updates
    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.noop?
    scope.where(suspended_at: domain_block.created_at).in_batches.update_all(suspended_at: nil, suspension_origin: nil) if domain_block.suspend?
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

describe UnblockDomainService, type: :service do
  subject { described_class.new }

  describe 'call' do
    let!(:independently_suspended) { Fabricate(:account, domain: 'example.com', suspended_at: 1.hour.ago) }
    let!(:independently_silenced) { Fabricate(:account, domain: 'example.com', silenced_at: 1.hour.ago) }
    let!(:domain_block) { Fabricate(:domain_block, domain: 'example.com') }
    let!(:silenced) { Fabricate(:account, domain: 'example.com', silenced_at: domain_block.created_at) }
    let!(:suspended) { Fabricate(:account, domain: 'example.com', suspended_at: domain_block.created_at) }

    it 'unsilences accounts and removes block' do
      domain_block.update(severity: :silence)

      subject.call(domain_block)
      expect_deleted_domain_block
      expect(silenced.reload.silenced?).to be false
      expect(suspended.reload.suspended?).to be true
      expect(independently_suspended.reload.suspended?).to be true
      expect(independently_silenced.reload.silenced?).to be true
    end

    it 'unsuspends accounts and removes block' do
      domain_block.update(severity: :suspend)

      subject.call(domain_block)
      expect_deleted_domain_block
      expect(suspended.reload.suspended?).to be false
      expect(silenced.reload.silenced?).to be false
      expect(independently_suspended.reload.suspended?).to be true
      expect(independently_silenced.reload.silenced?).to be true
    end
  end

  def expect_deleted_domain_block
    expect { domain_block.reload }.to raise_error(ActiveRecord::RecordNotFound)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class PurgeDomainService < BaseService
  def call(domain)
    Account.remote.where(domain: domain).reorder(nil).find_each do |account|
      DeleteAccountService.new.call(account, reserve_username: false, skip_side_effects: true)
    end
    CustomEmoji.remote.where(domain: domain).reorder(nil).find_each(&:destroy)
    Instance.refresh
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe PurgeDomainService, type: :service do
  subject { described_class.new }

  let!(:old_account) { Fabricate(:account, domain: 'obsolete.org') }
  let!(:old_status_plain) { Fabricate(:status, account: old_account) }
  let!(:old_status_with_attachment) { Fabricate(:status, account: old_account) }
  let!(:old_attachment) { Fabricate(:media_attachment, account: old_account, status: old_status_with_attachment, file: attachment_fixture('attachment.jpg')) }

  describe 'for a suspension' do
    before do
      subject.call('obsolete.org')
    end

    it 'removes the remote accounts\'s statuses and media attachments' do
      expect { old_account.reload }.to raise_exception ActiveRecord::RecordNotFound
      expect { old_status_plain.reload }.to raise_exception ActiveRecord::RecordNotFound
      expect { old_status_with_attachment.reload }.to raise_exception ActiveRecord::RecordNotFound
      expect { old_attachment.reload }.to raise_exception ActiveRecord::RecordNotFound
    end

    it 'refreshes instances view' do
      expect(Instance.where(domain: 'obsolete.org').exists?).to be false
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class RejectFollowService < BaseService
  include Payloadable

  def call(source_account, target_account)
    follow_request = FollowRequest.find_by!(account: source_account, target_account: target_account)
    follow_request.reject!
    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::RejectFollowSerializer))
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe RejectFollowService, type: :service do
  subject { described_class.new }

  let(:sender) { Fabricate(:account, username: 'alice') }

  describe 'local' do
    let(:bob) { Fabricate(:account) }

    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 'does not create follow relation' do
      expect(bob.following?(sender)).to be false
    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 'does not create follow relation' do
      expect(bob.following?(sender)).to be false
    end

    it 'sends a reject 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 UnallowDomainService < BaseService
  include DomainControlHelper

  def call(domain_allow)
    suspend_accounts!(domain_allow.domain) if limited_federation_mode?

    domain_allow.destroy
  end

  private

  def suspend_accounts!(domain)
    Account.where(domain: domain).in_batches.update_all(suspended_at: Time.now.utc)
    AfterUnallowDomainWorker.perform_async(domain)
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe UnallowDomainService, type: :service do
  subject { described_class.new }

  let!(:bad_account) { Fabricate(:account, username: 'badguy666', domain: 'evil.org') }
  let!(:bad_status_harassment) { Fabricate(:status, account: bad_account, text: 'You suck') }
  let!(:bad_status_mean) { Fabricate(:status, account: bad_account, text: 'Hahaha') }
  let!(:bad_attachment) { Fabricate(:media_attachment, account: bad_account, status: bad_status_mean, file: attachment_fixture('attachment.jpg')) }
  let!(:already_banned_account) { Fabricate(:account, username: 'badguy', domain: 'evil.org', suspended: true, silenced: true) }
  let!(:domain_allow) { Fabricate(:domain_allow, domain: 'evil.org') }

  context 'with limited federation mode' do
    before do
      allow(Rails.configuration.x).to receive(:limited_federation_mode).and_return(true)
    end

    describe '#call' do
      before do
        subject.call(domain_allow)
      end

      it 'removes the allowed domain' do
        expect(DomainAllow.allowed?('evil.org')).to be false
      end

      it 'removes remote accounts from that domain' do
        expect(Account.where(domain: 'evil.org').exists?).to be false
      end

      it 'removes the remote accounts\'s statuses and media attachments' do
        expect { bad_status_harassment.reload }.to raise_exception ActiveRecord::RecordNotFound
        expect { bad_status_mean.reload }.to raise_exception ActiveRecord::RecordNotFound
        expect { bad_attachment.reload }.to raise_exception ActiveRecord::RecordNotFound
      end
    end
  end

  context 'without limited federation mode' do
    before do
      allow(Rails.configuration.x).to receive(:limited_federation_mode).and_return(false)
    end

    describe '#call' do
      before do
        subject.call(domain_allow)
      end

      it 'removes the allowed domain' do
        expect(DomainAllow.allowed?('evil.org')).to be false
      end

      it 'does not remove accounts from that domain' do
        expect(Account.where(domain: 'evil.org').exists?).to be true
      end

      it 'removes the remote accounts\'s statuses and media attachments' do
        expect { bad_status_harassment.reload }.to_not raise_error
        expect { bad_status_mean.reload }.to_not raise_error
        expect { bad_attachment.reload }.to_not raise_error
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class ReportService < BaseService
  include Payloadable

  def call(source_account, target_account, options = {})
    @source_account = source_account
    @target_account = target_account
    @status_ids     = options.delete(:status_ids).presence || []
    @comment        = options.delete(:comment).presence || ''
    @category       = options[:rule_ids].present? ? 'violation' : (options.delete(:category).presence || 'other')
    @rule_ids       = options.delete(:rule_ids).presence
    @options        = options

    raise ActiveRecord::RecordNotFound if @target_account.unavailable?

    create_report!
    notify_staff!

    if forward?
      forward_to_origin!
      forward_to_replied_to!
    end

    @report
  end

  private

  def create_report!
    @report = @source_account.reports.create!(
      target_account: @target_account,
      status_ids: reported_status_ids,
      comment: @comment,
      uri: @options[:uri],
      forwarded: forward_to_origin?,
      category: @category,
      rule_ids: @rule_ids
    )
  end

  def notify_staff!
    return if @report.unresolved_siblings?

    User.those_who_can(:manage_reports).includes(:account).find_each do |u|
      LocalNotificationWorker.perform_async(u.account_id, @report.id, 'Report', 'admin.report')
      AdminMailer.with(recipient: u.account).new_report(@report).deliver_later if u.allows_report_emails?
    end
  end

  def forward_to_origin!
    return unless forward_to_origin?

    # Send report to the server where the account originates from
    ActivityPub::DeliveryWorker.perform_async(payload, some_local_account.id, @target_account.inbox_url)
  end

  def forward_to_replied_to!
    # Send report to servers to which the account was replying to, so they also have a chance to act
    inbox_urls = Account.remote.where(domain: forward_to_domains).where(id: Status.where(id: reported_status_ids).where.not(in_reply_to_account_id: nil).select(:in_reply_to_account_id)).inboxes - [@target_account.inbox_url, @target_account.shared_inbox_url]

    inbox_urls.each do |inbox_url|
      ActivityPub::DeliveryWorker.perform_async(payload, some_local_account.id, inbox_url)
    end
  end

  def forward?
    !@target_account.local? && ActiveModel::Type::Boolean.new.cast(@options[:forward])
  end

  def forward_to_origin?
    forward? && forward_to_domains.include?(@target_account.domain)
  end

  def forward_to_domains
    @forward_to_domains ||= (@options[:forward_to_domains] || [@target_account.domain]).filter_map { |domain| TagManager.instance.normalize_domain(domain&.strip) }.uniq
  end

  def reported_status_ids
    return AccountStatusesFilter.new(@target_account, @source_account).results.with_discarded.find(Array(@status_ids)).pluck(:id) if @source_account.local?

    # If the account making reports is remote, it is likely anonymized so we have to relax the requirements for attaching statuses.
    domain = @source_account.domain.to_s.downcase
    has_followers = @target_account.followers.where(Account.arel_table[:domain].lower.eq(domain)).exists?
    visibility = has_followers ? %i(public unlisted private) : %i(public unlisted)
    scope = @target_account.statuses.with_discarded
    scope.merge!(scope.where(visibility: visibility).or(scope.where('EXISTS (SELECT 1 FROM mentions m JOIN accounts a ON m.account_id = a.id WHERE lower(a.domain) = ?)', domain)))
    # Allow missing posts to not drop reports that include e.g. a deleted post
    scope.where(id: Array(@status_ids)).pluck(:id)
  end

  def payload
    Oj.dump(serialize_payload(@report, ActivityPub::FlagSerializer, account: some_local_account))
  end

  def some_local_account
    @some_local_account ||= Account.representative
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe ReportService, type: :service do
  subject { described_class.new }

  let(:source_account) { Fabricate(:account) }
  let(:target_account) { Fabricate(:account) }

  context 'with a local account' do
    it 'has a uri' do
      report = subject.call(source_account, target_account)
      expect(report.uri).to_not be_nil
    end
  end

  context 'with a remote account' do
    let(:remote_account) { Fabricate(:account, domain: 'example.com', protocol: :activitypub, inbox_url: 'http://example.com/inbox') }
    let(:forward) { false }

    before do
      stub_request(:post, 'http://example.com/inbox').to_return(status: 200)
    end

    context 'when forward is true' do
      let(:forward) { true }

      it 'sends ActivityPub payload when forward is true' do
        subject.call(source_account, remote_account, forward: forward)
        expect(a_request(:post, 'http://example.com/inbox')).to have_been_made
      end

      it 'has an uri' do
        report = subject.call(source_account, remote_account, forward: forward)
        expect(report.uri).to_not be_nil
      end

      context 'when reporting a reply on a different remote server' do
        let(:remote_thread_account) { Fabricate(:account, domain: 'foo.com', protocol: :activitypub, inbox_url: 'http://foo.com/inbox') }
        let(:reported_status) { Fabricate(:status, account: remote_account, thread: Fabricate(:status, account: remote_thread_account)) }

        before do
          stub_request(:post, 'http://foo.com/inbox').to_return(status: 200)
        end

        context 'when forward_to_domains includes both the replied-to domain and the origin domain' do
          it 'sends ActivityPub payload to both the author of the replied-to post and the reported user' do
            subject.call(source_account, remote_account, status_ids: [reported_status.id], forward: forward, forward_to_domains: [remote_account.domain, remote_thread_account.domain])
            expect(a_request(:post, 'http://foo.com/inbox')).to have_been_made
            expect(a_request(:post, 'http://example.com/inbox')).to have_been_made
          end
        end

        context 'when forward_to_domains includes only the replied-to domain' do
          it 'sends ActivityPub payload only to the author of the replied-to post' do
            subject.call(source_account, remote_account, status_ids: [reported_status.id], forward: forward, forward_to_domains: [remote_thread_account.domain])
            expect(a_request(:post, 'http://foo.com/inbox')).to have_been_made
            expect(a_request(:post, 'http://example.com/inbox')).to_not have_been_made
          end
        end

        context 'when forward_to_domains does not include the replied-to domain' do
          it 'does not send ActivityPub payload to the author of the replied-to post' do
            subject.call(source_account, remote_account, status_ids: [reported_status.id], forward: forward)
            expect(a_request(:post, 'http://foo.com/inbox')).to_not have_been_made
          end
        end
      end

      context 'when reporting a reply on the same remote server as the person being replied-to' do
        let(:remote_thread_account) { Fabricate(:account, domain: 'example.com', protocol: :activitypub, inbox_url: 'http://example.com/inbox') }
        let(:reported_status) { Fabricate(:status, account: remote_account, thread: Fabricate(:status, account: remote_thread_account)) }

        context 'when forward_to_domains includes both the replied-to domain and the origin domain' do
          it 'sends ActivityPub payload only once' do
            subject.call(source_account, remote_account, status_ids: [reported_status.id], forward: forward, forward_to_domains: [remote_account.domain])
            expect(a_request(:post, 'http://example.com/inbox')).to have_been_made.once
          end
        end

        context 'when forward_to_domains does not include the replied-to domain' do
          it 'sends ActivityPub payload only once' do
            subject.call(source_account, remote_account, status_ids: [reported_status.id], forward: forward)
            expect(a_request(:post, 'http://example.com/inbox')).to have_been_made.once
          end
        end
      end
    end

    context 'when forward is false' do
      it 'does not send anything' do
        subject.call(source_account, remote_account, forward: forward)
        expect(a_request(:post, 'http://example.com/inbox')).to_not have_been_made
      end
    end
  end

  context 'when the reported status is a DM' do
    subject do
      -> { described_class.new.call(source_account, target_account, status_ids: [status.id]) }
    end

    let(:status) { Fabricate(:status, account: target_account, visibility: :direct) }

    context 'when it is addressed to the reporter' do
      before do
        status.mentions.create(account: source_account)
      end

      it 'creates a report' do
        expect { subject.call }.to change { target_account.targeted_reports.count }.from(0).to(1)
      end

      it 'attaches the DM to the report' do
        subject.call
        expect(target_account.targeted_reports.pluck(:status_ids)).to eq [[status.id]]
      end
    end

    context 'when it is not addressed to the reporter' do
      it 'errors out' do
        expect { subject.call }.to raise_error(ActiveRecord::RecordNotFound)
      end
    end

    context 'when the reporter is remote' do
      let(:source_account) { Fabricate(:account, domain: 'example.com', uri: 'https://example.com/users/1') }

      context 'when it is addressed to the reporter' do
        before do
          status.mentions.create(account: source_account)
        end

        it 'creates a report' do
          expect { subject.call }.to change { target_account.targeted_reports.count }.from(0).to(1)
        end

        it 'attaches the DM to the report' do
          subject.call
          expect(target_account.targeted_reports.pluck(:status_ids)).to eq [[status.id]]
        end
      end

      context 'when it is not addressed to the reporter' do
        it 'does not add the DM to the report' do
          subject.call
          expect(target_account.targeted_reports.pluck(:status_ids)).to eq [[]]
        end
      end
    end
  end

  context 'when other reports already exist for the same target' do
    subject do
      -> {  described_class.new.call(source_account, target_account) }
    end

    let!(:other_report) { Fabricate(:report, target_account: target_account) }

    before do
      ActionMailer::Base.deliveries.clear
      source_account.user.settings['notification_emails.report'] = true
      source_account.user.save
    end

    it 'does not send an e-mail' do
      expect { subject.call }.to_not change(ActionMailer::Base.deliveries, :count).from(0)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class FavouriteService < BaseService
  include Authorization
  include Payloadable

  # Favourite a status and notify remote user
  # @param [Account] account
  # @param [Status] status
  # @return [Favourite]
  def call(account, status)
    authorize_with account, status, :favourite?

    favourite = Favourite.find_by(account: account, status: status)

    return favourite unless favourite.nil?

    favourite = Favourite.create!(account: account, status: status)

    Trends.statuses.register(status)

    create_notification(favourite)
    bump_potential_friendship(account, status)

    favourite
  end

  private

  def create_notification(favourite)
    status = favourite.status

    if status.account.local?
      LocalNotificationWorker.perform_async(status.account_id, favourite.id, 'Favourite', 'favourite')
    elsif status.account.activitypub?
      ActivityPub::DeliveryWorker.perform_async(build_json(favourite), favourite.account_id, status.account.inbox_url)
    end
  end

  def bump_potential_friendship(account, status)
    ActivityTracker.increment('activity:interactions')
    return if account.following?(status.account_id)

    PotentialFriendshipTracker.record(account.id, status.account_id, :favourite)
  end

  def build_json(favourite)
    Oj.dump(serialize_payload(favourite, ActivityPub::LikeSerializer))
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe FavouriteService, type: :service do
  subject { described_class.new }

  let(:sender) { Fabricate(:account, username: 'alice') }

  describe 'local' do
    let(:bob)    { Fabricate(:account) }
    let(:status) { Fabricate(:status, account: bob) }

    before do
      subject.call(sender, status)
    end

    it 'creates a favourite' do
      expect(status.favourites.first).to_not be_nil
    end
  end

  describe 'remote ActivityPub' do
    let(:bob)    { Fabricate(:account, protocol: :activitypub, username: 'bob', domain: 'example.com', inbox_url: 'http://example.com/inbox') }
    let(:status) { Fabricate(:status, account: bob) }

    before do
      stub_request(:post, 'http://example.com/inbox').to_return(status: 200, body: '', headers: {})
      subject.call(sender, status)
    end

    it 'creates a favourite' do
      expect(status.favourites.first).to_not be_nil
    end

    it 'sends a like 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 ClearDomainMediaService < BaseService
  attr_reader :domain_block

  def call(domain_block)
    @domain_block = domain_block
    clear_media! if domain_block.reject_media?
  end

  private

  def clear_media!
    clear_account_images!
    clear_account_attachments!
    clear_emojos!
  end

  def clear_account_images!
    blocked_domain_accounts.reorder(nil).find_in_batches do |accounts|
      AttachmentBatch.new(Account, accounts).clear
    end
  end

  def clear_account_attachments!
    media_from_blocked_domain.reorder(nil).find_in_batches do |attachments|
      AttachmentBatch.new(MediaAttachment, attachments).clear
    end
  end

  def clear_emojos!
    emojis_from_blocked_domains.find_in_batches do |custom_emojis|
      AttachmentBatch.new(CustomEmoji, custom_emojis).delete
    end
  end

  def blocked_domain
    domain_block.domain
  end

  def blocked_domain_accounts
    Account.by_domain_and_subdomains(blocked_domain)
  end

  def media_from_blocked_domain
    MediaAttachment.joins(:account).merge(blocked_domain_accounts)
  end

  def emojis_from_blocked_domains
    CustomEmoji.by_domain_and_subdomains(blocked_domain)
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe ClearDomainMediaService, 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')) }

  describe 'for a silence with reject media' do
    before do
      subject.call(DomainBlock.create!(domain: 'evil.org', severity: :silence, reject_media: true))
    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 UnblockService < BaseService
  include Payloadable

  def call(account, target_account)
    return unless account.blocking?(target_account)

    unblock = account.unblock!(target_account)
    create_notification(unblock) if !target_account.local? && target_account.activitypub?
    unblock
  end

  private

  def create_notification(unblock)
    ActivityPub::DeliveryWorker.perform_async(build_json(unblock), unblock.account_id, unblock.target_account.inbox_url)
  end

  def build_json(unblock)
    Oj.dump(serialize_payload(unblock, ActivityPub::UndoBlockSerializer))
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe UnblockService, type: :service do
  subject { described_class.new }

  let(:sender) { Fabricate(:account, username: 'alice') }

  describe 'local' do
    let(:bob) { Fabricate(:account) }

    before do
      sender.block!(bob)
      subject.call(sender, bob)
    end

    it 'destroys the blocking relation' do
      expect(sender.blocking?(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.block!(bob)
      stub_request(:post, 'http://example.com/inbox').to_return(status: 200)
      subject.call(sender, bob)
    end

    it 'destroys the blocking relation' do
      expect(sender.blocking?(bob)).to be false
    end

    it 'sends an unblock 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 NotifyService < BaseService
  include Redisable

  NON_EMAIL_TYPES = %i(
    admin.report
    admin.sign_up
    update
    poll
    status
  ).freeze

  def call(recipient, type, activity)
    @recipient    = recipient
    @activity     = activity
    @notification = Notification.new(account: @recipient, type: type, activity: @activity)

    return if recipient.user.nil? || blocked?

    @notification.save!

    # It's possible the underlying activity has been deleted
    # between the save call and now
    return if @notification.activity.nil?

    push_notification!
    push_to_conversation! if direct_message?
    send_email! if email_needed?
  rescue ActiveRecord::RecordInvalid
    nil
  end

  private

  def blocked_mention?
    FeedManager.instance.filter?(:mentions, @notification.mention.status, @recipient)
  end

  def following_sender?
    return @following_sender if defined?(@following_sender)

    @following_sender = @recipient.following?(@notification.from_account) || @recipient.requested?(@notification.from_account)
  end

  def optional_non_follower?
    @recipient.user.settings['interactions.must_be_follower']  && !@notification.from_account.following?(@recipient)
  end

  def optional_non_following?
    @recipient.user.settings['interactions.must_be_following'] && !following_sender?
  end

  def message?
    @notification.type == :mention
  end

  def direct_message?
    message? && @notification.target_status.direct_visibility?
  end

  # Returns true if the sender has been mentioned by the recipient up the thread
  def response_to_recipient?
    return false if @notification.target_status.in_reply_to_id.nil?

    # Using an SQL CTE to avoid unneeded back-and-forth with SQL server in case of long threads
    !Status.count_by_sql([<<-SQL.squish, id: @notification.target_status.in_reply_to_id, recipient_id: @recipient.id, sender_id: @notification.from_account.id, depth_limit: 100]).zero?
      WITH RECURSIVE ancestors(id, in_reply_to_id, mention_id, path, depth) AS (
          SELECT s.id, s.in_reply_to_id, m.id, ARRAY[s.id], 0
          FROM statuses s
          LEFT JOIN mentions m ON m.silent = FALSE AND m.account_id = :sender_id AND m.status_id = s.id
          WHERE s.id = :id
        UNION ALL
          SELECT s.id, s.in_reply_to_id, m.id, st.path || s.id, st.depth + 1
          FROM ancestors st
          JOIN statuses s ON s.id = st.in_reply_to_id
          LEFT JOIN mentions m ON m.silent = FALSE AND m.account_id = :sender_id AND m.status_id = s.id
          WHERE st.mention_id IS NULL AND NOT s.id = ANY(path) AND st.depth < :depth_limit
      )
      SELECT COUNT(*)
      FROM ancestors st
      JOIN statuses s ON s.id = st.id
      WHERE st.mention_id IS NOT NULL AND s.visibility = 3
    SQL
  end

  def from_staff?
    @notification.from_account.local? && @notification.from_account.user.present? && @notification.from_account.user_role&.overrides?(@recipient.user_role)
  end

  def optional_non_following_and_direct?
    direct_message? &&
      @recipient.user.settings['interactions.must_be_following_dm'] &&
      !following_sender? &&
      !response_to_recipient?
  end

  def hellbanned?
    @notification.from_account.silenced? && !following_sender?
  end

  def from_self?
    @recipient.id == @notification.from_account.id
  end

  def domain_blocking?
    @recipient.domain_blocking?(@notification.from_account.domain) && !following_sender?
  end

  def blocked?
    blocked   = @recipient.unavailable?
    blocked ||= from_self? && @notification.type != :poll

    return blocked if message? && from_staff?

    blocked ||= domain_blocking?
    blocked ||= @recipient.blocking?(@notification.from_account)
    blocked ||= @recipient.muting_notifications?(@notification.from_account)
    blocked ||= hellbanned?
    blocked ||= optional_non_follower?
    blocked ||= optional_non_following?
    blocked ||= optional_non_following_and_direct?
    blocked ||= conversation_muted?
    blocked ||= blocked_mention? if @notification.type == :mention
    blocked
  end

  def conversation_muted?
    if @notification.target_status
      @recipient.muting_conversation?(@notification.target_status.conversation)
    else
      false
    end
  end

  def push_notification!
    push_to_streaming_api! if subscribed_to_streaming_api?
    push_to_web_push_subscriptions!
  end

  def push_to_streaming_api!
    redis.publish(""timeline:#{@recipient.id}:notifications"", Oj.dump(event: :notification, payload: InlineRenderer.render(@notification, @recipient, :notification)))
  end

  def subscribed_to_streaming_api?
    redis.exists?(""subscribed:timeline:#{@recipient.id}"") || redis.exists?(""subscribed:timeline:#{@recipient.id}:notifications"")
  end

  def push_to_conversation!
    AccountConversation.add_status(@recipient, @notification.target_status)
  end

  def push_to_web_push_subscriptions!
    ::Web::PushNotificationWorker.push_bulk(web_push_subscriptions.select { |subscription| subscription.pushable?(@notification) }) { |subscription| [subscription.id, @notification.id] }
  end

  def web_push_subscriptions
    @web_push_subscriptions ||= ::Web::PushSubscription.where(user_id: @recipient.user.id).to_a
  end

  def subscribed_to_web_push?
    web_push_subscriptions.any?
  end

  def send_email!
    return unless NotificationMailer.respond_to?(@notification.type)

    NotificationMailer
      .with(recipient: @recipient, notification: @notification)
      .public_send(@notification.type)
      .deliver_later(wait: 2.minutes)
  end

  def email_needed?
    (!recipient_online? || always_send_emails?) && send_email_for_notification_type?
  end

  def recipient_online?
    subscribed_to_streaming_api? || subscribed_to_web_push?
  end

  def always_send_emails?
    @recipient.user.settings.always_send_emails
  end

  def send_email_for_notification_type?
    NON_EMAIL_TYPES.exclude?(@notification.type) && @recipient.user.settings[""notification_emails.#{@notification.type}""]
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe NotifyService, type: :service do
  subject { described_class.new.call(recipient, type, activity) }

  let(:user) { Fabricate(:user) }
  let(:recipient) { user.account }
  let(:sender) { Fabricate(:account, domain: 'example.com') }
  let(:activity) { Fabricate(:follow, account: sender, target_account: recipient) }
  let(:type) { :follow }

  it { expect { subject }.to change(Notification, :count).by(1) }

  it 'does not notify when sender is blocked' do
    recipient.block!(sender)
    expect { subject }.to_not change(Notification, :count)
  end

  it 'does not notify when sender is muted with hide_notifications' do
    recipient.mute!(sender, notifications: true)
    expect { subject }.to_not change(Notification, :count)
  end

  it 'does notify when sender is muted without hide_notifications' do
    recipient.mute!(sender, notifications: false)
    expect { subject }.to change(Notification, :count)
  end

  it 'does not notify when sender\'s domain is blocked' do
    recipient.block_domain!(sender.domain)
    expect { subject }.to_not change(Notification, :count)
  end

  it 'does still notify when sender\'s domain is blocked but sender is followed' do
    recipient.block_domain!(sender.domain)
    recipient.follow!(sender)
    expect { subject }.to change(Notification, :count)
  end

  it 'does not notify when sender is silenced and not followed' do
    sender.silence!
    expect { subject }.to_not change(Notification, :count)
  end

  it 'does not notify when recipient is suspended' do
    recipient.suspend!
    expect { subject }.to_not change(Notification, :count)
  end

  context 'with direct messages' do
    let(:activity) { Fabricate(:mention, account: recipient, status: Fabricate(:status, account: sender, visibility: :direct)) }
    let(:type)     { :mention }

    before do
      user.settings.update('interactions.must_be_following_dm': enabled)
      user.save
    end

    context 'when recipient is supposed to be following sender' do
      let(:enabled) { true }

      it 'does not notify' do
        expect { subject }.to_not change(Notification, :count)
      end

      context 'when the message chain is initiated by recipient, but is not direct message' do
        let(:reply_to) { Fabricate(:status, account: recipient) }
        let!(:mention) { Fabricate(:mention, account: sender, status: reply_to) }
        let(:activity) { Fabricate(:mention, account: recipient, status: Fabricate(:status, account: sender, visibility: :direct, thread: reply_to)) }

        it 'does not notify' do
          expect { subject }.to_not change(Notification, :count)
        end
      end

      context 'when the message chain is initiated by recipient, but without a mention to the sender, even if the sender sends multiple messages in a row' do
        let(:reply_to) { Fabricate(:status, account: recipient) }
        let!(:mention) { Fabricate(:mention, account: sender, status: reply_to) }
        let(:dummy_reply) { Fabricate(:status, account: sender, visibility: :direct, thread: reply_to) }
        let(:activity) { Fabricate(:mention, account: recipient, status: Fabricate(:status, account: sender, visibility: :direct, thread: dummy_reply)) }

        it 'does not notify' do
          expect { subject }.to_not change(Notification, :count)
        end
      end

      context 'when the message chain is initiated by the recipient with a mention to the sender' do
        let(:reply_to) { Fabricate(:status, account: recipient, visibility: :direct) }
        let!(:mention) { Fabricate(:mention, account: sender, status: reply_to) }
        let(:activity) { Fabricate(:mention, account: recipient, status: Fabricate(:status, account: sender, visibility: :direct, thread: reply_to)) }

        it 'does notify' do
          expect { subject }.to change(Notification, :count)
        end
      end
    end

    context 'when recipient is NOT supposed to be following sender' do
      let(:enabled) { false }

      it 'does notify' do
        expect { subject }.to change(Notification, :count)
      end
    end
  end

  describe 'reblogs' do
    let(:status)   { Fabricate(:status, account: Fabricate(:account)) }
    let(:activity) { Fabricate(:status, account: sender, reblog: status) }
    let(:type)     { :reblog }

    it 'shows reblogs by default' do
      recipient.follow!(sender)
      expect { subject }.to change(Notification, :count)
    end

    it 'shows reblogs when explicitly enabled' do
      recipient.follow!(sender, reblogs: true)
      expect { subject }.to change(Notification, :count)
    end

    it 'shows reblogs when disabled' do
      recipient.follow!(sender, reblogs: false)
      expect { subject }.to change(Notification, :count)
    end
  end

  context 'with muted and blocked users' do
    let(:asshole)  { Fabricate(:account, username: 'asshole') }
    let(:reply_to) { Fabricate(:status, account: asshole) }
    let(:activity) { Fabricate(:mention, account: recipient, status: Fabricate(:status, account: sender, thread: reply_to)) }
    let(:type)     { :mention }

    it 'does not notify when conversation is muted' do
      recipient.mute_conversation!(activity.status.conversation)
      expect { subject }.to_not change(Notification, :count)
    end

    it 'does not notify when it is a reply to a blocked user' do
      recipient.block!(asshole)
      expect { subject }.to_not change(Notification, :count)
    end
  end

  context 'with sender as recipient' do
    let(:sender) { recipient }

    it 'does not notify when recipient is the sender' do
      expect { subject }.to_not change(Notification, :count)
    end
  end

  describe 'email' do
    before do
      ActionMailer::Base.deliveries.clear

      user.settings.update('notification_emails.follow': enabled)
      user.save
    end

    context 'when email notification is enabled' do
      let(:enabled) { true }

      it 'sends email' do
        expect { subject }.to change(ActionMailer::Base.deliveries, :count).by(1)
      end
    end

    context 'when email notification is disabled' do
      let(:enabled) { false }

      it ""doesn't send email"" do
        expect { subject }.to_not change(ActionMailer::Base.deliveries, :count).from(0)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class TranslateStatusService < BaseService
  CACHE_TTL = 1.day.freeze

  include ERB::Util
  include FormattingHelper

  def call(status, target_language)
    @status = status
    @source_texts = source_texts
    @target_language = target_language

    raise Mastodon::NotPermittedError unless permitted?

    status_translation = Rails.cache.fetch(""v2:translations/#{@status.language}/#{@target_language}/#{content_hash}"", expires_in: CACHE_TTL) do
      translations = translation_backend.translate(@source_texts.values, @status.language, @target_language)
      build_status_translation(translations)
    end

    status_translation.status = @status

    status_translation
  end

  private

  def translation_backend
    @translation_backend ||= TranslationService.configured
  end

  def permitted?
    return false unless @status.distributable? && TranslationService.configured?

    languages[@status.language]&.include?(@target_language)
  end

  def languages
    Rails.cache.fetch('translation_service/languages', expires_in: 7.days, race_condition_ttl: 1.hour) { TranslationService.configured.languages }
  end

  def content_hash
    Digest::SHA256.base64digest(@source_texts.transform_keys { |key| key.respond_to?(:id) ? ""#{key.class}-#{key.id}"" : key }.to_json)
  end

  def source_texts
    texts = {}
    texts[:content] = wrap_emoji_shortcodes(status_content_format(@status)) if @status.content.present?
    texts[:spoiler_text] = wrap_emoji_shortcodes(html_escape(@status.spoiler_text)) if @status.spoiler_text.present?

    @status.preloadable_poll&.loaded_options&.each do |option|
      texts[option] = wrap_emoji_shortcodes(html_escape(option.title))
    end

    @status.media_attachments.each do |media_attachment|
      texts[media_attachment] = html_escape(media_attachment.description)
    end

    texts
  end

  def build_status_translation(translations)
    status_translation = Translation.new(
      detected_source_language: translations.first&.detected_source_language,
      language: @target_language,
      provider: translations.first&.provider,
      content: '',
      spoiler_text: '',
      poll_options: [],
      media_attachments: []
    )

    @source_texts.keys.each_with_index do |source, index|
      translation = translations[index]

      case source
      when :content
        node = unwrap_emoji_shortcodes(translation.text)
        Sanitize.node!(node, Sanitize::Config::MASTODON_STRICT)
        status_translation.content = node.to_html
      when :spoiler_text
        status_translation.spoiler_text = unwrap_emoji_shortcodes(translation.text).content
      when Poll::Option
        status_translation.poll_options << Translation::Option.new(
          title: unwrap_emoji_shortcodes(translation.text).content
        )
      when MediaAttachment
        status_translation.media_attachments << Translation::MediaAttachment.new(
          id: source.id,
          description: html_entities.decode(translation.text)
        )
      end
    end

    status_translation
  end

  def wrap_emoji_shortcodes(text)
    EmojiFormatter.new(text, @status.emojis, { raw_shortcode: true }).to_s
  end

  def unwrap_emoji_shortcodes(html)
    fragment = Nokogiri::HTML.fragment(html)
    fragment.css('span[translate=""no""]').each do |element|
      element.remove_attribute('translate')
      element.replace(element.children) if element.attributes.empty?
    end
    fragment
  end

  def html_entities
    HTMLEntities.new
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe TranslateStatusService, type: :service do
  subject(:service) { described_class.new }

  let(:status) { Fabricate(:status, text: text, spoiler_text: spoiler_text, language: 'en', preloadable_poll: poll, media_attachments: media_attachments) }
  let(:text) { 'Hello' }
  let(:spoiler_text) { '' }
  let(:poll) { nil }
  let(:media_attachments) { [] }

  before do
    Fabricate(:custom_emoji, shortcode: 'highfive')
  end

  describe '#call' do
    before do
      translation_service = TranslationService.new
      allow(translation_service).to receive(:languages).and_return({ 'en' => ['es'] })
      allow(translation_service).to receive(:translate) do |texts|
        texts.map do |text|
          TranslationService::Translation.new(
            text: text.gsub('Hello', 'Hola').gsub('higfive', 'cincoaltos'),
            detected_source_language: 'en',
            provider: 'Dummy'
          )
        end
      end

      allow(TranslationService).to receive_messages(configured?: true, configured: translation_service)
    end

    it 'returns translated status content' do
      expect(service.call(status, 'es').content).to eq '<p>Hola</p>'
    end

    it 'returns source language' do
      expect(service.call(status, 'es').detected_source_language).to eq 'en'
    end

    it 'returns translation provider' do
      expect(service.call(status, 'es').provider).to eq 'Dummy'
    end

    it 'returns original status' do
      expect(service.call(status, 'es').status).to eq status
    end

    describe 'status has content with custom emoji' do
      let(:text) { 'Hello & :highfive:' }

      it 'does not translate shortcode' do
        expect(service.call(status, 'es').content).to eq '<p>Hola &amp; :highfive:</p>'
      end
    end

    describe 'status has no spoiler_text' do
      it 'returns an empty string' do
        expect(service.call(status, 'es').spoiler_text).to eq ''
      end
    end

    describe 'status has spoiler_text' do
      let(:spoiler_text) { 'Hello & Hello!' }

      it 'translates the spoiler text' do
        expect(service.call(status, 'es').spoiler_text).to eq 'Hola & Hola!'
      end
    end

    describe 'status has spoiler_text with custom emoji' do
      let(:spoiler_text) { 'Hello :highfive:' }

      it 'does not translate shortcode' do
        expect(service.call(status, 'es').spoiler_text).to eq 'Hola :highfive:'
      end
    end

    describe 'status has spoiler_text with unmatched custom emoji' do
      let(:spoiler_text) { 'Hello :Hello:' }

      it 'translates the invalid shortcode' do
        expect(service.call(status, 'es').spoiler_text).to eq 'Hola :Hola:'
      end
    end

    describe 'status has poll' do
      let(:poll) { Fabricate(:poll, options: ['Hello 1', 'Hello 2']) }

      it 'translates the poll option title' do
        status_translation = service.call(status, 'es')
        expect(status_translation.poll_options.size).to eq 2
        expect(status_translation.poll_options.first.title).to eq 'Hola 1'
      end
    end

    describe 'status has media attachment' do
      let(:media_attachments) { [Fabricate(:media_attachment, description: 'Hello & :highfive:')] }

      it 'translates the media attachment description' do
        status_translation = service.call(status, 'es')

        media_attachment = status_translation.media_attachments.first
        expect(media_attachment.id).to eq media_attachments.first.id
        expect(media_attachment.description).to eq 'Hola & :highfive:'
      end
    end
  end

  describe '#source_texts' do
    before do
      service.instance_variable_set(:@status, status)
    end

    describe 'status only has content' do
      it 'returns formatted content' do
        expect(service.send(:source_texts)).to eq({ content: '<p>Hello</p>' })
      end
    end

    describe 'status content contains custom emoji' do
      let(:status) { Fabricate(:status, text: 'Hello :highfive:') }

      it 'returns formatted content' do
        source_texts = service.send(:source_texts)
        expect(source_texts[:content]).to eq '<p>Hello <span translate=""no"">:highfive:</span></p>'
      end
    end

    describe 'status content contains tags' do
      let(:status) { Fabricate(:status, text: 'Hello #hola') }

      it 'returns formatted content' do
        source_texts = service.send(:source_texts)
        expect(source_texts[:content]).to include '<p>Hello <a'
        expect(source_texts[:content]).to include '/tags/hola'
      end
    end

    describe 'status has spoiler text' do
      let(:status) { Fabricate(:status, spoiler_text: 'Hello :highfive:') }

      it 'returns formatted spoiler text' do
        source_texts = service.send(:source_texts)
        expect(source_texts[:spoiler_text]).to eq 'Hello <span translate=""no"">:highfive:</span>'
      end
    end

    describe 'status has poll' do
      let(:poll) { Fabricate(:poll, options: %w(Blue Green)) }

      context 'with source texts from the service' do
        let!(:source_texts) { service.send(:source_texts) }

        it 'returns formatted poll options' do
          expect(source_texts.size).to eq 3
          expect(source_texts.values).to eq %w(<p>Hello</p> Blue Green)
        end

        it 'has a first key with content' do
          expect(source_texts.keys.first).to eq :content
        end

        it 'has the first option in the second key with correct options' do
          option1 = source_texts.keys.second
          expect(option1).to be_a Poll::Option
          expect(option1.id).to eq '0'
          expect(option1.title).to eq 'Blue'
        end

        it 'has the second option in the third key with correct options' do
          option2 = source_texts.keys.third
          expect(option2).to be_a Poll::Option
          expect(option2.id).to eq '1'
          expect(option2.title).to eq 'Green'
        end
      end
    end

    describe 'status has poll with custom emoji' do
      let(:poll) { Fabricate(:poll, options: ['Blue', 'Green :highfive:']) }

      it 'returns formatted poll options' do
        html = service.send(:source_texts).values.last
        expect(html).to eq 'Green <span translate=""no"">:highfive:</span>'
      end
    end

    describe 'status has media attachments' do
      let(:text) { '' }
      let(:media_attachments) { [Fabricate(:media_attachment, description: 'Hello :highfive:')] }

      it 'returns media attachments without custom emoji rendering' do
        source_texts = service.send(:source_texts)
        expect(source_texts.size).to eq 1

        key, text = source_texts.first
        expect(key).to eq media_attachments.first
        expect(text).to eq 'Hello :highfive:'
      end
    end
  end

  describe '#wrap_emoji_shortcodes' do
    before do
      service.instance_variable_set(:@status, status)
    end

    describe 'string contains custom emoji' do
      let(:text) { ':highfive:' }

      it 'renders the emoji' do
        html = service.send(:wrap_emoji_shortcodes, 'Hello :highfive:'.html_safe)
        expect(html).to eq 'Hello <span translate=""no"">:highfive:</span>'
      end
    end
  end

  describe '#unwrap_emoji_shortcodes' do
    describe 'string contains custom emoji' do
      it 'inserts the shortcode' do
        fragment = service.send(:unwrap_emoji_shortcodes, '<p>Hello <span translate=""no"">:highfive:</span>!</p>')
        expect(fragment.to_html).to eq '<p>Hello :highfive:!</p>'
      end

      it 'preserves other attributes than translate=no' do
        fragment = service.send(:unwrap_emoji_shortcodes, '<p>Hello <span translate=""no"" class=""foo"">:highfive:</span>!</p>')
        expect(fragment.to_html).to eq '<p>Hello <span class=""foo"">:highfive:</span>!</p>'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class FanOutOnWriteService < BaseService
  include Redisable

  # Push a status into home and mentions feeds
  # @param [Status] status
  # @param [Hash] options
  # @option options [Boolean] update
  # @option options [Array<Integer>] silenced_account_ids
  # @option options [Boolean] skip_notifications
  def call(status, options = {})
    @status    = status
    @account   = status.account
    @options   = options

    check_race_condition!
    warm_payload_cache!

    fan_out_to_local_recipients!
    fan_out_to_public_recipients! if broadcastable?
    fan_out_to_public_streams! if broadcastable?
  end

  private

  def check_race_condition!
    # I don't know why but at some point we had an issue where
    # this service was being executed with status objects
    # that had a null visibility - which should not be possible
    # since the column in the database is not nullable.
    #
    # This check re-queues the service to be run at a later time
    # with the full object, if something like it occurs

    raise Mastodon::RaceConditionError if @status.visibility.nil?
  end

  def fan_out_to_local_recipients!
    deliver_to_self!

    unless @options[:skip_notifications]
      notify_mentioned_accounts!
      notify_about_update! if update?
    end

    case @status.visibility.to_sym
    when :public, :unlisted, :private
      deliver_to_all_followers!
      deliver_to_lists!
    when :limited
      deliver_to_mentioned_followers!
    else
      deliver_to_mentioned_followers!
      deliver_to_conversation!
    end
  end

  def fan_out_to_public_recipients!
    deliver_to_hashtag_followers!
  end

  def fan_out_to_public_streams!
    broadcast_to_hashtag_streams!
    broadcast_to_public_streams!
  end

  def deliver_to_self!
    FeedManager.instance.push_to_home(@account, @status, update: update?) if @account.local?
  end

  def notify_mentioned_accounts!
    @status.active_mentions.where.not(id: @options[:silenced_account_ids] || []).joins(:account).merge(Account.local).select(:id, :account_id).reorder(nil).find_in_batches do |mentions|
      LocalNotificationWorker.push_bulk(mentions) do |mention|
        [mention.account_id, mention.id, 'Mention', 'mention']
      end
    end
  end

  def notify_about_update!
    @status.reblogged_by_accounts.merge(Account.local).select(:id).reorder(nil).find_in_batches do |accounts|
      LocalNotificationWorker.push_bulk(accounts) do |account|
        [account.id, @status.id, 'Status', 'update']
      end
    end
  end

  def deliver_to_all_followers!
    @account.followers_for_local_distribution.select(:id).reorder(nil).find_in_batches do |followers|
      FeedInsertWorker.push_bulk(followers) do |follower|
        [@status.id, follower.id, 'home', { 'update' => update? }]
      end
    end
  end

  def deliver_to_hashtag_followers!
    TagFollow.where(tag_id: @status.tags.map(&:id)).select(:id, :account_id).reorder(nil).find_in_batches do |follows|
      FeedInsertWorker.push_bulk(follows) do |follow|
        [@status.id, follow.account_id, 'tags', { 'update' => update? }]
      end
    end
  end

  def deliver_to_lists!
    @account.lists_for_local_distribution.select(:id).reorder(nil).find_in_batches do |lists|
      FeedInsertWorker.push_bulk(lists) do |list|
        [@status.id, list.id, 'list', { 'update' => update? }]
      end
    end
  end

  def deliver_to_mentioned_followers!
    @status.mentions.joins(:account).merge(@account.followers_for_local_distribution).select(:id, :account_id).reorder(nil).find_in_batches do |mentions|
      FeedInsertWorker.push_bulk(mentions) do |mention|
        [@status.id, mention.account_id, 'home', { 'update' => update? }]
      end
    end
  end

  def broadcast_to_hashtag_streams!
    @status.tags.map(&:name).each do |hashtag|
      redis.publish(""timeline:hashtag:#{hashtag.mb_chars.downcase}"", anonymous_payload)
      redis.publish(""timeline:hashtag:#{hashtag.mb_chars.downcase}:local"", anonymous_payload) if @status.local?
    end
  end

  def broadcast_to_public_streams!
    return if @status.reply? && @status.in_reply_to_account_id != @account.id

    redis.publish('timeline:public', anonymous_payload)
    redis.publish(@status.local? ? 'timeline:public:local' : 'timeline:public:remote', anonymous_payload)

    if @status.with_media?
      redis.publish('timeline:public:media', anonymous_payload)
      redis.publish(@status.local? ? 'timeline:public:local:media' : 'timeline:public:remote:media', anonymous_payload)
    end
  end

  def deliver_to_conversation!
    AccountConversation.add_status(@account, @status) unless update?
  end

  def warm_payload_cache!
    Rails.cache.write(""fan-out/#{@status.id}"", rendered_status)
  end

  def anonymous_payload
    @anonymous_payload ||= Oj.dump(
      event: update? ? :'status.update' : :update,
      payload: rendered_status
    )
  end

  def rendered_status
    @rendered_status ||= InlineRenderer.render(@status, nil, :status)
  end

  def update?
    @options[:update]
  end

  def broadcastable?
    @status.public_visibility? && !@status.reblog? && !@account.silenced?
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe FanOutOnWriteService, type: :service do
  subject { described_class.new }

  let(:last_active_at) { Time.now.utc }
  let(:status) { Fabricate(:status, account: alice, visibility: visibility, text: 'Hello @bob #hoge') }

  let!(:alice) { Fabricate(:user, current_sign_in_at: last_active_at).account }
  let!(:bob)   { Fabricate(:user, current_sign_in_at: last_active_at, account_attributes: { username: 'bob' }).account }
  let!(:tom)   { Fabricate(:user, current_sign_in_at: last_active_at).account }

  before do
    bob.follow!(alice)
    tom.follow!(alice)

    ProcessMentionsService.new.call(status)
    ProcessHashtagsService.new.call(status)

    allow(redis).to receive(:publish)

    subject.call(status)
  end

  def home_feed_of(account)
    HomeFeed.new(account).get(10).map(&:id)
  end

  context 'when status is public' do
    let(:visibility) { 'public' }

    it 'is added to the home feed of its author' do
      expect(home_feed_of(alice)).to include status.id
    end

    it 'is added to the home feed of a follower' do
      expect(home_feed_of(bob)).to include status.id
      expect(home_feed_of(tom)).to include status.id
    end

    it 'is broadcast to the hashtag stream' do
      expect(redis).to have_received(:publish).with('timeline:hashtag:hoge', anything)
      expect(redis).to have_received(:publish).with('timeline:hashtag:hoge:local', anything)
    end

    it 'is broadcast to the public stream' do
      expect(redis).to have_received(:publish).with('timeline:public', anything)
      expect(redis).to have_received(:publish).with('timeline:public:local', anything)
    end
  end

  context 'when status is limited' do
    let(:visibility) { 'limited' }

    it 'is added to the home feed of its author' do
      expect(home_feed_of(alice)).to include status.id
    end

    it 'is added to the home feed of the mentioned follower' do
      expect(home_feed_of(bob)).to include status.id
    end

    it 'is not added to the home feed of the other follower' do
      expect(home_feed_of(tom)).to_not include status.id
    end

    it 'is not broadcast publicly' do
      expect(redis).to_not have_received(:publish).with('timeline:hashtag:hoge', anything)
      expect(redis).to_not have_received(:publish).with('timeline:public', anything)
    end
  end

  context 'when status is private' do
    let(:visibility) { 'private' }

    it 'is added to the home feed of its author' do
      expect(home_feed_of(alice)).to include status.id
    end

    it 'is added to the home feed of a follower' do
      expect(home_feed_of(bob)).to include status.id
      expect(home_feed_of(tom)).to include status.id
    end

    it 'is not broadcast publicly' do
      expect(redis).to_not have_received(:publish).with('timeline:hashtag:hoge', anything)
      expect(redis).to_not have_received(:publish).with('timeline:public', anything)
    end
  end

  context 'when status is direct' do
    let(:visibility) { 'direct' }

    it 'is added to the home feed of its author' do
      expect(home_feed_of(alice)).to include status.id
    end

    it 'is added to the home feed of the mentioned follower' do
      expect(home_feed_of(bob)).to include status.id
    end

    it 'is not added to the home feed of the other follower' do
      expect(home_feed_of(tom)).to_not include status.id
    end

    it 'is not broadcast publicly' do
      expect(redis).to_not have_received(:publish).with('timeline:hashtag:hoge', anything)
      expect(redis).to_not have_received(:publish).with('timeline:public', anything)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class ResolveURLService < BaseService
  include JsonLdHelper
  include Authorization

  USERNAME_STATUS_RE = %r{/@(?<username>#{Account::USERNAME_RE})/(?<status_id>[0-9]+)\Z}

  def call(url, on_behalf_of: nil)
    @url          = url
    @on_behalf_of = on_behalf_of

    if local_url?
      process_local_url
    elsif !fetched_resource.nil?
      process_url
    else
      process_url_from_db
    end
  end

  private

  def process_url
    if equals_or_includes_any?(type, ActivityPub::FetchRemoteActorService::SUPPORTED_TYPES)
      ActivityPub::FetchRemoteActorService.new.call(resource_url, prefetched_body: body)
    elsif equals_or_includes_any?(type, ActivityPub::Activity::Create::SUPPORTED_TYPES + ActivityPub::Activity::Create::CONVERTED_TYPES)
      status = FetchRemoteStatusService.new.call(resource_url, prefetched_body: body)
      authorize_with @on_behalf_of, status, :show? unless status.nil?
      status
    end
  end

  def process_url_from_db
    if [500, 502, 503, 504, nil].include?(fetch_resource_service.response_code)
      account = Account.find_by(uri: @url)
      return account unless account.nil?
    end

    return unless @on_behalf_of.present? && [401, 403, 404].include?(fetch_resource_service.response_code)

    # It may happen that the resource is a private toot, and thus not fetchable,
    # but we can return the toot if we already know about it.
    scope = Status.where(uri: @url)

    # We don't have an index on `url`, so try guessing the `uri` from `url`
    parsed_url = Addressable::URI.parse(@url)
    parsed_url.path.match(USERNAME_STATUS_RE) do |matched|
      parsed_url.path = ""/users/#{matched[:username]}/statuses/#{matched[:status_id]}""
      scope = scope.or(Status.where(uri: parsed_url.to_s, url: @url))
    end

    status = scope.first

    authorize_with @on_behalf_of, status, :show? unless status.nil?
    status
  rescue Mastodon::NotPermittedError
    nil
  end

  def fetched_resource
    @fetched_resource ||= fetch_resource_service.call(@url)
  end

  def fetch_resource_service
    @fetch_resource_service ||= FetchResourceService.new
  end

  def resource_url
    fetched_resource.first
  end

  def body
    fetched_resource.second[:prefetched_body]
  end

  def type
    json_data['type']
  end

  def json_data
    @json_data ||= body_to_json(body)
  end

  def local_url?
    TagManager.instance.local_url?(@url)
  end

  def process_local_url
    recognized_params = Rails.application.routes.recognize_path(@url)

    case recognized_params[:controller]
    when 'statuses'
      return unless recognized_params[:action] == 'show'

      status = Status.find_by(id: recognized_params[:id])
      check_local_status(status)
    when 'accounts'
      return unless recognized_params[:action] == 'show'

      Account.find_local(recognized_params[:username])
    when 'home'
      return unless recognized_params[:action] == 'index' && recognized_params[:username_with_domain].present?

      if recognized_params[:any]&.match?(/\A[0-9]+\Z/)
        status = Status.find_by(id: recognized_params[:any])
        check_local_status(status)
      elsif recognized_params[:any].blank?
        username, domain = recognized_params[:username_with_domain].gsub(/\A@/, '').split('@')
        return unless username.present? && domain.present?

        Account.find_remote(username, domain)
      end
    end
  end

  def check_local_status(status)
    return if status.nil?

    authorize_with @on_behalf_of, status, :show?
    status
  rescue Mastodon::NotPermittedError
    nil
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

describe ResolveURLService, type: :service do
  subject { described_class.new }

  describe '#call' do
    it 'returns nil when there is no resource url' do
      url = 'http://example.com/missing-resource'
      Fabricate(:account, uri: url, domain: 'example.com')
      service = instance_double(FetchResourceService)

      allow(FetchResourceService).to receive(:new).and_return service
      allow(service).to receive(:response_code).and_return(404)
      allow(service).to receive(:call).with(url).and_return(nil)

      expect(subject.call(url)).to be_nil
    end

    it 'returns known account on temporary error' do
      url           = 'http://example.com/missing-resource'
      known_account = Fabricate(:account, uri: url, domain: 'example.com')
      service = instance_double(FetchResourceService)

      allow(FetchResourceService).to receive(:new).and_return service
      allow(service).to receive(:response_code).and_return(500)
      allow(service).to receive(:call).with(url).and_return(nil)

      expect(subject.call(url)).to eq known_account
    end

    context 'when searching for a remote private status' do
      let(:account)  { Fabricate(:account) }
      let(:poster)   { Fabricate(:account, domain: 'example.com') }
      let(:url)      { 'https://example.com/@foo/42' }
      let(:uri)      { 'https://example.com/users/foo/statuses/42' }
      let!(:status)  { Fabricate(:status, url: url, uri: uri, account: poster, visibility: :private) }

      before do
        stub_request(:get, url).to_return(status: 404) if url.present?
        stub_request(:get, uri).to_return(status: 404)
      end

      context 'when the account follows the poster' do
        before do
          account.follow!(poster)
        end

        context 'when the status uses Mastodon-style URLs' do
          let(:url) { 'https://example.com/@foo/42' }
          let(:uri) { 'https://example.com/users/foo/statuses/42' }

          it 'returns status by url' do
            expect(subject.call(url, on_behalf_of: account)).to eq(status)
          end

          it 'returns status by uri' do
            expect(subject.call(uri, on_behalf_of: account)).to eq(status)
          end
        end

        context 'when the status uses pleroma-style URLs' do
          let(:url) { nil }
          let(:uri) { 'https://example.com/objects/0123-456-789-abc-def' }

          it 'returns status by uri' do
            expect(subject.call(uri, on_behalf_of: account)).to eq(status)
          end
        end
      end

      context 'when the account does not follow the poster' do
        context 'when the status uses Mastodon-style URLs' do
          let(:url) { 'https://example.com/@foo/42' }
          let(:uri) { 'https://example.com/users/foo/statuses/42' }

          it 'does not return the status by url' do
            expect(subject.call(url, on_behalf_of: account)).to be_nil
          end

          it 'does not return the status by uri' do
            expect(subject.call(uri, on_behalf_of: account)).to be_nil
          end
        end

        context 'when the status uses pleroma-style URLs' do
          let(:url) { nil }
          let(:uri) { 'https://example.com/objects/0123-456-789-abc-def' }

          it 'returns status by uri' do
            expect(subject.call(uri, on_behalf_of: account)).to be_nil
          end
        end
      end
    end

    context 'when searching for a local private status' do
      let(:account) { Fabricate(:account) }
      let(:poster)  { Fabricate(:account) }
      let!(:status) { Fabricate(:status, account: poster, visibility: :private) }
      let(:url)     { ActivityPub::TagManager.instance.url_for(status) }
      let(:uri)     { ActivityPub::TagManager.instance.uri_for(status) }

      context 'when the account follows the poster' do
        before do
          account.follow!(poster)
        end

        it 'returns status by url' do
          expect(subject.call(url, on_behalf_of: account)).to eq(status)
        end

        it 'returns status by uri' do
          expect(subject.call(uri, on_behalf_of: account)).to eq(status)
        end
      end

      context 'when the account does not follow the poster' do
        it 'does not return the status by url' do
          expect(subject.call(url, on_behalf_of: account)).to be_nil
        end

        it 'does not return the status by uri' do
          expect(subject.call(uri, on_behalf_of: account)).to be_nil
        end
      end
    end

    context 'when searching for a link that redirects to a local public status' do
      let(:account) { Fabricate(:account) }
      let(:poster)  { Fabricate(:account) }
      let!(:status) { Fabricate(:status, account: poster, visibility: :public) }
      let(:url)     { 'https://link.to/foobar' }
      let(:status_url) { ActivityPub::TagManager.instance.url_for(status) }
      let(:uri) { ActivityPub::TagManager.instance.uri_for(status) }

      before do
        stub_request(:get, url).to_return(status: 302, headers: { 'Location' => status_url })
        body = ActiveModelSerializers::SerializableResource.new(status, serializer: ActivityPub::NoteSerializer, adapter: ActivityPub::Adapter).to_json
        stub_request(:get, status_url).to_return(body: body, headers: { 'Content-Type' => 'application/activity+json' })
      end

      it 'returns status by url' do
        expect(subject.call(url, on_behalf_of: account)).to eq(status)
      end
    end

    context 'when searching for a local link of a remote private status' do
      let(:account)    { Fabricate(:account) }
      let(:poster)     { Fabricate(:account, username: 'foo', domain: 'example.com') }
      let(:url)        { 'https://example.com/@foo/42' }
      let(:uri)        { 'https://example.com/users/foo/statuses/42' }
      let!(:status)    { Fabricate(:status, url: url, uri: uri, account: poster, visibility: :private) }
      let(:search_url) { ""https://#{Rails.configuration.x.local_domain}/@foo@example.com/#{status.id}"" }

      before do
        stub_request(:get, url).to_return(status: 404) if url.present?
        stub_request(:get, uri).to_return(status: 404)
      end

      context 'when the account follows the poster' do
        before do
          account.follow!(poster)
        end

        it 'returns the status' do
          expect(subject.call(search_url, on_behalf_of: account)).to eq(status)
        end
      end

      context 'when the account does not follow the poster' do
        it 'does not return the status' do
          expect(subject.call(search_url, on_behalf_of: account)).to be_nil
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

require 'zip'

class BackupService < BaseService
  include Payloadable
  include ContextHelper

  attr_reader :account, :backup

  def call(backup)
    @backup  = backup
    @account = backup.user.account

    build_archive!
  end

  private

  def build_outbox_json!(file)
    skeleton = serialize(collection_presenter, ActivityPub::CollectionSerializer)
    skeleton[:@context] = full_context
    skeleton[:orderedItems] = ['!PLACEHOLDER!']
    skeleton = Oj.dump(skeleton)
    prepend, append = skeleton.split('""!PLACEHOLDER!""')
    add_comma = false

    file.write(prepend)

    account.statuses.with_includes.reorder(nil).find_in_batches do |statuses|
      file.write(',') if add_comma
      add_comma = true

      file.write(statuses.map do |status|
        item = serialize_payload(ActivityPub::ActivityPresenter.from_status(status), ActivityPub::ActivitySerializer)
        item.delete('@context')

        unless item[:type] == 'Announce' || item[:object][:attachment].blank?
          item[:object][:attachment].each do |attachment|
            attachment[:url] = Addressable::URI.parse(attachment[:url]).path.delete_prefix('/system/')
          end
        end

        Oj.dump(item)
      end.join(','))

      GC.start
    end

    file.write(append)
  end

  def build_archive!
    tmp_file = Tempfile.new(%w(archive .zip))

    Zip::File.open(tmp_file, create: true) do |zipfile|
      dump_outbox!(zipfile)
      dump_media_attachments!(zipfile)
      dump_likes!(zipfile)
      dump_bookmarks!(zipfile)
      dump_actor!(zipfile)
    end

    archive_filename = ""#{['archive', Time.now.utc.strftime('%Y%m%d%H%M%S'), SecureRandom.hex(16)].join('-')}.zip""

    @backup.dump      = ActionDispatch::Http::UploadedFile.new(tempfile: tmp_file, filename: archive_filename)
    @backup.processed = true
    @backup.save!
  ensure
    tmp_file.close
    tmp_file.unlink
  end

  def dump_media_attachments!(zipfile)
    MediaAttachment.attached.where(account: account).find_in_batches do |media_attachments|
      media_attachments.each do |m|
        path = m.file&.path
        next unless path

        path = path.gsub(%r{\A.*/system/}, '')
        path = path.gsub(%r{\A/+}, '')
        download_to_zip(zipfile, m.file, path)
      end

      GC.start
    end
  end

  def dump_outbox!(zipfile)
    zipfile.get_output_stream('outbox.json') do |io|
      build_outbox_json!(io)
    end
  end

  def dump_actor!(zipfile)
    actor = serialize(account, ActivityPub::ActorSerializer)

    actor[:icon][:url]  = ""avatar#{File.extname(actor[:icon][:url])}""  if actor[:icon]
    actor[:image][:url] = ""header#{File.extname(actor[:image][:url])}"" if actor[:image]
    actor[:outbox]      = 'outbox.json'
    actor[:likes]       = 'likes.json'
    actor[:bookmarks]   = 'bookmarks.json'

    download_to_zip(zipfile, account.avatar, ""avatar#{File.extname(account.avatar.path)}"") if account.avatar.exists?
    download_to_zip(zipfile, account.header, ""header#{File.extname(account.header.path)}"") if account.header.exists?

    json = Oj.dump(actor)

    zipfile.get_output_stream('actor.json') do |io|
      io.write(json)
    end
  end

  def dump_likes!(zipfile)
    skeleton = serialize(ActivityPub::CollectionPresenter.new(id: 'likes.json', type: :ordered, size: 0, items: []), ActivityPub::CollectionSerializer)
    skeleton.delete(:totalItems)
    skeleton[:orderedItems] = ['!PLACEHOLDER!']
    skeleton = Oj.dump(skeleton)
    prepend, append = skeleton.split('""!PLACEHOLDER!""')

    zipfile.get_output_stream('likes.json') do |io|
      io.write(prepend)

      add_comma = false

      Status.reorder(nil).joins(:favourites).includes(:account).merge(account.favourites).find_in_batches do |statuses|
        io.write(',') if add_comma
        add_comma = true

        io.write(statuses.map do |status|
          Oj.dump(ActivityPub::TagManager.instance.uri_for(status))
        end.join(','))

        GC.start
      end

      io.write(append)
    end
  end

  def dump_bookmarks!(zipfile)
    skeleton = serialize(ActivityPub::CollectionPresenter.new(id: 'bookmarks.json', type: :ordered, size: 0, items: []), ActivityPub::CollectionSerializer)
    skeleton.delete(:totalItems)
    skeleton[:orderedItems] = ['!PLACEHOLDER!']
    skeleton = Oj.dump(skeleton)
    prepend, append = skeleton.split('""!PLACEHOLDER!""')

    zipfile.get_output_stream('bookmarks.json') do |io|
      io.write(prepend)

      add_comma = false
      Status.reorder(nil).joins(:bookmarks).includes(:account).merge(account.bookmarks).find_in_batches do |statuses|
        io.write(',') if add_comma
        add_comma = true

        io.write(statuses.map do |status|
          Oj.dump(ActivityPub::TagManager.instance.uri_for(status))
        end.join(','))

        GC.start
      end

      io.write(append)
    end
  end

  def collection_presenter
    ActivityPub::CollectionPresenter.new(
      id: 'outbox.json',
      type: :ordered,
      size: account.statuses_count,
      items: []
    )
  end

  def serialize(object, serializer)
    ActiveModelSerializers::SerializableResource.new(
      object,
      serializer: serializer,
      adapter: ActivityPub::Adapter
    ).as_json
  end

  CHUNK_SIZE = 1.megabyte

  def download_to_zip(zipfile, attachment, filename)
    adapter = Paperclip.io_adapters.for(attachment)

    zipfile.get_output_stream(filename) do |io|
      while (buffer = adapter.read(CHUNK_SIZE))
        io.write(buffer)
      end
    end
  rescue Errno::ENOENT, Seahorse::Client::NetworkingError => e
    Rails.logger.warn ""Could not backup file #{filename}: #{e}""
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe BackupService, type: :service do
  subject(:service_call) { described_class.new.call(backup) }

  let!(:user)           { Fabricate(:user) }
  let!(:attachment)     { Fabricate(:media_attachment, account: user.account) }
  let!(:status)         { Fabricate(:status, account: user.account, text: 'Hello', visibility: :public, media_attachments: [attachment]) }
  let!(:private_status) { Fabricate(:status, account: user.account, text: 'secret', visibility: :private) }
  let!(:favourite)      { Fabricate(:favourite, account: user.account) }
  let!(:bookmark)       { Fabricate(:bookmark, account: user.account) }
  let!(:backup)         { Fabricate(:backup, user: user) }

  def read_zip_file(backup, filename)
    file = Paperclip.io_adapters.for(backup.dump)
    Zip::File.open(file) do |zipfile|
      entry = zipfile.glob(filename).first
      return entry.get_input_stream.read
    end
  end

  context 'when the user has an avatar and header' do
    before do
      user.account.update!(avatar: attachment_fixture('avatar.gif'))
      user.account.update!(header: attachment_fixture('emojo.png'))
    end

    it 'stores them as expected' do
      service_call

      json = export_json(:actor)
      avatar_path = json.dig('icon', 'url')
      header_path = json.dig('image', 'url')

      expect(avatar_path).to_not be_nil
      expect(header_path).to_not be_nil

      expect(read_zip_file(backup, avatar_path)).to be_present
      expect(read_zip_file(backup, header_path)).to be_present
    end
  end

  it 'marks the backup as processed and exports files' do
    expect { service_call }.to process_backup

    expect_outbox_export
    expect_likes_export
    expect_bookmarks_export
  end

  def process_backup
    change(backup, :processed).from(false).to(true)
  end

  def expect_outbox_export
    json = export_json(:outbox)

    aggregate_failures do
      expect(json['@context']).to_not be_nil
      expect(json['type']).to eq 'OrderedCollection'
      expect(json['totalItems']).to eq 2
      expect(json['orderedItems'][0]['@context']).to be_nil
      expect(json['orderedItems'][0]).to include_create_item(status)
      expect(json['orderedItems'][1]).to include_create_item(private_status)
    end
  end

  def expect_likes_export
    json = export_json(:likes)

    aggregate_failures do
      expect(json['type']).to eq 'OrderedCollection'
      expect(json['orderedItems']).to eq [ActivityPub::TagManager.instance.uri_for(favourite.status)]
    end
  end

  def expect_bookmarks_export
    json = export_json(:bookmarks)

    aggregate_failures do
      expect(json['type']).to eq 'OrderedCollection'
      expect(json['orderedItems']).to eq [ActivityPub::TagManager.instance.uri_for(bookmark.status)]
    end
  end

  def export_json(type)
    Oj.load(read_zip_file(backup, ""#{type}.json""))
  end

  def include_create_item(status)
    include({
      'type' => 'Create',
      'object' => include({
        'id' => ActivityPub::TagManager.instance.uri_for(status),
        'content' => ""<p>#{status.text}</p>"",
      }),
    })
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class AccountStatusesCleanupService < BaseService
  # @param [AccountStatusesCleanupPolicy] account_policy
  # @param [Integer] budget
  # @return [Integer]
  def call(account_policy, budget = 50)
    return 0 unless account_policy.enabled?

    cutoff_id = account_policy.compute_cutoff_id
    return 0 if cutoff_id.blank?

    num_deleted = 0
    last_deleted = nil

    account_policy.statuses_to_delete(budget, cutoff_id, account_policy.last_inspected).reorder(nil).find_each(order: :asc) do |status|
      status.discard_with_reblogs
      RemovalWorker.perform_async(status.id, { 'redraft' => false })
      num_deleted += 1
      last_deleted = status.id
    end

    account_policy.record_last_inspected(last_deleted.presence || cutoff_id)

    num_deleted
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

describe AccountStatusesCleanupService, type: :service do
  let(:account)           { Fabricate(:account, username: 'alice', domain: nil) }
  let(:account_policy)    { Fabricate(:account_statuses_cleanup_policy, account: account) }
  let!(:unrelated_status) { Fabricate(:status, created_at: 3.years.ago) }

  describe '#call' do
    context 'when the account has not posted anything' do
      it 'returns 0 deleted toots' do
        expect(subject.call(account_policy)).to eq 0
      end
    end

    context 'when the account has posted several old statuses' do
      let!(:very_old_status)    { Fabricate(:status, created_at: 3.years.ago, account: account) }
      let!(:old_status)         { Fabricate(:status, created_at: 1.year.ago, account: account) }
      let!(:another_old_status) { Fabricate(:status, created_at: 1.year.ago, account: account) }
      let!(:recent_status)      { Fabricate(:status, created_at: 1.day.ago, account: account) }

      context 'when given a budget of 1' do
        it 'reports 1 deleted toot' do
          expect(subject.call(account_policy, 1)).to eq 1
        end
      end

      context 'when given a normal budget of 10' do
        it 'reports 3 deleted statuses' do
          expect(subject.call(account_policy, 10)).to eq 3
        end

        it 'records the last deleted id' do
          subject.call(account_policy, 10)
          expect(account_policy.last_inspected).to eq [old_status.id, another_old_status.id].max
        end

        it 'actually deletes the statuses' do
          subject.call(account_policy, 10)
          expect(Status.find_by(id: [very_old_status.id, old_status.id, another_old_status.id])).to be_nil
        end
      end

      context 'when called repeatedly with a budget of 2' do
        it 'reports 2 then 1 deleted statuses' do
          expect(subject.call(account_policy, 2)).to eq 2
          expect(subject.call(account_policy, 2)).to eq 1
        end

        it 'actually deletes the statuses in the expected order' do
          subject.call(account_policy, 2)
          expect(Status.find_by(id: very_old_status.id)).to be_nil
          subject.call(account_policy, 2)
          expect(Status.find_by(id: [very_old_status.id, old_status.id, another_old_status.id])).to be_nil
        end
      end

      context 'when a self-faved toot is unfaved' do
        let!(:self_faved) { Fabricate(:status, created_at: 6.months.ago, account: account) }
        let!(:favourite)  { Fabricate(:favourite, account: account, status: self_faved) }

        it 'deletes it once unfaved' do
          expect(subject.call(account_policy, 20)).to eq 3
          expect(Status.find_by(id: self_faved.id)).to_not be_nil
          expect(subject.call(account_policy, 20)).to eq 0
          favourite.destroy!
          expect(subject.call(account_policy, 20)).to eq 1
          expect(Status.find_by(id: self_faved.id)).to be_nil
        end
      end

      context 'when there are more un-deletable old toots than the early search cutoff' do
        before do
          stub_const 'AccountStatusesCleanupPolicy::EARLY_SEARCH_CUTOFF', 5
          # Old statuses that should be cut-off
          10.times do
            Fabricate(:status, created_at: 4.years.ago, visibility: :direct, account: account)
          end
          # New statuses that prevent cut-off id to reach the last status
          10.times do
            Fabricate(:status, created_at: 4.seconds.ago, visibility: :direct, account: account)
          end
        end

        it 'reports 0 deleted statuses then 0 then 3 then 0 again' do
          expect(subject.call(account_policy, 10)).to eq 0
          expect(subject.call(account_policy, 10)).to eq 0
          expect(subject.call(account_policy, 10)).to eq 3
          expect(subject.call(account_policy, 10)).to eq 0
        end

        it 'never causes the recorded id to get higher than oldest deletable toot' do
          subject.call(account_policy, 10)
          subject.call(account_policy, 10)
          subject.call(account_policy, 10)
          subject.call(account_policy, 10)
          expect(account_policy.last_inspected).to be < Mastodon::Snowflake.id_at(account_policy.min_status_age.seconds.ago, with_random: false)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class FetchOEmbedService
  ENDPOINT_CACHE_EXPIRES_IN = 24.hours.freeze
  URL_REGEX                 = %r{(=(https?(%3A|:)(//|%2F%2F)))([^&]*)}i

  attr_reader :url, :options, :format, :endpoint_url

  def call(url, options = {})
    @url     = url
    @options = options

    if @options[:cached_endpoint]
      parse_cached_endpoint!
    else
      discover_endpoint!
    end

    fetch!
  end

  private

  def discover_endpoint!
    return if html.nil?

    @format = @options[:format]
    page    = Nokogiri::HTML(html)

    if @format.nil? || @format == :json
      @endpoint_url ||= page.at_xpath('//link[@type=""application/json+oembed""]|//link[@type=""text/json+oembed""]')&.attribute('href')&.value
      @format       ||= :json if @endpoint_url
    end

    if @format.nil? || @format == :xml
      @endpoint_url ||= page.at_xpath('//link[@type=""text/xml+oembed""]')&.attribute('href')&.value
      @format       ||= :xml if @endpoint_url
    end

    return if @endpoint_url.blank?

    @endpoint_url = begin
      base_url = Addressable::URI.parse(@url)

      # If the OEmbed endpoint is given as http but the URL we opened
      # was served over https, we can assume OEmbed will be available
      # through https as well

      (base_url + @endpoint_url).tap do |absolute_url|
        absolute_url.scheme = base_url.scheme if base_url.scheme == 'https'
      end.to_s
    end

    cache_endpoint!
  rescue Addressable::URI::InvalidURIError
    @endpoint_url = nil
  end

  def parse_cached_endpoint!
    cached = @options[:cached_endpoint]

    return if cached[:endpoint].nil? || cached[:format].nil?

    @endpoint_url = Addressable::Template.new(cached[:endpoint]).expand(url: @url).to_s
    @format       = cached[:format]
  end

  def cache_endpoint!
    return unless URL_REGEX.match?(@endpoint_url)

    url_domain = Addressable::URI.parse(@url).normalized_host

    endpoint_hash = {
      endpoint: @endpoint_url.gsub(URL_REGEX, '={url}'),
      format: @format,
    }

    Rails.cache.write(""oembed_endpoint:#{url_domain}"", endpoint_hash, expires_in: ENDPOINT_CACHE_EXPIRES_IN)
  end

  def fetch!
    return if @endpoint_url.blank?

    body = Request.new(:get, @endpoint_url).perform do |res|
      res.code == 200 ? res.body_with_limit : nil
    end

    validate(parse_for_format(body)) if body.present?
  rescue Oj::ParseError, Ox::ParseError
    nil
  end

  def parse_for_format(body)
    case @format
    when :json
      Oj.load(body, mode: :strict)&.with_indifferent_access
    when :xml
      Ox.load(body, mode: :hash_no_attrs)&.with_indifferent_access&.dig(:oembed)
    end
  end

  def validate(oembed)
    oembed if oembed[:version].to_s == '1.0' && oembed[:type].present?
  end

  def html
    return @html if defined?(@html)

    @html = @options[:html] || Request.new(:get, @url).add_headers('Accept' => 'text/html').perform do |res|
      res.code != 200 || res.mime_type != 'text/html' ? nil : res.body_with_limit
    end
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

describe FetchOEmbedService, type: :service do
  subject { described_class.new }

  before do
    stub_request(:get, 'https://host.test/provider.json').to_return(status: 404)
    stub_request(:get, 'https://host.test/provider.xml').to_return(status: 404)
    stub_request(:get, 'https://host.test/empty_provider.json').to_return(status: 200)
  end

  describe 'discover_provider' do
    context 'when status code is 200 and MIME type is text/html' do
      context 'when OEmbed endpoint contains URL as parameter' do
        before do
          stub_request(:get, 'https://www.youtube.com/watch?v=IPSbNdBmWKE').to_return(
            status: 200,
            headers: { 'Content-Type': 'text/html' },
            body: request_fixture('oembed_youtube.html')
          )
          stub_request(:get, 'https://www.youtube.com/oembed?format=json&url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DIPSbNdBmWKE').to_return(
            status: 200,
            headers: { 'Content-Type': 'text/html' },
            body: request_fixture('oembed_json_empty.html')
          )
        end

        it 'returns new OEmbed::Provider for JSON provider' do
          subject.call('https://www.youtube.com/watch?v=IPSbNdBmWKE')
          expect(subject.endpoint_url).to eq 'https://www.youtube.com/oembed?format=json&url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DIPSbNdBmWKE'
          expect(subject.format).to eq :json
        end

        it 'stores URL template' do
          subject.call('https://www.youtube.com/watch?v=IPSbNdBmWKE')
          expect(Rails.cache.read('oembed_endpoint:www.youtube.com')[:endpoint]).to eq 'https://www.youtube.com/oembed?format=json&url={url}'
        end
      end

      context 'when both of JSON and XML provider are discoverable' do
        before do
          stub_request(:get, 'https://host.test/oembed.html').to_return(
            status: 200,
            headers: { 'Content-Type': 'text/html' },
            body: request_fixture('oembed_json_xml.html')
          )
        end

        it 'returns new OEmbed::Provider for JSON provider if :format option is set to :json' do
          subject.call('https://host.test/oembed.html', format: :json)
          expect(subject.endpoint_url).to eq 'https://host.test/provider.json'
          expect(subject.format).to eq :json
        end

        it 'returns new OEmbed::Provider for XML provider if :format option is set to :xml' do
          subject.call('https://host.test/oembed.html', format: :xml)
          expect(subject.endpoint_url).to eq 'https://host.test/provider.xml'
          expect(subject.format).to eq :xml
        end

        it 'does not cache OEmbed endpoint' do
          subject.call('https://host.test/oembed.html', format: :xml)
          expect(Rails.cache.exist?('oembed_endpoint:host.test')).to be false
        end
      end

      context 'when JSON provider is discoverable while XML provider is not' do
        before do
          stub_request(:get, 'https://host.test/oembed.html').to_return(
            status: 200,
            headers: { 'Content-Type': 'text/html' },
            body: request_fixture('oembed_json.html')
          )
        end

        it 'returns new OEmbed::Provider for JSON provider' do
          subject.call('https://host.test/oembed.html')
          expect(subject.endpoint_url).to eq 'https://host.test/provider.json'
          expect(subject.format).to eq :json
        end

        it 'does not cache OEmbed endpoint' do
          subject.call('https://host.test/oembed.html')
          expect(Rails.cache.exist?('oembed_endpoint:host.test')).to be false
        end
      end

      context 'when XML provider is discoverable while JSON provider is not' do
        before do
          stub_request(:get, 'https://host.test/oembed.html').to_return(
            status: 200,
            headers: { 'Content-Type': 'text/html' },
            body: request_fixture('oembed_xml.html')
          )
        end

        it 'returns new OEmbed::Provider for XML provider' do
          subject.call('https://host.test/oembed.html')
          expect(subject.endpoint_url).to eq 'https://host.test/provider.xml'
          expect(subject.format).to eq :xml
        end

        it 'does not cache OEmbed endpoint' do
          subject.call('https://host.test/oembed.html')
          expect(Rails.cache.exist?('oembed_endpoint:host.test')).to be false
        end
      end

      context 'with Invalid XML provider is discoverable while JSON provider is not' do
        before do
          stub_request(:get, 'https://host.test/oembed.html').to_return(
            status: 200,
            headers: { 'Content-Type': 'text/html' },
            body: request_fixture('oembed_invalid_xml.html')
          )
        end

        it 'returns nil' do
          expect(subject.call('https://host.test/oembed.html')).to be_nil
        end
      end

      context 'with neither of JSON and XML provider is discoverable' do
        before do
          stub_request(:get, 'https://host.test/oembed.html').to_return(
            status: 200,
            headers: { 'Content-Type': 'text/html' },
            body: request_fixture('oembed_undiscoverable.html')
          )
        end

        it 'returns nil' do
          expect(subject.call('https://host.test/oembed.html')).to be_nil
        end
      end

      context 'when empty JSON provider is discoverable' do
        before do
          stub_request(:get, 'https://host.test/oembed.html').to_return(
            status: 200,
            headers: { 'Content-Type': 'text/html' },
            body: request_fixture('oembed_json_empty.html')
          )
        end

        it 'returns new OEmbed::Provider for JSON provider' do
          subject.call('https://host.test/oembed.html')
          expect(subject.endpoint_url).to eq 'https://host.test/empty_provider.json'
          expect(subject.format).to eq :json
        end
      end
    end

    context 'when endpoint is cached' do
      before do
        stub_request(:get, 'http://www.youtube.com/oembed?format=json&url=https://www.youtube.com/watch?v=dqwpQarrDwk').to_return(
          status: 200,
          headers: { 'Content-Type': 'text/html' },
          body: request_fixture('oembed_json_empty.html')
        )
      end

      it 'returns new provider without fetching original URL first' do
        subject.call('https://www.youtube.com/watch?v=dqwpQarrDwk', cached_endpoint: { endpoint: 'http://www.youtube.com/oembed?format=json&url={url}', format: :json })
        expect(a_request(:get, 'https://www.youtube.com/watch?v=dqwpQarrDwk')).to_not have_been_made
        expect(subject.endpoint_url).to eq 'http://www.youtube.com/oembed?format=json&url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DdqwpQarrDwk'
        expect(subject.format).to eq :json
        expect(a_request(:get, 'http://www.youtube.com/oembed?format=json&url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DdqwpQarrDwk')).to have_been_made
      end
    end

    context 'when status code is not 200' do
      before do
        stub_request(:get, 'https://host.test/oembed.html').to_return(
          status: 400,
          headers: { 'Content-Type': 'text/html' },
          body: request_fixture('oembed_xml.html')
        )
      end

      it 'returns nil' do
        expect(subject.call('https://host.test/oembed.html')).to be_nil
      end
    end

    context 'when MIME type is not text/html' do
      before do
        stub_request(:get, 'https://host.test/oembed.html').to_return(
          status: 200,
          body: request_fixture('oembed_xml.html')
        )
      end

      it 'returns nil' do
        expect(subject.call('https://host.test/oembed.html')).to be_nil
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class UpdateStatusService < BaseService
  include Redisable
  include LanguagesHelper

  class NoChangesSubmittedError < StandardError; end

  # @param [Status] status
  # @param [Integer] account_id
  # @param [Hash] options
  # @option options [Array<Integer>] :media_ids
  # @option options [Array<Hash>] :media_attributes
  # @option options [Hash] :poll
  # @option options [String] :text
  # @option options [String] :spoiler_text
  # @option options [Boolean] :sensitive
  # @option options [String] :language
  def call(status, account_id, options = {})
    @status                    = status
    @options                   = options
    @account_id                = account_id
    @media_attachments_changed = false
    @poll_changed              = false

    Status.transaction do
      create_previous_edit!
      update_media_attachments! if @options.key?(:media_ids)
      update_poll! if @options.key?(:poll)
      update_immediate_attributes!
      create_edit!
    end

    queue_poll_notifications!
    reset_preview_card!
    update_metadata!
    broadcast_updates!

    @status
  rescue NoChangesSubmittedError
    # For calls that result in no changes, swallow the error
    # but get back to the original state

    @status.reload
  end

  private

  def update_media_attachments!
    previous_media_attachments = @status.ordered_media_attachments.to_a
    next_media_attachments     = validate_media!
    added_media_attachments    = next_media_attachments - previous_media_attachments

    (@options[:media_attributes] || []).each do |attributes|
      media = next_media_attachments.find { |attachment| attachment.id == attributes[:id].to_i }
      next if media.nil?

      media.update!(attributes.slice(:thumbnail, :description, :focus))
      @media_attachments_changed ||= media.significantly_changed?
    end

    MediaAttachment.where(id: added_media_attachments.map(&:id)).update_all(status_id: @status.id)

    @status.ordered_media_attachment_ids = (@options[:media_ids] || []).map(&:to_i) & next_media_attachments.map(&:id)
    @media_attachments_changed ||= previous_media_attachments.map(&:id) != @status.ordered_media_attachment_ids
    @status.media_attachments.reload
  end

  def validate_media!
    return [] if @options[:media_ids].blank? || !@options[:media_ids].is_a?(Enumerable)

    raise Mastodon::ValidationError, I18n.t('media_attachments.validations.too_many') if @options[:media_ids].size > 4 || @options[:poll].present?

    media_attachments = @status.account.media_attachments.where(status_id: [nil, @status.id]).where(scheduled_status_id: nil).where(id: @options[:media_ids].take(4).map(&:to_i)).to_a

    raise Mastodon::ValidationError, I18n.t('media_attachments.validations.images_and_video') if media_attachments.size > 1 && media_attachments.find(&:audio_or_video?)
    raise Mastodon::ValidationError, I18n.t('media_attachments.validations.not_ready') if media_attachments.any?(&:not_processed?)

    media_attachments
  end

  def update_poll!
    previous_poll        = @status.preloadable_poll
    @previous_expires_at = previous_poll&.expires_at

    if @options[:poll].present?
      poll = previous_poll || @status.account.polls.new(status: @status, votes_count: 0)

      # If for some reasons the options were changed, it invalidates all previous
      # votes, so we need to remove them
      @poll_changed = true if @options[:poll][:options] != poll.options || ActiveModel::Type::Boolean.new.cast(@options[:poll][:multiple]) != poll.multiple

      poll.options     = @options[:poll][:options]
      poll.hide_totals = @options[:poll][:hide_totals] || false
      poll.multiple    = @options[:poll][:multiple] || false
      poll.expires_in  = @options[:poll][:expires_in]
      poll.reset_votes! if @poll_changed
      poll.save!

      @status.poll_id = poll.id
    elsif previous_poll.present?
      previous_poll.destroy
      @poll_changed = true
      @status.poll_id = nil
    end

    @poll_changed = true if @previous_expires_at != @status.preloadable_poll&.expires_at
  end

  def update_immediate_attributes!
    @status.text         = @options[:text].presence || @options.delete(:spoiler_text) || '' if @options.key?(:text)
    @status.spoiler_text = @options[:spoiler_text] || '' if @options.key?(:spoiler_text)
    @status.sensitive    = @options[:sensitive] || @options[:spoiler_text].present? if @options.key?(:sensitive) || @options.key?(:spoiler_text)
    @status.language     = valid_locale_cascade(@options[:language], @status.language, @status.account.user&.preferred_posting_language, I18n.default_locale)

    # We raise here to rollback the entire transaction
    raise NoChangesSubmittedError unless significant_changes?

    @status.edited_at = Time.now.utc
    @status.save!
  end

  def reset_preview_card!
    return unless @status.text_previously_changed?

    @status.reset_preview_card!
    LinkCrawlWorker.perform_async(@status.id)
  end

  def update_metadata!
    ProcessHashtagsService.new.call(@status)
    ProcessMentionsService.new.call(@status)
  end

  def broadcast_updates!
    DistributionWorker.perform_async(@status.id, { 'update' => true })
    ActivityPub::StatusUpdateDistributionWorker.perform_async(@status.id)
  end

  def queue_poll_notifications!
    poll = @status.preloadable_poll

    # If the poll had no expiration date set but now has, or now has a sooner
    # expiration date, schedule a notification

    return unless poll.present? && poll.expires_at.present?

    PollExpirationNotifyWorker.remove_from_scheduled(poll.id) if @previous_expires_at.present? && @previous_expires_at > poll.expires_at
    PollExpirationNotifyWorker.perform_at(poll.expires_at + 5.minutes, poll.id)
  end

  def create_previous_edit!
    # We only need to create a previous edit when no previous edits exist, e.g.
    # when the status has never been edited. For other cases, we always create
    # an edit, so the step can be skipped

    return if @status.edits.any?

    @status.snapshot!(at_time: @status.created_at, rate_limit: false)
  end

  def create_edit!
    @status.snapshot!(account_id: @account_id)
  end

  def significant_changes?
    @status.changed? || @poll_changed || @media_attachments_changed
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe UpdateStatusService, type: :service do
  subject { described_class.new }

  context 'when nothing changes' do
    let!(:status) { Fabricate(:status, text: 'Foo', language: 'en') }

    before do
      allow(ActivityPub::DistributionWorker).to receive(:perform_async)
      subject.call(status, status.account_id, text: 'Foo')
    end

    it 'does not create an edit' do
      expect(status.reload.edits).to be_empty
    end

    it 'does not notify anyone' do
      expect(ActivityPub::DistributionWorker).to_not have_received(:perform_async)
    end
  end

  context 'when text changes' do
    let(:status) { Fabricate(:status, text: 'Foo') }
    let(:preview_card) { Fabricate(:preview_card) }

    before do
      PreviewCardsStatus.create(status: status, preview_card: preview_card)
      subject.call(status, status.account_id, text: 'Bar')
    end

    it 'updates text' do
      expect(status.reload.text).to eq 'Bar'
    end

    it 'resets preview card' do
      expect(status.reload.preview_card).to be_nil
    end

    it 'saves edit history' do
      expect(status.edits.pluck(:text)).to eq %w(Foo Bar)
    end
  end

  context 'when content warning changes' do
    let(:status) { Fabricate(:status, text: 'Foo', spoiler_text: '') }
    let(:preview_card) { Fabricate(:preview_card) }

    before do
      PreviewCardsStatus.create(status: status, preview_card: preview_card)
      subject.call(status, status.account_id, text: 'Foo', spoiler_text: 'Bar')
    end

    it 'updates content warning' do
      expect(status.reload.spoiler_text).to eq 'Bar'
    end

    it 'saves edit history' do
      expect(status.edits.pluck(:text, :spoiler_text)).to eq [['Foo', ''], ['Foo', 'Bar']]
    end
  end

  context 'when media attachments change' do
    let!(:status) { Fabricate(:status, text: 'Foo') }
    let!(:detached_media_attachment) { Fabricate(:media_attachment, account: status.account) }
    let!(:attached_media_attachment) { Fabricate(:media_attachment, account: status.account) }

    before do
      status.media_attachments << detached_media_attachment
      subject.call(status, status.account_id, text: 'Foo', media_ids: [attached_media_attachment.id])
    end

    it 'updates media attachments' do
      expect(status.ordered_media_attachments).to eq [attached_media_attachment]
    end

    it 'does not detach detached media attachments' do
      expect(detached_media_attachment.reload.status_id).to eq status.id
    end

    it 'attaches attached media attachments' do
      expect(attached_media_attachment.reload.status_id).to eq status.id
    end

    it 'saves edit history' do
      expect(status.edits.pluck(:ordered_media_attachment_ids)).to eq [[detached_media_attachment.id], [attached_media_attachment.id]]
    end
  end

  context 'when already-attached media changes' do
    let!(:status) { Fabricate(:status, text: 'Foo') }
    let!(:media_attachment) { Fabricate(:media_attachment, account: status.account, description: 'Old description') }

    before do
      status.media_attachments << media_attachment
      subject.call(status, status.account_id, text: 'Foo', media_ids: [media_attachment.id], media_attributes: [{ id: media_attachment.id, description: 'New description' }])
    end

    it 'does not detach media attachment' do
      expect(media_attachment.reload.status_id).to eq status.id
    end

    it 'updates the media attachment description' do
      expect(media_attachment.reload.description).to eq 'New description'
    end

    it 'saves edit history' do
      expect(status.edits.map { |edit| edit.ordered_media_attachments.map(&:description) }).to eq [['Old description'], ['New description']]
    end
  end

  context 'when poll changes', :sidekiq_fake do
    let(:account) { Fabricate(:account) }
    let!(:status) { Fabricate(:status, text: 'Foo', account: account, poll_attributes: { options: %w(Foo Bar), account: account, multiple: false, hide_totals: false, expires_at: 7.days.from_now }) }
    let!(:poll)   { status.poll }
    let!(:voter) { Fabricate(:account) }

    before do
      status.update(poll: poll)
      VoteService.new.call(voter, poll, [0])
      subject.call(status, status.account_id, text: 'Foo', poll: { options: %w(Bar Baz Foo), expires_in: 5.days.to_i })
    end

    it 'updates poll' do
      poll = status.poll.reload
      expect(poll.options).to eq %w(Bar Baz Foo)
    end

    it 'resets votes' do
      poll = status.poll.reload
      expect(poll.votes_count).to eq 0
      expect(poll.votes.count).to eq 0
      expect(poll.cached_tallies).to eq [0, 0, 0]
    end

    it 'saves edit history' do
      expect(status.edits.pluck(:poll_options)).to eq [%w(Foo Bar), %w(Bar Baz Foo)]
    end

    it 'requeues expiration notification' do
      poll = status.poll.reload
      expect(PollExpirationNotifyWorker).to have_enqueued_sidekiq_job(poll.id).at(poll.expires_at + 5.minutes)
    end
  end

  context 'when mentions in text change' do
    let!(:account) { Fabricate(:account) }
    let!(:alice) { Fabricate(:account, username: 'alice') }
    let!(:bob) { Fabricate(:account, username: 'bob') }
    let!(:status) { PostStatusService.new.call(account, text: 'Hello @alice') }

    before do
      subject.call(status, status.account_id, text: 'Hello @bob')
    end

    it 'changes mentions' do
      expect(status.active_mentions.pluck(:account_id)).to eq [bob.id]
    end

    it 'keeps old mentions as silent mentions' do
      expect(status.mentions.pluck(:account_id)).to contain_exactly(alice.id, bob.id)
    end
  end

  context 'when hashtags in text change' do
    let!(:account) { Fabricate(:account) }
    let!(:status) { PostStatusService.new.call(account, text: 'Hello #foo') }

    before do
      subject.call(status, status.account_id, text: 'Hello #bar')
    end

    it 'changes tags' do
      expect(status.tags.pluck(:name)).to eq %w(bar)
    end
  end

  it 'notifies ActivityPub about the update' do
    status = Fabricate(:status, text: 'Foo')
    allow(ActivityPub::DistributionWorker).to receive(:perform_async)
    subject.call(status, status.account_id, text: 'Bar')
    expect(ActivityPub::DistributionWorker).to have_received(:perform_async)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class BootstrapTimelineService < BaseService
  def call(source_account)
    @source_account = source_account

    autofollow_inviter!
    notify_staff!
  end

  private

  def autofollow_inviter!
    return unless @source_account&.user&.invite&.autofollow?

    FollowService.new.call(@source_account, @source_account.user.invite.user.account)
  end

  def notify_staff!
    User.those_who_can(:manage_users).includes(:account).find_each do |user|
      LocalNotificationWorker.perform_async(user.account_id, @source_account.id, 'Account', 'admin.sign_up')
    end
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe BootstrapTimelineService, type: :service do
  subject { described_class.new }

  context 'when the new user has registered from an invite' do
    let(:service)    { instance_double(FollowService) }
    let(:autofollow) { false }
    let(:inviter)    { Fabricate(:user, confirmed_at: 2.days.ago) }
    let(:invite)     { Fabricate(:invite, user: inviter, max_uses: nil, expires_at: 1.hour.from_now, autofollow: autofollow) }
    let(:new_user)   { Fabricate(:user, invite_code: invite.code) }

    before do
      allow(FollowService).to receive(:new).and_return(service)
      allow(service).to receive(:call)
    end

    context 'when the invite has auto-follow enabled' do
      let(:autofollow) { true }

      it 'calls FollowService to follow the inviter' do
        subject.call(new_user.account)
        expect(service).to have_received(:call).with(new_user.account, inviter.account)
      end
    end

    context 'when the invite does not have auto-follow enable' do
      let(:autofollow) { false }

      it 'calls FollowService to follow the inviter' do
        subject.call(new_user.account)
        expect(service).to_not have_received(:call)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class ResolveAccountService < BaseService
  include DomainControlHelper
  include WebfingerHelper
  include Redisable
  include Lockable

  # Find or create an account record for a remote user. When creating,
  # look up the user's webfinger and fetch ActivityPub data
  # @param [String, Account] uri URI in the username@domain format or account record
  # @param [Hash] options
  # @option options [Boolean] :redirected Do not follow further Webfinger redirects
  # @option options [Boolean] :skip_webfinger Do not attempt any webfinger query or refreshing account data
  # @option options [Boolean] :skip_cache Get the latest data from origin even if cache is not due to update yet
  # @option options [Boolean] :suppress_errors When failing, return nil instead of raising an error
  # @return [Account]
  def call(uri, options = {})
    return if uri.blank?

    process_options!(uri, options)

    # First of all we want to check if we've got the account
    # record with the URI already, and if so, we can exit early

    return if domain_not_allowed?(@domain)

    @account ||= Account.find_remote(@username, @domain)

    return @account if @account&.local? || @domain.nil? || !webfinger_update_due?

    # At this point we are in need of a Webfinger query, which may
    # yield us a different username/domain through a redirect
    process_webfinger!(@uri)
    @domain = nil if TagManager.instance.local_domain?(@domain)

    # Because the username/domain pair may be different than what
    # we already checked, we need to check if we've already got
    # the record with that URI, again

    return if domain_not_allowed?(@domain)

    @account ||= Account.find_remote(@username, @domain)

    if gone_from_origin? && not_yet_deleted?
      queue_deletion!
      return
    end

    return @account if @account&.local? || gone_from_origin? || !webfinger_update_due?

    # Now it is certain, it is definitely a remote account, and it
    # either needs to be created, or updated from fresh data

    fetch_account!
  rescue Webfinger::Error => e
    Rails.logger.debug { ""Webfinger query for #{@uri} failed: #{e}"" }
    raise unless @options[:suppress_errors]
  end

  private

  def process_options!(uri, options)
    @options = { suppress_errors: true }.merge(options)

    if uri.is_a?(Account)
      @account  = uri
      @username = @account.username
      @domain   = @account.domain
    else
      @username, @domain = uri.strip.gsub(/\A@/, '').split('@')
    end

    @domain = if TagManager.instance.local_domain?(@domain)
                nil
              else
                TagManager.instance.normalize_domain(@domain)
              end

    @uri = [@username, @domain].compact.join('@')
  end

  def process_webfinger!(uri)
    @webfinger                           = webfinger!(""acct:#{uri}"")
    confirmed_username, confirmed_domain = split_acct(@webfinger.subject)

    if confirmed_username.casecmp(@username).zero? && confirmed_domain.casecmp(@domain).zero?
      @username = confirmed_username
      @domain   = confirmed_domain
      return
    end

    # Account doesn't match, so it may have been redirected
    @webfinger         = webfinger!(""acct:#{confirmed_username}@#{confirmed_domain}"")
    @username, @domain = split_acct(@webfinger.subject)

    raise Webfinger::RedirectError, ""Too many webfinger redirects for URI #{uri} (stopped at #{@username}@#{@domain})"" unless confirmed_username.casecmp(@username).zero? && confirmed_domain.casecmp(@domain).zero?
  rescue Webfinger::GoneError
    @gone = true
  end

  def split_acct(acct)
    acct.delete_prefix('acct:').split('@').tap do |parts|
      raise Webfinger::Error, 'Webfinger response is missing user or host value' unless parts.size == 2
    end
  end

  def fetch_account!
    return unless activitypub_ready?

    with_redis_lock(""resolve:#{@username}@#{@domain}"") do
      @account = ActivityPub::FetchRemoteAccountService.new.call(actor_url, suppress_errors: @options[:suppress_errors])
    end

    @account
  end

  def webfinger_update_due?
    return false if @options[:check_delivery_availability] && !DeliveryFailureTracker.available?(@domain)
    return false if @options[:skip_webfinger]

    @options[:skip_cache] || @account.nil? || @account.possibly_stale?
  end

  def activitypub_ready?
    ['application/activity+json', 'application/ld+json; profile=""https://www.w3.org/ns/activitystreams""'].include?(@webfinger.link('self', 'type'))
  end

  def actor_url
    @actor_url ||= @webfinger.link('self', 'href')
  end

  def gone_from_origin?
    @gone
  end

  def not_yet_deleted?
    @account.present? && !@account.local?
  end

  def queue_deletion!
    @account.suspend!(origin: :remote)
    AccountDeletionWorker.perform_async(@account.id, { 'reserve_username' => false, 'skip_activitypub' => true })
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe ResolveAccountService, type: :service do
  subject { described_class.new }

  before do
    stub_request(:get, 'https://example.com/.well-known/host-meta').to_return(status: 404)
    stub_request(:get, 'https://quitter.no/avatar/7477-300-20160211190340.png').to_return(request_fixture('avatar.txt'))
    stub_request(:get, 'https://ap.example.com/.well-known/webfinger?resource=acct:foo@ap.example.com').to_return(request_fixture('activitypub-webfinger.txt'))
    stub_request(:get, 'https://ap.example.com/users/foo').to_return(request_fixture('activitypub-actor.txt'))
    stub_request(:get, 'https://ap.example.com/users/foo.atom').to_return(request_fixture('activitypub-feed.txt'))
    stub_request(:get, %r{https://ap\.example\.com/users/foo/\w+}).to_return(status: 404)
    stub_request(:get, 'https://example.com/.well-known/webfinger?resource=acct:hoge@example.com').to_return(status: 410)
  end

  context 'when using skip_webfinger' do
    context 'when account is known' do
      let!(:remote_account) { Fabricate(:account, username: 'foo', domain: 'ap.example.com', protocol: 'activitypub') }

      context 'when domain is banned' do
        let!(:domain_block) { Fabricate(:domain_block, domain: 'ap.example.com', severity: :suspend) }

        it 'does not return an account' do
          expect(subject.call('foo@ap.example.com', skip_webfinger: true)).to be_nil
        end

        it 'does not make a webfinger query' do
          subject.call('foo@ap.example.com', skip_webfinger: true)
          expect(a_request(:get, 'https://ap.example.com/.well-known/webfinger?resource=acct:foo@ap.example.com')).to_not have_been_made
        end
      end

      context 'when domain is not banned' do
        it 'returns the expected account' do
          expect(subject.call('foo@ap.example.com', skip_webfinger: true)).to eq remote_account
        end

        it 'does not make a webfinger query' do
          subject.call('foo@ap.example.com', skip_webfinger: true)
          expect(a_request(:get, 'https://ap.example.com/.well-known/webfinger?resource=acct:foo@ap.example.com')).to_not have_been_made
        end
      end
    end

    context 'when account is not known' do
      it 'does not return an account' do
        expect(subject.call('foo@ap.example.com', skip_webfinger: true)).to be_nil
      end

      it 'does not make a webfinger query' do
        subject.call('foo@ap.example.com', skip_webfinger: true)
        expect(a_request(:get, 'https://ap.example.com/.well-known/webfinger?resource=acct:foo@ap.example.com')).to_not have_been_made
      end
    end
  end

  context 'when there is an LRDD endpoint but no resolvable account' do
    before do
      stub_request(:get, 'https://quitter.no/.well-known/host-meta').to_return(request_fixture('.host-meta.txt'))
      stub_request(:get, 'https://quitter.no/.well-known/webfinger?resource=acct:catsrgr8@quitter.no').to_return(status: 404)
    end

    it 'returns nil' do
      expect(subject.call('catsrgr8@quitter.no')).to be_nil
    end
  end

  context 'when there is no LRDD endpoint nor resolvable account' do
    before do
      stub_request(:get, 'https://example.com/.well-known/webfinger?resource=acct:catsrgr8@example.com').to_return(status: 404)
    end

    it 'returns nil' do
      expect(subject.call('catsrgr8@example.com')).to be_nil
    end
  end

  context 'when webfinger returns http gone' do
    context 'with a previously known account' do
      before do
        Fabricate(:account, username: 'hoge', domain: 'example.com', last_webfingered_at: nil)
        allow(AccountDeletionWorker).to receive(:perform_async)
      end

      it 'returns nil' do
        expect(subject.call('hoge@example.com')).to be_nil
      end

      it 'queues account deletion worker' do
        subject.call('hoge@example.com')
        expect(AccountDeletionWorker).to have_received(:perform_async)
      end
    end

    context 'with a previously unknown account' do
      it 'returns nil' do
        expect(subject.call('hoge@example.com')).to be_nil
      end
    end
  end

  context 'with a legitimate webfinger redirection' do
    before do
      webfinger = { subject: 'acct:foo@ap.example.com', links: [{ rel: 'self', href: 'https://ap.example.com/users/foo', type: 'application/activity+json' }] }
      stub_request(:get, 'https://redirected.example.com/.well-known/webfinger?resource=acct:Foo@redirected.example.com').to_return(body: Oj.dump(webfinger), headers: { 'Content-Type': 'application/jrd+json' })
    end

    it 'returns new remote account' do
      account = subject.call('Foo@redirected.example.com')

      expect(account.activitypub?).to be true
      expect(account.acct).to eq 'foo@ap.example.com'
      expect(account.inbox_url).to eq 'https://ap.example.com/users/foo/inbox'
    end
  end

  context 'with a misconfigured redirection' do
    before do
      webfinger = { subject: 'acct:Foo@redirected.example.com', links: [{ rel: 'self', href: 'https://ap.example.com/users/foo', type: 'application/activity+json' }] }
      stub_request(:get, 'https://redirected.example.com/.well-known/webfinger?resource=acct:Foo@redirected.example.com').to_return(body: Oj.dump(webfinger), headers: { 'Content-Type': 'application/jrd+json' })
    end

    it 'returns new remote account' do
      account = subject.call('Foo@redirected.example.com')

      expect(account.activitypub?).to be true
      expect(account.acct).to eq 'foo@ap.example.com'
      expect(account.inbox_url).to eq 'https://ap.example.com/users/foo/inbox'
    end
  end

  context 'with too many webfinger redirections' do
    before do
      webfinger = { subject: 'acct:foo@evil.example.com', links: [{ rel: 'self', href: 'https://ap.example.com/users/foo', type: 'application/activity+json' }] }
      stub_request(:get, 'https://redirected.example.com/.well-known/webfinger?resource=acct:Foo@redirected.example.com').to_return(body: Oj.dump(webfinger), headers: { 'Content-Type': 'application/jrd+json' })
      webfinger2 = { subject: 'acct:foo@ap.example.com', links: [{ rel: 'self', href: 'https://ap.example.com/users/foo', type: 'application/activity+json' }] }
      stub_request(:get, 'https://evil.example.com/.well-known/webfinger?resource=acct:foo@evil.example.com').to_return(body: Oj.dump(webfinger2), headers: { 'Content-Type': 'application/jrd+json' })
    end

    it 'does not return a new remote account' do
      expect(subject.call('Foo@redirected.example.com')).to be_nil
    end
  end

  context 'with webfinger response subject missing a host value' do
    let(:body) { Oj.dump({ subject: 'user@' }) }
    let(:url) { 'https://host.example/.well-known/webfinger?resource=acct:user@host.example' }

    before do
      stub_request(:get, url).to_return(status: 200, body: body)
    end

    it 'returns nil with incomplete subject in response' do
      expect(subject.call('user@host.example')).to be_nil
    end
  end

  context 'with an ActivityPub account' do
    it 'returns new remote account' do
      account = subject.call('foo@ap.example.com')

      expect(account.activitypub?).to be true
      expect(account.domain).to eq 'ap.example.com'
      expect(account.inbox_url).to eq 'https://ap.example.com/users/foo/inbox'
    end

    context 'with multiple types' do
      before do
        stub_request(:get, 'https://ap.example.com/users/foo').to_return(request_fixture('activitypub-actor-individual.txt'))
      end

      it 'returns new remote account' do
        account = subject.call('foo@ap.example.com')

        expect(account.activitypub?).to be true
        expect(account.domain).to eq 'ap.example.com'
        expect(account.inbox_url).to eq 'https://ap.example.com/users/foo/inbox'
        expect(account.actor_type).to eq 'Person'
      end
    end
  end

  context 'with an already-known actor changing acct: URI' do
    let!(:duplicate) { Fabricate(:account, username: 'foo', domain: 'old.example.com', uri: 'https://ap.example.com/users/foo') }
    let!(:status)    { Fabricate(:status, account: duplicate, text: 'foo') }

    it 'returns new remote account' do
      account = subject.call('foo@ap.example.com')

      expect(account.activitypub?).to be true
      expect(account.domain).to eq 'ap.example.com'
      expect(account.inbox_url).to eq 'https://ap.example.com/users/foo/inbox'
      expect(account.uri).to eq 'https://ap.example.com/users/foo'
    end

    it 'merges accounts' do
      account = subject.call('foo@ap.example.com')

      expect(status.reload.account_id).to eq account.id
      expect(Account.where(uri: account.uri).count).to eq 1
    end
  end

  context 'with an already-known acct: URI changing ActivityPub id' do
    let!(:old_account) { Fabricate(:account, username: 'foo', domain: 'ap.example.com', uri: 'https://old.example.com/users/foo', last_webfingered_at: nil) }
    let!(:status) { Fabricate(:status, account: old_account, text: 'foo') }

    it 'returns new remote account' do
      account = subject.call('foo@ap.example.com')

      expect(account.activitypub?).to be true
      expect(account.domain).to eq 'ap.example.com'
      expect(account.inbox_url).to eq 'https://ap.example.com/users/foo/inbox'
      expect(account.uri).to eq 'https://ap.example.com/users/foo'
    end
  end

  it 'processes one remote account at a time using locks' do
    wait_for_start = true
    fail_occurred  = false
    return_values  = Concurrent::Array.new

    threads = Array.new(5) do
      Thread.new do
        true while wait_for_start

        begin
          return_values << described_class.new.call('foo@ap.example.com')
        rescue ActiveRecord::RecordNotUnique
          fail_occurred = true
        ensure
          RedisConfiguration.pool.checkin if Thread.current[:redis]
        end
      end
    end

    wait_for_start = false
    threads.each(&:join)

    expect(fail_occurred).to be false
    expect(return_values).to_not include(nil)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class FollowService < BaseService
  include Redisable
  include Payloadable
  include DomainControlHelper

  # Follow a remote user, notify remote user about the follow
  # @param [Account] source_account From which to follow
  # @param [Account] target_account Account to follow
  # @param [Hash] options
  # @option [Boolean] :reblogs Whether or not to show reblogs, defaults to true
  # @option [Boolean] :notify Whether to create notifications about new posts, defaults to false
  # @option [Array<String>] :languages Which languages to allow on the home feed from this account, defaults to all
  # @option [Boolean] :bypass_locked
  # @option [Boolean] :bypass_limit Allow following past the total follow number
  # @option [Boolean] :with_rate_limit
  def call(source_account, target_account, options = {})
    @source_account = source_account
    @target_account = target_account
    @options        = { bypass_locked: false, bypass_limit: false, with_rate_limit: false }.merge(options)

    raise ActiveRecord::RecordNotFound if following_not_possible?
    raise Mastodon::NotPermittedError  if following_not_allowed?

    if @source_account.following?(@target_account)
      return change_follow_options!
    elsif @source_account.requested?(@target_account)
      return change_follow_request_options!
    end

    ActivityTracker.increment('activity:interactions')

    # When an account follows someone for the first time, avoid showing
    # an empty home feed while the follow request is being processed
    # and the feeds are being merged
    mark_home_feed_as_partial! if @source_account.not_following_anyone?

    if (@target_account.locked? && !@options[:bypass_locked]) || @source_account.silenced? || @target_account.activitypub?
      request_follow!
    elsif @target_account.local?
      direct_follow!
    end
  end

  private

  def mark_home_feed_as_partial!
    redis.set(""account:#{@source_account.id}:regeneration"", true, nx: true, ex: 1.day.seconds)
  end

  def following_not_possible?
    @target_account.nil? || @target_account.id == @source_account.id || @target_account.unavailable?
  end

  def following_not_allowed?
    domain_not_allowed?(@target_account.domain) || @target_account.blocking?(@source_account) || @source_account.blocking?(@target_account) || @target_account.moved? || (!@target_account.local? && @target_account.ostatus?) || @source_account.domain_blocking?(@target_account.domain)
  end

  def change_follow_options!
    @source_account.follow!(@target_account, **follow_options)
  end

  def change_follow_request_options!
    @source_account.request_follow!(@target_account, **follow_options)
  end

  def request_follow!
    follow_request = @source_account.request_follow!(@target_account, **follow_options.merge(rate_limit: @options[:with_rate_limit], bypass_limit: @options[:bypass_limit]))

    if @target_account.local?
      LocalNotificationWorker.perform_async(@target_account.id, follow_request.id, follow_request.class.name, 'follow_request')
    elsif @target_account.activitypub?
      ActivityPub::DeliveryWorker.perform_async(build_json(follow_request), @source_account.id, @target_account.inbox_url, { 'bypass_availability' => true })
    end

    follow_request
  end

  def direct_follow!
    follow = @source_account.follow!(@target_account, **follow_options.merge(rate_limit: @options[:with_rate_limit], bypass_limit: @options[:bypass_limit]))

    LocalNotificationWorker.perform_async(@target_account.id, follow.id, follow.class.name, 'follow')
    MergeWorker.perform_async(@target_account.id, @source_account.id)

    follow
  end

  def build_json(follow_request)
    Oj.dump(serialize_payload(follow_request, ActivityPub::FollowSerializer))
  end

  def follow_options
    @options.slice(:reblogs, :notify, :languages)
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe FollowService, type: :service do
  subject { described_class.new }

  let(:sender) { Fabricate(:account, username: 'alice') }

  context 'when local account' do
    describe 'locked account' do
      let(:bob) { Fabricate(:account, locked: true, username: 'bob') }

      before do
        subject.call(sender, bob)
      end

      it 'creates a follow request with reblogs' do
        expect(FollowRequest.find_by(account: sender, target_account: bob, show_reblogs: true)).to_not be_nil
      end
    end

    describe 'locked account, no reblogs' do
      let(:bob) { Fabricate(:account, locked: true, username: 'bob') }

      before do
        subject.call(sender, bob, reblogs: false)
      end

      it 'creates a follow request without reblogs' do
        expect(FollowRequest.find_by(account: sender, target_account: bob, show_reblogs: false)).to_not be_nil
      end
    end

    describe 'unlocked account, from silenced account' do
      let(:bob) { Fabricate(:account, username: 'bob') }

      before do
        sender.touch(:silenced_at)
        subject.call(sender, bob)
      end

      it 'creates a follow request with reblogs' do
        expect(FollowRequest.find_by(account: sender, target_account: bob, show_reblogs: true)).to_not be_nil
      end
    end

    describe 'unlocked account, from a muted account' do
      let(:bob) { Fabricate(:account, username: 'bob') }

      before do
        bob.mute!(sender)
        subject.call(sender, bob)
      end

      it 'creates a following relation with reblogs' do
        expect(sender.following?(bob)).to be true
        expect(sender.muting_reblogs?(bob)).to be false
      end
    end

    describe 'unlocked account' do
      let(:bob) { Fabricate(:account, username: 'bob') }

      before do
        subject.call(sender, bob)
      end

      it 'creates a following relation with reblogs' do
        expect(sender.following?(bob)).to be true
        expect(sender.muting_reblogs?(bob)).to be false
      end
    end

    describe 'unlocked account, no reblogs' do
      let(:bob) { Fabricate(:account, username: 'bob') }

      before do
        subject.call(sender, bob, reblogs: false)
      end

      it 'creates a following relation without reblogs' do
        expect(sender.following?(bob)).to be true
        expect(sender.muting_reblogs?(bob)).to be true
      end
    end

    describe 'already followed account' do
      let(:bob) { Fabricate(:account, username: 'bob') }

      before do
        sender.follow!(bob)
        subject.call(sender, bob)
      end

      it 'keeps a following relation' do
        expect(sender.following?(bob)).to be true
      end
    end

    describe 'already followed account, turning reblogs off' do
      let(:bob) { Fabricate(:account, username: 'bob') }

      before do
        sender.follow!(bob, reblogs: true)
        subject.call(sender, bob, reblogs: false)
      end

      it 'disables reblogs' do
        expect(sender.muting_reblogs?(bob)).to be true
      end
    end

    describe 'already followed account, turning reblogs on' do
      let(:bob) { Fabricate(:account, username: 'bob') }

      before do
        sender.follow!(bob, reblogs: false)
        subject.call(sender, bob, reblogs: true)
      end

      it 'disables reblogs' do
        expect(sender.muting_reblogs?(bob)).to be false
      end
    end

    describe 'already followed account, changing languages' do
      let(:bob) { Fabricate(:account, username: 'bob') }

      before do
        sender.follow!(bob)
        subject.call(sender, bob, languages: %w(en es))
      end

      it 'changes languages' do
        expect(Follow.find_by(account: sender, target_account: bob)&.languages).to match_array %w(en es)
      end
    end
  end

  context 'when remote ActivityPub account' do
    let(:bob) { Fabricate(:account, username: 'bob', domain: 'example.com', protocol: :activitypub, inbox_url: 'http://example.com/inbox') }

    before do
      stub_request(:post, 'http://example.com/inbox').to_return(status: 200, body: '', headers: {})
      subject.call(sender, bob)
    end

    it 'creates follow request' do
      expect(FollowRequest.find_by(account: sender, target_account: bob)).to_not be_nil
    end

    it 'sends a follow activity to the inbox' 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 DeleteAccountService < BaseService
  include Payloadable

  ASSOCIATIONS_ON_SUSPEND = %w(
    account_notes
    account_pins
    active_relationships
    aliases
    block_relationships
    blocked_by_relationships
    conversation_mutes
    conversations
    custom_filters
    devices
    domain_blocks
    featured_tags
    follow_requests
    list_accounts
    migrations
    mute_relationships
    muted_by_relationships
    notifications
    owned_lists
    passive_relationships
    report_notes
    scheduled_statuses
    status_pins
  ).freeze

  # The following associations have no important side-effects
  # in callbacks and all of their own associations are secured
  # by foreign keys, making them safe to delete without loading
  # into memory
  ASSOCIATIONS_WITHOUT_SIDE_EFFECTS = %w(
    account_notes
    account_pins
    aliases
    conversation_mutes
    conversations
    custom_filters
    devices
    domain_blocks
    featured_tags
    follow_requests
    list_accounts
    migrations
    mute_relationships
    muted_by_relationships
    notifications
    owned_lists
    scheduled_statuses
    status_pins
  )

  ASSOCIATIONS_ON_DESTROY = %w(
    reports
    targeted_moderation_notes
    targeted_reports
  ).freeze

  # Suspend or remove an account and remove as much of its data
  # as possible. If it's a local account and it has not been confirmed
  # or never been approved, then side effects are skipped and both
  # the user and account records are removed fully. Otherwise,
  # it is controlled by options.
  # @param [Account]
  # @param [Hash] options
  # @option [Boolean] :reserve_email Keep user record. Only applicable for local accounts
  # @option [Boolean] :reserve_username Keep account record
  # @option [Boolean] :skip_side_effects Side effects are ActivityPub and streaming API payloads
  # @option [Boolean] :skip_activitypub Skip sending ActivityPub payloads. Implied by :skip_side_effects
  # @option [Time]    :suspended_at Only applicable when :reserve_username is true
  def call(account, **options)
    @account = account
    @options = { reserve_username: true, reserve_email: true }.merge(options)

    if @account.local? && @account.user_unconfirmed_or_pending?
      @options[:reserve_email]     = false
      @options[:reserve_username]  = false
      @options[:skip_side_effects] = true
    end

    @options[:skip_activitypub] = true if @options[:skip_side_effects]

    distribute_activities!
    purge_content!
    fulfill_deletion_request!
  end

  private

  def distribute_activities!
    return if skip_activitypub?

    if @account.local?
      delete_actor!
    elsif @account.activitypub?
      reject_follows!
      undo_follows!
    end
  end

  def reject_follows!
    # When deleting a remote account, the account obviously doesn't
    # actually become deleted on its origin server, i.e. unlike a
    # locally deleted 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.

    ActivityPub::DeliveryWorker.push_bulk(Follow.where(account: @account)) do |follow|
      [Oj.dump(serialize_payload(follow, ActivityPub::RejectFollowSerializer)), follow.target_account_id, @account.inbox_url]
    end
  end

  def undo_follows!
    # When deleting a remote account, the account obviously doesn't
    # actually become deleted on its origin server, but following relationships
    # are severed on our end. Therefore, make the remote server aware that the
    # follow relationships are severed to avoid confusion and potential issues
    # if the remote account gets un-suspended.

    ActivityPub::DeliveryWorker.push_bulk(Follow.where(target_account: @account)) do |follow|
      [Oj.dump(serialize_payload(follow, ActivityPub::UndoFollowSerializer)), follow.account_id, @account.inbox_url]
    end
  end

  def purge_user!
    return if !@account.local? || @account.user.nil?

    if keep_user_record?
      @account.user.disable!
      @account.user.invites.where(uses: 0).destroy_all
    else
      @account.user.destroy
    end
  end

  def purge_content!
    purge_user!
    purge_profile!
    purge_statuses!
    purge_mentions!
    purge_media_attachments!
    purge_polls!
    purge_generated_notifications!
    purge_favourites!
    purge_bookmarks!
    purge_feeds!
    purge_other_associations!

    @account.destroy unless keep_account_record?
  end

  def purge_statuses!
    @account.statuses.reorder(nil).where.not(id: reported_status_ids).in_batches do |statuses|
      BatchedRemoveStatusService.new.call(statuses, skip_side_effects: skip_side_effects?)
    end
  end

  def purge_mentions!
    @account.mentions.reorder(nil).where.not(status_id: reported_status_ids).in_batches.delete_all
  end

  def purge_media_attachments!
    @account.media_attachments.find_each do |media_attachment|
      next if keep_account_record? && reported_status_ids.include?(media_attachment.status_id)

      media_attachment.destroy
    end
  end

  def purge_polls!
    @account.polls.reorder(nil).where.not(status_id: reported_status_ids).in_batches.delete_all
  end

  def purge_generated_notifications!
    # By deleting polls and statuses without callbacks, we've left behind
    # polymorphically associated notifications generated by this account

    Notification.where(from_account: @account).in_batches.delete_all
  end

  def purge_favourites!
    @account.favourites.in_batches do |favourites|
      ids = favourites.pluck(:status_id)
      StatusStat.where(status_id: ids).update_all('favourites_count = GREATEST(0, favourites_count - 1)')
      Chewy.strategy.current.update(StatusesIndex, ids) if Chewy.enabled?
      Rails.cache.delete_multi(ids.map { |id| ""statuses/#{id}"" })
      favourites.delete_all
    end
  end

  def purge_bookmarks!
    @account.bookmarks.in_batches do |bookmarks|
      Chewy.strategy.current.update(StatusesIndex, bookmarks.pluck(:status_id)) if Chewy.enabled?
      bookmarks.delete_all
    end
  end

  def purge_other_associations!
    associations_for_destruction.each do |association_name|
      purge_association(association_name)
    end
  end

  def purge_feeds!
    return unless @account.local?

    FeedManager.instance.clean_feeds!(:home, [@account.id])
    FeedManager.instance.clean_feeds!(:list, @account.owned_lists.pluck(:id))
  end

  def purge_profile!
    # If the account is going to be destroyed
    # there is no point wasting time updating
    # its values first

    return unless keep_account_record?

    @account.silenced_at         = nil
    @account.suspended_at        = @options[:suspended_at] || Time.now.utc
    @account.suspension_origin   = :local
    @account.locked              = false
    @account.memorial            = false
    @account.discoverable        = false
    @account.trendable           = false
    @account.display_name        = ''
    @account.note                = ''
    @account.fields              = []
    @account.statuses_count      = 0
    @account.followers_count     = 0
    @account.following_count     = 0
    @account.moved_to_account    = nil
    @account.reviewed_at         = nil
    @account.requested_review_at = nil
    @account.also_known_as       = []
    @account.avatar.destroy
    @account.header.destroy
    @account.save!
  end

  def fulfill_deletion_request!
    @account.deletion_request&.destroy
  end

  def purge_association(association_name)
    association = @account.public_send(association_name)

    if ASSOCIATIONS_WITHOUT_SIDE_EFFECTS.include?(association_name)
      association.in_batches.delete_all
    else
      association.in_batches.destroy_all
    end
  end

  def delete_actor!
    ActivityPub::DeliveryWorker.push_bulk(delivery_inboxes, limit: 1_000) do |inbox_url|
      [delete_actor_json, @account.id, inbox_url]
    end

    ActivityPub::LowPriorityDeliveryWorker.push_bulk(low_priority_delivery_inboxes, limit: 1_000) do |inbox_url|
      [delete_actor_json, @account.id, inbox_url]
    end
  end

  def delete_actor_json
    @delete_actor_json ||= Oj.dump(serialize_payload(@account, ActivityPub::DeleteActorSerializer, signer: @account, always_sign: true))
  end

  def delivery_inboxes
    @delivery_inboxes ||= @account.followers.inboxes + Relay.enabled.pluck(:inbox_url)
  end

  def low_priority_delivery_inboxes
    Account.inboxes - delivery_inboxes
  end

  def reported_status_ids
    @reported_status_ids ||= Report.where(target_account: @account).unresolved.pluck(:status_ids).flatten.uniq
  end

  def associations_for_destruction
    if keep_account_record?
      ASSOCIATIONS_ON_SUSPEND
    else
      ASSOCIATIONS_ON_SUSPEND + ASSOCIATIONS_ON_DESTROY
    end
  end

  def keep_user_record?
    @options[:reserve_email]
  end

  def keep_account_record?
    @options[:reserve_username]
  end

  def skip_side_effects?
    @options[:skip_side_effects]
  end

  def skip_activitypub?
    @options[:skip_activitypub]
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe DeleteAccountService, type: :service do
  shared_examples 'common behavior' do
    subject { described_class.new.call(account) }

    let!(:status) { Fabricate(:status, account: account) }
    let!(:mention) { Fabricate(:mention, account: local_follower) }
    let!(:status_with_mention) { Fabricate(:status, account: account, mentions: [mention]) }
    let!(:media_attachment) { Fabricate(:media_attachment, account: account) }
    let!(:notification) { Fabricate(:notification, account: account) }
    let!(:favourite) { Fabricate(:favourite, account: account, status: Fabricate(:status, account: local_follower)) }
    let!(:poll) { Fabricate(:poll, account: account) }
    let!(:poll_vote) { Fabricate(:poll_vote, account: local_follower, poll: poll) }

    let!(:active_relationship) { Fabricate(:follow, account: account, target_account: local_follower) }
    let!(:passive_relationship) { Fabricate(:follow, account: local_follower, target_account: account) }
    let!(:endorsement) { Fabricate(:account_pin, account: local_follower, target_account: account) }

    let!(:mention_notification) { Fabricate(:notification, account: local_follower, activity: mention, type: :mention) }
    let!(:status_notification) { Fabricate(:notification, account: local_follower, activity: status, type: :status) }
    let!(:poll_notification) { Fabricate(:notification, account: local_follower, activity: poll, type: :poll) }
    let!(:favourite_notification) { Fabricate(:notification, account: local_follower, activity: favourite, type: :favourite) }
    let!(:follow_notification) { Fabricate(:notification, account: local_follower, activity: active_relationship, type: :follow) }

    let!(:account_note) { Fabricate(:account_note, account: account) }

    it 'deletes associated owned records' do
      expect { subject }.to change {
        [
          account.statuses,
          account.media_attachments,
          account.notifications,
          account.favourites,
          account.active_relationships,
          account.passive_relationships,
          account.polls,
          account.account_notes,
        ].map(&:count)
      }.from([2, 1, 1, 1, 1, 1, 1, 1]).to([0, 0, 0, 0, 0, 0, 0, 0])
    end

    it 'deletes associated target records' do
      expect { subject }.to change {
        [
          AccountPin.where(target_account: account),
        ].map(&:count)
      }.from([1]).to([0])
    end

    it 'deletes associated target notifications' do
      expect { subject }.to change {
        %w(
          poll favourite status mention follow
        ).map { |type| Notification.where(type: type).count }
      }.from([1, 1, 1, 1, 1]).to([0, 0, 0, 0, 0])
    end
  end

  describe '#call on local account' do
    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

    let!(:remote_alice) { Fabricate(:account, inbox_url: 'https://alice.com/inbox', domain: 'alice.com', protocol: :activitypub) }
    let!(:remote_bob) { Fabricate(:account, inbox_url: 'https://bob.com/inbox', domain: 'bob.com', protocol: :activitypub) }

    include_examples 'common behavior' do
      let!(:account) { Fabricate(:account) }
      let!(:local_follower) { Fabricate(:account) }

      it 'sends a delete actor activity to all known inboxes' do
        subject
        expect(a_request(:post, 'https://alice.com/inbox')).to have_been_made.once
        expect(a_request(:post, 'https://bob.com/inbox')).to have_been_made.once
      end
    end
  end

  describe '#call on remote account' do
    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, inbox_url: 'https://bob.com/inbox', protocol: :activitypub, domain: 'bob.com') }
      let!(:local_follower) { Fabricate(:account) }

      it 'sends expected activities to followed and follower inboxes' do
        subject

        expect(a_request(:post, account.inbox_url).with(
                 body:
                   hash_including({
                     'type' => 'Reject',
                     'object' => hash_including({
                       'type' => 'Follow',
                       'actor' => account.uri,
                       'object' => ActivityPub::TagManager.instance.uri_for(local_follower),
                     }),
                   })
               )).to have_been_made.once

        expect(a_request(:post, account.inbox_url).with(
                 body: hash_including({
                   'type' => 'Undo',
                   'object' => hash_including({
                     'type' => 'Follow',
                     'actor' => ActivityPub::TagManager.instance.uri_for(local_follower),
                     'object' => account.uri,
                   }),
                 })
               )).to have_been_made.once
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class RemoveStatusService < BaseService
  include Redisable
  include Payloadable
  include Lockable

  # Delete a status
  # @param   [Status] status
  # @param   [Hash] options
  # @option  [Boolean] :redraft
  # @option  [Boolean] :immediate
  # @option  [Boolean] :preserve
  # @option  [Boolean] :original_removed
  # @option  [Boolean] :skip_streaming
  def call(status, **options)
    @payload  = Oj.dump(event: :delete, payload: status.id.to_s)
    @status   = status
    @account  = status.account
    @options  = options

    with_redis_lock(""distribute:#{@status.id}"") do
      @status.discard_with_reblogs

      StatusPin.find_by(status: @status)&.destroy

      remove_from_self if @account.local?
      remove_from_followers
      remove_from_lists

      # There is no reason to send out Undo activities when the
      # cause is that the original object has been removed, since
      # original object being removed implicitly removes reblogs
      # of it. The Delete activity of the original is forwarded
      # separately.
      remove_from_remote_reach if @account.local? && !@options[:original_removed]

      # Since reblogs don't mention anyone, don't get reblogged,
      # favourited and don't contain their own media attachments
      # or hashtags, this can be skipped
      unless @status.reblog?
        remove_from_mentions
        remove_reblogs
        remove_from_hashtags
        remove_from_public
        remove_from_media if @status.with_media?
        remove_media
      end

      @status.destroy! if permanently?
    end
  end

  private

  # The following FeedManager calls all do not result in redis publishes for
  # streaming, as the `:update` option is false

  def remove_from_self
    FeedManager.instance.unpush_from_home(@account, @status)
  end

  def remove_from_followers
    @account.followers_for_local_distribution.includes(:user).reorder(nil).find_each do |follower|
      FeedManager.instance.unpush_from_home(follower, @status)
    end
  end

  def remove_from_lists
    @account.lists_for_local_distribution.select(:id, :account_id).includes(account: :user).reorder(nil).find_each do |list|
      FeedManager.instance.unpush_from_list(list, @status)
    end
  end

  def remove_from_mentions
    # For limited visibility statuses, the mentions that determine
    # who receives them in their home feed are a subset of followers
    # and therefore the delete is already handled by sending it to all
    # followers. Here we send a delete to actively mentioned accounts
    # that may not follow the account

    return if skip_streaming?

    @status.active_mentions.find_each do |mention|
      redis.publish(""timeline:#{mention.account_id}"", @payload)
    end
  end

  def remove_from_remote_reach
    # Followers, relays, people who got mentioned in the status,
    # or who reblogged it from someone else might not follow
    # the author and wouldn't normally receive the delete
    # notification - so here, we explicitly send it to them

    status_reach_finder = StatusReachFinder.new(@status, unsafe: true)

    ActivityPub::DeliveryWorker.push_bulk(status_reach_finder.inboxes, limit: 1_000) do |inbox_url|
      [signed_activity_json, @account.id, inbox_url]
    end
  end

  def signed_activity_json
    @signed_activity_json ||= Oj.dump(serialize_payload(@status, @status.reblog? ? ActivityPub::UndoAnnounceSerializer : ActivityPub::DeleteSerializer, signer: @account, always_sign: true))
  end

  def remove_reblogs
    # We delete reblogs of the status before the original status,
    # because once original status is gone, reblogs will disappear
    # without us being able to do all the fancy stuff

    @status.reblogs.rewhere(deleted_at: [nil, @status.deleted_at]).includes(:account).reorder(nil).find_each do |reblog|
      RemoveStatusService.new.call(reblog, original_removed: true, skip_streaming: skip_streaming?)
    end
  end

  def remove_from_hashtags
    @account.featured_tags.where(tag_id: @status.tags.map(&:id)).find_each do |featured_tag|
      featured_tag.decrement(@status.id)
    end

    return unless @status.public_visibility?

    return if skip_streaming?

    @status.tags.map(&:name).each do |hashtag|
      redis.publish(""timeline:hashtag:#{hashtag.mb_chars.downcase}"", @payload)
      redis.publish(""timeline:hashtag:#{hashtag.mb_chars.downcase}:local"", @payload) if @status.local?
    end
  end

  def remove_from_public
    return unless @status.public_visibility?

    return if skip_streaming?

    redis.publish('timeline:public', @payload)
    redis.publish(@status.local? ? 'timeline:public:local' : 'timeline:public:remote', @payload)
  end

  def remove_from_media
    return unless @status.public_visibility?

    return if skip_streaming?

    redis.publish('timeline:public:media', @payload)
    redis.publish(@status.local? ? 'timeline:public:local:media' : 'timeline:public:remote:media', @payload)
  end

  def remove_media
    return if @options[:redraft] || !permanently?

    @status.media_attachments.destroy_all
  end

  def permanently?
    @options[:immediate] || !(@options[:preserve] || @status.reported?)
  end

  def skip_streaming?
    !!@options[:skip_streaming]
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe RemoveStatusService, type: :service do
  subject { described_class.new }

  let!(:alice)  { Fabricate(:account) }
  let!(:bob)    { Fabricate(:account, username: 'bob', domain: 'example.com') }
  let!(:jeff)   { Fabricate(:account) }
  let!(:hank)   { Fabricate(:account, username: 'hank', protocol: :activitypub, domain: 'example.com', inbox_url: 'http://example.com/inbox') }
  let!(:bill)   { Fabricate(:account, username: 'bill', protocol: :activitypub, domain: 'example2.com', inbox_url: 'http://example2.com/inbox') }

  before do
    stub_request(:post, 'http://example.com/inbox').to_return(status: 200)
    stub_request(:post, 'http://example2.com/inbox').to_return(status: 200)

    jeff.follow!(alice)
    hank.follow!(alice)
  end

  context 'when removed status is not a reblog' do
    let!(:status) { PostStatusService.new.call(alice, text: 'Hello @bob@example.com ThisIsASecret') }

    before do
      FavouriteService.new.call(jeff, status)
      Fabricate(:status, account: bill, reblog: status, uri: 'hoge')
    end

    it 'removes status from author\'s home feed' do
      subject.call(status)
      expect(HomeFeed.new(alice).get(10).pluck(:id)).to_not include(status.id)
    end

    it 'removes status from local follower\'s home feed' do
      subject.call(status)
      expect(HomeFeed.new(jeff).get(10).pluck(:id)).to_not include(status.id)
    end

    it 'sends Delete activity to followers' do
      subject.call(status)
      expect(a_request(:post, 'http://example.com/inbox').with(
               body: hash_including({
                 'type' => 'Delete',
                 'object' => {
                   'type' => 'Tombstone',
                   'id' => ActivityPub::TagManager.instance.uri_for(status),
                   'atomUri' => OStatus::TagManager.instance.uri_for(status),
                 },
               })
             )).to have_been_made.once
    end

    it 'sends Delete activity to rebloggers' do
      subject.call(status)
      expect(a_request(:post, 'http://example2.com/inbox').with(
               body: hash_including({
                 'type' => 'Delete',
                 'object' => {
                   'type' => 'Tombstone',
                   'id' => ActivityPub::TagManager.instance.uri_for(status),
                   'atomUri' => OStatus::TagManager.instance.uri_for(status),
                 },
               })
             )).to have_been_made.once
    end

    it 'remove status from notifications' do
      expect { subject.call(status) }.to change {
        Notification.where(activity_type: 'Favourite', from_account: jeff, account: alice).count
      }.from(1).to(0)
    end
  end

  context 'when removed status is a private self-reblog' do
    let!(:original_status) { Fabricate(:status, account: alice, text: 'Hello ThisIsASecret', visibility: :private) }
    let!(:status) { ReblogService.new.call(alice, original_status) }

    it 'sends Undo activity to followers' do
      subject.call(status)
      expect(a_request(:post, 'http://example.com/inbox').with(
               body: hash_including({
                 'type' => 'Undo',
                 'object' => hash_including({
                   'type' => 'Announce',
                   'object' => ActivityPub::TagManager.instance.uri_for(original_status),
                 }),
               })
             )).to have_been_made.once
    end
  end

  context 'when removed status is public self-reblog' do
    let!(:original_status) { Fabricate(:status, account: alice, text: 'Hello ThisIsASecret', visibility: :public) }
    let!(:status) { ReblogService.new.call(alice, original_status) }

    it 'sends Undo activity to followers' do
      subject.call(status)
      expect(a_request(:post, 'http://example.com/inbox').with(
               body: hash_including({
                 'type' => 'Undo',
                 'object' => hash_including({
                   'type' => 'Announce',
                   'object' => ActivityPub::TagManager.instance.uri_for(original_status),
                 }),
               })
             )).to have_been_made.once
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class BulkImportRowService
  def call(row)
    @account = row.bulk_import.account
    @data    = row.data
    @type    = row.bulk_import.type.to_sym

    case @type
    when :following, :blocking, :muting, :lists
      target_acct     = @data['acct']
      target_domain   = domain(target_acct)
      @target_account = stoplight_wrap_request(target_domain) { ResolveAccountService.new.call(target_acct, { check_delivery_availability: true }) }
      return false if @target_account.nil?
    when :bookmarks
      target_uri      = @data['uri']
      target_domain   = Addressable::URI.parse(target_uri).normalized_host
      @target_status = ActivityPub::TagManager.instance.uri_to_resource(target_uri, Status)
      return false if @target_status.nil? && ActivityPub::TagManager.instance.local_uri?(target_uri)

      @target_status ||= stoplight_wrap_request(target_domain) { ActivityPub::FetchRemoteStatusService.new.call(target_uri) }
      return false if @target_status.nil?
    end

    case @type
    when :following
      FollowService.new.call(@account, @target_account, reblogs: @data['show_reblogs'], notify: @data['notify'], languages: @data['languages'])
    when :blocking
      BlockService.new.call(@account, @target_account)
    when :muting
      MuteService.new.call(@account, @target_account, notifications: @data['hide_notifications'])
    when :bookmarks
      return false unless StatusPolicy.new(@account, @target_status).show?

      @account.bookmarks.find_or_create_by!(status: @target_status)
    when :lists
      list = @account.owned_lists.find_or_create_by!(title: @data['list_name'])

      FollowService.new.call(@account, @target_account) unless @account.id == @target_account.id

      list.accounts << @target_account
    end

    true
  rescue ActiveRecord::RecordNotFound
    false
  end

  def domain(uri)
    domain = uri.is_a?(Account) ? uri.domain : uri.split('@')[1]
    TagManager.instance.local_domain?(domain) ? nil : TagManager.instance.normalize_domain(domain)
  end

  def stoplight_wrap_request(domain, &block)
    if domain.present?
      Stoplight(""source:#{domain}"", &block)
        .with_fallback { nil }
        .with_threshold(1)
        .with_cool_off_time(5.minutes.seconds)
        .with_error_handler { |error, handle| error.is_a?(HTTP::Error) || error.is_a?(OpenSSL::SSL::SSLError) ? handle.call(error) : raise(error) }
        .run
    else
      yield
    end
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe BulkImportRowService do
  subject { described_class.new }

  let(:account)    { Fabricate(:account) }
  let(:import)     { Fabricate(:bulk_import, account: account, type: import_type) }
  let(:import_row) { Fabricate(:bulk_import_row, bulk_import: import, data: data) }

  describe '#call' do
    context 'when importing a follow' do
      let(:import_type)    { 'following' }
      let(:target_account) { Fabricate(:account) }
      let(:service_double) { instance_double(FollowService, call: nil) }
      let(:data) do
        { 'acct' => target_account.acct }
      end

      before do
        allow(FollowService).to receive(:new).and_return(service_double)
      end

      it 'calls FollowService with the expected arguments and returns true' do
        expect(subject.call(import_row)).to be true

        expect(service_double).to have_received(:call).with(account, target_account, { reblogs: nil, notify: nil, languages: nil })
      end
    end

    context 'when importing a block' do
      let(:import_type)    { 'blocking' }
      let(:target_account) { Fabricate(:account) }
      let(:service_double) { instance_double(BlockService, call: nil) }
      let(:data) do
        { 'acct' => target_account.acct }
      end

      before do
        allow(BlockService).to receive(:new).and_return(service_double)
      end

      it 'calls BlockService with the expected arguments and returns true' do
        expect(subject.call(import_row)).to be true

        expect(service_double).to have_received(:call).with(account, target_account)
      end
    end

    context 'when importing a mute' do
      let(:import_type)    { 'muting' }
      let(:target_account) { Fabricate(:account) }
      let(:service_double) { instance_double(MuteService, call: nil) }
      let(:data) do
        { 'acct' => target_account.acct }
      end

      before do
        allow(MuteService).to receive(:new).and_return(service_double)
      end

      it 'calls MuteService with the expected arguments and returns true' do
        expect(subject.call(import_row)).to be true

        expect(service_double).to have_received(:call).with(account, target_account, { notifications: nil })
      end
    end

    context 'when importing a bookmark' do
      let(:import_type) { 'bookmarks' }
      let(:data) do
        { 'uri' => ActivityPub::TagManager.instance.uri_for(target_status) }
      end

      context 'when the status is public' do
        let(:target_status) { Fabricate(:status) }

        it 'bookmarks the status and returns true' do
          expect(subject.call(import_row)).to be true
          expect(account.bookmarked?(target_status)).to be true
        end
      end

      context 'when the status is not accessible to the user' do
        let(:target_status) { Fabricate(:status, visibility: :direct) }

        it 'does not bookmark the status and returns false' do
          expect(subject.call(import_row)).to be false
          expect(account.bookmarked?(target_status)).to be false
        end
      end
    end

    context 'when importing a list row' do
      let(:import_type) { 'lists' }
      let(:target_account) { Fabricate(:account) }
      let(:data) do
        { 'acct' => target_account.acct, 'list_name' => 'my list' }
      end

      shared_examples 'common behavior' do
        context 'when the target account is already followed' do
          before do
            account.follow!(target_account)
          end

          it 'returns true' do
            expect(subject.call(import_row)).to be true
          end

          it 'adds the target account to the list' do
            expect { subject.call(import_row) }.to change { ListAccount.joins(:list).exists?(account_id: target_account.id, list: { title: 'my list' }) }.from(false).to(true)
          end
        end

        context 'when the user already requested to follow the target account' do
          before do
            account.request_follow!(target_account)
          end

          it 'returns true' do
            expect(subject.call(import_row)).to be true
          end

          it 'adds the target account to the list' do
            expect { subject.call(import_row) }.to change { ListAccount.joins(:list).exists?(account_id: target_account.id, list: { title: 'my list' }) }.from(false).to(true)
          end
        end

        context 'when the target account is neither followed nor requested' do
          it 'returns true' do
            expect(subject.call(import_row)).to be true
          end

          it 'adds the target account to the list' do
            expect { subject.call(import_row) }.to change { ListAccount.joins(:list).exists?(account_id: target_account.id, list: { title: 'my list' }) }.from(false).to(true)
          end
        end

        context 'when the target account is the user themself' do
          let(:target_account) { account }

          it 'returns true' do
            expect(subject.call(import_row)).to be true
          end

          it 'adds the target account to the list' do
            expect { subject.call(import_row) }.to change { ListAccount.joins(:list).exists?(account_id: target_account.id, list: { title: 'my list' }) }.from(false).to(true)
          end
        end
      end

      context 'when the list does not exist yet' do
        include_examples 'common behavior'
      end

      context 'when the list exists' do
        before do
          Fabricate(:list, account: account, title: 'my list')
        end

        include_examples 'common behavior'

        it 'does not create a new list' do
          account.follow!(target_account)

          expect { subject.call(import_row) }.to_not(change { List.where(title: 'my list').count })
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class ActivityPub::FetchRemoteKeyService < BaseService
  include JsonLdHelper

  class Error < StandardError; end

  # Returns actor that owns the key
  def call(uri, id: true, prefetched_body: nil, suppress_errors: true)
    raise Error, 'No key URI given' if uri.blank?

    if prefetched_body.nil?
      if id
        @json = fetch_resource_without_id_validation(uri)
        if actor_type?
          @json = fetch_resource(@json['id'], true)
        elsif uri != @json['id']
          raise Error, ""Fetched URI #{uri} has wrong id #{@json['id']}""
        end
      else
        @json = fetch_resource(uri, id)
      end
    else
      @json = body_to_json(prefetched_body, compare_id: id ? uri : nil)
    end

    raise Error, ""Unable to fetch key JSON at #{uri}"" if @json.nil?
    raise Error, ""Unsupported JSON-LD context for document #{uri}"" unless supported_context?(@json)
    raise Error, ""Unexpected object type for key #{uri}"" unless expected_type?
    return find_actor(@json['id'], @json, suppress_errors) if actor_type?

    @owner = fetch_resource(owner_uri, true)

    raise Error, ""Unable to fetch actor JSON #{owner_uri}"" if @owner.nil?
    raise Error, ""Unsupported JSON-LD context for document #{owner_uri}"" unless supported_context?(@owner)
    raise Error, ""Unexpected object type for actor #{owner_uri} (expected any of: #{SUPPORTED_TYPES})"" unless expected_owner_type?
    raise Error, ""publicKey id for #{owner_uri} does not correspond to #{@json['id']}"" unless confirmed_owner?

    find_actor(owner_uri, @owner, suppress_errors)
  rescue Error => e
    Rails.logger.debug { ""Fetching key #{uri} failed: #{e.message}"" }
    raise unless suppress_errors
  end

  private

  def find_actor(uri, prefetched_body, suppress_errors)
    actor   = ActivityPub::TagManager.instance.uri_to_actor(uri)
    actor ||= ActivityPub::FetchRemoteActorService.new.call(uri, prefetched_body: prefetched_body, suppress_errors: suppress_errors)
    actor
  end

  def expected_type?
    actor_type? || public_key?
  end

  def actor_type?
    equals_or_includes_any?(@json['type'], ActivityPub::FetchRemoteActorService::SUPPORTED_TYPES)
  end

  def public_key?
    @json['publicKeyPem'].present? && @json['owner'].present?
  end

  def owner_uri
    @owner_uri ||= value_or_id(@json['owner'])
  end

  def expected_owner_type?
    equals_or_includes_any?(@owner['type'], ActivityPub::FetchRemoteActorService::SUPPORTED_TYPES)
  end

  def confirmed_owner?
    value_or_id(@owner['publicKey']) == @json['id']
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe ActivityPub::FetchRemoteKeyService, type: :service do
  subject { described_class.new }

  let(:webfinger) { { subject: 'acct:alice@example.com', links: [{ rel: 'self', href: 'https://example.com/alice' }] } }

  let(:public_key_pem) do
    <<~TEXT
      -----BEGIN PUBLIC KEY-----
      MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAu3L4vnpNLzVH31MeWI39
      4F0wKeJFsLDAsNXGeOu0QF2x+h1zLWZw/agqD2R3JPU9/kaDJGPIV2Sn5zLyUA9S
      6swCCMOtn7BBR9g9sucgXJmUFB0tACH2QSgHywMAybGfmSb3LsEMNKsGJ9VsvYoh
      8lDET6X4Pyw+ZJU0/OLo/41q9w+OrGtlsTm/PuPIeXnxa6BLqnDaxC+4IcjG/FiP
      ahNCTINl/1F/TgSSDZ4Taf4U9XFEIFw8wmgploELozzIzKq+t8nhQYkgAkt64euW
      pva3qL5KD1mTIZQEP+LZvh3s2WHrLi3fhbdRuwQ2c0KkJA2oSTFPDpqqbPGZ3Qvu
      HQIDAQAB
      -----END PUBLIC KEY-----
    TEXT
  end

  let(:public_key_id) { 'https://example.com/alice#main-key' }

  let(:key_json) do
    {
      id: public_key_id,
      owner: 'https://example.com/alice',
      publicKeyPem: public_key_pem,
    }
  end

  let(:actor_public_key) { key_json }

  let(:actor) do
    {
      '@context': [
        'https://www.w3.org/ns/activitystreams',
        'https://w3id.org/security/v1',
      ],
      id: 'https://example.com/alice',
      type: 'Person',
      preferredUsername: 'alice',
      name: 'Alice',
      summary: 'Foo bar',
      inbox: 'http://example.com/alice/inbox',
      publicKey: actor_public_key,
    }
  end

  before do
    stub_request(:get, 'https://example.com/alice').to_return(body: Oj.dump(actor))
    stub_request(:get, 'https://example.com/.well-known/webfinger?resource=acct:alice@example.com').to_return(body: Oj.dump(webfinger), headers: { 'Content-Type': 'application/jrd+json' })
  end

  describe '#call' do
    let(:account) { subject.call(public_key_id, id: false) }

    context 'when the key is a sub-object from the actor' do
      before do
        stub_request(:get, public_key_id).to_return(body: Oj.dump(actor))
      end

      it 'returns the expected account' do
        expect(account.uri).to eq 'https://example.com/alice'
      end
    end

    context 'when the key is a separate document' do
      let(:public_key_id) { 'https://example.com/alice-public-key.json' }

      before do
        stub_request(:get, public_key_id).to_return(body: Oj.dump(key_json.merge({ '@context': ['https://www.w3.org/ns/activitystreams', 'https://w3id.org/security/v1'] })))
      end

      it 'returns the expected account' do
        expect(account.uri).to eq 'https://example.com/alice'
      end
    end

    context 'when the key and owner do not match' do
      let(:public_key_id) { 'https://example.com/fake-public-key.json' }
      let(:actor_public_key) { 'https://example.com/alice-public-key.json' }

      before do
        stub_request(:get, public_key_id).to_return(body: Oj.dump(key_json.merge({ '@context': ['https://www.w3.org/ns/activitystreams', 'https://w3id.org/security/v1'] })))
      end

      it 'returns the nil' do
        expect(account).to be_nil
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class ActivityPub::ProcessCollectionService < BaseService
  include JsonLdHelper

  def call(body, actor, **options)
    @account = actor
    @json    = original_json = Oj.load(body, mode: :strict)
    @options = options

    return unless @json.is_a?(Hash)

    begin
      @json = compact(@json) if @json['signature'].is_a?(Hash)
    rescue JSON::LD::JsonLdError => e
      Rails.logger.debug { ""Error when compacting JSON-LD document for #{value_or_id(@json['actor'])}: #{e.message}"" }
      @json = original_json.without('signature')
    end

    return if !supported_context? || (different_actor? && verify_account!.nil?) || suspended_actor? || @account.local?
    return unless @account.is_a?(Account)

    if @json['signature'].present?
      # We have verified the signature, but in the compaction step above, might
      # have introduced incompatibilities with other servers that do not
      # normalize the JSON-LD documents (for instance, previous Mastodon
      # versions), so skip redistribution if we can't get a safe document.
      patch_for_forwarding!(original_json, @json)
      @json.delete('signature') unless safe_for_forwarding?(original_json, @json)
    end

    case @json['type']
    when 'Collection', 'CollectionPage'
      process_items @json['items']
    when 'OrderedCollection', 'OrderedCollectionPage'
      process_items @json['orderedItems']
    else
      process_items [@json]
    end
  rescue Oj::ParseError
    nil
  end

  private

  def different_actor?
    @json['actor'].present? && value_or_id(@json['actor']) != @account.uri
  end

  def suspended_actor?
    @account.suspended? && !activity_allowed_while_suspended?
  end

  def activity_allowed_while_suspended?
    %w(Delete Reject Undo Update).include?(@json['type'])
  end

  def process_items(items)
    items.reverse_each.filter_map { |item| process_item(item) }
  end

  def supported_context?
    super(@json)
  end

  def process_item(item)
    activity = ActivityPub::Activity.factory(item, @account, **@options)
    activity&.perform
  end

  def verify_account!
    @options[:relayed_through_actor] = @account
    @account = ActivityPub::LinkedDataSignature.new(@json).verify_actor!
    @account = nil unless @account.is_a?(Account)
    @account
  rescue JSON::LD::JsonLdError, RDF::WriterError => e
    Rails.logger.debug { ""Could not verify LD-Signature for #{value_or_id(@json['actor'])}: #{e.message}"" }
    nil
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe ActivityPub::ProcessCollectionService, type: :service do
  subject { described_class.new }

  let(:actor) { Fabricate(:account, domain: 'example.com', uri: 'http://example.com/account') }

  let(:payload) do
    {
      '@context': 'https://www.w3.org/ns/activitystreams',
      id: 'foo',
      type: 'Create',
      actor: ActivityPub::TagManager.instance.uri_for(actor),
      object: {
        id: 'bar',
        type: 'Note',
        content: 'Lorem ipsum',
      },
    }
  end

  let(:json) { Oj.dump(payload) }

  describe '#call' do
    context 'when actor is suspended' do
      before do
        actor.suspend!(origin: :remote)
      end

      %w(Accept Add Announce Block Create Flag Follow Like Move Remove).each do |activity_type|
        context ""with #{activity_type} activity"" do
          let(:payload) do
            {
              '@context': 'https://www.w3.org/ns/activitystreams',
              id: 'foo',
              type: activity_type,
              actor: ActivityPub::TagManager.instance.uri_for(actor),
            }
          end

          it 'does not process payload' do
            allow(ActivityPub::Activity).to receive(:factory)

            subject.call(json, actor)

            expect(ActivityPub::Activity).to_not have_received(:factory)
          end
        end
      end

      %w(Delete Reject Undo Update).each do |activity_type|
        context ""with #{activity_type} activity"" do
          let(:payload) do
            {
              '@context': 'https://www.w3.org/ns/activitystreams',
              id: 'foo',
              type: activity_type,
              actor: ActivityPub::TagManager.instance.uri_for(actor),
            }
          end

          it 'processes the payload' do
            allow(ActivityPub::Activity).to receive(:factory)

            subject.call(json, actor)

            expect(ActivityPub::Activity).to have_received(:factory)
          end
        end
      end
    end

    context 'when actor differs from sender' do
      let(:forwarder) { Fabricate(:account, domain: 'example.com', uri: 'http://example.com/other_account') }

      it 'does not process payload if no signature exists' do
        signature_double = instance_double(ActivityPub::LinkedDataSignature, verify_actor!: nil)
        allow(ActivityPub::LinkedDataSignature).to receive(:new).and_return(signature_double)
        allow(ActivityPub::Activity).to receive(:factory)

        subject.call(json, forwarder)

        expect(ActivityPub::Activity).to_not have_received(:factory)
      end

      it 'processes payload with actor if valid signature exists' do
        payload['signature'] = { 'type' => 'RsaSignature2017' }

        signature_double = instance_double(ActivityPub::LinkedDataSignature, verify_actor!: actor)
        allow(ActivityPub::LinkedDataSignature).to receive(:new).and_return(signature_double)
        allow(ActivityPub::Activity).to receive(:factory).with(instance_of(Hash), actor, instance_of(Hash))

        subject.call(json, forwarder)

        expect(ActivityPub::Activity).to have_received(:factory).with(instance_of(Hash), actor, instance_of(Hash))
      end

      it 'does not process payload if invalid signature exists' do
        payload['signature'] = { 'type' => 'RsaSignature2017' }

        signature_double = instance_double(ActivityPub::LinkedDataSignature, verify_actor!: nil)
        allow(ActivityPub::LinkedDataSignature).to receive(:new).and_return(signature_double)
        allow(ActivityPub::Activity).to receive(:factory)

        subject.call(json, forwarder)

        expect(ActivityPub::Activity).to_not have_received(:factory)
      end

      context 'when receiving a fabricated status' do
        let!(:actor) do
          Fabricate(:account,
                    username: 'bob',
                    domain: 'example.com',
                    uri: 'https://example.com/users/bob',
                    private_key: nil,
                    public_key: <<~TEXT)
                      -----BEGIN PUBLIC KEY-----
                      MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuuYyoyfsRkYnXRotMsId
                      W3euBDDfiv9oVqOxUVC7bhel8KednIMrMCRWFAkgJhbrlzbIkjVr68o1MP9qLcn7
                      CmH/BXHp7yhuFTr4byjdJKpwB+/i2jNEsvDH5jR8WTAeTCe0x/QHg21V3F7dSI5m
                      CCZ/1dSIyOXLRTWVlfDlm3rE4ntlCo+US3/7oSWbg/4/4qEnt1HC32kvklgScxua
                      4LR5ATdoXa5bFoopPWhul7MJ6NyWCyQyScUuGdlj8EN4kmKQJvphKHrI9fvhgOuG
                      TvhTR1S5InA4azSSchY0tXEEw/VNxraeX0KPjbgr6DPcwhPd/m0nhVDq0zVyVBBD
                      MwIDAQAB
                      -----END PUBLIC KEY-----
                    TEXT
        end

        let(:payload) do
          {
            '@context': [
              'https://www.w3.org/ns/activitystreams',
              nil,
              { object: 'https://www.w3.org/ns/activitystreams#object' },
            ],
            id: 'https://example.com/users/bob/fake-status/activity',
            type: 'Create',
            actor: 'https://example.com/users/bob',
            published: '2022-01-22T15:00:00Z',
            to: [
              'https://www.w3.org/ns/activitystreams#Public',
            ],
            cc: [
              'https://example.com/users/bob/followers',
            ],
            signature: {
              type: 'RsaSignature2017',
              creator: 'https://example.com/users/bob#main-key',
              created: '2022-03-09T21:57:25Z',
              signatureValue: 'WculK0LelTQ0MvGwU9TPoq5pFzFfGYRDCJqjZ232/Udj4' \
                              'CHqDTGOSw5UTDLShqBOyycCkbZGrQwXG+dpyDpQLSe1UV' \
                              'PZ5TPQtc/9XtI57WlS2nMNpdvRuxGnnb2btPdesXZ7n3p' \
                              'Cxo0zjaXrJMe0mqQh5QJO22mahb4bDwwmfTHgbD3nmkD+' \
                              'fBfGi+UV2qWwqr+jlV4L4JqNkh0gWljF5KTePLRRZCuWi' \
                              'Q/FAt7c67636cdIPf7fR+usjuZltTQyLZKEGuK8VUn2Gk' \
                              'fsx5qns7Vcjvlz1JqlAjyO8HPBbzTTHzUG2nUOIgC3Poj' \
                              'CSWv6mNTmRGoLZzOscCAYQA6cKw==',
            },
            '@id': 'https://example.com/users/bob/statuses/107928807471117876/activity',
            '@type': 'https://www.w3.org/ns/activitystreams#Create',
            'https://www.w3.org/ns/activitystreams#actor': {
              '@id': 'https://example.com/users/bob',
            },
            'https://www.w3.org/ns/activitystreams#cc': {
              '@id': 'https://example.com/users/bob/followers',
            },
            object: {
              id: 'https://example.com/users/bob/fake-status',
              type: 'Note',
              published: '2022-01-22T15:00:00Z',
              url: 'https://www.youtube.com/watch?v=dQw4w9WgXcQ&feature=puck-was-here',
              attributedTo: 'https://example.com/users/bob',
              to: [
                'https://www.w3.org/ns/activitystreams#Public',
              ],
              cc: [
                'https://example.com/users/bob/followers',
              ],
              sensitive: false,
              atomUri: 'https://example.com/users/bob/fake-status',
              conversation: 'tag:example.com,2022-03-09:objectId=15:objectType=Conversation',
              content: '<p>puck was here</p>',

              '@id': 'https://example.com/users/bob/statuses/107928807471117876',
              '@type': 'https://www.w3.org/ns/activitystreams#Note',
              'http://ostatus.org#atomUri': 'https://example.com/users/bob/statuses/107928807471117876',
              'http://ostatus.org#conversation': 'tag:example.com,2022-03-09:objectId=15:objectType=Conversation',
              'https://www.w3.org/ns/activitystreams#attachment': [],
              'https://www.w3.org/ns/activitystreams#attributedTo': {
                '@id': 'https://example.com/users/bob',
              },
              'https://www.w3.org/ns/activitystreams#cc': {
                '@id': 'https://example.com/users/bob/followers',
              },
              'https://www.w3.org/ns/activitystreams#content': [
                '<p>hello world</p>',
                {
                  '@value': '<p>hello world</p>',
                  '@language': 'en',
                },
              ],
              'https://www.w3.org/ns/activitystreams#published': {
                '@type': 'http://www.w3.org/2001/XMLSchema#dateTime',
                '@value': '2022-03-09T21:55:07Z',
              },
              'https://www.w3.org/ns/activitystreams#replies': {
                '@id': 'https://example.com/users/bob/statuses/107928807471117876/replies',
                '@type': 'https://www.w3.org/ns/activitystreams#Collection',
                'https://www.w3.org/ns/activitystreams#first': {
                  '@type': 'https://www.w3.org/ns/activitystreams#CollectionPage',
                  'https://www.w3.org/ns/activitystreams#items': [],
                  'https://www.w3.org/ns/activitystreams#next': {
                    '@id': 'https://example.com/users/bob/statuses/107928807471117876/replies?only_other_accounts=true&page=true',
                  },
                  'https://www.w3.org/ns/activitystreams#partOf': {
                    '@id': 'https://example.com/users/bob/statuses/107928807471117876/replies',
                  },
                },
              },
              'https://www.w3.org/ns/activitystreams#sensitive': false,
              'https://www.w3.org/ns/activitystreams#tag': [],
              'https://www.w3.org/ns/activitystreams#to': {
                '@id': 'https://www.w3.org/ns/activitystreams#Public',
              },
              'https://www.w3.org/ns/activitystreams#url': {
                '@id': 'https://example.com/@bob/107928807471117876',
              },
            },
            'https://www.w3.org/ns/activitystreams#published': {
              '@type': 'http://www.w3.org/2001/XMLSchema#dateTime',
              '@value': '2022-03-09T21:55:07Z',
            },
            'https://www.w3.org/ns/activitystreams#to': {
              '@id': 'https://www.w3.org/ns/activitystreams#Public',
            },
          }
        end

        it 'does not process forged payload' do
          allow(ActivityPub::Activity).to receive(:factory)

          subject.call(json, forwarder)

          expect(ActivityPub::Activity).to_not have_received(:factory).with(
            hash_including(
              'object' => hash_including(
                'id' => 'https://example.com/users/bob/fake-status'
              )
            ),
            anything,
            anything
          )

          expect(ActivityPub::Activity).to_not have_received(:factory).with(
            hash_including(
              'object' => hash_including(
                'content' => '<p>puck was here</p>'
              )
            ),
            anything,
            anything
          )

          expect(Status.where(uri: 'https://example.com/users/bob/fake-status').exists?).to be false
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class ActivityPub::FetchRemoteActorService < BaseService
  include JsonLdHelper
  include DomainControlHelper
  include WebfingerHelper

  class Error < StandardError; end

  SUPPORTED_TYPES = %w(Application Group Organization Person Service).freeze

  # Does a WebFinger roundtrip on each call, unless `only_key` is true
  def call(uri, id: true, prefetched_body: nil, break_on_redirect: false, only_key: false, suppress_errors: true, request_id: nil)
    return if domain_not_allowed?(uri)
    return ActivityPub::TagManager.instance.uri_to_actor(uri) if ActivityPub::TagManager.instance.local_uri?(uri)

    @json = begin
      if prefetched_body.nil?
        fetch_resource(uri, id)
      else
        body_to_json(prefetched_body, compare_id: id ? uri : nil)
      end
    rescue Oj::ParseError
      raise Error, ""Error parsing JSON-LD document #{uri}""
    end

    raise Error, ""Error fetching actor JSON at #{uri}"" if @json.nil?
    raise Error, ""Unsupported JSON-LD context for document #{uri}"" unless supported_context?
    raise Error, ""Unexpected object type for actor #{uri} (expected any of: #{SUPPORTED_TYPES})"" unless expected_type?
    raise Error, ""Actor #{uri} has moved to #{@json['movedTo']}"" if break_on_redirect && @json['movedTo'].present?
    raise Error, ""Actor #{uri} has no 'preferredUsername', which is a requirement for Mastodon compatibility"" if @json['preferredUsername'].blank?

    @uri      = @json['id']
    @username = @json['preferredUsername']
    @domain   = Addressable::URI.parse(@uri).normalized_host

    check_webfinger! unless only_key

    ActivityPub::ProcessAccountService.new.call(@username, @domain, @json, only_key: only_key, verified_webfinger: !only_key, request_id: request_id)
  rescue Error => e
    Rails.logger.debug { ""Fetching actor #{uri} failed: #{e.message}"" }
    raise unless suppress_errors
  end

  private

  def check_webfinger!
    webfinger                            = webfinger!(""acct:#{@username}@#{@domain}"")
    confirmed_username, confirmed_domain = split_acct(webfinger.subject)

    if @username.casecmp(confirmed_username).zero? && @domain.casecmp(confirmed_domain).zero?
      raise Error, ""Webfinger response for #{@username}@#{@domain} does not loop back to #{@uri}"" if webfinger.link('self', 'href') != @uri

      return
    end

    webfinger                            = webfinger!(""acct:#{confirmed_username}@#{confirmed_domain}"")
    @username, @domain                   = split_acct(webfinger.subject)

    raise Webfinger::RedirectError, ""Too many webfinger redirects for URI #{@uri} (stopped at #{@username}@#{@domain})"" unless confirmed_username.casecmp(@username).zero? && confirmed_domain.casecmp(@domain).zero?

    raise Error, ""Webfinger response for #{@username}@#{@domain} does not loop back to #{@uri}"" if webfinger.link('self', 'href') != @uri
  rescue Webfinger::RedirectError => e
    raise Error, e.message
  rescue Webfinger::Error => e
    raise Error, ""Webfinger error when resolving #{@username}@#{@domain}: #{e.message}""
  end

  def split_acct(acct)
    acct.delete_prefix('acct:').split('@')
  end

  def supported_context?
    super(@json)
  end

  def expected_type?
    equals_or_includes_any?(@json['type'], SUPPORTED_TYPES)
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe ActivityPub::FetchRemoteActorService, type: :service do
  subject { described_class.new }

  let!(:actor) do
    {
      '@context': 'https://www.w3.org/ns/activitystreams',
      id: 'https://example.com/alice',
      type: 'Person',
      preferredUsername: 'alice',
      name: 'Alice',
      summary: 'Foo bar',
      inbox: 'http://example.com/alice/inbox',
    }
  end

  describe '#call' do
    let(:account) { subject.call('https://example.com/alice', id: true) }

    shared_examples 'sets profile data' do
      it 'returns an account' do
        expect(account).to be_an Account
      end

      it 'sets display name' do
        expect(account.display_name).to eq 'Alice'
      end

      it 'sets note' do
        expect(account.note).to eq 'Foo bar'
      end

      it 'sets URL' do
        expect(account.url).to eq 'https://example.com/alice'
      end
    end

    context 'when the account does not have a inbox' do
      let!(:webfinger) { { subject: 'acct:alice@example.com', links: [{ rel: 'self', href: 'https://example.com/alice' }] } }

      before do
        actor[:inbox] = nil

        stub_request(:get, 'https://example.com/alice').to_return(body: Oj.dump(actor))
        stub_request(:get, 'https://example.com/.well-known/webfinger?resource=acct:alice@example.com').to_return(body: Oj.dump(webfinger), headers: { 'Content-Type': 'application/jrd+json' })
      end

      it 'fetches resource' do
        account
        expect(a_request(:get, 'https://example.com/alice')).to have_been_made.once
      end

      it 'looks up webfinger' do
        account
        expect(a_request(:get, 'https://example.com/.well-known/webfinger?resource=acct:alice@example.com')).to have_been_made.once
      end

      it 'returns nil' do
        expect(account).to be_nil
      end
    end

    context 'when URI and WebFinger share the same host' do
      let!(:webfinger) { { subject: 'acct:alice@example.com', links: [{ rel: 'self', href: 'https://example.com/alice' }] } }

      before do
        stub_request(:get, 'https://example.com/alice').to_return(body: Oj.dump(actor))
        stub_request(:get, 'https://example.com/.well-known/webfinger?resource=acct:alice@example.com').to_return(body: Oj.dump(webfinger), headers: { 'Content-Type': 'application/jrd+json' })
      end

      it 'fetches resource' do
        account
        expect(a_request(:get, 'https://example.com/alice')).to have_been_made.once
      end

      it 'looks up webfinger' do
        account
        expect(a_request(:get, 'https://example.com/.well-known/webfinger?resource=acct:alice@example.com')).to have_been_made.once
      end

      it 'sets username and domain from webfinger' do
        expect(account.username).to eq 'alice'
        expect(account.domain).to eq 'example.com'
      end

      include_examples 'sets profile data'
    end

    context 'when WebFinger presents different domain than URI' do
      let!(:webfinger) { { subject: 'acct:alice@iscool.af', links: [{ rel: 'self', href: 'https://example.com/alice' }] } }

      before do
        stub_request(:get, 'https://example.com/alice').to_return(body: Oj.dump(actor))
        stub_request(:get, 'https://example.com/.well-known/webfinger?resource=acct:alice@example.com').to_return(body: Oj.dump(webfinger), headers: { 'Content-Type': 'application/jrd+json' })
        stub_request(:get, 'https://iscool.af/.well-known/webfinger?resource=acct:alice@iscool.af').to_return(body: Oj.dump(webfinger), headers: { 'Content-Type': 'application/jrd+json' })
      end

      it 'fetches resource' do
        account
        expect(a_request(:get, 'https://example.com/alice')).to have_been_made.once
      end

      it 'looks up webfinger' do
        account
        expect(a_request(:get, 'https://example.com/.well-known/webfinger?resource=acct:alice@example.com')).to have_been_made.once
      end

      it 'looks up ""redirected"" webfinger' do
        account
        expect(a_request(:get, 'https://iscool.af/.well-known/webfinger?resource=acct:alice@iscool.af')).to have_been_made.once
      end

      it 'sets username and domain from final webfinger' do
        expect(account.username).to eq 'alice'
        expect(account.domain).to eq 'iscool.af'
      end

      include_examples 'sets profile data'
    end

    context 'when WebFinger returns a different URI' do
      let!(:webfinger) { { subject: 'acct:alice@example.com', links: [{ rel: 'self', href: 'https://example.com/bob' }] } }

      before do
        stub_request(:get, 'https://example.com/alice').to_return(body: Oj.dump(actor))
        stub_request(:get, 'https://example.com/.well-known/webfinger?resource=acct:alice@example.com').to_return(body: Oj.dump(webfinger), headers: { 'Content-Type': 'application/jrd+json' })
      end

      it 'fetches resource' do
        account
        expect(a_request(:get, 'https://example.com/alice')).to have_been_made.once
      end

      it 'looks up webfinger' do
        account
        expect(a_request(:get, 'https://example.com/.well-known/webfinger?resource=acct:alice@example.com')).to have_been_made.once
      end

      it 'does not create account' do
        expect(account).to be_nil
      end
    end

    context 'when WebFinger returns a different URI after a redirection' do
      let!(:webfinger) { { subject: 'acct:alice@iscool.af', links: [{ rel: 'self', href: 'https://example.com/bob' }] } }

      before do
        stub_request(:get, 'https://example.com/alice').to_return(body: Oj.dump(actor))
        stub_request(:get, 'https://example.com/.well-known/webfinger?resource=acct:alice@example.com').to_return(body: Oj.dump(webfinger), headers: { 'Content-Type': 'application/jrd+json' })
        stub_request(:get, 'https://iscool.af/.well-known/webfinger?resource=acct:alice@iscool.af').to_return(body: Oj.dump(webfinger), headers: { 'Content-Type': 'application/jrd+json' })
      end

      it 'fetches resource' do
        account
        expect(a_request(:get, 'https://example.com/alice')).to have_been_made.once
      end

      it 'looks up webfinger' do
        account
        expect(a_request(:get, 'https://example.com/.well-known/webfinger?resource=acct:alice@example.com')).to have_been_made.once
      end

      it 'looks up ""redirected"" webfinger' do
        account
        expect(a_request(:get, 'https://iscool.af/.well-known/webfinger?resource=acct:alice@iscool.af')).to have_been_made.once
      end

      it 'does not create account' do
        expect(account).to be_nil
      end
    end

    context 'with wrong id' do
      it 'does not create account' do
        expect(subject.call('https://fake.address/@foo', prefetched_body: Oj.dump(actor))).to be_nil
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class ActivityPub::FetchFeaturedCollectionService < BaseService
  include JsonLdHelper

  def call(account, **options)
    return if account.featured_collection_url.blank? || account.suspended? || account.local?

    @account = account
    @options = options
    @json    = fetch_resource(@account.featured_collection_url, true, local_follower)

    return unless supported_context?(@json)

    process_items(collection_items(@json))
  end

  private

  def collection_items(collection)
    collection = fetch_collection(collection['first']) if collection['first'].present?
    return unless collection.is_a?(Hash)

    case collection['type']
    when 'Collection', 'CollectionPage'
      collection['items']
    when 'OrderedCollection', 'OrderedCollectionPage'
      collection['orderedItems']
    end
  end

  def fetch_collection(collection_or_uri)
    return collection_or_uri if collection_or_uri.is_a?(Hash)
    return if non_matching_uri_hosts?(@account.uri, collection_or_uri)

    fetch_resource_without_id_validation(collection_or_uri, local_follower, true)
  end

  def process_items(items)
    return if items.nil?

    process_note_items(items) if @options[:note]
    process_hashtag_items(items) if @options[:hashtag]
  end

  def process_note_items(items)
    status_ids = items.filter_map do |item|
      next unless item.is_a?(String) || item['type'] == 'Note'

      uri = value_or_id(item)
      next if ActivityPub::TagManager.instance.local_uri?(uri) || non_matching_uri_hosts?(@account.uri, uri)

      status = ActivityPub::FetchRemoteStatusService.new.call(uri, on_behalf_of: local_follower, expected_actor_uri: @account.uri, request_id: @options[:request_id])
      next unless status&.account_id == @account.id

      status.id
    rescue ActiveRecord::RecordInvalid => e
      Rails.logger.debug { ""Invalid pinned status #{uri}: #{e.message}"" }
      nil
    end

    to_remove = []
    to_add    = status_ids

    StatusPin.where(account: @account).pluck(:status_id).each do |status_id|
      if status_ids.include?(status_id)
        to_add.delete(status_id)
      else
        to_remove << status_id
      end
    end

    StatusPin.where(account: @account, status_id: to_remove).delete_all unless to_remove.empty?

    to_add.each do |status_id|
      StatusPin.create!(account: @account, status_id: status_id)
    end
  end

  def process_hashtag_items(items)
    names     = items.filter_map { |item| item['type'] == 'Hashtag' && item['name']&.delete_prefix('#') }.map { |name| HashtagNormalizer.new.normalize(name) }
    to_remove = []
    to_add    = names

    FeaturedTag.where(account: @account).map(&:name).each do |name|
      if names.include?(name)
        to_add.delete(name)
      else
        to_remove << name
      end
    end

    FeaturedTag.includes(:tag).where(account: @account, tags: { name: to_remove }).delete_all unless to_remove.empty?

    to_add.each do |name|
      FeaturedTag.create!(account: @account, name: name)
    end
  end

  def local_follower
    return @local_follower if defined?(@local_follower)

    @local_follower = @account.followers.local.without_suspended.first
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe ActivityPub::FetchFeaturedCollectionService, type: :service do
  subject { described_class.new }

  let(:actor) { Fabricate(:account, domain: 'example.com', uri: 'https://example.com/account', featured_collection_url: 'https://example.com/account/pinned') }

  let!(:known_status) { Fabricate(:status, account: actor, uri: 'https://example.com/account/pinned/1') }

  let(:status_json_pinned_known) do
    {
      '@context': 'https://www.w3.org/ns/activitystreams',
      type: 'Note',
      id: 'https://example.com/account/pinned/known',
      content: 'foo',
      attributedTo: actor.uri,
      to: 'https://www.w3.org/ns/activitystreams#Public',
    }
  end

  let(:status_json_pinned_unknown_inlined) do
    {
      '@context': 'https://www.w3.org/ns/activitystreams',
      type: 'Note',
      id: 'https://example.com/account/pinned/unknown-inlined',
      content: 'foo',
      attributedTo: actor.uri,
      to: 'https://www.w3.org/ns/activitystreams#Public',
    }
  end

  let(:status_json_pinned_unknown_unreachable) do
    {
      '@context': 'https://www.w3.org/ns/activitystreams',
      type: 'Note',
      id: 'https://example.com/account/pinned/unknown-reachable',
      content: 'foo',
      attributedTo: actor.uri,
      to: 'https://www.w3.org/ns/activitystreams#Public',
    }
  end

  let(:featured_with_null) do
    {
      '@context': 'https://www.w3.org/ns/activitystreams',
      id: 'https://example.com/account/collections/featured',
      totalItems: 0,
      type: 'OrderedCollection',
    }
  end

  let(:items) do
    [
      'https://example.com/account/pinned/known', # known
      status_json_pinned_unknown_inlined, # unknown inlined
      'https://example.com/account/pinned/unknown-unreachable', # unknown unreachable
      'https://example.com/account/pinned/unknown-reachable', # unknown reachable
      'https://example.com/account/collections/featured', # featured with null
    ]
  end

  let(:payload) do
    {
      '@context': 'https://www.w3.org/ns/activitystreams',
      type: 'Collection',
      id: actor.featured_collection_url,
      items: items,
    }.with_indifferent_access
  end

  shared_examples 'sets pinned posts' do
    before do
      stub_request(:get, 'https://example.com/account/pinned/known').to_return(status: 200, body: Oj.dump(status_json_pinned_known))
      stub_request(:get, 'https://example.com/account/pinned/unknown-inlined').to_return(status: 200, body: Oj.dump(status_json_pinned_unknown_inlined))
      stub_request(:get, 'https://example.com/account/pinned/unknown-unreachable').to_return(status: 404)
      stub_request(:get, 'https://example.com/account/pinned/unknown-reachable').to_return(status: 200, body: Oj.dump(status_json_pinned_unknown_unreachable))
      stub_request(:get, 'https://example.com/account/collections/featured').to_return(status: 200, body: Oj.dump(featured_with_null))

      subject.call(actor, note: true, hashtag: false)
    end

    it 'sets expected posts as pinned posts' do
      expect(actor.pinned_statuses.pluck(:uri)).to contain_exactly(
        'https://example.com/account/pinned/known',
        'https://example.com/account/pinned/unknown-inlined',
        'https://example.com/account/pinned/unknown-reachable'
      )
    end
  end

  describe '#call' do
    context 'when the endpoint is a Collection' do
      before do
        stub_request(:get, actor.featured_collection_url).to_return(status: 200, body: Oj.dump(payload))
      end

      it_behaves_like 'sets pinned posts'
    end

    context 'when the endpoint is an OrderedCollection' do
      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          type: 'OrderedCollection',
          id: actor.featured_collection_url,
          orderedItems: items,
        }.with_indifferent_access
      end

      before do
        stub_request(:get, actor.featured_collection_url).to_return(status: 200, body: Oj.dump(payload))
      end

      it_behaves_like 'sets pinned posts'
    end

    context 'when the endpoint is a paginated Collection' do
      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          type: 'Collection',
          id: actor.featured_collection_url,
          first: {
            type: 'CollectionPage',
            partOf: actor.featured_collection_url,
            items: items,
          },
        }.with_indifferent_access
      end

      before do
        stub_request(:get, actor.featured_collection_url).to_return(status: 200, body: Oj.dump(payload))
      end

      it_behaves_like 'sets pinned posts'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class ActivityPub::FetchRemoteAccountService < ActivityPub::FetchRemoteActorService
  # Does a WebFinger roundtrip on each call, unless `only_key` is true
  def call(uri, id: true, prefetched_body: nil, break_on_redirect: false, only_key: false, suppress_errors: true, request_id: nil)
    actor = super
    return actor if actor.nil? || actor.is_a?(Account)

    Rails.logger.debug { ""Fetching account #{uri} failed: Expected Account, got #{actor.class.name}"" }
    raise Error, ""Expected Account, got #{actor.class.name}"" unless suppress_errors
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe ActivityPub::FetchRemoteAccountService, type: :service do
  subject { described_class.new }

  let!(:actor) do
    {
      '@context': 'https://www.w3.org/ns/activitystreams',
      id: 'https://example.com/alice',
      type: 'Person',
      preferredUsername: 'alice',
      name: 'Alice',
      summary: 'Foo bar',
      inbox: 'http://example.com/alice/inbox',
    }
  end

  describe '#call' do
    let(:account) { subject.call('https://example.com/alice', id: true) }

    shared_examples 'sets profile data' do
      it 'returns an account' do
        expect(account).to be_an Account
      end

      it 'sets display name' do
        expect(account.display_name).to eq 'Alice'
      end

      it 'sets note' do
        expect(account.note).to eq 'Foo bar'
      end

      it 'sets URL' do
        expect(account.url).to eq 'https://example.com/alice'
      end
    end

    context 'when the account does not have a inbox' do
      let!(:webfinger) { { subject: 'acct:alice@example.com', links: [{ rel: 'self', href: 'https://example.com/alice' }] } }

      before do
        actor[:inbox] = nil

        stub_request(:get, 'https://example.com/alice').to_return(body: Oj.dump(actor))
        stub_request(:get, 'https://example.com/.well-known/webfinger?resource=acct:alice@example.com').to_return(body: Oj.dump(webfinger), headers: { 'Content-Type': 'application/jrd+json' })
      end

      it 'fetches resource' do
        account
        expect(a_request(:get, 'https://example.com/alice')).to have_been_made.once
      end

      it 'looks up webfinger' do
        account
        expect(a_request(:get, 'https://example.com/.well-known/webfinger?resource=acct:alice@example.com')).to have_been_made.once
      end

      it 'returns nil' do
        expect(account).to be_nil
      end
    end

    context 'when URI and WebFinger share the same host' do
      let!(:webfinger) { { subject: 'acct:alice@example.com', links: [{ rel: 'self', href: 'https://example.com/alice' }] } }

      before do
        stub_request(:get, 'https://example.com/alice').to_return(body: Oj.dump(actor))
        stub_request(:get, 'https://example.com/.well-known/webfinger?resource=acct:alice@example.com').to_return(body: Oj.dump(webfinger), headers: { 'Content-Type': 'application/jrd+json' })
      end

      it 'fetches resource' do
        account
        expect(a_request(:get, 'https://example.com/alice')).to have_been_made.once
      end

      it 'looks up webfinger' do
        account
        expect(a_request(:get, 'https://example.com/.well-known/webfinger?resource=acct:alice@example.com')).to have_been_made.once
      end

      it 'sets username and domain from webfinger' do
        expect(account.username).to eq 'alice'
        expect(account.domain).to eq 'example.com'
      end

      include_examples 'sets profile data'
    end

    context 'when WebFinger presents different domain than URI' do
      let!(:webfinger) { { subject: 'acct:alice@iscool.af', links: [{ rel: 'self', href: 'https://example.com/alice' }] } }

      before do
        stub_request(:get, 'https://example.com/alice').to_return(body: Oj.dump(actor))
        stub_request(:get, 'https://example.com/.well-known/webfinger?resource=acct:alice@example.com').to_return(body: Oj.dump(webfinger), headers: { 'Content-Type': 'application/jrd+json' })
        stub_request(:get, 'https://iscool.af/.well-known/webfinger?resource=acct:alice@iscool.af').to_return(body: Oj.dump(webfinger), headers: { 'Content-Type': 'application/jrd+json' })
      end

      it 'fetches resource' do
        account
        expect(a_request(:get, 'https://example.com/alice')).to have_been_made.once
      end

      it 'looks up webfinger' do
        account
        expect(a_request(:get, 'https://example.com/.well-known/webfinger?resource=acct:alice@example.com')).to have_been_made.once
      end

      it 'looks up ""redirected"" webfinger' do
        account
        expect(a_request(:get, 'https://iscool.af/.well-known/webfinger?resource=acct:alice@iscool.af')).to have_been_made.once
      end

      it 'sets username and domain from final webfinger' do
        expect(account.username).to eq 'alice'
        expect(account.domain).to eq 'iscool.af'
      end

      include_examples 'sets profile data'
    end

    context 'when WebFinger returns a different URI' do
      let!(:webfinger) { { subject: 'acct:alice@example.com', links: [{ rel: 'self', href: 'https://example.com/bob' }] } }

      before do
        stub_request(:get, 'https://example.com/alice').to_return(body: Oj.dump(actor))
        stub_request(:get, 'https://example.com/.well-known/webfinger?resource=acct:alice@example.com').to_return(body: Oj.dump(webfinger), headers: { 'Content-Type': 'application/jrd+json' })
      end

      it 'fetches resource' do
        account
        expect(a_request(:get, 'https://example.com/alice')).to have_been_made.once
      end

      it 'looks up webfinger' do
        account
        expect(a_request(:get, 'https://example.com/.well-known/webfinger?resource=acct:alice@example.com')).to have_been_made.once
      end

      it 'does not create account' do
        expect(account).to be_nil
      end
    end

    context 'when WebFinger returns a different URI after a redirection' do
      let!(:webfinger) { { subject: 'acct:alice@iscool.af', links: [{ rel: 'self', href: 'https://example.com/bob' }] } }

      before do
        stub_request(:get, 'https://example.com/alice').to_return(body: Oj.dump(actor))
        stub_request(:get, 'https://example.com/.well-known/webfinger?resource=acct:alice@example.com').to_return(body: Oj.dump(webfinger), headers: { 'Content-Type': 'application/jrd+json' })
        stub_request(:get, 'https://iscool.af/.well-known/webfinger?resource=acct:alice@iscool.af').to_return(body: Oj.dump(webfinger), headers: { 'Content-Type': 'application/jrd+json' })
      end

      it 'fetches resource' do
        account
        expect(a_request(:get, 'https://example.com/alice')).to have_been_made.once
      end

      it 'looks up webfinger' do
        account
        expect(a_request(:get, 'https://example.com/.well-known/webfinger?resource=acct:alice@example.com')).to have_been_made.once
      end

      it 'looks up ""redirected"" webfinger' do
        account
        expect(a_request(:get, 'https://iscool.af/.well-known/webfinger?resource=acct:alice@iscool.af')).to have_been_made.once
      end

      it 'does not create account' do
        expect(account).to be_nil
      end
    end

    context 'with wrong id' do
      it 'does not create account' do
        expect(subject.call('https://fake.address/@foo', prefetched_body: Oj.dump(actor))).to be_nil
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class ActivityPub::FetchFeaturedTagsCollectionService < BaseService
  include JsonLdHelper

  def call(account, url)
    return if url.blank? || account.suspended? || account.local?

    @account = account
    @json    = fetch_resource(url, true, local_follower)

    return unless supported_context?(@json)

    process_items(collection_items(@json))
  end

  private

  def collection_items(collection)
    all_items = []

    collection = fetch_collection(collection['first']) if collection['first'].present?

    while collection.is_a?(Hash)
      items = case collection['type']
              when 'Collection', 'CollectionPage'
                collection['items']
              when 'OrderedCollection', 'OrderedCollectionPage'
                collection['orderedItems']
              end

      break if items.blank?

      all_items.concat(items)

      break if all_items.size >= FeaturedTag::LIMIT

      collection = collection['next'].present? ? fetch_collection(collection['next']) : nil
    end

    all_items
  end

  def fetch_collection(collection_or_uri)
    return collection_or_uri if collection_or_uri.is_a?(Hash)
    return if non_matching_uri_hosts?(@account.uri, collection_or_uri)

    fetch_resource_without_id_validation(collection_or_uri, local_follower, true)
  end

  def process_items(items)
    names            = items.filter_map { |item| item['type'] == 'Hashtag' && item['name']&.delete_prefix('#') }.take(FeaturedTag::LIMIT)
    tags             = names.index_by { |name| HashtagNormalizer.new.normalize(name) }
    normalized_names = tags.keys

    FeaturedTag.includes(:tag).references(:tag).where(account: @account).where.not(tag: { name: normalized_names }).delete_all

    FeaturedTag.includes(:tag).references(:tag).where(account: @account, tag: { name: normalized_names }).find_each do |featured_tag|
      featured_tag.update(name: tags.delete(featured_tag.tag.name))
    end

    tags.each_value do |name|
      FeaturedTag.create!(account: @account, name: name)
    end
  end

  def local_follower
    return @local_follower if defined?(@local_follower)

    @local_follower = @account.followers.local.without_suspended.first
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe ActivityPub::FetchFeaturedTagsCollectionService, type: :service do
  subject { described_class.new }

  let(:collection_url) { 'https://example.com/account/tags' }
  let(:actor) { Fabricate(:account, domain: 'example.com', uri: 'https://example.com/account') }

  let(:items) do
    [
      { type: 'Hashtag', href: 'https://example.com/account/tagged/foo', name: 'Foo' },
      { type: 'Hashtag', href: 'https://example.com/account/tagged/bar', name: 'bar' },
      { type: 'Hashtag', href: 'https://example.com/account/tagged/baz', name: 'baZ' },
    ]
  end

  let(:payload) do
    {
      '@context': 'https://www.w3.org/ns/activitystreams',
      type: 'Collection',
      id: collection_url,
      items: items,
    }.with_indifferent_access
  end

  shared_examples 'sets featured tags' do
    before do
      subject.call(actor, collection_url)
    end

    it 'sets expected tags as pinned tags' do
      expect(actor.featured_tags.map(&:display_name)).to match_array %w(Foo bar baZ)
    end
  end

  describe '#call' do
    context 'when the endpoint is a Collection' do
      before do
        stub_request(:get, collection_url).to_return(status: 200, body: Oj.dump(payload))
      end

      it_behaves_like 'sets featured tags'
    end

    context 'when the account already has featured tags' do
      before do
        stub_request(:get, collection_url).to_return(status: 200, body: Oj.dump(payload))

        actor.featured_tags.create!(name: 'FoO')
        actor.featured_tags.create!(name: 'baz')
        actor.featured_tags.create!(name: 'oh').update(name: nil)
      end

      it_behaves_like 'sets featured tags'
    end

    context 'when the endpoint is an OrderedCollection' do
      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          type: 'OrderedCollection',
          id: collection_url,
          orderedItems: items,
        }.with_indifferent_access
      end

      before do
        stub_request(:get, collection_url).to_return(status: 200, body: Oj.dump(payload))
      end

      it_behaves_like 'sets featured tags'
    end

    context 'when the endpoint is a paginated Collection' do
      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          type: 'Collection',
          id: collection_url,
          first: {
            type: 'CollectionPage',
            partOf: collection_url,
            items: items,
          },
        }.with_indifferent_access
      end

      before do
        stub_request(:get, collection_url).to_return(status: 200, body: Oj.dump(payload))
      end

      it_behaves_like 'sets featured tags'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class ActivityPub::FetchRemoteStatusService < BaseService
  include JsonLdHelper
  include DomainControlHelper
  include Redisable

  DISCOVERIES_PER_REQUEST = 1000

  # Should be called when uri has already been checked for locality
  def call(uri, id: true, prefetched_body: nil, on_behalf_of: nil, expected_actor_uri: nil, request_id: nil)
    return if domain_not_allowed?(uri)

    @request_id = request_id || ""#{Time.now.utc.to_i}-status-#{uri}""
    @json = if prefetched_body.nil?
              fetch_resource(uri, id, on_behalf_of)
            else
              body_to_json(prefetched_body, compare_id: id ? uri : nil)
            end

    return unless supported_context?

    actor_uri     = nil
    activity_json = nil
    object_uri    = nil

    if expected_object_type?
      actor_uri     = value_or_id(first_of_value(@json['attributedTo']))
      activity_json = { 'type' => 'Create', 'actor' => actor_uri, 'object' => @json }
      object_uri    = uri_from_bearcap(@json['id'])
    elsif expected_activity_type?
      actor_uri     = value_or_id(first_of_value(@json['actor']))
      activity_json = @json
      object_uri    = uri_from_bearcap(value_or_id(@json['object']))
    end

    return if activity_json.nil? || object_uri.nil? || !trustworthy_attribution?(@json['id'], actor_uri)
    return if expected_actor_uri.present? && actor_uri != expected_actor_uri
    return ActivityPub::TagManager.instance.uri_to_resource(object_uri, Status) if ActivityPub::TagManager.instance.local_uri?(object_uri)

    actor = account_from_uri(actor_uri)

    return if actor.nil? || actor.suspended?

    # If we fetched a status that already exists, then we need to treat the
    # activity as an update rather than create
    activity_json['type'] = 'Update' if equals_or_includes_any?(activity_json['type'], %w(Create)) && Status.where(uri: object_uri, account_id: actor.id).exists?

    with_redis do |redis|
      discoveries = redis.incr(""status_discovery_per_request:#{@request_id}"")
      redis.expire(""status_discovery_per_request:#{@request_id}"", 5.minutes.seconds)
      return nil if discoveries > DISCOVERIES_PER_REQUEST
    end

    ActivityPub::Activity.factory(activity_json, actor, request_id: @request_id).perform
  end

  private

  def trustworthy_attribution?(uri, attributed_to)
    return false if uri.nil? || attributed_to.nil?

    Addressable::URI.parse(uri).normalized_host.casecmp(Addressable::URI.parse(attributed_to).normalized_host).zero?
  end

  def account_from_uri(uri)
    actor = ActivityPub::TagManager.instance.uri_to_resource(uri, Account)
    actor = ActivityPub::FetchRemoteAccountService.new.call(uri, id: true, request_id: @request_id) if actor.nil? || actor.possibly_stale?
    actor
  end

  def supported_context?
    super(@json)
  end

  def expected_activity_type?
    equals_or_includes_any?(@json['type'], %w(Create Announce))
  end

  def expected_object_type?
    equals_or_includes_any?(@json['type'], ActivityPub::Activity::Create::SUPPORTED_TYPES + ActivityPub::Activity::Create::CONVERTED_TYPES)
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe ActivityPub::FetchRemoteStatusService, type: :service do
  include ActionView::Helpers::TextHelper

  subject { described_class.new }

  let!(:sender) { Fabricate(:account, domain: 'foo.bar', uri: 'https://foo.bar') }
  let!(:recipient) { Fabricate(:account) }

  let(:existing_status) { nil }

  let(:note) do
    {
      '@context': 'https://www.w3.org/ns/activitystreams',
      id: 'https://foo.bar/@foo/1234',
      type: 'Note',
      content: 'Lorem ipsum',
      attributedTo: ActivityPub::TagManager.instance.uri_for(sender),
    }
  end

  before do
    stub_request(:get, 'https://foo.bar/watch?v=12345').to_return(status: 404, body: '')
    stub_request(:get, object[:id]).to_return(body: Oj.dump(object))
  end

  describe '#call' do
    before do
      existing_status
      subject.call(object[:id], prefetched_body: Oj.dump(object))
    end

    context 'with Note object' do
      let(:object) { note }

      it 'creates status' do
        status = sender.statuses.first

        expect(status).to_not be_nil
        expect(status.text).to eq 'Lorem ipsum'
      end
    end

    context 'with Video object' do
      let(:object) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'https://foo.bar/@foo/1234',
          type: 'Video',
          name: 'Nyan Cat 10 hours remix',
          attributedTo: ActivityPub::TagManager.instance.uri_for(sender),
          url: [
            {
              type: 'Link',
              mimeType: 'application/x-bittorrent',
              href: 'https://foo.bar/12345.torrent',
            },

            {
              type: 'Link',
              mimeType: 'text/html',
              href: 'https://foo.bar/watch?v=12345',
            },
          ],
        }
      end

      it 'creates status' do
        status = sender.statuses.first

        expect(status).to_not be_nil
        expect(status.url).to eq 'https://foo.bar/watch?v=12345'
        expect(strip_tags(status.text)).to eq 'Nyan Cat 10 hours remixhttps://foo.bar/watch?v=12345'
      end
    end

    context 'with Audio object' do
      let(:object) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'https://foo.bar/@foo/1234',
          type: 'Audio',
          name: 'Nyan Cat 10 hours remix',
          attributedTo: ActivityPub::TagManager.instance.uri_for(sender),
          url: [
            {
              type: 'Link',
              mimeType: 'application/x-bittorrent',
              href: 'https://foo.bar/12345.torrent',
            },

            {
              type: 'Link',
              mimeType: 'text/html',
              href: 'https://foo.bar/watch?v=12345',
            },
          ],
        }
      end

      it 'creates status' do
        status = sender.statuses.first

        expect(status).to_not be_nil
        expect(status.url).to eq 'https://foo.bar/watch?v=12345'
        expect(strip_tags(status.text)).to eq 'Nyan Cat 10 hours remixhttps://foo.bar/watch?v=12345'
      end
    end

    context 'with Event object' do
      let(:object) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'https://foo.bar/@foo/1234',
          type: 'Event',
          name: ""Let's change the world"",
          attributedTo: ActivityPub::TagManager.instance.uri_for(sender),
        }
      end

      it 'creates status' do
        status = sender.statuses.first

        expect(status).to_not be_nil
        expect(status.url).to eq 'https://foo.bar/@foo/1234'
        expect(strip_tags(status.text)).to eq ""Let's change the worldhttps://foo.bar/@foo/1234""
      end
    end

    context 'with wrong id' do
      let(:note) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'https://real.address/@foo/1234',
          type: 'Note',
          content: 'Lorem ipsum',
          attributedTo: ActivityPub::TagManager.instance.uri_for(sender),
        }
      end

      let(:object) do
        temp = note.dup
        temp[:id] = 'https://fake.address/@foo/5678'
        temp
      end

      it 'does not create status' do
        expect(sender.statuses.first).to be_nil
      end
    end

    context 'with a valid Create activity' do
      let(:object) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'https://foo.bar/@foo/1234/create',
          type: 'Create',
          actor: ActivityPub::TagManager.instance.uri_for(sender),
          object: note,
        }
      end

      it 'creates status' do
        status = sender.statuses.first

        expect(status).to_not be_nil
        expect(status.uri).to eq note[:id]
        expect(status.text).to eq note[:content]
      end
    end

    context 'with a Create activity with a mismatching id' do
      let(:object) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'https://foo.bar/@foo/1234/create',
          type: 'Create',
          actor: ActivityPub::TagManager.instance.uri_for(sender),
          object: {
            id: 'https://real.address/@foo/1234',
            type: 'Note',
            content: 'Lorem ipsum',
            attributedTo: ActivityPub::TagManager.instance.uri_for(sender),
          },
        }
      end

      it 'does not create status' do
        expect(sender.statuses.first).to be_nil
      end
    end

    context 'when status already exists' do
      let(:existing_status) { Fabricate(:status, account: sender, text: 'Foo', uri: note[:id]) }

      context 'with a Note object' do
        let(:object) { note.merge(updated: '2021-09-08T22:39:25Z') }

        it 'updates status' do
          existing_status.reload
          expect(existing_status.text).to eq 'Lorem ipsum'
          expect(existing_status.edits).to_not be_empty
        end
      end

      context 'with a Create activity' do
        let(:object) do
          {
            '@context': 'https://www.w3.org/ns/activitystreams',
            id: 'https://foo.bar/@foo/1234/create',
            type: 'Create',
            actor: ActivityPub::TagManager.instance.uri_for(sender),
            object: note.merge(updated: '2021-09-08T22:39:25Z'),
          }
        end

        it 'updates status' do
          existing_status.reload
          expect(existing_status.text).to eq 'Lorem ipsum'
          expect(existing_status.edits).to_not be_empty
        end
      end
    end
  end

  context 'with statuses referencing other statuses' do
    before do
      stub_const 'ActivityPub::FetchRemoteStatusService::DISCOVERIES_PER_REQUEST', 5
    end

    context 'when using inReplyTo' do
      let(:object) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'https://foo.bar/@foo/1',
          type: 'Note',
          content: 'Lorem ipsum',
          inReplyTo: 'https://foo.bar/@foo/2',
          attributedTo: ActivityPub::TagManager.instance.uri_for(sender),
        }
      end

      before do
        8.times do |i|
          status_json = {
            '@context': 'https://www.w3.org/ns/activitystreams',
            id: ""https://foo.bar/@foo/#{i}"",
            type: 'Note',
            content: 'Lorem ipsum',
            inReplyTo: ""https://foo.bar/@foo/#{i + 1}"",
            attributedTo: ActivityPub::TagManager.instance.uri_for(sender),
            to: 'as:Public',
          }.with_indifferent_access
          stub_request(:get, ""https://foo.bar/@foo/#{i}"").to_return(status: 200, body: status_json.to_json, headers: { 'Content-Type': 'application/activity+json' })
        end
      end

      it 'creates at least some statuses' do
        expect { subject.call(object[:id], prefetched_body: Oj.dump(object)) }.to change { sender.statuses.count }.by_at_least(2)
      end

      it 'creates no more account than the limit allows' do
        expect { subject.call(object[:id], prefetched_body: Oj.dump(object)) }.to change { sender.statuses.count }.by_at_most(5)
      end
    end

    context 'when using replies' do
      let(:object) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'https://foo.bar/@foo/1',
          type: 'Note',
          content: 'Lorem ipsum',
          replies: {
            type: 'Collection',
            id: 'https://foo.bar/@foo/1/replies',
            first: {
              type: 'CollectionPage',
              partOf: 'https://foo.bar/@foo/1/replies',
              items: ['https://foo.bar/@foo/2'],
            },
          },
          attributedTo: ActivityPub::TagManager.instance.uri_for(sender),
        }
      end

      before do
        8.times do |i|
          status_json = {
            '@context': 'https://www.w3.org/ns/activitystreams',
            id: ""https://foo.bar/@foo/#{i}"",
            type: 'Note',
            content: 'Lorem ipsum',
            replies: {
              type: 'Collection',
              id: ""https://foo.bar/@foo/#{i}/replies"",
              first: {
                type: 'CollectionPage',
                partOf: ""https://foo.bar/@foo/#{i}/replies"",
                items: [""https://foo.bar/@foo/#{i + 1}""],
              },
            },
            attributedTo: ActivityPub::TagManager.instance.uri_for(sender),
            to: 'as:Public',
          }.with_indifferent_access
          stub_request(:get, ""https://foo.bar/@foo/#{i}"").to_return(status: 200, body: status_json.to_json, headers: { 'Content-Type': 'application/activity+json' })
        end
      end

      it 'creates at least some statuses' do
        expect { subject.call(object[:id], prefetched_body: Oj.dump(object)) }.to change { sender.statuses.count }.by_at_least(2)
      end

      it 'creates no more account than the limit allows' do
        expect { subject.call(object[:id], prefetched_body: Oj.dump(object)) }.to change { sender.statuses.count }.by_at_most(5)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class ActivityPub::ProcessAccountService < BaseService
  include JsonLdHelper
  include DomainControlHelper
  include Redisable
  include Lockable

  SUBDOMAINS_RATELIMIT = 10
  DISCOVERIES_PER_REQUEST = 400

  # Should be called with confirmed valid JSON
  # and WebFinger-resolved username and domain
  def call(username, domain, json, options = {})
    return if json['inbox'].blank? || unsupported_uri_scheme?(json['id']) || domain_not_allowed?(domain)

    @options     = options
    @json        = json
    @uri         = @json['id']
    @username    = username
    @domain      = TagManager.instance.normalize_domain(domain)
    @collections = {}

    # The key does not need to be unguessable, it just needs to be somewhat unique
    @options[:request_id] ||= ""#{Time.now.utc.to_i}-#{username}@#{domain}""

    with_redis_lock(""process_account:#{@uri}"") do
      @account            = Account.remote.find_by(uri: @uri) if @options[:only_key]
      @account          ||= Account.find_remote(@username, @domain)
      @old_public_key     = @account&.public_key
      @old_protocol       = @account&.protocol
      @suspension_changed = false

      if @account.nil?
        with_redis do |redis|
          return nil if redis.pfcount(""unique_subdomains_for:#{PublicSuffix.domain(@domain, ignore_private: true)}"") >= SUBDOMAINS_RATELIMIT

          discoveries = redis.incr(""discovery_per_request:#{@options[:request_id]}"")
          redis.expire(""discovery_per_request:#{@options[:request_id]}"", 5.minutes.seconds)
          return nil if discoveries > DISCOVERIES_PER_REQUEST
        end

        create_account
      end

      update_account
      process_tags

      process_duplicate_accounts! if @options[:verified_webfinger]
    end

    after_protocol_change! if protocol_changed?
    after_key_change! if key_changed? && !@options[:signed_with_known_key]
    clear_tombstones! if key_changed?
    after_suspension_change! if suspension_changed?

    unless @options[:only_key] || @account.suspended?
      check_featured_collection! if @account.featured_collection_url.present?
      check_featured_tags_collection! if @json['featuredTags'].present?
      check_links! if @account.fields.any?(&:requires_verification?)
    end

    @account
  rescue Oj::ParseError
    nil
  end

  private

  def create_account
    @account = Account.new
    @account.protocol          = :activitypub
    @account.username          = @username
    @account.domain            = @domain
    @account.private_key       = nil
    @account.suspended_at      = domain_block.created_at if auto_suspend?
    @account.suspension_origin = :local if auto_suspend?
    @account.silenced_at       = domain_block.created_at if auto_silence?

    set_immediate_protocol_attributes!

    @account.save!
  end

  def update_account
    @account.last_webfingered_at = Time.now.utc unless @options[:only_key]
    @account.protocol            = :activitypub

    set_suspension!
    set_immediate_protocol_attributes!
    set_fetchable_key! unless @account.suspended? && @account.suspension_origin_local?
    set_immediate_attributes! unless @account.suspended?
    set_fetchable_attributes! unless @options[:only_key] || @account.suspended?

    @account.save_with_optional_media!
  end

  def set_immediate_protocol_attributes!
    @account.inbox_url               = @json['inbox'] || ''
    @account.outbox_url              = @json['outbox'] || ''
    @account.shared_inbox_url        = (@json['endpoints'].is_a?(Hash) ? @json['endpoints']['sharedInbox'] : @json['sharedInbox']) || ''
    @account.followers_url           = @json['followers'] || ''
    @account.url                     = url || @uri
    @account.uri                     = @uri
    @account.actor_type              = actor_type
    @account.created_at              = @json['published'] if @json['published'].present?
  end

  def set_immediate_attributes!
    @account.featured_collection_url = @json['featured'] || ''
    @account.devices_url             = @json['devices'] || ''
    @account.display_name            = @json['name'] || ''
    @account.note                    = @json['summary'] || ''
    @account.locked                  = @json['manuallyApprovesFollowers'] || false
    @account.fields                  = property_values || {}
    @account.also_known_as           = as_array(@json['alsoKnownAs'] || []).map { |item| value_or_id(item) }
    @account.discoverable            = @json['discoverable'] || false
    @account.indexable               = @json['indexable'] || false
    @account.memorial                = @json['memorial'] || false
  end

  def set_fetchable_key!
    @account.public_key = public_key || ''
  end

  def set_fetchable_attributes!
    begin
      @account.avatar_remote_url = image_url('icon') || '' unless skip_download?
      @account.avatar = nil if @account.avatar_remote_url.blank?
    rescue Mastodon::UnexpectedResponseError, HTTP::TimeoutError, HTTP::ConnectionError, OpenSSL::SSL::SSLError
      RedownloadAvatarWorker.perform_in(rand(30..600).seconds, @account.id)
    end
    begin
      @account.header_remote_url = image_url('image') || '' unless skip_download?
      @account.header = nil if @account.header_remote_url.blank?
    rescue Mastodon::UnexpectedResponseError, HTTP::TimeoutError, HTTP::ConnectionError, OpenSSL::SSL::SSLError
      RedownloadHeaderWorker.perform_in(rand(30..600).seconds, @account.id)
    end
    @account.statuses_count    = outbox_total_items    if outbox_total_items.present?
    @account.following_count   = following_total_items if following_total_items.present?
    @account.followers_count   = followers_total_items if followers_total_items.present?
    @account.hide_collections  = following_private? || followers_private?
    @account.moved_to_account  = @json['movedTo'].present? ? moved_account : nil
  end

  def set_suspension!
    return if @account.suspended? && @account.suspension_origin_local?

    if @account.suspended? && !@json['suspended']
      @account.unsuspend!
      @suspension_changed = true
    elsif !@account.suspended? && @json['suspended']
      @account.suspend!(origin: :remote)
      @suspension_changed = true
    end
  end

  def after_protocol_change!
    ActivityPub::PostUpgradeWorker.perform_async(@account.domain)
  end

  def after_key_change!
    RefollowWorker.perform_async(@account.id)
  end

  def after_suspension_change!
    if @account.suspended?
      Admin::SuspensionWorker.perform_async(@account.id)
    else
      Admin::UnsuspensionWorker.perform_async(@account.id)
    end
  end

  def check_featured_collection!
    ActivityPub::SynchronizeFeaturedCollectionWorker.perform_async(@account.id, { 'hashtag' => @json['featuredTags'].blank?, 'request_id' => @options[:request_id] })
  end

  def check_featured_tags_collection!
    ActivityPub::SynchronizeFeaturedTagsCollectionWorker.perform_async(@account.id, @json['featuredTags'])
  end

  def check_links!
    VerifyAccountLinksWorker.perform_in(rand(10.minutes.to_i), @account.id)
  end

  def process_duplicate_accounts!
    return unless Account.where(uri: @account.uri).where.not(id: @account.id).exists?

    AccountMergingWorker.perform_async(@account.id)
  end

  def actor_type
    if @json['type'].is_a?(Array)
      @json['type'].find { |type| ActivityPub::FetchRemoteAccountService::SUPPORTED_TYPES.include?(type) }
    else
      @json['type']
    end
  end

  def image_url(key)
    value = first_of_value(@json[key])

    return if value.nil?
    return value['url'] if value.is_a?(Hash)

    image = fetch_resource_without_id_validation(value)
    image['url'] if image
  end

  def public_key
    value = first_of_value(@json['publicKey'])

    return if value.nil?
    return value['publicKeyPem'] if value.is_a?(Hash)

    key = fetch_resource_without_id_validation(value)
    key['publicKeyPem'] if key
  end

  def url
    return if @json['url'].blank?

    url_candidate = url_to_href(@json['url'], 'text/html')

    if unsupported_uri_scheme?(url_candidate) || mismatching_origin?(url_candidate)
      nil
    else
      url_candidate
    end
  end

  def property_values
    return unless @json['attachment'].is_a?(Array)

    as_array(@json['attachment']).select { |attachment| attachment['type'] == 'PropertyValue' }.map { |attachment| attachment.slice('name', 'value') }
  end

  def mismatching_origin?(url)
    needle   = Addressable::URI.parse(url).host
    haystack = Addressable::URI.parse(@uri).host

    !haystack.casecmp(needle).zero?
  end

  def outbox_total_items
    collection_info('outbox').first
  end

  def following_total_items
    collection_info('following').first
  end

  def followers_total_items
    collection_info('followers').first
  end

  def following_private?
    !collection_info('following').last
  end

  def followers_private?
    !collection_info('followers').last
  end

  def collection_info(type)
    return [nil, nil] if @json[type].blank?
    return @collections[type] if @collections.key?(type)

    collection = fetch_resource_without_id_validation(@json[type])

    total_items = collection.is_a?(Hash) && collection['totalItems'].present? && collection['totalItems'].is_a?(Numeric) ? collection['totalItems'] : nil
    has_first_page = collection.is_a?(Hash) && collection['first'].present?
    @collections[type] = [total_items, has_first_page]
  rescue HTTP::Error, OpenSSL::SSL::SSLError, Mastodon::LengthValidationError
    @collections[type] = [nil, nil]
  end

  def moved_account
    account   = ActivityPub::TagManager.instance.uri_to_resource(@json['movedTo'], Account)
    account ||= ActivityPub::FetchRemoteAccountService.new.call(@json['movedTo'], id: true, break_on_redirect: true, request_id: @options[:request_id])
    account
  end

  def skip_download?
    @account.suspended? || domain_block&.reject_media?
  end

  def auto_suspend?
    domain_block&.suspend?
  end

  def auto_silence?
    domain_block&.silence?
  end

  def domain_block
    return @domain_block if defined?(@domain_block)

    @domain_block = DomainBlock.rule_for(@domain)
  end

  def key_changed?
    !@old_public_key.nil? && @old_public_key != @account.public_key
  end

  def suspension_changed?
    @suspension_changed
  end

  def clear_tombstones!
    Tombstone.where(account_id: @account.id).delete_all
  end

  def protocol_changed?
    !@old_protocol.nil? && @old_protocol != @account.protocol
  end

  def process_tags
    return if @json['tag'].blank?

    as_array(@json['tag']).each do |tag|
      process_emoji tag if equals_or_includes?(tag['type'], 'Emoji')
    end
  end

  def process_emoji(tag)
    return if skip_download?
    return if tag['name'].blank? || tag['icon'].blank? || tag['icon']['url'].blank?

    shortcode = tag['name'].delete(':')
    image_url = tag['icon']['url']
    uri       = tag['id']
    updated   = tag['updated']
    emoji     = CustomEmoji.find_by(shortcode: shortcode, domain: @account.domain)

    return unless emoji.nil? || image_url != emoji.image_remote_url || (updated && updated >= emoji.updated_at)

    emoji ||= CustomEmoji.new(domain: @account.domain, shortcode: shortcode, uri: uri)
    emoji.image_remote_url = image_url
    emoji.save
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe ActivityPub::ProcessAccountService, type: :service do
  subject { described_class.new }

  context 'with property values' do
    let(:payload) do
      {
        id: 'https://foo.test',
        type: 'Actor',
        inbox: 'https://foo.test/inbox',
        attachment: [
          { type: 'PropertyValue', name: 'Pronouns', value: 'They/them' },
          { type: 'PropertyValue', name: 'Occupation', value: 'Unit test' },
          { type: 'PropertyValue', name: 'non-string', value: %w(foo bar) },
        ],
      }.with_indifferent_access
    end

    it 'parses out of attachment' do
      account = subject.call('alice', 'example.com', payload)
      expect(account.fields).to be_a Array
      expect(account.fields.size).to eq 2
      expect(account.fields[0]).to be_a Account::Field
      expect(account.fields[0].name).to eq 'Pronouns'
      expect(account.fields[0].value).to eq 'They/them'
      expect(account.fields[1]).to be_a Account::Field
      expect(account.fields[1].name).to eq 'Occupation'
      expect(account.fields[1].value).to eq 'Unit test'
    end
  end

  context 'when account is not suspended' do
    subject { described_class.new.call('alice', 'example.com', payload) }

    let!(:account) { Fabricate(:account, username: 'alice', domain: 'example.com') }

    let(:payload) do
      {
        id: 'https://foo.test',
        type: 'Actor',
        inbox: 'https://foo.test/inbox',
        suspended: true,
      }.with_indifferent_access
    end

    before do
      allow(Admin::SuspensionWorker).to receive(:perform_async)
    end

    it 'suspends account remotely' do
      expect(subject.suspended?).to be true
      expect(subject.suspension_origin_remote?).to be true
    end

    it 'queues suspension worker' do
      subject
      expect(Admin::SuspensionWorker).to have_received(:perform_async)
    end
  end

  context 'when account is suspended' do
    subject { described_class.new.call('alice', 'example.com', payload) }

    let!(:account) { Fabricate(:account, username: 'alice', domain: 'example.com', display_name: '') }

    let(:payload) do
      {
        id: 'https://foo.test',
        type: 'Actor',
        inbox: 'https://foo.test/inbox',
        suspended: false,
        name: 'Hoge',
      }.with_indifferent_access
    end

    before do
      allow(Admin::UnsuspensionWorker).to receive(:perform_async)

      account.suspend!(origin: suspension_origin)
    end

    context 'when locally' do
      let(:suspension_origin) { :local }

      it 'does not unsuspend it' do
        expect(subject.suspended?).to be true
      end

      it 'does not update any attributes' do
        expect(subject.display_name).to_not eq 'Hoge'
      end
    end

    context 'when remotely' do
      let(:suspension_origin) { :remote }

      it 'unsuspends it' do
        expect(subject.suspended?).to be false
      end

      it 'queues unsuspension worker' do
        subject
        expect(Admin::UnsuspensionWorker).to have_received(:perform_async)
      end

      it 'updates attributes' do
        expect(subject.display_name).to eq 'Hoge'
      end
    end
  end

  context 'when discovering many subdomains in a short timeframe' do
    subject do
      8.times do |i|
        domain = ""test#{i}.testdomain.com""
        json = {
          id: ""https://#{domain}/users/1"",
          type: 'Actor',
          inbox: ""https://#{domain}/inbox"",
        }.with_indifferent_access
        described_class.new.call('alice', domain, json)
      end
    end

    before do
      stub_const 'ActivityPub::ProcessAccountService::SUBDOMAINS_RATELIMIT', 5
    end

    it 'creates at least some accounts' do
      expect { subject }.to change { Account.remote.count }.by_at_least(2)
    end

    it 'creates no more account than the limit allows' do
      expect { subject }.to change { Account.remote.count }.by_at_most(5)
    end
  end

  context 'when Accounts referencing other accounts' do
    let(:payload) do
      {
        '@context': ['https://www.w3.org/ns/activitystreams'],
        id: 'https://foo.test/users/1',
        type: 'Person',
        inbox: 'https://foo.test/inbox',
        featured: 'https://foo.test/users/1/featured',
        preferredUsername: 'user1',
      }.with_indifferent_access
    end

    before do
      stub_const 'ActivityPub::ProcessAccountService::DISCOVERIES_PER_REQUEST', 5

      8.times do |i|
        actor_json = {
          '@context': ['https://www.w3.org/ns/activitystreams'],
          id: ""https://foo.test/users/#{i}"",
          type: 'Person',
          inbox: 'https://foo.test/inbox',
          featured: ""https://foo.test/users/#{i}/featured"",
          preferredUsername: ""user#{i}"",
        }.with_indifferent_access
        status_json = {
          '@context': ['https://www.w3.org/ns/activitystreams'],
          id: ""https://foo.test/users/#{i}/status"",
          attributedTo: ""https://foo.test/users/#{i}"",
          type: 'Note',
          content: ""@user#{i + 1} test"",
          tag: [
            {
              type: 'Mention',
              href: ""https://foo.test/users/#{i + 1}"",
              name: ""@user#{i + 1}"",
            },
          ],
          to: ['as:Public', ""https://foo.test/users/#{i + 1}""],
        }.with_indifferent_access
        featured_json = {
          '@context': ['https://www.w3.org/ns/activitystreams'],
          id: ""https://foo.test/users/#{i}/featured"",
          type: 'OrderedCollection',
          totalItems: 1,
          orderedItems: [status_json],
        }.with_indifferent_access
        webfinger = {
          subject: ""acct:user#{i}@foo.test"",
          links: [{ rel: 'self', href: ""https://foo.test/users/#{i}"" }],
        }.with_indifferent_access
        stub_request(:get, ""https://foo.test/users/#{i}"").to_return(status: 200, body: actor_json.to_json, headers: { 'Content-Type': 'application/activity+json' })
        stub_request(:get, ""https://foo.test/users/#{i}/featured"").to_return(status: 200, body: featured_json.to_json, headers: { 'Content-Type': 'application/activity+json' })
        stub_request(:get, ""https://foo.test/users/#{i}/status"").to_return(status: 200, body: status_json.to_json, headers: { 'Content-Type': 'application/activity+json' })
        stub_request(:get, ""https://foo.test/.well-known/webfinger?resource=acct:user#{i}@foo.test"").to_return(body: webfinger.to_json, headers: { 'Content-Type': 'application/jrd+json' })
      end
    end

    it 'creates at least some accounts' do
      expect { subject.call('user1', 'foo.test', payload) }.to change { Account.remote.count }.by_at_least(2)
    end

    it 'creates no more account than the limit allows' do
      expect { subject.call('user1', 'foo.test', payload) }.to change { Account.remote.count }.by_at_most(5)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class ActivityPub::FetchRepliesService < BaseService
  include JsonLdHelper

  def call(parent_status, collection_or_uri, allow_synchronous_requests: true, request_id: nil)
    @account = parent_status.account
    @allow_synchronous_requests = allow_synchronous_requests

    @items = collection_items(collection_or_uri)
    return if @items.nil?

    FetchReplyWorker.push_bulk(filtered_replies) { |reply_uri| [reply_uri, { 'request_id' => request_id }] }

    @items
  end

  private

  def collection_items(collection_or_uri)
    collection = fetch_collection(collection_or_uri)
    return unless collection.is_a?(Hash)

    collection = fetch_collection(collection['first']) if collection['first'].present?
    return unless collection.is_a?(Hash)

    case collection['type']
    when 'Collection', 'CollectionPage'
      collection['items']
    when 'OrderedCollection', 'OrderedCollectionPage'
      collection['orderedItems']
    end
  end

  def fetch_collection(collection_or_uri)
    return collection_or_uri if collection_or_uri.is_a?(Hash)
    return unless @allow_synchronous_requests
    return if non_matching_uri_hosts?(@account.uri, collection_or_uri)

    fetch_resource_without_id_validation(collection_or_uri, nil, true)
  end

  def filtered_replies
    # Only fetch replies to the same server as the original status to avoid
    # amplification attacks.

    # Also limit to 5 fetched replies to limit potential for DoS.
    @items.map { |item| value_or_id(item) }.reject { |uri| non_matching_uri_hosts?(@account.uri, uri) }.take(5)
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe ActivityPub::FetchRepliesService, type: :service do
  subject { described_class.new }

  let(:actor)          { Fabricate(:account, domain: 'example.com', uri: 'http://example.com/account') }
  let(:status)         { Fabricate(:status, account: actor) }
  let(:collection_uri) { 'http://example.com/replies/1' }

  let(:items) do
    [
      'http://example.com/self-reply-1',
      'http://example.com/self-reply-2',
      'http://example.com/self-reply-3',
      'http://other.com/other-reply-1',
      'http://other.com/other-reply-2',
      'http://other.com/other-reply-3',
      'http://example.com/self-reply-4',
      'http://example.com/self-reply-5',
      'http://example.com/self-reply-6',
    ]
  end

  let(:payload) do
    {
      '@context': 'https://www.w3.org/ns/activitystreams',
      type: 'Collection',
      id: collection_uri,
      items: items,
    }.with_indifferent_access
  end

  describe '#call' do
    context 'when the payload is a Collection with inlined replies' do
      context 'when passing the collection itself' do
        it 'spawns workers for up to 5 replies on the same server' do
          allow(FetchReplyWorker).to receive(:push_bulk)

          subject.call(status, payload)

          expect(FetchReplyWorker).to have_received(:push_bulk).with(['http://example.com/self-reply-1', 'http://example.com/self-reply-2', 'http://example.com/self-reply-3', 'http://example.com/self-reply-4', 'http://example.com/self-reply-5'])
        end
      end

      context 'when passing the URL to the collection' do
        before do
          stub_request(:get, collection_uri).to_return(status: 200, body: Oj.dump(payload))
        end

        it 'spawns workers for up to 5 replies on the same server' do
          allow(FetchReplyWorker).to receive(:push_bulk)

          subject.call(status, collection_uri)

          expect(FetchReplyWorker).to have_received(:push_bulk).with(['http://example.com/self-reply-1', 'http://example.com/self-reply-2', 'http://example.com/self-reply-3', 'http://example.com/self-reply-4', 'http://example.com/self-reply-5'])
        end
      end
    end

    context 'when the payload is an OrderedCollection with inlined replies' do
      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          type: 'OrderedCollection',
          id: collection_uri,
          orderedItems: items,
        }.with_indifferent_access
      end

      context 'when passing the collection itself' do
        it 'spawns workers for up to 5 replies on the same server' do
          allow(FetchReplyWorker).to receive(:push_bulk)

          subject.call(status, payload)

          expect(FetchReplyWorker).to have_received(:push_bulk).with(['http://example.com/self-reply-1', 'http://example.com/self-reply-2', 'http://example.com/self-reply-3', 'http://example.com/self-reply-4', 'http://example.com/self-reply-5'])
        end
      end

      context 'when passing the URL to the collection' do
        before do
          stub_request(:get, collection_uri).to_return(status: 200, body: Oj.dump(payload))
        end

        it 'spawns workers for up to 5 replies on the same server' do
          allow(FetchReplyWorker).to receive(:push_bulk)

          subject.call(status, collection_uri)

          expect(FetchReplyWorker).to have_received(:push_bulk).with(['http://example.com/self-reply-1', 'http://example.com/self-reply-2', 'http://example.com/self-reply-3', 'http://example.com/self-reply-4', 'http://example.com/self-reply-5'])
        end
      end
    end

    context 'when the payload is a paginated Collection with inlined replies' do
      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          type: 'Collection',
          id: collection_uri,
          first: {
            type: 'CollectionPage',
            partOf: collection_uri,
            items: items,
          },
        }.with_indifferent_access
      end

      context 'when passing the collection itself' do
        it 'spawns workers for up to 5 replies on the same server' do
          allow(FetchReplyWorker).to receive(:push_bulk)

          subject.call(status, payload)

          expect(FetchReplyWorker).to have_received(:push_bulk).with(['http://example.com/self-reply-1', 'http://example.com/self-reply-2', 'http://example.com/self-reply-3', 'http://example.com/self-reply-4', 'http://example.com/self-reply-5'])
        end
      end

      context 'when passing the URL to the collection' do
        before do
          stub_request(:get, collection_uri).to_return(status: 200, body: Oj.dump(payload))
        end

        it 'spawns workers for up to 5 replies on the same server' do
          allow(FetchReplyWorker).to receive(:push_bulk)

          subject.call(status, collection_uri)

          expect(FetchReplyWorker).to have_received(:push_bulk).with(['http://example.com/self-reply-1', 'http://example.com/self-reply-2', 'http://example.com/self-reply-3', 'http://example.com/self-reply-4', 'http://example.com/self-reply-5'])
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class ActivityPub::SynchronizeFollowersService < BaseService
  include JsonLdHelper
  include Payloadable

  def call(account, partial_collection_url)
    @account = account

    items = collection_items(partial_collection_url)
    return if items.nil?

    # There could be unresolved accounts (hence the call to .compact) but this
    # should never happen in practice, since in almost all cases we keep an
    # Account record, and should we not do that, we should have sent a Delete.
    # In any case there is not much we can do if that occurs.
    @expected_followers = items.filter_map { |uri| ActivityPub::TagManager.instance.uri_to_resource(uri, Account) }

    remove_unexpected_local_followers!
    handle_unexpected_outgoing_follows!
  end

  private

  def remove_unexpected_local_followers!
    @account.followers.local.where.not(id: @expected_followers.map(&:id)).reorder(nil).find_each do |unexpected_follower|
      UnfollowService.new.call(unexpected_follower, @account)
    end
  end

  def handle_unexpected_outgoing_follows!
    @expected_followers.each do |expected_follower|
      next if expected_follower.following?(@account)

      if expected_follower.requested?(@account)
        # For some reason the follow request went through but we missed it
        expected_follower.follow_requests.find_by(target_account: @account)&.authorize!
      else
        # Since we were not aware of the follow from our side, we do not have an
        # ID for it that we can include in the Undo activity. For this reason,
        # the Undo may not work with software that relies exclusively on
        # matching activity IDs and not the actor and target
        follow = Follow.new(account: expected_follower, target_account: @account)
        ActivityPub::DeliveryWorker.perform_async(build_undo_follow_json(follow), follow.account_id, follow.target_account.inbox_url)
      end
    end
  end

  def build_undo_follow_json(follow)
    Oj.dump(serialize_payload(follow, ActivityPub::UndoFollowSerializer))
  end

  def collection_items(collection_or_uri)
    collection = fetch_collection(collection_or_uri)
    return unless collection.is_a?(Hash)

    collection = fetch_collection(collection['first']) if collection['first'].present?
    return unless collection.is_a?(Hash)

    case collection['type']
    when 'Collection', 'CollectionPage'
      collection['items']
    when 'OrderedCollection', 'OrderedCollectionPage'
      collection['orderedItems']
    end
  end

  def fetch_collection(collection_or_uri)
    return collection_or_uri if collection_or_uri.is_a?(Hash)
    return if non_matching_uri_hosts?(@account.uri, collection_or_uri)

    fetch_resource_without_id_validation(collection_or_uri, nil, true)
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

RSpec.describe ActivityPub::SynchronizeFollowersService, type: :service do
  subject { described_class.new }

  let(:actor)          { Fabricate(:account, domain: 'example.com', uri: 'http://example.com/account', inbox_url: 'http://example.com/inbox') }
  let(:alice)          { Fabricate(:account, username: 'alice') }
  let(:bob)            { Fabricate(:account, username: 'bob') }
  let(:eve)            { Fabricate(:account, username: 'eve') }
  let(:mallory)        { Fabricate(:account, username: 'mallory') }
  let(:collection_uri) { 'http://example.com/partial-followers' }

  let(:items) do
    [
      ActivityPub::TagManager.instance.uri_for(alice),
      ActivityPub::TagManager.instance.uri_for(eve),
      ActivityPub::TagManager.instance.uri_for(mallory),
    ]
  end

  let(:payload) do
    {
      '@context': 'https://www.w3.org/ns/activitystreams',
      type: 'Collection',
      id: collection_uri,
      items: items,
    }.with_indifferent_access
  end

  shared_examples 'synchronizes followers' do
    before do
      alice.follow!(actor)
      bob.follow!(actor)
      mallory.request_follow!(actor)

      allow(ActivityPub::DeliveryWorker).to receive(:perform_async)

      subject.call(actor, collection_uri)
    end

    it 'keeps expected followers' do
      expect(alice.following?(actor)).to be true
    end

    it 'removes local followers not in the remote list' do
      expect(bob.following?(actor)).to be false
    end

    it 'converts follow requests to follow relationships when they have been accepted' do
      expect(mallory.following?(actor)).to be true
    end

    it 'sends an Undo Follow to the actor' do
      expect(ActivityPub::DeliveryWorker).to have_received(:perform_async).with(anything, eve.id, actor.inbox_url)
    end
  end

  describe '#call' do
    context 'when the endpoint is a Collection of actor URIs' do
      before do
        stub_request(:get, collection_uri).to_return(status: 200, body: Oj.dump(payload))
      end

      it_behaves_like 'synchronizes followers'
    end

    context 'when the endpoint is an OrderedCollection of actor URIs' do
      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          type: 'OrderedCollection',
          id: collection_uri,
          orderedItems: items,
        }.with_indifferent_access
      end

      before do
        stub_request(:get, collection_uri).to_return(status: 200, body: Oj.dump(payload))
      end

      it_behaves_like 'synchronizes followers'
    end

    context 'when the endpoint is a paginated Collection of actor URIs' do
      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          type: 'Collection',
          id: collection_uri,
          first: {
            type: 'CollectionPage',
            partOf: collection_uri,
            items: items,
          },
        }.with_indifferent_access
      end

      before do
        stub_request(:get, collection_uri).to_return(status: 200, body: Oj.dump(payload))
      end

      it_behaves_like 'synchronizes followers'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class ActivityPub::ProcessStatusUpdateService < BaseService
  include JsonLdHelper
  include Redisable
  include Lockable

  def call(status, activity_json, object_json, request_id: nil)
    raise ArgumentError, 'Status has unsaved changes' if status.changed?

    @activity_json             = activity_json
    @json                      = object_json
    @status_parser             = ActivityPub::Parser::StatusParser.new(@json)
    @uri                       = @status_parser.uri
    @status                    = status
    @account                   = status.account
    @media_attachments_changed = false
    @poll_changed              = false
    @request_id                = request_id

    # Only native types can be updated at the moment
    return @status if !expected_type? || already_updated_more_recently?

    if @status_parser.edited_at.present? && (@status.edited_at.nil? || @status_parser.edited_at > @status.edited_at)
      handle_explicit_update!
    else
      handle_implicit_update!
    end

    @status
  end

  private

  def handle_explicit_update!
    last_edit_date = @status.edited_at.presence || @status.created_at

    # Only allow processing one create/update per status at a time
    with_redis_lock(""create:#{@uri}"") do
      Status.transaction do
        record_previous_edit!
        update_media_attachments!
        update_poll!
        update_immediate_attributes!
        update_metadata!
        create_edits!
      end

      download_media_files!
      queue_poll_notifications!

      next unless significant_changes?

      reset_preview_card!
      broadcast_updates!
    end

    forward_activity! if significant_changes? && @status_parser.edited_at > last_edit_date
  end

  def handle_implicit_update!
    with_redis_lock(""create:#{@uri}"") do
      update_poll!(allow_significant_changes: false)
      queue_poll_notifications!
    end
  end

  def update_media_attachments!
    previous_media_attachments     = @status.media_attachments.to_a
    previous_media_attachments_ids = @status.ordered_media_attachment_ids || previous_media_attachments.map(&:id)
    @next_media_attachments        = []

    as_array(@json['attachment']).each do |attachment|
      media_attachment_parser = ActivityPub::Parser::MediaAttachmentParser.new(attachment)

      next if media_attachment_parser.remote_url.blank? || @next_media_attachments.size > 4

      begin
        media_attachment   = previous_media_attachments.find { |previous_media_attachment| previous_media_attachment.remote_url == media_attachment_parser.remote_url }
        media_attachment ||= MediaAttachment.new(account: @account, remote_url: media_attachment_parser.remote_url)

        # If a previously existing media attachment was significantly updated, mark
        # media attachments as changed even if none were added or removed
        @media_attachments_changed = true if media_attachment_parser.significantly_changes?(media_attachment)

        media_attachment.description          = media_attachment_parser.description
        media_attachment.focus                = media_attachment_parser.focus
        media_attachment.thumbnail_remote_url = media_attachment_parser.thumbnail_remote_url
        media_attachment.blurhash             = media_attachment_parser.blurhash
        media_attachment.status_id            = @status.id
        media_attachment.skip_download        = unsupported_media_type?(media_attachment_parser.file_content_type) || skip_download?
        media_attachment.save!

        @next_media_attachments << media_attachment
      rescue Addressable::URI::InvalidURIError => e
        Rails.logger.debug { ""Invalid URL in attachment: #{e}"" }
      end
    end

    @status.ordered_media_attachment_ids = @next_media_attachments.map(&:id)

    @media_attachments_changed = true if @status.ordered_media_attachment_ids != previous_media_attachments_ids
  end

  def download_media_files!
    @next_media_attachments.each do |media_attachment|
      next if media_attachment.skip_download

      media_attachment.download_file! if media_attachment.remote_url_previously_changed?
      media_attachment.download_thumbnail! if media_attachment.thumbnail_remote_url_previously_changed?
      media_attachment.save
    rescue Mastodon::UnexpectedResponseError, HTTP::TimeoutError, HTTP::ConnectionError, OpenSSL::SSL::SSLError
      RedownloadMediaWorker.perform_in(rand(30..600).seconds, media_attachment.id)
    rescue Seahorse::Client::NetworkingError => e
      Rails.logger.warn ""Error storing media attachment: #{e}""
    end

    @status.media_attachments.reload
  end

  def update_poll!(allow_significant_changes: true)
    previous_poll        = @status.preloadable_poll
    @previous_expires_at = previous_poll&.expires_at
    poll_parser          = ActivityPub::Parser::PollParser.new(@json)

    if poll_parser.valid?
      poll = previous_poll || @account.polls.new(status: @status)

      # If for some reasons the options were changed, it invalidates all previous
      # votes, so we need to remove them
      @poll_changed = true if poll_parser.significantly_changes?(poll)
      return if @poll_changed && !allow_significant_changes

      poll.last_fetched_at = Time.now.utc
      poll.options         = poll_parser.options
      poll.multiple        = poll_parser.multiple
      poll.expires_at      = poll_parser.expires_at
      poll.voters_count    = poll_parser.voters_count
      poll.cached_tallies  = poll_parser.cached_tallies
      poll.reset_votes! if @poll_changed
      poll.save!

      @status.poll_id = poll.id
    elsif previous_poll.present?
      return unless allow_significant_changes

      previous_poll.destroy!
      @poll_changed = true
      @status.poll_id = nil
    end
  end

  def update_immediate_attributes!
    @status.text         = @status_parser.text || ''
    @status.spoiler_text = @status_parser.spoiler_text || ''
    @status.sensitive    = @account.sensitized? || @status_parser.sensitive || false
    @status.language     = @status_parser.language

    @significant_changes = text_significantly_changed? || @status.spoiler_text_changed? || @media_attachments_changed || @poll_changed

    @status.edited_at = @status_parser.edited_at if significant_changes?

    @status.save!
  end

  def update_metadata!
    @raw_tags     = []
    @raw_mentions = []
    @raw_emojis   = []

    as_array(@json['tag']).each do |tag|
      if equals_or_includes?(tag['type'], 'Hashtag')
        @raw_tags << tag['name'] if tag['name'].present?
      elsif equals_or_includes?(tag['type'], 'Mention')
        @raw_mentions << tag['href'] if tag['href'].present?
      elsif equals_or_includes?(tag['type'], 'Emoji')
        @raw_emojis << tag
      end
    end

    update_tags!
    update_mentions!
    update_emojis!
  end

  def update_tags!
    @status.tags = Tag.find_or_create_by_names(@raw_tags)
  end

  def update_mentions!
    previous_mentions = @status.active_mentions.includes(:account).to_a
    current_mentions  = []

    @raw_mentions.each do |href|
      next if href.blank?

      account   = ActivityPub::TagManager.instance.uri_to_resource(href, Account)
      account ||= ActivityPub::FetchRemoteAccountService.new.call(href, request_id: @request_id)

      next if account.nil?

      mention   = previous_mentions.find { |x| x.account_id == account.id }
      mention ||= account.mentions.new(status: @status)

      current_mentions << mention
    end

    current_mentions.each do |mention|
      mention.save if mention.new_record?
    end

    # If previous mentions are no longer contained in the text, convert them
    # to silent mentions, since withdrawing access from someone who already
    # received a notification might be more confusing
    removed_mentions = previous_mentions - current_mentions

    Mention.where(id: removed_mentions.map(&:id)).update_all(silent: true) unless removed_mentions.empty?
  end

  def update_emojis!
    return if skip_download?

    @raw_emojis.each do |raw_emoji|
      custom_emoji_parser = ActivityPub::Parser::CustomEmojiParser.new(raw_emoji)

      next if custom_emoji_parser.shortcode.blank? || custom_emoji_parser.image_remote_url.blank?

      emoji = CustomEmoji.find_by(shortcode: custom_emoji_parser.shortcode, domain: @account.domain)

      next unless emoji.nil? || custom_emoji_parser.image_remote_url != emoji.image_remote_url || (custom_emoji_parser.updated_at && custom_emoji_parser.updated_at >= emoji.updated_at)

      begin
        emoji ||= CustomEmoji.new(domain: @account.domain, shortcode: custom_emoji_parser.shortcode, uri: custom_emoji_parser.uri)
        emoji.image_remote_url = custom_emoji_parser.image_remote_url
        emoji.save
      rescue Seahorse::Client::NetworkingError => e
        Rails.logger.warn ""Error storing emoji: #{e}""
      end
    end
  end

  def expected_type?
    equals_or_includes_any?(@json['type'], %w(Note Question))
  end

  def record_previous_edit!
    @previous_edit = @status.build_snapshot(at_time: @status.created_at, rate_limit: false) if @status.edits.empty?
  end

  def create_edits!
    return unless significant_changes?

    @previous_edit&.save!
    @status.snapshot!(account_id: @account.id, rate_limit: false)
  end

  def skip_download?
    return @skip_download if defined?(@skip_download)

    @skip_download ||= DomainBlock.reject_media?(@account.domain)
  end

  def unsupported_media_type?(mime_type)
    mime_type.present? && !MediaAttachment.supported_mime_types.include?(mime_type)
  end

  def significant_changes?
    @significant_changes
  end

  def text_significantly_changed?
    return false unless @status.text_changed?

    old, new = @status.text_change
    HtmlAwareFormatter.new(old, false).to_s != HtmlAwareFormatter.new(new, false).to_s
  end

  def already_updated_more_recently?
    @status.edited_at.present? && @status_parser.edited_at.present? && @status.edited_at > @status_parser.edited_at
  end

  def reset_preview_card!
    @status.reset_preview_card!
    LinkCrawlWorker.perform_in(rand(1..59).seconds, @status.id)
  end

  def broadcast_updates!
    ::DistributionWorker.perform_async(@status.id, { 'update' => true })
  end

  def queue_poll_notifications!
    poll = @status.preloadable_poll

    # If the poll had no expiration date set but now has, or now has a sooner
    # expiration date, and people have voted, schedule a notification

    return unless poll.present? && poll.expires_at.present? && poll.votes.exists?

    PollExpirationNotifyWorker.remove_from_scheduled(poll.id) if @previous_expires_at.present? && @previous_expires_at > poll.expires_at
    PollExpirationNotifyWorker.perform_at(poll.expires_at + 5.minutes, poll.id)
  end

  def forward_activity!
    forwarder.forward! if forwarder.forwardable?
  end

  def forwarder
    @forwarder ||= ActivityPub::Forwarder.new(@account, @activity_json, @status)
  end
end

```","# frozen_string_literal: true

require 'rails_helper'

def poll_option_json(name, votes)
  { type: 'Note', name: name, replies: { type: 'Collection', totalItems: votes } }
end

RSpec.describe ActivityPub::ProcessStatusUpdateService, type: :service do
  subject { described_class.new }

  let!(:status) { Fabricate(:status, text: 'Hello world', account: Fabricate(:account, domain: 'example.com')) }
  let(:payload) do
    {
      '@context': 'https://www.w3.org/ns/activitystreams',
      id: 'foo',
      type: 'Note',
      summary: 'Show more',
      content: 'Hello universe',
      updated: '2021-09-08T22:39:25Z',
      tag: [
        { type: 'Hashtag', name: 'hoge' },
        { type: 'Mention', href: ActivityPub::TagManager.instance.uri_for(alice) },
      ],
    }
  end
  let(:json) { Oj.load(Oj.dump(payload)) }

  let(:alice) { Fabricate(:account) }
  let(:bob) { Fabricate(:account) }

  let(:mentions) { [] }
  let(:tags) { [] }
  let(:media_attachments) { [] }

  before do
    mentions.each { |a| Fabricate(:mention, status: status, account: a) }
    tags.each { |t| status.tags << t }
    media_attachments.each { |m| status.media_attachments << m }
  end

  describe '#call' do
    it 'updates text' do
      subject.call(status, json, json)
      expect(status.reload.text).to eq 'Hello universe'
    end

    it 'updates content warning' do
      subject.call(status, json, json)
      expect(status.reload.spoiler_text).to eq 'Show more'
    end

    context 'when the changes are only in sanitized-out HTML' do
      let!(:status) { Fabricate(:status, text: '<p>Hello world <a href=""https://joinmastodon.org"" rel=""nofollow"">joinmastodon.org</a></p>', account: Fabricate(:account, domain: 'example.com')) }

      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'foo',
          type: 'Note',
          updated: '2021-09-08T22:39:25Z',
          content: '<p>Hello world <a href=""https://joinmastodon.org"" rel=""noreferrer"">joinmastodon.org</a></p>',
        }
      end

      before do
        subject.call(status, json, json)
      end

      it 'does not create any edits' do
        expect(status.reload.edits).to be_empty
      end

      it 'does not mark status as edited' do
        expect(status.edited?).to be false
      end
    end

    context 'when the status has not been explicitly edited' do
      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'foo',
          type: 'Note',
          content: 'Updated text',
        }
      end

      before do
        subject.call(status, json, json)
      end

      it 'does not create any edits' do
        expect(status.reload.edits).to be_empty
      end

      it 'does not mark status as edited' do
        expect(status.reload.edited?).to be false
      end

      it 'does not update the text' do
        expect(status.reload.text).to eq 'Hello world'
      end
    end

    context 'when the status has not been explicitly edited and features a poll' do
      let(:account) { Fabricate(:account, domain: 'example.com') }
      let!(:expiration) { 10.days.from_now.utc }
      let!(:status) do
        Fabricate(:status,
                  text: 'Hello world',
                  account: account,
                  poll_attributes: {
                    options: %w(Foo Bar),
                    account: account,
                    multiple: false,
                    hide_totals: false,
                    expires_at: expiration,
                  })
      end

      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'https://example.com/foo',
          type: 'Question',
          content: 'Hello world',
          endTime: expiration.iso8601,
          oneOf: [
            poll_option_json('Foo', 4),
            poll_option_json('Bar', 3),
          ],
        }
      end

      before do
        subject.call(status, json, json)
      end

      it 'does not create any edits' do
        expect(status.reload.edits).to be_empty
      end

      it 'does not mark status as edited' do
        expect(status.reload.edited?).to be false
      end

      it 'does not update the text' do
        expect(status.reload.text).to eq 'Hello world'
      end

      it 'updates tallies' do
        expect(status.poll.reload.cached_tallies).to eq [4, 3]
      end
    end

    context 'when the status changes a poll despite being not explicitly marked as updated' do
      let(:account) { Fabricate(:account, domain: 'example.com') }
      let!(:expiration) { 10.days.from_now.utc }
      let!(:status) do
        Fabricate(:status,
                  text: 'Hello world',
                  account: account,
                  poll_attributes: {
                    options: %w(Foo Bar),
                    account: account,
                    multiple: false,
                    hide_totals: false,
                    expires_at: expiration,
                  })
      end

      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'https://example.com/foo',
          type: 'Question',
          content: 'Hello world',
          endTime: expiration.iso8601,
          oneOf: [
            poll_option_json('Foo', 4),
            poll_option_json('Bar', 3),
            poll_option_json('Baz', 3),
          ],
        }
      end

      before do
        subject.call(status, json, json)
      end

      it 'does not create any edits' do
        expect(status.reload.edits).to be_empty
      end

      it 'does not mark status as edited' do
        expect(status.reload.edited?).to be false
      end

      it 'does not update the text' do
        expect(status.reload.text).to eq 'Hello world'
      end

      it 'does not update tallies' do
        expect(status.poll.reload.cached_tallies).to eq [0, 0]
      end
    end

    context 'when receiving an edit older than the latest processed' do
      before do
        status.snapshot!(at_time: status.created_at, rate_limit: false)
        status.update!(text: 'Hello newer world', edited_at: Time.now.utc)
        status.snapshot!(rate_limit: false)
      end

      it 'does not create any edits' do
        expect { subject.call(status, json, json) }.to_not(change { status.reload.edits.pluck(&:id) })
      end

      it 'does not update the text, spoiler_text or edited_at' do
        expect { subject.call(status, json, json) }.to_not(change { s = status.reload; [s.text, s.spoiler_text, s.edited_at] })
      end
    end

    context 'with no changes at all' do
      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'foo',
          type: 'Note',
          content: 'Hello world',
        }
      end

      before do
        subject.call(status, json, json)
      end

      it 'does not create any edits' do
        expect(status.reload.edits).to be_empty
      end

      it 'does not mark status as edited' do
        expect(status.edited?).to be false
      end
    end

    context 'with no changes and originally with no ordered_media_attachment_ids' do
      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'foo',
          type: 'Note',
          content: 'Hello world',
        }
      end

      before do
        status.update(ordered_media_attachment_ids: nil)
        subject.call(status, json, json)
      end

      it 'does not create any edits' do
        expect(status.reload.edits).to be_empty
      end

      it 'does not mark status as edited' do
        expect(status.edited?).to be false
      end
    end

    context 'when originally without tags' do
      before do
        subject.call(status, json, json)
      end

      it 'updates tags' do
        expect(status.tags.reload.map(&:name)).to eq %w(hoge)
      end
    end

    context 'when originally with tags' do
      let(:tags) { [Fabricate(:tag, name: 'test'), Fabricate(:tag, name: 'foo')] }

      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'foo',
          type: 'Note',
          summary: 'Show more',
          content: 'Hello universe',
          updated: '2021-09-08T22:39:25Z',
          tag: [
            { type: 'Hashtag', name: 'foo' },
          ],
        }
      end

      before do
        subject.call(status, json, json)
      end

      it 'updates tags' do
        expect(status.tags.reload.map(&:name)).to eq %w(foo)
      end
    end

    context 'when originally without mentions' do
      before do
        subject.call(status, json, json)
      end

      it 'updates mentions' do
        expect(status.active_mentions.reload.map(&:account_id)).to eq [alice.id]
      end
    end

    context 'when originally with mentions' do
      let(:mentions) { [alice, bob] }

      before do
        subject.call(status, json, json)
      end

      it 'updates mentions' do
        expect(status.active_mentions.reload.map(&:account_id)).to eq [alice.id]
      end
    end

    context 'when originally without media attachments' do
      before do
        stub_request(:get, 'https://example.com/foo.png').to_return(body: attachment_fixture('emojo.png'))
        subject.call(status, json, json)
      end

      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'foo',
          type: 'Note',
          content: 'Hello universe',
          updated: '2021-09-08T22:39:25Z',
          attachment: [
            { type: 'Image', mediaType: 'image/png', url: 'https://example.com/foo.png' },
          ],
        }
      end

      it 'updates media attachments' do
        media_attachment = status.reload.ordered_media_attachments.first

        expect(media_attachment).to_not be_nil
        expect(media_attachment.remote_url).to eq 'https://example.com/foo.png'
      end

      it 'fetches the attachment' do
        expect(a_request(:get, 'https://example.com/foo.png')).to have_been_made
      end

      it 'records media change in edit' do
        expect(status.edits.reload.last.ordered_media_attachment_ids).to_not be_empty
      end
    end

    context 'when originally with media attachments' do
      let(:media_attachments) { [Fabricate(:media_attachment, remote_url: 'https://example.com/foo.png'), Fabricate(:media_attachment, remote_url: 'https://example.com/unused.png')] }

      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'foo',
          type: 'Note',
          content: 'Hello universe',
          updated: '2021-09-08T22:39:25Z',
          attachment: [
            { type: 'Image', mediaType: 'image/png', url: 'https://example.com/foo.png', name: 'A picture' },
          ],
        }
      end

      before do
        allow(RedownloadMediaWorker).to receive(:perform_async)
        subject.call(status, json, json)
      end

      it 'updates the existing media attachment in-place' do
        media_attachment = status.media_attachments.ordered.reload.first

        expect(media_attachment).to_not be_nil
        expect(media_attachment.remote_url).to eq 'https://example.com/foo.png'
        expect(media_attachment.description).to eq 'A picture'
      end

      it 'does not queue redownload for the existing media attachment' do
        expect(RedownloadMediaWorker).to_not have_received(:perform_async)
      end

      it 'updates media attachments' do
        expect(status.ordered_media_attachments.map(&:remote_url)).to eq %w(https://example.com/foo.png)
      end

      it 'records media change in edit' do
        expect(status.edits.reload.last.ordered_media_attachment_ids).to_not be_empty
      end
    end

    context 'when originally with a poll' do
      before do
        poll = Fabricate(:poll, status: status)
        status.update(preloadable_poll: poll)
        subject.call(status, json, json)
      end

      it 'removes poll' do
        expect(status.reload.poll).to be_nil
      end

      it 'records media change in edit' do
        expect(status.edits.reload.last.poll_options).to be_nil
      end
    end

    context 'when originally without a poll' do
      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'foo',
          type: 'Question',
          content: 'Hello universe',
          updated: '2021-09-08T22:39:25Z',
          closed: true,
          oneOf: [
            { type: 'Note', name: 'Foo' },
            { type: 'Note', name: 'Bar' },
            { type: 'Note', name: 'Baz' },
          ],
        }
      end

      before do
        subject.call(status, json, json)
      end

      it 'creates a poll' do
        poll = status.reload.poll

        expect(poll).to_not be_nil
        expect(poll.options).to eq %w(Foo Bar Baz)
      end

      it 'records media change in edit' do
        expect(status.edits.reload.last.poll_options).to eq %w(Foo Bar Baz)
      end
    end

    it 'creates edit history' do
      subject.call(status, json, json)
      expect(status.edits.reload.map(&:text)).to eq ['Hello world', 'Hello universe']
    end

    it 'sets edited timestamp' do
      subject.call(status, json, json)
      expect(status.reload.edited_at.to_s).to eq '2021-09-08 22:39:25 UTC'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class UploadService
  # Temporarily introduced for upload API: https://gitlab.com/gitlab-org/gitlab/-/issues/325788
  attr_accessor :override_max_attachment_size

  def initialize(model, file, uploader_class = FileUploader, **uploader_context)
    @model = model
    @file = file
    @uploader_class = uploader_class
    @uploader_context = uploader_context
  end

  def execute
    return unless file && file.size <= max_attachment_size

    uploader = uploader_class.new(model, nil, **uploader_context)
    uploader.store!(file)

    uploader
  end

  private

  attr_reader :model, :file, :uploader_class, :uploader_context

  def max_attachment_size
    override_max_attachment_size || Gitlab::CurrentSettings.max_attachment_size.megabytes.to_i
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe UploadService, feature_category: :shared do
  describe 'File service' do
    before do
      @user = create(:user)
      @project = create(:project, creator_id: @user.id, namespace: @user.namespace)
    end

    context 'for valid gif file' do
      before do
        gif = fixture_file_upload('spec/fixtures/banana_sample.gif', 'image/gif')
        @link_to_file = upload_file(@project, gif)
      end

      it { expect(@link_to_file).to have_key(:alt) }
      it { expect(@link_to_file).to have_key(:url) }
      it { expect(@link_to_file).to have_value('banana_sample') }
      it { expect(@link_to_file[:url]).to match('banana_sample.gif') }
    end

    context 'for valid png file' do
      before do
        png = fixture_file_upload('spec/fixtures/dk.png',
          'image/png')
        @link_to_file = upload_file(@project, png)
      end

      it { expect(@link_to_file).to have_key(:alt) }
      it { expect(@link_to_file).to have_key(:url) }
      it { expect(@link_to_file).to have_value('dk') }
      it { expect(@link_to_file[:url]).to match('dk.png') }
    end

    context 'for valid jpg file' do
      before do
        jpg = fixture_file_upload('spec/fixtures/rails_sample.jpg', 'image/jpg')
        @link_to_file = upload_file(@project, jpg)
      end

      it { expect(@link_to_file).to have_key(:alt) }
      it { expect(@link_to_file).to have_key(:url) }
      it { expect(@link_to_file).to have_value('rails_sample') }
      it { expect(@link_to_file[:url]).to match('rails_sample.jpg') }
    end

    context 'for txt file' do
      before do
        txt = fixture_file_upload('spec/fixtures/doc_sample.txt', 'text/plain')
        @link_to_file = upload_file(@project, txt)
      end

      it { expect(@link_to_file).to have_key(:alt) }
      it { expect(@link_to_file).to have_key(:url) }
      it { expect(@link_to_file).to have_value('doc_sample.txt') }
      it { expect(@link_to_file[:url]).to match('doc_sample.txt') }
    end

    context 'for too large a file' do
      before do
        txt = fixture_file_upload('spec/fixtures/doc_sample.txt', 'text/plain')
        allow(txt).to receive(:size) { 1000.megabytes.to_i }
        @link_to_file = upload_file(@project, txt)
      end

      it { expect(@link_to_file).to eq({}) }
    end

    describe '#override_max_attachment_size' do
      let(:txt) { fixture_file_upload('spec/fixtures/doc_sample.txt', 'text/plain') }
      let(:service) { described_class.new(@project, txt, FileUploader) }

      subject { service.execute.to_h }

      before do
        allow(txt).to receive(:size) { 100.megabytes.to_i }
      end

      it 'allows the upload' do
        service.override_max_attachment_size = 101.megabytes

        expect(subject.keys).to eq(%i[alt url markdown])
      end

      it 'disallows the upload' do
        service.override_max_attachment_size = 99.megabytes

        expect(subject).to eq({})
      end
    end
  end

  def upload_file(project, file)
    described_class.new(project, file, FileUploader).execute.to_h
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class NoteSummary
  attr_reader :note
  attr_reader :metadata

  def initialize(noteable, project, author, body, action: nil, commit_count: nil, created_at: nil)
    @note = { noteable: noteable,
              created_at: created_at || noteable.system_note_timestamp,
              project: project, author: author, note: body }
    @metadata = { action: action, commit_count: commit_count }.compact

    if action == 'description' && noteable.saved_description_version
      @metadata[:description_version] = noteable.saved_description_version
    end

    set_commit_params if note[:noteable].is_a?(Commit)
  end

  def metadata?
    metadata.present?
  end

  def set_commit_params
    note.merge!(noteable_type: 'Commit', commit_id: note[:noteable].id)
    note[:noteable] = nil
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe NoteSummary, feature_category: :code_review_workflow do
  let(:project)  { build(:project) }
  let(:noteable) { build(:issue) }
  let(:user)     { build(:user) }

  def create_note_summary
    described_class.new(noteable, project, user, 'note', action: 'icon', commit_count: 5)
  end

  describe '#metadata?' do
    it 'returns true when metadata present' do
      expect(create_note_summary.metadata?).to be_truthy
    end

    it 'returns false when metadata not present' do
      expect(described_class.new(noteable, project, user, 'note').metadata?).to be_falsey
    end
  end

  describe '#note' do
    it 'returns note hash' do
      freeze_time do
        expect(create_note_summary.note).to eq(
          noteable: noteable,
          project: project,
          author: user,
          note: 'note',
          created_at: Time.current
        )
      end
    end

    context 'when noteable is a commit' do
      let(:noteable) { build(:commit, system_note_timestamp: Time.zone.at(43)) }

      it 'returns note hash specific to commit' do
        expect(create_note_summary.note).to eq(
          noteable: nil, project: project, author: user, note: 'note',
          noteable_type: 'Commit', commit_id: noteable.id,
          created_at: Time.zone.at(43)
        )
      end
    end
  end

  describe '#metadata' do
    it 'returns metadata hash' do
      expect(create_note_summary.metadata).to eq(action: 'icon', commit_count: 5)
    end

    context 'description action and noteable has saved_description_version' do
      before do
        noteable.saved_description_version = 1
      end

      subject { described_class.new(noteable, project, user, 'note', action: 'description') }

      it 'sets the description_version metadata' do
        expect(subject.metadata).to include(description_version: 1)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class AutoMergeService < BaseService
  include Gitlab::Utils::StrongMemoize

  STRATEGY_MERGE_WHEN_PIPELINE_SUCCEEDS = 'merge_when_pipeline_succeeds'
  STRATEGIES = [STRATEGY_MERGE_WHEN_PIPELINE_SUCCEEDS].freeze

  class << self
    def all_strategies_ordered_by_preference
      STRATEGIES
    end

    def get_service_class(strategy)
      return unless all_strategies_ordered_by_preference.include?(strategy)

      ""::AutoMerge::#{strategy.camelize}Service"".constantize
    end
  end

  def execute(merge_request, strategy = nil)
    strategy ||= preferred_strategy(merge_request)
    service = get_service_instance(merge_request, strategy)

    return :failed unless service&.available_for?(merge_request)

    service.execute(merge_request)
  end

  def update(merge_request)
    return :failed unless merge_request.auto_merge_enabled?

    strategy = merge_request.auto_merge_strategy
    get_service_instance(merge_request, strategy).update(merge_request)
  end

  def process(merge_request)
    return unless merge_request.auto_merge_enabled?

    strategy = merge_request.auto_merge_strategy
    get_service_instance(merge_request, strategy).process(merge_request)
  end

  def cancel(merge_request)
    return error(""Can't cancel the automatic merge"", 406) unless merge_request.auto_merge_enabled?

    strategy = merge_request.auto_merge_strategy
    get_service_instance(merge_request, strategy).cancel(merge_request)
  end

  def abort(merge_request, reason)
    return error(""Can't abort the automatic merge"", 406) unless merge_request.auto_merge_enabled?

    strategy = merge_request.auto_merge_strategy
    get_service_instance(merge_request, strategy).abort(merge_request, reason)
  end

  def available_strategies(merge_request)
    self.class.all_strategies_ordered_by_preference.select do |strategy|
      get_service_instance(merge_request, strategy).available_for?(merge_request)
    end
  end

  def preferred_strategy(merge_request)
    available_strategies(merge_request).first
  end

  private

  def get_service_instance(merge_request, strategy)
    strong_memoize(""service_instance_#{merge_request.id}_#{strategy}"") do
      self.class.get_service_class(strategy)&.new(project, current_user, params)
    end
  end
end

AutoMergeService.prepend_mod_with('AutoMergeService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe AutoMergeService, feature_category: :code_review_workflow do
  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:user) { create(:user) }

  let(:service) { described_class.new(project, user) }

  before_all do
    project.add_maintainer(user)
  end

  describe '.all_strategies_ordered_by_preference' do
    subject { described_class.all_strategies_ordered_by_preference }

    it 'returns all strategies in preference order' do
      if Gitlab.ee?
        is_expected.to contain_exactly(
          AutoMergeService::STRATEGY_MERGE_TRAIN,
          AutoMergeService::STRATEGY_ADD_TO_MERGE_TRAIN_WHEN_PIPELINE_SUCCEEDS,
          AutoMergeService::STRATEGY_MERGE_WHEN_CHECKS_PASS,
          AutoMergeService::STRATEGY_MERGE_WHEN_PIPELINE_SUCCEEDS
        )
      else
        is_expected.to eq([AutoMergeService::STRATEGY_MERGE_WHEN_PIPELINE_SUCCEEDS])
      end
    end
  end

  describe '#available_strategies' do
    subject { service.available_strategies(merge_request) }

    let(:merge_request) do
      create(:merge_request, source_project: project)
    end

    let(:pipeline_status) { :running }

    before do
      create(
        :ci_pipeline,
        pipeline_status,
        ref: merge_request.source_branch,
        sha: merge_request.diff_head_sha,
        project: merge_request.source_project
      )

      merge_request.update_head_pipeline
    end

    it 'returns available strategies' do
      is_expected.to include('merge_when_pipeline_succeeds')
    end

    context 'when the head piipeline succeeded' do
      let(:pipeline_status) { :success }

      it 'returns available strategies' do
        is_expected.to be_empty
      end
    end
  end

  describe '#preferred_strategy' do
    subject { service.preferred_strategy(merge_request) }

    let(:merge_request) do
      create(:merge_request, source_project: project)
    end

    let(:pipeline_status) { :running }

    before do
      create(
        :ci_pipeline,
        pipeline_status,
        ref: merge_request.source_branch,
        sha: merge_request.diff_head_sha,
        project: merge_request.source_project
      )

      merge_request.update_head_pipeline

      stub_licensed_features(merge_request_approvers: true) if Gitlab.ee?
    end

    it 'returns preferred strategy', if: Gitlab.ee? do
      is_expected.to eq('merge_when_checks_pass')
    end

    it 'returns preferred strategy', unless: Gitlab.ee? do
      is_expected.to eq('merge_when_pipeline_succeeds')
    end

    context 'when the head pipeline succeeded' do
      let(:pipeline_status) { :success }

      it 'returns available strategies' do
        is_expected.to be_nil
      end
    end
  end

  describe '.get_service_class' do
    subject { described_class.get_service_class(strategy) }

    let(:strategy) { AutoMergeService::STRATEGY_MERGE_WHEN_PIPELINE_SUCCEEDS }

    it 'returns service instance' do
      is_expected.to eq(AutoMerge::MergeWhenPipelineSucceedsService)
    end

    context 'when strategy is not present' do
      let(:strategy) {}

      it 'returns nil' do
        is_expected.to be_nil
      end
    end
  end

  describe '#execute' do
    subject { service.execute(merge_request, strategy) }

    let(:merge_request) do
      create(:merge_request, source_project: project)
    end

    let(:pipeline_status) { :running }
    let(:strategy) { AutoMergeService::STRATEGY_MERGE_WHEN_PIPELINE_SUCCEEDS }

    before do
      create(
        :ci_pipeline,
        pipeline_status,
        ref: merge_request.source_branch,
        sha: merge_request.diff_head_sha,
        project: merge_request.source_project
      )

      merge_request.update_head_pipeline
    end

    it 'delegates to a relevant service instance' do
      expect_next_instance_of(AutoMerge::MergeWhenPipelineSucceedsService) do |service|
        expect(service).to receive(:execute).with(merge_request)
      end

      subject
    end

    context 'when the head pipeline succeeded' do
      let(:pipeline_status) { :success }

      it 'returns failed' do
        is_expected.to eq(:failed)
      end
    end

    context 'when strategy is not specified' do
      let(:strategy) {}

      before do
        stub_licensed_features(merge_request_approvers: true) if Gitlab.ee?
      end

      it 'chooses the most preferred strategy', if: Gitlab.ee? do
        is_expected.to eq(:merge_when_checks_pass)
      end

      it 'chooses the most preferred strategy', unless: Gitlab.ee? do
        is_expected.to eq(:merge_when_pipeline_succeeds)
      end
    end
  end

  describe '#update' do
    subject { service.update(merge_request) } # rubocop:disable Rails/SaveBang

    context 'when auto merge is enabled' do
      let(:merge_request) { create(:merge_request, :merge_when_pipeline_succeeds) }

      it 'delegates to a relevant service instance' do
        expect_next_instance_of(AutoMerge::MergeWhenPipelineSucceedsService) do |service|
          expect(service).to receive(:update).with(merge_request)
        end

        subject
      end
    end

    context 'when auto merge is not enabled' do
      let(:merge_request) { create(:merge_request) }

      it 'returns failed' do
        is_expected.to eq(:failed)
      end
    end
  end

  describe '#process' do
    subject { service.process(merge_request) }

    let(:merge_request) { create(:merge_request, :merge_when_pipeline_succeeds) }

    it 'delegates to a relevant service instance' do
      expect_next_instance_of(AutoMerge::MergeWhenPipelineSucceedsService) do |service|
        expect(service).to receive(:process).with(merge_request)
      end

      subject
    end

    context 'when auto merge is not enabled' do
      let(:merge_request) { create(:merge_request) }

      it 'returns nil' do
        is_expected.to be_nil
      end
    end
  end

  describe '#cancel' do
    subject { service.cancel(merge_request) }

    let(:merge_request) { create(:merge_request, :merge_when_pipeline_succeeds) }

    it 'delegates to a relevant service instance' do
      expect_next_instance_of(AutoMerge::MergeWhenPipelineSucceedsService) do |service|
        expect(service).to receive(:cancel).with(merge_request)
      end

      subject
    end

    context 'when auto merge is not enabled' do
      let(:merge_request) { create(:merge_request) }

      it 'returns error' do
        expect(subject[:message]).to eq(""Can't cancel the automatic merge"")
        expect(subject[:status]).to eq(:error)
        expect(subject[:http_status]).to eq(406)
      end
    end
  end

  describe '#abort' do
    subject { service.abort(merge_request, error) }

    let(:merge_request) { create(:merge_request, :merge_when_pipeline_succeeds) }
    let(:error) { 'an error' }

    it 'delegates to a relevant service instance' do
      expect_next_instance_of(AutoMerge::MergeWhenPipelineSucceedsService) do |service|
        expect(service).to receive(:abort).with(merge_request, error)
      end

      subject
    end

    context 'when auto merge is not enabled' do
      let(:merge_request) { create(:merge_request) }

      it 'returns error' do
        expect(subject[:message]).to eq(""Can't abort the automatic merge"")
        expect(subject[:status]).to eq(:error)
        expect(subject[:http_status]).to eq(406)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# RepositoryArchiveCleanUpService removes cached repository archives
# that are generated on-the-fly by Gitaly. These files are stored in the
# following form (as defined in lib/gitlab/git/repository.rb) and served
# by GitLab Workhorse:
#
# /path/to/repository/downloads/project-N/sha/@v2/archive.format
#
# Legacy paths omit the @v2 prefix.
#
# For example:
#
# /var/opt/gitlab/gitlab-rails/shared/cache/archive/project-1/master/@v2/archive.zip
class RepositoryArchiveCleanUpService
  LAST_MODIFIED_TIME_IN_MINUTES = 120

  # For `/path/project-N/sha/@v2/archive.zip`, `find /path -maxdepth 4` will find this file
  MAX_ARCHIVE_DEPTH = 4

  attr_reader :mmin, :path

  def initialize(mmin = LAST_MODIFIED_TIME_IN_MINUTES)
    @mmin = mmin
    @path = Gitlab.config.gitlab.repository_downloads_path
  end

  def execute
    Gitlab::Metrics.measure(:repository_archive_clean_up) do
      next unless File.directory?(path)

      clean_up_old_archives
      clean_up_empty_directories
    end
  end

  private

  def clean_up_old_archives
    run(%W[find #{path} -mindepth 1 -maxdepth #{MAX_ARCHIVE_DEPTH} -type f \( -name \*.tar -o -name \*.bz2 -o -name \*.tar.gz -o -name \*.zip \) -mmin +#{mmin} -delete])
  end

  def clean_up_empty_directories
    (1...MAX_ARCHIVE_DEPTH).reverse_each { |depth| clean_up_empty_directories_with_depth(depth) }
  end

  def clean_up_empty_directories_with_depth(depth)
    run(%W[find #{path} -mindepth #{depth} -maxdepth #{depth} -type d -empty -delete])
  end

  def run(cmd)
    Gitlab::Popen.popen(cmd)
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe RepositoryArchiveCleanUpService, feature_category: :source_code_management do
  subject(:service) { described_class.new }

  describe '#execute (new archive locations)' do
    let(:sha) { ""0"" * 40 }

    it 'removes outdated archives and directories in a new-style path' do
      in_directory_with_files(""project-#{non_existing_record_id}/#{sha}"", %w[tar tar.bz2 tar.gz zip], 3.hours) do |dirname, files|
        service.execute

        files.each { |filename| expect(File.exist?(filename)).to be_falsy }
        expect(File.directory?(dirname)).to be_falsy
        expect(File.directory?(File.dirname(dirname))).to be_falsy
      end
    end

    it 'removes outdated archives and directories in a versioned path' do
      in_directory_with_files(""project-#{non_existing_record_id}/#{sha}/@v2"", %w[tar tar.bz2 tar.gz zip], 3.hours) do |dirname, files|
        service.execute

        files.each { |filename| expect(File.exist?(filename)).to be_falsy }
        expect(File.directory?(dirname)).to be_falsy
        expect(File.directory?(File.dirname(dirname))).to be_falsy
      end
    end

    it 'does not remove directories when they contain outdated non-archives' do
      in_directory_with_files(""project-#{non_existing_record_id}/#{sha}"", %w[tar conf rb], 2.hours) do |dirname, files|
        service.execute

        expect(File.directory?(dirname)).to be_truthy
      end
    end

    it 'does not remove in-date archives in a new-style path' do
      in_directory_with_files(""project-#{non_existing_record_id}/#{sha}"", %w[tar tar.bz2 tar.gz zip], 1.hour) do |dirname, files|
        service.execute

        files.each { |filename| expect(File.exist?(filename)).to be_truthy }
      end
    end
  end

  describe '#execute (legacy archive locations)' do
    context 'when the downloads directory does not exist' do
      it 'does not remove any archives' do
        path = '/invalid/path/'
        stub_repository_downloads_path(path)

        allow(File).to receive(:directory?).and_call_original
        expect(File).to receive(:directory?).with(path).and_return(false)

        expect(service).not_to receive(:clean_up_old_archives)
        expect(service).not_to receive(:clean_up_empty_directories)

        service.execute
      end
    end

    context 'when the downloads directory exists' do
      shared_examples 'invalid archive files' do |dirname, extensions, mtime|
        it 'does not remove files and directory' do
          in_directory_with_files(dirname, extensions, mtime) do |dir, files|
            service.execute

            files.each { |file| expect(File.exist?(file)).to eq true }
            expect(File.directory?(dir)).to eq true
          end
        end
      end

      it 'removes files older than 2 hours that matches valid archive extensions' do
        # In macOS, the the `mmin` parameter for `find` rounds up, so add a full
        # minute to ensure these files are deemed old.
        in_directory_with_files('sample.git', %w[tar tar.bz2 tar.gz zip], 121.minutes) do |dir, files|
          service.execute

          files.each { |file| expect(File.exist?(file)).to eq false }
          expect(File.directory?(dir)).to eq false
        end
      end

      context 'with files older than 2 hours that does not matches valid archive extensions' do
        it_behaves_like 'invalid archive files', 'sample.git', %w[conf rb], 121.minutes
      end

      context 'with files older than 2 hours inside invalid directories' do
        it_behaves_like 'invalid archive files', 'john/t/doe/sample.git', %w[conf rb tar tar.gz], 121.minutes
      end

      context 'with files newer than 2 hours that matches valid archive extensions' do
        it_behaves_like 'invalid archive files', 'sample.git', %w[tar tar.bz2 tar.gz zip], 1.hour
      end

      context 'with files newer than 2 hours that does not matches valid archive extensions' do
        it_behaves_like 'invalid archive files', 'sample.git', %w[conf rb], 1.hour
      end

      context 'with files newer than 2 hours inside invalid directories' do
        it_behaves_like 'invalid archive files', 'sample.git', %w[conf rb tar tar.gz], 1.hour
      end
    end
  end

  def in_directory_with_files(dirname, extensions, mtime)
    Dir.mktmpdir do |tmpdir|
      stub_repository_downloads_path(tmpdir)
      dir = File.join(tmpdir, dirname)
      files = create_temporary_files(dir, extensions, mtime)

      yield(dir, files)
    end
  end

  def stub_repository_downloads_path(path)
    allow(Gitlab.config.gitlab).to receive(:repository_downloads_path).and_return(path)
  end

  def create_temporary_files(dir, extensions, mtime)
    FileUtils.mkdir_p(dir)
    FileUtils.touch(extensions.map { |ext| File.join(dir, ""sample.#{ext}"") }, mtime: Time.now.utc - mtime)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class ImportExportCleanUpService
  LAST_MODIFIED_TIME_IN_MINUTES = 1440
  DIR_DEPTH = 5

  attr_reader :mmin, :path

  def initialize(mmin = LAST_MODIFIED_TIME_IN_MINUTES)
    @mmin = mmin
    @path = Gitlab::ImportExport.storage_path
  end

  def execute
    Gitlab::Metrics.measure(:import_export_clean_up) do
      execute_cleanup
    end
  end

  private

  def execute_cleanup
    clean_up_export_object_files
  ensure
    # We don't want a failure in cleaning up object storage from
    # blocking us from cleaning up temporary storage.
    clean_up_export_files if File.directory?(path)
  end

  def clean_up_export_files
    old_directories do |dir|
      FileUtils.remove_entry(dir)

      logger.info(
        message: 'Removed Import/Export tmp directory',
        dir_path: dir
      )
    end
  end

  def clean_up_export_object_files
    ImportExportUpload.with_export_file.updated_before(mmin.minutes.ago).each do |upload|
      upload.remove_export_file!
      upload.save!

      logger.info(
        message: 'Removed Import/Export export_file',
        project_id: upload.project_id,
        group_id: upload.group_id
      )
    end
  end

  def old_directories
    IO.popen(directories_cmd) do |find|
      find.each_line(chomp: true) do |directory|
        yield directory
      end
    end
  end

  def directories_cmd
    %W[find #{path} -mindepth #{DIR_DEPTH} -maxdepth #{DIR_DEPTH} -type d -not -path #{path} -mmin +#{mmin}]
  end

  def logger
    @logger ||= Gitlab::Import::Logger.build
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ImportExportCleanUpService, feature_category: :importers do
  describe '#execute' do
    let(:service) { described_class.new }

    let(:tmp_import_export_folder) { 'tmp/gitlab_exports' }

    before do
      allow_next_instance_of(Gitlab::Import::Logger) do |logger|
        allow(logger).to receive(:info)
      end
    end

    context 'when the import/export tmp storage directory does not exist' do
      it 'does not remove any archives' do
        path = '/invalid/path/'
        stub_repository_downloads_path(path)

        expect(service).not_to receive(:clean_up_export_files)

        service.execute
      end
    end

    context 'when the import/export tmp storage directory exists' do
      shared_examples 'removes old tmp files' do |subdir|
        it 'removes old files and logs' do
          expect_next_instance_of(Gitlab::Import::Logger) do |logger|
            expect(logger)
              .to receive(:info)
              .with(
                message: 'Removed Import/Export tmp directory',
                dir_path: anything
              )
          end

          validate_cleanup(subdir: subdir, mtime: 2.days.ago, expected: false)
        end

        it 'does not remove new files or logs' do
          expect(Gitlab::Import::Logger).not_to receive(:new)

          validate_cleanup(subdir: subdir, mtime: 2.hours.ago, expected: true)
        end
      end

      include_examples 'removes old tmp files', '@hashed'
      include_examples 'removes old tmp files', '@groups'
    end

    context 'with uploader exports' do
      it 'removes old files and logs' do
        upload = create(
          :import_export_upload,
          updated_at: 2.days.ago,
          export_file: fixture_file_upload('spec/fixtures/project_export.tar.gz')
        )

        expect_next_instance_of(Gitlab::Import::Logger) do |logger|
          expect(logger)
            .to receive(:info)
            .with(
              message: 'Removed Import/Export export_file',
              project_id: upload.project_id,
              group_id: upload.group_id
            )
        end

        expect { service.execute }.to change { upload.reload.export_file.file.nil? }.to(true)

        expect(ImportExportUpload.where(export_file: nil)).to include(upload)
      end

      it 'does not remove new files or logs' do
        upload = create(
          :import_export_upload,
          updated_at: 1.hour.ago,
          export_file: fixture_file_upload('spec/fixtures/project_export.tar.gz')
        )

        expect(Gitlab::Import::Logger).not_to receive(:new)

        expect { service.execute }.not_to change { upload.reload.export_file.file.nil? }

        expect(ImportExportUpload.where.not(export_file: nil)).to include(upload)
      end
    end

    def validate_cleanup(subdir:, mtime:, expected:)
      in_directory_with_files(mtime: mtime, subdir: subdir) do |dir, files|
        service.execute

        files.each { |file| expect(File.exist?(file)).to eq(expected) }
        expect(File.directory?(dir)).to eq(expected)
      end
    end

    def in_directory_with_files(mtime:, subdir:)
      Dir.mktmpdir do |tmpdir|
        stub_repository_downloads_path(tmpdir)
        hashed = Digest::SHA2.hexdigest(subdir)
        subdir_path = [subdir, hashed[0..1], hashed[2..3], hashed, hashed[4..10]]
        dir = File.join(tmpdir, tmp_import_export_folder, *[subdir_path])

        FileUtils.mkdir_p(dir)
        File.utime(mtime.to_i, mtime.to_i, dir)

        files = FileUtils.touch(file_list(dir) + [dir], mtime: mtime.to_time)

        yield(dir, files)
      end
    end

    def stub_repository_downloads_path(path)
      new_shared_settings = Settings.shared.merge('path' => path)
      allow(Settings).to receive(:shared).and_return(new_shared_settings)
    end

    def file_list(dir)
      Array.new(5) do |num|
        File.join(dir, ""random-#{num}.tar.gz"")
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Finds the correct checkbox in the passed in markdown/html and toggles it's state,
# returning the updated markdown/html.
# We don't care if the text has changed above or below the specific checkbox, as long
# the checkbox still exists at exactly the same line number and the text is equal.
# If successful, new values are available in `updated_markdown` and `updated_markdown_html`
class TaskListToggleService
  attr_reader :updated_markdown, :updated_markdown_html

  def initialize(markdown, markdown_html, line_source:, line_number:, toggle_as_checked:)
    @markdown = markdown
    @markdown_html = markdown_html
    @line_source = line_source
    @line_number = line_number
    @toggle_as_checked = toggle_as_checked

    @updated_markdown, @updated_markdown_html = nil
  end

  def execute
    return false unless markdown && markdown_html

    toggle_markdown && toggle_markdown_html
  end

  private

  attr_reader :markdown, :markdown_html, :toggle_as_checked
  attr_reader :line_source, :line_number

  def toggle_markdown
    source_lines      = markdown.split(""\n"")
    source_line_index = line_number - 1
    markdown_task     = source_lines[source_line_index]

    # The source in the DB could be using either \n or \r\n line endings
    return unless markdown_task.chomp == line_source
    return unless source_checkbox = Taskable::ITEM_PATTERN.match(markdown_task)

    currently_checked = TaskList::Item.new(source_checkbox[2]).complete?

    # Check `toggle_as_checked` to make sure we don't accidentally replace
    # any `[ ]` or `[x]` in the middle of the text
    if currently_checked
      markdown_task.sub!(Taskable::COMPLETE_PATTERN, '[ ]') unless toggle_as_checked
    elsif toggle_as_checked
      markdown_task.sub!(Taskable::INCOMPLETE_PATTERN, '[x]')
    end

    source_lines[source_line_index] = markdown_task
    @updated_markdown = source_lines.join(""\n"")
  end

  def toggle_markdown_html
    html          = Nokogiri::HTML.fragment(markdown_html)
    html_checkbox = get_html_checkbox(html)
    return unless html_checkbox

    if toggle_as_checked
      html_checkbox[:checked] = 'checked'
    else
      html_checkbox.remove_attribute('checked')
    end

    @updated_markdown_html = html.to_html
  end

  # When using CommonMark, we should be able to use the embedded `sourcepos` attribute to
  # target the exact line in the DOM.
  def get_html_checkbox(html)
    html.css("".task-list-item[data-sourcepos^='#{line_number}:'] input.task-list-item-checkbox"").first
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe TaskListToggleService, feature_category: :team_planning do
  let(:markdown) do
    <<-EOT.strip_heredoc
      * [ ] Task 1
      * [x] Task 2

      A paragraph

      1. [X] Item 1
         - [ ] Sub-item 1

      - [ ] loose list

        with an embedded paragraph

      + [ ] No-break space (U+00A0)

      2) [ ] Another item
    EOT
  end

  let(:markdown_html) do
    <<-EOT.strip_heredoc
      <ul data-sourcepos=""1:1-3:0"" class=""task-list"" dir=""auto"">
        <li data-sourcepos=""1:1-1:12"" class=""task-list-item"">
          <input type=""checkbox"" class=""task-list-item-checkbox"" disabled> Task 1
        </li>
        <li data-sourcepos=""2:1-3:0"" class=""task-list-item"">
          <input type=""checkbox"" class=""task-list-item-checkbox"" disabled checked> Task 2
        </li>
      </ul>
      <p data-sourcepos=""4:1-4:11"" dir=""auto"">A paragraph</p>
      <ol data-sourcepos=""6:1-8:0"" class=""task-list"" dir=""auto"">
        <li data-sourcepos=""6:1-8:0"" class=""task-list-item"">
          <input type=""checkbox"" class=""task-list-item-checkbox"" checked="""" disabled=""""> Item 1
          <ul data-sourcepos=""7:4-8:0"" class=""task-list"">
            <li data-sourcepos=""7:4-8:0"" class=""task-list-item"">
              <input type=""checkbox"" class=""task-list-item-checkbox"" disabled=""""> Sub-item 1
            </li>
          </ul>
        </li>
      </ol>
      <ul data-sourcepos=""9:1-12:0"" class=""task-list"" dir=""auto"">
        <li data-sourcepos=""9:1-12:0"" class=""task-list-item"">
          <p data-sourcepos=""9:3-9:16""><input type=""checkbox"" class=""task-list-item-checkbox"" disabled=""""> loose list</p>
          <p data-sourcepos=""11:3-11:28"">with an embedded paragraph</p>
        </li>
      </ul>
      <ul data-sourcepos=""13:1-13:21"" class=""task-list"" dir=""auto"">
        <li data-sourcepos=""13:1-13:21"" class=""task-list-item"">
          <input type=""checkbox"" class=""task-list-item-checkbox"" disabled=""""> No-break space (U+00A0)
        </li>
      </ul>
      <ol start=""2"" data-sourcepos=""15:1-15:19"" class=""task-list"" dir=""auto"">
        <li data-sourcepos=""15:1-15:19"" class=""task-list-item"">
          <input type=""checkbox"" class=""task-list-item-checkbox"" disabled> Another item
        </li>
      </ol>
    EOT
  end

  it 'checks Task 1' do
    toggler = described_class.new(
      markdown, markdown_html,
      toggle_as_checked: true,
      line_source: '* [ ] Task 1',
      line_number: 1
    )

    expect(toggler.execute).to be_truthy
    expect(toggler.updated_markdown.lines[0]).to eq ""* [x] Task 1\n""
    expect(toggler.updated_markdown_html).to include('disabled checked> Task 1')
  end

  it 'unchecks Item 1' do
    toggler = described_class.new(
      markdown, markdown_html,
      toggle_as_checked: false,
      line_source: '1. [X] Item 1',
      line_number: 6
    )

    expect(toggler.execute).to be_truthy
    expect(toggler.updated_markdown.lines[5]).to eq ""1. [ ] Item 1\n""
    expect(toggler.updated_markdown_html).to include('disabled> Item 1')
  end

  it 'checks task in loose list' do
    toggler = described_class.new(
      markdown, markdown_html,
      toggle_as_checked: true,
      line_source: '- [ ] loose list',
      line_number: 9
    )

    expect(toggler.execute).to be_truthy
    expect(toggler.updated_markdown.lines[8]).to eq ""- [x] loose list\n""
    expect(toggler.updated_markdown_html).to include('disabled checked> loose list')
  end

  it 'checks task with no-break space' do
    toggler = described_class.new(
      markdown, markdown_html,
      toggle_as_checked: true,
      line_source: '+ [ ] No-break space (U+00A0)',
      line_number: 13
    )

    expect(toggler.execute).to be_truthy
    expect(toggler.updated_markdown.lines[12]).to eq ""+ [x] No-break space (U+00A0)\n""
    expect(toggler.updated_markdown_html).to include('disabled checked> No-break space (U+00A0)')
  end

  it 'checks Another item' do
    toggler = described_class.new(
      markdown, markdown_html,
      toggle_as_checked: true,
      line_source: '2) [ ] Another item',
      line_number: 15
    )

    expect(toggler.execute).to be_truthy
    expect(toggler.updated_markdown.lines[14]).to eq ""2) [x] Another item""
    expect(toggler.updated_markdown_html).to include('disabled checked> Another item')
  end

  it 'returns false if line_source does not match the text' do
    toggler = described_class.new(
      markdown, markdown_html,
      toggle_as_checked: false,
      line_source: '* [x] Task Added',
      line_number: 2
    )

    expect(toggler.execute).to be_falsey
  end

  it 'tolerates \r\n line endings' do
    rn_markdown = markdown.gsub(""\n"", ""\r\n"")
    toggler = described_class.new(
      rn_markdown,
      markdown_html,
      toggle_as_checked: true,
      line_source: '* [ ] Task 1',
      line_number: 1
    )

    expect(toggler.execute).to be_truthy
    expect(toggler.updated_markdown.lines[0]).to eq ""* [x] Task 1\r\n""
    expect(toggler.updated_markdown_html).to include('disabled checked> Task 1')
  end

  it 'returns false if markdown is nil' do
    toggler = described_class.new(
      nil,
      markdown_html,
      toggle_as_checked: false,
      line_source: '* [x] Task Added',
      line_number: 2
    )

    expect(toggler.execute).to be_falsey
  end

  it 'returns false if markdown_html is nil' do
    toggler = described_class.new(
      markdown,
      nil,
      toggle_as_checked: false,
      line_source: '* [x] Task Added',
      line_number: 2
    )

    expect(toggler.execute).to be_falsey
  end

  it 'properly handles tasks in a blockquote' do
    markdown =
      <<-EOT.strip_heredoc
      > > * [ ] Task 1
      > * [x] Task 2
      EOT

    markdown_html = parse_markdown(markdown)
    toggler = described_class.new(
      markdown,
      markdown_html,
      toggle_as_checked: true,
      line_source: '> > * [ ] Task 1',
      line_number: 1
    )

    expect(toggler.execute).to be_truthy
    expect(toggler.updated_markdown.lines[0]).to eq ""> > * [x] Task 1\n""
    expect(toggler.updated_markdown_html).to include('disabled checked> Task 1')
  end

  it 'properly handles a GitLab blockquote' do
    markdown =
      <<-EOT.strip_heredoc
      >>>
      gitlab blockquote
      >>>

      * [ ] Task 1
      * [x] Task 2
      EOT

    markdown_html = parse_markdown(markdown)
    toggler = described_class.new(
      markdown,
      markdown_html,
      toggle_as_checked: true,
      line_source: '* [ ] Task 1',
      line_number: 5
    )

    expect(toggler.execute).to be_truthy
    expect(toggler.updated_markdown.lines[4]).to eq ""* [x] Task 1\n""
    expect(toggler.updated_markdown_html).to include('disabled checked> Task 1')
  end

  context 'when clicking an embedded subtask' do
    it 'properly handles it inside an unordered list' do
      markdown =
        <<-EOT.strip_heredoc
      - - [ ] Task 1
        - [x] Task 2
        EOT

      markdown_html = parse_markdown(markdown)
      toggler = described_class.new(
        markdown,
        markdown_html,
        toggle_as_checked: true,
        line_source: '- - [ ] Task 1',
        line_number: 1
      )

      expect(toggler.execute).to be_truthy
      expect(toggler.updated_markdown.lines[0]).to eq ""- - [x] Task 1\n""
      expect(toggler.updated_markdown_html).to include('disabled checked> Task 1')
    end

    it 'properly handles it inside an ordered list' do
      markdown =
        <<-EOT.strip_heredoc
      1. - [ ] Task 1
         - [x] Task 2
        EOT

      markdown_html = parse_markdown(markdown)
      toggler = described_class.new(
        markdown,
        markdown_html,
        toggle_as_checked: true,
        line_source: '1. - [ ] Task 1',
        line_number: 1
      )

      expect(toggler.execute).to be_truthy
      expect(toggler.updated_markdown.lines[0]).to eq ""1. - [x] Task 1\n""
      expect(toggler.updated_markdown_html).to include('disabled checked> Task 1')
    end
  end

  def parse_markdown(markdown)
    Banzai::Pipeline::FullPipeline.call(markdown, project: nil)[:output].to_html
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class UpdateContainerRegistryInfoService
  def execute
    registry_config = Gitlab.config.registry
    return unless registry_config.enabled && registry_config.api_url.presence

    # registry_info will query the /v2 route of the registry API. This route
    # requires authentication, but not authorization (the response has no body,
    # only headers that show the version of the registry). There might be no
    # associated user when running this (e.g. from a rake task or a cron job),
    # so we need to generate a valid JWT token with no access permissions to
    # authenticate as a trusted client.
    token = Auth::ContainerRegistryAuthenticationService.access_token({})
    client = ContainerRegistry::Client.new(registry_config.api_url, token: token)
    info = client.registry_info

    gitlab_api_client = ContainerRegistry::GitlabApiClient.new(registry_config.api_url, token: token)
    if gitlab_api_client.supports_gitlab_api?
      info[:features] ||= []
      info[:features] << ContainerRegistry::GitlabApiClient::REGISTRY_GITLAB_V1_API_FEATURE
    end

    Gitlab::CurrentSettings.update!(
      container_registry_vendor: info[:vendor] || '',
      container_registry_version: info[:version] || '',
      container_registry_features: info[:features] || [],
      container_registry_db_enabled: info[:db_enabled] || false
    )
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe UpdateContainerRegistryInfoService, feature_category: :container_registry do
  let_it_be(:application_settings) { Gitlab::CurrentSettings }
  let_it_be(:api_url) { 'http://registry.gitlab' }

  describe '#execute' do
    before do
      stub_access_token
      stub_container_registry_config(enabled: true, api_url: api_url)
    end

    subject { described_class.new.execute }

    shared_examples 'invalid config' do
      it 'does not update the application settings' do
        expect(application_settings).not_to receive(:update!)

        subject
      end

      it 'does not raise an error' do
        expect { subject }.not_to raise_error
      end
    end

    context 'when container registry is disabled' do
      before do
        stub_container_registry_config(enabled: false)
      end

      it_behaves_like 'invalid config'
    end

    context 'when container registry api_url is blank' do
      before do
        stub_container_registry_config(api_url: '')
      end

      it_behaves_like 'invalid config'
    end

    context 'when creating a registry client instance' do
      let(:token) { 'foo' }
      let(:client) { ContainerRegistry::Client.new(api_url, token: token) }

      before do
        stub_registry_info({})
        stub_supports_gitlab_api(false)
      end

      it 'uses a token with no access permissions' do
        expect(Auth::ContainerRegistryAuthenticationService)
          .to receive(:access_token).with({}).and_return(token)
        expect(ContainerRegistry::Client)
          .to receive(:new).with(api_url, token: token).and_return(client)

        subject
      end
    end

    context 'when unabled to detect the container registry type' do
      it 'sets the application settings to their defaults' do
        stub_registry_info({})
        stub_supports_gitlab_api(false)

        subject

        application_settings.reload
        expect(application_settings.container_registry_vendor).to be_blank
        expect(application_settings.container_registry_version).to be_blank
        expect(application_settings.container_registry_features).to eq([])
        expect(application_settings.container_registry_db_enabled).to be_falsey
      end
    end

    context 'when able to detect the container registry type' do
      context 'when using the GitLab container registry' do
        it 'updates application settings accordingly' do
          stub_registry_info(vendor: 'gitlab', version: '2.9.1-gitlab', features: %w[a b c], db_enabled: true)
          stub_supports_gitlab_api(true)

          subject

          application_settings.reload
          expect(application_settings.container_registry_vendor).to eq('gitlab')
          expect(application_settings.container_registry_version).to eq('2.9.1-gitlab')
          expect(application_settings.container_registry_features)
            .to match_array(%W[a b c #{ContainerRegistry::GitlabApiClient::REGISTRY_GITLAB_V1_API_FEATURE}])
          expect(application_settings.container_registry_db_enabled).to be_truthy
        end
      end

      context 'when using a third-party container registry' do
        it 'updates application settings accordingly' do
          stub_registry_info(vendor: 'other', version: nil, features: nil, db_enabled: false)
          stub_supports_gitlab_api(false)

          subject

          application_settings.reload
          expect(application_settings.container_registry_vendor).to eq('other')
          expect(application_settings.container_registry_version).to be_blank
          expect(application_settings.container_registry_features).to eq([])
          expect(application_settings.container_registry_db_enabled).to be_falsey
        end
      end
    end
  end

  def stub_access_token
    allow(Auth::ContainerRegistryAuthenticationService)
      .to receive(:access_token).with({}).and_return('foo')
  end

  def stub_registry_info(output)
    allow_next_instance_of(ContainerRegistry::Client) do |client|
      allow(client).to receive(:registry_info).and_return(output)
    end
  end

  def stub_supports_gitlab_api(output)
    allow_next_instance_of(ContainerRegistry::GitlabApiClient) do |client|
      allow(client).to receive(:supports_gitlab_api?).and_return(output)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Base class, scoped by container (project or group).
#
# New or existing services which only require a project or group container
# should subclass BaseProjectService or BaseGroupService.
#
# If you require a different but specific, non-polymorphic container
# consider creating a new subclass, and update the related comment at
# the top of the original BaseService.
class BaseContainerService
  include BaseServiceUtility
  include ::Gitlab::Utils::StrongMemoize

  attr_accessor :project, :group
  attr_reader :container, :current_user, :params

  def initialize(container:, current_user: nil, params: {})
    @container = container
    @current_user = current_user
    @params = params.dup

    handle_container_type(container)
  end

  def project_container?
    container.is_a?(::Project)
  end

  def group_container?
    container.is_a?(::Group)
  end

  def namespace_container?
    container.is_a?(::Namespace)
  end

  def project_group
    project&.group
  end
  strong_memoize_attr :project_group

  private

  def handle_container_type(container)
    case container
    when Project
      @project = container
    when Group
      @group = container
    when Namespaces::ProjectNamespace
      @project = container.project
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe BaseContainerService, feature_category: :container_registry do
  let(:project) { Project.new }
  let(:user) { User.new }

  describe '#initialize' do
    it 'accepts container and current_user' do
      subject = described_class.new(container: project, current_user: user)

      expect(subject.container).to eq(project)
      expect(subject.current_user).to eq(user)
    end

    it 'treats current_user as optional' do
      subject = described_class.new(container: project)

      expect(subject.current_user).to be_nil
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class GravatarService
  def execute(email, size = nil, scale = 2, username: nil)
    return if Gitlab::FIPS.enabled?
    return unless Gitlab::CurrentSettings.gravatar_enabled?

    identifier = email.presence || username.presence
    return unless identifier

    hash = Digest::MD5.hexdigest(identifier.strip.downcase)
    size = Groups::GroupMembersHelper::AVATAR_SIZE unless size && size > 0

    sprintf gravatar_url,
      hash: hash,
      size: size * scale,
      email: ERB::Util.url_encode(email&.strip || ''),
      username: ERB::Util.url_encode(username&.strip || '')
  end

  def gitlab_config
    Gitlab.config.gitlab
  end

  def gravatar_config
    Gitlab.config.gravatar
  end

  def gravatar_url
    if gitlab_config.https
      gravatar_config.ssl_url
    else
      gravatar_config.plain_url
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe GravatarService, feature_category: :user_profile do
  describe '#execute' do
    let(:url) { 'http://example.com/avatar?hash=%{hash}&size=%{size}&email=%{email}&username=%{username}' }

    before do
      allow(Gitlab.config.gravatar).to receive(:plain_url).and_return(url)
    end

    it 'replaces the placeholders' do
      avatar_url = described_class.new.execute('user@example.com', 100, 2, username: 'user')

      expect(avatar_url).to include(""hash=#{Digest::MD5.hexdigest('user@example.com')}"")
      expect(avatar_url).to include(""size=200"")
      expect(avatar_url).to include(""email=user%40example.com"")
      expect(avatar_url).to include(""username=user"")
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class AccessTokenValidationService
  # Results:
  VALID = :valid
  EXPIRED = :expired
  REVOKED = :revoked
  INSUFFICIENT_SCOPE = :insufficient_scope
  IMPERSONATION_DISABLED = :impersonation_disabled

  attr_reader :token, :request

  def initialize(token, request: nil)
    @token = token
    @request = request
  end

  def validate(scopes: [])
    if token.expired?
      EXPIRED

    elsif token.revoked?
      REVOKED

    elsif !self.include_any_scope?(scopes)
      INSUFFICIENT_SCOPE

    elsif token.respond_to?(:impersonation) &&
        token.impersonation &&
        !Gitlab.config.gitlab.impersonation_enabled
      IMPERSONATION_DISABLED

    else
      VALID
    end
  end

  # True if the token's scope contains any of the passed scopes.
  def include_any_scope?(required_scopes)
    if required_scopes.blank?
      true
    else
      # We're comparing each required_scope against all token scopes, which would
      # take quadratic time. This consideration is irrelevant here because of the
      # small number of records involved.
      # https://gitlab.com/gitlab-org/gitlab-foss/merge_requests/12300/#note_33689006
      token_scopes = token.scopes.map(&:to_sym)

      required_scopes.any? do |scope|
        scope = API::Scope.new(scope) unless scope.is_a?(API::Scope)
        scope.sufficient?(token_scopes, request)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe AccessTokenValidationService, feature_category: :system_access do
  describe "".include_any_scope?"" do
    let(:request) { double(""request"") }

    it ""returns true if the required scope is present in the token's scopes"" do
      token = double(""token"", scopes: [:api, :read_user])
      scopes = [:api]

      expect(described_class.new(token, request: request).include_any_scope?(scopes)).to be(true)
    end

    it ""returns true if more than one of the required scopes is present in the token's scopes"" do
      token = double(""token"", scopes: [:api, :read_user, :other_scope])
      scopes = [:api, :other_scope]

      expect(described_class.new(token, request: request).include_any_scope?(scopes)).to be(true)
    end

    it ""returns true if the list of required scopes is an exact match for the token's scopes"" do
      token = double(""token"", scopes: [:api, :read_user, :other_scope])
      scopes = [:api, :read_user, :other_scope]

      expect(described_class.new(token, request: request).include_any_scope?(scopes)).to be(true)
    end

    it ""returns true if the list of required scopes contains all of the token's scopes, in addition to others"" do
      token = double(""token"", scopes: [:api, :read_user])
      scopes = [:api, :read_user, :other_scope]

      expect(described_class.new(token, request: request).include_any_scope?(scopes)).to be(true)
    end

    it 'returns true if the list of required scopes is blank' do
      token = double(""token"", scopes: [])
      scopes = []

      expect(described_class.new(token, request: request).include_any_scope?(scopes)).to be(true)
    end

    it ""returns false if there are no scopes in common between the required scopes and the token scopes"" do
      token = double(""token"", scopes: [:api, :read_user])
      scopes = [:other_scope]

      expect(described_class.new(token, request: request).include_any_scope?(scopes)).to be(false)
    end

    context ""conditions"" do
      it ""ignores any scopes whose `if` condition returns false"" do
        token = double(""token"", scopes: [:api, :read_user])
        scopes = [API::Scope.new(:api, if: ->(_) { false })]

        expect(described_class.new(token, request: request).include_any_scope?(scopes)).to be(false)
      end

      it ""does not ignore scopes whose `if` condition is not set"" do
        token = double(""token"", scopes: [:api, :read_user])
        scopes = [API::Scope.new(:api, if: ->(_) { false }), :read_user]

        expect(described_class.new(token, request: request).include_any_scope?(scopes)).to be(true)
      end

      it ""does not ignore scopes whose `if` condition returns true"" do
        token = double(""token"", scopes: [:api, :read_user])
        scopes = [API::Scope.new(:api, if: ->(_) { true }), API::Scope.new(:read_user, if: ->(_) { false })]

        expect(described_class.new(token, request: request).include_any_scope?(scopes)).to be(true)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class AuditEventService
  include AuditEventSaveType

  # Instantiates a new service
  #
  # @param [User, token String] author the entity who authors the change
  # @param [User, Project, Group] entity the scope which audit event belongs to
  #   This param is also used to determine the visibility of the audit event.
  #   - Project: events are visible at Project and Instance level
  #   - Group: events are visible at Group and Instance level
  #   - User: events are visible at Instance level
  # @param [Hash] details extra data of audit event
  # @param [Symbol] save_type the type to save the event
  #   Can be selected from the following, :database, :stream, :database_and_stream .
  # @params [DateTime] created_at the time the action occured
  #
  # @return [AuditEventService]
  def initialize(author, entity, details = {}, save_type = :database_and_stream, created_at = DateTime.current)
    @author = build_author(author)
    @entity = entity
    @details = details
    @ip_address = resolve_ip_address(@author)
    @save_type = save_type
    @created_at = created_at
  end

  # Builds the @details attribute for authentication
  #
  # This uses the @author as the target object being audited
  #
  # @return [AuditEventService]
  def for_authentication
    mark_as_authentication_event!

    @details = {
      with: @details[:with],
      target_id: @author.id,
      target_type: 'User',
      target_details: @author.name
    }

    self
  end

  # Writes event to a file and creates an event record in DB
  #
  # @return [AuditEvent] persisted if saves and non-persisted if fails
  def security_event
    log_security_event_to_file
    log_authentication_event_to_database
    log_security_event_to_database
  end

  # Writes event to a file
  def log_security_event_to_file
    file_logger.info(base_payload.merge(formatted_details))
  end

  private

  attr_reader :ip_address

  def build_author(author)
    case author
    when User
      author.impersonated? ? Gitlab::Audit::ImpersonatedAuthor.new(author) : author
    else
      Gitlab::Audit::UnauthenticatedAuthor.new(name: author)
    end
  end

  def resolve_ip_address(author)
    Gitlab::RequestContext.instance.client_ip ||
      author.current_sign_in_ip
  end

  def base_payload
    {
      author_id: @author.id,
      author_name: @author.name,
      entity_id: @entity.id,
      entity_type: @entity.class.name,
      created_at: @created_at
    }
  end

  def authentication_event_payload
    {
      # @author can be a User or various Gitlab::Audit authors.
      # Only capture real users for successful authentication events.
      user: author_if_user,
      user_name: @author.name,
      ip_address: ip_address,
      result: AuthenticationEvent.results[:success],
      provider: @details[:with]
    }
  end

  def author_if_user
    @author if @author.is_a?(User)
  end

  def file_logger
    @file_logger ||= Gitlab::AuditJsonLogger.build
  end

  def formatted_details
    @details.merge(@details.slice(:from, :to).transform_values(&:to_s))
  end

  def mark_as_authentication_event!
    @authentication_event = true
  end

  def authentication_event?
    @authentication_event
  end

  def log_security_event_to_database
    return if Gitlab::Database.read_only?

    event = build_event
    save_or_track event
    event
  end

  def build_event
    AuditEvent.new(base_payload.merge(details: @details))
  end

  def stream_event_to_external_destinations(_event)
    # Defined in EE
  end

  def log_authentication_event_to_database
    return unless Gitlab::Database.read_write? && authentication_event?

    event = AuthenticationEvent.new(authentication_event_payload)
    save_or_track event

    event
  end

  def save_or_track(event)
    event.save! if should_save_database?(@save_type)
    stream_event_to_external_destinations(event) if should_save_stream?(@save_type)
  rescue StandardError => e
    Gitlab::ErrorTracking.track_and_raise_for_dev_exception(e, audit_event_type: event.class.to_s)
  end
end

AuditEventService.prepend_mod_with('AuditEventService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe AuditEventService, :with_license, feature_category: :audit_events do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user, :with_sign_ins) }
  let_it_be(:project_member) { create(:project_member, user: user) }

  let(:service) { described_class.new(user, project, { action: :destroy }) }
  let(:logger) { instance_double(Gitlab::AuditJsonLogger) }

  describe '#security_event' do
    it 'creates an event and logs to a file' do
      expect(service).to receive(:file_logger).and_return(logger)
      expect(logger).to receive(:info).with({ author_id: user.id,
                                              author_name: user.name,
                                              entity_id: project.id,
                                              entity_type: ""Project"",
                                              action: :destroy,
                                              created_at: anything })

      expect { service.security_event }.to change(AuditEvent, :count).by(1)
    end

    it 'formats from and to fields' do
      service = described_class.new(
        user, project,
        {
          from: true,
          to: false,
          action: :create,
          target_id: 1
        })
      expect(service).to receive(:file_logger).and_return(logger)
      expect(logger).to receive(:info).with({ author_id: user.id,
                                              author_name: user.name,
                                              entity_type: 'Project',
                                              entity_id: project.id,
                                              from: 'true',
                                              to: 'false',
                                              action: :create,
                                              target_id: 1,
                                              created_at: anything })

      expect { service.security_event }.to change(AuditEvent, :count).by(1)

      details = AuditEvent.last.details
      expect(details[:from]).to be true
      expect(details[:to]).to be false
      expect(details[:action]).to eq(:create)
      expect(details[:target_id]).to eq(1)
    end

    context 'when defining created_at manually' do
      let(:service) { described_class.new(user, project, { action: :destroy }, :database, 3.weeks.ago) }

      it 'is overridden successfully' do
        freeze_time do
          expect(service).to receive(:file_logger).and_return(logger)
          expect(logger).to receive(:info).with({ author_id: user.id,
                                                  author_name: user.name,
                                                  entity_id: project.id,
                                                  entity_type: ""Project"",
                                                  action: :destroy,
                                                  created_at: 3.weeks.ago })

          expect { service.security_event }.to change(AuditEvent, :count).by(1)
          expect(AuditEvent.last.created_at).to eq(3.weeks.ago)
        end
      end
    end

    context 'authentication event' do
      let(:audit_service) { described_class.new(user, user, with: 'standard') }

      it 'creates an authentication event' do
        expect(AuthenticationEvent).to receive(:new).with(
          {
            user: user,
            user_name: user.name,
            ip_address: user.current_sign_in_ip,
            result: AuthenticationEvent.results[:success],
            provider: 'standard'
          }
        ).and_call_original

        audit_service.for_authentication.security_event
      end

      it 'tracks exceptions when the event cannot be created' do
        allow_next_instance_of(AuditEvent) do |event|
          allow(event).to receive(:valid?).and_return(false)
        end

        expect(Gitlab::ErrorTracking).to(
          receive(:track_and_raise_for_dev_exception)
        )

        audit_service.for_authentication.security_event
      end

      context 'with IP address', :request_store do
        using RSpec::Parameterized::TableSyntax

        where(:from_context, :from_author_sign_in, :output) do
          '192.168.0.2' | '192.168.0.3' | '192.168.0.2'
          nil           | '192.168.0.3' | '192.168.0.3'
        end

        with_them do
          let(:user) { create(:user, current_sign_in_ip: from_author_sign_in) }
          let(:audit_service) { described_class.new(user, user, with: 'standard') }

          before do
            allow(Gitlab::RequestContext.instance).to receive(:client_ip).and_return(from_context)
          end

          specify do
            expect(AuthenticationEvent).to receive(:new).with(hash_including(ip_address: output)).and_call_original

            audit_service.for_authentication.security_event
          end
        end
      end
    end
  end

  describe '#log_security_event_to_file' do
    it 'logs security event to file' do
      expect(service).to receive(:file_logger).and_return(logger)
      expect(logger).to receive(:info).with({ author_id: user.id,
                                              author_name: user.name,
                                              entity_type: 'Project',
                                              entity_id: project.id,
                                              action: :destroy,
                                              created_at: anything })

      service.log_security_event_to_file
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# SystemNoteService
#
# Used for creating system notes (e.g., when a user references a merge request
# from an issue, an issue's assignee changes, an issue is closed, etc.)
module SystemNoteService
  extend self

  # Called when commits are added to a merge request
  #
  # noteable         - Noteable object
  # project          - Project owning noteable
  # author           - User performing the change
  # new_commits      - Array of Commits added since last push
  # existing_commits - Array of Commits added in a previous push
  # oldrev           - Optional String SHA of a previous Commit
  #
  # Returns the created Note object
  def add_commits(noteable, project, author, new_commits, existing_commits = [], oldrev = nil)
    ::SystemNotes::CommitService.new(noteable: noteable, project: project, author: author).add_commits(new_commits, existing_commits, oldrev)
  end

  # Called when a commit was tagged
  #
  # noteable  - Noteable object
  # project   - Project owning noteable
  # author    - User performing the tag
  # tag_name  - The created tag name
  #
  # Returns the created Note object
  def tag_commit(noteable, project, author, tag_name)
    ::SystemNotes::CommitService.new(noteable: noteable, project: project, author: author).tag_commit(tag_name)
  end

  def change_assignee(noteable, project, author, assignee)
    ::SystemNotes::IssuablesService.new(noteable: noteable, project: project, author: author).change_assignee(assignee)
  end

  def change_issuable_assignees(issuable, project, author, old_assignees)
    ::SystemNotes::IssuablesService.new(noteable: issuable, project: project, author: author).change_issuable_assignees(old_assignees)
  end

  def change_issuable_reviewers(issuable, project, author, old_reviewers)
    ::SystemNotes::IssuablesService.new(noteable: issuable, project: project, author: author).change_issuable_reviewers(old_reviewers)
  end

  def change_issuable_contacts(issuable, project, author, added_count, removed_count)
    ::SystemNotes::IssuablesService.new(noteable: issuable, project: project, author: author).change_issuable_contacts(added_count, removed_count)
  end

  def relate_issuable(noteable, noteable_ref, user)
    ::SystemNotes::IssuablesService.new(noteable: noteable, project: noteable.project, author: user).relate_issuable(noteable_ref)
  end

  def unrelate_issuable(noteable, noteable_ref, user)
    ::SystemNotes::IssuablesService.new(noteable: noteable, project: noteable.project, author: user).unrelate_issuable(noteable_ref)
  end

  # Called when the due_date or start_date of a Noteable is changed
  #
  # noteable  - Noteable object
  # project   - Project owning noteable
  # author    - User performing the change
  # due_date  - Due date being assigned, or nil
  #
  # Example Note text:
  #
  #   ""removed due date""
  #
  #   ""changed due date to September 20, 2018 and changed start date to September 25, 2018""
  #
  # Returns the created Note object
  def change_start_date_or_due_date(noteable, project, author, changed_dates)
    ::SystemNotes::TimeTrackingService.new(
      noteable: noteable,
      project: project,
      author: author
    ).change_start_date_or_due_date(changed_dates)
  end

  # Called when the estimated time of a Noteable is changed
  #
  # noteable      - Noteable object
  # project       - Project owning noteable
  # author        - User performing the change
  # time_estimate - Estimated time
  #
  # Example Note text:
  #
  #   ""removed time estimate""
  #
  #   ""changed time estimate to 3d 5h""
  #
  # Returns the created Note object
  def change_time_estimate(noteable, project, author)
    ::SystemNotes::TimeTrackingService.new(noteable: noteable, project: project, author: author).change_time_estimate
  end

  # Called when the spent time of a Noteable is changed
  #
  # noteable   - Noteable object
  # project    - Project owning noteable
  # author     - User performing the change
  # time_spent - Spent time
  #
  # Example Note text:
  #
  #   ""removed time spent""
  #
  #   ""added 2h 30m of time spent""
  #
  # Returns the created Note object
  def change_time_spent(noteable, project, author)
    ::SystemNotes::TimeTrackingService.new(noteable: noteable, project: project, author: author).change_time_spent
  end

  # Called when a timelog is added to an issuable
  #
  # issuable   - Issuable object (Issue, WorkItem or MergeRequest)
  # project    - Project owning the issuable
  # author     - User performing the change
  # timelog    - Created timelog
  #
  # Example Note text:
  #
  #   ""subtracted 1h 15m of time spent""
  #
  #   ""added 2h 30m of time spent""
  #
  # Returns the created Note object
  def created_timelog(issuable, project, author, timelog)
    ::SystemNotes::TimeTrackingService.new(noteable: issuable, project: project, author: author).created_timelog(timelog)
  end

  # Called when a timelog is removed from a Noteable
  #
  # noteable  - Noteable object
  # project   - Project owning the noteable
  # author    - User performing the change
  # timelog   - The removed timelog
  #
  # Example Note text:
  #   ""deleted 2h 30m of time spent from 22-03-2022""
  #
  # Returns the created Note object
  def remove_timelog(noteable, project, author, timelog)
    ::SystemNotes::TimeTrackingService.new(noteable: noteable, project: project, author: author).remove_timelog(timelog)
  end

  def close_after_error_tracking_resolve(issue, project, author)
    ::SystemNotes::IssuablesService.new(noteable: issue, project: project, author: author).close_after_error_tracking_resolve
  end

  def change_status(noteable, project, author, status, source = nil)
    ::SystemNotes::IssuablesService.new(noteable: noteable, project: project, author: author).change_status(status, source)
  end

  # Called when 'merge when pipeline succeeds' is executed
  def merge_when_pipeline_succeeds(noteable, project, author, sha)
    ::SystemNotes::MergeRequestsService.new(noteable: noteable, project: project, author: author).merge_when_pipeline_succeeds(sha)
  end

  # Called when 'merge when pipeline succeeds' is canceled
  def cancel_merge_when_pipeline_succeeds(noteable, project, author)
    ::SystemNotes::MergeRequestsService.new(noteable: noteable, project: project, author: author).cancel_merge_when_pipeline_succeeds
  end

  # Called when 'merge when pipeline succeeds' is aborted
  def abort_merge_when_pipeline_succeeds(noteable, project, author, reason)
    ::SystemNotes::MergeRequestsService.new(noteable: noteable, project: project, author: author).abort_merge_when_pipeline_succeeds(reason)
  end

  def handle_merge_request_draft(noteable, project, author)
    ::SystemNotes::MergeRequestsService.new(noteable: noteable, project: project, author: author).handle_merge_request_draft
  end

  def add_merge_request_draft_from_commit(noteable, project, author, commit)
    ::SystemNotes::MergeRequestsService.new(noteable: noteable, project: project, author: author).add_merge_request_draft_from_commit(commit)
  end

  def resolve_all_discussions(merge_request, project, author)
    ::SystemNotes::MergeRequestsService.new(noteable: merge_request, project: project, author: author).resolve_all_discussions
  end

  def discussion_continued_in_issue(discussion, project, author, issue)
    ::SystemNotes::MergeRequestsService.new(project: project, author: author).discussion_continued_in_issue(discussion, issue)
  end

  def diff_discussion_outdated(discussion, project, author, change_position)
    ::SystemNotes::MergeRequestsService.new(project: project, author: author).diff_discussion_outdated(discussion, change_position)
  end

  def change_title(noteable, project, author, old_title)
    ::SystemNotes::IssuablesService.new(noteable: noteable, project: project, author: author).change_title(old_title)
  end

  def change_description(noteable, project, author)
    ::SystemNotes::IssuablesService.new(noteable: noteable, project: project, author: author).change_description
  end

  def change_issue_confidentiality(issue, project, author)
    ::SystemNotes::IssuablesService.new(noteable: issue, project: project, author: author).change_issue_confidentiality
  end

  # Called when a branch in Noteable is changed
  #
  # noteable    - Noteable object
  # project     - Project owning noteable
  # author      - User performing the change
  # branch_type - 'source' or 'target'
  # event_type  - the source of event: 'update' or 'delete'
  # old_branch  - old branch name
  # new_branch  - new branch name
  #
  # Example Note text is based on event_type:
  #
  #   update: ""changed target branch from `Old` to `New`""
  #   delete: ""deleted the `Old` branch. This merge request now targets the `New` branch""
  #
  # Returns the created Note object
  def change_branch(noteable, project, author, branch_type, event_type, old_branch, new_branch)
    ::SystemNotes::MergeRequestsService.new(noteable: noteable, project: project, author: author)
      .change_branch(branch_type, event_type, old_branch, new_branch)
  end

  # Called when a branch in Noteable is added or deleted
  #
  # noteable    - Noteable object
  # project     - Project owning noteable
  # author      - User performing the change
  # branch_type - :source or :target
  # branch      - branch name
  # presence    - :add or :delete
  #
  # Example Note text:
  #
  #   ""restored target branch `feature`""
  #
  # Returns the created Note object
  def change_branch_presence(noteable, project, author, branch_type, branch, presence)
    ::SystemNotes::MergeRequestsService.new(noteable: noteable, project: project, author: author).change_branch_presence(branch_type, branch, presence)
  end

  # Called when a branch is created from the 'new branch' button on a issue
  # Example note text:
  #
  #   ""created branch `201-issue-branch-button`""
  def new_issue_branch(issue, project, author, branch, branch_project: nil)
    ::SystemNotes::MergeRequestsService.new(noteable: issue, project: project, author: author).new_issue_branch(branch, branch_project: branch_project)
  end

  def new_merge_request(issue, project, author, merge_request)
    ::SystemNotes::MergeRequestsService.new(noteable: issue, project: project, author: author).new_merge_request(merge_request)
  end

  def cross_reference(mentioned, mentioned_in, author)
    ::SystemNotes::IssuablesService.new(noteable: mentioned, author: author).cross_reference(mentioned_in)
  end

  def cross_reference_exists?(mentioned, mentioned_in)
    ::SystemNotes::IssuablesService.new(noteable: mentioned).cross_reference_exists?(mentioned_in)
  end

  def change_task_status(noteable, project, author, new_task)
    ::SystemNotes::IssuablesService.new(noteable: noteable, project: project, author: author).change_task_status(new_task)
  end

  def noteable_moved(noteable, project, noteable_ref, author, direction:)
    ::SystemNotes::IssuablesService.new(noteable: noteable, project: project, author: author).noteable_moved(noteable_ref, direction)
  end

  def noteable_cloned(noteable, project, noteable_ref, author, direction:, created_at: nil)
    ::SystemNotes::IssuablesService.new(noteable: noteable, project: project, author: author).noteable_cloned(noteable_ref, direction, created_at: created_at)
  end

  def mark_duplicate_issue(noteable, project, author, canonical_issue)
    ::SystemNotes::IssuablesService.new(noteable: noteable, project: project, author: author).mark_duplicate_issue(canonical_issue)
  end

  def mark_canonical_issue_of_duplicate(noteable, project, author, duplicate_issue)
    ::SystemNotes::IssuablesService.new(noteable: noteable, project: project, author: author).mark_canonical_issue_of_duplicate(duplicate_issue)
  end

  def add_email_participants(noteable, project, author, body)
    ::SystemNotes::IssuablesService.new(noteable: noteable, project: project, author: author).add_email_participants(body)
  end

  def discussion_lock(issuable, author)
    ::SystemNotes::IssuablesService.new(noteable: issuable, project: issuable.project, author: author).discussion_lock
  end

  def cross_reference_disallowed?(mentioned, mentioned_in)
    ::SystemNotes::IssuablesService.new(noteable: mentioned).cross_reference_disallowed?(mentioned_in)
  end

  def relate_work_item(noteable, work_item, user)
    ::SystemNotes::IssuablesService
      .new(noteable: noteable, project: noteable.project, author: user)
      .hierarchy_changed(work_item, 'relate')
  end

  def unrelate_work_item(noteable, work_item, user)
    ::SystemNotes::IssuablesService
      .new(noteable: noteable, project: noteable.project, author: user)
      .hierarchy_changed(work_item, 'unrelate')
  end

  def zoom_link_added(issue, project, author)
    ::SystemNotes::ZoomService.new(noteable: issue, project: project, author: author).zoom_link_added
  end

  def zoom_link_removed(issue, project, author)
    ::SystemNotes::ZoomService.new(noteable: issue, project: project, author: author).zoom_link_removed
  end

  def auto_resolve_prometheus_alert(noteable, project, author)
    ::SystemNotes::IssuablesService.new(noteable: noteable, project: project, author: author).auto_resolve_prometheus_alert
  end

  # Parameters:
  #   - version [DesignManagement::Version]
  #
  # Example Note text:
  #
  #   ""added [1 designs](link-to-version)""
  #   ""changed [2 designs](link-to-version)""
  #
  # Returns [Array<Note>]: the created Note objects
  def design_version_added(version)
    ::SystemNotes::DesignManagementService.new(noteable: version.issue, project: version.issue.project, author: version.author).design_version_added(version)
  end

  # Called when a new discussion is created on a design
  #
  # discussion_note - DiscussionNote
  #
  # Example Note text:
  #
  #   ""started a discussion on screen.png""
  #
  # Returns the created Note object
  def design_discussion_added(discussion_note)
    design = discussion_note.noteable

    ::SystemNotes::DesignManagementService.new(noteable: design.issue, project: design.project, author: discussion_note.author).design_discussion_added(discussion_note)
  end

  # Called when the merge request is approved by user
  #
  # noteable - Noteable object
  # user     - User performing approve
  #
  # Example Note text:
  #
  #   ""approved this merge request""
  #
  # Returns the created Note object
  def approve_mr(noteable, user)
    merge_requests_service(noteable, noteable.project, user).approve_mr
  end

  def unapprove_mr(noteable, user)
    merge_requests_service(noteable, noteable.project, user).unapprove_mr
  end

  def change_alert_status(alert, author, reason = nil)
    ::SystemNotes::AlertManagementService.new(noteable: alert, project: alert.project, author: author).change_alert_status(reason)
  end

  def new_alert_issue(alert, issue, author)
    ::SystemNotes::AlertManagementService.new(noteable: alert, project: alert.project, author: author).new_alert_issue(issue)
  end

  def create_new_alert(alert, monitoring_tool)
    ::SystemNotes::AlertManagementService.new(noteable: alert, project: alert.project).create_new_alert(monitoring_tool)
  end

  def change_incident_severity(incident, author)
    ::SystemNotes::IncidentService.new(noteable: incident, project: incident.project, author: author).change_incident_severity
  end

  def change_incident_status(incident, author, reason = nil)
    ::SystemNotes::IncidentService.new(noteable: incident, project: incident.project, author: author).change_incident_status(reason)
  end

  def log_resolving_alert(alert, monitoring_tool)
    ::SystemNotes::AlertManagementService.new(noteable: alert, project: alert.project).log_resolving_alert(monitoring_tool)
  end

  def change_issue_type(issue, author, previous_type)
    ::SystemNotes::IssuablesService.new(noteable: issue, project: issue.project, author: author).change_issue_type(previous_type)
  end

  def add_timeline_event(timeline_event)
    incidents_service(timeline_event.incident).add_timeline_event(timeline_event)
  end

  def edit_timeline_event(timeline_event, author, was_changed:)
    incidents_service(timeline_event.incident).edit_timeline_event(timeline_event, author, was_changed: was_changed)
  end

  def delete_timeline_event(noteable, author)
    incidents_service(noteable).delete_timeline_event(author)
  end

  private

  def merge_requests_service(noteable, project, author)
    ::SystemNotes::MergeRequestsService.new(noteable: noteable, project: project, author: author)
  end

  def incidents_service(incident)
    ::SystemNotes::IncidentsService.new(noteable: incident)
  end
end

SystemNoteService.prepend_mod_with('SystemNoteService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe SystemNoteService, feature_category: :shared do
  include Gitlab::Routing
  include RepoHelpers
  include AssetsHelpers
  include DesignManagementTestHelpers

  let_it_be(:group)    { create(:group) }
  let_it_be(:project)  { create(:project, :repository, group: group) }
  let_it_be(:author)   { create(:user) }

  let(:noteable) { create(:issue, project: project) }
  let(:issue)    { noteable }

  describe '.add_commits' do
    let(:new_commits) { double }
    let(:old_commits) { double }
    let(:oldrev)      { double }

    it 'calls CommitService' do
      expect_next_instance_of(::SystemNotes::CommitService) do |service|
        expect(service).to receive(:add_commits).with(new_commits, old_commits, oldrev)
      end

      described_class.add_commits(noteable, project, author, new_commits, old_commits, oldrev)
    end
  end

  describe '.tag_commit' do
    let(:tag_name) { double }

    it 'calls CommitService' do
      expect_next_instance_of(::SystemNotes::CommitService) do |service|
        expect(service).to receive(:tag_commit).with(tag_name)
      end

      described_class.tag_commit(noteable, project, author, tag_name)
    end
  end

  describe '.change_assignee' do
    let(:assignee) { double }

    it 'calls IssuableService' do
      expect_next_instance_of(::SystemNotes::IssuablesService) do |service|
        expect(service).to receive(:change_assignee).with(assignee)
      end

      described_class.change_assignee(noteable, project, author, assignee)
    end
  end

  describe '.change_issuable_assignees' do
    let(:assignees) { [double, double] }

    it 'calls IssuableService' do
      expect_next_instance_of(::SystemNotes::IssuablesService) do |service|
        expect(service).to receive(:change_issuable_assignees).with(assignees)
      end

      described_class.change_issuable_assignees(noteable, project, author, assignees)
    end
  end

  describe '.change_issuable_reviewers' do
    let(:reviewers) { [double, double] }

    it 'calls IssuableService' do
      expect_next_instance_of(::SystemNotes::IssuablesService) do |service|
        expect(service).to receive(:change_issuable_reviewers).with(reviewers)
      end

      described_class.change_issuable_reviewers(noteable, project, author, reviewers)
    end
  end

  describe '.change_issuable_contacts' do
    let(:added_count) { 5 }
    let(:removed_count) { 3 }

    it 'calls IssuableService' do
      expect_next_instance_of(::SystemNotes::IssuablesService) do |service|
        expect(service).to receive(:change_issuable_contacts).with(added_count, removed_count)
      end

      described_class.change_issuable_contacts(noteable, project, author, added_count, removed_count)
    end
  end

  describe '.close_after_error_tracking_resolve' do
    it 'calls IssuableService' do
      expect_next_instance_of(::SystemNotes::IssuablesService) do |service|
        expect(service).to receive(:close_after_error_tracking_resolve)
      end

      described_class.close_after_error_tracking_resolve(noteable, project, author)
    end
  end

  describe '.relate_issuable' do
    let(:noteable_ref) { double }
    let(:noteable) { double }

    before do
      allow(noteable).to receive(:project).and_return(double)
    end

    it 'calls IssuableService' do
      expect_next_instance_of(::SystemNotes::IssuablesService) do |service|
        expect(service).to receive(:relate_issuable).with(noteable_ref)
      end

      described_class.relate_issuable(noteable, noteable_ref, double)
    end
  end

  describe '.unrelate_issuable' do
    let(:noteable_ref) { double }
    let(:noteable) { double }

    before do
      allow(noteable).to receive(:project).and_return(double)
    end

    it 'calls IssuableService' do
      expect_next_instance_of(::SystemNotes::IssuablesService) do |service|
        expect(service).to receive(:unrelate_issuable).with(noteable_ref)
      end

      described_class.unrelate_issuable(noteable, noteable_ref, double)
    end
  end

  describe '.change_start_date_or_due_date' do
    let(:changed_dates) { double }

    it 'calls TimeTrackingService' do
      expect_next_instance_of(::SystemNotes::TimeTrackingService) do |service|
        expect(service).to receive(:change_start_date_or_due_date).with(changed_dates)
      end

      described_class.change_start_date_or_due_date(noteable, project, author, changed_dates)
    end
  end

  describe '.change_status' do
    let(:status) { double }
    let(:source) { double }

    it 'calls IssuableService' do
      expect_next_instance_of(::SystemNotes::IssuablesService) do |service|
        expect(service).to receive(:change_status).with(status, source)
      end

      described_class.change_status(noteable, project, author, status, source)
    end
  end

  describe '.merge_when_pipeline_succeeds' do
    it 'calls MergeRequestsService' do
      sha = double

      expect_next_instance_of(::SystemNotes::MergeRequestsService) do |service|
        expect(service).to receive(:merge_when_pipeline_succeeds).with(sha)
      end

      described_class.merge_when_pipeline_succeeds(noteable, project, author, sha)
    end
  end

  describe '.cancel_merge_when_pipeline_succeeds' do
    it 'calls MergeRequestsService' do
      expect_next_instance_of(::SystemNotes::MergeRequestsService) do |service|
        expect(service).to receive(:cancel_merge_when_pipeline_succeeds)
      end

      described_class.cancel_merge_when_pipeline_succeeds(noteable, project, author)
    end
  end

  describe '.abort_merge_when_pipeline_succeeds' do
    it 'calls MergeRequestsService' do
      reason = double

      expect_next_instance_of(::SystemNotes::MergeRequestsService) do |service|
        expect(service).to receive(:abort_merge_when_pipeline_succeeds).with(reason)
      end

      described_class.abort_merge_when_pipeline_succeeds(noteable, project, author, reason)
    end
  end

  describe '.change_title' do
    let(:title) { double }

    it 'calls IssuableService' do
      expect_next_instance_of(::SystemNotes::IssuablesService) do |service|
        expect(service).to receive(:change_title).with(title)
      end

      described_class.change_title(noteable, project, author, title)
    end
  end

  describe '.change_description' do
    it 'calls IssuableService' do
      expect_next_instance_of(::SystemNotes::IssuablesService) do |service|
        expect(service).to receive(:change_description)
      end

      described_class.change_description(noteable, project, author)
    end
  end

  describe '.change_issue_confidentiality' do
    it 'calls IssuableService' do
      expect_next_instance_of(::SystemNotes::IssuablesService) do |service|
        expect(service).to receive(:change_issue_confidentiality)
      end

      described_class.change_issue_confidentiality(noteable, project, author)
    end
  end

  describe '.change_branch' do
    it 'calls MergeRequestsService' do
      old_branch = double('old_branch')
      new_branch = double('new_branch')
      branch_type = double('branch_type')
      event_type = double('event_type')

      expect_next_instance_of(::SystemNotes::MergeRequestsService) do |service|
        expect(service).to receive(:change_branch).with(branch_type, event_type, old_branch, new_branch)
      end

      described_class.change_branch(noteable, project, author, branch_type, event_type, old_branch, new_branch)
    end
  end

  describe '.change_branch_presence' do
    it 'calls MergeRequestsService' do
      presence = double
      branch = double
      branch_type = double

      expect_next_instance_of(::SystemNotes::MergeRequestsService) do |service|
        expect(service).to receive(:change_branch_presence).with(branch_type, branch, presence)
      end

      described_class.change_branch_presence(noteable, project, author, branch_type, branch, presence)
    end
  end

  describe '.new_issue_branch' do
    it 'calls MergeRequestsService' do
      branch = double
      branch_project = double

      expect_next_instance_of(::SystemNotes::MergeRequestsService) do |service|
        expect(service).to receive(:new_issue_branch).with(branch, branch_project: branch_project)
      end

      described_class.new_issue_branch(noteable, project, author, branch, branch_project: branch_project)
    end
  end

  describe '.new_merge_request' do
    it 'calls MergeRequestsService' do
      merge_request = double

      expect_next_instance_of(::SystemNotes::MergeRequestsService) do |service|
        expect(service).to receive(:new_merge_request).with(merge_request)
      end

      described_class.new_merge_request(noteable, project, author, merge_request)
    end
  end

  describe '.zoom_link_added' do
    it 'calls ZoomService' do
      expect_next_instance_of(::SystemNotes::ZoomService) do |service|
        expect(service).to receive(:zoom_link_added)
      end

      described_class.zoom_link_added(noteable, project, author)
    end
  end

  describe '.zoom_link_removed' do
    it 'calls ZoomService' do
      expect_next_instance_of(::SystemNotes::ZoomService) do |service|
        expect(service).to receive(:zoom_link_removed)
      end

      described_class.zoom_link_removed(noteable, project, author)
    end
  end

  describe '.cross_reference' do
    let(:mentioned_in) { double }

    it 'calls IssuableService' do
      expect_next_instance_of(::SystemNotes::IssuablesService) do |service|
        expect(service).to receive(:cross_reference).with(mentioned_in)
      end

      described_class.cross_reference(double, mentioned_in, double)
    end
  end

  describe '.cross_reference_disallowed?' do
    let(:mentioned_in) { double }

    it 'calls IssuableService' do
      expect_next_instance_of(::SystemNotes::IssuablesService) do |service|
        expect(service).to receive(:cross_reference_disallowed?).with(mentioned_in)
      end

      described_class.cross_reference_disallowed?(double, mentioned_in)
    end
  end

  describe '.cross_reference_exists?' do
    let(:mentioned_in) { double }

    it 'calls IssuableService' do
      expect_next_instance_of(::SystemNotes::IssuablesService) do |service|
        expect(service).to receive(:cross_reference_exists?).with(mentioned_in)
      end

      described_class.cross_reference_exists?(double, mentioned_in)
    end
  end

  describe '.noteable_moved' do
    let(:noteable_ref) { double }
    let(:direction) { double }

    it 'calls IssuableService' do
      expect_next_instance_of(::SystemNotes::IssuablesService) do |service|
        expect(service).to receive(:noteable_moved).with(noteable_ref, direction)
      end

      described_class.noteable_moved(double, double, noteable_ref, double, direction: direction)
    end
  end

  describe '.noteable_cloned' do
    let(:noteable_ref) { double }
    let(:direction) { double }
    let(:created_at) { double }

    it 'calls IssuableService' do
      expect_next_instance_of(::SystemNotes::IssuablesService) do |service|
        expect(service).to receive(:noteable_cloned).with(noteable_ref, direction, created_at: created_at)
      end

      described_class.noteable_cloned(double, double, noteable_ref, double, direction: direction, created_at: created_at)
    end
  end

  describe '.change_time_estimate' do
    it 'calls TimeTrackingService' do
      expect_next_instance_of(::SystemNotes::TimeTrackingService) do |service|
        expect(service).to receive(:change_time_estimate)
      end

      described_class.change_time_estimate(noteable, project, author)
    end
  end

  describe '.discussion_continued_in_issue' do
    let(:discussion) { create(:diff_note_on_merge_request, project: project).to_discussion }
    let(:merge_request) { discussion.noteable }
    let(:issue) { create(:issue, project: project) }

    def reloaded_merge_request
      MergeRequest.find(merge_request.id)
    end

    subject { described_class.discussion_continued_in_issue(discussion, project, author, issue) }

    it_behaves_like 'a system note' do
      let(:expected_noteable) { discussion.first_note.noteable }
      let(:action)              { 'discussion' }
    end

    it 'creates a new note in the discussion' do
      # we need to completely rebuild the merge request object, or the `@discussions` on the merge request are not reloaded.
      expect { subject }.to change { reloaded_merge_request.discussions.first.notes.size }.by(1)
    end

    it 'mentions the created issue in the system note' do
      expect(subject.note).to include(issue.to_reference)
    end
  end

  describe '.change_time_spent' do
    it 'calls TimeTrackingService' do
      expect_next_instance_of(::SystemNotes::TimeTrackingService) do |service|
        expect(service).to receive(:change_time_spent)
      end

      described_class.change_time_spent(noteable, project, author)
    end
  end

  describe '.created_timelog' do
    let(:issue) { create(:issue, project: project) }
    let(:timelog) { create(:timelog, user: author, issue: issue, time_spent: 1800) }

    it 'calls TimeTrackingService' do
      expect_next_instance_of(::SystemNotes::TimeTrackingService) do |service|
        expect(service).to receive(:created_timelog)
      end

      described_class.created_timelog(noteable, project, author, timelog)
    end
  end

  describe '.remove_timelog' do
    let(:issue) { create(:issue, project: project) }
    let(:timelog) { create(:timelog, user: author, issue: issue, time_spent: 1800) }

    it 'calls TimeTrackingService' do
      expect_next_instance_of(::SystemNotes::TimeTrackingService) do |service|
        expect(service).to receive(:remove_timelog)
      end

      described_class.remove_timelog(noteable, project, author, timelog)
    end
  end

  describe '.handle_merge_request_draft' do
    it 'calls MergeRequestsService' do
      expect_next_instance_of(::SystemNotes::MergeRequestsService) do |service|
        expect(service).to receive(:handle_merge_request_draft)
      end

      described_class.handle_merge_request_draft(noteable, project, author)
    end
  end

  describe '.add_merge_request_draft_from_commit' do
    it 'calls MergeRequestsService' do
      commit = double

      expect_next_instance_of(::SystemNotes::MergeRequestsService) do |service|
        expect(service).to receive(:add_merge_request_draft_from_commit).with(commit)
      end

      described_class.add_merge_request_draft_from_commit(noteable, project, author, commit)
    end
  end

  describe '.change_task_status' do
    let(:new_task) { double }

    it 'calls IssuableService' do
      expect_next_instance_of(::SystemNotes::IssuablesService) do |service|
        expect(service).to receive(:change_task_status).with(new_task)
      end

      described_class.change_task_status(noteable, project, author, new_task)
    end
  end

  describe '.resolve_all_discussions' do
    it 'calls MergeRequestsService' do
      expect_next_instance_of(::SystemNotes::MergeRequestsService) do |service|
        expect(service).to receive(:resolve_all_discussions)
      end

      described_class.resolve_all_discussions(noteable, project, author)
    end
  end

  describe '.diff_discussion_outdated' do
    it 'calls MergeRequestsService' do
      discussion = double
      change_position = double

      expect_next_instance_of(::SystemNotes::MergeRequestsService) do |service|
        expect(service).to receive(:diff_discussion_outdated).with(discussion, change_position)
      end

      described_class.diff_discussion_outdated(discussion, project, author, change_position)
    end
  end

  describe '.mark_duplicate_issue' do
    let(:canonical_issue) { double }

    it 'calls IssuableService' do
      expect_next_instance_of(::SystemNotes::IssuablesService) do |service|
        expect(service).to receive(:mark_duplicate_issue).with(canonical_issue)
      end

      described_class.mark_duplicate_issue(noteable, project, author, canonical_issue)
    end
  end

  describe '.mark_canonical_issue_of_duplicate' do
    let(:duplicate_issue) { double }

    it 'calls IssuableService' do
      expect_next_instance_of(::SystemNotes::IssuablesService) do |service|
        expect(service).to receive(:mark_canonical_issue_of_duplicate).with(duplicate_issue)
      end

      described_class.mark_canonical_issue_of_duplicate(noteable, project, author, duplicate_issue)
    end
  end

  describe '.discussion_lock' do
    let(:issuable) { double }

    before do
      allow(issuable).to receive(:project).and_return(double)
    end

    it 'calls IssuableService' do
      expect_next_instance_of(::SystemNotes::IssuablesService) do |service|
        expect(service).to receive(:discussion_lock)
      end

      described_class.discussion_lock(issuable, double)
    end
  end

  describe '.auto_resolve_prometheus_alert' do
    it 'calls IssuableService' do
      expect_next_instance_of(::SystemNotes::IssuablesService) do |service|
        expect(service).to receive(:auto_resolve_prometheus_alert)
      end

      described_class.auto_resolve_prometheus_alert(noteable, project, author)
    end
  end

  describe '.design_version_added' do
    let(:version) { create(:design_version) }

    it 'calls DesignManagementService' do
      expect_next_instance_of(SystemNotes::DesignManagementService) do |service|
        expect(service).to receive(:design_version_added).with(version)
      end

      described_class.design_version_added(version)
    end
  end

  describe '.design_discussion_added' do
    let(:discussion_note) { create(:diff_note_on_design) }

    it 'calls DesignManagementService' do
      expect_next_instance_of(SystemNotes::DesignManagementService) do |service|
        expect(service).to receive(:design_discussion_added).with(discussion_note)
      end

      described_class.design_discussion_added(discussion_note)
    end
  end

  describe '.approve_mr' do
    it 'calls MergeRequestsService' do
      expect_next_instance_of(::SystemNotes::MergeRequestsService) do |service|
        expect(service).to receive(:approve_mr)
      end

      described_class.approve_mr(noteable, author)
    end
  end

  describe '.unapprove_mr' do
    it 'calls MergeRequestsService' do
      expect_next_instance_of(::SystemNotes::MergeRequestsService) do |service|
        expect(service).to receive(:unapprove_mr)
      end

      described_class.unapprove_mr(noteable, author)
    end
  end

  describe '.change_alert_status' do
    let(:alert) { build(:alert_management_alert) }

    context 'with status change reason' do
      let(:reason) { 'reason for status change' }

      it 'calls AlertManagementService' do
        expect_next_instance_of(SystemNotes::AlertManagementService) do |service|
          expect(service).to receive(:change_alert_status).with(reason)
        end

        described_class.change_alert_status(alert, author, reason)
      end
    end

    context 'without status change reason' do
      it 'calls AlertManagementService' do
        expect_next_instance_of(SystemNotes::AlertManagementService) do |service|
          expect(service).to receive(:change_alert_status).with(nil)
        end

        described_class.change_alert_status(alert, author)
      end
    end
  end

  describe '.new_alert_issue' do
    let(:alert) { build(:alert_management_alert, :with_incident) }

    it 'calls AlertManagementService' do
      expect_next_instance_of(SystemNotes::AlertManagementService) do |service|
        expect(service).to receive(:new_alert_issue).with(alert.issue)
      end

      described_class.new_alert_issue(alert, alert.issue, author)
    end
  end

  describe '.create_new_alert' do
    let(:alert) { build(:alert_management_alert) }
    let(:monitoring_tool) { 'Prometheus' }

    it 'calls AlertManagementService' do
      expect_next_instance_of(SystemNotes::AlertManagementService) do |service|
        expect(service).to receive(:create_new_alert).with(monitoring_tool)
      end

      described_class.create_new_alert(alert, monitoring_tool)
    end
  end

  describe '.change_incident_severity' do
    let(:incident) { build(:incident) }

    it 'calls IncidentService' do
      expect_next_instance_of(SystemNotes::IncidentService) do |service|
        expect(service).to receive(:change_incident_severity)
      end

      described_class.change_incident_severity(incident, author)
    end
  end

  describe '.change_incident_status' do
    let(:incident) { instance_double('Issue', project: project) }

    context 'with status change reason' do
      let(:reason) { 'reason for status change' }

      it 'calls IncidentService' do
        expect_next_instance_of(SystemNotes::IncidentService) do |service|
          expect(service).to receive(:change_incident_status).with(reason)
        end

        described_class.change_incident_status(incident, author, reason)
      end
    end

    context 'without status change reason' do
      it 'calls IncidentService' do
        expect_next_instance_of(SystemNotes::IncidentService) do |service|
          expect(service).to receive(:change_incident_status).with(nil)
        end

        described_class.change_incident_status(incident, author)
      end
    end
  end

  describe '.log_resolving_alert' do
    let(:alert) { build(:alert_management_alert) }
    let(:monitoring_tool) { 'Prometheus' }

    it 'calls AlertManagementService' do
      expect_next_instance_of(SystemNotes::AlertManagementService) do |service|
        expect(service).to receive(:log_resolving_alert).with(monitoring_tool)
      end

      described_class.log_resolving_alert(alert, monitoring_tool)
    end
  end

  describe '.change_issue_type' do
    let(:incident) { build(:incident) }

    it 'calls IssuableService' do
      expect_next_instance_of(::SystemNotes::IssuablesService) do |service|
        expect(service).to receive(:change_issue_type).with('issue')
      end

      described_class.change_issue_type(incident, author, 'issue')
    end
  end

  describe '.add_timeline_event' do
    let(:timeline_event) { instance_double('IncidentManagement::TimelineEvent', incident: noteable, project: project) }

    it 'calls IncidentsService' do
      expect_next_instance_of(::SystemNotes::IncidentsService) do |service|
        expect(service).to receive(:add_timeline_event).with(timeline_event)
      end

      described_class.add_timeline_event(timeline_event)
    end
  end

  describe '.edit_timeline_event' do
    let(:timeline_event) { instance_double('IncidentManagement::TimelineEvent', incident: noteable, project: project) }

    it 'calls IncidentsService' do
      expect_next_instance_of(::SystemNotes::IncidentsService) do |service|
        expect(service).to receive(:edit_timeline_event).with(timeline_event, author, was_changed: :occurred_at)
      end

      described_class.edit_timeline_event(timeline_event, author, was_changed: :occurred_at)
    end
  end

  describe '.delete_timeline_event' do
    it 'calls IncidentsService' do
      expect_next_instance_of(::SystemNotes::IncidentsService) do |service|
        expect(service).to receive(:delete_timeline_event).with(author)
      end

      described_class.delete_timeline_event(noteable, author)
    end
  end

  describe '.relate_work_item' do
    let(:work_item) { double('work_item', issue_type: :task) }
    let(:noteable) { double }

    before do
      allow(noteable).to receive(:project).and_return(double)
    end

    it 'calls IssuableService' do
      expect_next_instance_of(::SystemNotes::IssuablesService) do |service|
        expect(service).to receive(:hierarchy_changed).with(work_item, 'relate')
      end

      described_class.relate_work_item(noteable, work_item, double)
    end
  end

  describe '.unrelate_wotk_item' do
    let(:work_item) { double('work_item', issue_type: :task) }
    let(:noteable) { double }

    before do
      allow(noteable).to receive(:project).and_return(double)
    end

    it 'calls IssuableService' do
      expect_next_instance_of(::SystemNotes::IssuablesService) do |service|
        expect(service).to receive(:hierarchy_changed).with(work_item, 'unrelate')
      end

      described_class.unrelate_work_item(noteable, work_item, double)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class BulkPushEventPayloadService
  def initialize(event, push_data)
    @event = event
    @push_data = push_data
  end

  def execute
    @event.build_push_event_payload(
      action: @push_data[:action],
      commit_count: 0,
      ref_count: @push_data[:ref_count],
      ref_type: @push_data[:ref_type]
    )

    @event.push_event_payload.tap(&:save!)
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe BulkPushEventPayloadService, feature_category: :source_code_management do
  let(:event) { create(:push_event) }

  let(:push_data) do
    {
      action: :created,
      ref_count: 4,
      ref_type: :branch
    }
  end

  subject { described_class.new(event, push_data) }

  it 'creates a PushEventPayload' do
    push_event_payload = subject.execute

    expect(push_event_payload).to be_persisted
    expect(push_event_payload.action).to eq(push_data[:action].to_s)
    expect(push_event_payload.commit_count).to eq(0)
    expect(push_event_payload.ref_count).to eq(push_data[:ref_count])
    expect(push_event_payload.ref_type).to eq(push_data[:ref_type].to_s)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# TodoService class
#
# Used for creating/updating todos after certain user actions
#
# Ex.
#   TodoService.new.new_issue(issue, current_user)
#
class TodoService
  include Gitlab::Utils::UsageData

  # When create an issue we should:
  #
  #  * create a todo for assignee if issue is assigned
  #  * create a todo for each mentioned user on issue
  #
  def new_issue(issue, current_user)
    new_issuable(issue, current_user)
  end

  # When update an issue we should:
  #
  #  * mark all pending todos related to the issue for the current user as done
  #
  def update_issue(issue, current_user, skip_users = [])
    update_issuable(issue, current_user, skip_users)
  end

  # When close an issue we should:
  #
  #  * mark all pending todos related to the target for the current user as done
  #
  def close_issue(issue, current_user)
    resolve_todos_for_target(issue, current_user)
  end

  # When we destroy a todo target we should:
  #
  #  * refresh the todos count cache for all users with todos on the target
  #
  # This needs to yield back to the caller to destroy the target, because it
  # collects the todo users before the todos themselves are deleted, then
  # updates the todo counts for those users.
  #
  def destroy_target(target)
    todo_user_ids = target.todos.distinct_user_ids

    yield target

    Users::UpdateTodoCountCacheService.new(todo_user_ids).execute if todo_user_ids.present?
  end

  # When we reassign an assignable object (issuable, alert) we should:
  #
  #  * create a pending todo for new assignee if object is assigned
  #
  def reassigned_assignable(issuable, current_user, old_assignees = [])
    create_assignment_todo(issuable, current_user, old_assignees)
  end

  # When we reassign an reviewable object (merge request) we should:
  #
  #  * create a pending todo for new reviewer if object is assigned
  #
  def reassigned_reviewable(issuable, current_user, old_reviewers = [])
    create_reviewer_todo(issuable, current_user, old_reviewers)
  end

  # When create a merge request we should:
  #
  #  * creates a pending todo for assignee if merge request is assigned
  #  * create a todo for each mentioned user on merge request
  #
  def new_merge_request(merge_request, current_user)
    new_issuable(merge_request, current_user)
  end

  # When update a merge request we should:
  #
  #  * create a todo for each mentioned user on merge request
  #
  def update_merge_request(merge_request, current_user, skip_users = [])
    update_issuable(merge_request, current_user, skip_users)
  end

  # When close a merge request we should:
  #
  #  * mark all pending todos related to the target for the current user as done
  #
  def close_merge_request(merge_request, current_user)
    resolve_todos_for_target(merge_request, current_user)
  end

  # When merge a merge request we should:
  #
  #  * mark all pending todos related to the target for the current user as done
  #
  def merge_merge_request(merge_request, current_user)
    resolve_todos_for_target(merge_request, current_user)
  end

  # When a build fails on the HEAD of a merge request we should:
  #
  #  * create a todo for each merge participant
  #
  def merge_request_build_failed(merge_request)
    merge_request.merge_participants.each do |user|
      create_build_failed_todo(merge_request, user)
    end
  end

  # When a new commit is pushed to a merge request we should:
  #
  #  * mark all pending todos related to the merge request for that user as done
  #
  def merge_request_push(merge_request, current_user)
    resolve_todos_for_target(merge_request, current_user)
  end

  # When a build is retried to a merge request we should:
  #
  #  * mark all pending todos related to the merge request as done for each merge participant
  #
  def merge_request_build_retried(merge_request)
    merge_request.merge_participants.each do |user|
      resolve_todos_for_target(merge_request, user)
    end
  end

  # When a merge request could not be merged due to its unmergeable state we should:
  #
  #  * create a todo for each merge participant
  #
  def merge_request_became_unmergeable(merge_request)
    merge_request.merge_participants.each do |user|
      create_unmergeable_todo(merge_request, user)
    end
  end

  # When create a note we should:
  #
  #  * mark all pending todos related to the noteable for the note author as done
  #  * create a todo for each mentioned user on note
  #
  def new_note(note, current_user)
    handle_note(note, current_user)
  end

  # When update a note we should:
  #
  #  * mark all pending todos related to the noteable for the current user as done
  #  * create a todo for each new user mentioned on note
  #
  def update_note(note, current_user, skip_users = [])
    handle_note(note, current_user, skip_users)
  end

  # When an emoji is awarded we should:
  #
  #  * mark all pending todos related to the awardable for the current user as done
  #
  def new_award_emoji(awardable, current_user)
    resolve_todos_for_target(awardable, current_user)
  end

  # When user marks a target as todo
  def mark_todo(target, current_user)
    project = target.project
    attributes = attributes_for_todo(project, target, current_user, Todo::MARKED)
    create_todos(current_user, attributes, target_namespace(target), project)
  end

  def todo_exist?(issuable, current_user)
    TodosFinder.new(current_user).any_for_target?(issuable, :pending)
  end

  # Resolves all todos related to target for the current_user
  def resolve_todos_for_target(target, current_user)
    attributes = attributes_for_target(target)

    resolve_todos(pending_todos([current_user], attributes), current_user)
  end

  # Resolves all todos related to target for all users
  def resolve_todos_with_attributes_for_target(target, attributes, resolution: :done, resolved_by_action: :system_done)
    target_attributes = { target_id: target.id, target_type: target.class.polymorphic_name }
    attributes.merge!(target_attributes)
    attributes[:preload_user_association] = true

    todos = PendingTodosFinder.new(attributes).execute
    users = todos.map(&:user)
    todos_ids = todos.batch_update(state: resolution, resolved_by_action: resolved_by_action)
    users.each(&:update_todos_count_cache)
    todos_ids
  end

  def resolve_todos(todos, current_user, resolution: :done, resolved_by_action: :system_done)
    todos_ids = todos.batch_update(state: resolution, resolved_by_action: resolved_by_action)

    current_user.update_todos_count_cache

    todos_ids
  end

  def resolve_todo(todo, current_user, resolution: :done, resolved_by_action: :system_done)
    return if todo.done?

    todo.update(state: resolution, resolved_by_action: resolved_by_action)

    current_user.update_todos_count_cache
  end

  def resolve_access_request_todos(member)
    return if member.nil?

    # Group or Project
    target = member.source

    todos_params = {
      state: :pending,
      author_id: member.user_id,
      action: ::Todo::MEMBER_ACCESS_REQUESTED,
      type: target.class.polymorphic_name
    }

    resolve_todos_with_attributes_for_target(target, todos_params)
  end

  def restore_todos(todos, current_user)
    todos_ids = todos.batch_update(state: :pending)

    current_user.update_todos_count_cache

    todos_ids
  end

  def restore_todo(todo, current_user)
    return if todo.pending?

    todo.update(state: :pending)

    current_user.update_todos_count_cache
  end

  def create_request_review_todo(target, author, reviewers)
    project = target.project
    attributes = attributes_for_todo(project, target, author, Todo::REVIEW_REQUESTED)
    create_todos(reviewers, attributes, project.namespace, project)
  end

  def create_member_access_request_todos(member)
    source = member.source
    attributes = attributes_for_access_request_todos(source, member.user, Todo::MEMBER_ACCESS_REQUESTED)

    approvers = source.access_request_approvers_to_be_notified.map(&:user)
    return true if approvers.empty?

    if source.instance_of? Project
      project = source
      namespace = project.namespace
    else
      project = nil
      namespace = source
    end

    create_todos(approvers, attributes, namespace, project)
  end

  private

  def create_todos(users, attributes, namespace, project)
    users = Array(users)

    return if users.empty?

    users_single_todos, users_multiple_todos = users.partition { |u| Feature.disabled?(:multiple_todos, u) }
    excluded_user_ids = []

    if users_single_todos.present?
      excluded_user_ids += pending_todos(
        users_single_todos,
        attributes.slice(:project_id, :target_id, :target_type, :commit_id, :discussion)
      ).distinct_user_ids
    end

    if users_multiple_todos.present? && !Todo::ACTIONS_MULTIPLE_ALLOWED.include?(attributes.fetch(:action))
      excluded_user_ids += pending_todos(
        users_multiple_todos,
        attributes.slice(:project_id, :target_id, :target_type, :commit_id, :discussion, :action)
      ).distinct_user_ids
    end

    users.reject! { |user| excluded_user_ids.include?(user.id) }

    todos = users.map do |user|
      issue_type = attributes.delete(:issue_type)
      track_todo_creation(user, issue_type, namespace, project)

      Todo.create(attributes.merge(user_id: user.id))
    end

    Users::UpdateTodoCountCacheService.new(users.map(&:id)).execute

    todos
  end

  def new_issuable(issuable, author)
    create_assignment_todo(issuable, author)
    create_reviewer_todo(issuable, author) if issuable.allows_reviewers?
    create_mention_todos(issuable.project, issuable, author)
  end

  def update_issuable(issuable, author, skip_users = [])
    # Skip toggling a task list item in a description
    return if toggling_tasks?(issuable)

    create_mention_todos(issuable.project, issuable, author, nil, skip_users)
  end

  def toggling_tasks?(issuable)
    issuable.previous_changes.include?('description') &&
      issuable.tasks? && issuable.updated_tasks.any?
  end

  def handle_note(note, author, skip_users = [])
    return unless note.can_create_todo?

    project = note.project
    target = note.noteable

    resolve_todos_for_target(target, author)
    create_mention_todos(project, target, author, note, skip_users)
  end

  def create_assignment_todo(target, author, old_assignees = [])
    if target.assignees.any?
      project = target.project
      assignees = target.assignees - old_assignees
      attributes = attributes_for_todo(project, target, author, Todo::ASSIGNED)
      create_todos(assignees, attributes, target_namespace(target), project)
    end
  end

  def create_reviewer_todo(target, author, old_reviewers = [])
    if target.reviewers.any?
      reviewers = target.reviewers - old_reviewers
      create_request_review_todo(target, author, reviewers)
    end
  end

  def create_mention_todos(parent, target, author, note = nil, skip_users = [])
    # Create Todos for directly addressed users
    directly_addressed_users = filter_directly_addressed_users(parent, note || target, author, skip_users)
    attributes = attributes_for_todo(parent, target, author, Todo::DIRECTLY_ADDRESSED, note)
    create_todos(directly_addressed_users, attributes, parent&.namespace, parent)

    # Create Todos for mentioned users
    mentioned_users = filter_mentioned_users(parent, note || target, author, skip_users + directly_addressed_users)
    attributes = attributes_for_todo(parent, target, author, Todo::MENTIONED, note)
    create_todos(mentioned_users, attributes, parent&.namespace, parent)
  end

  def create_build_failed_todo(merge_request, todo_author)
    project = merge_request.project
    attributes = attributes_for_todo(project, merge_request, todo_author, Todo::BUILD_FAILED)
    create_todos(todo_author, attributes, project.namespace, project)
  end

  def create_unmergeable_todo(merge_request, todo_author)
    project = merge_request.project
    attributes = attributes_for_todo(project, merge_request, todo_author, Todo::UNMERGEABLE)
    create_todos(todo_author, attributes, project.namespace, project)
  end

  def attributes_for_target(target)
    attributes = {
      project_id: target&.project&.id,
      target_id: target.id,
      target_type: target.class.try(:polymorphic_name) || target.class.name,
      commit_id: nil
    }

    case target
    when Commit
      attributes.merge!(target_id: nil, commit_id: target.id)
    when Issue
      attributes[:issue_type] = target.issue_type
      attributes[:group] = target.namespace if target.project.blank?
    when Discussion
      attributes.merge!(target_type: nil, target_id: nil, discussion: target)
    end

    attributes
  end

  def attributes_for_todo(project, target, author, action, note = nil)
    attributes_for_target(target).merge!(
      project_id: project&.id,
      author_id: author.id,
      action: action,
      note: note
    )
  end

  def filter_todo_users(users, parent, target)
    reject_users_without_access(users, parent, target).uniq
  end

  def filter_mentioned_users(parent, target, author, skip_users = [])
    mentioned_users = target.mentioned_users(author) - skip_users
    filter_todo_users(mentioned_users, parent, target)
  end

  def filter_directly_addressed_users(parent, target, author, skip_users = [])
    directly_addressed_users = target.directly_addressed_users(author) - skip_users
    filter_todo_users(directly_addressed_users, parent, target)
  end

  def reject_users_without_access(users, parent, target)
    if target.respond_to?(:to_ability_name)
      select_users(users, :""read_#{target.to_ability_name}"", target)
    else
      select_users(users, :read_project, parent)
    end
  end

  def select_users(users, ability, subject)
    users.select do |user|
      user.can?(ability.to_sym, subject)
    end
  end

  def pending_todos(users, criteria = {})
    PendingTodosFinder.new(criteria.merge(users: users)).execute
  end

  def track_todo_creation(user, issue_type, namespace, project)
    return unless issue_type == 'incident'

    event = ""incident_management_incident_todo""
    track_usage_event(event, user.id)

    Gitlab::Tracking.event(
      self.class.to_s,
      event,
      project: project,
      namespace: namespace,
      user: user,
      label: 'redis_hll_counters.incident_management.incident_management_total_unique_counts_monthly',
      context: [Gitlab::Tracking::ServicePingContext.new(data_source: :redis_hll, event: event).to_context]
    )
  end

  def attributes_for_access_request_todos(source, author, action, note = nil)
    attributes = {
      target_id: source.id,
      target_type: source.class.polymorphic_name,
      author_id: author.id,
      action: action,
      note: note
    }

    if source.instance_of? Project
      attributes[:project_id] = source.id
      attributes[:group_id] = source.group.id if source.group.present?
    else
      attributes[:group_id] = source.id
    end

    attributes
  end

  def target_namespace(target)
    project = target.project
    project&.namespace || target.try(:namespace)
  end
end

TodoService.prepend_mod_with('TodoService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe TodoService, feature_category: :team_planning do
  include AfterNextHelpers

  let_it_be(:group) { create(:group) }
  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:author) { create(:user) }
  let_it_be(:assignee) { create(:user) }
  let_it_be(:non_member) { create(:user) }
  let_it_be(:member) { create(:user) }
  let_it_be(:guest) { create(:user) }
  let_it_be(:admin) { create(:admin) }
  let_it_be(:john_doe) { create(:user) }
  let_it_be(:skipped) { create(:user) }

  let(:skip_users) { [skipped] }
  let(:mentions) { 'FYI: ' + [author, assignee, john_doe, member, guest, non_member, admin, skipped].map(&:to_reference).join(' ') }
  let(:directly_addressed) { [author, assignee, john_doe, member, guest, non_member, admin, skipped].map(&:to_reference).join(' ') }
  let(:directly_addressed_and_mentioned) { member.to_reference + "", what do you think? cc: "" + [guest, admin, skipped].map(&:to_reference).join(' ') }
  let(:service) { described_class.new }

  before_all do
    project.add_guest(guest)
    project.add_developer(author)
    project.add_developer(assignee)
    project.add_developer(member)
    project.add_developer(john_doe)
    project.add_developer(skipped)
  end

  shared_examples 'reassigned target' do
    let(:additional_todo_attributes) { {} }

    it 'creates a pending todo for new assignee' do
      target_unassigned.assignees = [john_doe]
      service.send(described_method, target_unassigned, author)

      should_create_todo(
        user: john_doe,
        target: target_unassigned,
        action: Todo::ASSIGNED,
        **additional_todo_attributes
      )
    end

    it 'does not create a todo if unassigned' do
      target_assigned.assignees = []

      should_not_create_any_todo { service.send(described_method, target_assigned, author) }
    end

    it 'creates a todo if new assignee is the current user' do
      target_assigned.assignees = [john_doe]
      service.send(described_method, target_assigned, john_doe)

      should_create_todo(
        user: john_doe,
        target: target_assigned,
        author: john_doe,
        action: Todo::ASSIGNED,
        **additional_todo_attributes
      )
    end

    it 'does not create a todo for guests' do
      service.send(described_method, target_assigned, author)
      should_not_create_todo(user: guest, target: target_assigned, action: Todo::MENTIONED)
    end

    it 'does not create a directly addressed todo for guests' do
      service.send(described_method, addressed_target_assigned, author)

      should_not_create_todo(user: guest, target: addressed_target_assigned, action: Todo::DIRECTLY_ADDRESSED)
    end

    it 'does not create a todo if already assigned' do
      should_not_create_any_todo { service.send(described_method, target_assigned, author, [john_doe]) }
    end
  end

  shared_examples 'reassigned reviewable target' do
    context 'with no existing reviewers' do
      let(:assigned_reviewers) { [] }

      it 'creates a pending todo for new reviewer' do
        target.reviewers = [john_doe]
        service.send(described_method, target, author)

        should_create_todo(user: john_doe, target: target, action: Todo::REVIEW_REQUESTED)
      end
    end

    context 'with an existing reviewer' do
      let(:assigned_reviewers) { [john_doe] }

      it 'does not create a todo if unassigned' do
        target.reviewers = []

        should_not_create_any_todo { service.send(described_method, target, author) }
      end

      it 'creates a todo if new reviewer is the current user' do
        target.reviewers = [john_doe]
        service.send(described_method, target, john_doe)

        should_create_todo(user: john_doe, target: target, author: john_doe, action: Todo::REVIEW_REQUESTED)
      end

      it 'does not create a todo if already assigned' do
        should_not_create_any_todo { service.send(described_method, target, author, [john_doe]) }
      end
    end
  end

  describe 'Issues' do
    let(:issue) { create(:issue, project: project, author: author, description: ""- [ ] Task 1\n- [ ] Task 2 #{mentions}"") }
    let(:addressed_issue) { create(:issue, project: project, author: author, description: ""#{directly_addressed}\n- [ ] Task 1\n- [ ] Task 2"") }
    let(:assigned_issue) { create(:issue, project: project, assignees: [john_doe]) }
    let(:unassigned_issue) { create(:issue, project: project, assignees: []) }
    let(:confidential_issue) { create(:issue, :confidential, project: project, author: author, assignees: [assignee], description: mentions) }
    let(:addressed_confident_issue) { create(:issue, :confidential, project: project, author: author, assignees: [assignee], description: directly_addressed) }

    describe '#new_issue' do
      it 'creates a todo if assigned' do
        service.new_issue(assigned_issue, author)

        should_create_todo(user: john_doe, target: assigned_issue, action: Todo::ASSIGNED)
      end

      it 'does not create a todo if unassigned' do
        should_not_create_any_todo { service.new_issue(unassigned_issue, author) }
      end

      it 'creates a todo if assignee is the current user' do
        unassigned_issue.assignees = [john_doe]
        service.new_issue(unassigned_issue, john_doe)

        should_create_todo(user: john_doe, target: unassigned_issue, author: john_doe, action: Todo::ASSIGNED)
      end

      it 'creates a todo for each valid mentioned user' do
        service.new_issue(issue, author)

        should_create_todo(user: member, target: issue, action: Todo::MENTIONED)
        should_create_todo(user: guest, target: issue, action: Todo::MENTIONED)
        should_create_todo(user: author, target: issue, action: Todo::MENTIONED)
        should_create_todo(user: john_doe, target: issue, action: Todo::MENTIONED)
        should_not_create_todo(user: non_member, target: issue, action: Todo::MENTIONED)
      end

      it 'creates a directly addressed todo for each valid addressed user' do
        service.new_issue(addressed_issue, author)

        should_create_todo(user: member, target: addressed_issue, action: Todo::DIRECTLY_ADDRESSED)
        should_create_todo(user: guest, target: addressed_issue, action: Todo::DIRECTLY_ADDRESSED)
        should_create_todo(user: author, target: addressed_issue, action: Todo::DIRECTLY_ADDRESSED)
        should_create_todo(user: john_doe, target: addressed_issue, action: Todo::DIRECTLY_ADDRESSED)
        should_not_create_todo(user: non_member, target: addressed_issue, action: Todo::DIRECTLY_ADDRESSED)
      end

      it 'creates correct todos for each valid user based on the type of mention' do
        issue.update!(description: directly_addressed_and_mentioned)

        service.new_issue(issue, author)

        should_create_todo(user: member, target: issue, action: Todo::DIRECTLY_ADDRESSED)
        should_not_create_todo(user: admin, target: issue, action: Todo::MENTIONED)
        should_create_todo(user: guest, target: issue, action: Todo::MENTIONED)
      end

      it 'does not create todo if user can not see the issue when issue is confidential' do
        service.new_issue(confidential_issue, john_doe)

        should_create_todo(user: assignee, target: confidential_issue, author: john_doe, action: Todo::ASSIGNED)
        should_create_todo(user: author, target: confidential_issue, author: john_doe, action: Todo::MENTIONED)
        should_create_todo(user: member, target: confidential_issue, author: john_doe, action: Todo::MENTIONED)
        should_not_create_todo(user: admin, target: confidential_issue, author: john_doe, action: Todo::MENTIONED)
        should_not_create_todo(user: guest, target: confidential_issue, author: john_doe, action: Todo::MENTIONED)
        should_create_todo(user: john_doe, target: confidential_issue, author: john_doe, action: Todo::MENTIONED)
      end

      it 'does not create directly addressed todo if user cannot see the issue when issue is confidential' do
        service.new_issue(addressed_confident_issue, john_doe)

        should_create_todo(user: assignee, target: addressed_confident_issue, author: john_doe, action: Todo::ASSIGNED)
        should_create_todo(user: author, target: addressed_confident_issue, author: john_doe, action: Todo::DIRECTLY_ADDRESSED)
        should_create_todo(user: member, target: addressed_confident_issue, author: john_doe, action: Todo::DIRECTLY_ADDRESSED)
        should_not_create_todo(user: admin, target: addressed_confident_issue, author: john_doe, action: Todo::DIRECTLY_ADDRESSED)
        should_not_create_todo(user: guest, target: addressed_confident_issue, author: john_doe, action: Todo::DIRECTLY_ADDRESSED)
        should_create_todo(user: john_doe, target: addressed_confident_issue, author: john_doe, action: Todo::DIRECTLY_ADDRESSED)
      end

      context 'when a private group is mentioned' do
        let(:group)   { create(:group, :private) }
        let(:project) { create(:project, :private, group: group) }
        let(:issue)   { create(:issue, author: author, project: project, description: group.to_reference) }

        before do
          group.add_owner(author)
          group.add_member(member, Gitlab::Access::DEVELOPER)
          group.add_member(john_doe, Gitlab::Access::DEVELOPER)

          service.new_issue(issue, author)
        end

        it 'creates a todo for group members' do
          should_create_todo(user: member, target: issue)
          should_create_todo(user: john_doe, target: issue)
        end
      end

      context 'issue is an incident' do
        let(:issue) { create(:incident, project: project, assignees: [john_doe], author: author) }

        subject do
          service.new_issue(issue, author)
          should_create_todo(user: john_doe, target: issue, action: Todo::ASSIGNED)
        end

        it_behaves_like 'an incident management tracked event', :incident_management_incident_todo do
          let(:current_user) { john_doe }
        end

        it_behaves_like 'Snowplow event tracking with RedisHLL context' do
          let(:namespace) { project.namespace }
          let(:category) { described_class.to_s }
          let(:action) { 'incident_management_incident_todo' }
          let(:label) { 'redis_hll_counters.incident_management.incident_management_total_unique_counts_monthly' }
          let(:user) { john_doe }
        end
      end
    end

    describe '#update_issue' do
      it 'creates a todo for each valid mentioned user not included in skip_users' do
        service.update_issue(issue, author, skip_users)

        should_create_todo(user: member, target: issue, action: Todo::MENTIONED)
        should_create_todo(user: guest, target: issue, action: Todo::MENTIONED)
        should_create_todo(user: john_doe, target: issue, action: Todo::MENTIONED)
        should_create_todo(user: author, target: issue, action: Todo::MENTIONED)
        should_not_create_todo(user: non_member, target: issue, action: Todo::MENTIONED)
        should_not_create_todo(user: skipped, target: issue, action: Todo::MENTIONED)
      end

      it 'creates a todo for each valid user not included in skip_users based on the type of mention' do
        issue.update!(description: directly_addressed_and_mentioned)

        service.update_issue(issue, author, skip_users)

        should_create_todo(user: member, target: issue, action: Todo::DIRECTLY_ADDRESSED)
        should_create_todo(user: guest, target: issue, action: Todo::MENTIONED)
        should_not_create_todo(user: admin, target: issue, action: Todo::MENTIONED)
        should_not_create_todo(user: skipped, target: issue)
      end

      it 'creates a directly addressed todo for each valid addressed user not included in skip_users' do
        service.update_issue(addressed_issue, author, skip_users)

        should_create_todo(user: member, target: addressed_issue, action: Todo::DIRECTLY_ADDRESSED)
        should_create_todo(user: guest, target: addressed_issue, action: Todo::DIRECTLY_ADDRESSED)
        should_create_todo(user: john_doe, target: addressed_issue, action: Todo::DIRECTLY_ADDRESSED)
        should_create_todo(user: author, target: addressed_issue, action: Todo::DIRECTLY_ADDRESSED)
        should_not_create_todo(user: non_member, target: addressed_issue, action: Todo::DIRECTLY_ADDRESSED)
        should_not_create_todo(user: skipped, target: addressed_issue, action: Todo::DIRECTLY_ADDRESSED)
      end

      it 'does not create a todo if user was already mentioned and todo is pending' do
        stub_feature_flags(multiple_todos: false)

        create(:todo, :mentioned, user: member, project: project, target: issue, author: author)

        expect { service.update_issue(issue, author, skip_users) }.not_to change(member.todos, :count)
      end

      it 'does not create a todo if user was already mentioned and todo is done' do
        create(:todo, :mentioned, :done, user: skipped, project: project, target: issue, author: author)

        expect { service.update_issue(issue, author, skip_users) }.not_to change(skipped.todos, :count)
      end

      it 'does not create a directly addressed todo if user was already mentioned or addressed and todo is pending' do
        stub_feature_flags(multiple_todos: false)

        create(:todo, :directly_addressed, user: member, project: project, target: addressed_issue, author: author)

        expect { service.update_issue(addressed_issue, author, skip_users) }.not_to change(member.todos, :count)
      end

      it 'does not create a directly addressed todo if user was already mentioned or addressed and todo is done' do
        create(:todo, :directly_addressed, :done, user: skipped, project: project, target: addressed_issue, author: author)

        expect { service.update_issue(addressed_issue, author, skip_users) }.not_to change(skipped.todos, :count)
      end

      it 'does not create todo if user can not see the issue when issue is confidential' do
        service.update_issue(confidential_issue, john_doe)

        should_create_todo(user: author, target: confidential_issue, author: john_doe, action: Todo::MENTIONED)
        should_create_todo(user: assignee, target: confidential_issue, author: john_doe, action: Todo::MENTIONED)
        should_create_todo(user: member, target: confidential_issue, author: john_doe, action: Todo::MENTIONED)
        should_not_create_todo(user: admin, target: confidential_issue, author: john_doe, action: Todo::MENTIONED)
        should_not_create_todo(user: guest, target: confidential_issue, author: john_doe, action: Todo::MENTIONED)
        should_create_todo(user: john_doe, target: confidential_issue, author: john_doe, action: Todo::MENTIONED)
      end

      it 'does not create a directly addressed todo if user can not see the issue when issue is confidential' do
        service.update_issue(addressed_confident_issue, john_doe)

        should_create_todo(user: author, target: addressed_confident_issue, author: john_doe, action: Todo::DIRECTLY_ADDRESSED)
        should_create_todo(user: assignee, target: addressed_confident_issue, author: john_doe, action: Todo::DIRECTLY_ADDRESSED)
        should_create_todo(user: member, target: addressed_confident_issue, author: john_doe, action: Todo::DIRECTLY_ADDRESSED)
        should_not_create_todo(user: admin, target: addressed_confident_issue, author: john_doe, action: Todo::DIRECTLY_ADDRESSED)
        should_not_create_todo(user: guest, target: addressed_confident_issue, author: john_doe, action: Todo::DIRECTLY_ADDRESSED)
        should_create_todo(user: john_doe, target: addressed_confident_issue, author: john_doe, action: Todo::DIRECTLY_ADDRESSED)
      end

      context 'issues with a task list' do
        it 'does not create todo when tasks are marked as completed' do
          issue.update!(description: ""- [x] Task 1\n- [X] Task 2 #{mentions}"")

          service.update_issue(issue, author)

          should_not_create_todo(user: admin, target: issue, action: Todo::MENTIONED)
          should_not_create_todo(user: assignee, target: issue, action: Todo::MENTIONED)
          should_not_create_todo(user: author, target: issue, action: Todo::MENTIONED)
          should_not_create_todo(user: john_doe, target: issue, action: Todo::MENTIONED)
          should_not_create_todo(user: member, target: issue, action: Todo::MENTIONED)
          should_not_create_todo(user: non_member, target: issue, action: Todo::MENTIONED)
        end

        it 'does not create directly addressed todo when tasks are marked as completed' do
          addressed_issue.update!(description: ""#{directly_addressed}\n- [x] Task 1\n- [x] Task 2\n"")

          service.update_issue(addressed_issue, author)

          should_not_create_todo(user: admin, target: addressed_issue, action: Todo::DIRECTLY_ADDRESSED)
          should_not_create_todo(user: assignee, target: addressed_issue, action: Todo::DIRECTLY_ADDRESSED)
          should_not_create_todo(user: author, target: addressed_issue, action: Todo::DIRECTLY_ADDRESSED)
          should_not_create_todo(user: john_doe, target: addressed_issue, action: Todo::DIRECTLY_ADDRESSED)
          should_not_create_todo(user: member, target: addressed_issue, action: Todo::DIRECTLY_ADDRESSED)
          should_not_create_todo(user: non_member, target: addressed_issue, action: Todo::DIRECTLY_ADDRESSED)
        end

        it 'does not raise an error when description not change' do
          issue.update!(title: 'Sample')

          expect { service.update_issue(issue, author) }.not_to raise_error
        end
      end
    end

    describe '#close_issue' do
      it 'marks related pending todos to the target for the user as done' do
        first_todo = create(:todo, :assigned, user: john_doe, project: project, target: issue, author: author)
        second_todo = create(:todo, :assigned, user: john_doe, project: project, target: issue, author: author)

        service.close_issue(issue, john_doe)

        expect(first_todo.reload).to be_done
        expect(second_todo.reload).to be_done
      end
    end

    describe '#destroy_target' do
      it 'refreshes the todos count cache for users with todos on the target' do
        create(:todo, state: :pending, target: issue, user: author, author: author, project: issue.project)
        create(:todo, state: :done, target: issue, user: assignee, author: assignee, project: issue.project)

        expect_next(Users::UpdateTodoCountCacheService, [author.id, assignee.id]).to receive(:execute)

        service.destroy_target(issue) { issue.destroy! }
      end

      it 'yields the target to the caller' do
        expect { |b| service.destroy_target(issue, &b) }
          .to yield_with_args(issue)
      end
    end

    describe '#resolve_todos_for_target' do
      it 'marks related pending todos to the target for the user as done' do
        first_todo = create(:todo, :assigned, user: john_doe, project: project, target: issue, author: author)
        second_todo = create(:todo, :assigned, user: john_doe, project: project, target: issue, author: author)

        service.resolve_todos_for_target(issue, john_doe)

        expect(first_todo.reload).to be_done
        expect(second_todo.reload).to be_done
      end

      describe 'cached counts' do
        it 'updates when todos change' do
          create(:todo, :assigned, user: john_doe, project: project, target: issue, author: author)

          expect(john_doe.todos_done_count).to eq(0)
          expect(john_doe.todos_pending_count).to eq(1)
          expect(john_doe).to receive(:update_todos_count_cache).and_call_original

          service.resolve_todos_for_target(issue, john_doe)

          expect(john_doe.todos_done_count).to eq(1)
          expect(john_doe.todos_pending_count).to eq(0)
        end
      end
    end

    describe '#resolve_todos_with_attributes_for_target' do
      it 'marks related pending todos to the target for all the users as done' do
        first_todo = create(:todo, :assigned, user: member, project: project, target: issue, author: author)
        second_todo = create(:todo, :review_requested, user: john_doe, project: project, target: issue, author: author)
        another_todo = create(:todo, :assigned, user: john_doe, project: project, target: project, author: author)

        service.resolve_todos_with_attributes_for_target(issue, {})

        expect(first_todo.reload).to be_done
        expect(second_todo.reload).to be_done
        expect(another_todo.reload).to be_pending
      end

      it 'marks related only filtered pending todos to the target for all the users as done' do
        first_todo = create(:todo, :assigned, user: member, project: project, target: issue, author: author)
        second_todo = create(:todo, :review_requested, user: john_doe, project: project, target: issue, author: author)
        another_todo = create(:todo, :assigned, user: john_doe, project: project, target: project, author: author)

        service.resolve_todos_with_attributes_for_target(issue, { action: Todo::ASSIGNED })

        expect(first_todo.reload).to be_done
        expect(second_todo.reload).to be_pending
        expect(another_todo.reload).to be_pending
      end

      it 'fetches the pending todos with users preloaded' do
        expect(PendingTodosFinder).to receive(:new)
          .with(a_hash_including(preload_user_association: true)).and_call_original

        service.resolve_todos_with_attributes_for_target(issue, { action: Todo::ASSIGNED })
      end
    end

    describe '#new_note' do
      let!(:first_todo) { create(:todo, :assigned, user: john_doe, project: project, target: issue, author: author) }
      let!(:second_todo) { create(:todo, :assigned, user: john_doe, project: project, target: issue, author: author) }
      let(:confidential_issue) { create(:issue, :confidential, project: project, author: author, assignees: [assignee]) }
      let(:note) { create(:note, project: project, noteable: issue, author: john_doe, note: mentions) }
      let(:confidential_note) { create(:note, :confidential, project: project, noteable: issue, author: john_doe, note: mentions) }
      let(:addressed_note) { create(:note, project: project, noteable: issue, author: john_doe, note: directly_addressed) }
      let(:note_on_commit) { create(:note_on_commit, project: project, author: john_doe, note: mentions) }
      let(:addressed_note_on_commit) { create(:note_on_commit, project: project, author: john_doe, note: directly_addressed) }
      let(:note_on_confidential_issue) { create(:note_on_issue, noteable: confidential_issue, project: project, note: mentions) }
      let(:addressed_note_on_confidential_issue) { create(:note_on_issue, noteable: confidential_issue, project: project, note: directly_addressed) }
      let(:note_on_project_snippet) { create(:note_on_project_snippet, project: project, author: john_doe, note: mentions) }
      let(:system_note) { create(:system_note, project: project, noteable: issue) }

      it 'mark related pending todos to the noteable for the note author as done' do
        first_todo = create(:todo, :assigned, user: john_doe, project: project, target: issue, author: author)
        second_todo = create(:todo, :assigned, user: john_doe, project: project, target: issue, author: author)

        service.new_note(note, john_doe)

        expect(first_todo.reload).to be_done
        expect(second_todo.reload).to be_done
      end

      it 'does not mark related pending todos it is a system note' do
        service.new_note(system_note, john_doe)

        expect(first_todo.reload).to be_pending
        expect(second_todo.reload).to be_pending
      end

      it 'creates a todo for each valid mentioned user' do
        service.new_note(note, john_doe)

        should_create_todo(user: member, target: issue, author: john_doe, action: Todo::MENTIONED, note: note)
        should_create_todo(user: guest, target: issue, author: john_doe, action: Todo::MENTIONED, note: note)
        should_create_todo(user: author, target: issue, author: john_doe, action: Todo::MENTIONED, note: note)
        should_create_todo(user: john_doe, target: issue, author: john_doe, action: Todo::MENTIONED, note: note)
        should_not_create_todo(user: non_member, target: issue, author: john_doe, action: Todo::MENTIONED, note: note)
      end

      it 'creates a todo for each valid user based on the type of mention' do
        note.update!(note: directly_addressed_and_mentioned)

        service.new_note(note, john_doe)

        should_create_todo(user: member, target: issue, author: john_doe, action: Todo::DIRECTLY_ADDRESSED, note: note)
        should_not_create_todo(user: admin, target: issue, author: john_doe, action: Todo::MENTIONED, note: note)
        should_create_todo(user: guest, target: issue, author: john_doe, action: Todo::MENTIONED, note: note)
      end

      it 'creates a directly addressed todo for each valid addressed user' do
        service.new_note(addressed_note, john_doe)

        should_create_todo(user: member, target: issue, author: john_doe, action: Todo::DIRECTLY_ADDRESSED, note: addressed_note)
        should_create_todo(user: guest, target: issue, author: john_doe, action: Todo::DIRECTLY_ADDRESSED, note: addressed_note)
        should_create_todo(user: author, target: issue, author: john_doe, action: Todo::DIRECTLY_ADDRESSED, note: addressed_note)
        should_create_todo(user: john_doe, target: issue, author: john_doe, action: Todo::DIRECTLY_ADDRESSED, note: addressed_note)
        should_not_create_todo(user: non_member, target: issue, author: john_doe, action: Todo::DIRECTLY_ADDRESSED, note: addressed_note)
      end

      it 'does not create todo if user can not see the issue when leaving a note on a confidential issue' do
        service.new_note(note_on_confidential_issue, john_doe)

        should_create_todo(user: author, target: confidential_issue, author: john_doe, action: Todo::MENTIONED, note: note_on_confidential_issue)
        should_create_todo(user: assignee, target: confidential_issue, author: john_doe, action: Todo::MENTIONED, note: note_on_confidential_issue)
        should_create_todo(user: member, target: confidential_issue, author: john_doe, action: Todo::MENTIONED, note: note_on_confidential_issue)
        should_not_create_todo(user: admin, target: confidential_issue, author: john_doe, action: Todo::MENTIONED, note: note_on_confidential_issue)
        should_not_create_todo(user: guest, target: confidential_issue, author: john_doe, action: Todo::MENTIONED, note: note_on_confidential_issue)
        should_create_todo(user: john_doe, target: confidential_issue, author: john_doe, action: Todo::MENTIONED, note: note_on_confidential_issue)
      end

      it 'does not create a directly addressed todo if user can not see the issue when leaving a note on a confidential issue' do
        service.new_note(addressed_note_on_confidential_issue, john_doe)

        should_create_todo(user: author, target: confidential_issue, author: john_doe, action: Todo::DIRECTLY_ADDRESSED, note: addressed_note_on_confidential_issue)
        should_create_todo(user: assignee, target: confidential_issue, author: john_doe, action: Todo::DIRECTLY_ADDRESSED, note: addressed_note_on_confidential_issue)
        should_create_todo(user: member, target: confidential_issue, author: john_doe, action: Todo::DIRECTLY_ADDRESSED, note: addressed_note_on_confidential_issue)
        should_not_create_todo(user: admin, target: confidential_issue, author: john_doe, action: Todo::DIRECTLY_ADDRESSED, note: addressed_note_on_confidential_issue)
        should_not_create_todo(user: guest, target: confidential_issue, author: john_doe, action: Todo::DIRECTLY_ADDRESSED, note: addressed_note_on_confidential_issue)
        should_create_todo(user: john_doe, target: confidential_issue, author: john_doe, action: Todo::DIRECTLY_ADDRESSED, note: addressed_note_on_confidential_issue)
      end

      it 'does not create todo if user can not read confidential note' do
        service.new_note(confidential_note, john_doe)

        should_not_create_todo(user: non_member, target: issue, author: john_doe, action: Todo::MENTIONED, note: confidential_note)
        should_not_create_todo(user: guest, target: issue, author: john_doe, action: Todo::MENTIONED, note: confidential_note)
        should_create_todo(user: member, target: issue, author: john_doe, action: Todo::MENTIONED, note: confidential_note)
        should_create_todo(user: author, target: issue, author: john_doe, action: Todo::MENTIONED, note: confidential_note)
        should_create_todo(user: assignee, target: issue, author: john_doe, action: Todo::MENTIONED, note: confidential_note)
        should_create_todo(user: john_doe, target: issue, author: john_doe, action: Todo::MENTIONED, note: confidential_note)
      end

      context 'commits' do
        let(:base_commit_todo_attrs) { { target_id: nil, target_type: 'Commit', author: john_doe } }

        context 'leaving a note on a commit in a public project' do
          let(:project) { create(:project, :repository, :public) }

          it 'creates a todo for each valid mentioned user' do
            expected_todo = base_commit_todo_attrs.merge(
              action: Todo::MENTIONED,
              note: note_on_commit,
              commit_id: note_on_commit.commit_id
            )

            service.new_note(note_on_commit, john_doe)

            should_create_todo(expected_todo.merge(user: member))
            should_create_todo(expected_todo.merge(user: author))
            should_create_todo(expected_todo.merge(user: john_doe))
            should_create_todo(expected_todo.merge(user: guest))
            should_create_todo(expected_todo.merge(user: non_member))
          end

          it 'creates a directly addressed todo for each valid mentioned user' do
            expected_todo = base_commit_todo_attrs.merge(
              action: Todo::DIRECTLY_ADDRESSED,
              note: addressed_note_on_commit,
              commit_id: addressed_note_on_commit.commit_id
            )

            service.new_note(addressed_note_on_commit, john_doe)

            should_create_todo(expected_todo.merge(user: member))
            should_create_todo(expected_todo.merge(user: author))
            should_create_todo(expected_todo.merge(user: john_doe))
            should_create_todo(expected_todo.merge(user: guest))
            should_create_todo(expected_todo.merge(user: non_member))
          end
        end

        context 'leaving a note on a commit in a public project with private code' do
          let_it_be(:project) { create(:project, :repository, :public, :repository_private) }

          before_all do
            project.add_guest(guest)
            project.add_developer(author)
            project.add_developer(assignee)
            project.add_developer(member)
            project.add_developer(john_doe)
            project.add_developer(skipped)
          end

          it 'creates a todo for each valid mentioned user' do
            expected_todo = base_commit_todo_attrs.merge(
              action: Todo::MENTIONED,
              note: note_on_commit,
              commit_id: note_on_commit.commit_id
            )

            service.new_note(note_on_commit, john_doe)

            should_create_todo(expected_todo.merge(user: member))
            should_create_todo(expected_todo.merge(user: author))
            should_create_todo(expected_todo.merge(user: john_doe))
            should_create_todo(expected_todo.merge(user: guest))
            should_not_create_todo(expected_todo.merge(user: non_member))
          end

          it 'creates a directly addressed todo for each valid mentioned user' do
            expected_todo = base_commit_todo_attrs.merge(
              action: Todo::DIRECTLY_ADDRESSED,
              note: addressed_note_on_commit,
              commit_id: addressed_note_on_commit.commit_id
            )

            service.new_note(addressed_note_on_commit, john_doe)

            should_create_todo(expected_todo.merge(user: member))
            should_create_todo(expected_todo.merge(user: author))
            should_create_todo(expected_todo.merge(user: john_doe))
            should_create_todo(expected_todo.merge(user: guest))
            should_not_create_todo(expected_todo.merge(user: non_member))
          end
        end

        context 'leaving a note on a commit in a private project' do
          let_it_be(:project) { create(:project, :repository, :private) }

          before_all do
            project.add_guest(guest)
            project.add_developer(author)
            project.add_developer(assignee)
            project.add_developer(member)
            project.add_developer(john_doe)
            project.add_developer(skipped)
          end

          it 'creates a todo for each valid mentioned user' do
            expected_todo = base_commit_todo_attrs.merge(
              action: Todo::MENTIONED,
              note: note_on_commit,
              commit_id: note_on_commit.commit_id
            )

            service.new_note(note_on_commit, john_doe)

            should_create_todo(expected_todo.merge(user: member))
            should_create_todo(expected_todo.merge(user: author))
            should_create_todo(expected_todo.merge(user: john_doe))
            should_not_create_todo(expected_todo.merge(user: guest))
            should_not_create_todo(expected_todo.merge(user: non_member))
          end

          it 'creates a directly addressed todo for each valid mentioned user' do
            expected_todo = base_commit_todo_attrs.merge(
              action: Todo::DIRECTLY_ADDRESSED,
              note: addressed_note_on_commit,
              commit_id: addressed_note_on_commit.commit_id
            )

            service.new_note(addressed_note_on_commit, john_doe)

            should_create_todo(expected_todo.merge(user: member))
            should_create_todo(expected_todo.merge(user: author))
            should_create_todo(expected_todo.merge(user: john_doe))
            should_not_create_todo(expected_todo.merge(user: guest))
            should_not_create_todo(expected_todo.merge(user: non_member))
          end
        end
      end

      it 'does not create todo when leaving a note on snippet' do
        should_not_create_any_todo { service.new_note(note_on_project_snippet, john_doe) }
      end
    end

    describe '#mark_todo' do
      it 'creates a todo from an issue' do
        service.mark_todo(unassigned_issue, author)

        should_create_todo(user: author, target: unassigned_issue, action: Todo::MARKED)
      end

      context 'when issue belongs to a group' do
        it 'creates a todo from an issue' do
          group_issue = create(:issue, :group_level, namespace: group)
          service.mark_todo(group_issue, group_issue.author)

          should_create_todo(
            user: group_issue.author,
            author: group_issue.author,
            target: group_issue,
            action: Todo::MARKED,
            project: nil,
            group: group
          )
        end
      end
    end

    describe '#todo_exists?' do
      it 'returns false when no todo exist for the given issuable' do
        expect(service.todo_exist?(unassigned_issue, author)).to be_falsy
      end

      it 'returns true when a todo exist for the given issuable' do
        service.mark_todo(unassigned_issue, author)

        expect(service.todo_exist?(unassigned_issue, author)).to be_truthy
      end
    end

    context 'when multiple_todos are enabled' do
      before do
        stub_feature_flags(multiple_todos: true)
      end

      it 'creates a MENTIONED todo even if user already has a pending MENTIONED todo' do
        create(:todo, :mentioned, user: member, project: project, target: issue, author: author)

        expect { service.update_issue(issue, author) }.to change(member.todos, :count)
      end

      it 'creates a DIRECTLY_ADDRESSED todo even if user already has a pending DIRECTLY_ADDRESSED todo' do
        create(:todo, :directly_addressed, user: member, project: project, target: issue, author: author)

        issue.update!(description: ""#{member.to_reference}, what do you think?"")

        expect { service.update_issue(issue, author) }.to change(member.todos, :count)
      end

      it 'creates an ASSIGNED todo even if user already has a pending MARKED todo' do
        create(:todo, :marked, user: john_doe, project: project, target: assigned_issue, author: author)

        expect { service.reassigned_assignable(assigned_issue, author) }.to change(john_doe.todos, :count)
      end

      it 'does not create an ASSIGNED todo if user already has an ASSIGNED todo' do
        create(:todo, :assigned, user: john_doe, project: project, target: assigned_issue, author: author)

        expect { service.reassigned_assignable(assigned_issue, author) }.not_to change(john_doe.todos, :count)
      end

      it 'creates multiple todos if a user is assigned and mentioned in a new issue' do
        assigned_issue.description = mentions
        service.new_issue(assigned_issue, author)

        should_create_todo(user: john_doe, target: assigned_issue, action: Todo::ASSIGNED)
        should_create_todo(user: john_doe, target: assigned_issue, action: Todo::MENTIONED)
      end
    end
  end

  describe 'Work Items' do
    let_it_be(:work_item) { create(:work_item, :task, project: project, author: author) }

    describe '#mark_todo' do
      it 'creates a todo from a work item' do
        service.mark_todo(work_item, author)

        should_create_todo(user: author, target: work_item, action: Todo::MARKED)
      end

      context 'when work item belongs to a group' do
        it 'creates a todo from a work item' do
          group_work_item = create(:work_item, :group_level, namespace: group)
          service.mark_todo(group_work_item, group_work_item.author)

          should_create_todo(
            user: group_work_item.author,
            author: group_work_item.author,
            target: group_work_item,
            action: Todo::MARKED,
            project: nil,
            group: group
          )
        end
      end
    end

    describe '#todo_exists?' do
      it 'returns false when no todo exist for the given work_item' do
        expect(service.todo_exist?(work_item, author)).to be_falsy
      end

      it 'returns true when a todo exist for the given work_item' do
        service.mark_todo(work_item, author)

        expect(service.todo_exist?(work_item, author)).to be_truthy
      end
    end

    describe '#resolve_todos_for_target' do
      it 'marks related pending todos to the target for the user as done' do
        first_todo = create(:todo, :assigned, user: john_doe, project: project, target: work_item, author: author)
        second_todo = create(:todo, :assigned, user: john_doe, project: project, target: work_item, author: author)

        service.resolve_todos_for_target(work_item, john_doe)

        expect(first_todo.reload).to be_done
        expect(second_todo.reload).to be_done
      end

      describe 'cached counts' do
        it 'updates when todos change' do
          create(:todo, :assigned, user: john_doe, project: project, target: work_item, author: author)

          expect(john_doe.todos_done_count).to eq(0)
          expect(john_doe.todos_pending_count).to eq(1)
          expect(john_doe).to receive(:update_todos_count_cache).and_call_original

          service.resolve_todos_for_target(work_item, john_doe)

          expect(john_doe.todos_done_count).to eq(1)
          expect(john_doe.todos_pending_count).to eq(0)
        end
      end
    end
  end

  describe '#reassigned_assignable' do
    let(:described_method) { :reassigned_assignable }

    context 'assignable is a merge request' do
      it_behaves_like 'reassigned target' do
        let(:target_assigned) { create(:merge_request, source_project: project, author: author, assignees: [john_doe], description: ""- [ ] Task 1\n- [ ] Task 2 #{mentions}"") }
        let(:addressed_target_assigned) { create(:merge_request, source_project: project, author: author, assignees: [john_doe], description: ""#{directly_addressed}\n- [ ] Task 1\n- [ ] Task 2"") }
        let(:target_unassigned) { create(:merge_request, source_project: project, author: author, assignees: []) }
      end
    end

    context 'assignable is a project level issue' do
      it_behaves_like 'reassigned target' do
        let(:target_assigned) { create(:issue, project: project, author: author, assignees: [john_doe], description: ""- [ ] Task 1\n- [ ] Task 2 #{mentions}"") }
        let(:addressed_target_assigned) { create(:issue, project: project, author: author, assignees: [john_doe], description: ""#{directly_addressed}\n- [ ] Task 1\n- [ ] Task 2"") }
        let(:target_unassigned) { create(:issue, project: project, author: author, assignees: []) }
      end
    end

    context 'assignable is a project level work_item' do
      it_behaves_like 'reassigned target' do
        let(:target_assigned) { create(:work_item, project: project, author: author, assignees: [john_doe], description: ""- [ ] Task 1\n- [ ] Task 2 #{mentions}"") }
        let(:addressed_target_assigned) { create(:work_item, project: project, author: author, assignees: [john_doe], description: ""#{directly_addressed}\n- [ ] Task 1\n- [ ] Task 2"") }
        let(:target_unassigned) { create(:work_item, project: project, author: author, assignees: []) }
      end
    end

    context 'assignable is a group level issue' do
      it_behaves_like 'reassigned target' do
        let(:additional_todo_attributes) { { project: nil, group: group } }
        let(:target_assigned) { create(:issue, :group_level, namespace: group, author: author, assignees: [john_doe], description: ""- [ ] Task 1\n- [ ] Task 2 #{mentions}"") }
        let(:addressed_target_assigned) { create(:issue, :group_level, namespace: group, author: author, assignees: [john_doe], description: ""#{directly_addressed}\n- [ ] Task 1\n- [ ] Task 2"") }
        let(:target_unassigned) { create(:issue, :group_level, namespace: group, author: author, assignees: []) }
      end
    end

    context 'assignable is a group level work item' do
      it_behaves_like 'reassigned target' do
        let(:additional_todo_attributes) { { project: nil, group: group } }
        let(:target_assigned) { create(:work_item, :group_level, namespace: group, author: author, assignees: [john_doe], description: ""- [ ] Task 1\n- [ ] Task 2 #{mentions}"") }
        let(:addressed_target_assigned) { create(:work_item, :group_level, namespace: group, author: author, assignees: [john_doe], description: ""#{directly_addressed}\n- [ ] Task 1\n- [ ] Task 2"") }
        let(:target_unassigned) { create(:work_item, :group_level, namespace: group, author: author, assignees: []) }
      end
    end

    context 'assignable is an alert' do
      it_behaves_like 'reassigned target' do
        let(:target_assigned) { create(:alert_management_alert, project: project, assignees: [john_doe]) }
        let(:addressed_target_assigned) { create(:alert_management_alert, project: project, assignees: [john_doe]) }
        let(:target_unassigned) { create(:alert_management_alert, project: project, assignees: []) }
      end
    end
  end

  describe '#reassigned_reviewable' do
    let(:described_method) { :reassigned_reviewable }

    context 'reviewable is a merge request' do
      it_behaves_like 'reassigned reviewable target' do
        let(:assigned_reviewers) { [] }
        let(:target) { create(:merge_request, source_project: project, author: author, reviewers: assigned_reviewers) }
      end
    end
  end

  describe 'Merge Requests' do
    let(:mentioned_mr) { create(:merge_request, source_project: project, author: author, description: ""- [ ] Task 1\n- [ ] Task 2 #{mentions}"") }
    let(:addressed_mr) { create(:merge_request, source_project: project, author: author, description: ""#{directly_addressed}\n- [ ] Task 1\n- [ ] Task 2"") }
    let(:assigned_mr) { create(:merge_request, source_project: project, author: author, assignees: [john_doe]) }
    let(:unassigned_mr) { create(:merge_request, source_project: project, author: author, assignees: []) }

    describe '#new_merge_request' do
      it 'creates a pending todo if assigned' do
        service.new_merge_request(assigned_mr, author)

        should_create_todo(user: john_doe, target: assigned_mr, action: Todo::ASSIGNED)
      end

      it 'does not create a todo if unassigned' do
        should_not_create_any_todo { service.new_merge_request(unassigned_mr, author) }
      end

      it 'creates a todo if assignee is the current user' do
        service.new_merge_request(assigned_mr, john_doe)

        should_create_todo(user: john_doe, target: assigned_mr, author: john_doe, action: Todo::ASSIGNED)
      end

      it 'creates a todo for each valid mentioned user' do
        service.new_merge_request(mentioned_mr, author)

        should_create_todo(user: member, target: mentioned_mr, action: Todo::MENTIONED)
        should_not_create_todo(user: guest, target: mentioned_mr, action: Todo::MENTIONED)
        should_create_todo(user: author, target: mentioned_mr, action: Todo::MENTIONED)
        should_create_todo(user: john_doe, target: mentioned_mr, action: Todo::MENTIONED)
        should_not_create_todo(user: non_member, target: mentioned_mr, action: Todo::MENTIONED)
      end

      it 'creates a todo for each valid user based on the type of mention' do
        mentioned_mr.update!(description: directly_addressed_and_mentioned)

        service.new_merge_request(mentioned_mr, author)

        should_create_todo(user: member, target: mentioned_mr, action: Todo::DIRECTLY_ADDRESSED)
        should_not_create_todo(user: admin, target: mentioned_mr, action: Todo::MENTIONED)
      end

      it 'creates a directly addressed todo for each valid addressed user' do
        service.new_merge_request(addressed_mr, author)

        should_create_todo(user: member, target: addressed_mr, action: Todo::DIRECTLY_ADDRESSED)
        should_not_create_todo(user: guest, target: addressed_mr, action: Todo::DIRECTLY_ADDRESSED)
        should_create_todo(user: author, target: addressed_mr, action: Todo::DIRECTLY_ADDRESSED)
        should_create_todo(user: john_doe, target: addressed_mr, action: Todo::DIRECTLY_ADDRESSED)
        should_not_create_todo(user: non_member, target: addressed_mr, action: Todo::DIRECTLY_ADDRESSED)
      end
    end

    describe '#update_merge_request' do
      it 'creates a todo for each valid mentioned user not included in skip_users' do
        service.update_merge_request(mentioned_mr, author, skip_users)

        should_create_todo(user: member, target: mentioned_mr, action: Todo::MENTIONED)
        should_not_create_todo(user: guest, target: mentioned_mr, action: Todo::MENTIONED)
        should_create_todo(user: john_doe, target: mentioned_mr, action: Todo::MENTIONED)
        should_create_todo(user: author, target: mentioned_mr, action: Todo::MENTIONED)
        should_not_create_todo(user: non_member, target: mentioned_mr, action: Todo::MENTIONED)
        should_not_create_todo(user: skipped, target: mentioned_mr, action: Todo::MENTIONED)
      end

      it 'creates a todo for each valid user not included in skip_users based on the type of mention' do
        mentioned_mr.update!(description: directly_addressed_and_mentioned)

        service.update_merge_request(mentioned_mr, author, skip_users)

        should_create_todo(user: member, target: mentioned_mr, action: Todo::DIRECTLY_ADDRESSED)
        should_not_create_todo(user: admin, target: mentioned_mr, action: Todo::MENTIONED)
        should_not_create_todo(user: skipped, target: mentioned_mr)
      end

      it 'creates a directly addressed todo for each valid addressed user not included in skip_users' do
        service.update_merge_request(addressed_mr, author, skip_users)

        should_create_todo(user: member, target: addressed_mr, action: Todo::DIRECTLY_ADDRESSED)
        should_not_create_todo(user: guest, target: addressed_mr, action: Todo::DIRECTLY_ADDRESSED)
        should_create_todo(user: john_doe, target: addressed_mr, action: Todo::DIRECTLY_ADDRESSED)
        should_create_todo(user: author, target: addressed_mr, action: Todo::DIRECTLY_ADDRESSED)
        should_not_create_todo(user: non_member, target: addressed_mr, action: Todo::DIRECTLY_ADDRESSED)
        should_not_create_todo(user: skipped, target: addressed_mr, action: Todo::DIRECTLY_ADDRESSED)
      end

      it 'does not create a todo if user was already mentioned and todo is pending' do
        stub_feature_flags(multiple_todos: false)

        create(:todo, :mentioned, user: member, project: project, target: mentioned_mr, author: author)

        expect { service.update_merge_request(mentioned_mr, author) }.not_to change(member.todos, :count)
      end

      it 'does not create a todo if user was already mentioned and todo is done' do
        create(:todo, :mentioned, :done, user: skipped, project: project, target: mentioned_mr, author: author)

        expect { service.update_merge_request(mentioned_mr, author, skip_users) }.not_to change(skipped.todos, :count)
      end

      it 'does not create a directly addressed todo if user was already mentioned or addressed and todo is pending' do
        stub_feature_flags(multiple_todos: false)

        create(:todo, :directly_addressed, user: member, project: project, target: addressed_mr, author: author)

        expect { service.update_merge_request(addressed_mr, author) }.not_to change(member.todos, :count)
      end

      it 'does not create a directly addressed todo if user was already mentioned or addressed and todo is done' do
        create(:todo, :directly_addressed, user: skipped, project: project, target: addressed_mr, author: author)

        expect { service.update_merge_request(addressed_mr, author, skip_users) }.not_to change(skipped.todos, :count)
      end

      context 'with a task list' do
        it 'does not create todo when tasks are marked as completed' do
          mentioned_mr.update!(description: ""- [x] Task 1\n- [X] Task 2 #{mentions}"")

          service.update_merge_request(mentioned_mr, author)

          should_not_create_todo(user: admin, target: mentioned_mr, action: Todo::MENTIONED)
          should_not_create_todo(user: assignee, target: mentioned_mr, action: Todo::MENTIONED)
          should_not_create_todo(user: author, target: mentioned_mr, action: Todo::MENTIONED)
          should_not_create_todo(user: john_doe, target: mentioned_mr, action: Todo::MENTIONED)
          should_not_create_todo(user: member, target: mentioned_mr, action: Todo::MENTIONED)
          should_not_create_todo(user: non_member, target: mentioned_mr, action: Todo::MENTIONED)
          should_not_create_todo(user: guest, target: mentioned_mr, action: Todo::MENTIONED)
        end

        it 'does not create directly addressed todo when tasks are marked as completed' do
          addressed_mr.update!(description: ""#{directly_addressed}\n- [x] Task 1\n- [X] Task 2"")

          service.update_merge_request(addressed_mr, author)

          should_not_create_todo(user: admin, target: addressed_mr, action: Todo::DIRECTLY_ADDRESSED)
          should_not_create_todo(user: assignee, target: addressed_mr, action: Todo::DIRECTLY_ADDRESSED)
          should_not_create_todo(user: author, target: addressed_mr, action: Todo::DIRECTLY_ADDRESSED)
          should_not_create_todo(user: john_doe, target: addressed_mr, action: Todo::DIRECTLY_ADDRESSED)
          should_not_create_todo(user: member, target: addressed_mr, action: Todo::DIRECTLY_ADDRESSED)
          should_not_create_todo(user: non_member, target: addressed_mr, action: Todo::DIRECTLY_ADDRESSED)
          should_not_create_todo(user: guest, target: addressed_mr, action: Todo::DIRECTLY_ADDRESSED)
        end

        it 'does not raise an error when description not change' do
          mentioned_mr.update!(title: 'Sample')

          expect { service.update_merge_request(mentioned_mr, author) }.not_to raise_error
        end
      end
    end

    describe '#close_merge_request' do
      it 'marks related pending todos to the target for the user as done' do
        first_todo = create(:todo, :assigned, user: john_doe, project: project, target: mentioned_mr, author: author)
        second_todo = create(:todo, :assigned, user: john_doe, project: project, target: mentioned_mr, author: author)
        service.close_merge_request(mentioned_mr, john_doe)

        expect(first_todo.reload).to be_done
        expect(second_todo.reload).to be_done
      end
    end

    describe '#merge_merge_request' do
      it 'marks related pending todos to the target for the user as done' do
        first_todo = create(:todo, :assigned, user: john_doe, project: project, target: mentioned_mr, author: author)
        second_todo = create(:todo, :assigned, user: john_doe, project: project, target: mentioned_mr, author: author)
        service.merge_merge_request(mentioned_mr, john_doe)

        expect(first_todo.reload).to be_done
        expect(second_todo.reload).to be_done
      end

      it 'does not create todo for guests' do
        service.merge_merge_request(mentioned_mr, john_doe)
        should_not_create_todo(user: guest, target: mentioned_mr, action: Todo::MENTIONED)
      end

      it 'does not create directly addressed todo for guests' do
        service.merge_merge_request(addressed_mr, john_doe)
        should_not_create_todo(user: guest, target: addressed_mr, action: Todo::DIRECTLY_ADDRESSED)
      end
    end

    describe '#new_award_emoji' do
      it 'marks related pending todos to the target for the user as done' do
        todo = create(:todo, user: john_doe, project: project, target: mentioned_mr, author: author)
        service.new_award_emoji(mentioned_mr, john_doe)

        expect(todo.reload).to be_done
      end
    end

    describe '#merge_request_build_failed' do
      let(:merge_participants) { [unassigned_mr.author, admin] }

      before do
        allow(unassigned_mr).to receive(:merge_participants).and_return(merge_participants)
      end

      it 'creates a pending todo for each merge_participant' do
        service.merge_request_build_failed(unassigned_mr)

        merge_participants.each do |participant|
          should_create_todo(user: participant, author: participant, target: unassigned_mr, action: Todo::BUILD_FAILED)
        end
      end
    end

    describe '#merge_request_push' do
      it 'marks related pending todos to the target for the user as done' do
        first_todo = create(:todo, :build_failed, user: author, project: project, target: mentioned_mr, author: john_doe)
        second_todo = create(:todo, :build_failed, user: john_doe, project: project, target: mentioned_mr, author: john_doe)
        service.merge_request_push(mentioned_mr, author)

        expect(first_todo.reload).to be_done
        expect(second_todo.reload).not_to be_done
      end
    end

    describe '#merge_request_became_unmergeable' do
      let(:merge_participants) { [admin, create(:user)] }

      before do
        allow(unassigned_mr).to receive(:merge_participants).and_return(merge_participants)
      end

      it 'creates a pending todo for each merge_participant' do
        unassigned_mr.update!(merge_when_pipeline_succeeds: true, merge_user: admin)
        service.merge_request_became_unmergeable(unassigned_mr)

        merge_participants.each do |participant|
          should_create_todo(user: participant, author: participant, target: unassigned_mr, action: Todo::UNMERGEABLE)
        end
      end
    end

    describe '#mark_todo' do
      it 'creates a todo from a merge request' do
        service.mark_todo(unassigned_mr, author)

        should_create_todo(user: author, target: unassigned_mr, action: Todo::MARKED)
      end
    end

    describe '#new_note' do
      let_it_be(:project) { create(:project, :repository) }

      before_all do
        project.add_guest(guest)
        project.add_developer(author)
        project.add_developer(assignee)
        project.add_developer(member)
        project.add_developer(john_doe)
        project.add_developer(skipped)
      end

      let(:mention) { john_doe.to_reference }
      let(:diff_note_on_merge_request) { create(:diff_note_on_merge_request, project: project, noteable: unassigned_mr, author: author, note: ""Hey #{mention}"") }
      let(:addressed_diff_note_on_merge_request) { create(:diff_note_on_merge_request, project: project, noteable: unassigned_mr, author: author, note: ""#{mention}, hey!"") }
      let(:legacy_diff_note_on_merge_request) { create(:legacy_diff_note_on_merge_request, project: project, noteable: unassigned_mr, author: author, note: ""Hey #{mention}"") }

      it 'creates a todo for mentioned user on new diff note' do
        service.new_note(diff_note_on_merge_request, author)

        should_create_todo(user: john_doe, target: unassigned_mr, author: author, action: Todo::MENTIONED, note: diff_note_on_merge_request)
      end

      it 'creates a directly addressed todo for addressed user on new diff note' do
        service.new_note(addressed_diff_note_on_merge_request, author)

        should_create_todo(user: john_doe, target: unassigned_mr, author: author, action: Todo::DIRECTLY_ADDRESSED, note: addressed_diff_note_on_merge_request)
      end

      it 'creates a todo for mentioned user on legacy diff note' do
        service.new_note(legacy_diff_note_on_merge_request, author)

        should_create_todo(user: john_doe, target: unassigned_mr, author: author, action: Todo::MENTIONED, note: legacy_diff_note_on_merge_request)
      end

      it 'does not create todo for guests' do
        note_on_merge_request = create :note_on_merge_request, project: project, noteable: mentioned_mr, note: mentions
        service.new_note(note_on_merge_request, author)

        should_not_create_todo(user: guest, target: mentioned_mr, action: Todo::MENTIONED)
      end
    end
  end

  describe 'Designs' do
    include DesignManagementTestHelpers

    let(:issue) { create(:issue, project: project) }
    let(:design) { create(:design, issue: issue) }

    before do
      enable_design_management

      project.add_guest(author)
      project.add_developer(john_doe)
    end

    let(:note) do
      build(
        :diff_note_on_design,
        noteable: design,
        author: author,
        note: ""Hey #{john_doe.to_reference}""
      )
    end

    it 'creates a todo for mentioned user on new diff note' do
      service.new_note(note, author)

      should_create_todo(
        user: john_doe,
        target: design,
        action: Todo::MENTIONED,
        note: note
      )
    end
  end

  describe '#update_note' do
    let_it_be(:noteable) { create(:issue, project: project) }

    let(:note) { create(:note, project: project, note: mentions, noteable: noteable) }
    let(:addressed_note) { create(:note, project: project, note: directly_addressed.to_s, noteable: noteable) }

    it 'creates a todo for each valid mentioned user not included in skip_users' do
      service.update_note(note, author, skip_users)

      should_create_todo(user: member, target: noteable, action: Todo::MENTIONED)
      should_create_todo(user: guest, target: noteable, action: Todo::MENTIONED)
      should_create_todo(user: john_doe, target: noteable, action: Todo::MENTIONED)
      should_create_todo(user: author, target: noteable, action: Todo::MENTIONED)
      should_not_create_todo(user: non_member, target: noteable, action: Todo::MENTIONED)
      should_not_create_todo(user: skipped, target: noteable, action: Todo::MENTIONED)
    end

    it 'creates a todo for each valid user not included in skip_users based on the type of mention' do
      note.update!(note: directly_addressed_and_mentioned)

      service.update_note(note, author, skip_users)

      should_create_todo(user: member, target: noteable, action: Todo::DIRECTLY_ADDRESSED)
      should_create_todo(user: guest, target: noteable, action: Todo::MENTIONED)
      should_not_create_todo(user: admin, target: noteable, action: Todo::MENTIONED)
      should_not_create_todo(user: skipped, target: noteable)
    end

    it 'creates a directly addressed todo for each valid addressed user not included in skip_users' do
      service.update_note(addressed_note, author, skip_users)

      should_create_todo(user: member, target: noteable, action: Todo::DIRECTLY_ADDRESSED)
      should_create_todo(user: guest, target: noteable, action: Todo::DIRECTLY_ADDRESSED)
      should_create_todo(user: john_doe, target: noteable, action: Todo::DIRECTLY_ADDRESSED)
      should_create_todo(user: author, target: noteable, action: Todo::DIRECTLY_ADDRESSED)
      should_not_create_todo(user: non_member, target: noteable, action: Todo::DIRECTLY_ADDRESSED)
      should_not_create_todo(user: skipped, target: noteable, action: Todo::DIRECTLY_ADDRESSED)
    end

    context 'users already have pending todos and the multiple_todos feature is off' do
      before do
        stub_feature_flags(multiple_todos: false)
      end

      let_it_be(:pending_todo_for_member) { create(:todo, :mentioned, user: member, project: project, target: noteable) }
      let_it_be(:pending_todo_for_guest) { create(:todo, :mentioned, user: guest, project: project, target: noteable) }
      let_it_be(:pending_todo_for_admin) { create(:todo, :mentioned, user: admin, project: project, target: noteable) }
      let_it_be(:note_mentioning_1_user) do
        create(:note, project: project, note: ""FYI #{member.to_reference}"", noteable: noteable)
      end

      let_it_be(:note_mentioning_3_users) do
        create(:note, project: project, note: 'FYI: ' + [member, guest, admin].map(&:to_reference).join(' '), noteable: noteable)
      end

      it 'does not create a todo if user was already mentioned and todo is pending' do
        expect { service.update_note(note_mentioning_1_user, author, skip_users) }.not_to change(member.todos, :count)
      end

      it 'does not create N+1 queries for pending todos' do
        # Excluding queries for user permissions because those do execute N+1 queries
        allow_any_instance_of(User).to receive(:can?).and_return(true)

        control_count = ActiveRecord::QueryRecorder.new { service.update_note(note_mentioning_1_user, author, skip_users) }.count

        expect { service.update_note(note_mentioning_3_users, author, skip_users) }.not_to exceed_query_limit(control_count)
      end
    end

    it 'does not create a todo if user was already mentioned and todo is done' do
      create(:todo, :mentioned, :done, user: skipped, project: project, target: noteable, author: author)

      expect { service.update_note(note, author, skip_users) }.not_to change(skipped.todos, :count)
    end

    it 'does not create a directly addressed todo if user was already mentioned or addressed and todo is pending' do
      stub_feature_flags(multiple_todos: false)

      create(:todo, :directly_addressed, user: member, project: project, target: noteable, author: author)

      expect { service.update_note(addressed_note, author, skip_users) }.not_to change(member.todos, :count)
    end

    it 'does not create a directly addressed todo if user was already mentioned or addressed and todo is done' do
      create(:todo, :directly_addressed, :done, user: skipped, project: project, target: noteable, author: author)

      expect { service.update_note(addressed_note, author, skip_users) }.not_to change(skipped.todos, :count)
    end
  end

  it 'updates cached counts when a todo is created' do
    issue = create(:issue, project: project, assignees: [john_doe], author: author)

    expect_next(Users::UpdateTodoCountCacheService, [john_doe.id]).to receive(:execute)

    service.new_issue(issue, author)
  end

  shared_examples 'updating todos state' do |state, new_state, new_resolved_by = nil|
    let!(:first_todo) { create(:todo, state, user: john_doe) }
    let!(:second_todo) { create(:todo, state, user: john_doe) }
    let(:collection) { Todo.all }

    it 'updates related todos for the user with the new_state' do
      method_call

      expect(collection.all? { |todo| todo.reload.state?(new_state) }).to be_truthy
    end

    if new_resolved_by
      it 'updates resolution mechanism' do
        method_call

        expect(collection.all? { |todo| todo.reload.resolved_by_action == new_resolved_by }).to be_truthy
      end
    end

    it 'returns the updated ids' do
      expect(method_call).to match_array([first_todo.id, second_todo.id])
    end

    describe 'cached counts' do
      it 'updates when todos change' do
        expect(john_doe.todos.where(state: new_state).count).to eq(0)
        expect(john_doe.todos.where(state: state).count).to eq(2)
        expect(john_doe).to receive(:update_todos_count_cache).and_call_original

        method_call

        expect(john_doe.todos.where(state: new_state).count).to eq(2)
        expect(john_doe.todos.where(state: state).count).to eq(0)
      end
    end
  end

  describe '#resolve_todos' do
    it_behaves_like 'updating todos state', :pending, :done, 'mark_done' do
      subject(:method_call) do
        service.resolve_todos(collection, john_doe, resolution: :done, resolved_by_action: :mark_done)
      end
    end
  end

  describe '#restore_todos' do
    it_behaves_like 'updating todos state', :done, :pending do
      subject(:method_call) do
        service.restore_todos(collection, john_doe)
      end
    end
  end

  describe '#resolve_todo' do
    let!(:todo) { create(:todo, :assigned, user: john_doe) }

    it 'marks pending todo as done' do
      expect do
        service.resolve_todo(todo, john_doe)
        todo.reload
      end.to change { todo.done? }.to(true)
    end

    it 'saves resolution mechanism' do
      expect do
        service.resolve_todo(todo, john_doe, resolved_by_action: :mark_done)
        todo.reload
      end.to change { todo.resolved_by_mark_done? }.to(true)
    end

    context 'cached counts' do
      it 'updates when todos change' do
        expect(john_doe.todos_done_count).to eq(0)
        expect(john_doe.todos_pending_count).to eq(1)
        expect(john_doe).to receive(:update_todos_count_cache).and_call_original

        service.resolve_todo(todo, john_doe)

        expect(john_doe.todos_done_count).to eq(1)
        expect(john_doe.todos_pending_count).to eq(0)
      end
    end
  end

  describe '#resolve_access_request_todos' do
    let_it_be(:group) { create(:group, :public) }
    let_it_be(:group_requester) { create(:group_member, :access_request, group: group, user: assignee) }
    let_it_be(:project_requester) { create(:project_member, :access_request, project: project, user: non_member) }
    let_it_be(:another_pending_todo) { create(:todo, state: :pending, user: john_doe) }
    # access request by another user
    let_it_be(:another_group_todo) do
      create(:todo, state: :pending, target: group, action: Todo::MEMBER_ACCESS_REQUESTED)
    end

    let_it_be(:another_project_todo) do
      create(:todo, state: :pending, target: project, action: Todo::MEMBER_ACCESS_REQUESTED)
    end

    it 'marks the todos for group access request handlers as done' do
      access_request_todos = [member, john_doe].map do |group_user|
        create(:todo,
          user: group_user,
          state: :pending,
          action: Todo::MEMBER_ACCESS_REQUESTED,
          author: group_requester.user,
          target: group
        )
      end

      expect do
        service.resolve_access_request_todos(group_requester)
      end.to change {
        Todo.pending.where(target: group).for_author(group_requester.user)
          .for_action(Todo::MEMBER_ACCESS_REQUESTED).count
      }.from(2).to(0)

      expect(access_request_todos.each(&:reload)).to all be_done
      expect(another_pending_todo.reload).not_to be_done
      expect(another_group_todo.reload).not_to be_done
    end

    it 'marks the todos for project access request handlers as done' do
      # The project has 1 owner already. Adding another owner here
      project.add_member(john_doe, Gitlab::Access::OWNER)

      access_request_todo = create(:todo,
        user: john_doe,
        state: :pending,
        action: Todo::MEMBER_ACCESS_REQUESTED,
        author: project_requester.user,
        target: project
      )

      expect do
        service.resolve_access_request_todos(project_requester)
      end.to change {
        Todo.pending.where(target: project).for_author(project_requester.user)
          .for_action(Todo::MEMBER_ACCESS_REQUESTED).count
      }.from(2).to(0) # The original owner todo was created with the pending access request

      expect(access_request_todo.reload).to be_done
      expect(another_pending_todo.reload).to be_pending
      expect(another_project_todo.reload).to be_pending
    end
  end

  describe '#restore_todo' do
    let!(:todo) { create(:todo, :done, user: john_doe) }

    it 'marks resolved todo as pending' do
      expect do
        service.restore_todo(todo, john_doe)
        todo.reload
      end.to change { todo.pending? }.to(true)
    end

    context 'cached counts' do
      it 'updates when todos change' do
        expect(john_doe.todos_done_count).to eq(1)
        expect(john_doe.todos_pending_count).to eq(0)
        expect(john_doe).to receive(:update_todos_count_cache).and_call_original

        service.restore_todo(todo, john_doe)

        expect(john_doe.todos_done_count).to eq(0)
        expect(john_doe.todos_pending_count).to eq(1)
      end
    end
  end

  describe '#create_request_review_todo' do
    let(:target) { create(:merge_request, author: author, source_project: project) }
    let(:reviewer) { create(:user) }

    it 'creates a todo for reviewer' do
      service.create_request_review_todo(target, author, reviewer)

      should_create_todo(user: reviewer, target: target, action: Todo::REVIEW_REQUESTED)
    end
  end

  describe '#create_member_access_request_todos' do
    let_it_be(:group) { create(:group, :public) }
    let_it_be(:project) { create(:project, :public, group: group) }

    shared_examples 'member access request is raised' do
      context 'when the source has more than 10 owners' do
        it 'creates todos for 10 recently active source owners' do
          users = create_list(:user, 12, :with_sign_ins)
          users.each do |user|
            source.add_owner(user)
          end
          ten_most_recently_active_source_owners = users.sort_by(&:last_sign_in_at).last(10)
          excluded_source_owners = users - ten_most_recently_active_source_owners

          service.create_member_access_request_todos(requester1)

          ten_most_recently_active_source_owners.each do |owner|
            expect(Todo.where(user: owner, target: source, action: Todo::MEMBER_ACCESS_REQUESTED, author: requester1.user).count).to eq 1
          end

          excluded_source_owners.each do |owner|
            expect(Todo.where(user: owner, target: source, action: Todo::MEMBER_ACCESS_REQUESTED, author: requester1.user).count).to eq 0
          end
        end
      end

      context 'when total owners are less than 10' do
        it 'creates todos for all source owners' do
          users = create_list(:user, 4, :with_sign_ins)
          users.map do |user|
            source.add_owner(user)
          end

          service.create_member_access_request_todos(requester1)

          users.each do |owner|
            expect(Todo.where(user: owner, target: source, action: Todo::MEMBER_ACCESS_REQUESTED, author: requester1.user).count).to eq 1
          end
        end
      end

      context 'when multiple access requests are raised' do
        it 'creates todos for 10 recently active source owners for multiple requests' do
          users = create_list(:user, 12, :with_sign_ins)
          users.each do |user|
            source.add_owner(user)
          end
          ten_most_recently_active_source_owners = users.sort_by(&:last_sign_in_at).last(10)
          excluded_source_owners = users - ten_most_recently_active_source_owners

          service.create_member_access_request_todos(requester1)
          service.create_member_access_request_todos(requester2)

          ten_most_recently_active_source_owners.each do |owner|
            expect(Todo.where(user: owner, target: source, action: Todo::MEMBER_ACCESS_REQUESTED, author: requester1.user).count).to eq 1
            expect(Todo.where(user: owner, target: source, action: Todo::MEMBER_ACCESS_REQUESTED, author: requester2.user).count).to eq 1
          end

          excluded_source_owners.each do |owner|
            expect(Todo.where(user: owner, target: source, action: Todo::MEMBER_ACCESS_REQUESTED, author: requester1.user).count).to eq 0
            expect(Todo.where(user: owner, target: source, action: Todo::MEMBER_ACCESS_REQUESTED, author: requester2.user).count).to eq 0
          end
        end
      end
    end

    context 'when request is raised for group' do
      it_behaves_like 'member access request is raised' do
        let_it_be(:source) { create(:group, :public) }
        let_it_be(:requester1) { create(:group_member, :access_request, group: source, user: assignee) }
        let_it_be(:requester2) { create(:group_member, :access_request, group: source, user: non_member) }
      end
    end

    context 'when request is raised for project' do
      it_behaves_like 'member access request is raised' do
        let_it_be(:source) { create(:project, :public) }
        let_it_be(:requester1) { create(:project_member, :access_request, project: source, user: assignee) }
        let_it_be(:requester2) { create(:project_member, :access_request, project: source, user: non_member) }
      end
    end
  end

  def should_create_todo(attributes = {})
    attributes.reverse_merge!(
      project: project,
      author: author,
      state: :pending
    )

    expect(Todo.where(attributes).count).to eq 1
  end

  def should_not_create_todo(attributes = {})
    attributes.reverse_merge!(
      project: project,
      author: author,
      state: :pending
    )

    expect(Todo.where(attributes).count).to eq 0
  end

  def should_not_create_any_todo
    expect { yield }.not_to change(Todo, :count)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Base class for services that count a single resource such as the number of
# issues for a project.
class BaseCountService
  def relation_for_count
    raise(
      NotImplementedError,
      '""relation_for_count"" must be implemented and return an ActiveRecord::Relation'
    )
  end

  def count
    Rails.cache.fetch(cache_key, cache_options) { uncached_count }.to_i
  end

  def count_stored?
    Rails.cache.read(cache_key).present?
  end

  def refresh_cache(&block)
    update_cache_for_key(cache_key, &block)
  end

  def uncached_count
    relation_for_count.count
  end

  def delete_cache
    ::Gitlab::Cache.delete(cache_key)
  end

  def raw?
    false
  end

  def cache_key
    raise NotImplementedError, 'cache_key must be implemented and return a String, Array, or Hash'
  end

  # subclasses can override to add any specific options, such as
  #   super.merge({ expires_in: 5.minutes })
  def cache_options
    { raw: raw? }
  end

  def update_cache_for_key(key, &block)
    Rails.cache.write(key, block ? yield : uncached_count, raw: raw?)
  end
end

BaseCountService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe BaseCountService, :use_clean_rails_memory_store_caching, feature_category: :shared do
  let(:service) { described_class.new }

  describe '#relation_for_count' do
    it 'raises NotImplementedError' do
      expect { service.relation_for_count }.to raise_error(NotImplementedError)
    end
  end

  describe '#count' do
    it 'returns the number of values' do
      expect(service)
        .to receive(:cache_key)
        .and_return('foo')

      expect(service)
        .to receive(:uncached_count)
        .and_return(5)

      expect(service.count).to eq(5)
    end
  end

  describe '#uncached_count' do
    it 'returns the uncached number of values' do
      expect(service)
        .to receive(:relation_for_count)
        .and_return(double(:relation, count: 5))

      expect(service.uncached_count).to eq(5)
    end
  end

  describe '#refresh_cache' do
    it 'refreshes the cache' do
      allow(service)
        .to receive(:cache_key)
        .and_return('foo')

      allow(service)
        .to receive(:uncached_count)
        .and_return(4)

      service.refresh_cache

      expect(Rails.cache.fetch(service.cache_key, raw: service.raw?)).to eq(4)
    end
  end

  describe '#delete_cache' do
    it 'deletes the cache' do
      allow(service)
        .to receive(:cache_key)
        .and_return('foo')

      allow(service)
        .to receive(:uncached_count)
        .and_return(4)

      service.refresh_cache
      service.delete_cache

      expect(Rails.cache.fetch(service.cache_key, raw: service.raw?)).to be_nil
    end
  end

  describe '#raw?' do
    it 'returns false' do
      expect(service.raw?).to eq(false)
    end
  end

  describe '#cache_key' do
    it 'raises NotImplementedError' do
      expect { service.cache_key }.to raise_error(NotImplementedError)
    end
  end

  describe '#cache_options' do
    it 'returns the default in options' do
      expect(service.cache_options).to eq({ raw: false })
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Service class for creating push event payloads as stored in the
# ""push_event_payloads"" table.
#
# Example:
#
#     data = Gitlab::DataBuilder::Push.build(...)
#     event = Event.create(...)
#
#     PushEventPayloadService.new(event, data).execute
class PushEventPayloadService
  # event - The event this push payload belongs to.
  # push_data - A Hash produced by `Gitlab::DataBuilder::Push.build` to use for
  #             building the push payload.
  def initialize(event, push_data)
    @event = event
    @push_data = push_data
  end

  # Creates and returns a new PushEventPayload row.
  #
  # This method will raise upon encountering validation errors.
  #
  # Returns an instance of PushEventPayload.
  def execute
    @event.build_push_event_payload(
      commit_count: commit_count,
      action: action,
      ref_type: ref_type,
      commit_from: commit_from_id,
      commit_to: commit_to_id,
      ref: trimmed_ref,
      commit_title: commit_title,
      event_id: @event.id
    )

    @event.push_event_payload.save!
    @event.push_event_payload
  end

  # Returns the commit title to use.
  #
  # The commit title is limited to the first line and a maximum of 70
  # characters.
  def commit_title
    commit = @push_data.fetch(:commits).last

    return unless commit && commit[:message]

    raw_msg = commit[:message]

    # Find where the first line ends, without turning the entire message into an
    # Array of lines (this is a waste of memory for large commit messages).
    index = raw_msg.index(""\n"")
    message = index ? raw_msg[0..index] : raw_msg

    message.strip.truncate(70)
  end

  def commit_from_id
    if create?
      nil
    else
      revision_before
    end
  end

  def commit_to_id
    if remove?
      nil
    else
      revision_after
    end
  end

  def commit_count
    @push_data.fetch(:total_commits_count)
  end

  def ref
    @push_data.fetch(:ref)
  end

  def revision_before
    @push_data.fetch(:before)
  end

  def revision_after
    @push_data.fetch(:after)
  end

  def trimmed_ref
    Gitlab::Git.ref_name(ref)
  end

  def create?
    Gitlab::Git.blank_ref?(revision_before)
  end

  def remove?
    Gitlab::Git.blank_ref?(revision_after)
  end

  def action
    if create?
      :created
    elsif remove?
      :removed
    else
      :pushed
    end
  end

  def ref_type
    if Gitlab::Git.tag_ref?(ref)
      :tag
    else
      :branch
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe PushEventPayloadService, feature_category: :source_code_management do
  let(:event) { create(:push_event) }

  describe '#execute' do
    let(:push_data) do
      {
        commits: [
          {
            id: '1cf19a015df3523caf0a1f9d40c98a267d6a2fc2',
            message: 'This is a commit'
          }
        ],
        before: '0000000000000000000000000000000000000000',
        after: '1cf19a015df3523caf0a1f9d40c98a267d6a2fc2',
        total_commits_count: 1,
        ref: 'refs/heads/my-branch'
      }
    end

    it 'creates a new PushEventPayload row' do
      payload = described_class.new(event, push_data).execute

      expect(payload.commit_count).to eq(1)
      expect(payload.action).to eq('created')
      expect(payload.ref_type).to eq('branch')
      expect(payload.commit_from).to be_nil
      expect(payload.commit_to).to eq(push_data[:after])
      expect(payload.ref).to eq('my-branch')
      expect(payload.commit_title).to eq('This is a commit')
      expect(payload.event_id).to eq(event.id)
    end

    it 'sets the push_event_payload association of the used event' do
      payload = described_class.new(event, push_data).execute

      expect(event.push_event_payload).to eq(payload)
    end
  end

  describe '#commit_title' do
    it 'returns nil if no commits were pushed' do
      service = described_class.new(event, commits: [])

      expect(service.commit_title).to be_nil
    end

    it 'returns a String limited to 70 characters' do
      service = described_class.new(event, commits: [{ message: 'a' * 100 }])

      expect(service.commit_title).to eq(('a' * 67) + '...')
    end

    it 'does not truncate the commit message if it is shorter than 70 characters' do
      service = described_class.new(event, commits: [{ message: 'Hello' }])

      expect(service.commit_title).to eq('Hello')
    end

    it 'includes the first line of a commit message if the message spans multiple lines' do
      service = described_class
        .new(event, commits: [{ message: ""Hello\n\nworld"" }])

      expect(service.commit_title).to eq('Hello')
    end
  end

  describe '#commit_from_id' do
    it 'returns nil when creating a new ref' do
      service = described_class.new(event, before: Gitlab::Git::BLANK_SHA)

      expect(service.commit_from_id).to be_nil
    end

    it 'returns the ID of the first commit when pushing to an existing ref' do
      service = described_class.new(event, before: '123')

      expect(service.commit_from_id).to eq('123')
    end
  end

  describe '#commit_to_id' do
    it 'returns nil when removing an existing ref' do
      service = described_class.new(event, after: Gitlab::Git::BLANK_SHA)

      expect(service.commit_to_id).to be_nil
    end
  end

  describe '#commit_count' do
    it 'returns the number of commits' do
      service = described_class.new(event, total_commits_count: 1)

      expect(service.commit_count).to eq(1)
    end

    it 'raises when the push data does not contain the commits count' do
      service = described_class.new(event, {})

      expect { service.commit_count }.to raise_error(KeyError)
    end
  end

  describe '#ref' do
    it 'returns the name of the ref' do
      service = described_class.new(event, ref: 'refs/heads/foo')

      expect(service.ref).to eq('refs/heads/foo')
    end

    it 'raises when the push data does not contain the ref name' do
      service = described_class.new(event, {})

      expect { service.ref }.to raise_error(KeyError)
    end
  end

  describe '#revision_before' do
    it 'returns the revision from before the push' do
      service = described_class.new(event, before: 'foo')

      expect(service.revision_before).to eq('foo')
    end

    it 'raises when the push data does not contain the before revision' do
      service = described_class.new(event, {})

      expect { service.revision_before }.to raise_error(KeyError)
    end
  end

  describe '#revision_after' do
    it 'returns the revision from after the push' do
      service = described_class.new(event, after: 'foo')

      expect(service.revision_after).to eq('foo')
    end

    it 'raises when the push data does not contain the after revision' do
      service = described_class.new(event, {})

      expect { service.revision_after }.to raise_error(KeyError)
    end
  end

  describe '#trimmed_ref' do
    it 'returns the ref name without its prefix' do
      service = described_class.new(event, ref: 'refs/heads/foo')

      expect(service.trimmed_ref).to eq('foo')
    end
  end

  describe '#create?' do
    it 'returns true when creating a new ref' do
      service = described_class.new(event, before: Gitlab::Git::BLANK_SHA)

      expect(service.create?).to eq(true)
    end

    it 'returns false when pushing to an existing ref' do
      service = described_class.new(event, before: 'foo')

      expect(service.create?).to eq(false)
    end
  end

  describe '#remove?' do
    it 'returns true when removing an existing ref' do
      service = described_class.new(event, after: Gitlab::Git::BLANK_SHA)

      expect(service.remove?).to eq(true)
    end

    it 'returns false pushing to an existing ref' do
      service = described_class.new(event, after: 'foo')

      expect(service.remove?).to eq(false)
    end
  end

  describe '#action' do
    it 'returns :created when creating a ref' do
      service = described_class.new(event, before: Gitlab::Git::BLANK_SHA)

      expect(service.action).to eq(:created)
    end

    it 'returns :removed when removing an existing ref' do
      service = described_class.new(event, before: '123', after: Gitlab::Git::BLANK_SHA)

      expect(service.action).to eq(:removed)
    end

    it 'returns :pushed when pushing to an existing ref' do
      service = described_class.new(event, before: '123', after: '456')

      expect(service.action).to eq(:pushed)
    end
  end

  describe '#ref_type' do
    it 'returns :tag for a tag' do
      service = described_class.new(event, ref: 'refs/tags/1.2')

      expect(service.ref_type).to eq(:tag)
    end

    it 'returns :branch for a branch' do
      service = described_class.new(event, ref: 'refs/heads/master')

      expect(service.ref_type).to eq(:branch)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

require 'resolv'

class VerifyPagesDomainService < BaseService
  # The maximum number of seconds to be spent on each DNS lookup
  RESOLVER_TIMEOUT_SECONDS = 15

  # How long verification lasts for
  VERIFICATION_PERIOD = 7.days
  REMOVAL_DELAY = 1.week.freeze

  attr_reader :domain

  def initialize(domain)
    @domain = domain
  end

  def execute
    return error(""No verification code set for #{domain.domain}"") unless domain.verification_code.present?

    if !verification_enabled? || dns_record_present?
      verify_domain!
    elsif expired?
      disable_domain!
    else
      unverify_domain!
    end
  end

  private

  def verify_domain!
    was_disabled = !domain.enabled?
    was_unverified = domain.unverified?

    # Prevent any pre-existing grace period from being truncated
    reverify = [domain.enabled_until, VERIFICATION_PERIOD.from_now].compact.max

    domain.assign_attributes(verified_at: Time.current, enabled_until: reverify, remove_at: nil)
    domain.save!(validate: false)

    if was_disabled
      notify(:enabled)
    elsif was_unverified
      notify(:verification_succeeded)
    end

    after_successful_verification

    success
  end

  def after_successful_verification
    # method overridden in EE
  end

  def unverify_domain!
    was_verified = domain.verified?

    domain.assign_attributes(verified_at: nil)
    domain.remove_at ||= REMOVAL_DELAY.from_now unless domain.enabled?
    domain.save!(validate: false)

    notify(:verification_failed) if was_verified

    error(""Couldn't verify #{domain.domain}"")
  end

  def disable_domain!
    domain.assign_attributes(verified_at: nil, enabled_until: nil)
    domain.remove_at ||= REMOVAL_DELAY.from_now
    domain.save!(validate: false)

    notify(:disabled)

    error(""Couldn't verify #{domain.domain}. It is now disabled."")
  end

  # A domain is only expired until `disable!` has been called
  def expired?
    domain.enabled_until&.past?
  end

  def dns_record_present?
    Resolv::DNS.open do |resolver|
      resolver.timeouts = RESOLVER_TIMEOUT_SECONDS

      check(domain.domain, resolver) || check(domain.verification_domain, resolver)
    end
  end

  def check(domain_name, resolver)
    # Append '.' to domain_name, indicating absolute FQDN
    records = parse(txt_records(domain_name + '.', resolver))

    records.any? do |record|
      record == domain.keyed_verification_code || record == domain.verification_code
    end
  rescue StandardError => err
    log_error(""Failed to check TXT records on #{domain_name} for #{domain.domain}: #{err}"")
    false
  end

  def txt_records(domain_name, resolver)
    resolver.getresources(domain_name, Resolv::DNS::Resource::IN::TXT)
  end

  def parse(records)
    records.flat_map(&:strings).flat_map(&:split)
  end

  def verification_enabled?
    Gitlab::CurrentSettings.pages_domain_verification_enabled?
  end

  def notify(type)
    return unless verification_enabled?

    Gitlab::AppLogger.info(""Pages domain '#{domain.domain}' changed state to '#{type}'"")
    notification_service.public_send(""pages_domain_#{type}"", domain) # rubocop:disable GitlabSecurity/PublicSend
  end
end

VerifyPagesDomainService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe VerifyPagesDomainService, feature_category: :pages do
  using RSpec::Parameterized::TableSyntax
  include EmailHelpers

  let(:error_status) { { status: :error, message: ""Couldn't verify #{domain.domain}"" } }

  subject(:service) { described_class.new(domain) }

  describe '#execute' do
    where(:domain_sym, :code_sym) do
      :domain | :verification_code
      :domain | :keyed_verification_code

      :verification_domain | :verification_code
      :verification_domain | :keyed_verification_code
    end

    with_them do
      let(:domain_name) { domain.send(domain_sym) }
      let(:verification_code) { domain.send(code_sym) }

      shared_examples 'verifies and enables the domain' do
        it 'verifies and enables the domain' do
          expect(service.execute).to eq(status: :success)

          expect(domain).to be_verified
          expect(domain).to be_enabled
          expect(domain.remove_at).to be_nil
        end
      end

      shared_examples 'successful enablement and verification' do
        context 'when txt record contains verification code' do
          before do
            stub_resolver(domain_name => ['something else', verification_code])
          end

          include_examples 'verifies and enables the domain'
        end

        context 'when txt record contains verification code with other text' do
          before do
            stub_resolver(domain_name => ""something #{verification_code} else"")
          end

          include_examples 'verifies and enables the domain'
        end
      end

      shared_examples 'unverifies and disables domain' do
        it 'unverifies domain' do
          expect(service.execute).to eq(error_status)
          expect(domain).not_to be_verified
        end

        it 'disables domain and shedules it for removal in 1 week' do
          service.execute

          expect(domain).not_to be_enabled

          expect(domain.remove_at).to be_like_time(7.days.from_now)
        end
      end

      context 'when domain is disabled(or new)' do
        let(:domain) { create(:pages_domain, :disabled) }

        include_examples 'successful enablement and verification'

        context 'when txt record does not contain verification code' do
          before do
            stub_resolver(domain_name => 'something else')
          end

          include_examples 'unverifies and disables domain'
        end

        context 'when txt record does not contain verification code' do
          before do
            stub_resolver(domain_name => 'something else')
          end

          include_examples 'unverifies and disables domain'
        end

        context 'when no txt records are present' do
          before do
            stub_resolver
          end

          include_examples 'unverifies and disables domain'
        end
      end

      context 'when domain is verified' do
        let(:domain) { create(:pages_domain) }

        include_examples 'successful enablement and verification'

        shared_examples 'unverifing domain' do
          it 'unverifies but does not disable domain' do
            expect(service.execute).to eq(error_status)
            expect(domain).not_to be_verified
            expect(domain).to be_enabled
          end

          it 'does not schedule domain for removal' do
            service.execute
            expect(domain.remove_at).to be_nil
          end
        end

        context 'when txt record does not contain verification code' do
          before do
            stub_resolver(domain_name => 'something else')
          end

          include_examples 'unverifing domain'
        end

        context 'when no txt records are present' do
          before do
            stub_resolver
          end

          include_examples 'unverifing domain'
        end
      end

      context 'when domain is expired' do
        let(:domain) { create(:pages_domain, :expired) }

        context 'when the right code is present' do
          before do
            stub_resolver(domain_name => domain.keyed_verification_code)
          end

          include_examples 'verifies and enables the domain'
        end

        context 'when the right code is not present' do
          before do
            stub_resolver
          end

          let(:error_status) { { status: :error, message: ""Couldn't verify #{domain.domain}. It is now disabled."" } }

          include_examples 'unverifies and disables domain'
        end
      end

      context 'when domain is disabled and scheduled for removal' do
        let(:domain) { create(:pages_domain, :disabled, :scheduled_for_removal) }

        context 'when the right code is present' do
          before do
            stub_resolver(domain.domain => domain.keyed_verification_code)
          end

          it 'verifies and enables domain' do
            expect(service.execute).to eq(status: :success)

            expect(domain).to be_verified
            expect(domain).to be_enabled
          end

          it 'prevent domain from being removed' do
            expect { service.execute }.to change { domain.remove_at }.to(nil)
          end
        end

        context 'when the right code is not present' do
          before do
            stub_resolver
          end

          it 'keeps domain scheduled for removal but does not change removal time' do
            expect { service.execute }.not_to change { domain.remove_at }
            expect(domain.remove_at).to be_present
          end
        end
      end

      context 'invalid domain' do
        let(:domain) { build(:pages_domain, :expired, :with_missing_chain) }

        before do
          domain.save!(validate: false)
        end

        it 'can be disabled' do
          error_status[:message] += '. It is now disabled.'

          stub_resolver

          expect(service.execute).to eq(error_status)

          expect(domain).not_to be_verified
          expect(domain).not_to be_enabled
        end
      end
    end

    context 'timeout behaviour' do
      let(:domain) { create(:pages_domain) }

      it 'sets a timeout on the DNS query' do
        expect(stub_resolver).to receive(:timeouts=).with(described_class::RESOLVER_TIMEOUT_SECONDS)

        service.execute
      end
    end

    context 'email notifications' do
      let(:notification_service) { instance_double('NotificationService') }

      where(:factory, :verification_succeeds, :expected_notification) do
        nil         | true  | nil
        nil         | false | :verification_failed
        :reverify   | true  | nil
        :reverify   | false | :verification_failed
        :unverified | true  | :verification_succeeded
        :unverified | false | nil
        :expired    | true  | nil
        :expired    | false | :disabled
        :disabled   | true  | :enabled
        :disabled   | false | nil
      end

      with_them do
        let(:domain) { create(:pages_domain, *[factory].compact) }

        before do
          allow(service).to receive(:notification_service) { notification_service }

          if verification_succeeds
            stub_resolver(domain.domain => domain.verification_code)
          else
            stub_resolver
          end
        end

        it 'sends a notification if appropriate' do
          if expected_notification
            expect(notification_service).to receive(:""pages_domain_#{expected_notification}"").with(domain)
          end

          service.execute
        end
      end

      context 'pages verification disabled' do
        let(:domain) { create(:pages_domain, :disabled) }

        before do
          stub_application_setting(pages_domain_verification_enabled: false)
          allow(service).to receive(:notification_service) { notification_service }
        end

        it 'skips email notifications' do
          expect(notification_service).not_to receive(:pages_domain_enabled)

          service.execute
        end
      end
    end

    context 'no verification code' do
      let(:domain) { create(:pages_domain) }

      it 'returns an error' do
        domain.verification_code = ''

        disallow_resolver!

        expect(service.execute).to eq(status: :error, message: ""No verification code set for #{domain.domain}"")
      end
    end

    context 'pages domain verification is disabled' do
      let(:domain) { create(:pages_domain, :disabled) }

      before do
        stub_application_setting(pages_domain_verification_enabled: false)
      end

      it 'extends domain validity by unconditionally reverifying' do
        disallow_resolver!

        service.execute

        expect(domain).to be_verified
        expect(domain).to be_enabled
      end

      it 'does not shorten any grace period' do
        grace = Time.current + 1.year
        domain.update!(enabled_until: grace)
        disallow_resolver!

        service.execute

        expect(domain.enabled_until).to be_like_time(grace)
      end
    end
  end

  def disallow_resolver!
    expect(Resolv::DNS).not_to receive(:open)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# This service passes Markdown content through our GFM rewriter classes
# which rewrite references to GitLab objects and uploads within the content
# based on their visibility by the `target_parent`.
class MarkdownContentRewriterService
  include Gitlab::Utils::StrongMemoize

  REWRITERS = [Gitlab::Gfm::ReferenceRewriter, Gitlab::Gfm::UploadsRewriter].freeze

  def initialize(current_user, object, field, source_parent, target_parent)
    @current_user = current_user
    @source_parent = source_parent
    @target_parent = target_parent
    @object = object
    @field = field

    validate_parameters!

    @content = object[field].dup.presence
    @html_field = object.cached_markdown_fields.html_field(field)
    @content_html = object.cached_html_for(field)

    @rewriters =
      REWRITERS.map do |rewriter_class|
        rewriter_class.new(@content, content_html, source_parent, current_user)
      end

    @result = {
      field => nil,
      html_field => nil
    }.with_indifferent_access
  end

  def execute
    return result unless content

    unless safe_to_copy_markdown?
      rewriters.each do |rewriter|
        rewriter.rewrite(target_parent)
      end
    end

    result[field] = content
    result[html_field] = content_html if safe_to_copy_markdown?
    result[:skip_markdown_cache_validation] = safe_to_copy_markdown?

    result
  end

  def safe_to_copy_markdown?
    strong_memoize(:safe_to_copy_markdown) do
      rewriters.none?(&:needs_rewrite?)
    end
  end

  private

  def validate_parameters!
    # See https://gitlab.com/gitlab-org/gitlab/-/merge_requests/39654#note_399095117
    raise ArgumentError, 'The rewriter classes require that `source_parent` is a `Project`' \
      unless source_parent.is_a?(Project)

    if object.cached_markdown_fields[field].nil?
      raise ArgumentError, 'The `field` attribute does not contain cached markdown'
    end
  end

  attr_reader :current_user, :content, :source_parent,
              :target_parent, :rewriters, :content_html,
              :field, :html_field, :object, :result
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MarkdownContentRewriterService, feature_category: :team_planning do
  let_it_be(:user) { create(:user) }
  let_it_be(:source_parent) { create(:project, :public) }
  let_it_be(:target_parent) { create(:project, :public) }

  let(:content) { 'My content' }
  let(:issue) { create(:issue, project: source_parent, description: content) }

  describe '#initialize' do
    it 'raises an error if source_parent is not a Project' do
      expect do
        described_class.new(user, issue, :description, create(:group), target_parent)
      end.to raise_error(ArgumentError, 'The rewriter classes require that `source_parent` is a `Project`')
    end

    it 'raises an error if field does not have cached markdown' do
      expect do
        described_class.new(user, issue, :author, source_parent, target_parent)
      end.to raise_error(ArgumentError, 'The `field` attribute does not contain cached markdown')
    end
  end

  describe '#execute' do
    subject { described_class.new(user, issue, :description, source_parent, target_parent).execute }

    context 'when content does not need a rewrite' do
      it 'returns original content and cached html' do
        expect(subject).to eq({
          'description' => issue.description,
          'description_html' => issue.description_html,
          'skip_markdown_cache_validation' => true
        })
      end
    end

    context 'when content needs a rewrite' do
      it 'calls the rewriter classes successfully', :aggregate_failures do
        described_class::REWRITERS.each do |rewriter_class|
          service = double

          allow(service).to receive(:needs_rewrite?).and_return(true)

          expect(service).to receive(:rewrite).with(target_parent)
          expect(rewriter_class).to receive(:new).and_return(service)
        end

        subject
      end
    end

    # Perform simple integration-style tests for each rewriter class.
    # to prove they run correctly.
    context 'when content has references' do
      let_it_be(:issue_to_reference) { create(:issue, project: source_parent) }

      let(:content) { ""See ##{issue_to_reference.iid}"" }

      it 'rewrites content' do
        expect(subject).to eq({
          'description' => ""See #{source_parent.full_path}##{issue_to_reference.iid}"",
          'description_html' => nil,
          'skip_markdown_cache_validation' => false
        })
      end
    end

    context 'when content contains an upload' do
      let(:image_uploader) { build(:file_uploader, project: source_parent) }
      let(:content) { ""Text and #{image_uploader.markdown_link}"" }

      it 'rewrites content' do
        new_content = subject

        expect(new_content[:description]).not_to eq(content)
        expect(new_content[:description].length).to eq(content.length)
        expect(new_content[1]).to eq(nil)
      end
    end
  end

  describe '#safe_to_copy_markdown?' do
    subject do
      rewriter = described_class.new(user, issue, :description, source_parent, target_parent)
      rewriter.safe_to_copy_markdown?
    end

    context 'when content has references' do
      let(:milestone) { create(:milestone, project: source_parent) }
      let(:content) { ""Description that references #{milestone.to_reference}"" }

      it { is_expected.to eq(false) }
    end

    context 'when content has uploaded file references' do
      let(:image_uploader) { build(:file_uploader, project: source_parent) }
      let(:content) { ""Text and #{image_uploader.markdown_link}"" }

      it { is_expected.to eq(false) }
    end

    context 'when content does not have references or uploads' do
      let(:content) { ""simples text with ```code```"" }

      it { is_expected.to eq(true) }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class SearchService
  include Gitlab::Allowable
  include Gitlab::Utils::StrongMemoize

  DEFAULT_PER_PAGE = Gitlab::SearchResults::DEFAULT_PER_PAGE
  MAX_PER_PAGE = 200

  attr_reader :params

  def initialize(current_user, params = {})
    @current_user = current_user
    @params = Gitlab::Search::Params.new(params, detect_abuse: true)
  end

  # rubocop: disable CodeReuse/ActiveRecord
  def project
    strong_memoize(:project) do
      if params[:project_id].present? && valid_request?
        the_project = Project.find_by(id: params[:project_id])
        can?(current_user, :read_project, the_project) ? the_project : nil
      end
    end
  end
  # rubocop: enable CodeReuse/ActiveRecord

  # rubocop: disable CodeReuse/ActiveRecord
  def group
    strong_memoize(:group) do
      if params[:group_id].present? && valid_request?
        the_group = Group.find_by(id: params[:group_id])
        can?(current_user, :read_group, the_group) ? the_group : nil
      end
    end
  end
  # rubocop: enable CodeReuse/ActiveRecord

  def projects
    # overridden in EE
  end

  def global_search?
    project.blank? && group.blank?
  end

  def search_type
    'basic'
  end

  def show_snippets?
    strong_memoize(:show_snippets) do
      params[:snippets] == 'true'
    end
  end

  delegate :scope, to: :search_service
  delegate :valid_terms_count?, :valid_query_length?, to: :params

  def search_results
    strong_memoize(:search_results) do
      abuse_detected? ? Gitlab::EmptySearchResults.new : search_service.execute
    end
  end

  def search_objects(preload_method = nil)
    @search_objects ||= redact_unauthorized_results(
      search_results.objects(scope, page: page, per_page: per_page, preload_method: preload_method)
    )
  end

  def search_highlight
    search_results.highlight_map(scope)
  end

  def search_aggregations
    search_results.aggregations(scope)
  end

  def abuse_detected?
    strong_memoize(:abuse_detected) do
      params.abusive?
    end
  end

  def abuse_messages
    return [] unless params.abusive?

    params.abuse_detection.errors.full_messages
  end

  def valid_request?
    strong_memoize(:valid_request) do
      params.valid?
    end
  end

  def level
    @level ||=
      if project
        'project'
      elsif group
        'group'
      else
        'global'
      end
  end

  def global_search_enabled_for_scope?
    return false if show_snippets? && Feature.disabled?(:global_search_snippet_titles_tab, current_user, type: :ops)

    case params[:scope]
    when 'blobs'
      Feature.enabled?(:global_search_code_tab, current_user, type: :ops)
    when 'commits'
      Feature.enabled?(:global_search_commits_tab, current_user, type: :ops)
    when 'issues'
      Feature.enabled?(:global_search_issues_tab, current_user, type: :ops)
    when 'merge_requests'
      Feature.enabled?(:global_search_merge_requests_tab, current_user, type: :ops)
    when 'snippet_titles'
      Feature.enabled?(:global_search_snippet_titles_tab, current_user, type: :ops)
    when 'wiki_blobs'
      Feature.enabled?(:global_search_wiki_tab, current_user, type: :ops)
    when 'users'
      Feature.enabled?(:global_search_users_tab, current_user, type: :ops)
    else
      true
    end
  end

  private

  def page
    [1, params[:page].to_i].max
  end

  def per_page
    per_page_param = params[:per_page].to_i

    return DEFAULT_PER_PAGE unless per_page_param > 0

    [MAX_PER_PAGE, per_page_param].min
  end

  def visible_result?(object)
    return true unless object.respond_to?(:to_ability_name) && DeclarativePolicy.has_policy?(object)

    Ability.allowed?(current_user, :""read_#{object.to_ability_name}"", object)
  end

  def redact_unauthorized_results(results_collection)
    redacted_results = results_collection.reject { |object| visible_result?(object) }

    if redacted_results.any?
      redacted_log = redacted_results.each_with_object({}) do |object, memo|
        memo[object.id] = { ability: :""read_#{object.to_ability_name}"", id: object.id, class_name: object.class.name }
      end

      log_redacted_search_results(redacted_log.values)

      return results_collection.id_not_in(redacted_log.keys) if results_collection.is_a?(ActiveRecord::Relation)
    end

    return results_collection if results_collection.is_a?(ActiveRecord::Relation)

    permitted_results = results_collection - redacted_results

    Kaminari.paginate_array(
      permitted_results,
      total_count: results_collection.total_count,
      limit: results_collection.limit_value,
      offset: results_collection.offset_value
    )
  end

  def log_redacted_search_results(filtered_results)
    logger.error(message: ""redacted_search_results"", filtered: filtered_results, current_user_id: current_user&.id, query: params[:search])
  end

  def logger
    @logger ||= ::Gitlab::RedactedSearchResultsLogger.build
  end

  def search_service
    @search_service ||=
      if project
        Search::ProjectService.new(current_user, project, params)
      elsif show_snippets?
        Search::SnippetService.new(current_user, params)
      elsif group
        Search::GroupService.new(current_user, group, params)
      else
        Search::GlobalService.new(current_user, params)
      end
  end

  attr_reader :current_user
end

SearchService.prepend_mod_with('SearchService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe SearchService, feature_category: :global_search do
  let_it_be(:user) { create(:user) }

  let_it_be(:accessible_group) { create(:group, :private) }
  let_it_be(:inaccessible_group) { create(:group, :private) }
  let_it_be(:group_member) { create(:group_member, group: accessible_group, user: user) }

  let_it_be(:accessible_project) { create(:project, :repository, :private, name: 'accessible_project') }
  let_it_be(:note) { create(:note_on_issue, project: accessible_project) }

  let_it_be(:inaccessible_project) { create(:project, :repository, :private, name: 'inaccessible_project') }

  let(:snippet) { create(:snippet, author: user) }
  let(:group_project) { create(:project, group: accessible_group, name: 'group_project') }
  let(:public_project) { create(:project, :public, name: 'public_project') }

  let(:page) { 1 }
  let(:per_page) { described_class::DEFAULT_PER_PAGE }
  let(:valid_search) { ""what is love?"" }

  subject(:search_service) { described_class.new(user, search: search, scope: scope, page: page, per_page: per_page) }

  before do
    accessible_project.add_maintainer(user)
  end

  describe '#project' do
    context 'when the project is accessible' do
      it 'returns the project' do
        project = described_class.new(user, project_id: accessible_project.id, search: valid_search).project

        expect(project).to eq accessible_project
      end

      it 'returns the project for guests' do
        search_project = create :project
        search_project.add_guest(user)

        project = described_class.new(user, project_id: search_project.id, search: valid_search).project

        expect(project).to eq search_project
      end
    end

    context 'when the project is not accessible' do
      it 'returns nil' do
        project = described_class.new(user, project_id: inaccessible_project.id, search: valid_search).project

        expect(project).to be_nil
      end
    end

    context 'when there is no project_id' do
      it 'returns nil' do
        project = described_class.new(user, search: valid_search).project

        expect(project).to be_nil
      end
    end
  end

  describe '#group' do
    context 'when the group is accessible' do
      it 'returns the group' do
        group = described_class.new(user, group_id: accessible_group.id, search: valid_search).group

        expect(group).to eq accessible_group
      end
    end

    context 'when the group is not accessible' do
      it 'returns nil' do
        group = described_class.new(user, group_id: inaccessible_group.id, search: valid_search).group

        expect(group).to be_nil
      end
    end

    context 'when there is no group_id' do
      it 'returns nil' do
        group = described_class.new(user, search: valid_search).group

        expect(group).to be_nil
      end
    end
  end

  describe '#search_type' do
    subject { described_class.new(user, search: valid_search).search_type }

    it { is_expected.to eq('basic') }
  end

  describe '#show_snippets?' do
    context 'when :snippets is \'true\'' do
      it 'returns true' do
        show_snippets = described_class.new(user, snippets: 'true').show_snippets?

        expect(show_snippets).to be_truthy
      end
    end

    context 'when :snippets is not \'true\'' do
      it 'returns false' do
        show_snippets = described_class.new(user, snippets: 'tru').show_snippets?

        expect(show_snippets).to be_falsey
      end
    end

    context 'when :snippets is missing' do
      it 'returns false' do
        show_snippets = described_class.new(user).show_snippets?

        expect(show_snippets).to be_falsey
      end
    end
  end

  describe '#scope' do
    context 'with accessible project_id' do
      context 'and allowed scope' do
        it 'returns the specified scope' do
          scope = described_class.new(user, project_id: accessible_project.id, scope: 'notes', search: valid_search).scope

          expect(scope).to eq 'notes'
        end
      end

      context 'and disallowed scope' do
        it 'returns the default scope' do
          scope = described_class.new(user, project_id: accessible_project.id, scope: 'projects', search: valid_search).scope

          expect(scope).to eq 'blobs'
        end
      end

      context 'and no scope' do
        it 'returns the default scope' do
          scope = described_class.new(user, project_id: accessible_project.id, search: valid_search).scope

          expect(scope).to eq 'blobs'
        end
      end
    end

    context 'with \'true\' snippets' do
      context 'and allowed scope' do
        it 'returns the specified scope' do
          scope = described_class.new(user, snippets: 'true', scope: 'snippet_titles').scope

          expect(scope).to eq 'snippet_titles'
        end
      end

      context 'and disallowed scope' do
        it 'returns the default scope' do
          scope = described_class.new(user, snippets: 'true', scope: 'projects').scope

          expect(scope).to eq 'snippet_titles'
        end
      end

      context 'and no scope' do
        it 'returns the default scope' do
          scope = described_class.new(user, snippets: 'true').scope

          expect(scope).to eq 'snippet_titles'
        end
      end
    end

    context 'with no project_id, no snippets' do
      context 'and allowed scope' do
        it 'returns the specified scope' do
          scope = described_class.new(user, scope: 'issues').scope

          expect(scope).to eq 'issues'
        end
      end

      context 'and disallowed scope' do
        it 'returns the default scope' do
          scope = described_class.new(user, scope: 'blobs').scope

          expect(scope).to eq 'projects'
        end
      end

      context 'and no scope' do
        it 'returns the default scope' do
          scope = described_class.new(user).scope

          expect(scope).to eq 'projects'
        end
      end
    end
  end

  describe '#search_results' do
    context 'with accessible project_id' do
      it 'returns an instance of Gitlab::ProjectSearchResults' do
        search_results = described_class.new(
          user,
          project_id: accessible_project.id,
          scope: 'notes',
          search: note.note).search_results

        expect(search_results).to be_a Gitlab::ProjectSearchResults
      end
    end

    context 'with accessible project_id and \'true\' snippets' do
      it 'returns an instance of Gitlab::ProjectSearchResults' do
        search_results = described_class.new(
          user,
          project_id: accessible_project.id,
          snippets: 'true',
          scope: 'notes',
          search: note.note).search_results

        expect(search_results).to be_a Gitlab::ProjectSearchResults
      end
    end

    context 'with \'true\' snippets' do
      it 'returns an instance of Gitlab::SnippetSearchResults' do
        search_results = described_class.new(
          user,
          snippets: 'true',
          search: snippet.title).search_results

        expect(search_results).to be_a Gitlab::SnippetSearchResults
      end
    end

    context 'with no project_id and no snippets' do
      it 'returns an instance of Gitlab::SearchResults' do
        search_results = described_class.new(
          user,
          search: public_project.name).search_results

        expect(search_results).to be_a Gitlab::SearchResults
      end
    end
  end

  describe '#search_objects' do
    let(:search) { '' }
    let(:scope) { nil }

    describe 'per_page: parameter' do
      context 'when nil' do
        let(:per_page) { nil }

        it ""defaults to #{described_class::DEFAULT_PER_PAGE}"" do
          expect_any_instance_of(Gitlab::SearchResults)
            .to receive(:objects)
            .with(anything, hash_including(per_page: described_class::DEFAULT_PER_PAGE))
            .and_call_original

          subject.search_objects
        end
      end

      context 'when empty string' do
        let(:per_page) { '' }

        it ""defaults to #{described_class::DEFAULT_PER_PAGE}"" do
          expect_any_instance_of(Gitlab::SearchResults)
            .to receive(:objects)
            .with(anything, hash_including(per_page: described_class::DEFAULT_PER_PAGE))
            .and_call_original

          subject.search_objects
        end
      end

      context 'when negative' do
        let(:per_page) { '-1' }

        it ""defaults to #{described_class::DEFAULT_PER_PAGE}"" do
          expect_any_instance_of(Gitlab::SearchResults)
            .to receive(:objects)
            .with(anything, hash_including(per_page: described_class::DEFAULT_PER_PAGE))
            .and_call_original

          subject.search_objects
        end
      end

      context 'when present' do
        let(:per_page) { '50' }

        it ""converts to integer and passes to search results"" do
          expect_any_instance_of(Gitlab::SearchResults)
            .to receive(:objects)
            .with(anything, hash_including(per_page: 50))
            .and_call_original

          subject.search_objects
        end
      end

      context ""when greater than #{described_class::MAX_PER_PAGE}"" do
        let(:per_page) { described_class::MAX_PER_PAGE + 1 }

        it ""passes #{described_class::MAX_PER_PAGE}"" do
          expect_any_instance_of(Gitlab::SearchResults)
            .to receive(:objects)
            .with(anything, hash_including(per_page: described_class::MAX_PER_PAGE))
            .and_call_original

          subject.search_objects
        end
      end
    end

    describe 'page: parameter' do
      context 'when < 1' do
        let(:page) { 0 }

        it ""defaults to 1"" do
          expect_any_instance_of(Gitlab::SearchResults)
            .to receive(:objects)
            .with(anything, hash_including(page: 1))
            .and_call_original

          subject.search_objects
        end
      end

      context 'when nil' do
        let(:page) { nil }

        it ""defaults to 1"" do
          expect_any_instance_of(Gitlab::SearchResults)
            .to receive(:objects)
            .with(anything, hash_including(page: 1))
            .and_call_original

          subject.search_objects
        end
      end
    end

    context 'with accessible project_id' do
      it 'returns objects in the project' do
        search_objects = described_class.new(
          user,
          project_id: accessible_project.id,
          scope: 'notes',
          search: note.note).search_objects

        expect(search_objects.first).to eq note
      end
    end

    context 'with accessible project_id and \'true\' snippets' do
      it 'returns objects in the project' do
        search_objects = described_class.new(
          user,
          project_id: accessible_project.id,
          snippets: 'true',
          scope: 'notes',
          search: note.note).search_objects

        expect(search_objects.first).to eq note
      end
    end

    context 'with \'true\' snippets' do
      it 'returns objects in snippets' do
        search_objects = described_class.new(
          user,
          snippets: 'true',
          search: snippet.title).search_objects

        expect(search_objects.first).to eq snippet
      end
    end

    context 'with accessible group_id' do
      it 'returns objects in the group' do
        search_objects = described_class.new(
          user,
          group_id: accessible_group.id,
          search: group_project.name).search_objects

        expect(search_objects.first).to eq group_project
      end
    end

    context 'with no project_id, group_id or snippets' do
      it 'returns objects in global' do
        search_objects = described_class.new(
          user,
          search: public_project.name).search_objects

        expect(search_objects.first).to eq public_project
      end
    end

    it_behaves_like 'a redacted search results'
  end

  describe '#valid_request?' do
    let(:scope) { 'issues' }
    let(:search) { 'foobar' }
    let(:params) { instance_double(Gitlab::Search::Params) }

    before do
      allow(Gitlab::Search::Params).to receive(:new).and_return(params)
      allow(params).to receive(:valid?).and_return double(:valid?)
    end

    it 'is the return value of params.valid?' do
      expect(subject.valid_request?).to eq(params.valid?)
    end
  end

  describe '#abuse_messages' do
    let(:scope) { 'issues' }
    let(:search) { 'foobar' }
    let(:params) { instance_double(Gitlab::Search::Params) }

    before do
      allow(Gitlab::Search::Params).to receive(:new).and_return(params)
    end

    it 'returns an empty array when not abusive' do
      allow(params).to receive(:abusive?).and_return false
      expect(subject.abuse_messages).to match_array([])
    end

    it 'calls on abuse_detection.errors.full_messages when abusive' do
      allow(params).to receive(:abusive?).and_return true
      expect(params).to receive_message_chain(:abuse_detection, :errors, :full_messages)
      subject.abuse_messages
    end
  end

  describe 'abusive search handling' do
    subject { described_class.new(user, raw_params) }

    let(:raw_params) { { search: search, scope: scope } }
    let(:search) { 'foobar' }

    let(:search_service) { double(:search_service) }

    before do
      expect(Gitlab::Search::Params).to receive(:new)
        .with(raw_params, detect_abuse: true).and_call_original

      allow(subject).to receive(:search_service).and_return search_service
    end

    context 'a search is abusive' do
      let(:scope) { '1;drop%20table' }

      it 'does NOT execute search service' do
        expect(search_service).not_to receive(:execute)
        subject.search_results
      end
    end

    context 'a search is NOT abusive' do
      let(:scope) { 'issues' }

      it 'executes search service' do
        expect(search_service).to receive(:execute)
        subject.search_results
      end
    end
  end

  describe '.global_search_enabled_for_scope?' do
    using RSpec::Parameterized::TableSyntax
    let(:search) { 'foobar' }

    where(:scope, :feature_flag, :enabled, :expected) do
      'blobs'          | :global_search_code_tab           | false | false
      'blobs'          | :global_search_code_tab           | true  | true
      'commits'        | :global_search_commits_tab        | false | false
      'commits'        | :global_search_commits_tab        | true  | true
      'issues'         | :global_search_issues_tab         | false | false
      'issues'         | :global_search_issues_tab         | true  | true
      'merge_requests' | :global_search_merge_requests_tab | false | false
      'merge_requests' | :global_search_merge_requests_tab | true  | true
      'snippet_titles' | :global_search_snippet_titles_tab | false | false
      'snippet_titles' | :global_search_snippet_titles_tab | true  | true
      'wiki_blobs'     | :global_search_wiki_tab           | false | false
      'wiki_blobs'     | :global_search_wiki_tab           | true  | true
      'users'          | :global_search_users_tab          | false | false
      'users'          | :global_search_users_tab          | true  | true
      'random'         | :random                           | nil   | true
    end

    with_them do
      it 'returns false when feature_flag is not enabled and returns true when feature_flag is enabled' do
        stub_feature_flags(feature_flag => enabled)
        expect(subject.global_search_enabled_for_scope?).to eq expected
      end
    end

    context 'when snippet search is enabled' do
      let(:scope) { 'snippet_titles' }

      before do
        allow(described_class).to receive(:show_snippets?).and_return(true)
      end

      it 'returns false when feature_flag is not enabled' do
        stub_feature_flags(global_search_snippet_titles_tab: false)

        expect(subject.global_search_enabled_for_scope?).to eq false
      end

      it 'returns true when feature_flag is enabled' do
        stub_feature_flags(global_search_snippet_titles_tab: true)

        expect(subject.global_search_enabled_for_scope?).to eq true
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class SystemHooksService
  def execute_hooks_for(model, event)
    data = build_event_data(model, event)

    model.run_after_commit_or_now do
      SystemHooksService.new.execute_hooks(data)
    end
  end

  def execute_hooks(data, hooks_scope = :all)
    SystemHook.executable.hooks_for(hooks_scope).find_each do |hook|
      hook.async_execute(data, 'system_hooks')
    end

    Gitlab::FileHook.execute_all_async(data)
  end

  private

  def build_event_data(model, event)
    builder_class = case model
                    when GroupMember
                      Gitlab::HookData::GroupMemberBuilder
                    when Group
                      Gitlab::HookData::GroupBuilder
                    when ProjectMember
                      Gitlab::HookData::ProjectMemberBuilder
                    when User
                      Gitlab::HookData::UserBuilder
                    when Project
                      Gitlab::HookData::ProjectBuilder
                    when Key
                      Gitlab::HookData::KeyBuilder
                    end

    builder_class.new(model).build(event)
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe SystemHooksService, feature_category: :webhooks do
  describe '#execute_hooks_for' do
    let_it_be(:user) { create(:user) }
    let_it_be(:group) { create(:group) }
    let_it_be(:project) { create(:project) }
    let_it_be(:group_member) { create(:group_member, source: group, user: user) }
    let_it_be(:project_member) { create(:project_member, source: project, user: user) }
    let_it_be(:key) { create(:key, user: user) }
    let_it_be(:deploy_key) { create(:key) }

    let(:event) { :create }

    using RSpec::Parameterized::TableSyntax

    where(:model_name, :builder_class) do
      :group_member | Gitlab::HookData::GroupMemberBuilder
      :group | Gitlab::HookData::GroupBuilder
      :project_member | Gitlab::HookData::ProjectMemberBuilder
      :user | Gitlab::HookData::UserBuilder
      :project | Gitlab::HookData::ProjectBuilder
      :key | Gitlab::HookData::KeyBuilder
      :deploy_key | Gitlab::HookData::KeyBuilder
    end

    with_them do
      it 'builds the data with the relevant builder class and then calls #execute_hooks with the obtained data' do
        data = double
        model = public_send(model_name)

        expect_next_instance_of(builder_class, model) do |builder|
          expect(builder).to receive(:build).with(event).and_return(data)
        end

        service = described_class.new

        expect_next_instance_of(SystemHooksService) do |system_hook_service|
          expect(system_hook_service).to receive(:execute_hooks).with(data)
        end

        service.execute_hooks_for(model, event)
      end
    end
  end

  describe '#execute_hooks' do
    let(:data) { { key: :value } }

    subject { described_class.new.execute_hooks(data) }

    it 'executes system hooks with the given data' do
      hook = create(:system_hook)

      allow(SystemHook).to receive_message_chain(:hooks_for, :find_each).and_yield(hook)

      expect(hook).to receive(:async_execute).with(data, 'system_hooks')

      subject
    end

    it 'executes FileHook with the given data' do
      expect(Gitlab::FileHook).to receive(:execute_all_async).with(data)

      subject
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

require 'securerandom'

# Compare 2 refs for one repo or between repositories
# and return Compare object that responds to commits and diffs
class CompareService
  attr_reader :start_project, :start_ref_name

  def initialize(new_start_project, new_start_ref_name)
    @start_project = new_start_project
    @start_ref_name = new_start_ref_name
  end

  def execute(target_project, target_ref, base_sha: nil, straight: false)
    raw_compare = target_project.repository.compare_source_branch(target_ref, start_project.repository, start_ref_name, straight: straight)

    return unless raw_compare && raw_compare.base && raw_compare.head

    Compare.new(raw_compare, start_project, base_sha: base_sha, straight: straight)
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe CompareService, feature_category: :source_code_management do
  let(:project) { create(:project, :repository) }
  let(:user) { create(:user) }
  let(:service) { described_class.new(project, 'feature') }

  describe '#execute' do
    context 'compare with base, like feature...fix' do
      subject { service.execute(project, 'fix', straight: false) }

      it { expect(subject.diffs.size).to eq(1) }
    end

    context 'straight compare, like feature..fix' do
      subject { service.execute(project, 'fix', straight: true) }

      it { expect(subject.diffs.size).to eq(3) }
    end

    context 'compare with target branch that does not exist' do
      subject { service.execute(project, 'non-existent-ref') }

      it { expect(subject).to be_nil }
    end

    context 'compare with source branch that does not exist' do
      let(:service) { described_class.new(project, 'non-existent-branch') }

      subject { service.execute(project, 'non-existent-ref') }

      it { expect(subject).to be_nil }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class UserAgentDetailService
  def initialize(spammable:, perform_spam_check:)
    @spammable = spammable
    @perform_spam_check = perform_spam_check
  end

  def create
    spam_params = Gitlab::RequestContext.instance.spam_params
    if !perform_spam_check || spam_params&.user_agent.blank? || spam_params&.ip_address.blank?
      message = 'Skipped UserAgentDetail creation because necessary spam_params were not provided'
      return ServiceResponse.success(message: message)
    end

    spammable.create_user_agent_detail(user_agent: spam_params.user_agent, ip_address: spam_params.ip_address)
  end

  private

  attr_reader :spammable, :perform_spam_check
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe UserAgentDetailService, feature_category: :instance_resiliency do
  describe '#create', :request_store do
    let_it_be(:spammable) { create(:issue) }

    using RSpec::Parameterized::TableSyntax

    where(:perform_spam_check, :spam_params_present, :user_agent, :ip_address, :creates_user_agent_detail) do
      true  | true  | 'UA' | 'IP' | true
      true  | false | 'UA' | 'IP' | false
      false | true  | 'UA' | 'IP' | false
      true  | true  | ''   | 'IP' | false
      true  | true  | nil  | 'IP' | false
      true  | true  | 'UA' | ''   | false
      true  | true  | 'UA' | nil  | false
    end

    with_them do
      let(:spam_params) do
        instance_double('Spam::SpamParams', user_agent: user_agent, ip_address: ip_address) if spam_params_present
      end

      before do
        allow(Gitlab::RequestContext.instance).to receive(:spam_params).and_return(spam_params)
      end

      subject { described_class.new(spammable: spammable, perform_spam_check: perform_spam_check).create } # rubocop:disable Rails/SaveBang

      it 'creates a user agent detail when expected' do
        if creates_user_agent_detail
          expect { subject }.to change { UserAgentDetail.count }.by(1)
        else
          expect(subject).to be_a ServiceResponse
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class X509CertificateRevokeService
  def execute(certificate)
    return unless certificate.revoked?

    certificate.x509_commit_signatures.update_all(verification_status: :unverified)
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe X509CertificateRevokeService, feature_category: :system_access do
  describe '#execute' do
    let(:service) { described_class.new }
    let!(:x509_signature_1) { create(:x509_commit_signature, x509_certificate: x509_certificate, verification_status: :verified) }
    let!(:x509_signature_2) { create(:x509_commit_signature, x509_certificate: x509_certificate, verification_status: :verified) }

    context 'for revoked certificates' do
      let(:x509_certificate) { create(:x509_certificate, certificate_status: :revoked) }

      it 'update all commit signatures' do
        expect do
          service.execute(x509_certificate)

          x509_signature_1.reload
          x509_signature_2.reload
        end
          .to change(x509_signature_1, :verification_status).from('verified').to('unverified')
          .and change(x509_signature_2, :verification_status).from('verified').to('unverified')
      end
    end

    context 'for good certificates' do
      let(:x509_certificate) { create(:x509_certificate) }

      it 'do not update any commit signature' do
        expect do
          service.execute(x509_certificate)

          x509_signature_1.reload
          x509_signature_2.reload
        end
          .to not_change(x509_signature_1, :verification_status)
          .and not_change(x509_signature_2, :verification_status)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# EventCreateService class
#
# Used for creating events feed on dashboard after certain user action
#
# Ex.
#   EventCreateService.new.new_issue(issue, current_user)
#
class EventCreateService
  IllegalActionError = Class.new(StandardError)

  DEGIGN_EVENT_LABEL = 'usage_activity_by_stage_monthly.create.action_monthly_active_users_design_management'
  MR_EVENT_LABEL = 'usage_activity_by_stage_monthly.create.merge_requests_users'
  MR_EVENT_PROPERTY = 'merge_request_action'

  def open_issue(issue, current_user)
    create_record_event(issue, current_user, :created)
  end

  def close_issue(issue, current_user)
    create_record_event(issue, current_user, :closed)
  end

  def reopen_issue(issue, current_user)
    create_record_event(issue, current_user, :reopened)
  end

  def open_mr(merge_request, current_user)
    create_record_event(merge_request, current_user, :created).tap do
      Gitlab::UsageDataCounters::HLLRedisCounter.track_event(:merge_request_action, values: current_user.id)
      track_snowplow_event(
        action: :created,
        project: merge_request.project,
        user: current_user,
        label: MR_EVENT_LABEL,
        property: MR_EVENT_PROPERTY
      )
    end
  end

  def close_mr(merge_request, current_user)
    create_record_event(merge_request, current_user, :closed).tap do
      Gitlab::UsageDataCounters::HLLRedisCounter.track_event(:merge_request_action, values: current_user.id)
      track_snowplow_event(
        action: :closed,
        project: merge_request.project,
        user: current_user,
        label: MR_EVENT_LABEL,
        property: MR_EVENT_PROPERTY
      )
    end
  end

  def reopen_mr(merge_request, current_user)
    create_record_event(merge_request, current_user, :reopened)
  end

  def merge_mr(merge_request, current_user)
    create_record_event(merge_request, current_user, :merged).tap do
      Gitlab::UsageDataCounters::HLLRedisCounter.track_event(:merge_request_action, values: current_user.id)
      track_snowplow_event(
        action: :merged,
        project: merge_request.project,
        user: current_user,
        label: MR_EVENT_LABEL,
        property: MR_EVENT_PROPERTY
      )
    end
  end

  def open_milestone(milestone, current_user)
    create_record_event(milestone, current_user, :created)
  end

  def close_milestone(milestone, current_user)
    create_record_event(milestone, current_user, :closed)
  end

  def reopen_milestone(milestone, current_user)
    create_record_event(milestone, current_user, :reopened)
  end

  def destroy_milestone(milestone, current_user)
    create_record_event(milestone, current_user, :destroyed)
  end

  def leave_note(note, current_user)
    create_record_event(note, current_user, :commented).tap do
      if note.is_a?(DiffNote) && note.for_merge_request?
        Gitlab::UsageDataCounters::HLLRedisCounter.track_event(:merge_request_action, values: current_user.id)
        track_snowplow_event(
          action: :commented,
          project: note.project,
          user: current_user,
          label: MR_EVENT_LABEL,
          property: MR_EVENT_PROPERTY
        )
      end
    end
  end

  def join_project(project, current_user)
    create_event(project, current_user, :joined)
  end

  def leave_project(project, current_user)
    create_event(project, current_user, :left)
  end

  def expired_leave_project(project, current_user)
    create_event(project, current_user, :expired)
  end

  def create_project(project, current_user)
    create_event(project, current_user, :created)
  end

  def push(project, current_user, push_data)
    create_push_event(PushEventPayloadService, project, current_user, push_data)
  end

  def bulk_push(project, current_user, push_data)
    create_push_event(BulkPushEventPayloadService, project, current_user, push_data)
  end

  def save_designs(current_user, create: [], update: [])
    records = create.zip([:created].cycle) + update.zip([:updated].cycle)
    return [] if records.empty?

    event_meta = { user: current_user, label: DEGIGN_EVENT_LABEL, property: :design_action }
    track_snowplow_event(action: :create, project: create.first.project, **event_meta) if create.any?

    track_snowplow_event(action: :update, project: update.first.project, **event_meta) if update.any?

    inserted_events = create_record_events(records, current_user)

    Gitlab::UsageDataCounters::HLLRedisCounter.track_event(:design_action, values: current_user.id)
    Gitlab::UsageDataCounters::HLLRedisCounter.track_event(:git_write_action, values: current_user.id)

    inserted_events
  end

  def destroy_designs(designs, current_user)
    return [] unless designs.present?

    track_snowplow_event(
      action: :destroy,
      project: designs.first.project,
      user: current_user,
      label: DEGIGN_EVENT_LABEL,
      property: :design_action
    )

    inserted_events = create_record_events(designs.zip([:destroyed].cycle), current_user)

    Gitlab::UsageDataCounters::HLLRedisCounter.track_event(:design_action, values: current_user.id)
    Gitlab::UsageDataCounters::HLLRedisCounter.track_event(:git_write_action, values: current_user.id)

    inserted_events
  end

  # Create a new wiki page event
  #
  # @param [WikiPage::Meta] wiki_page_meta The event target
  # @param [User] author The event author
  # @param [Symbol] action One of the Event::WIKI_ACTIONS
  # @param [String] fingerprint The de-duplication fingerprint
  #
  # The fingerprint, if provided, should be sufficient to find duplicate events.
  # Suitable values would be, for example, the current page SHA.
  #
  # @return [Event] the event
  def wiki_event(wiki_page_meta, author, action, fingerprint)
    raise IllegalActionError, action unless Event::WIKI_ACTIONS.include?(action)

    Gitlab::UsageDataCounters::HLLRedisCounter.track_event(:wiki_action, values: author.id)
    Gitlab::UsageDataCounters::HLLRedisCounter.track_event(:git_write_action, values: author.id)

    duplicate = Event.for_wiki_meta(wiki_page_meta).for_fingerprint(fingerprint).first
    return duplicate if duplicate.present?

    create_record_event(wiki_page_meta, author, action, fingerprint.presence)
  end

  def approve_mr(merge_request, current_user)
    create_record_event(merge_request, current_user, :approved)
  end

  private

  def create_record_event(record, current_user, status, fingerprint = nil)
    create_event(
      record.resource_parent,
      current_user,
      status,
      fingerprint: fingerprint,
      target_id: record.id,
      target_type: record.class.name
    )
  end

  # If creating several events, this method will insert them all in a single
  # statement
  #
  # @param [[Eventable, Symbol, String]] a list of tuples of records, a valid status, and fingerprint
  # @param [User] the author of the event
  def create_record_events(tuples, current_user)
    base_attrs = {
      created_at: Time.now.utc,
      updated_at: Time.now.utc,
      author_id: current_user.id
    }

    attribute_sets = tuples.map do |record, status, fingerprint|
      action = Event.actions[status]
      raise IllegalActionError, ""#{status} is not a valid status"" if action.nil?

      parent_attrs(record.resource_parent)
        .merge(base_attrs)
        .merge(action: action, fingerprint: fingerprint, target_id: record.id, target_type: record.class.name)
    end

    Event.insert_all(attribute_sets, returning: %w[id])
  end

  def create_push_event(service_class, project, current_user, push_data)
    # We're using an explicit transaction here so that any errors that may occur
    # when creating push payload data will result in the event creation being
    # rolled back as well.
    event = Event.transaction do
      new_event = create_event(project, current_user, :pushed)

      service_class.new(new_event, push_data).execute

      new_event
    end

    Gitlab::UsageDataCounters::HLLRedisCounter.track_event(:project_action, values: current_user.id)
    Gitlab::UsageDataCounters::HLLRedisCounter.track_event(:git_write_action, values: current_user.id)

    namespace = project.namespace
    Gitlab::Tracking.event(
      self.class.to_s,
      :push,
      label: 'usage_activity_by_stage_monthly.create.action_monthly_active_users_project_repo',
      namespace: namespace,
      user: current_user,
      project: project,
      property: 'project_action',
      context: [Gitlab::Tracking::ServicePingContext.new(data_source: :redis_hll, event: 'project_action').to_context]
    )

    Users::LastPushEventService.new(current_user)
      .cache_last_push_event(event)

    Users::ActivityService.new(author: current_user, namespace: namespace, project: project).execute
  end

  def create_event(resource_parent, current_user, status, attributes = {})
    attributes.reverse_merge!(
      action: status,
      author_id: current_user.id
    )
    attributes.merge!(parent_attrs(resource_parent))

    if attributes[:fingerprint].present?
      Event.safe_find_or_create_by!(attributes)
    else
      Event.create!(attributes)
    end
  end

  def parent_attrs(resource_parent)
    resource_parent_attr = case resource_parent
                           when Project
                             :project_id
                           when Group
                             :group_id
                           end

    return {} unless resource_parent_attr

    { resource_parent_attr => resource_parent.id }
  end

  def track_snowplow_event(action:, project:, user:, label:, property:)
    Gitlab::Tracking.event(
      self.class.to_s,
      action.to_s,
      label: label,
      namespace: project.namespace,
      user: user,
      project: project,
      property: property.to_s,
      context: [Gitlab::Tracking::ServicePingContext.new(data_source: :redis_hll, event: property.to_s).to_context]
    )
  end
end

EventCreateService.prepend_mod_with('EventCreateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe EventCreateService, :clean_gitlab_redis_cache, :clean_gitlab_redis_shared_state, feature_category: :service_ping do
  include SnowplowHelpers

  let(:service) { described_class.new }
  let(:dates) { { start_date: Date.today.beginning_of_week, end_date: Date.today.next_week } }

  let_it_be(:user, reload: true) { create :user }
  let_it_be(:project) { create(:project) }

  shared_examples 'it records the event in the event counter' do
    specify do
      tracking_params = { event_names: event_action, **dates }

      expect { subject }
        .to change { Gitlab::UsageDataCounters::HLLRedisCounter.unique_events(**tracking_params) }
        .by(1)
    end
  end

  shared_examples 'it records a git write event' do
    specify do
      tracking_params = { event_names: 'git_write_action', **dates }

      expect { subject }
        .to change { Gitlab::UsageDataCounters::HLLRedisCounter.unique_events(**tracking_params) }
        .by(1)
    end
  end

  describe 'Issues' do
    describe '#open_issue' do
      let(:issue) { create(:issue) }

      it { expect(service.open_issue(issue, issue.author)).to be_truthy }

      it ""creates new event"" do
        expect { service.open_issue(issue, issue.author) }.to change { Event.count }
      end
    end

    describe '#close_issue' do
      let(:issue) { create(:issue) }

      it { expect(service.close_issue(issue, issue.author)).to be_truthy }

      it ""creates new event"" do
        expect { service.close_issue(issue, issue.author) }.to change { Event.count }
      end
    end

    describe '#reopen_issue' do
      let(:issue) { create(:issue) }

      it { expect(service.reopen_issue(issue, issue.author)).to be_truthy }

      it ""creates new event"" do
        expect { service.reopen_issue(issue, issue.author) }.to change { Event.count }
      end
    end
  end

  describe 'Merge Requests', :snowplow do
    describe '#open_mr' do
      subject(:open_mr) { service.open_mr(merge_request, merge_request.author) }

      let(:merge_request) { create(:merge_request) }

      it { expect(open_mr).to be_truthy }

      it ""creates new event"" do
        expect { open_mr }.to change { Event.count }
      end

      it_behaves_like ""it records the event in the event counter"" do
        let(:event_action) { :merge_request_action }
      end

      it_behaves_like 'Snowplow event tracking with RedisHLL context' do
        let(:category) { described_class.name }
        let(:action) { 'created' }
        let(:label) {  described_class::MR_EVENT_LABEL }
        let(:namespace) { project.namespace }
        let(:project) { merge_request.project }
        let(:user) { merge_request.author }
        let(:property) { described_class::MR_EVENT_PROPERTY }
        let(:context) do
          [Gitlab::Tracking::ServicePingContext.new(data_source: :redis_hll, event: property).to_context]
        end
      end
    end

    describe '#close_mr' do
      subject(:close_mr) { service.close_mr(merge_request, merge_request.author) }

      let(:merge_request) { create(:merge_request) }

      it { expect(close_mr).to be_truthy }

      it ""creates new event"" do
        expect { close_mr }.to change { Event.count }
      end

      it_behaves_like ""it records the event in the event counter"" do
        let(:event_action) { :merge_request_action }
      end

      it_behaves_like 'Snowplow event tracking with RedisHLL context' do
        let(:category) { described_class.name }
        let(:action) { 'closed' }
        let(:label) {  described_class::MR_EVENT_LABEL }
        let(:namespace) { project.namespace }
        let(:project) { merge_request.project }
        let(:user) { merge_request.author }
        let(:property) { described_class::MR_EVENT_PROPERTY }
        let(:context) do
          [Gitlab::Tracking::ServicePingContext.new(data_source: :redis_hll, event: property).to_context]
        end
      end
    end

    describe '#merge_mr' do
      subject(:merge_mr) { service.merge_mr(merge_request, merge_request.author) }

      let(:merge_request) { create(:merge_request) }

      it { expect(merge_mr).to be_truthy }

      it ""creates new event"" do
        expect { merge_mr }.to change { Event.count }
      end

      it_behaves_like ""it records the event in the event counter"" do
        let(:event_action) { :merge_request_action }
      end

      it_behaves_like 'Snowplow event tracking with RedisHLL context' do
        let(:category) { described_class.name }
        let(:action) { 'merged' }
        let(:label) { described_class::MR_EVENT_LABEL }
        let(:namespace) { project.namespace }
        let(:project) { merge_request.project }
        let(:user) { merge_request.author }
        let(:property) { described_class::MR_EVENT_PROPERTY }
        let(:context) do
          [Gitlab::Tracking::ServicePingContext.new(data_source: :redis_hll, event: property).to_context]
        end
      end
    end

    describe '#reopen_mr' do
      let(:merge_request) { create(:merge_request) }

      it { expect(service.reopen_mr(merge_request, merge_request.author)).to be_truthy }

      it ""creates new event"" do
        expect { service.reopen_mr(merge_request, merge_request.author) }.to change { Event.count }
      end
    end

    describe '#approve_mr' do
      let(:merge_request) { create(:merge_request) }

      it { expect(service.approve_mr(merge_request, user)).to be_truthy }

      it 'creates new event' do
        service.approve_mr(merge_request, user)

        change { Event.approved_action.where(target: merge_request).count }.by(1)
      end
    end
  end

  describe 'Milestone' do
    describe '#open_milestone' do
      let(:milestone) { create(:milestone) }

      it { expect(service.open_milestone(milestone, user)).to be_truthy }

      it ""creates new event"" do
        expect { service.open_milestone(milestone, user) }.to change { Event.count }
      end
    end

    describe '#close_mr' do
      let(:milestone) { create(:milestone) }

      it { expect(service.close_milestone(milestone, user)).to be_truthy }

      it ""creates new event"" do
        expect { service.close_milestone(milestone, user) }.to change { Event.count }
      end
    end

    describe '#destroy_mr' do
      let(:milestone) { create(:milestone) }

      it { expect(service.destroy_milestone(milestone, user)).to be_truthy }

      it ""creates new event"" do
        expect { service.destroy_milestone(milestone, user) }.to change { Event.count }
      end
    end
  end

  shared_examples_for 'service for creating a push event' do |service_class|
    it 'creates a new event' do
      expect { subject }.to change { Event.count }
    end

    it 'creates the push event payload' do
      expect(service_class).to receive(:new)
        .with(an_instance_of(PushEvent), push_data)
        .and_call_original

      subject
    end

    it 'updates user last activity' do
      expect { subject }.to change { user.last_activity_on }.to(Date.today)
    end

    it 'caches the last push event for the user' do
      expect_next_instance_of(Users::LastPushEventService) do |instance|
        expect(instance).to receive(:cache_last_push_event).with(an_instance_of(PushEvent))
      end

      subject
    end

    it 'does not create any event data when an error is raised' do
      payload_service = double(:service)

      allow(payload_service).to receive(:execute)
        .and_raise(RuntimeError)

      allow(service_class).to receive(:new)
        .and_return(payload_service)

      expect { subject }.to raise_error(RuntimeError)
      expect(Event.count).to eq(0)
      expect(PushEventPayload.count).to eq(0)
    end
  end

  describe '#wiki_event' do
    let_it_be(:user) { create(:user) }
    let_it_be(:wiki_page) { create(:wiki_page) }
    let_it_be(:meta) { create(:wiki_page_meta, :for_wiki_page, wiki_page: wiki_page) }

    let(:fingerprint) { generate(:sha) }

    def create_event
      service.wiki_event(meta, user, action, fingerprint)
    end

    where(:action) { Event::WIKI_ACTIONS.map { |action| [action] } }

    with_them do
      subject { create_event }

      it 'creates the event' do
        expect(create_event).to have_attributes(
          wiki_page?: true,
          valid?: true,
          persisted?: true,
          action: action.to_s,
          wiki_page: wiki_page,
          author: user,
          fingerprint: fingerprint
        )
      end

      it 'is idempotent', :aggregate_failures do
        event = nil
        expect { event = create_event }.to change(Event, :count).by(1)
        duplicate = nil
        expect { duplicate = create_event }.not_to change(Event, :count)

        expect(duplicate).to eq(event)
      end

      it_behaves_like ""it records the event in the event counter"" do
        let(:event_action) { :wiki_action }
      end

      it_behaves_like ""it records a git write event""
    end

    (Event.actions.keys - Event::WIKI_ACTIONS).each do |bad_action|
      context ""The action is #{bad_action}"" do
        let(:action) { bad_action }

        it 'raises an error' do
          expect { create_event }.to raise_error(described_class::IllegalActionError)
        end
      end
    end
  end

  describe '#push', :snowplow do
    let(:push_data) do
      {
        commits: [
          {
            id: '1cf19a015df3523caf0a1f9d40c98a267d6a2fc2',
            message: 'This is a commit'
          }
        ],
        before: '0000000000000000000000000000000000000000',
        after: '1cf19a015df3523caf0a1f9d40c98a267d6a2fc2',
        total_commits_count: 1,
        ref: 'refs/heads/my-branch'
      }
    end

    subject { service.push(project, user, push_data) }

    it_behaves_like 'service for creating a push event', PushEventPayloadService

    it_behaves_like ""it records the event in the event counter"" do
      let(:event_action) { :project_action }
    end

    it_behaves_like ""it records a git write event""

    it_behaves_like 'Snowplow event tracking with RedisHLL context' do
      let(:category) { described_class.to_s }
      let(:action) { :push }
      let(:namespace) { project.namespace }
      let(:label) { 'usage_activity_by_stage_monthly.create.action_monthly_active_users_project_repo' }
      let(:property) { 'project_action' }
    end
  end

  describe '#bulk_push', :snowplow do
    let(:push_data) do
      {
        action: :created,
        ref_count: 4,
        ref_type: :branch
      }
    end

    subject { service.bulk_push(project, user, push_data) }

    it_behaves_like 'service for creating a push event', BulkPushEventPayloadService

    it_behaves_like ""it records the event in the event counter"" do
      let(:event_action) { :project_action }
    end

    it_behaves_like ""it records a git write event""

    it_behaves_like 'Snowplow event tracking with RedisHLL context' do
      let(:category) { described_class.to_s }
      let(:action) { :push }
      let(:namespace) { project.namespace }
      let(:label) { 'usage_activity_by_stage_monthly.create.action_monthly_active_users_project_repo' }
      let(:property) { 'project_action' }
    end
  end

  describe 'Project' do
    describe '#join_project' do
      subject { service.join_project(project, user) }

      it { is_expected.to be_truthy }
      it { expect { subject }.to change { Event.count }.from(0).to(1) }
    end

    describe '#expired_leave_project' do
      subject { service.expired_leave_project(project, user) }

      it { is_expected.to be_truthy }
      it { expect { subject }.to change { Event.count }.from(0).to(1) }
    end
  end

  describe 'design events', :snowplow do
    let_it_be(:design) { create(:design, project: project) }
    let_it_be(:author) { user }

    before do
      allow(Gitlab::Tracking).to receive(:event) # rubocop:disable RSpec/ExpectGitlabTracking
    end

    describe '#save_designs' do
      let_it_be(:updated) { create_list(:design, 5) }
      let_it_be(:created) { create_list(:design, 3) }

      subject(:result) { service.save_designs(author, create: created, update: updated) }

      specify { expect { result }.to change { Event.count }.by(8) }

      # An addditional query due to event tracking
      specify { expect { result }.not_to exceed_query_limit(2) }

      it 'creates 3 created design events' do
        ids = result.pluck('id')
        events = Event.created_action.where(id: ids)

        expect(events.map(&:design)).to match_array(created)
      end

      it 'creates 5 created design events' do
        ids = result.pluck('id')
        events = Event.updated_action.where(id: ids)

        expect(events.map(&:design)).to match_array(updated)
      end

      it_behaves_like ""it records the event in the event counter"" do
        let(:event_action) { :design_action }
      end

      it_behaves_like ""it records a git write event""

      describe 'Snowplow tracking' do
        let(:project) { design.project }
        let(:namespace) { project.namespace }
        let(:category) { described_class.name }
        let(:property) { :design_action.to_s }
        let(:label) { ::EventCreateService::DEGIGN_EVENT_LABEL }

        context 'for create event' do
          it_behaves_like 'Snowplow event tracking with RedisHLL context' do
            subject(:design_service) { service.save_designs(author, create: [design]) }

            let(:action) { 'create' }
          end
        end

        context 'for update event' do
          it_behaves_like 'Snowplow event tracking with RedisHLL context' do
            subject(:design_service) { service.save_designs(author, update: [design]) }

            let(:action) { 'update' }
          end
        end
      end
    end

    describe '#destroy_designs' do
      let_it_be(:designs) { create_list(:design, 5) }
      let_it_be(:author) { create(:user) }

      subject(:result) { service.destroy_designs(designs, author) }

      specify { expect { result }.to change { Event.count }.by(5) }

      # An addditional query due to event tracking
      specify { expect { result }.not_to exceed_query_limit(2) }

      it 'creates 5 destroyed design events' do
        ids = result.pluck('id')
        events = Event.destroyed_action.where(id: ids)

        expect(events.map(&:design)).to match_array(designs)
      end

      it_behaves_like ""it records the event in the event counter"" do
        let(:event_action) { :design_action }
      end

      it_behaves_like ""it records a git write event""

      it_behaves_like 'Snowplow event tracking with RedisHLL context' do
        subject(:design_service) { service.destroy_designs([design], author) }

        let(:project) { design.project }
        let(:namespace) { project.namespace }
        let(:category) { described_class.name }
        let(:action) { 'destroy' }
        let(:user) { author }
        let(:property) { :design_action.to_s }
        let(:label) { ::EventCreateService::DEGIGN_EVENT_LABEL }
      end
    end
  end

  describe '#leave_note', :snowplow do
    subject(:leave_note) { service.leave_note(note, author) }

    let(:note) { create(:note) }
    let(:author) { create(:user) }
    let(:event_action) { :merge_request_action }

    it { expect(leave_note).to be_truthy }

    it ""creates new event"" do
      expect { leave_note }.to change { Event.count }.by(1)
    end

    context 'when it is a diff note' do
      let(:note) { create(:diff_note_on_merge_request) }

      it_behaves_like ""it records the event in the event counter""

      it_behaves_like 'Snowplow event tracking with RedisHLL context' do
        let(:note) { create(:diff_note_on_merge_request) }
        let(:category) { described_class.name }
        let(:action) { 'commented' }
        let(:property) { described_class::MR_EVENT_PROPERTY }
        let(:label) { described_class::MR_EVENT_LABEL }
        let(:namespace) { project.namespace }
        let(:project) { note.project }
        let(:user) { author }
        let(:context) do
          [Gitlab::Tracking::ServicePingContext.new(data_source: :redis_hll, event: property).to_context]
        end
      end
    end

    context 'when it is not a diff note' do
      it 'does not change the unique action counter' do
        tracking_params = { event_names: event_action, start_date: Date.yesterday, end_date: Date.today }

        expect { subject }.not_to change { Gitlab::UsageDataCounters::HLLRedisCounter.unique_events(**tracking_params) }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class WebHookService
  class InternalErrorResponse
    ERROR_MESSAGE = 'internal error'

    attr_reader :body, :headers, :code

    def success?
      false
    end

    def redirection?
      false
    end

    def internal_server_error?
      true
    end

    def initialize
      @headers = Gitlab::HTTP::Response::Headers.new({})
      @body = ''
      @code = ERROR_MESSAGE
    end
  end

  REQUEST_BODY_SIZE_LIMIT = 25.megabytes
  # Response body is for UI display only. It does not make much sense to save
  # whatever the receivers throw back at us
  RESPONSE_BODY_SIZE_LIMIT = 8.kilobytes
  # The headers are for debugging purpose. They are displayed on the UI only.
  RESPONSE_HEADERS_COUNT_LIMIT = 50
  RESPONSE_HEADERS_SIZE_LIMIT = 1.kilobytes

  attr_accessor :hook, :data, :hook_name, :request_options
  attr_reader :uniqueness_token

  def self.hook_to_event(hook_name, hook = nil)
    return hook.class.name.titleize if hook.is_a?(SystemHook)

    hook_name.to_s.singularize.titleize
  end

  def initialize(hook, data, hook_name, uniqueness_token = nil, force: false)
    @hook = hook
    @data = data.to_h
    @hook_name = hook_name.to_s
    @uniqueness_token = uniqueness_token
    @force = force
    @request_options = {
      timeout: Gitlab.config.gitlab.webhook_timeout,
      allow_local_requests: hook.allow_local_requests?
    }
  end

  def disabled?
    !@force && !hook.executable?
  end

  def execute
    if Gitlab::SilentMode.enabled?
      log_silent_mode_enabled
      return ServiceResponse.error(message: 'Silent mode enabled')
    end

    return ServiceResponse.error(message: 'Hook disabled') if disabled?

    if recursion_blocked?
      log_recursion_blocked
      return ServiceResponse.error(message: 'Recursive webhook blocked')
    end

    Gitlab::WebHooks::RecursionDetection.register!(hook)

    start_time = Gitlab::Metrics::System.monotonic_time

    response = if parsed_url.userinfo.blank?
                 make_request(parsed_url.to_s)
               else
                 make_request_with_auth
               end

    log_execution(
      response: response,
      execution_duration: ::Gitlab::Metrics::System.monotonic_time - start_time
    )

    ServiceResponse.success(message: response.body, payload: { http_status: response.code })
  rescue *Gitlab::HTTP::HTTP_ERRORS,
         Gitlab::Json::LimitedEncoder::LimitExceeded, URI::InvalidURIError => e
    execution_duration = ::Gitlab::Metrics::System.monotonic_time - start_time
    error_message = e.to_s

    log_execution(
      response: InternalErrorResponse.new,
      execution_duration: execution_duration,
      error_message: error_message
    )

    Gitlab::AppLogger.error(""WebHook Error after #{execution_duration.to_i.seconds}s => #{e}"")

    ServiceResponse.error(message: error_message)
  end

  def async_execute
    Gitlab::ApplicationContext.with_context(hook.application_context) do
      break log_silent_mode_enabled if Gitlab::SilentMode.enabled?
      break log_rate_limited if rate_limit!
      break log_recursion_blocked if recursion_blocked?

      params = {
        ""recursion_detection_request_uuid"" => Gitlab::WebHooks::RecursionDetection::UUID.instance.request_uuid
      }.compact

      WebHookWorker.perform_async(hook.id, data.deep_stringify_keys, hook_name.to_s, params)
    end
  end

  private

  def parsed_url
    @parsed_url ||= URI.parse(hook.interpolated_url)
  rescue WebHook::InterpolationError => e
    # Behavior-preserving fallback.
    Gitlab::ErrorTracking.track_exception(e)
    @parsed_url = URI.parse(hook.url)
  end

  def make_request(url, basic_auth = false)
    Gitlab::HTTP.post(url,
      body: Gitlab::Json::LimitedEncoder.encode(data, limit: REQUEST_BODY_SIZE_LIMIT),
      headers: build_headers,
      verify: hook.enable_ssl_verification,
      basic_auth: basic_auth,
      **request_options)
  end

  def make_request_with_auth
    post_url = parsed_url.to_s.gsub(""#{parsed_url.userinfo}@"", '')
    basic_auth = {
      username: CGI.unescape(parsed_url.user),
      password: CGI.unescape(parsed_url.password.presence || '')
    }
    make_request(post_url, basic_auth)
  end

  def log_execution(response:, execution_duration:, error_message: nil)
    category = response_category(response)
    log_data = {
      trigger: hook_name,
      url: hook.url,
      interpolated_url: hook.interpolated_url,
      execution_duration: execution_duration,
      request_headers: build_headers,
      request_data: data,
      response_headers: safe_response_headers(response),
      response_body: safe_response_body(response),
      response_status: response.code,
      internal_error_message: error_message
    }

    if @force # executed as part of test - run log-execution inline.
      ::WebHooks::LogExecutionService.new(hook: hook, log_data: log_data, response_category: category).execute
    else
      queue_log_execution_with_retry(log_data, category)
    end
  end

  def queue_log_execution_with_retry(log_data, category)
    retried = false
    begin
      ::WebHooks::LogExecutionWorker.perform_async(
        hook.id, log_data.deep_stringify_keys, category.to_s, uniqueness_token.to_s
      )
    rescue Gitlab::SidekiqMiddleware::SizeLimiter::ExceedLimitError
      raise if retried

      # Strip request data
      log_data[:request_data] = ::WebHookLog::OVERSIZE_REQUEST_DATA
      retried = true
      retry
    end
  end

  def response_category(response)
    if response.success? || response.redirection?
      :ok
    elsif response.internal_server_error?
      :error
    else
      :failed
    end
  end

  def build_headers
    @headers ||= begin
      headers = {
        'Content-Type' => 'application/json',
        'User-Agent' => ""GitLab/#{Gitlab::VERSION}"",
        Gitlab::WebHooks::GITLAB_EVENT_HEADER => self.class.hook_to_event(hook_name, hook),
        Gitlab::WebHooks::GITLAB_UUID_HEADER => SecureRandom.uuid,
        Gitlab::WebHooks::GITLAB_INSTANCE_HEADER => Gitlab.config.gitlab.base_url
      }

      headers['X-Gitlab-Token'] = Gitlab::Utils.remove_line_breaks(hook.token) if hook.token.present?
      headers.merge!(Gitlab::WebHooks::RecursionDetection.header(hook))
    end
  end

  # Make response headers more stylish
  # Net::HTTPHeader has downcased hash with arrays: { 'content-type' => ['text/html; charset=utf-8'] }
  # This method format response to capitalized hash with strings: { 'Content-Type' => 'text/html; charset=utf-8' }
  # rubocop:disable Style/HashTransformValues
  def safe_response_headers(response)
    response.headers.each_capitalized.first(RESPONSE_HEADERS_COUNT_LIMIT).to_h do |header_key, header_value|
      [enforce_utf8(header_key), string_size_limit(enforce_utf8(header_value), RESPONSE_HEADERS_SIZE_LIMIT)]
    end
  end
  # rubocop:enable Style/HashTransformValues

  def safe_response_body(response)
    return '' unless response.body

    response_body = enforce_utf8(response.body)
    string_size_limit(response_body, RESPONSE_BODY_SIZE_LIMIT)
  end

  # Increments rate-limit counter.
  # Returns true if hook should be rate-limited.
  def rate_limit!
    Gitlab::WebHooks::RateLimiter.new(hook).rate_limit!
  end

  def recursion_blocked?
    Gitlab::WebHooks::RecursionDetection.block?(hook)
  end

  def log_rate_limited
    log_auth_error('Webhook rate limit exceeded')
  end

  def log_recursion_blocked
    log_auth_error(
      'Recursive webhook blocked from executing',
      recursion_detection: ::Gitlab::WebHooks::RecursionDetection.to_log(hook)
    )
  end

  def log_silent_mode_enabled
    log_auth_error('GitLab is in silent mode')
  end

  def log_auth_error(message, params = {})
    Gitlab::AuthLogger.error(
      params.merge(
        { message: message, hook_id: hook.id, hook_type: hook.type, hook_name: hook_name },
        Gitlab::ApplicationContext.current
      )
    )
  end

  def string_size_limit(str, limit)
    str.truncate_bytes(limit)
  end

  def enforce_utf8(str)
    Gitlab::EncodingHelper.encode_utf8(str)
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WebHookService, :request_store, :clean_gitlab_redis_shared_state, feature_category: :webhooks do
  include StubRequests

  let(:ellipsis) { '…' }
  let_it_be(:project) { create(:project) }
  let_it_be_with_reload(:project_hook) { create(:project_hook, project: project) }

  let(:data) do
    { before: 'oldrev', after: 'newrev', ref: 'ref' }
  end

  let(:serialized_data) { data.deep_stringify_keys }

  let(:service_instance) { described_class.new(project_hook, data, :push_hooks) }

  describe '#initialize' do
    before do
      stub_application_setting(setting_name => setting)
    end

    shared_examples_for 'respects outbound network setting' do
      context 'when local requests are allowed' do
        let(:setting) { true }

        it { expect(hook.request_options[:allow_local_requests]).to be_truthy }
      end

      context 'when local requests are not allowed' do
        let(:setting) { false }

        it { expect(hook.request_options[:allow_local_requests]).to be_falsey }
      end
    end

    context 'when SystemHook' do
      let(:setting_name) { :allow_local_requests_from_system_hooks }
      let(:hook) { described_class.new(build(:system_hook), data, :system_hook) }

      include_examples 'respects outbound network setting'
    end

    context 'when ProjectHook' do
      let(:setting_name) { :allow_local_requests_from_web_hooks_and_services }
      let(:hook) { described_class.new(build(:project_hook), data, :project_hook) }

      include_examples 'respects outbound network setting'
    end
  end

  describe '#disabled?' do
    using RSpec::Parameterized::TableSyntax

    subject { described_class.new(hook, data, :push_hooks, force: forced) }

    let(:hook) { double(executable?: executable, allow_local_requests?: false) }

    where(:forced, :executable, :disabled) do
      false | true | false
      false | false | true
      true | true | false
      true | false | false
    end

    with_them do
      it { is_expected.to have_attributes(disabled?: disabled) }
    end
  end

  describe '#execute' do
    let(:uuid) { SecureRandom.uuid }
    let!(:recursion_uuid) { SecureRandom.uuid }
    let(:headers) do
      {
        'Content-Type' => 'application/json',
        'User-Agent' => ""GitLab/#{Gitlab::VERSION}"",
        'X-Gitlab-Webhook-UUID' => uuid,
        'X-Gitlab-Event' => 'Push Hook',
        'X-Gitlab-Event-UUID' => recursion_uuid,
        'X-Gitlab-Instance' => Gitlab.config.gitlab.base_url
      }
    end

    before do
      # Set stable values for the `X-Gitlab-Webhook-UUID` and `X-Gitlab-Event-UUID` headers.
      allow(SecureRandom).to receive(:uuid).and_return(uuid)
      Gitlab::WebHooks::RecursionDetection.set_request_uuid(recursion_uuid)
    end

    context 'when there is an interpolation error' do
      let(:error) { ::WebHook::InterpolationError.new('boom') }

      before do
        stub_full_request(project_hook.url, method: :post)
        allow(project_hook).to receive(:interpolated_url).and_raise(error)
      end

      it 'logs the error' do
        expect(Gitlab::ErrorTracking).to receive(:track_exception).with(error)

        expect(service_instance).to receive(:log_execution).with(
          execution_duration: (be > 0),
          response: have_attributes(code: 200)
        )

        service_instance.execute
      end
    end

    context 'when there are URL variables' do
      before do
        project_hook.update!(
          url: 'http://example.com/{one}/{two}',
          url_variables: { 'one' => 'a', 'two' => 'b' }
        )
      end

      it 'POSTs to the interpolated URL, and logs the hook.url' do
        stub_full_request(project_hook.interpolated_url, method: :post)

        expect(service_instance).to receive(:queue_log_execution_with_retry).with(
          include(url: project_hook.url),
          :ok
        )

        service_instance.execute

        expect(WebMock)
          .to have_requested(:post, stubbed_hostname(project_hook.interpolated_url)).once
      end

      context 'there is userinfo' do
        before do
          project_hook.update!(
            url: 'http://{foo}:{bar}@example.com',
            url_variables: { 'foo' => 'a', 'bar' => 'b' }
          )
          stub_full_request('http://example.com', method: :post)
        end

        it 'POSTs to the interpolated URL, and logs the hook.url' do
          expect(service_instance).to receive(:queue_log_execution_with_retry).with(
            include(url: project_hook.url),
            :ok
          )

          service_instance.execute

          expect(WebMock)
            .to have_requested(:post, stubbed_hostname('http://example.com'))
            .with(headers: headers.merge('Authorization' => 'Basic YTpi'))
            .once
        end
      end
    end

    context 'when token is defined' do
      before do
        project_hook.token = generate(:token)
      end

      it 'POSTs to the webhook URL' do
        stub_full_request(project_hook.url, method: :post)

        service_instance.execute

        expect(WebMock).to have_requested(:post, stubbed_hostname(project_hook.url)).with(
          headers: headers.merge({ 'X-Gitlab-Token' => project_hook.token })
        ).once
      end
    end

    context 'with SystemHook' do
      let_it_be(:system_hook) { create(:system_hook) }
      let(:service_instance) { described_class.new(system_hook, data, :push_hooks) }

      before do
        stub_full_request(system_hook.url, method: :post)
      end

      it 'POSTs to the webhook URL with correct headers' do
        service_instance.execute

        expect(WebMock).to have_requested(:post, stubbed_hostname(system_hook.url)).with(
          headers: headers.merge({ 'X-Gitlab-Event' => 'System Hook' })
        ).once
      end
    end

    it 'POSTs the data as JSON and returns expected headers' do
      stub_full_request(project_hook.url, method: :post)

      service_instance.execute

      expect(WebMock).to have_requested(:post, stubbed_hostname(project_hook.url)).with(
        headers: headers
      ).once
    end

    context 'when the data is a Gitlab::DataBuilder::Pipeline' do
      let(:pipeline) { create(:ci_pipeline, project: project) }
      let(:data) { ::Gitlab::DataBuilder::Pipeline.new(pipeline) }

      it 'can log the request payload' do
        stub_full_request(project_hook.url, method: :post)

        # we call this with force to ensure that the logs are written inline,
        # which tests that we can serialize the data to the DB correctly.
        service = described_class.new(project_hook, data, :push_hooks, force: true)

        expect { service.execute }.to change(::WebHookLog, :count).by(1)
      end
    end

    context 'when auth credentials are present' do
      let_it_be(:url) { 'https://example.org' }
      let_it_be(:project_hook) { create(:project_hook, url: 'https://demo:demo@example.org/') }

      it 'uses the credentials' do
        stub_full_request(url, method: :post)

        service_instance.execute

        expect(WebMock).to have_requested(:post, stubbed_hostname(url)).with(
          headers: headers.merge('Authorization' => 'Basic ZGVtbzpkZW1v')
        ).once
      end
    end

    context 'when auth credentials are partial present' do
      let_it_be(:url) { 'https://example.org' }
      let_it_be(:project_hook) { create(:project_hook, url: 'https://demo@example.org/') }

      it 'uses the credentials anyways' do
        stub_full_request(url, method: :post)

        service_instance.execute

        expect(WebMock).to have_requested(:post, stubbed_hostname(url)).with(
          headers: headers.merge('Authorization' => 'Basic ZGVtbzo=')
        ).once
      end
    end

    it 'catches exceptions' do
      stub_full_request(project_hook.url, method: :post).to_raise(StandardError.new('Some error'))

      expect { service_instance.execute }.to raise_error(StandardError)
    end

    it 'does not execute disabled hooks' do
      allow(service_instance).to receive(:disabled?).and_return(true)

      expect(service_instance.execute).to have_attributes(status: :error, message: 'Hook disabled')
    end

    it 'executes and registers the hook with the recursion detection', :aggregate_failures do
      stub_full_request(project_hook.url, method: :post)
      cache_key = Gitlab::WebHooks::RecursionDetection.send(:cache_key_for_hook, project_hook)

      ::Gitlab::Redis::SharedState.with do |redis|
        expect { service_instance.execute }.to change {
          redis.sismember(cache_key, project_hook.id)
        }.to(true)
      end

      expect(WebMock).to have_requested(:post, stubbed_hostname(project_hook.url))
        .with(headers: headers)
        .once
    end

    it 'blocks and logs if a recursive web hook is detected', :aggregate_failures do
      stub_full_request(project_hook.url, method: :post)
      Gitlab::WebHooks::RecursionDetection.register!(project_hook)

      expect(Gitlab::AuthLogger).to receive(:error).with(
        include(
          message: 'Recursive webhook blocked from executing',
          hook_id: project_hook.id,
          hook_type: 'ProjectHook',
          hook_name: 'push_hooks',
          recursion_detection: Gitlab::WebHooks::RecursionDetection.to_log(project_hook),
          'correlation_id' => kind_of(String)
        )
      )

      service_instance.execute

      expect(WebMock).not_to have_requested(:post, stubbed_hostname(project_hook.url))
    end

    it 'blocks and logs if the recursion count limit would be exceeded', :aggregate_failures do
      stub_full_request(project_hook.url, method: :post)
      stub_const(""#{Gitlab::WebHooks::RecursionDetection.name}::COUNT_LIMIT"", 3)
      previous_hooks = create_list(:project_hook, 3)
      previous_hooks.each { Gitlab::WebHooks::RecursionDetection.register!(_1) }

      expect(Gitlab::AuthLogger).to receive(:error).with(
        include(
          message: 'Recursive webhook blocked from executing',
          hook_id: project_hook.id,
          hook_type: 'ProjectHook',
          hook_name: 'push_hooks',
          recursion_detection: Gitlab::WebHooks::RecursionDetection.to_log(project_hook),
          'correlation_id' => kind_of(String)
        )
      )

      service_instance.execute

      expect(WebMock).not_to have_requested(:post, stubbed_hostname(project_hook.url))
    end

    context 'when silent mode is enabled' do
      before do
        stub_application_setting(silent_mode_enabled: true)
      end

      it 'blocks and logs an error' do
        stub_full_request(project_hook.url, method: :post)

        expect(Gitlab::AuthLogger).to receive(:error).with(include(message: 'GitLab is in silent mode'))
        expect(service_instance.execute).to be_error
        expect(WebMock).not_to have_requested(:post, stubbed_hostname(project_hook.url))
      end
    end

    it 'handles exceptions' do
      exceptions = Gitlab::HTTP::HTTP_ERRORS + [
        Gitlab::Json::LimitedEncoder::LimitExceeded, URI::InvalidURIError
      ]

      allow(Gitlab::WebHooks::RecursionDetection).to receive(:block?).and_return(false)

      exceptions.each do |exception_class|
        exception = exception_class.new('Exception message')
        project_hook.enable!

        stub_full_request(project_hook.url, method: :post).to_raise(exception)

        expect(service_instance.execute).to have_attributes(status: :error, message: exception.to_s)
        expect { service_instance.execute }.not_to raise_error
      end
    end

    context 'when url is not encoded' do
      let_it_be(:project_hook) { create(:project_hook, url: 'http://server.com/my path/') }

      it 'handles exceptions' do
        expect(service_instance.execute).to have_attributes(
          status: :error,
          message: 'bad URI(is not URI?): ""http://server.com/my path/""'
        )
        expect { service_instance.execute }.not_to raise_error
      end
    end

    context 'when request body size is too big' do
      it 'does not perform the request' do
        stub_const(""#{described_class}::REQUEST_BODY_SIZE_LIMIT"", 10.bytes)

        expect(service_instance.execute).to have_attributes(
          status: :error,
          message: 'Gitlab::Json::LimitedEncoder::LimitExceeded'
        )
      end
    end

    it 'handles 200 status code' do
      stub_full_request(project_hook.url, method: :post).to_return(status: 200, body: 'Success')

      expect(service_instance.execute).to have_attributes(
        status: :success,
        payload: { http_status: 200 },
        message: 'Success'
      )
    end

    it 'handles 2xx status codes' do
      stub_full_request(project_hook.url, method: :post).to_return(status: 201, body: 'Success')

      expect(service_instance.execute).to have_attributes(
        status: :success,
        payload: { http_status: 201 },
        message: 'Success'
      )
    end

    context 'execution logging' do
      let(:default_log_data) do
        {
          trigger: 'push_hooks',
          url: project_hook.url,
          interpolated_url: project_hook.interpolated_url,
          request_headers: headers,
          request_data: data,
          response_body: 'Success',
          response_headers: {},
          response_status: 200,
          execution_duration: be > 0,
          internal_error_message: nil
        }
      end

      context 'with success' do
        before do
          stub_full_request(project_hook.url, method: :post).to_return(status: 200, body: 'Success')
        end

        context 'when forced' do
          let(:service_instance) { described_class.new(project_hook, data, :push_hooks, force: true) }

          it 'logs execution inline' do
            expect(::WebHooks::LogExecutionWorker).not_to receive(:perform_async)
            expect(::WebHooks::LogExecutionService)
              .to receive(:new)
              .with(hook: project_hook, log_data: default_log_data, response_category: :ok)
              .and_return(double(execute: nil))

            service_instance.execute
          end
        end

        it 'queues LogExecutionWorker correctly' do
          expect(WebHooks::LogExecutionWorker).to receive(:perform_async)
            .with(
              project_hook.id,
              hash_including(default_log_data.deep_stringify_keys),
              'ok',
              ''
            )

          service_instance.execute
        end

        it 'queues LogExecutionWorker correctly, resulting in a log record (integration-style test)', :sidekiq_inline do
          expect { service_instance.execute }.to change(::WebHookLog, :count).by(1)
        end

        it 'does not log in the service itself' do
          expect { service_instance.execute }.not_to change(::WebHookLog, :count)
        end
      end

      context 'with bad request' do
        before do
          stub_full_request(project_hook.url, method: :post).to_return(status: 400, body: 'Bad request')
        end

        it 'queues LogExecutionWorker correctly' do
          expect(WebHooks::LogExecutionWorker).to receive(:perform_async)
            .with(
              project_hook.id,
              hash_including(
                default_log_data.merge(
                  response_body: 'Bad request',
                  response_status: 400
                ).deep_stringify_keys
              ),
              'failed',
              ''
            )

          service_instance.execute
        end
      end

      context 'with exception' do
        before do
          stub_full_request(project_hook.url, method: :post).to_raise(SocketError.new('Some HTTP Post error'))
        end

        it 'queues LogExecutionWorker correctly' do
          expect(WebHooks::LogExecutionWorker).to receive(:perform_async)
            .with(
              project_hook.id,
              hash_including(
                default_log_data.merge(
                  response_body: '',
                  response_status: 'internal error',
                  internal_error_message: 'Some HTTP Post error'
                ).deep_stringify_keys
              ),
              'error',
              ''
            )

          service_instance.execute
        end
      end

      context 'with unsafe response body' do
        before do
          stub_full_request(project_hook.url, method: :post).to_return(status: 200, body: ""\xBB"")
        end

        it 'queues LogExecutionWorker with sanitized response_body' do
          expect(WebHooks::LogExecutionWorker).to receive(:perform_async)
            .with(
              project_hook.id,
              hash_including(default_log_data.merge(response_body: '').deep_stringify_keys),
              'ok',
              ''
            )

          service_instance.execute
        end
      end

      context 'with oversize response body' do
        let(:oversize_body) { 'a' * (described_class::RESPONSE_BODY_SIZE_LIMIT + 1) }
        let(:stripped_body) { 'a' * (described_class::RESPONSE_BODY_SIZE_LIMIT - ellipsis.bytesize) + ellipsis }

        before do
          stub_full_request(project_hook.url, method: :post).to_return(status: 200, body: oversize_body)
        end

        it 'queues LogExecutionWorker with stripped response_body' do
          expect(WebHooks::LogExecutionWorker).to receive(:perform_async)
            .with(
              project_hook.id,
              hash_including(default_log_data.merge(response_body: stripped_body).deep_stringify_keys),
              'ok',
              ''
            )

          service_instance.execute
        end
      end

      context 'with massive amount of headers' do
        let(:response_headers) do
          (1..described_class::RESPONSE_HEADERS_COUNT_LIMIT + 1).to_a.to_h do |num|
            [""header-#{num}"", SecureRandom.hex(num)]
          end
        end

        let(:expected_response_headers) do
          (1..described_class::RESPONSE_HEADERS_COUNT_LIMIT).to_a.to_h do |num|
            # Capitalized
            [""Header-#{num}"", response_headers[""header-#{num}""]]
          end
        end

        before do
          stub_full_request(project_hook.url, method: :post).to_return(
            status: 200, body: 'Success', headers: response_headers
          )
        end

        it 'queues LogExecutionWorker with limited amount of headers' do
          expect(WebHooks::LogExecutionWorker).to receive(:perform_async)
            .with(
              project_hook.id,
              hash_including(default_log_data.merge(response_headers: expected_response_headers).deep_stringify_keys),
              'ok',
              ''
            )

          service_instance.execute
        end
      end

      context 'with oversize header' do
        let(:oversize_header) { 'a' * (described_class::RESPONSE_HEADERS_SIZE_LIMIT + 1) }
        let(:stripped_header) { 'a' * (described_class::RESPONSE_HEADERS_SIZE_LIMIT - ellipsis.bytesize) + ellipsis }
        let(:response_headers) { { 'oversized-header' => oversize_header } }
        let(:expected_response_headers) { { 'Oversized-Header' => stripped_header } }

        before do
          stub_full_request(project_hook.url, method: :post).to_return(
            status: 200, body: 'Success', headers: response_headers
          )
        end

        it 'queues LogExecutionWorker with stripped header value' do
          expect(WebHooks::LogExecutionWorker).to receive(:perform_async)
            .with(
              project_hook.id,
              hash_including(default_log_data.merge(response_headers: expected_response_headers).deep_stringify_keys),
              'ok',
              ''
            )

          service_instance.execute
        end
      end

      context 'with log data exceeding Sidekiq limit' do
        before do
          stub_full_request(project_hook.url, method: :post).to_return(status: 200, body: 'Success')
        end

        it 'queues LogExecutionWorker with request_data overrided in the second attempt' do
          expect(WebHooks::LogExecutionWorker).to receive(:perform_async)
            .with(
              project_hook.id,
              hash_including(default_log_data.deep_stringify_keys),
              'ok',
              ''
            )
            .and_raise(
              Gitlab::SidekiqMiddleware::SizeLimiter::ExceedLimitError.new(WebHooks::LogExecutionWorker, 100, 50)
            )
            .ordered
          expect(WebHooks::LogExecutionWorker).to receive(:perform_async)
            .with(
              project_hook.id,
              hash_including(default_log_data.merge(
                request_data: WebHookLog::OVERSIZE_REQUEST_DATA
              ).deep_stringify_keys),
              'ok',
              ''
            )
            .and_call_original
            .ordered

          service_instance.execute
        end

        context 'new log data still exceeds limit' do
          before do
            allow(WebHooks::LogExecutionWorker).to receive(:perform_async).and_raise(
              Gitlab::SidekiqMiddleware::SizeLimiter::ExceedLimitError.new(WebHooks::LogExecutionWorker, 100, 50)
            )
          end

          it 'raises an exception' do
            expect do
              service_instance.execute
            end.to raise_error(Gitlab::SidekiqMiddleware::SizeLimiter::ExceedLimitError)
          end
        end
      end
    end
  end

  describe '#async_execute' do
    def expect_to_perform_worker(hook)
      expect(WebHookWorker).to receive(:perform_async).with(
        hook.id, serialized_data, 'push_hooks', an_instance_of(Hash)
      )
    end

    def expect_to_rate_limit(hook, threshold:, throttled: false)
      expect(Gitlab::ApplicationRateLimiter).to receive(:throttled?)
        .with(:web_hook_calls, scope: [hook.parent.root_namespace], threshold: threshold)
        .and_return(throttled)
    end

    context 'when rate limiting is not configured' do
      it 'queues a worker without tracking the call' do
        expect(Gitlab::ApplicationRateLimiter).not_to receive(:throttled?)
        expect_to_perform_worker(project_hook)

        service_instance.async_execute
      end
    end

    context 'when rate limiting is configured' do
      let_it_be(:threshold) { 3 }
      let_it_be(:plan_limits) { create(:plan_limits, :default_plan, web_hook_calls: threshold) }

      it 'queues a worker and tracks the call' do
        expect_to_rate_limit(project_hook, threshold: threshold)
        expect_to_perform_worker(project_hook)

        service_instance.async_execute
      end

      context 'when the hook is throttled (via mock)' do
        before do
          expect_to_rate_limit(project_hook, threshold: threshold, throttled: true)
        end

        it 'does not queue a worker and logs an error' do
          expect(WebHookWorker).not_to receive(:perform_async)

          expect(Gitlab::AuthLogger).to receive(:error).with(
            include(
              message: 'Webhook rate limit exceeded',
              hook_id: project_hook.id,
              hook_type: 'ProjectHook',
              hook_name: 'push_hooks',
              ""correlation_id"" => kind_of(String),
              ""meta.project"" => project.full_path,
              ""meta.related_class"" => 'ProjectHook',
              ""meta.root_namespace"" => project.root_namespace.full_path
            )
          )

          service_instance.async_execute
        end
      end

      context 'when the hook is throttled (via Redis)', :clean_gitlab_redis_rate_limiting, :freeze_time do
        before do
          expect_to_perform_worker(project_hook).exactly(threshold).times

          threshold.times { service_instance.async_execute }
        end

        it 'stops queueing workers and logs errors' do
          expect(Gitlab::AuthLogger).to receive(:error).twice

          2.times { service_instance.async_execute }
        end

        it 'still queues workers for other hooks' do
          other_hook = create(:project_hook)

          expect_to_perform_worker(other_hook)

          described_class.new(other_hook, data, :push_hooks).async_execute
        end
      end
    end

    context 'recursion detection' do
      before do
        # Set a request UUID so `RecursionDetection.block?` will query redis.
        Gitlab::WebHooks::RecursionDetection.set_request_uuid(SecureRandom.uuid)
      end

      it 'does not queue a worker and logs an error if the call chain limit would be exceeded' do
        stub_const(""#{Gitlab::WebHooks::RecursionDetection.name}::COUNT_LIMIT"", 3)
        previous_hooks = create_list(:project_hook, 3)
        previous_hooks.each { Gitlab::WebHooks::RecursionDetection.register!(_1) }

        expect(WebHookWorker).not_to receive(:perform_async)
        expect(Gitlab::AuthLogger).to receive(:error).with(
          include(
            message: 'Recursive webhook blocked from executing',
            hook_id: project_hook.id,
            hook_type: 'ProjectHook',
            hook_name: 'push_hooks',
            recursion_detection: Gitlab::WebHooks::RecursionDetection.to_log(project_hook),
            'correlation_id' => kind_of(String),
            'meta.project' => project.full_path,
            'meta.related_class' => 'ProjectHook',
            'meta.root_namespace' => project.root_namespace.full_path
          )
        )

        service_instance.async_execute
      end

      it 'does not queue a worker and logs an error if a recursive call chain is detected' do
        Gitlab::WebHooks::RecursionDetection.register!(project_hook)

        expect(WebHookWorker).not_to receive(:perform_async)
        expect(Gitlab::AuthLogger).to receive(:error).with(
          include(
            message: 'Recursive webhook blocked from executing',
            hook_id: project_hook.id,
            hook_type: 'ProjectHook',
            hook_name: 'push_hooks',
            recursion_detection: Gitlab::WebHooks::RecursionDetection.to_log(project_hook),
            'correlation_id' => kind_of(String),
            'meta.project' => project.full_path,
            'meta.related_class' => 'ProjectHook',
            'meta.root_namespace' => project.root_namespace.full_path
          )
        )

        service_instance.async_execute
      end
    end

    context 'when silent mode is enabled' do
      before do
        stub_application_setting(silent_mode_enabled: true)
      end

      it 'does not queue a worker and logs an error' do
        expect(WebHookWorker).not_to receive(:perform_async)
        expect(Gitlab::AuthLogger).to receive(:error).with(include(message: 'GitLab is in silent mode'))

        service_instance.async_execute
      end
    end

    context 'when hook has custom context attributes' do
      it 'includes the attributes in the worker context' do
        expect(WebHookWorker).to receive(:perform_async) do
          expect(Gitlab::ApplicationContext.current).to include(
            'meta.project' => project_hook.project.full_path,
            'meta.root_namespace' => project.root_ancestor.path,
            'meta.related_class' => 'ProjectHook'
          )
        end

        service_instance.async_execute
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class CohortsService
  MONTHS_INCLUDED = 12

  def execute
    {
      months_included: MONTHS_INCLUDED,
      cohorts: cohorts
    }
  end

  # Get an array of hashes that looks like:
  #
  #     [
  #       {
  #         registration_month: Date.new(2017, 3),
  #         activity_months: [3, 2, 1],
  #         total: 3
  #         inactive: 0
  #      },
  #      etc.
  #
  # The `months` array is always from oldest to newest, so it's always
  # non-strictly decreasing from left to right.
  def cohorts
    months = Array.new(MONTHS_INCLUDED) { |i| i.months.ago.beginning_of_month.to_date }

    Array.new(MONTHS_INCLUDED) do
      registration_month = months.last
      activity_months = running_totals(months, registration_month)

      # Even if no users registered in this month, we always want to have a
      # value to fill in the table.
      inactive = counts_by_month[[registration_month, nil]].to_i

      months.pop

      {
        registration_month: registration_month,
        activity_months: activity_months[1..],
        total: activity_months.first[:total],
        inactive: inactive
      }
    end
  end

  private

  # Calculate a running sum of active users, so users active in later months
  # count as active in this month, too. Start with the most recent month first,
  # for calculating the running totals, and then reverse for displaying in the
  # table.
  #
  # Each month has a total, and a percentage of the overall total, as keys.
  def running_totals(all_months, registration_month)
    month_totals =
      all_months
        .map { |activity_month| counts_by_month[[registration_month, activity_month]] }
        .reduce([]) { |result, total| result << result.last.to_i + total.to_i }
        .reverse

    overall_total = month_totals.first

    month_totals.map do |total|
      { total: total, percentage: total == 0 ? 0 : 100 * total / overall_total }
    end
  end

  # Get a hash that looks like:
  #
  #     {
  #       [created_at_month, last_activity_on_month] => count,
  #       [created_at_month, last_activity_on_month_2] => count_2,
  #       # etc.
  #     }
  #
  # created_at_month can never be nil, but last_activity_on_month can (when a
  # user has never logged in, just been created). This covers the last
  # MONTHS_INCLUDED months.
  # rubocop: disable CodeReuse/ActiveRecord
  def counts_by_month
    @counts_by_month ||=
      begin
        created_at_month = column_to_date('created_at')
        last_activity_on_month = column_to_date('last_activity_on')

        User
          .where('created_at > ?', MONTHS_INCLUDED.months.ago.end_of_month)
          .group(created_at_month, last_activity_on_month)
          .reorder(Arel.sql(""#{created_at_month} ASC, #{last_activity_on_month} ASC""))
          .count
      end
  end
  # rubocop: enable CodeReuse/ActiveRecord

  def column_to_date(column)
    ""CAST(DATE_TRUNC('month', #{column}) AS date)""
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe CohortsService, feature_category: :shared do
  describe '#execute' do
    def month_start(months_ago)
      months_ago.months.ago.beginning_of_month.to_date
    end

    # In the interests of speed and clarity, this example has minimal data.
    it 'returns a list of user cohorts' do
      6.times do |months_ago|
        months_ago_time = (months_ago * 2).months.ago

        create(:user, created_at: months_ago_time, last_activity_on: Time.current)
        create(:user, created_at: months_ago_time, last_activity_on: months_ago_time)
      end

      create(:user) # this user is inactive and belongs to the current month

      expected_cohorts = [
        {
          registration_month: month_start(11),
          activity_months: Array.new(11) { { total: 0, percentage: 0 } },
          total: 0,
          inactive: 0
        },
        {
          registration_month: month_start(10),
          activity_months: Array.new(10) { { total: 1, percentage: 50 } },
          total: 2,
          inactive: 0
        },
        {
          registration_month: month_start(9),
          activity_months: Array.new(9) { { total: 0, percentage: 0 } },
          total: 0,
          inactive: 0
        },
        {
          registration_month: month_start(8),
          activity_months: Array.new(8) { { total: 1, percentage: 50 } },
          total: 2,
          inactive: 0
        },
        {
          registration_month: month_start(7),
          activity_months: Array.new(7) { { total: 0, percentage: 0 } },
          total: 0,
          inactive: 0
        },
        {
          registration_month: month_start(6),
          activity_months: Array.new(6) { { total: 1, percentage: 50 } },
          total: 2,
          inactive: 0
        },
        {
          registration_month: month_start(5),
          activity_months: Array.new(5) { { total: 0, percentage: 0 } },
          total: 0,
          inactive: 0
        },
        {
          registration_month: month_start(4),
          activity_months: Array.new(4) { { total: 1, percentage: 50 } },
          total: 2,
          inactive: 0
        },
        {
          registration_month: month_start(3),
          activity_months: Array.new(3) { { total: 0, percentage: 0 } },
          total: 0,
          inactive: 0
        },
        {
          registration_month: month_start(2),
          activity_months: Array.new(2) { { total: 1, percentage: 50 } },
          total: 2,
          inactive: 0
        },
        {
          registration_month: month_start(1),
          activity_months: Array.new(1) { { total: 0, percentage: 0 } },
          total: 0,
          inactive: 0
        },
        {
          registration_month: month_start(0),
          activity_months: [],
          total: 2,
          inactive: 1
        }
      ]

      expect(described_class.new.execute).to eq(months_included: 12, cohorts: expected_cohorts)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class UserProjectAccessChangedService
  DELAY = 1.hour
  MEDIUM_DELAY = 10.minutes

  HIGH_PRIORITY = :high
  MEDIUM_PRIORITY = :medium
  LOW_PRIORITY = :low

  def initialize(user_ids)
    @user_ids = Array.wrap(user_ids)
  end

  def execute(priority: HIGH_PRIORITY)
    return if @user_ids.empty?

    bulk_args = @user_ids.map { |id| [id] }

    result =
      case priority
      when HIGH_PRIORITY
        AuthorizedProjectsWorker.bulk_perform_async(bulk_args) # rubocop:disable Scalability/BulkPerformWithContext
      when MEDIUM_PRIORITY
        AuthorizedProjectUpdate::UserRefreshWithLowUrgencyWorker.bulk_perform_in(MEDIUM_DELAY, bulk_args, batch_size: 100, batch_delay: 30.seconds) # rubocop:disable Scalability/BulkPerformWithContext
      when LOW_PRIORITY
        if Feature.disabled?(:do_not_run_safety_net_auth_refresh_jobs)
          with_related_class_context do
            # We wrap the execution in `with_related_class_context`so as to obtain
            # the location of the original caller
            # in jobs enqueued from within `AuthorizedProjectUpdate::UserRefreshFromReplicaWorker`
            AuthorizedProjectUpdate::UserRefreshFromReplicaWorker.bulk_perform_in( # rubocop:disable Scalability/BulkPerformWithContext
              DELAY, bulk_args, batch_size: 100, batch_delay: 30.seconds)
          end
        end
      end

    ::User.sticking.bulk_stick(:user, @user_ids)

    result
  end

  private

  def with_related_class_context(&block)
    current_caller_id = Gitlab::ApplicationContext.current_context_attribute('meta.caller_id').presence
    Gitlab::ApplicationContext.with_context(related_class: current_caller_id, &block)
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe UserProjectAccessChangedService, feature_category: :system_access do
  describe '#execute' do
    it 'permits high-priority operation' do
      expect(AuthorizedProjectsWorker).to receive(:bulk_perform_async)
        .with([[1], [2]])

      described_class.new([1, 2]).execute
    end

    context 'for low priority operation' do
      context 'when the feature flag `do_not_run_safety_net_auth_refresh_jobs` is disabled' do
        before do
          stub_feature_flags(do_not_run_safety_net_auth_refresh_jobs: false)
        end

        it 'permits low-priority operation' do
          expect(AuthorizedProjectUpdate::UserRefreshFromReplicaWorker).to(
            receive(:bulk_perform_in).with(
              described_class::DELAY,
              [[1], [2]],
              { batch_delay: 30.seconds, batch_size: 100 }
            )
          )

          described_class.new([1, 2]).execute(priority: described_class::LOW_PRIORITY)
        end
      end

      it 'does not perform low-priority operation' do
        expect(AuthorizedProjectUpdate::UserRefreshFromReplicaWorker).not_to receive(:bulk_perform_in)

        described_class.new([1, 2]).execute(priority: described_class::LOW_PRIORITY)
      end
    end

    it 'permits medium-priority operation' do
      expect(AuthorizedProjectUpdate::UserRefreshWithLowUrgencyWorker).to(
        receive(:bulk_perform_in).with(
          described_class::MEDIUM_DELAY,
          [[1], [2]],
          { batch_delay: 30.seconds, batch_size: 100 }
        )
      )

      described_class.new([1, 2]).execute(priority: described_class::MEDIUM_PRIORITY)
    end

    it 'sets the current caller_id as related_class in the context of all the enqueued jobs' do
      Gitlab::ApplicationContext.with_context(caller_id: 'Foo') do
        described_class.new([1, 2]).execute(priority: described_class::LOW_PRIORITY)
      end

      expect(AuthorizedProjectUpdate::UserRefreshFromReplicaWorker.jobs).to all(
        include(Labkit::Context.log_key(:related_class) => 'Foo')
      )
    end
  end

  context 'with load balancing enabled' do
    let(:service) { described_class.new([1, 2]) }

    before do
      expect(AuthorizedProjectsWorker).to receive(:bulk_perform_async)
                                            .with([[1], [2]])
                                            .and_return(10)
    end

    it 'sticks all the updated users and returns the original result', :aggregate_failures do
      expect(ApplicationRecord.sticking).to receive(:bulk_stick).with(:user, [1, 2])

      expect(service.execute).to eq(10)
    end

    it 'avoids N+1 cached queries', :use_sql_query_cache, :request_store do
      # Run this once to establish a baseline
      control_count = ActiveRecord::QueryRecorder.new(skip_cached: false) do
        service.execute
      end

      service = described_class.new([1, 2, 3, 4, 5])

      allow(AuthorizedProjectsWorker).to receive(:bulk_perform_async)
                                            .with([[1], [2], [3], [4], [5]])
                                            .and_return(10)

      expect { service.execute }.not_to exceed_all_query_limit(control_count.count)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# rubocop:disable GitlabSecurity/PublicSend

# NotificationService class
#
# Used for notifying users with emails about different events
#
# Ex.
#   NotificationService.new.new_issue(issue, current_user)
#
# When calculating the recipients of a notification is expensive (for instance,
# in the new issue case), `#async` will make that calculation happen in Sidekiq
# instead:
#
#   NotificationService.new.async.new_issue(issue, current_user)
#
class NotificationService
  # These should not be called by the MailScheduler::NotificationServiceWorker -
  # what would it even mean?
  EXCLUDED_ACTIONS = %i[async].freeze

  def self.permitted_actions
    @permitted_actions ||= gitlab_extensions.flat_map do |klass|
      klass.public_instance_methods(false) - EXCLUDED_ACTIONS
    end.to_set
  end

  class Async
    attr_reader :parent

    delegate :respond_to_missing, to: :parent

    def initialize(parent)
      @parent = parent
    end

    def method_missing(meth, *args)
      return super unless parent.respond_to?(meth)

      MailScheduler::NotificationServiceWorker.perform_async(meth.to_s, *args)
    end
  end

  def async
    @async ||= Async.new(self)
  end

  def disabled_two_factor(user)
    return unless user.can?(:receive_notifications)

    mailer.disabled_two_factor_email(user).deliver_later
  end

  # Always notify user about ssh key added
  # only if ssh key is not deploy key
  #
  # This is security email so it will be sent
  # even if user disabled notifications. However,
  # it won't be sent to internal users like the
  # ghost user or the EE support bot.
  def new_key(key)
    if key.user&.can?(:receive_notifications)
      mailer.new_ssh_key_email(key.id).deliver_later
    end
  end

  # Always notify the user about gpg key added
  #
  # This is a security email so it will be sent even if the user disabled
  # notifications
  def new_gpg_key(gpg_key)
    if gpg_key.user&.can?(:receive_notifications)
      mailer.new_gpg_key_email(gpg_key.id).deliver_later
    end
  end

  def resource_access_tokens_about_to_expire(bot_user, token_names)
    recipients = bot_user.resource_bot_owners.select { |owner| owner.can?(:receive_notifications) }
    resource = bot_user.resource_bot_resource

    recipients.each do |recipient|
      mailer.resource_access_tokens_about_to_expire_email(
        recipient,
        resource,
        token_names
      ).deliver_later
    end
  end

  # Notify the owner of the account when a new personal access token is created
  def access_token_created(user, token_name)
    return unless user.can?(:receive_notifications)

    mailer.access_token_created_email(user, token_name).deliver_later
  end

  # Notify the owner of the personal access token, when it is about to expire
  # And mark the token with about_to_expire_delivered
  def access_token_about_to_expire(user, token_names)
    return unless user.can?(:receive_notifications)

    mailer.access_token_about_to_expire_email(user, token_names).deliver_later
  end

  # Notify the user when at least one of their personal access tokens has expired today
  def access_token_expired(user, token_names = [])
    return unless user.can?(:receive_notifications)

    mailer.access_token_expired_email(user, token_names).deliver_later
  end

  # Notify the user when one of their personal access tokens is revoked
  def access_token_revoked(user, token_name, source = nil)
    return unless user.can?(:receive_notifications)

    mailer.access_token_revoked_email(user, token_name, source).deliver_later
  end

  # Notify the user when at least one of their ssh key has expired today
  def ssh_key_expired(user, fingerprints)
    return unless user.can?(:receive_notifications)

    mailer.ssh_key_expired_email(user, fingerprints).deliver_later
  end

  # Notify the user when at least one of their ssh key is expiring soon
  def ssh_key_expiring_soon(user, fingerprints)
    return unless user.can?(:receive_notifications)

    mailer.ssh_key_expiring_soon_email(user, fingerprints).deliver_later
  end

  # Notify a user when a previously unknown IP or device is used to
  # sign in to their account
  def unknown_sign_in(user, ip, time)
    return unless user.can?(:receive_notifications)

    mailer.unknown_sign_in_email(user, ip, time).deliver_later
  end

  # Notify a user when a wrong 2FA OTP has been entered to
  # try to sign in to their account
  def two_factor_otp_attempt_failed(user, ip)
    return unless user.can?(:receive_notifications)

    mailer.two_factor_otp_attempt_failed_email(user, ip).deliver_later
  end

  # Notify a user when a new email address is added to the their account
  def new_email_address_added(user, email)
    return unless user.can?(:receive_notifications)

    mailer.new_email_address_added_email(user, email).deliver_later
  end

  # When create an issue we should send an email to:
  #
  #  * issue assignee if their notification level is not Disabled
  #  * project team members with notification level higher then Participating
  #  * watchers of the issue's labels
  #  * users with custom level checked with ""new issue""
  #
  def new_issue(issue, current_user)
    new_resource_email(issue, current_user, :new_issue_email)
  end

  # When issue text is updated, we should send an email to:
  #
  #  * newly mentioned project team members with notification level higher than Participating
  #
  def new_mentions_in_issue(issue, new_mentioned_users, current_user)
    new_mentions_in_resource_email(
      issue,
      new_mentioned_users,
      current_user,
      :new_mention_in_issue_email
    )
  end

  # When we close an issue we should send an email to:
  #
  #  * issue author if their notification level is not Disabled
  #  * issue assignee if their notification level is not Disabled
  #  * project team members with notification level higher then Participating
  #  * users with custom level checked with ""close issue""
  #
  def close_issue(issue, current_user, params = {})
    close_resource_email(issue, current_user, :closed_issue_email, closed_via: params[:closed_via])
  end

  # When we reassign an issue we should send an email to:
  #
  #  * issue old assignees if their notification level is not Disabled
  #  * issue new assignees if their notification level is not Disabled
  #  * users with custom level checked with ""reassign issue""
  #
  def reassigned_issue(issue, current_user, previous_assignees = [])
    recipients = NotificationRecipients::BuildService.build_recipients(
      issue,
      current_user,
      action: ""reassign"",
      previous_assignees: previous_assignees
    )

    previous_assignee_ids = previous_assignees.map(&:id)

    recipients.each do |recipient|
      mailer.send(
        :reassigned_issue_email,
        recipient.user.id,
        issue.id,
        previous_assignee_ids,
        current_user.id,
        recipient.reason
      ).deliver_later
    end
  end

  # When we add labels to an issue we should send an email to:
  #
  #  * watchers of the issue's labels
  #
  def relabeled_issue(issue, added_labels, current_user)
    relabeled_resource_email(issue, added_labels, current_user, :relabeled_issue_email)
  end

  # When create a merge request we should send an email to:
  #
  #  * mr author
  #  * mr assignees if their notification level is not Disabled
  #  * project team members with notification level higher then Participating
  #  * watchers of the mr's labels
  #  * users with custom level checked with ""new merge request""
  #
  # In EE, approvers of the merge request are also included
  def new_merge_request(merge_request, current_user)
    new_resource_email(merge_request, current_user, :new_merge_request_email)
  end

  NEW_COMMIT_EMAIL_DISPLAY_LIMIT = 20
  def push_to_merge_request(merge_request, current_user, new_commits: [], existing_commits: [])
    total_new_commits_count = new_commits.count
    truncated_new_commits = new_commits.first(NEW_COMMIT_EMAIL_DISPLAY_LIMIT).map do |commit|
      { short_id: commit.short_id, title: commit.title }
    end

    # We don't need the list of all existing commits. We need the first, the
    # last, and the total number of existing commits only.
    total_existing_commits_count = existing_commits.count
    existing_commits = [existing_commits.first, existing_commits.last] if total_existing_commits_count > 2
    existing_commits = existing_commits.map do |commit|
      { short_id: commit.short_id, title: commit.title }
    end

    recipients = NotificationRecipients::BuildService.build_recipients(merge_request, current_user, action: ""push_to"")

    recipients.each do |recipient|
      mailer.send(
        :push_to_merge_request_email,
        recipient.user.id, merge_request.id, current_user.id, recipient.reason,
        new_commits: truncated_new_commits, total_new_commits_count: total_new_commits_count,
        existing_commits: existing_commits, total_existing_commits_count: total_existing_commits_count
      ).deliver_later
    end
  end

  def change_in_merge_request_draft_status(merge_request, current_user)
    recipients = NotificationRecipients::BuildService.build_recipients(merge_request, current_user, action: ""draft_status_change"")

    recipients.each do |recipient|
      mailer.send(
        :change_in_merge_request_draft_status_email,
        recipient.user.id,
        merge_request.id,
        current_user.id,
        recipient.reason
      ).deliver_later
    end
  end

  # When a merge request is found to be unmergeable, we should send an email to:
  #
  #  * mr author
  #  * mr merge user if set
  #
  def merge_request_unmergeable(merge_request)
    merge_request_unmergeable_email(merge_request)
  end

  # When merge request text is updated, we should send an email to:
  #
  #  * newly mentioned project team members with notification level higher than Participating
  #
  def new_mentions_in_merge_request(merge_request, new_mentioned_users, current_user)
    new_mentions_in_resource_email(
      merge_request,
      new_mentioned_users,
      current_user,
      :new_mention_in_merge_request_email
    )
  end

  # When we reassign a merge_request we should send an email to:
  #
  #  * merge_request old assignees if their notification level is not Disabled
  #  * merge_request new assignees if their notification level is not Disabled
  #  * users with custom level checked with ""reassign merge request""
  #
  def reassigned_merge_request(merge_request, current_user, previous_assignees = [])
    recipients = NotificationRecipients::BuildService.build_recipients(
      merge_request,
      current_user,
      action: ""reassign"",
      previous_assignees: previous_assignees
    )

    previous_assignee_ids = previous_assignees.map(&:id)

    recipients.each do |recipient|
      mailer.reassigned_merge_request_email(
        recipient.user.id,
        merge_request.id,
        previous_assignee_ids,
        current_user.id,
        recipient.reason
      ).deliver_later
    end
  end

  # When we change reviewer in a merge_request we should send an email to:
  #
  #  * merge_request old reviewers if their notification level is not Disabled
  #  * merge_request new reviewers if their notification level is not Disabled
  #  * users with custom level checked with ""change reviewer merge request""
  #
  def changed_reviewer_of_merge_request(merge_request, current_user, previous_reviewers = [])
    recipients = NotificationRecipients::BuildService.build_recipients(
      merge_request,
      current_user,
      action: ""change_reviewer"",
      previous_assignees: previous_reviewers
    )

    previous_reviewer_ids = previous_reviewers.map(&:id)

    recipients.each do |recipient|
      mailer.changed_reviewer_of_merge_request_email(
        recipient.user.id,
        merge_request.id,
        previous_reviewer_ids,
        current_user.id,
        recipient.reason
      ).deliver_later
    end
  end

  def review_requested_of_merge_request(merge_request, current_user, reviewer)
    recipients = NotificationRecipients::BuildService.build_requested_review_recipients(merge_request, current_user, reviewer)

    deliver_option = review_request_deliver_options(merge_request.project)

    recipients.each do |recipient|
      mailer
        .request_review_merge_request_email(recipient.user.id, merge_request.id, current_user.id, recipient.reason)
        .deliver_later(deliver_option)
    end
  end

  # When we add labels to a merge request we should send an email to:
  #
  #  * watchers of the mr's labels
  #
  def relabeled_merge_request(merge_request, added_labels, current_user)
    relabeled_resource_email(merge_request, added_labels, current_user, :relabeled_merge_request_email)
  end

  def close_mr(merge_request, current_user)
    close_resource_email(merge_request, current_user, :closed_merge_request_email)
  end

  def reopen_issue(issue, current_user)
    reopen_resource_email(issue, current_user, :issue_status_changed_email, 'reopened')
  end

  def merge_mr(merge_request, current_user)
    close_resource_email(
      merge_request,
      current_user,
      :merged_merge_request_email,
      skip_current_user: !merge_request.auto_merge_enabled?
    )
  end

  def reopen_mr(merge_request, current_user)
    reopen_resource_email(
      merge_request,
      current_user,
      :merge_request_status_email,
      'reopened'
    )
  end

  def resolve_all_discussions(merge_request, current_user)
    recipients = NotificationRecipients::BuildService.build_recipients(
      merge_request,
      current_user,
      action: ""resolve_all_discussions"")

    recipients.each do |recipient|
      mailer.resolved_all_discussions_email(recipient.user.id, merge_request.id, current_user.id, recipient.reason).deliver_later
    end
  end

  # Notify new user with email after creation
  def new_user(user, token = nil)
    return true unless notifiable?(user, :mention)

    # Don't email omniauth created users
    mailer.new_user_email(user.id, token).deliver_later unless user.identities.any?
  end

  # Notify users on new note in system
  def new_note(note)
    return true unless note.noteable_type.present?

    # ignore gitlab service messages
    return true if note.system_note_with_references?

    send_new_note_notifications(note)
    send_service_desk_notification(note)
  end

  def send_new_note_notifications(note)
    notify_method = ""note_#{note.noteable_ability_name}_email"".to_sym

    recipients = NotificationRecipients::BuildService.build_new_note_recipients(note)
    recipients.each do |recipient|
      mailer.send(notify_method, recipient.user.id, note.id, recipient.reason).deliver_later
    end
  end

  def send_service_desk_notification(note)
    return unless note.noteable_type == 'Issue'
    return if note.confidential
    return unless note.project.service_desk_enabled?

    issue = note.noteable
    recipients = issue.email_participants_emails

    return unless recipients.any?

    support_bot = Users::Internal.support_bot
    recipients.delete(issue.external_author) if note.author == support_bot

    recipients.each do |recipient|
      mailer.service_desk_new_note_email(issue.id, note.id, recipient).deliver_later
      Gitlab::Metrics::BackgroundTransaction.current&.add_event(:service_desk_new_note_email)
    end
  end

  # Notify users when a new release is created
  def send_new_release_notifications(release)
    unless release.author&.can_trigger_notifications?
      warn_skipping_notifications(release.author, release)
      return false
    end

    recipients = NotificationRecipients::BuildService.build_recipients(release,
      release.author,
      action: ""new"")

    recipients.each do |recipient|
      mailer.new_release_email(recipient.user.id, release, recipient.reason).deliver_later
    end
  end

  def new_instance_access_request(user)
    recipients = User.instance_access_request_approvers_to_be_notified # https://gitlab.com/gitlab-org/gitlab/-/issues/277016 will change this

    return true if recipients.empty?

    recipients.each do |recipient|
      mailer.instance_access_request_email(user, recipient).deliver_later
    end
  end

  def user_admin_rejection(name, email)
    mailer.user_admin_rejection_email(name, email).deliver_later
  end

  def user_deactivated(name, email)
    mailer.user_deactivated_email(name, email).deliver_later
  end

  # Members
  def new_access_request(member)
    return true unless member.notifiable?(:subscription)

    recipients = member.source.access_request_approvers_to_be_notified

    return true if recipients.empty?

    recipients.each { |recipient| deliver_access_request_email(recipient, member) }
  end

  def decline_access_request(member)
    return true unless member.notifiable?(:subscription)

    mailer.member_access_denied_email(member.real_source_type, member.source_id, member.user_id).deliver_later
  end

  def decline_invite(member)
    # Must always send, regardless of project/namespace configuration since it's a
    # response to the user's action.

    mailer.member_invite_declined_email(
      member.real_source_type,
      member.source.id,
      member.invite_email,
      member.created_by_id
    ).deliver_later
  end

  # Project invite
  def invite_project_member(project_member, token)
    return true unless project_member.notifiable?(:subscription)

    mailer.member_invited_email(project_member.real_source_type, project_member.id, token).deliver_later
  end

  def accept_project_invite(project_member)
    return true unless project_member.notifiable?(:subscription)

    mailer.member_invite_accepted_email(project_member.real_source_type, project_member.id).deliver_later
  end

  def new_project_member(project_member)
    return true unless project_member.notifiable?(:mention, skip_read_ability: true)

    mailer.member_access_granted_email(project_member.real_source_type, project_member.id).deliver_later
  end

  def update_project_member(project_member)
    return true unless project_member.notifiable?(:mention)

    mailer.member_access_granted_email(project_member.real_source_type, project_member.id).deliver_later
  end

  def member_about_to_expire(member)
    return true unless member.notifiable?(:mention)

    mailer.member_about_to_expire_email(member.real_source_type, member.id).deliver_later
  end

  # Group invite
  def invite_group_member(group_member, token)
    mailer.member_invited_email(group_member.real_source_type, group_member.id, token).deliver_later
  end

  def invite_member_reminder(group_member, token, reminder_index)
    mailer.member_invited_reminder_email(group_member.real_source_type, group_member.id, token, reminder_index).deliver_later
  end

  def accept_group_invite(group_member)
    mailer.member_invite_accepted_email(group_member.real_source_type, group_member.id).deliver_later
  end

  def new_group_member(group_member)
    return true unless group_member.notifiable?(:mention)

    mailer.member_access_granted_email(group_member.real_source_type, group_member.id).deliver_later
  end

  def update_group_member(group_member)
    return true unless group_member.notifiable?(:mention)

    mailer.member_access_granted_email(group_member.real_source_type, group_member.id).deliver_later
  end

  def updated_group_member_expiration(group_member)
    return true unless group_member.notifiable?(:mention)

    mailer.member_expiration_date_updated_email(group_member.real_source_type, group_member.id).deliver_later
  end

  def project_was_moved(project, old_path_with_namespace)
    recipients = project_moved_recipients(project)
    recipients = notifiable_users(recipients, :custom, custom_action: :moved_project, project: project)

    recipients.each do |recipient|
      mailer.project_was_moved_email(
        project.id,
        recipient.id,
        old_path_with_namespace
      ).deliver_later
    end
  end

  def issue_moved(issue, new_issue, current_user)
    recipients = NotificationRecipients::BuildService.build_recipients(issue, current_user, action: 'moved')

    recipients.map do |recipient|
      email = mailer.issue_moved_email(recipient.user, issue, new_issue, current_user, recipient.reason)
      email.deliver_later
      email
    end
  end

  def issue_cloned(issue, new_issue, current_user)
    recipients = NotificationRecipients::BuildService.build_recipients(issue, current_user, action: 'cloned')

    recipients.map do |recipient|
      email = mailer.issue_cloned_email(recipient.user, issue, new_issue, current_user, recipient.reason)
      email.deliver_later
      email
    end
  end

  def project_exported(project, current_user)
    return true unless notifiable?(current_user, :mention, project: project)

    mailer.project_was_exported_email(current_user, project).deliver_later
  end

  def project_not_exported(project, current_user, errors)
    return true unless notifiable?(current_user, :mention, project: project)

    mailer.project_was_not_exported_email(current_user, project, errors).deliver_later
  end

  def pipeline_finished(pipeline, ref_status: nil, recipients: nil)
    # Must always check project configuration since recipients could be a list of emails
    # from the PipelinesEmailService integration.
    return if pipeline.project.emails_disabled?

    status = pipeline_notification_status(ref_status, pipeline)
    email_template = ""pipeline_#{status}_email""

    return unless mailer.respond_to?(email_template)

    recipients ||= notifiable_users(
      [pipeline.user], :watch,
      custom_action: :""#{status}_pipeline"",
      target: pipeline
    ).map do |user|
      user.notification_email_for(pipeline.project.group)
    end

    recipients.each do |recipient|
      mailer.public_send(email_template, pipeline, recipient).deliver_later
    end
  end

  def autodevops_disabled(pipeline, recipients)
    return if pipeline.project.emails_disabled?

    recipients.each do |recipient|
      mailer.autodevops_disabled_email(pipeline, recipient).deliver_later
    end
  end

  def pages_domain_verification_succeeded(domain)
    project_maintainers_recipients(domain, action: 'succeeded').each do |recipient|
      mailer.pages_domain_verification_succeeded_email(domain, recipient.user).deliver_later
    end
  end

  def pages_domain_verification_failed(domain)
    project_maintainers_recipients(domain, action: 'failed').each do |recipient|
      mailer.pages_domain_verification_failed_email(domain, recipient.user).deliver_later
    end
  end

  def pages_domain_enabled(domain)
    project_maintainers_recipients(domain, action: 'enabled').each do |recipient|
      mailer.pages_domain_enabled_email(domain, recipient.user).deliver_later
    end
  end

  def pages_domain_disabled(domain)
    project_maintainers_recipients(domain, action: 'disabled').each do |recipient|
      mailer.pages_domain_disabled_email(domain, recipient.user).deliver_later
    end
  end

  def pages_domain_auto_ssl_failed(domain)
    project_maintainers_recipients(domain, action: 'disabled').each do |recipient|
      mailer.pages_domain_auto_ssl_failed_email(domain, recipient.user).deliver_later
    end
  end

  def issue_due(issue)
    recipients = NotificationRecipients::BuildService.build_recipients(
      issue,
      issue.author,
      action: 'due',
      custom_action: :issue_due,
      skip_current_user: false
    )

    recipients.each do |recipient|
      mailer.send(:issue_due_email, recipient.user.id, issue.id, recipient.reason).deliver_later
    end
  end

  def repository_cleanup_success(project, user)
    return if project.emails_disabled?

    mailer.send(:repository_cleanup_success_email, project, user).deliver_later
  end

  def repository_cleanup_failure(project, user, error)
    return if project.emails_disabled?

    mailer.send(:repository_cleanup_failure_email, project, user, error).deliver_later
  end

  def remote_mirror_update_failed(remote_mirror)
    recipients = project_maintainers_recipients(remote_mirror, action: 'update_failed')

    recipients.each do |recipient|
      mailer.remote_mirror_update_failed_email(remote_mirror.id, recipient.user.id).deliver_later
    end
  end

  def prometheus_alerts_fired(project, alerts)
    return if project.emails_disabled?

    owners_and_maintainers_without_invites(project).to_a.product(alerts).each do |recipient, alert|
      mailer.prometheus_alert_fired_email(project, recipient.user, alert).deliver_later
    end
  end

  def group_was_exported(group, current_user)
    return true unless notifiable?(current_user, :mention, group: group)

    mailer.group_was_exported_email(current_user, group).deliver_later
  end

  def group_was_not_exported(group, current_user, errors)
    return true unless notifiable?(current_user, :mention, group: group)

    mailer.group_was_not_exported_email(current_user, group, errors).deliver_later
  end

  # Notify users on new review in system
  def new_review(review)
    recipients = NotificationRecipients::BuildService.build_new_review_recipients(review)
    deliver_options = new_review_deliver_options(review)

    recipients.each do |recipient|
      mailer
        .new_review_email(recipient.user.id, review.id)
        .deliver_later(deliver_options)
    end
  end

  def merge_when_pipeline_succeeds(merge_request, current_user)
    recipients = ::NotificationRecipients::BuildService.build_recipients(
      merge_request,
      current_user,
      action: 'merge_when_pipeline_succeeds',
      custom_action: :merge_when_pipeline_succeeds
    )

    recipients.each do |recipient|
      mailer.merge_when_pipeline_succeeds_email(recipient.user.id, merge_request.id, current_user.id).deliver_later
    end
  end

  def approve_mr(merge_request, current_user)
    approve_mr_email(merge_request, merge_request.target_project, current_user)
  end

  def unapprove_mr(merge_request, current_user)
    unapprove_mr_email(merge_request, merge_request.target_project, current_user)
  end

  def inactive_project_deletion_warning(project, deletion_date)
    owners_and_maintainers_without_invites(project).each do |recipient|
      mailer.inactive_project_deletion_warning_email(project, recipient.user, deletion_date).deliver_later
    end
  end

  def removed_milestone(target, current_user)
    method = case target
             when Issue
               :removed_milestone_issue_email
             when MergeRequest
               :removed_milestone_merge_request_email
             end

    recipients = NotificationRecipients::BuildService.build_recipients(
      target,
      current_user,
      action: 'removed_milestone'
    )

    recipients.each do |recipient|
      mailer.send(method, recipient.user.id, target.id, current_user.id).deliver_later
    end
  end

  def changed_milestone(target, milestone, current_user)
    method = case target
             when Issue
               :changed_milestone_issue_email
             when MergeRequest
               :changed_milestone_merge_request_email
             end

    recipients = NotificationRecipients::BuildService.build_recipients(
      target,
      current_user,
      action: 'changed_milestone'
    )

    recipients.each do |recipient|
      mailer.send(method, recipient.user.id, target.id, milestone, current_user.id).deliver_later
    end
  end

  def new_achievement_email(user, achievement)
    mailer.new_achievement_email(user, achievement)
  end

  protected

  def new_resource_email(target, current_user, method)
    unless current_user&.can_trigger_notifications?
      warn_skipping_notifications(current_user, target)
      return false
    end

    recipients = NotificationRecipients::BuildService.build_recipients(target, target.author, action: ""new"")

    recipients.each do |recipient|
      mailer.send(method, recipient.user.id, target.id, recipient.reason).deliver_later
    end
  end

  def new_mentions_in_resource_email(target, new_mentioned_users, current_user, method)
    unless current_user&.can_trigger_notifications?
      warn_skipping_notifications(current_user, target)
      return false
    end

    recipients = NotificationRecipients::BuildService.build_recipients(target, current_user, action: ""new"")
    recipients = recipients.select { |r| new_mentioned_users.include?(r.user) }

    recipients.each do |recipient|
      mailer.send(method, recipient.user.id, target.id, current_user.id, recipient.reason).deliver_later
    end
  end

  def close_resource_email(target, current_user, method, skip_current_user: true, closed_via: nil)
    action = method == :merged_merge_request_email ? ""merge"" : ""close""

    recipients = NotificationRecipients::BuildService.build_recipients(
      target,
      current_user,
      action: action,
      skip_current_user: skip_current_user
    )

    recipients.each do |recipient|
      mailer.send(method, recipient.user.id, target.id, current_user.id, reason: recipient.reason, closed_via: closed_via).deliver_later
    end
  end

  def relabeled_resource_email(target, labels, current_user, method)
    recipients = labels.flat_map { |l| l.subscribers(target.project) }.uniq
    recipients = notifiable_users(
      recipients, :subscription,
      target: target,
      acting_user: current_user
    )

    label_names = labels.map(&:name)

    recipients.each do |recipient|
      mailer.send(method, recipient.id, target.id, label_names, current_user.id).deliver_later
    end
  end

  def reopen_resource_email(target, current_user, method, status)
    recipients = NotificationRecipients::BuildService.build_recipients(target, current_user, action: ""reopen"")

    recipients.each do |recipient|
      mailer.send(method, recipient.user.id, target.id, status, current_user.id, recipient.reason).deliver_later
    end
  end

  def merge_request_unmergeable_email(merge_request)
    recipients = NotificationRecipients::BuildService.build_merge_request_unmergeable_recipients(merge_request)

    recipients.each do |recipient|
      mailer.merge_request_unmergeable_email(recipient.user.id, merge_request.id).deliver_later
    end
  end

  def mailer
    Notify
  end

  private

  def approve_mr_email(merge_request, project, current_user)
    recipients = ::NotificationRecipients::BuildService.build_recipients(merge_request, current_user, action: 'approve')

    recipients.each do |recipient|
      mailer.approved_merge_request_email(recipient.user.id, merge_request.id, current_user.id).deliver_later
    end
  end

  def unapprove_mr_email(merge_request, project, current_user)
    recipients = ::NotificationRecipients::BuildService.build_recipients(merge_request, current_user, action: 'unapprove')

    recipients.each do |recipient|
      mailer.unapproved_merge_request_email(recipient.user.id, merge_request.id, current_user.id).deliver_later
    end
  end

  def pipeline_notification_status(ref_status, pipeline)
    if Ci::Ref.failing_state?(ref_status)
      'failed'
    elsif ref_status
      ref_status
    else
      pipeline.status
    end
  end

  def owners_and_maintainers_without_invites(project)
    recipients = project.members.active_without_invites_and_requests.owners_and_maintainers

    if recipients.empty? && project.group
      recipients = project.group.members.active_without_invites_and_requests.owners_and_maintainers
    end

    recipients
  end

  def project_moved_recipients(project)
    finder = MembersFinder.new(project, nil, params: {
      active_without_invites_and_requests: true,
      owners_and_maintainers: true
    })
    finder.execute.preload_user_and_notification_settings.map(&:user)
  end

  def project_maintainers_recipients(target, action:)
    NotificationRecipients::BuildService.build_project_maintainers_recipients(target, action: action)
  end

  def notifiable?(...)
    NotificationRecipients::BuildService.notifiable?(...)
  end

  def notifiable_users(...)
    NotificationRecipients::BuildService.notifiable_users(...)
  end

  def deliver_access_request_email(recipient, member)
    mailer.member_access_requested_email(member.real_source_type, member.id, recipient.user.id).deliver_later
  end

  def warn_skipping_notifications(user, object)
    Gitlab::AppLogger.warn(message: ""Skipping sending notifications"", user: user.id, klass: object.class.to_s, object_id: object.id)
  end

  def new_review_deliver_options(review)
    # Overridden in EE
    {}
  end

  def review_request_deliver_options(project)
    # Overridden in EE
    {}
  end
end

NotificationService.prepend_mod_with('NotificationService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe NotificationService, :mailer, feature_category: :team_planning do
  include EmailSpec::Matchers
  include ExternalAuthorizationServiceHelpers
  include NotificationHelpers

  let_it_be_with_refind(:project, reload: true) { create(:project, :public) }
  let_it_be_with_refind(:assignee) { create(:user) }

  let(:notification) { described_class.new }

  around(:example, :deliver_mails_inline) do |example|
    # This is a temporary `around` hook until all the examples check the
    # background jobs queue instead of the delivered emails array.
    # `perform_enqueued_jobs` makes the ActiveJob jobs (e.g. mailer jobs) run inline
    # compared to `Sidekiq::Testing.inline!` which makes the Sidekiq jobs run inline.
    perform_enqueued_jobs { example.run }
  end

  shared_examples 'altered milestone notification on issue' do
    it 'sends the email to the correct people' do
      should_email(subscriber_to_new_milestone)
      issue.assignees.each do |a|
        should_email(a)
      end
      should_email(@u_watcher)
      should_email(@u_guest_watcher)
      should_email(@u_participant_mentioned)
      should_email(@subscriber)
      should_email(@subscribed_participant)
      should_email(@watcher_and_subscriber)
      should_not_email(@u_guest_custom)
      should_not_email(@u_committer)
      should_not_email(@unsubscriber)
      should_not_email(@u_participating)
      should_not_email(@u_lazy_participant)
      should_not_email(issue.author)
      should_not_email(@u_disabled)
      should_not_email(@u_custom_global)
      should_not_email(@u_mentioned)
    end
  end

  shared_examples 'altered milestone notification on merge request' do
    it 'sends the email to the correct people' do
      should_email(subscriber_to_new_milestone)
      merge_request.assignees.each do |a|
        should_email(a)
      end
      should_email(@u_watcher)
      should_email(@u_guest_watcher)
      should_email(@u_participant_mentioned)
      should_email(@subscriber)
      should_email(@subscribed_participant)
      should_email(@watcher_and_subscriber)
      should_not_email(@u_guest_custom)
      should_not_email(@u_committer)
      should_not_email(@unsubscriber)
      should_not_email(@u_participating)
      should_not_email(@u_lazy_participant)
      should_not_email(merge_request.author)
      should_not_email(@u_disabled)
      should_not_email(@u_custom_global)
      should_not_email(@u_mentioned)
    end
  end

  shared_examples 'notifications for new mentions' do
    it 'sends no emails when no new mentions are present' do
      send_notifications
      should_not_email_anyone
    end

    it 'emails new mentions with a watch level higher than mention' do
      send_notifications(@u_watcher, @u_participant_mentioned, @u_custom_global, @u_mentioned)
      should_only_email(@u_watcher, @u_participant_mentioned, @u_custom_global, @u_mentioned)
    end

    it 'does not email new mentions with a watch level equal to or less than mention' do
      send_notifications(@u_disabled)
      should_not_email_anyone
    end

    it 'emails new mentions despite being unsubscribed' do
      send_notifications(@unsubscribed_mentioned)

      should_only_email(@unsubscribed_mentioned)
    end

    it 'sends the proper notification reason header' do
      send_notifications(@u_watcher)
      should_only_email(@u_watcher)
      email = find_email_for(@u_watcher)

      expect(email).to have_header('X-GitLab-NotificationReason', NotificationReason::MENTIONED)
    end
  end

  shared_examples 'is not able to send notifications' do |check_delivery_jobs_queue: false|
    it 'does not send any notification' do
      user_1 = create(:user)
      recipient_1 = NotificationRecipient.new(user_1, :custom, custom_action: :new_release)
      allow(NotificationRecipients::BuildService).to receive(:build_new_release_recipients).and_return([recipient_1])

      expect(Gitlab::AppLogger).to receive(:warn).with(message: 'Skipping sending notifications', user: current_user.id, klass: object.class.to_s, object_id: object.id)

      if check_delivery_jobs_queue
        expect do
          action
        end.to not_enqueue_mail_with(Notify, notification_method, @u_mentioned, anything, anything)
          .and(not_enqueue_mail_with(Notify, notification_method, @u_guest_watcher, anything, anything))
          .and(not_enqueue_mail_with(Notify, notification_method, user_1, anything, anything))
          .and(not_enqueue_mail_with(Notify, notification_method, current_user, anything, anything))
      else
        action

        should_not_email(@u_mentioned)
        should_not_email(@u_guest_watcher)
        should_not_email(user_1)
        should_not_email(current_user)
      end
    end
  end

  # Next shared examples are intended to test notifications of ""participants""
  #
  # they take the following parameters:
  # * issuable
  # * notification trigger
  # * participant
  #
  shared_examples 'participating by note notification' do |check_delivery_jobs_queue: false|
    it 'emails the participant' do
      create(:note_on_issue, noteable: issuable, project_id: project.id, note: 'anything', author: participant)

      if check_delivery_jobs_queue
        expect do
          notification_trigger
        end.to enqueue_mail_with(Notify, mailer_method, *expectation_args_for_user(participant))
      else
        notification_trigger

        should_email(participant)
      end
    end

    context 'for subgroups' do
      before do
        build_group(project)
      end

      it 'emails the participant' do
        create(:note_on_issue, noteable: issuable, project_id: project.id, note: 'anything', author: @pg_participant)

        if check_delivery_jobs_queue
          expect do
            notification_trigger
          end.to enqueue_mail_with(Notify, mailer_method, *expectation_args_for_user(@pg_participant))
        else
          notification_trigger

          should_email_nested_group_user(@pg_participant)
        end
      end
    end
  end

  shared_examples 'participating by confidential note notification' do |check_delivery_jobs_queue: false|
    context 'when user is mentioned on confidential note' do
      let_it_be(:guest_1) { create(:user) }
      let_it_be(:guest_2) { create(:user) }
      let_it_be(:reporter) { create(:user) }

      before do
        issuable.resource_parent.add_guest(guest_1)
        issuable.resource_parent.add_guest(guest_2)
        issuable.resource_parent.add_reporter(reporter)
      end

      it 'only emails authorized users' do
        confidential_note_text = ""#{guest_1.to_reference} and #{guest_2.to_reference} and #{reporter.to_reference}""
        note_text = ""Mentions #{guest_2.to_reference}""
        create(:note_on_issue, noteable: issuable, project_id: project.id, note: confidential_note_text, confidential: true)
        create(:note_on_issue, noteable: issuable, project_id: project.id, note: note_text)

        if check_delivery_jobs_queue
          expect do
            notification_trigger
          end.to enqueue_mail_with(Notify, mailer_method, *expectation_args_for_user(guest_2))
            .and(enqueue_mail_with(Notify, mailer_method, *expectation_args_for_user(reporter)))
            .and(not_enqueue_mail_with(Notify, mailer_method, *expectation_args_for_user(guest_1)))
        else
          reset_delivered_emails!

          notification_trigger

          should_not_email(guest_1)
          should_email(guest_2)
          should_email(reporter)
        end
      end
    end
  end

  shared_examples 'participating by assignee notification' do |check_delivery_jobs_queue: false|
    it 'emails the participant' do
      issuable.assignees << participant

      if check_delivery_jobs_queue
        expect do
          notification_trigger
        end.to enqueue_mail_with(Notify, mailer_method, *expectation_args_for_user(participant))
      else
        notification_trigger

        should_email(participant)
      end
    end
  end

  shared_examples 'participating by author notification' do |check_delivery_jobs_queue: false|
    it 'emails the participant' do
      issuable.author = participant

      if check_delivery_jobs_queue
        expect do
          notification_trigger
        end.to enqueue_mail_with(Notify, mailer_method, *expectation_args_for_user(participant))
      else
        notification_trigger

        should_email(participant)
      end
    end
  end

  shared_examples 'participating by reviewer notification' do
    it 'emails the participant' do
      issuable.reviewers << participant

      notification_trigger

      should_email(participant)
    end
  end

  shared_examples_for 'participating notifications' do |check_delivery_jobs_queue: false|
    it_behaves_like 'participating by note notification', check_delivery_jobs_queue: check_delivery_jobs_queue
    it_behaves_like 'participating by author notification', check_delivery_jobs_queue: check_delivery_jobs_queue
    it_behaves_like 'participating by assignee notification', check_delivery_jobs_queue: check_delivery_jobs_queue
  end

  shared_examples 'declines the invite' do
    specify do
      member = source.members.last

      expect do
        notification.decline_invite(member)
      end.to change { ActionMailer::Base.deliveries.size }.by(1)
    end
  end

  describe '.permitted_actions' do
    it 'includes public methods' do
      expect(described_class.permitted_actions).to include(:access_token_created)
    end

    it 'excludes EXCLUDED_ACTIONS' do
      described_class::EXCLUDED_ACTIONS.each do |action|
        expect(described_class.permitted_actions).not_to include(action)
      end
    end

    it 'excludes protected and private methods' do
      expect(described_class.permitted_actions).not_to include(:new_resource_email)
      expect(described_class.permitted_actions).not_to include(:approve_mr_email)
    end
  end

  describe '#async' do
    let(:async) { notification.async }

    let_it_be(:key) { create(:personal_key) }

    it 'returns an Async object with the correct parent' do
      expect(async).to be_a(described_class::Async)
      expect(async.parent).to eq(notification)
    end

    context 'when receiving a public method' do
      it 'schedules a MailScheduler::NotificationServiceWorker' do
        expect(MailScheduler::NotificationServiceWorker)
          .to receive(:perform_async).with('new_key', key)

        async.new_key(key)
      end
    end

    context 'when receiving a private method' do
      it 'raises NoMethodError' do
        expect { async.notifiable?(key) }.to raise_error(NoMethodError)
      end
    end

    context 'when receiving a non-existent method' do
      it 'raises NoMethodError' do
        expect { async.foo(key) }.to raise_error(NoMethodError)
      end
    end
  end

  describe 'Keys' do
    describe '#new_key' do
      let(:key_options) { {} }
      let!(:key) { build_stubbed(:personal_key, key_options) }

      subject { notification.new_key(key) }

      it ""sends email to key owner"" do
        expect { subject }.to have_enqueued_email(key.id, mail: ""new_ssh_key_email"")
      end

      describe ""never emails the ghost user"" do
        let(:key_options) { { user: Users::Internal.ghost } }

        it ""does not send email to key owner"" do
          expect { subject }.not_to have_enqueued_email(key.id, mail: ""new_ssh_key_email"")
        end
      end
    end
  end

  describe 'GpgKeys' do
    describe '#new_gpg_key' do
      let(:key_options) { {} }
      let(:key) { create(:gpg_key, key_options) }

      subject { notification.new_gpg_key(key) }

      it ""sends email to key owner"" do
        expect { subject }.to have_enqueued_email(key.id, mail: ""new_gpg_key_email"")
      end

      describe ""never emails the ghost user"" do
        let(:key_options) { { user: Users::Internal.ghost } }

        it ""does not send email to key owner"" do
          expect { subject }.not_to have_enqueued_email(key.id, mail: ""new_gpg_key_email"")
        end
      end
    end
  end

  describe 'AccessToken' do
    describe '#access_token_created' do
      let_it_be(:user) { create(:user) }
      let_it_be(:pat) { create(:personal_access_token, user: user) }

      subject(:notification_service) { notification.access_token_created(user, pat.name) }

      it 'sends email to the token owner' do
        expect { notification_service }.to have_enqueued_email(user, pat.name, mail: ""access_token_created_email"")
      end

      context 'when user is not allowed to receive notifications' do
        before do
          user.block!
        end

        it 'does not send email to the token owner' do
          expect { notification_service }.not_to have_enqueued_email(user, pat.name, mail: ""access_token_created_email"")
        end
      end
    end

    describe '#resource_access_token_about_to_expire' do
      let_it_be(:project_bot) { create(:user, :project_bot) }
      let_it_be(:expiring_token) { create(:personal_access_token, user: project_bot, expires_at: 5.days.from_now) }

      let_it_be(:owner1) { create(:user) }
      let_it_be(:owner2) { create(:user) }

      subject(:notification_service) do
        notification.resource_access_tokens_about_to_expire(project_bot, [expiring_token.name])
      end

      context 'when the resource is a group' do
        let(:group) { create(:group) }

        before do
          group.add_owner(owner1)
          group.add_owner(owner2)
          group.add_reporter(project_bot)
        end

        it 'sends emails to the group owners' do
          expect { notification_service }.to(
            have_enqueued_email(
              owner1,
              project_bot.resource_bot_resource,
              [expiring_token.name],
              mail: ""resource_access_tokens_about_to_expire_email""
            ).and(
              have_enqueued_email(
                owner2,
                project_bot.resource_bot_resource,
                [expiring_token.name],
                mail: ""resource_access_tokens_about_to_expire_email""
              )
            )
          )
        end
      end

      context 'when the resource is a project' do
        let(:project) { create(:project) }

        before do
          project.add_maintainer(owner1)
          project.add_maintainer(owner2)
          project.add_reporter(project_bot)
        end

        it 'sends emails to the group owners' do
          expect { notification_service }.to(
            have_enqueued_email(
              owner1,
              project_bot.resource_bot_resource,
              [expiring_token.name],
              mail: ""resource_access_tokens_about_to_expire_email""
            ).and(
              have_enqueued_email(
                owner2,
                project_bot.resource_bot_resource,
                [expiring_token.name],
                mail: ""resource_access_tokens_about_to_expire_email""
              )
            )
          )
        end
      end
    end

    describe '#access_token_about_to_expire' do
      let_it_be(:user) { create(:user) }
      let_it_be(:pat) { create(:personal_access_token, user: user, expires_at: 5.days.from_now) }

      subject { notification.access_token_about_to_expire(user, [pat.name]) }

      it 'sends email to the token owner' do
        expect { subject }.to have_enqueued_email(user, [pat.name], mail: ""access_token_about_to_expire_email"")
      end
    end

    describe '#access_token_expired' do
      let_it_be(:user) { create(:user) }
      let_it_be(:pat) { create(:personal_access_token, user: user) }

      subject { notification.access_token_expired(user, pat.name) }

      it 'sends email to the token owner' do
        expect { subject }.to have_enqueued_email(user, pat.name, mail: ""access_token_expired_email"")
      end

      context 'when user is not allowed to receive notifications' do
        before do
          user.block!
        end

        it 'does not send email to the token owner' do
          expect { subject }.not_to have_enqueued_email(user, pat.name, mail: ""access_token_expired_email"")
        end
      end
    end

    describe '#access_token_revoked' do
      let_it_be(:user) { create(:user) }
      let_it_be(:pat) { create(:personal_access_token, user: user) }

      subject(:notification_service) { notification.access_token_revoked(user, pat.name) }

      it 'sends email to the token owner without source' do
        expect { notification_service }.to have_enqueued_email(user, pat.name, nil, mail: ""access_token_revoked_email"")
      end

      it 'sends email to the token owner with source' do
        expect do
          notification.access_token_revoked(user, pat.name, 'secret_detection')
        end.to have_enqueued_email(user, pat.name, 'secret_detection', mail: ""access_token_revoked_email"")
      end

      context 'when user is not allowed to receive notifications' do
        before do
          user.block!
        end

        it 'does not send email to the token owner' do
          expect { notification_service }.not_to have_enqueued_email(user, pat.name, mail: ""access_token_revoked_email"")
        end
      end
    end
  end

  describe 'SSH Keys' do
    let_it_be_with_reload(:user) { create(:user) }
    let_it_be(:fingerprints) { [""aa:bb:cc:dd:ee:zz""] }

    shared_context 'block user' do
      before do
        user.block!
      end
    end

    describe '#ssh_key_expired' do
      subject { notification.ssh_key_expired(user, fingerprints) }

      it 'sends email to the token owner' do
        expect { subject }.to have_enqueued_email(user, fingerprints, mail: ""ssh_key_expired_email"")
      end

      context 'when user is not allowed to receive notifications' do
        include_context 'block user'

        it 'does not send email to the token owner' do
          expect { subject }.not_to have_enqueued_email(user, fingerprints, mail: ""ssh_key_expired_email"")
        end
      end
    end

    describe '#ssh_key_expiring_soon' do
      subject { notification.ssh_key_expiring_soon(user, fingerprints) }

      it 'sends email to the token owner' do
        expect { subject }.to have_enqueued_email(user, fingerprints, mail: ""ssh_key_expiring_soon_email"")
      end

      context 'when user is not allowed to receive notifications' do
        include_context 'block user'

        it 'does not send email to the token owner' do
          expect { subject }.not_to have_enqueued_email(user, fingerprints, mail: ""ssh_key_expiring_soon_email"")
        end
      end
    end
  end

  describe '#unknown_sign_in' do
    let_it_be(:user) { create(:user) }
    let_it_be(:ip) { '127.0.0.1' }
    let_it_be(:time) { Time.current }

    subject { notification.unknown_sign_in(user, ip, time) }

    it 'sends email to the user' do
      expect { subject }.to have_enqueued_email(user, ip, time, mail: 'unknown_sign_in_email')
    end
  end

  describe '#disabled_two_factor' do
    let_it_be(:user) { create(:user) }

    subject { notification.disabled_two_factor(user) }

    it 'sends email to the user' do
      expect { subject }.to have_enqueued_email(user, mail: 'disabled_two_factor_email')
    end
  end

  describe '#new_email_address_added' do
    let_it_be(:user) { create(:user) }
    let_it_be(:email) { create(:email, user: user) }

    subject { notification.new_email_address_added(user, email) }

    it 'sends email to the user' do
      expect { subject }.to have_enqueued_email(user, email, mail: 'new_email_address_added_email')
    end
  end

  describe 'Notes' do
    context 'issue note' do
      let_it_be(:project) { create(:project, :private) }
      let_it_be_with_reload(:issue) { create(:issue, project: project, assignees: [assignee]) }
      let_it_be(:mentioned_issue) { create(:issue, assignees: issue.assignees) }
      let_it_be_with_reload(:author) { create(:user) }

      let(:note) { create(:note_on_issue, author: author, noteable: issue, project_id: issue.project_id, note: '@mention referenced, @unsubscribed_mentioned and @outsider also') }

      subject { notification.new_note(note) }

      context 'issue_email_participants' do
        before do
          allow(Notify).to receive(:service_desk_new_note_email)
                             .with(Integer, Integer, String).and_return(mailer)

          allow(::Gitlab::Email::IncomingEmail).to receive(:enabled?) { true }
          allow(::Gitlab::Email::IncomingEmail).to receive(:supports_wildcard?) { true }
        end

        let(:subject) { described_class.new }
        let(:mailer) { double(deliver_later: true) }
        let(:issue) { create(:issue, author: Users::Internal.support_bot) }
        let(:project) { issue.project }
        let(:note) { create(:note, noteable: issue, project: project) }

        shared_examples 'notification with exact metric events' do |number_of_events|
          it 'adds metric event' do
            metric_transaction = double('Gitlab::Metrics::WebTransaction', increment: true, observe: true)
            allow(::Gitlab::Metrics::BackgroundTransaction).to receive(:current).and_return(metric_transaction)
            expect(metric_transaction).to receive(:add_event).with(:service_desk_new_note_email).exactly(number_of_events).times

            subject.new_note(note)
          end
        end

        shared_examples 'no participants are notified' do
          it 'does not send the email' do
            expect(Notify).not_to receive(:service_desk_new_note_email)

            subject.new_note(note)
          end

          it_behaves_like 'notification with exact metric events', 0
        end

        it_behaves_like 'no participants are notified'

        context 'do exist and note not confidential' do
          let!(:issue_email_participant) { issue.issue_email_participants.create!(email: 'service.desk@example.com') }

          before do
            issue.update!(external_author: 'service.desk@example.com')
            project.update!(service_desk_enabled: true)
          end

          it 'sends the email' do
            expect(Notify).to receive(:service_desk_new_note_email)
              .with(issue.id, note.id, issue.external_author)

            subject.new_note(note)
          end

          it_behaves_like 'notification with exact metric events', 1

          context 'when service desk is disabled' do
            before do
              project.update!(service_desk_enabled: false)
            end

            it_behaves_like 'no participants are notified'
          end
        end

        context 'do exist and note is confidential' do
          let(:note) { create(:note, noteable: issue, project: project, confidential: true) }
          let!(:issue_email_participant) { issue.issue_email_participants.create!(email: 'service.desk@example.com') }

          before do
            issue.update!(external_author: 'service.desk@example.com')
            project.update!(service_desk_enabled: true)
          end

          it_behaves_like 'no participants are notified'
        end
      end

      describe '#new_note' do
        before_all do
          build_team(project)
          project.add_maintainer(issue.author)
          project.add_maintainer(assignee)
          project.add_maintainer(author)

          @u_custom_off = create_user_with_notification(:custom, 'custom_off')
          project.add_guest(@u_custom_off)

          create(
            :note_on_issue,
            author: @u_custom_off,
            noteable: issue,
            project_id: issue.project_id,
            note: 'i think @subscribed_participant should see this'
          )

          update_custom_notification(:new_note, @u_guest_custom, resource: project)
          update_custom_notification(:new_note, @u_custom_global)
        end

        context 'with users' do
          before_all do
            add_users(project)
            add_user_subscriptions(issue)
          end

          before do
            reset_delivered_emails!
          end

          it 'sends emails to recipients', :aggregate_failures do
            subject

            expect_delivery_jobs_count(10)
            expect_enqueud_email(@u_watcher.id, note.id, nil, mail: ""note_issue_email"")
            expect_enqueud_email(note.noteable.author.id, note.id, nil, mail: ""note_issue_email"")
            expect_enqueud_email(note.noteable.assignees.first.id, note.id, nil, mail: ""note_issue_email"")
            expect_enqueud_email(@u_custom_global.id, note.id, nil, mail: ""note_issue_email"")
            expect_enqueud_email(@u_mentioned.id, note.id, ""mentioned"", mail: ""note_issue_email"")
            expect_enqueud_email(@subscriber.id, note.id, ""subscribed"", mail: ""note_issue_email"")
            expect_enqueud_email(@watcher_and_subscriber.id, note.id, ""subscribed"", mail: ""note_issue_email"")
            expect_enqueud_email(@subscribed_participant.id, note.id, ""subscribed"", mail: ""note_issue_email"")
            expect_enqueud_email(@u_custom_off.id, note.id, nil, mail: ""note_issue_email"")
            expect_enqueud_email(@unsubscribed_mentioned.id, note.id, ""mentioned"", mail: ""note_issue_email"")
          end

          it ""emails the note author if they've opted into notifications about their activity"", :deliver_mails_inline do
            note.author.notified_of_own_activity = true

            notification.new_note(note)

            should_email(note.author)
            expect(find_email_for(note.author)).to have_header('X-GitLab-NotificationReason', 'own_activity')
          end

          it_behaves_like 'project emails are disabled', check_delivery_jobs_queue: true do
            let(:notification_target)  { note }
            let(:notification_trigger) { notification.new_note(note) }
          end
        end

        it 'filters out ""mentioned in"" notes' do
          mentioned_note = SystemNoteService.cross_reference(mentioned_issue, issue, issue.author)
          reset_delivered_emails!

          notification.new_note(mentioned_note)

          expect_no_delivery_jobs
        end

        context 'participating' do
          context 'by note' do
            before do
              note.author = @u_lazy_participant
              note.save!
            end

            it { expect { subject }.not_to have_enqueued_email(@u_lazy_participant.id, note.id, mail: ""note_issue_email"") }
          end
        end

        context 'in project that belongs to a group' do
          let_it_be(:parent_group) { create(:group) }

          before do
            note.project.namespace_id = group.id
            group.add_member(@u_watcher, GroupMember::MAINTAINER)
            group.add_member(@u_custom_global, GroupMember::MAINTAINER)
            note.project.save!

            @u_watcher.notification_settings_for(note.project).participating!
            @u_watcher.notification_settings_for(group).global!
            update_custom_notification(:new_note, @u_custom_global)
            reset_delivered_emails!
          end

          shared_examples 'new note notifications' do
            it 'sends notifications', :deliver_mails_inline do
              notification.new_note(note)

              should_email(note.noteable.author)
              should_email(note.noteable.assignees.first)
              should_email(@u_mentioned)
              should_email(@u_custom_global)
              should_not_email(@u_guest_custom)
              should_not_email(@u_guest_watcher)
              should_not_email(@u_watcher)
              should_not_email(note.author)
              should_not_email(@u_participating)
              should_not_email(@u_disabled)
              should_not_email(@u_lazy_participant)

              expect(find_email_for(@u_mentioned)).to have_header('X-GitLab-NotificationReason', 'mentioned')
              expect(find_email_for(@u_custom_global)).to have_header('X-GitLab-NotificationReason', '')
            end
          end

          context 'which is a top-level group' do
            let!(:group) { parent_group }

            it_behaves_like 'new note notifications'

            it_behaves_like 'project emails are disabled', check_delivery_jobs_queue: true do
              let(:notification_target)  { note }
              let(:notification_trigger) { notification.new_note(note) }
            end
          end

          context 'which is a subgroup' do
            let!(:group) { create(:group, parent: parent_group) }

            it_behaves_like 'new note notifications'

            it 'overrides child objects with global level' do
              user = create(:user)
              parent_group.add_developer(user)
              user.notification_settings_for(parent_group).watch!
              reset_delivered_emails!

              notification.new_note(note)

              expect_enqueud_email(user.id, note.id, nil, mail: ""note_issue_email"")
            end
          end
        end
      end
    end

    context 'confidential issue note' do
      let(:author) { create(:user) }
      let(:non_member) { create(:user) }
      let(:member) { create(:user) }
      let(:guest) { create(:user) }
      let(:admin) { create(:admin) }
      let(:confidential_issue) { create(:issue, :confidential, project: project, author: author, assignees: [assignee]) }
      let(:note) { create(:note_on_issue, noteable: confidential_issue, project: project, note: ""#{author.to_reference} #{assignee.to_reference} #{non_member.to_reference} #{member.to_reference} #{admin.to_reference}"") }
      let(:guest_watcher) { create_user_with_notification(:watch, ""guest-watcher-confidential"") }

      subject { notification.new_note(note) }

      before do
        project.add_developer(member)
        project.add_guest(guest)
        reset_delivered_emails!
      end

      it 'filters out users that can not read the issue' do
        subject

        expect_delivery_jobs_count(4)
        expect_enqueud_email(author.id, note.id, ""mentioned"", mail: ""note_issue_email"")
        expect_enqueud_email(assignee.id, note.id, ""mentioned"", mail: ""note_issue_email"")
        expect_enqueud_email(member.id, note.id, ""mentioned"", mail: ""note_issue_email"")
        expect_enqueud_email(admin.id, note.id, ""mentioned"", mail: ""note_issue_email"")
      end

      context 'on project that belongs to subgroup' do
        let(:group_reporter) { create(:user) }
        let(:group_guest) { create(:user) }
        let(:parent_group) { create(:group) }
        let(:child_group) { create(:group, parent: parent_group) }
        let(:project) { create(:project, namespace: child_group) }

        context 'when user is group guest member' do
          before do
            parent_group.add_reporter(group_reporter)
            parent_group.add_guest(group_guest)
            group_guest.notification_settings_for(parent_group).watch!
            group_reporter.notification_settings_for(parent_group).watch!
            reset_delivered_emails!
          end

          it 'does not email guest user' do
            subject

            expect_enqueud_email(group_reporter.id, note.id, nil, mail: ""note_issue_email"")
            expect_not_enqueud_email(group_guest.id, ""mentioned"", mail: ""note_issue_email"")
          end
        end
      end
    end

    context 'issue note mention', :deliver_mails_inline do
      let_it_be(:issue) { create(:issue, project: project, assignees: [assignee]) }
      let_it_be(:mentioned_issue) { create(:issue, assignees: issue.assignees) }
      let_it_be(:user_to_exclude) { create(:user) }
      let_it_be(:author) { create(:user) }

      let(:user_mentions) do
        other_members = [
          @unsubscribed_mentioned,
          @u_guest_watcher,
          @pg_watcher,
          @u_mentioned,
          @u_not_mentioned,
          @u_disabled,
          @pg_disabled
        ]

        (issue.project.team.members + other_members).map(&:to_reference).join(' ')
      end

      let(:note) { create(:note_on_issue, author: author, noteable: issue, project_id: issue.project_id, note: note_content) }

      before_all do
        build_team(project)
        build_group(project)
        add_users(project)
        add_user_subscriptions(issue)
        project.add_maintainer(author)
      end

      before do
        reset_delivered_emails!
      end

      describe '#new_note' do
        it 'notifies parent group members with mention level' do
          note = create(:note_on_issue, noteable: issue, project_id: issue.project_id, note: ""@#{@pg_mention.username}"")

          notification.new_note(note)

          should_email_nested_group_user(@pg_mention)
        end

        shared_examples 'correct team members are notified' do
          it 'notifies the team members' do
            notification.new_note(note)

            # Make sure @unsubscribed_mentioned is part of the team
            expect(note.project.team.members).to include(@unsubscribed_mentioned)

            # Notify all team members
            note.project.team.members.each do |member|
              # User with disabled notification should not be notified
              next if member.id == @u_disabled.id
              # Author should not be notified
              next if member.id == note.author.id

              should_email(member)
            end

            should_email(@u_guest_watcher)
            should_email(note.noteable.author)
            should_email(note.noteable.assignees.first)
            should_email_nested_group_user(@pg_watcher)
            should_email(@u_mentioned)
            should_email(@u_not_mentioned)
            should_not_email(note.author)
            should_not_email(@u_disabled)
            should_not_email_nested_group_user(@pg_disabled)
          end

          it 'filters out ""mentioned in"" notes' do
            mentioned_note = SystemNoteService.cross_reference(mentioned_issue, issue, issue.author)

            expect(Notify).not_to receive(:note_issue_email)
            notification.new_note(mentioned_note)
          end

          it_behaves_like 'project emails are disabled' do
            let(:notification_target)  { note }
            let(:notification_trigger) { notification.new_note(note) }
          end

          context 'when note is confidential' do
            let(:note) { create(:note_on_issue, author: author, noteable: issue, project_id: issue.project_id, note: note_content, confidential: true) }
            let(:guest) { create(:user) }

            it 'does not notify users that cannot read note' do
              project.add_guest(guest)
              reset_delivered_emails!

              notification.new_note(note)

              should_not_email(guest)
            end
          end
        end

        context 'when `disable_all_mention` FF is disabled' do
          before do
            stub_feature_flags(disable_all_mention: false)
          end

          context 'when `@all` mention is used' do
            let(:note_content) { ""@all mentioned"" }

            it_behaves_like 'correct team members are notified'
          end

          context 'when users are individually mentioned' do
            # `user_mentions` is concatenanting individual user mentions
            # so that the end result is the same as `@all`.
            let(:note_content) { ""#{user_mentions} mentioned"" }

            it_behaves_like 'correct team members are notified'
          end
        end

        context 'when `disable_all_mention` FF is enabled' do
          before do
            stub_feature_flags(disable_all_mention: true)
          end

          context 'when `@all` mention is used' do
            before_all do
              # user_to_exclude is in the note's project but is neither mentioned nor participating.
              project.add_maintainer(user_to_exclude)
            end

            let(:note_content) { ""@all mentioned"" }

            it ""does not notify users who are not participating or mentioned"" do
              reset_delivered_emails!

              notification.new_note(note)

              should_email(note.noteable.author)
              should_not_email(user_to_exclude)
            end
          end

          context 'when users are individually mentioned' do
            # `user_mentions` is concatenanting individual user mentions
            # so that the end result is the same as `@all`.
            let(:note_content) { ""#{user_mentions} mentioned"" }

            it_behaves_like 'correct team members are notified'
          end
        end
      end
    end

    context 'project snippet note', :deliver_mails_inline do
      let(:user_mentions) do
        other_members = [
          @u_custom_global,
          @u_guest_watcher,
          snippet.author, # snippet = note.noteable's author
          author, # note's author
          @u_disabled,
          @u_mentioned,
          @u_not_mentioned
        ]

        (snippet.project.team.members + other_members).map(&:to_reference).join(' ')
      end

      let(:snippet) { create(:project_snippet, project: project, author: create(:user)) }
      let(:author) { create(:user) }
      let(:note) { create(:note_on_project_snippet, author: author, noteable: snippet, project_id: project.id, note: note_content) }

      describe '#new_note' do
        shared_examples 'correct team members are notified' do
          before do
            build_team(project)
            build_group(project)
            project.add_maintainer(author)

            # make sure these users can read the project snippet!
            project.add_guest(@u_guest_watcher)
            project.add_guest(@u_guest_custom)
            add_member_for_parent_group(@pg_watcher, project)
            reset_delivered_emails!
          end

          it 'notifies the team members' do
            notification.new_note(note)
            # Notify all team members
            note.project.team.members.each do |member|
              # User with disabled notification should not be notified
              next if member.id == @u_disabled.id
              # Author should not be notified
              next if member.id == note.author.id

              should_email(member)
            end

            # it emails custom global users on mention
            should_email(@u_custom_global)

            should_email(@u_guest_watcher)
            should_email(note.noteable.author)
            should_not_email(note.author)
            should_email(@u_mentioned)
            should_not_email(@u_disabled)
            should_email(@u_not_mentioned)
          end
        end

        context 'when `disable_all_mention` FF is disabled' do
          before do
            stub_feature_flags(disable_all_mention: false)
          end

          context 'when `@all` mention is used' do
            let(:note_content) { ""@all mentioned"" }

            it_behaves_like 'correct team members are notified'
          end

          context 'when users are individually mentioned' do
            # `user_mentions` is concatenanting individual user mentions
            # so that the end result is the same as `@all`.
            let(:note_content) { ""#{user_mentions} mentioned"" }

            it_behaves_like 'correct team members are notified'
          end
        end

        context 'when `disable_all_mention` FF is enabled' do
          before do
            stub_feature_flags(disable_all_mention: true)
          end

          context 'when `@all` mention is used' do
            let(:user_to_exclude) { create(:user) }
            let(:note_content) { ""@all mentioned"" }

            before do
              project.add_maintainer(author)
              project.add_maintainer(user_to_exclude)

              reset_delivered_emails!
            end

            it ""does not notify users who are not participating or mentioned"" do
              notification.new_note(note)

              should_email(note.noteable.author)
              should_not_email(user_to_exclude)
            end
          end

          context 'when users are individually mentioned' do
            # `user_mentions` is concatenanting individual user mentions
            # so that the end result is the same as `@all`.
            let(:note_content) { ""#{user_mentions} mentioned"" }

            it_behaves_like 'correct team members are notified'
          end
        end
      end
    end

    context 'personal snippet note', :deliver_mails_inline do
      let(:snippet) { create(:personal_snippet, :public, author: @u_snippet_author) }
      let(:note)    { create(:note_on_personal_snippet, noteable: snippet, note: '@mentioned note', author: @u_note_author) }

      before do
        @u_watcher               = create_global_setting_for(create(:user), :watch)
        @u_participant           = create_global_setting_for(create(:user), :participating)
        @u_disabled              = create_global_setting_for(create(:user), :disabled)
        @u_mentioned             = create_global_setting_for(create(:user, username: 'mentioned'), :mention)
        @u_mentioned_level       = create_global_setting_for(create(:user, username: 'participator'), :mention)
        @u_note_author           = create(:user, username: 'note_author')
        @u_snippet_author        = create(:user, username: 'snippet_author')
        @u_not_mentioned         = create_global_setting_for(create(:user, username: 'regular'), :participating)

        reset_delivered_emails!
      end

      let!(:notes) do
        [
          create(:note_on_personal_snippet, noteable: snippet, note: 'note', author: @u_watcher),
          create(:note_on_personal_snippet, noteable: snippet, note: 'note', author: @u_participant),
          create(:note_on_personal_snippet, noteable: snippet, note: 'note', author: @u_mentioned),
          create(:note_on_personal_snippet, noteable: snippet, note: 'note', author: @u_disabled),
          create(:note_on_personal_snippet, noteable: snippet, note: 'note', author: @u_note_author)
        ]
      end

      describe '#new_note' do
        it 'notifies the participants' do
          notification.new_note(note)

          # it emails participants
          should_email(@u_watcher)
          should_email(@u_participant)
          should_email(@u_watcher)
          should_email(@u_snippet_author)

          # it emails mentioned users
          should_email(@u_mentioned)

          # it does not email participants with mention notification level
          should_not_email(@u_mentioned_level)

          # it does not email note author
          should_not_email(@u_note_author)
        end
      end
    end

    context 'commit note', :deliver_mails_inline do
      let_it_be(:project) { create(:project, :public, :repository) }
      let_it_be(:note) { create(:note_on_commit, project: project) }

      before_all do
        build_team(project)
        build_group(project)
        update_custom_notification(:new_note, @u_guest_custom, resource: project)
        update_custom_notification(:new_note, @u_custom_global)
      end

      before do
        reset_delivered_emails!
        allow(note.noteable).to receive(:author).and_return(@u_committer)
      end

      describe '#new_note, #perform_enqueued_jobs' do
        it do
          notification.new_note(note)
          should_email(@u_guest_watcher)
          should_email(@u_custom_global)
          should_email(@u_guest_custom)
          should_email(@u_committer)
          should_email(@u_watcher)
          should_email_nested_group_user(@pg_watcher)
          should_not_email(@u_mentioned)
          should_not_email(note.author)
          should_not_email(@u_participating)
          should_not_email(@u_disabled)
          should_not_email(@u_lazy_participant)
          should_not_email_nested_group_user(@pg_disabled)
        end

        it do
          note.update_attribute(:note, '@mention referenced')
          notification.new_note(note)

          should_email(@u_guest_watcher)
          should_email(@u_committer)
          should_email(@u_watcher)
          should_email(@u_mentioned)
          should_email_nested_group_user(@pg_watcher)
          should_not_email(note.author)
          should_not_email(@u_participating)
          should_not_email(@u_disabled)
          should_not_email(@u_lazy_participant)
          should_not_email_nested_group_user(@pg_disabled)
        end

        it do
          @u_committer = create_global_setting_for(@u_committer, :mention)
          notification.new_note(note)
          should_not_email(@u_committer)
        end

        it_behaves_like 'project emails are disabled' do
          let(:notification_target)  { note }
          let(:notification_trigger) { notification.new_note(note) }
        end
      end
    end

    context ""merge request diff note"", :deliver_mails_inline do
      let_it_be(:project) { create(:project, :repository) }
      let_it_be(:user) { create(:user) }
      let_it_be(:merge_request) { create(:merge_request, source_project: project, assignees: [user], author: create(:user)) }
      let_it_be(:note) { create(:diff_note_on_merge_request, project: project, noteable: merge_request) }

      before_all do
        build_team(note.project)
        project.add_maintainer(merge_request.author)
        merge_request.assignees.each { |assignee| project.add_maintainer(assignee) }
      end

      describe '#new_note' do
        it ""records sent notifications"" do
          # 3 SentNotification are sent: the MR assignee and author, and the @u_watcher
          expect(SentNotification).to receive(:record_note).with(note, any_args).exactly(3).times.and_call_original

          notification.new_note(note)

          expect(SentNotification.last(3).map(&:recipient).map(&:id))
            .to contain_exactly(*merge_request.assignees.pluck(:id), merge_request.author.id, @u_watcher.id)
          expect(SentNotification.last.in_reply_to_discussion_id).to eq(note.discussion_id)
        end

        it_behaves_like 'project emails are disabled' do
          let(:notification_target)  { note }
          let(:notification_trigger) { notification.new_note(note) }
        end
      end
    end

    context 'design diff note', :deliver_mails_inline do
      include DesignManagementTestHelpers

      let_it_be(:design) { create(:design, :with_file) }
      let_it_be(:project) { design.project }
      let_it_be(:member_and_mentioned) { create(:user, developer_projects: [project]) }
      let_it_be(:member_and_author_of_second_note) { create(:user, developer_projects: [project]) }
      let_it_be(:member_and_not_mentioned) { create(:user, developer_projects: [project]) }
      let_it_be(:non_member_and_mentioned) { create(:user) }
      let_it_be(:note) do
        create(
          :diff_note_on_design,
          noteable: design,
          note: ""Hello #{member_and_mentioned.to_reference}, G'day #{non_member_and_mentioned.to_reference}""
        )
      end

      let_it_be(:note_2) do
        create(:diff_note_on_design, noteable: design, author: member_and_author_of_second_note)
      end

      context 'design management is enabled' do
        before do
          enable_design_management
        end

        it 'sends new note notifications', :aggregate_failures do
          notification.new_note(note)

          should_email(design.authors.first)
          should_email(member_and_mentioned)
          should_email(member_and_author_of_second_note)
          should_not_email(member_and_not_mentioned)
          should_not_email(non_member_and_mentioned)
          should_not_email(note.author)
        end
      end

      context 'design management is disabled' do
        before do
          enable_design_management(false)
        end

        it 'does not notify anyone' do
          notification.new_note(note)

          should_not_email_anyone
        end
      end
    end
  end

  describe '#send_new_release_notifications', :deliver_mails_inline do
    let(:release) { create(:release, project: project, author: current_user) }
    let(:object) { release }
    let(:action) { notification.send_new_release_notifications(release) }

    before_all do
      build_team(project)

      update_custom_notification(:new_release, @u_guest_custom, resource: project)
      update_custom_notification(:new_release, @u_custom_global)
    end

    context 'when release author is blocked' do
      let(:current_user) { create(:user, :blocked) }

      include_examples 'is not able to send notifications'
    end

    context 'when release author is a ghost' do
      let(:current_user) { create(:user, :ghost) }

      include_examples 'is not able to send notifications'
    end

    context 'when recipients for a new release exist' do
      let(:current_user) { create(:user) }

      it 'notifies the expected users' do
        notification.send_new_release_notifications(release)

        should_only_email(
          @u_watcher,
          @u_guest_watcher,
          @u_custom_global,
          @u_guest_custom
        )
      end
    end
  end

  describe 'Participating project notification settings have priority over group and global settings if available', :deliver_mails_inline do
    let_it_be(:group) { create(:group) }
    let_it_be(:maintainer) { group.add_owner(create(:user, username: 'maintainer')).user }
    let_it_be(:user1) { group.add_developer(create(:user, username: 'user_with_project_and_custom_setting')).user }
    let_it_be(:project) { create(:project, :public, namespace: group) }

    let(:issue) { create :issue, project: project, assignees: [assignee], description: '' }

    before do
      reset_delivered_emails!

      create_notification_setting(user1, project, :participating)
    end

    context 'custom on group' do
      [nil, true].each do |new_issue_value|
        value_caption = new_issue_value || 'nil'
        it ""does not send an email to user1 when a new issue is created and new_issue is set to #{value_caption}"" do
          update_custom_notification(:new_issue, user1, resource: group, value: new_issue_value)

          notification.new_issue(issue, maintainer)
          should_not_email(user1)
        end
      end
    end

    context 'watch on group' do
      it 'does not send an email' do
        user1.notification_settings_for(group).update!(level: :watch)

        notification.new_issue(issue, maintainer)
        should_not_email(user1)
      end
    end

    context 'custom on global, global on group' do
      it 'does not send an email' do
        user1.notification_settings_for(nil).update!(level: :custom)

        user1.notification_settings_for(group).update!(level: :global)

        notification.new_issue(issue, maintainer)
        should_not_email(user1)
      end
    end

    context 'watch on global, global on group' do
      it 'does not send an email' do
        user1.notification_settings_for(nil).update!(level: :watch)

        user1.notification_settings_for(group).update!(level: :global)

        notification.new_issue(issue, maintainer)
        should_not_email(user1)
      end
    end
  end

  describe 'Issues', :aggregate_failures do
    let(:another_project) { create(:project, :public, namespace: group) }
    let(:issue) { create :issue, project: project, assignees: [assignee], description: 'cc @participant @unsubscribed_mentioned' }

    let_it_be(:group) { create(:group) }
    let_it_be(:project) { create(:project, :public, namespace: group) }

    before_all do
      build_team(project)
      build_group(project)
      add_users(project)
    end

    before do
      project.reload
      add_user_subscriptions(issue)
      reset_delivered_emails!
      update_custom_notification(:new_issue, @u_guest_custom, resource: project)
      update_custom_notification(:new_issue, @u_custom_global)

      issue.author.notified_of_own_activity = false
    end

    describe '#new_issue' do
      it 'notifies the expected users' do
        expect do
          notification.new_issue(issue, @u_disabled)
        end.to enqueue_mail_with(Notify, :new_issue_email, assignee, issue, 'assigned')
          .and(enqueue_mail_with(Notify, :new_issue_email, @u_watcher, issue, nil))
          .and(enqueue_mail_with(Notify, :new_issue_email, @u_guest_watcher, issue, nil))
          .and(enqueue_mail_with(Notify, :new_issue_email, @u_guest_custom, issue, nil))
          .and(enqueue_mail_with(Notify, :new_issue_email, @u_custom_global, issue, nil))
          .and(enqueue_mail_with(Notify, :new_issue_email, @u_participant_mentioned, issue, 'mentioned'))
          .and(enqueue_mail_with(Notify, :new_issue_email, @g_global_watcher.id, issue.id, nil))
          .and(enqueue_mail_with(Notify, :new_issue_email, @g_watcher, issue, nil))
          .and(enqueue_mail_with(Notify, :new_issue_email, @unsubscribed_mentioned, issue, 'mentioned'))
          .and(enqueue_mail_with(Notify, :new_issue_email, @pg_watcher, issue, nil))
          .and(not_enqueue_mail_with(Notify, :new_issue_email, @u_mentioned, anything, anything))
          .and(not_enqueue_mail_with(Notify, :new_issue_email, @u_participating, anything, anything))
          .and(not_enqueue_mail_with(Notify, :new_issue_email, @u_disabled, anything, anything))
          .and(not_enqueue_mail_with(Notify, :new_issue_email, @u_lazy_participant, anything, anything))
          .and(not_enqueue_mail_with(Notify, :new_issue_email, @pg_disabled, anything, anything))
          .and(not_enqueue_mail_with(Notify, :new_issue_email, @pg_mention, anything, anything))
      end

      context 'when user has an only mention notification setting' do
        before do
          create_global_setting_for(issue.assignees.first, :mention)
        end

        it 'does not send assignee notifications' do
          expect do
            notification.new_issue(issue, @u_disabled)
          end.to not_enqueue_mail_with(Notify, :new_issue_email, issue.assignees.first, anything, anything)
        end
      end

      it 'properly prioritizes notification reason' do
        # have assignee be both assigned and mentioned
        issue.update_attribute(:description, ""/cc #{assignee.to_reference} #{@u_mentioned.to_reference}"")

        expect do
          notification.new_issue(issue, @u_disabled)
        end.to enqueue_mail_with(Notify, :new_issue_email, assignee, issue, 'assigned')
          .and(enqueue_mail_with(Notify, :new_issue_email, @u_mentioned, issue, 'mentioned'))
      end

      it 'adds ""assigned"" reason for assignees if any' do
        expect do
          notification.new_issue(issue, @u_disabled)
        end.to enqueue_mail_with(Notify, :new_issue_email, assignee, issue, 'assigned')
      end

      it ""emails any mentioned users with the mention level"" do
        issue.description = @u_mentioned.to_reference

        expect do
          notification.new_issue(issue, @u_disabled)
        end.to enqueue_mail_with(Notify, :new_issue_email, @u_mentioned, issue, 'mentioned')
      end

      it ""emails the author if they've opted into notifications about their activity"" do
        issue.author.notified_of_own_activity = true

        expect do
          notification.new_issue(issue, issue.author)
        end.to enqueue_mail_with(Notify, :new_issue_email, issue.author, issue, 'own_activity')
      end

      it ""doesn't email the author if they haven't opted into notifications about their activity"" do
        expect do
          notification.new_issue(issue, issue.author)
        end.to not_enqueue_mail_with(Notify, :new_issue_email, issue.author, anything, anything)
      end

      it ""emails subscribers of the issue's labels and adds `subscribed` reason"" do
        user_1 = create(:user)
        user_2 = create(:user)
        user_3 = create(:user)
        user_4 = create(:user)
        label = create(:label, project: project, issues: [issue])
        group_label = create(:group_label, group: group, issues: [issue])
        issue.reload
        label.toggle_subscription(user_1, project)
        group_label.toggle_subscription(user_2, project)
        group_label.toggle_subscription(user_3, another_project)
        group_label.toggle_subscription(user_4)

        expect do
          notification.new_issue(issue, issue.author)
        end.to enqueue_mail_with(Notify, :new_issue_email, user_1, issue, NotificationReason::SUBSCRIBED)
          .and(enqueue_mail_with(Notify, :new_issue_email, user_2, issue, NotificationReason::SUBSCRIBED))
          .and(enqueue_mail_with(Notify, :new_issue_email, user_4, issue, NotificationReason::SUBSCRIBED))
          .and(not_enqueue_mail_with(Notify, :new_issue_email, user_3, anything, anything))
      end

      it_behaves_like 'project emails are disabled', check_delivery_jobs_queue: true do
        let(:notification_target)  { issue }
        let(:notification_trigger) { notification.new_issue(issue, @u_disabled) }
      end

      context 'confidential issues' do
        let(:author) { create(:user) }
        let(:non_member) { create(:user) }
        let(:member) { create(:user) }
        let(:guest) { create(:user) }
        let(:admin) { create(:admin) }
        let(:confidential_issue) { create(:issue, :confidential, project: project, title: 'Confidential issue', author: author, assignees: [assignee]) }

        it ""emails subscribers of the issue's labels that can read the issue"" do
          project.add_developer(member)
          project.add_guest(guest)

          label = create(:label, project: project, issues: [confidential_issue])
          confidential_issue.reload
          label.toggle_subscription(non_member, project)
          label.toggle_subscription(author, project)
          label.toggle_subscription(assignee, project)
          label.toggle_subscription(member, project)
          label.toggle_subscription(guest, project)
          label.toggle_subscription(admin, project)

          expect do
            notification.new_issue(confidential_issue, issue.author)
          end.to enqueue_mail_with(Notify, :new_issue_email, assignee, confidential_issue, NotificationReason::ASSIGNED)
            .and(enqueue_mail_with(Notify, :new_issue_email, member, confidential_issue, NotificationReason::SUBSCRIBED))
            .and(enqueue_mail_with(Notify, :new_issue_email, admin, confidential_issue, NotificationReason::SUBSCRIBED))
            .and(not_enqueue_mail_with(Notify, :new_issue_email, @u_guest_watcher, anything, anything))
            .and(not_enqueue_mail_with(Notify, :new_issue_email, non_member, anything, anything))
            .and(not_enqueue_mail_with(Notify, :new_issue_email, author, anything, anything))
            .and(not_enqueue_mail_with(Notify, :new_issue_email, guest, anything, anything))
        end
      end

      context 'when the author is not allowed to trigger notifications' do
        let(:object) { issue }
        let(:action) { notification.new_issue(issue, current_user) }
        let(:notification_method) { :new_issue_email }

        context 'because they are blocked' do
          let(:current_user) { create(:user, :blocked) }

          include_examples 'is not able to send notifications', check_delivery_jobs_queue: true
        end

        context 'because they are a ghost' do
          let(:current_user) { create(:user, :ghost) }

          include_examples 'is not able to send notifications', check_delivery_jobs_queue: true
        end
      end
    end

    describe '#new_mentions_in_issue' do
      let(:notification_method) { :new_mentions_in_issue }
      let(:mentionable) { issue }
      let(:object) { mentionable }
      let(:action) { send_notifications(@u_mentioned, current_user: current_user) }

      it 'sends no emails when no new mentions are present' do
        send_notifications

        expect_no_delivery_jobs
      end

      it 'emails new mentions with a watch level higher than mention' do
        expect do
          send_notifications(@u_watcher, @u_participant_mentioned, @u_custom_global, @u_mentioned)
        end.to have_only_enqueued_mail_with_args(
          Notify,
          :new_mention_in_issue_email,
          [@u_watcher.id, mentionable.id, anything, anything],
          [@u_participant_mentioned.id, mentionable.id, anything, anything],
          [@u_custom_global.id, mentionable.id, anything, anything],
          [@u_mentioned.id, mentionable.id, anything, anything]
        )
      end

      it 'does not email new mentions with a watch level equal to or less than mention' do
        send_notifications(@u_disabled)

        expect_no_delivery_jobs
      end

      it 'emails new mentions despite being unsubscribed' do
        expect do
          send_notifications(@unsubscribed_mentioned)
        end.to have_only_enqueued_mail_with_args(
          Notify,
          :new_mention_in_issue_email,
          [@unsubscribed_mentioned.id, mentionable.id, anything, anything]
        )
      end

      it 'sends the proper notification reason header' do
        expect do
          send_notifications(@u_watcher)
        end.to have_only_enqueued_mail_with_args(
          Notify,
          :new_mention_in_issue_email,
          [@u_watcher.id, mentionable.id, anything, NotificationReason::MENTIONED]
        )
      end

      it_behaves_like 'project emails are disabled', check_delivery_jobs_queue: true do
        let(:notification_target)  { issue }
        let(:notification_trigger) { send_notifications(@u_watcher, @u_participant_mentioned, @u_custom_global, @u_mentioned) }
      end

      context 'where current_user is blocked' do
        let(:current_user) { create(:user, :blocked) }

        include_examples 'is not able to send notifications', check_delivery_jobs_queue: true
      end

      context 'where current_user is a ghost' do
        let(:current_user) { create(:user, :ghost) }

        include_examples 'is not able to send notifications', check_delivery_jobs_queue: true
      end
    end

    describe '#reassigned_issue' do
      let(:anything_args) { [anything, anything, anything, anything] }
      let(:mailer_method) { :reassigned_issue_email }

      before do
        update_custom_notification(:reassign_issue, @u_guest_custom, resource: project)
        update_custom_notification(:reassign_issue, @u_custom_global)
      end

      it 'emails new assignee' do
        expect do
          notification.reassigned_issue(issue, @u_disabled, [assignee])
        end.to enqueue_mail_with(Notify, :reassigned_issue_email, issue.assignees.first, *anything_args)
          .and(enqueue_mail_with(Notify, :reassigned_issue_email, @u_watcher, *anything_args))
          .and(enqueue_mail_with(Notify, :reassigned_issue_email, @u_guest_watcher, *anything_args))
          .and(enqueue_mail_with(Notify, :reassigned_issue_email, @u_guest_custom, *anything_args))
          .and(enqueue_mail_with(Notify, :reassigned_issue_email, @u_custom_global, *anything_args))
          .and(enqueue_mail_with(Notify, :reassigned_issue_email, @u_participant_mentioned, *anything_args))
          .and(enqueue_mail_with(Notify, :reassigned_issue_email, @subscriber, *anything_args))
          .and(not_enqueue_mail_with(Notify, :reassigned_issue_email, @unsubscriber, *anything_args))
          .and(not_enqueue_mail_with(Notify, :reassigned_issue_email, @u_participating, *anything_args))
          .and(not_enqueue_mail_with(Notify, :reassigned_issue_email, @u_disabled, *anything_args))
          .and(not_enqueue_mail_with(Notify, :reassigned_issue_email, @u_lazy_participant, *anything_args))
      end

      it 'adds ""assigned"" reason for new assignee' do
        expect do
          notification.reassigned_issue(issue, @u_disabled, [assignee])
        end.to enqueue_mail_with(
          Notify,
          :reassigned_issue_email,
          issue.assignees.first,
          anything,
          anything,
          anything,
          NotificationReason::ASSIGNED
        )
      end

      it 'emails previous assignee even if they have the ""on mention"" notif level' do
        issue.assignees = [@u_mentioned]

        expect do
          notification.reassigned_issue(issue, @u_disabled, [@u_watcher])
        end.to enqueue_mail_with(Notify, :reassigned_issue_email, @u_mentioned, *anything_args)
          .and(enqueue_mail_with(Notify, :reassigned_issue_email, @u_watcher, *anything_args))
          .and(enqueue_mail_with(Notify, :reassigned_issue_email, @u_guest_watcher, *anything_args))
          .and(enqueue_mail_with(Notify, :reassigned_issue_email, @u_guest_custom, *anything_args))
          .and(enqueue_mail_with(Notify, :reassigned_issue_email, @u_participant_mentioned, *anything_args))
          .and(enqueue_mail_with(Notify, :reassigned_issue_email, @subscriber, *anything_args))
          .and(enqueue_mail_with(Notify, :reassigned_issue_email, @u_custom_global, *anything_args))
          .and(not_enqueue_mail_with(Notify, :reassigned_issue_email, @unsubscriber, *anything_args))
          .and(not_enqueue_mail_with(Notify, :reassigned_issue_email, @u_participating, *anything_args))
          .and(not_enqueue_mail_with(Notify, :reassigned_issue_email, @u_disabled, *anything_args))
          .and(not_enqueue_mail_with(Notify, :reassigned_issue_email, @u_lazy_participant, *anything_args))
      end

      it 'emails new assignee even if they have the ""on mention"" notif level' do
        issue.assignees = [@u_mentioned]

        expect(issue.assignees.first).to eq(@u_mentioned)
        expect do
          notification.reassigned_issue(issue, @u_disabled, [@u_mentioned])
        end.to enqueue_mail_with(Notify, :reassigned_issue_email, issue.assignees.first, *anything_args)
          .and(enqueue_mail_with(Notify, :reassigned_issue_email, @u_watcher, *anything_args))
          .and(enqueue_mail_with(Notify, :reassigned_issue_email, @u_guest_watcher, *anything_args))
          .and(enqueue_mail_with(Notify, :reassigned_issue_email, @u_guest_custom, *anything_args))
          .and(enqueue_mail_with(Notify, :reassigned_issue_email, @u_participant_mentioned, *anything_args))
          .and(enqueue_mail_with(Notify, :reassigned_issue_email, @subscriber, *anything_args))
          .and(enqueue_mail_with(Notify, :reassigned_issue_email, @u_custom_global, *anything_args))
          .and(not_enqueue_mail_with(Notify, :reassigned_issue_email, @unsubscriber, *anything_args))
          .and(not_enqueue_mail_with(Notify, :reassigned_issue_email, @u_participating, *anything_args))
          .and(not_enqueue_mail_with(Notify, :reassigned_issue_email, @u_disabled, *anything_args))
          .and(not_enqueue_mail_with(Notify, :reassigned_issue_email, @u_lazy_participant, *anything_args))
      end

      it 'does not email new assignee if they are the current user' do
        issue.assignees = [@u_mentioned]
        notification.reassigned_issue(issue, @u_mentioned, [@u_mentioned])

        expect(issue.assignees.first).to eq(@u_mentioned)
        expect do
          notification.reassigned_issue(issue, @u_mentioned, [@u_mentioned])
        end.to enqueue_mail_with(Notify, :reassigned_issue_email, @u_watcher, *anything_args)
          .and(enqueue_mail_with(Notify, :reassigned_issue_email, @u_guest_watcher, *anything_args))
          .and(enqueue_mail_with(Notify, :reassigned_issue_email, @u_guest_custom, *anything_args))
          .and(enqueue_mail_with(Notify, :reassigned_issue_email, @u_participant_mentioned, *anything_args))
          .and(enqueue_mail_with(Notify, :reassigned_issue_email, @subscriber, *anything_args))
          .and(enqueue_mail_with(Notify, :reassigned_issue_email, @u_custom_global, *anything_args))
          .and(not_enqueue_mail_with(Notify, :reassigned_issue_email, issue.assignees.first, *anything_args))
          .and(not_enqueue_mail_with(Notify, :reassigned_issue_email, @unsubscriber, *anything_args))
          .and(not_enqueue_mail_with(Notify, :reassigned_issue_email, @u_participating, *anything_args))
          .and(not_enqueue_mail_with(Notify, :reassigned_issue_email, @u_disabled, *anything_args))
          .and(not_enqueue_mail_with(Notify, :reassigned_issue_email, @u_lazy_participant, *anything_args))
      end

      it_behaves_like 'participating notifications', check_delivery_jobs_queue: true do
        let(:participant) { create(:user, username: 'user-participant') }
        let(:issuable) { issue }
        let(:notification_trigger) { notification.reassigned_issue(issue, @u_disabled, [assignee]) }
      end

      it_behaves_like 'participating by confidential note notification', check_delivery_jobs_queue: true do
        let(:issuable) { issue }
        let(:notification_trigger) { notification.reassigned_issue(issue, @u_disabled, [assignee]) }
      end

      it_behaves_like 'project emails are disabled', check_delivery_jobs_queue: true do
        let(:notification_target)  { issue }
        let(:notification_trigger) { notification.reassigned_issue(issue, @u_disabled, [assignee]) }
      end
    end

    describe '#relabeled_issue', :deliver_mails_inline do
      let(:group_label_1) { create(:group_label, group: group, title: 'Group Label 1', issues: [issue]) }
      let(:group_label_2) { create(:group_label, group: group, title: 'Group Label 2') }
      let(:label_1) { create(:label, project: project, title: 'Label 1', issues: [issue]) }
      let(:label_2) { create(:label, project: project, title: 'Label 2') }
      let!(:subscriber_to_group_label_1) { create(:user) { |u| group_label_1.toggle_subscription(u, project) } }
      let!(:subscriber_1_to_group_label_2) { create(:user) { |u| group_label_2.toggle_subscription(u, project) } }
      let!(:subscriber_2_to_group_label_2) { create(:user) { |u| group_label_2.toggle_subscription(u) } }
      let!(:subscriber_to_group_label_2_on_another_project) { create(:user) { |u| group_label_2.toggle_subscription(u, another_project) } }
      let!(:subscriber_to_label_1) { create(:user) { |u| label_1.toggle_subscription(u, project) } }
      let!(:subscriber_to_label_2) { create(:user) { |u| label_2.toggle_subscription(u, project) } }

      it ""emails the current user if they've opted into notifications about their activity"" do
        subscriber_to_label_2.notified_of_own_activity = true
        notification.relabeled_issue(issue, [group_label_2, label_2], subscriber_to_label_2)

        should_email(subscriber_to_label_2)
      end

      it ""doesn't email the current user if they haven't opted into notifications about their activity"" do
        notification.relabeled_issue(issue, [group_label_2, label_2], subscriber_to_label_2)

        should_not_email(subscriber_to_label_2)
      end

      it ""doesn't send email to anyone but subscribers of the given labels"" do
        notification.relabeled_issue(issue, [group_label_2, label_2], @u_disabled)

        should_not_email(subscriber_to_label_1)
        should_not_email(subscriber_to_group_label_1)
        should_not_email(subscriber_to_group_label_2_on_another_project)
        should_email(subscriber_1_to_group_label_2)
        should_email(subscriber_2_to_group_label_2)
        should_email(subscriber_to_label_2)
        should_not_email(issue.assignees.first)
        should_not_email(issue.author)
        should_not_email(@u_watcher)
        should_not_email(@u_guest_watcher)
        should_not_email(@u_participant_mentioned)
        should_not_email(@subscriber)
        should_not_email(@watcher_and_subscriber)
        should_not_email(@unsubscriber)
        should_not_email(@u_participating)
      end

      it ""doesn't send multiple email when a user is subscribed to multiple given labels"" do
        subscriber_to_both = create(:user) do |user|
          [label_1, label_2].each { |label| label.toggle_subscription(user, project) }
        end

        notification.relabeled_issue(issue, [label_1, label_2], @u_disabled)

        should_email(subscriber_to_label_1)
        should_email(subscriber_to_label_2)
        should_email(subscriber_to_both)
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { issue }
        let(:notification_trigger) { notification.relabeled_issue(issue, [group_label_2, label_2], @u_disabled) }
      end

      context 'confidential issues' do
        let(:author) { create(:user) }
        let(:non_member) { create(:user) }
        let(:member) { create(:user) }
        let(:guest) { create(:user) }
        let(:admin) { create(:admin) }
        let(:confidential_issue) { create(:issue, :confidential, project: project, title: 'Confidential issue', author: author, assignees: [assignee]) }
        let!(:label_1) { create(:label, project: project, issues: [confidential_issue]) }
        let!(:label_2) { create(:label, project: project) }

        it ""emails subscribers of the issue's labels that can read the issue"" do
          project.add_developer(member)
          project.add_guest(guest)

          label_2.toggle_subscription(non_member, project)
          label_2.toggle_subscription(author, project)
          label_2.toggle_subscription(assignee, project)
          label_2.toggle_subscription(member, project)
          label_2.toggle_subscription(guest, project)
          label_2.toggle_subscription(admin, project)

          reset_delivered_emails!

          notification.relabeled_issue(confidential_issue, [label_2], @u_disabled)

          should_not_email(non_member)
          should_not_email(guest)
          should_email(author)
          should_email(assignee)
          should_email(member)
          should_email(admin)
        end
      end
    end

    describe '#removed_milestone on Issue', :deliver_mails_inline do
      context do
        let(:milestone) { create(:milestone, project: project, issues: [issue]) }
        let!(:subscriber_to_new_milestone) { create(:user) { |u| issue.toggle_subscription(u, project) } }

        it_behaves_like 'altered milestone notification on issue' do
          before do
            notification.removed_milestone(issue, issue.author)
          end
        end

        it_behaves_like 'project emails are disabled' do
          let(:notification_target)  { issue }
          let(:notification_trigger) { notification.removed_milestone(issue, issue.author) }
        end

        it_behaves_like 'participating by confidential note notification' do
          let(:issuable) { issue }
          let(:notification_trigger) { notification.removed_milestone(issue, issue.author) }
        end
      end

      context 'confidential issues' do
        let(:author) { create(:user) }
        let(:non_member) { create(:user) }
        let(:member) { create(:user) }
        let(:guest) { create(:user) }
        let(:admin) { create(:admin) }
        let(:confidential_issue) { create(:issue, :confidential, project: project, title: 'Confidential issue', author: author, assignees: [assignee]) }
        let(:milestone) { create(:milestone, project: project, issues: [confidential_issue]) }

        it ""emails subscribers of the issue's milestone that can read the issue"" do
          project.add_developer(member)
          project.add_guest(guest)

          confidential_issue.subscribe(non_member, project)
          confidential_issue.subscribe(author, project)
          confidential_issue.subscribe(assignee, project)
          confidential_issue.subscribe(member, project)
          confidential_issue.subscribe(guest, project)
          confidential_issue.subscribe(admin, project)

          reset_delivered_emails!

          notification.removed_milestone(confidential_issue, @u_disabled)

          should_not_email(non_member)
          should_not_email(guest)
          should_email(author)
          should_email(assignee)
          should_email(member)
          should_email(admin)
        end
      end
    end

    describe '#changed_milestone on Issue', :deliver_mails_inline do
      context do
        let(:new_milestone) { create(:milestone, project: project, issues: [issue]) }
        let!(:subscriber_to_new_milestone) { create(:user) { |u| issue.toggle_subscription(u, project) } }

        it_behaves_like 'altered milestone notification on issue' do
          before do
            notification.changed_milestone(issue, new_milestone, issue.author)
          end
        end

        it_behaves_like 'project emails are disabled' do
          let(:notification_target)  { issue }
          let(:notification_trigger) { notification.changed_milestone(issue, new_milestone, issue.author) }
        end
      end

      context 'confidential issues' do
        let(:author) { create(:user) }
        let(:non_member) { create(:user) }
        let(:member) { create(:user) }
        let(:guest) { create(:user) }
        let(:admin) { create(:admin) }
        let(:confidential_issue) { create(:issue, :confidential, project: project, title: 'Confidential issue', author: author, assignees: [assignee]) }
        let(:new_milestone) { create(:milestone, project: project, issues: [confidential_issue]) }

        it ""emails subscribers of the issue's milestone that can read the issue"" do
          project.add_developer(member)
          project.add_guest(guest)

          confidential_issue.subscribe(non_member, project)
          confidential_issue.subscribe(author, project)
          confidential_issue.subscribe(assignee, project)
          confidential_issue.subscribe(member, project)
          confidential_issue.subscribe(guest, project)
          confidential_issue.subscribe(admin, project)

          reset_delivered_emails!

          notification.changed_milestone(confidential_issue, new_milestone, @u_disabled)

          should_not_email(non_member)
          should_not_email(guest)
          should_email(author)
          should_email(assignee)
          should_email(member)
          should_email(admin)
        end
      end
    end

    describe '#close_issue', :deliver_mails_inline do
      before do
        update_custom_notification(:close_issue, @u_guest_custom, resource: project)
        update_custom_notification(:close_issue, @u_custom_global)
      end

      it 'sends email to issue assignee and issue author' do
        notification.close_issue(issue, @u_disabled)

        should_email(issue.assignees.first)
        should_email(issue.author)
        should_email(@u_watcher)
        should_email(@u_guest_watcher)
        should_email(@u_guest_custom)
        should_email(@u_custom_global)
        should_email(@u_participant_mentioned)
        should_email(@subscriber)
        should_email(@watcher_and_subscriber)
        should_not_email(@unsubscriber)
        should_not_email(@u_participating)
        should_not_email(@u_disabled)
        should_not_email(@u_lazy_participant)
      end

      it_behaves_like 'participating notifications' do
        let(:participant) { create(:user, username: 'user-participant') }
        let(:issuable) { issue }
        let(:notification_trigger) { notification.close_issue(issue, @u_disabled) }
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { issue }
        let(:notification_trigger) { notification.close_issue(issue, @u_disabled) }
      end

      it_behaves_like 'participating by confidential note notification' do
        let(:issuable) { issue }
        let(:notification_trigger) { notification.close_issue(issue, @u_disabled) }
      end

      it 'adds ""subscribed"" reason to subscriber emails' do
        user_1 = create(:user)
        issue.subscribe(user_1)
        issue.reload

        notification.close_issue(issue, @u_disabled)

        email = find_email_for(user_1)
        expect(email).to have_header('X-GitLab-NotificationReason', NotificationReason::SUBSCRIBED)
      end
    end

    describe '#reopen_issue', :deliver_mails_inline do
      before do
        update_custom_notification(:reopen_issue, @u_guest_custom, resource: project)
        update_custom_notification(:reopen_issue, @u_custom_global)
      end

      it 'sends email to issue notification recipients' do
        notification.reopen_issue(issue, @u_disabled)

        should_email(issue.assignees.first)
        should_email(issue.author)
        should_email(@u_watcher)
        should_email(@u_guest_watcher)
        should_email(@u_guest_custom)
        should_email(@u_custom_global)
        should_email(@u_participant_mentioned)
        should_email(@subscriber)
        should_email(@watcher_and_subscriber)
        should_not_email(@unsubscriber)
        should_not_email(@u_participating)
        should_not_email(@u_disabled)
        should_not_email(@u_lazy_participant)
      end

      it_behaves_like 'participating notifications' do
        let(:participant) { create(:user, username: 'user-participant') }
        let(:issuable) { issue }
        let(:notification_trigger) { notification.reopen_issue(issue, @u_disabled) }
      end

      it_behaves_like 'participating by confidential note notification' do
        let(:issuable) { issue }
        let(:notification_trigger) { notification.reopen_issue(issue, @u_disabled) }
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { issue }
        let(:notification_trigger) { notification.reopen_issue(issue, @u_disabled) }
      end
    end

    describe '#issue_moved', :deliver_mails_inline do
      let(:new_issue) { create(:issue) }

      it 'sends email to issue notification recipients' do
        notification.issue_moved(issue, new_issue, @u_disabled)

        should_email(issue.assignees.first)
        should_email(issue.author)
        should_email(@u_watcher)
        should_email(@u_guest_watcher)
        should_email(@u_participant_mentioned)
        should_email(@subscriber)
        should_email(@watcher_and_subscriber)
        should_not_email(@unsubscriber)
        should_not_email(@u_participating)
        should_not_email(@u_disabled)
        should_not_email(@u_lazy_participant)
      end

      it_behaves_like 'participating notifications' do
        let(:participant) { create(:user, username: 'user-participant') }
        let(:issuable) { issue }
        let(:notification_trigger) { notification.issue_moved(issue, new_issue, @u_disabled) }
      end

      it_behaves_like 'participating by confidential note notification' do
        let(:issuable) { issue }
        let(:notification_trigger) { notification.issue_moved(issue, new_issue, @u_disabled) }
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { issue }
        let(:notification_trigger) { notification.issue_moved(issue, new_issue, @u_disabled) }
      end
    end

    describe '#issue_cloned', :deliver_mails_inline do
      let(:new_issue) { create(:issue) }

      it 'sends email to issue notification recipients' do
        notification.issue_cloned(issue, new_issue, @u_disabled)

        should_email(issue.assignees.first)
        should_email(issue.author)
        should_email(@u_watcher)
        should_email(@u_guest_watcher)
        should_email(@u_participant_mentioned)
        should_email(@subscriber)
        should_email(@watcher_and_subscriber)
        should_not_email(@unsubscriber)
        should_not_email(@u_participating)
        should_not_email(@u_disabled)
        should_not_email(@u_lazy_participant)
      end

      it_behaves_like 'participating notifications' do
        let(:participant) { create(:user, username: 'user-participant') }
        let(:issuable) { issue }
        let(:notification_trigger) { notification.issue_cloned(issue, new_issue, @u_disabled) }
      end

      it_behaves_like 'participating by confidential note notification' do
        let(:issuable) { issue }
        let(:notification_trigger) { notification.issue_cloned(issue, new_issue, @u_disabled) }
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { issue }
        let(:notification_trigger) { notification.issue_cloned(issue, new_issue, @u_disabled) }
      end
    end

    describe '#issue_due', :deliver_mails_inline do
      before do
        issue.update!(due_date: Date.today)

        update_custom_notification(:issue_due, @u_guest_custom, resource: project)
        update_custom_notification(:issue_due, @u_custom_global)
      end

      it 'sends email to issue notification recipients, excluding watchers' do
        notification.issue_due(issue)

        should_email(issue.assignees.first)
        should_email(issue.author)
        should_email(@u_guest_custom)
        should_email(@u_custom_global)
        should_email(@u_participant_mentioned)
        should_email(@subscriber)
        should_email(@watcher_and_subscriber)
        should_not_email(@u_watcher)
        should_not_email(@u_guest_watcher)
        should_not_email(@unsubscriber)
        should_not_email(@u_participating)
        should_not_email(@u_disabled)
        should_not_email(@u_lazy_participant)
      end

      it 'sends the email from the author' do
        notification.issue_due(issue)
        email = find_email_for(@subscriber)

        expect(email.header[:from].display_names).to eq([""#{issue.author.name} (@#{issue.author.username})""])
      end

      it_behaves_like 'participating notifications' do
        let(:participant) { create(:user, username: 'user-participant') }
        let(:issuable) { issue }
        let(:notification_trigger) { notification.issue_due(issue) }
      end

      it_behaves_like 'participating by confidential note notification' do
        let(:issuable) { issue }
        let(:notification_trigger) { notification.issue_due(issue) }
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { issue }
        let(:notification_trigger) { notification.issue_due(issue) }
      end
    end
  end

  describe 'Merge Requests', :deliver_mails_inline do
    let(:another_project) { create(:project, :public, namespace: group) }
    let(:assignees) { Array.wrap(assignee) }
    let(:merge_request) { create :merge_request, author: author, source_project: project, assignees: assignees, description: 'cc @participant' }

    let_it_be_with_reload(:author) { create(:user) }
    let_it_be(:group) { create(:group) }
    let_it_be(:project) { create(:project, :public, :repository, namespace: group) }

    before_all do
      build_team(project)
      add_users(project)

      project.add_maintainer(author)
      project.add_maintainer(assignee)
    end

    before do
      add_user_subscriptions(merge_request)
      update_custom_notification(:new_merge_request, @u_guest_custom, resource: project)
      update_custom_notification(:new_merge_request, @u_custom_global)
      reset_delivered_emails!
    end

    describe '#new_merge_request' do
      it do
        notification.new_merge_request(merge_request, @u_disabled)

        merge_request.assignees.each { |assignee| should_email(assignee) }
        should_email(@u_watcher)
        should_email(@watcher_and_subscriber)
        should_email(@u_participant_mentioned)
        should_email(@u_guest_watcher)
        should_email(@u_guest_custom)
        should_email(@u_custom_global)
        should_not_email(@u_participating)
        should_not_email(@u_disabled)
        should_not_email(@u_lazy_participant)
      end

      it 'adds ""assigned"" reason for assignee, if any' do
        notification.new_merge_request(merge_request, @u_disabled)

        merge_request.assignees.each do |assignee|
          email = find_email_for(assignee)

          expect(email).to have_header('X-GitLab-NotificationReason', NotificationReason::ASSIGNED)
        end
      end

      it ""emails any mentioned users with the mention level"" do
        merge_request.description = @u_mentioned.to_reference

        notification.new_merge_request(merge_request, @u_disabled)

        should_email(@u_mentioned)
      end

      it ""emails the author if they've opted into notifications about their activity"" do
        merge_request.author.notified_of_own_activity = true

        notification.new_merge_request(merge_request, merge_request.author)

        should_email(merge_request.author)

        email = find_email_for(merge_request.author)
        expect(email).to have_header('X-GitLab-NotificationReason', NotificationReason::OWN_ACTIVITY)
      end

      it ""doesn't email the author if they haven't opted into notifications about their activity"" do
        notification.new_merge_request(merge_request, merge_request.author)

        should_not_email(merge_request.author)
      end

      it ""emails subscribers of the merge request's labels"" do
        user_1 = create(:user)
        user_2 = create(:user)
        user_3 = create(:user)
        user_4 = create(:user)
        label = create(:label, project: project, merge_requests: [merge_request])
        group_label = create(:group_label, group: group, merge_requests: [merge_request])
        label.toggle_subscription(user_1, project)
        group_label.toggle_subscription(user_2, project)
        group_label.toggle_subscription(user_3, another_project)
        group_label.toggle_subscription(user_4)

        notification.new_merge_request(merge_request, @u_disabled)

        should_email(user_1)
        should_email(user_2)
        should_not_email(user_3)
        should_email(user_4)
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { merge_request }
        let(:notification_trigger) { notification.new_merge_request(merge_request, @u_disabled) }
      end

      describe 'Approvals' do
        let(:notification_target)  { merge_request }
        let(:maintainer) { create(:user) }

        describe '#approve_mr' do
          it 'will notify the author, subscribers, and assigned users' do
            notification.approve_mr(merge_request, maintainer)

            merge_request.assignees.each { |assignee| should_email(assignee) }
            should_email(merge_request.author)
            should_email(@u_watcher)
            should_email(@u_participant_mentioned)
            should_email(@subscribed_participant)
            should_email(@subscriber)
            should_email(@watcher_and_subscriber)
            should_email(@u_guest_watcher)

            should_not_email(@unsubscriber)
            should_not_email(@u_participating)
            should_not_email(@u_disabled)
            should_not_email(@u_lazy_participant)

            expect(email_recipients.size).to eq(8)
            # assignee, author, @u_watcher,
            # @u_participant_mentioned, @subscribed_participant,
            # @subscriber, @watcher_and_subscriber, @u_guest_watcher
          end
        end

        describe '#unapprove_mr' do
          it 'will notify the author, subscribers, and assigned users' do
            notification.unapprove_mr(merge_request, maintainer)

            merge_request.assignees.each { |assignee| should_email(assignee) }
            should_email(merge_request.author)
            should_email(@u_watcher)
            should_email(@u_participant_mentioned)
            should_email(@subscribed_participant)
            should_email(@subscriber)
            should_email(@watcher_and_subscriber)
            should_email(@u_guest_watcher)

            should_not_email(@unsubscriber)
            should_not_email(@u_participating)
            should_not_email(@u_disabled)
            should_not_email(@u_lazy_participant)

            expect(email_recipients.size).to eq(8)
            # assignee, author, @u_watcher,
            # @u_participant_mentioned, @subscribed_participant,
            # @subscriber, @watcher_and_subscriber, @u_guest_watcher
          end
        end
      end

      context 'participating' do
        it_behaves_like 'participating by assignee notification' do
          let(:participant) { create(:user, username: 'user-participant') }
          let(:issuable) { merge_request }
          let(:notification_trigger) { notification.new_merge_request(merge_request, @u_disabled) }
        end

        it_behaves_like 'participating by note notification' do
          let(:participant) { create(:user, username: 'user-participant') }
          let(:issuable) { merge_request }
          let(:notification_trigger) { notification.new_merge_request(merge_request, @u_disabled) }
        end

        context 'by author' do
          let(:participant) { create(:user, username: 'user-participant') }

          before do
            merge_request.author = participant
            merge_request.save!
            notification.new_merge_request(merge_request, @u_disabled)
          end

          it { should_not_email(participant) }
        end
      end

      context 'when the author is not allowed to trigger notifications' do
        let(:current_user) { nil }
        let(:object) { merge_request }
        let(:action) { notification.new_merge_request(merge_request, current_user) }

        context 'because they are blocked' do
          let(:current_user) { create(:user, :blocked) }

          it_behaves_like 'is not able to send notifications'
        end

        context 'because they are a ghost' do
          let(:current_user) { create(:user, :ghost) }

          it_behaves_like 'is not able to send notifications'
        end
      end
    end

    describe '#new_mentions_in_merge_request' do
      let(:notification_method) { :new_mentions_in_merge_request }
      let(:mentionable) { merge_request }
      let(:object) { mentionable }
      let(:action) { send_notifications(@u_mentioned, current_user: current_user) }

      include_examples 'notifications for new mentions'

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { merge_request }
        let(:notification_trigger) { send_notifications(@u_watcher, @u_participant_mentioned, @u_custom_global, @u_mentioned) }
      end

      context 'where current_user is blocked' do
        let(:current_user) { create(:user, :blocked) }

        include_examples 'is not able to send notifications'
      end

      context 'where current_user is a ghost' do
        let(:current_user) { create(:user, :ghost) }

        include_examples 'is not able to send notifications'
      end
    end

    describe '#reassigned_merge_request' do
      let(:current_user) { create(:user) }

      before do
        update_custom_notification(:reassign_merge_request, @u_guest_custom, resource: project)
        update_custom_notification(:reassign_merge_request, @u_custom_global)
      end

      it do
        notification.reassigned_merge_request(merge_request, current_user, [assignee])

        merge_request.assignees.each { |assignee| should_email(assignee) }
        should_email(merge_request.author)
        should_email(@u_watcher)
        should_email(@u_participant_mentioned)
        should_email(@subscriber)
        should_email(@watcher_and_subscriber)
        should_email(@u_guest_watcher)
        should_email(@u_guest_custom)
        should_email(@u_custom_global)
        should_not_email(@unsubscriber)
        should_not_email(@u_participating)
        should_not_email(@u_disabled)
        should_not_email(@u_lazy_participant)
      end

      it 'adds ""assigned"" reason for new assignee' do
        notification.reassigned_merge_request(merge_request, current_user, [assignee])

        merge_request.assignees.each do |assignee|
          email = find_email_for(assignee)

          expect(email).to have_header('X-GitLab-NotificationReason', NotificationReason::ASSIGNED)
        end
      end

      it_behaves_like 'participating notifications' do
        let(:participant) { create(:user, username: 'user-participant') }
        let(:issuable) { merge_request }
        let(:notification_trigger) { notification.reassigned_merge_request(merge_request, current_user, [assignee]) }
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { merge_request }
        let(:notification_trigger) { notification.reassigned_merge_request(merge_request, current_user, [assignee]) }
      end
    end

    describe '#changed_reviewer_of_merge_request' do
      let(:merge_request) { create(:merge_request, author: author, source_project: project, reviewers: [reviewer], description: 'cc @participant') }

      let_it_be(:current_user) { create(:user) }
      let_it_be(:reviewer) { create(:user) }

      before do
        update_custom_notification(:change_reviewer_merge_request, @u_guest_custom, resource: project)
        update_custom_notification(:change_reviewer_merge_request, @u_custom_global)
      end

      it 'sends emails to relevant users only', :aggregate_failures do
        notification.changed_reviewer_of_merge_request(merge_request, current_user, [reviewer])

        merge_request.reviewers.each { |reviewer| should_email(reviewer) }
        should_email(merge_request.author)
        should_email(@u_watcher)
        should_email(@u_participant_mentioned)
        should_email(@subscriber)
        should_email(@watcher_and_subscriber)
        should_email(@u_guest_watcher)
        should_email(@u_guest_custom)
        should_email(@u_custom_global)
        should_not_email(@unsubscriber)
        should_not_email(@u_participating)
        should_not_email(@u_disabled)
        should_not_email(@u_lazy_participant)
      end

      it 'adds ""review requested"" reason for new reviewer' do
        notification.changed_reviewer_of_merge_request(merge_request, current_user, [reviewer])

        merge_request.reviewers.each do |assignee|
          email = find_email_for(assignee)

          expect(email).to have_header('X-GitLab-NotificationReason', NotificationReason::REVIEW_REQUESTED)
        end
      end

      context 'participating notifications with reviewers' do
        let(:participant) { create(:user, username: 'user-participant') }
        let(:issuable) { merge_request }
        let(:notification_trigger) { notification.changed_reviewer_of_merge_request(merge_request, current_user, [reviewer]) }

        it_behaves_like 'participating notifications'
        it_behaves_like 'participating by reviewer notification'
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { merge_request }
        let(:notification_trigger) { notification.changed_reviewer_of_merge_request(merge_request, current_user, [reviewer]) }
      end
    end

    describe '#change_in_merge_request_draft_status' do
      let(:merge_request) { create(:merge_request, author: author, source_project: project) }

      let_it_be(:current_user) { create(:user) }

      it 'sends emails to relevant users only', :aggregate_failures do
        notification.change_in_merge_request_draft_status(merge_request, current_user)

        merge_request.reviewers.each { |reviewer| should_email(reviewer) }
        merge_request.assignees.each { |assignee| should_email(assignee) }
        should_email(merge_request.author)
        should_email(@u_watcher)
        should_email(@subscriber)
        should_email(@watcher_and_subscriber)
        should_email(@u_guest_watcher)
        should_not_email(@u_participant_mentioned)
        should_not_email(@u_guest_custom)
        should_not_email(@u_custom_global)
        should_not_email(@unsubscriber)
        should_not_email(@u_participating)
        should_not_email(@u_disabled)
        should_not_email(@u_lazy_participant)
      end

      it_behaves_like 'participating notifications' do
        let(:participant) { create(:user, username: 'user-participant') }
        let(:issuable) { merge_request }
        let(:notification_trigger) { notification.change_in_merge_request_draft_status(merge_request, @u_disabled) }
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { merge_request }
        let(:notification_trigger) { notification.change_in_merge_request_draft_status(merge_request, @u_disabled) }
      end
    end

    describe '#push_to_merge_request' do
      before do
        update_custom_notification(:push_to_merge_request, @u_guest_custom, resource: project)
        update_custom_notification(:push_to_merge_request, @u_custom_global)
      end

      it do
        notification.push_to_merge_request(merge_request, @u_disabled)

        merge_request.assignees.each { |assignee| should_email(assignee) }
        should_email(@u_guest_custom)
        should_email(@u_custom_global)
        should_email(@u_participant_mentioned)
        should_email(@subscriber)
        should_email(@watcher_and_subscriber)
        should_not_email(@u_watcher)
        should_not_email(@u_guest_watcher)
        should_not_email(@unsubscriber)
        should_not_email(@u_participating)
        should_not_email(@u_disabled)
        should_not_email(@u_lazy_participant)
      end

      describe 'triggers push_to_merge_request_email with corresponding email' do
        let_it_be(:merge_request) { create(:merge_request, author: author, source_project: project) }

        def mock_commits(length)
          Array.new(length) { |i| double(:commit, short_id: SecureRandom.hex(4), title: ""This is commit #{i}"") }
        end

        def commit_to_hash(commit)
          { short_id: commit.short_id, title: commit.title }
        end

        let(:existing_commits) { mock_commits(50) }
        let(:expected_existing_commits) { [commit_to_hash(existing_commits.first), commit_to_hash(existing_commits.last)] }

        before do
          allow(::Notify).to receive(:push_to_merge_request_email).and_call_original
        end

        where(:number_of_new_commits, :number_of_new_commits_displayed) do
          limit = described_class::NEW_COMMIT_EMAIL_DISPLAY_LIMIT
          [
            [0, 0],
            [limit - 2, limit - 2],
            [limit - 1, limit - 1],
            [limit, limit],
            [limit + 1, limit],
            [limit + 2, limit]
          ]
        end

        with_them do
          let(:new_commits) { mock_commits(number_of_new_commits) }
          let(:expected_new_commits) { new_commits.first(number_of_new_commits_displayed).map(&method(:commit_to_hash)) }

          it 'triggers the corresponding mailer method with list of stripped commits' do
            notification.push_to_merge_request(
              merge_request, merge_request.author,
              new_commits: new_commits, existing_commits: existing_commits
            )

            expect(Notify).to have_received(:push_to_merge_request_email).at_least(:once).with(
              @subscriber.id, merge_request.id, merge_request.author.id, ""subscribed"",
              new_commits: expected_new_commits, total_new_commits_count: number_of_new_commits,
              existing_commits: expected_existing_commits, total_existing_commits_count: 50
            )
          end
        end

        context 'there is only one existing commit' do
          let(:new_commits) { mock_commits(10) }
          let(:expected_new_commits) { new_commits.map(&method(:commit_to_hash)) }

          it 'triggers corresponding mailer method with only one existing commit' do
            notification.push_to_merge_request(merge_request, merge_request.author, new_commits: new_commits, existing_commits: existing_commits.first(1))

            expect(Notify).to have_received(:push_to_merge_request_email).at_least(:once).with(
              @subscriber.id, merge_request.id, merge_request.author.id, ""subscribed"",
              new_commits: expected_new_commits, total_new_commits_count: 10,
              existing_commits: expected_existing_commits.first(1), total_existing_commits_count: 1
            )
          end
        end
      end

      it_behaves_like 'participating notifications' do
        let(:participant) { create(:user, username: 'user-participant') }
        let(:issuable) { merge_request }
        let(:notification_trigger) { notification.push_to_merge_request(merge_request, @u_disabled) }
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { merge_request }
        let(:notification_trigger) { notification.push_to_merge_request(merge_request, @u_disabled) }
      end
    end

    describe '#relabel_merge_request' do
      let(:group_label_1) { create(:group_label, group: group, title: 'Group Label 1', merge_requests: [merge_request]) }
      let(:group_label_2) { create(:group_label, group: group, title: 'Group Label 2') }
      let(:label_1) { create(:label, project: project, title: 'Label 1', merge_requests: [merge_request]) }
      let(:label_2) { create(:label, project: project, title: 'Label 2') }
      let!(:subscriber_to_group_label_1) { create(:user) { |u| group_label_1.toggle_subscription(u, project) } }
      let!(:subscriber_1_to_group_label_2) { create(:user) { |u| group_label_2.toggle_subscription(u, project) } }
      let!(:subscriber_2_to_group_label_2) { create(:user) { |u| group_label_2.toggle_subscription(u) } }
      let!(:subscriber_to_group_label_2_on_another_project) { create(:user) { |u| group_label_2.toggle_subscription(u, another_project) } }
      let!(:subscriber_to_label_1) { create(:user) { |u| label_1.toggle_subscription(u, project) } }
      let!(:subscriber_to_label_2) { create(:user) { |u| label_2.toggle_subscription(u, project) } }

      it ""doesn't send email to anyone but subscribers of the given labels"" do
        notification.relabeled_merge_request(merge_request, [group_label_2, label_2], @u_disabled)

        should_not_email(subscriber_to_label_1)
        should_not_email(subscriber_to_group_label_1)
        should_not_email(subscriber_to_group_label_2_on_another_project)
        should_email(subscriber_1_to_group_label_2)
        should_email(subscriber_2_to_group_label_2)
        should_email(subscriber_to_label_2)
        merge_request.assignees.each { |assignee| should_not_email(assignee) }
        should_not_email(merge_request.author)
        should_not_email(@u_watcher)
        should_not_email(@u_participant_mentioned)
        should_not_email(@subscriber)
        should_not_email(@watcher_and_subscriber)
        should_not_email(@unsubscriber)
        should_not_email(@u_participating)
        should_not_email(@u_lazy_participant)
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { merge_request }
        let(:notification_trigger) { notification.relabeled_merge_request(merge_request, [group_label_2, label_2], @u_disabled) }
      end
    end

    describe '#removed_milestone on MergeRequest' do
      let(:milestone) { create(:milestone, project: project, merge_requests: [merge_request]) }
      let!(:subscriber_to_new_milestone) { create(:user) { |u| merge_request.toggle_subscription(u, project) } }

      it_behaves_like 'altered milestone notification on merge request' do
        before do
          notification.removed_milestone(merge_request, merge_request.author)
        end
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { merge_request }
        let(:notification_trigger) { notification.removed_milestone(merge_request, merge_request.author) }
      end
    end

    describe '#changed_milestone on MergeRequest' do
      let(:new_milestone) { create(:milestone, project: project, merge_requests: [merge_request]) }
      let!(:subscriber_to_new_milestone) { create(:user) { |u| merge_request.toggle_subscription(u, project) } }

      it_behaves_like 'altered milestone notification on merge request' do
        before do
          notification.changed_milestone(merge_request, new_milestone, merge_request.author)
        end
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { merge_request }
        let(:notification_trigger) { notification.changed_milestone(merge_request, new_milestone, merge_request.author) }
      end
    end

    describe '#merge_request_unmergeable' do
      it ""sends email to merge request author"" do
        notification.merge_request_unmergeable(merge_request)

        should_email(merge_request.author)
        expect(email_recipients.size).to eq(1)
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { merge_request }
        let(:notification_trigger) { notification.merge_request_unmergeable(merge_request) }
      end

      describe 'when merge_when_pipeline_succeeds is true' do
        before do
          merge_request.update!(
            merge_when_pipeline_succeeds: true,
            merge_user: create(:user)
          )
        end

        it ""sends email to merge request author and merge_user"" do
          notification.merge_request_unmergeable(merge_request)

          should_email(merge_request.author)
          should_email(merge_request.merge_user)
          expect(email_recipients.size).to eq(2)
        end
      end
    end

    describe '#closed_merge_request' do
      before do
        update_custom_notification(:close_merge_request, @u_guest_custom, resource: project)
        update_custom_notification(:close_merge_request, @u_custom_global)
      end

      it do
        notification.close_mr(merge_request, @u_disabled)

        merge_request.assignees.each { |assignee| should_email(assignee) }
        should_email(@u_watcher)
        should_email(@u_guest_watcher)
        should_email(@u_guest_custom)
        should_email(@u_custom_global)
        should_email(@u_participant_mentioned)
        should_email(@subscriber)
        should_email(@watcher_and_subscriber)
        should_not_email(@unsubscriber)
        should_not_email(@u_participating)
        should_not_email(@u_disabled)
        should_not_email(@u_lazy_participant)
      end

      it_behaves_like 'participating notifications' do
        let(:participant) { create(:user, username: 'user-participant') }
        let(:issuable) { merge_request }
        let(:notification_trigger) { notification.close_mr(merge_request, @u_disabled) }
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { merge_request }
        let(:notification_trigger) { notification.close_mr(merge_request, @u_disabled) }
      end
    end

    describe '#merged_merge_request' do
      before do
        update_custom_notification(:merge_merge_request, @u_guest_custom, resource: project)
        update_custom_notification(:merge_merge_request, @u_custom_global)
      end

      it do
        notification.merge_mr(merge_request, @u_disabled)

        merge_request.assignees.each { |assignee| should_email(assignee) }
        should_email(@u_watcher)
        should_email(@u_guest_watcher)
        should_email(@u_guest_custom)
        should_email(@u_custom_global)
        should_email(@u_participant_mentioned)
        should_email(@subscriber)
        should_email(@watcher_and_subscriber)
        should_not_email(@unsubscriber)
        should_not_email(@u_participating)
        should_not_email(@u_disabled)
        should_not_email(@u_lazy_participant)
      end

      it ""notifies the merger when the pipeline succeeds is true"" do
        merge_request.merge_when_pipeline_succeeds = true
        notification.merge_mr(merge_request, @u_watcher)

        should_email(@u_watcher)
      end

      it ""does not notify the merger when the pipeline succeeds is false"" do
        merge_request.merge_when_pipeline_succeeds = false
        notification.merge_mr(merge_request, @u_watcher)

        should_not_email(@u_watcher)
      end

      it ""notifies the merger when the pipeline succeeds is false but they've opted into notifications about their activity"" do
        merge_request.merge_when_pipeline_succeeds = false
        @u_watcher.notified_of_own_activity = true
        notification.merge_mr(merge_request, @u_watcher)

        should_email(@u_watcher)
      end

      it_behaves_like 'participating notifications' do
        let(:participant) { create(:user, username: 'user-participant') }
        let(:issuable) { merge_request }
        let(:notification_trigger) { notification.merge_mr(merge_request, @u_disabled) }
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { merge_request }
        let(:notification_trigger) { notification.merge_mr(merge_request, @u_disabled) }
      end
    end

    describe '#reopen_merge_request' do
      before do
        update_custom_notification(:reopen_merge_request, @u_guest_custom, resource: project)
        update_custom_notification(:reopen_merge_request, @u_custom_global)
      end

      it do
        notification.reopen_mr(merge_request, @u_disabled)

        merge_request.assignees.each { |assignee| should_email(assignee) }
        should_email(@u_watcher)
        should_email(@u_participant_mentioned)
        should_email(@subscriber)
        should_email(@watcher_and_subscriber)
        should_email(@u_guest_watcher)
        should_email(@u_guest_custom)
        should_email(@u_custom_global)
        should_not_email(@unsubscriber)
        should_not_email(@u_participating)
        should_not_email(@u_disabled)
        should_not_email(@u_lazy_participant)
      end

      it_behaves_like 'participating notifications' do
        let(:participant) { create(:user, username: 'user-participant') }
        let(:issuable) { merge_request }
        let(:notification_trigger) { notification.reopen_mr(merge_request, @u_disabled) }
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { merge_request }
        let(:notification_trigger) { notification.reopen_mr(merge_request, @u_disabled) }
      end
    end

    describe ""#resolve_all_discussions"" do
      it do
        notification.resolve_all_discussions(merge_request, @u_disabled)

        merge_request.assignees.each { |assignee| should_email(assignee) }
        should_email(@u_watcher)
        should_email(@u_participant_mentioned)
        should_email(@subscriber)
        should_email(@watcher_and_subscriber)
        should_email(@u_guest_watcher)
        should_not_email(@unsubscriber)
        should_not_email(@u_participating)
        should_not_email(@u_disabled)
        should_not_email(@u_lazy_participant)
      end

      it_behaves_like 'participating notifications' do
        let(:participant) { create(:user, username: 'user-participant') }
        let(:issuable) { merge_request }
        let(:notification_trigger) { notification.resolve_all_discussions(merge_request, @u_disabled) }
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { merge_request }
        let(:notification_trigger) { notification.resolve_all_discussions(merge_request, @u_disabled) }
      end
    end

    describe '#merge_when_pipeline_succeeds' do
      before do
        update_custom_notification(:merge_when_pipeline_succeeds, @u_guest_custom, resource: project)
        update_custom_notification(:merge_when_pipeline_succeeds, @u_custom_global)
      end

      it 'send notification that merge will happen when pipeline succeeds' do
        notification.merge_when_pipeline_succeeds(merge_request, assignee)

        should_email(merge_request.author)
        should_email(@u_watcher)
        should_email(@subscriber)
        should_email(@u_guest_custom)
        should_email(@u_custom_global)
        should_not_email(@unsubscriber)
        should_not_email(@u_disabled)
      end

      it 'does not send notification if the custom event is disabled' do
        update_custom_notification(:merge_when_pipeline_succeeds, @u_guest_custom, resource: project, value: false)
        update_custom_notification(:merge_when_pipeline_succeeds, @u_custom_global, resource: nil, value: false)
        notification.merge_when_pipeline_succeeds(merge_request, assignee)

        should_not_email(@u_guest_custom)
        should_not_email(@u_custom_global)
      end

      it 'sends notification to participants even if the custom event is disabled' do
        update_custom_notification(:merge_when_pipeline_succeeds, merge_request.author, resource: project, value: false)
        update_custom_notification(:merge_when_pipeline_succeeds, @u_watcher, resource: project, value: false)
        update_custom_notification(:merge_when_pipeline_succeeds, @subscriber, resource: project, value: false)
        notification.merge_when_pipeline_succeeds(merge_request, assignee)

        should_email(merge_request.author)
        should_email(@u_watcher)
        should_email(@subscriber)
      end

      it_behaves_like 'participating notifications' do
        let(:participant) { create(:user, username: 'user-participant') }
        let(:issuable) { merge_request }
        let(:notification_trigger) { notification.merge_when_pipeline_succeeds(merge_request, @u_disabled) }
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { merge_request }
        let(:notification_trigger) { notification.merge_when_pipeline_succeeds(merge_request, @u_disabled) }
      end
    end

    describe '#review_requested_of_merge_request' do
      let(:merge_request) { create(:merge_request, author: author, source_project: project, reviewers: [reviewer]) }
      let(:mailer) { double }

      let_it_be(:current_user) { create(:user) }
      let_it_be(:reviewer) { create(:user) }

      it 'sends email to reviewer', :aggregate_failures do
        notification.review_requested_of_merge_request(merge_request, current_user, reviewer)

        merge_request.reviewers.each { |reviewer| should_email(reviewer) }
        should_not_email(merge_request.author)
        should_not_email(@u_watcher)
        should_not_email(@u_participant_mentioned)
        should_not_email(@subscriber)
        should_not_email(@watcher_and_subscriber)
        should_not_email(@u_guest_watcher)
        should_not_email(@u_guest_custom)
        should_not_email(@u_custom_global)
        should_not_email(@unsubscriber)
        should_not_email(@u_participating)
        should_not_email(@u_disabled)
        should_not_email(@u_lazy_participant)
      end

      it 'deliver email immediately' do
        allow(Notify).to receive(:request_review_merge_request_email)
                           .with(Integer, Integer, Integer, String).and_return(mailer)
        expect(mailer).to receive(:deliver_later).with({})

        notification.review_requested_of_merge_request(merge_request, current_user, reviewer)
      end

      it 'adds ""review requested"" reason for new reviewer' do
        notification.review_requested_of_merge_request(merge_request, current_user, reviewer)

        merge_request.reviewers.each do |reviewer|
          email = find_email_for(reviewer)

          expect(email).to have_header('X-GitLab-NotificationReason', NotificationReason::REVIEW_REQUESTED)
        end
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { merge_request }
        let(:notification_trigger) { notification.review_requested_of_merge_request(merge_request, current_user, reviewer) }
      end
    end
  end

  describe 'Projects', :deliver_mails_inline do
    before_all do
      build_team(project)
      reset_delivered_emails!
    end

    describe '#project_was_moved' do
      context 'when notifications are disabled' do
        before do
          @u_custom_global.global_notification_setting.update!(moved_project: false)
        end

        it 'does not send a notification' do
          notification.project_was_moved(project, ""gitlab/gitlab"")

          should_not_email(@u_custom_global)
        end
      end

      context 'with users at both project and group level' do
        let(:maintainer) { create(:user) }
        let(:developer) { create(:user) }
        let(:group_owner) { create(:user) }
        let(:group_maintainer) { create(:user) }
        let(:group_developer) { create(:user) }
        let(:blocked_user) { create(:user, :blocked) }
        let(:invited_user) { create(:user) }

        let!(:group) do
          create(:group, :public) do |group|
            project.group = group
            project.save!

            group.add_owner(group_owner)
            group.add_maintainer(group_maintainer)
            group.add_developer(group_developer)
            # This is to check for dupes
            group.add_maintainer(maintainer)
            group.add_maintainer(blocked_user)
          end
        end

        before do
          project.add_maintainer(maintainer)
          project.add_developer(developer)
          project.add_maintainer(blocked_user)
          reset_delivered_emails!
        end

        it 'notifies the expected users' do
          notification.project_was_moved(project, ""gitlab/gitlab"")

          should_email(@u_watcher)
          should_email(@u_participating)
          should_email(@u_lazy_participant)
          should_email(@u_custom_global)
          should_not_email(@u_guest_watcher)
          should_not_email(@u_guest_custom)
          should_not_email(@u_disabled)

          should_email(maintainer)
          should_email(group_owner)
          should_email(group_maintainer)
          should_not_email(group_developer)
          should_not_email(developer)
          should_not_email(blocked_user)
        end
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { project }
        let(:notification_trigger) { notification.project_was_moved(project, ""gitlab/gitlab"") }
      end

      context 'users not having access to the new location' do
        it 'does not send email' do
          old_user = create(:user)
          ProjectAuthorization.create!(project: project, user: old_user, access_level: Gitlab::Access::GUEST)

          build_group(project)
          reset_delivered_emails!

          notification.project_was_moved(project, ""gitlab/gitlab"")

          should_email(@g_watcher)
          should_email(@g_global_watcher)
          should_email(project.creator)
          should_not_email(old_user)
        end
      end
    end

    context 'user with notifications disabled' do
      describe '#project_exported' do
        it do
          notification.project_exported(project, @u_disabled)

          should_not_email_anyone
        end
      end

      describe '#project_not_exported' do
        it do
          notification.project_not_exported(project, @u_disabled, ['error'])

          should_not_email_anyone
        end
      end
    end

    context 'user with notifications enabled' do
      describe '#project_exported' do
        it do
          notification.project_exported(project, @u_participating)

          should_only_email(@u_participating)
        end

        it_behaves_like 'project emails are disabled' do
          let(:notification_target)  { project }
          let(:notification_trigger) { notification.project_exported(project, @u_participating) }
        end
      end

      describe '#project_not_exported' do
        it do
          notification.project_not_exported(project, @u_participating, ['error'])

          should_only_email(@u_participating)
        end

        it_behaves_like 'project emails are disabled' do
          let(:notification_target)  { project }
          let(:notification_trigger) { notification.project_not_exported(project, @u_participating, ['error']) }
        end
      end
    end
  end

  describe '#invite_member_reminder' do
    let_it_be(:group_member) { create(:group_member) }

    subject { notification.invite_member_reminder(group_member, 'token', 0) }

    it 'calls the Notify.invite_member_reminder method with the right params' do
      expect(Notify).to receive(:member_invited_reminder_email).with('Group', group_member.id, 'token', 0).at_least(:once).and_call_original

      subject
    end

    it 'sends exactly one email' do
      subject

      expect_delivery_jobs_count(1)
      expect_enqueud_email('Group', group_member.id, 'token', 0, mail: 'member_invited_reminder_email')
    end
  end

  describe '#new_instance_access_request', :deliver_mails_inline do
    let_it_be(:user) { create(:user, :blocked_pending_approval) }
    let_it_be(:admins) { create_list(:admin, 12, :with_sign_ins) }

    subject { notification.new_instance_access_request(user) }

    before do
      reset_delivered_emails!
      stub_application_setting(require_admin_approval_after_user_signup: true)
    end

    it 'sends notification only to a maximum of ten most recently active instance admins' do
      ten_most_recently_active_instance_admins = User.admins.active.sort_by(&:current_sign_in_at).last(10)

      subject

      should_only_email(*ten_most_recently_active_instance_admins)
    end
  end

  describe '#user_admin_rejection', :deliver_mails_inline do
    let_it_be(:user) { create(:user, :blocked_pending_approval) }

    before do
      reset_delivered_emails!
    end

    it 'sends the user a rejection email' do
      notification.user_admin_rejection(user.name, user.email)

      should_only_email(user)
    end
  end

  describe '#user_deactivated', :deliver_mails_inline do
    let_it_be(:user) { create(:user) }

    it 'sends the user an email' do
      notification.user_deactivated(user.name, user.notification_email_or_default)

      should_only_email(user)
    end
  end

  describe 'GroupMember', :deliver_mails_inline do
    let(:added_user) { create(:user) }

    describe '#new_access_request' do
      context 'recipients' do
        let(:maintainer) { create(:user) }
        let(:owner) { create(:user) }
        let(:developer) { create(:user) }

        let!(:group) do
          create(:group, :public) do |group|
            group.add_owner(owner)
            group.add_maintainer(maintainer)
            group.add_developer(developer)
          end
        end

        before do
          reset_delivered_emails!
        end

        it 'sends notification only to group owners' do
          group.request_access(added_user)

          should_email(owner)
          should_not_email(maintainer)
          should_not_email(developer)
        end

        it_behaves_like 'group emails are disabled' do
          let(:notification_target)  { group }
          let(:notification_trigger) { group.request_access(added_user) }
        end
      end

      it_behaves_like 'sends notification only to a maximum of ten, most recently active group owners' do
        let(:group) { create(:group, :public) }
        let(:notification_trigger) { group.request_access(added_user) }
      end
    end

    describe '#decline_invite' do
      let(:creator) { create(:user) }
      let(:group) { create(:group) }
      let(:member) { create(:user) }

      before do
        group.add_owner(creator)
        group.add_developer(member, creator)
      end

      it_behaves_like 'declines the invite' do
        let(:source) { group }
      end
    end

    describe '#new_group_member' do
      let(:group) { create(:group) }

      it 'sends a notification' do
        group.add_guest(added_user)
        should_only_email(added_user)
      end

      describe 'when notifications are disabled' do
        before do
          create_global_setting_for(added_user, :disabled)
        end

        it 'does not send a notification' do
          group.add_guest(added_user)
          should_not_email_anyone
        end
      end

      it_behaves_like 'group emails are disabled' do
        let(:notification_target)  { group }
        let(:notification_trigger) { group.add_guest(added_user) }
      end
    end

    describe '#updated_group_member_expiration' do
      let_it_be(:group_member) { create(:group_member) }

      it 'emails the user that their group membership expiry has changed' do
        expect_next_instance_of(NotificationService) do |notification|
          allow(notification).to receive(:updated_group_member_expiration).with(group_member)
        end

        group_member.update!(expires_at: 5.days.from_now)
      end
    end
  end

  describe 'ProjectMember', :deliver_mails_inline do
    let(:added_user) { create(:user) }

    describe '#new_access_request' do
      context 'for a project in a user namespace' do
        context 'recipients' do
          let(:developer) { create(:user) }
          let(:maintainer) { create(:user) }

          let!(:project) do
            create(:project, :public) do |project|
              project.add_developer(developer)
              project.add_maintainer(maintainer)
            end
          end

          before do
            reset_delivered_emails!
          end

          it 'sends notification only to project maintainers' do
            project.request_access(added_user)

            should_email(maintainer)
            should_not_email(developer)
          end

          it_behaves_like 'project emails are disabled' do
            let(:notification_target)  { project }
            let(:notification_trigger) { project.request_access(added_user) }
          end
        end

        it_behaves_like 'sends notification only to a maximum of ten, most recently active project maintainers' do
          let(:notification_trigger) { project.request_access(added_user) }
        end
      end

      context 'for a project in a group' do
        let(:group_owner) { create(:user) }
        let(:group) { create(:group).tap { |g| g.add_owner(group_owner) } }

        context 'when the project has no maintainers' do
          context 'when the group has at least one owner' do
            let!(:project) { create(:project, :public, namespace: group) }

            before do
              reset_delivered_emails!
            end

            context 'recipients' do
              it 'sends notifications to the group owners' do
                project.request_access(added_user)

                should_only_email(group_owner)
              end
            end

            it_behaves_like 'sends notification only to a maximum of ten, most recently active group owners' do
              let(:group) { create(:group, :public) }
              let(:notification_trigger) { project.request_access(added_user) }
            end
          end

          context 'when the group does not have any owners' do
            let(:group) { create(:group) }
            let!(:project) { create(:project, :public, namespace: group) }

            context 'recipients' do
              before do
                reset_delivered_emails!
              end

              it 'does not send any notifications' do
                project.request_access(added_user)

                should_not_email_anyone
              end
            end
          end
        end

        context 'when the project has maintainers' do
          let(:maintainer) { create(:user) }
          let(:developer) { create(:user) }

          let!(:project) do
            create(:project, :public, namespace: group) do |project|
              project.add_maintainer(maintainer)
              project.add_developer(developer)
            end
          end

          before do
            reset_delivered_emails!
          end

          context 'recipients' do
            it 'sends notifications only to project maintainers' do
              project.request_access(added_user)

              should_email(maintainer)
              should_not_email(developer)
              should_not_email(group_owner)
            end
          end

          it_behaves_like 'sends notification only to a maximum of ten, most recently active project maintainers' do
            let(:project) { create(:project, :public, namespace: group) }
            let(:notification_trigger) { project.request_access(added_user) }
          end
        end
      end
    end

    describe '#decline_invite' do
      let(:member) { create(:user) }

      before do
        project.add_developer(member, current_user: project.first_owner)
      end

      it_behaves_like 'declines the invite' do
        let(:source) { project }
      end
    end

    describe '#new_project_member' do
      it do
        create_member!
        should_only_email(added_user)
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { project }
        let(:notification_trigger) { create_member! }
      end

      context 'when notifications are disabled' do
        before do
          create_global_setting_for(added_user, :disabled)
        end

        it do
          create_member!
          should_not_email_anyone
        end
      end
    end

    describe '#member_about_to_expire' do
      let_it_be(:group_member) { create(:group_member, expires_at: 7.days.from_now.to_date) }
      let_it_be(:project_member) { create(:project_member, expires_at: 7.days.from_now.to_date) }

      context ""with group member"" do
        it 'emails the user that their group membership will be expired' do
          notification.member_about_to_expire(group_member)

          should_email(group_member.user)
        end
      end

      context ""with project member"" do
        it 'emails the user that their project membership will be expired' do
          notification.member_about_to_expire(project_member)

          should_email(project_member.user)
        end
      end
    end

    def create_member!
      create(:project_member, user: added_user, project: project)
    end
  end

  context 'guest user in private project', :deliver_mails_inline do
    let(:private_project) { create(:project, :private) }
    let(:guest) { create(:user) }
    let(:developer) { create(:user) }
    let(:merge_request) { create(:merge_request, source_project: private_project, assignees: [assignee]) }
    let(:merge_request1) { create(:merge_request, source_project: private_project, assignees: [assignee], description: ""cc @#{guest.username}"") }
    let(:note) { create(:note, noteable: merge_request, project: private_project) }

    before do
      private_project.add_developer(assignee)
      private_project.add_developer(developer)
      private_project.add_guest(guest)

      ActionMailer::Base.deliveries.clear
    end

    it 'filters out guests when new note is created' do
      expect(SentNotification).to receive(:record).with(merge_request, any_args).once

      notification.new_note(note)

      should_not_email(guest)
      should_email(assignee)
    end

    it 'filters out guests when new merge request is created' do
      notification.new_merge_request(merge_request1, developer)

      should_not_email(guest)
      should_email(assignee)
    end

    it 'filters out guests when merge request is closed' do
      notification.close_mr(merge_request, developer)

      should_not_email(guest)
      should_email(assignee)
    end

    it 'filters out guests when merge request is reopened' do
      notification.reopen_mr(merge_request, developer)

      should_not_email(guest)
      should_email(assignee)
    end

    it 'filters out guests when merge request is merged' do
      notification.merge_mr(merge_request, developer)

      should_not_email(guest)
      should_email(assignee)
    end
  end

  describe 'Pipelines', :deliver_mails_inline do
    describe '#pipeline_finished' do
      let_it_be(:project) { create(:project, :public, :repository) }
      let_it_be(:u_member) { create(:user) }
      let_it_be(:u_watcher) { create_user_with_notification(:watch, 'watcher') }

      let_it_be(:u_custom_notification_unset) do
        create_user_with_notification(:custom, 'custom_unset')
      end

      let_it_be(:u_custom_notification_enabled) do
        user = create_user_with_notification(:custom, 'custom_enabled')
        update_custom_notification(:success_pipeline, user, resource: project)
        update_custom_notification(:failed_pipeline, user, resource: project)
        update_custom_notification(:fixed_pipeline, user, resource: project)
        user
      end

      let_it_be(:u_custom_notification_disabled) do
        user = create_user_with_notification(:custom, 'custom_disabled')
        update_custom_notification(:success_pipeline, user, resource: project, value: false)
        update_custom_notification(:failed_pipeline, user, resource: project, value: false)
        update_custom_notification(:fixed_pipeline, user, resource: project, value: false)
        user
      end

      let(:commit) { project.commit }

      def create_pipeline(user, status)
        create(
          :ci_pipeline, status,
          project: project,
          user: user,
          ref: 'refs/heads/master',
          sha: commit.id,
          before_sha: '00000000'
        )
      end

      before_all do
        project.add_maintainer(u_member)
        project.add_maintainer(u_watcher)
        project.add_maintainer(u_custom_notification_unset)
        project.add_maintainer(u_custom_notification_enabled)
        project.add_maintainer(u_custom_notification_disabled)
      end

      before do
        reset_delivered_emails!
      end

      context 'with a successful pipeline' do
        context 'when the creator has default settings' do
          before do
            pipeline = create_pipeline(u_member, :success)
            notification.pipeline_finished(pipeline)
          end

          it 'notifies nobody' do
            should_not_email_anyone
          end
        end

        context 'when the creator has watch set' do
          before do
            pipeline = create_pipeline(u_watcher, :success)
            notification.pipeline_finished(pipeline)
          end

          it 'notifies nobody' do
            should_not_email_anyone
          end
        end

        context 'when the creator has custom notifications, but without any set' do
          before do
            pipeline = create_pipeline(u_custom_notification_unset, :success)
            notification.pipeline_finished(pipeline)
          end

          it 'notifies nobody' do
            should_not_email_anyone
          end
        end

        context 'when the creator has custom notifications disabled' do
          before do
            pipeline = create_pipeline(u_custom_notification_disabled, :success)
            notification.pipeline_finished(pipeline)
          end

          it 'notifies nobody' do
            should_not_email_anyone
          end
        end

        context 'when the creator has custom notifications enabled' do
          let(:pipeline) { create_pipeline(u_custom_notification_enabled, :success) }

          it 'emails only the creator' do
            notification.pipeline_finished(pipeline)

            should_only_email(u_custom_notification_enabled)
          end

          it_behaves_like 'project emails are disabled' do
            let(:notification_target)  { pipeline }
            let(:notification_trigger) { notification.pipeline_finished(pipeline) }
          end

          context 'when the creator has group notification email set' do
            let(:group_notification_email) { 'user+group@example.com' }

            before do
              group = create(:group)

              project.update!(group: group)

              create(:email, :confirmed, user: u_custom_notification_enabled, email: group_notification_email)
              create(:notification_setting, user: u_custom_notification_enabled, source: group, notification_email: group_notification_email)
            end

            it 'sends to group notification email' do
              notification.pipeline_finished(pipeline)

              expect(email_recipients.first).to eq(group_notification_email)
            end
          end
        end
      end

      context 'with a failed pipeline' do
        context 'when the creator has no custom notification set' do
          let(:pipeline) { create_pipeline(u_member, :failed) }

          it 'emails only the creator' do
            notification.pipeline_finished(pipeline)

            should_only_email(u_member)
          end

          it_behaves_like 'project emails are disabled' do
            let(:notification_target)  { pipeline }
            let(:notification_trigger) { notification.pipeline_finished(pipeline) }
          end

          context 'when the creator has group notification email set' do
            let(:group_notification_email) { 'user+group@example.com' }

            before do
              group = create(:group)

              project.update!(group: group)
              create(:email, :confirmed, user: u_member, email: group_notification_email)
              create(:notification_setting, user: u_member, source: group, notification_email: group_notification_email)
            end

            it 'sends to group notification email' do
              notification.pipeline_finished(pipeline)

              expect(email_recipients.first).to eq(group_notification_email)
            end
          end
        end

        context 'when the creator has watch set' do
          before do
            pipeline = create_pipeline(u_watcher, :failed)
            notification.pipeline_finished(pipeline)
          end

          it 'emails only the creator' do
            should_only_email(u_watcher)
          end
        end

        context 'when the creator has custom notifications, but without any set' do
          before do
            pipeline = create_pipeline(u_custom_notification_unset, :failed)
            notification.pipeline_finished(pipeline)
          end

          it 'emails only the creator' do
            should_only_email(u_custom_notification_unset)
          end
        end

        context 'when the creator has custom notifications disabled' do
          before do
            pipeline = create_pipeline(u_custom_notification_disabled, :failed)
            notification.pipeline_finished(pipeline)
          end

          it 'notifies nobody' do
            should_not_email_anyone
          end
        end

        context 'when the creator has custom notifications set' do
          before do
            pipeline = create_pipeline(u_custom_notification_enabled, :failed)
            notification.pipeline_finished(pipeline)
          end

          it 'emails only the creator' do
            should_only_email(u_custom_notification_enabled)
          end
        end

        context 'when the creator has no read_build access' do
          before do
            pipeline = create_pipeline(u_member, :failed)
            project.update!(public_builds: false)
            project.team.truncate
            notification.pipeline_finished(pipeline)
          end

          it 'does not send emails', :sidekiq_inline do
            should_not_email_anyone
          end
        end
      end

      context 'with a fixed pipeline' do
        let(:ref_status) { 'fixed' }

        context 'when the creator has no custom notification set' do
          let(:pipeline) { create_pipeline(u_member, :success) }

          it 'emails only the creator' do
            notification.pipeline_finished(pipeline, ref_status: ref_status)

            should_only_email(u_member)
          end

          it_behaves_like 'project emails are disabled' do
            let(:notification_target)  { pipeline }
            let(:notification_trigger) { notification.pipeline_finished(pipeline, ref_status: ref_status) }
          end

          context 'when the creator has group notification email set' do
            let(:group_notification_email) { 'user+group@example.com' }

            before do
              group = create(:group)

              project.update!(group: group)
              create(:email, :confirmed, user: u_member, email: group_notification_email)
              create(:notification_setting, user: u_member, source: group, notification_email: group_notification_email)
            end

            it 'sends to group notification email' do
              notification.pipeline_finished(pipeline, ref_status: ref_status)

              expect(email_recipients.first).to eq(group_notification_email)
            end
          end
        end

        context 'when the creator has watch set' do
          before do
            pipeline = create_pipeline(u_watcher, :success)
            notification.pipeline_finished(pipeline, ref_status: ref_status)
          end

          it 'emails only the creator' do
            should_only_email(u_watcher)
          end
        end

        context 'when the creator has custom notifications, but without any set' do
          before do
            pipeline = create_pipeline(u_custom_notification_unset, :success)
            notification.pipeline_finished(pipeline, ref_status: ref_status)
          end

          it 'emails only the creator' do
            should_only_email(u_custom_notification_unset)
          end
        end

        context 'when the creator has custom notifications disabled' do
          before do
            pipeline = create_pipeline(u_custom_notification_disabled, :success)
            notification.pipeline_finished(pipeline, ref_status: ref_status)
          end

          it 'notifies nobody' do
            should_not_email_anyone
          end
        end

        context 'when the creator has custom notifications set' do
          it 'emails only the creator' do
            pipeline = create_pipeline(u_custom_notification_enabled, :success)

            notification.pipeline_finished(pipeline, ref_status: ref_status)

            should_only_email(u_custom_notification_enabled)
          end
        end
      end
    end
  end

  describe 'Pages domains', :deliver_mails_inline do
    let_it_be(:project, reload: true) { create(:project) }
    let_it_be(:domain, reload: true) { create(:pages_domain, project: project) }
    let_it_be(:u_blocked) { create(:user, :blocked) }
    let_it_be(:u_silence) { create_user_with_notification(:disabled, 'silent', project) }
    let_it_be(:u_owner) { project.first_owner }
    let_it_be(:u_maintainer1) { create(:user) }
    let_it_be(:u_maintainer2) { create(:user) }
    let_it_be(:u_developer) { create(:user) }

    before do
      project.add_maintainer(u_blocked)
      project.add_maintainer(u_silence)
      project.add_maintainer(u_maintainer1)
      project.add_maintainer(u_maintainer2)
      project.add_developer(u_developer)

      reset_delivered_emails!
    end

    %i[
      pages_domain_enabled
      pages_domain_disabled
      pages_domain_verification_succeeded
      pages_domain_verification_failed
      pages_domain_auto_ssl_failed
    ].each do |sym|
      describe ""##{sym}"" do
        subject(:notify!) { notification.send(sym, domain) }

        it 'emails current watching maintainers and owners' do
          expect(Notify).to receive(:""#{sym}_email"").at_least(:once).and_call_original

          notify!

          should_only_email(u_maintainer1, u_maintainer2, u_owner)
        end

        it_behaves_like 'project emails are disabled' do
          let(:notification_target)  { domain }
          let(:notification_trigger) { notify! }
        end

        it 'emails nobody if the project is missing' do
          domain.project = nil

          notify!

          should_not_email_anyone
        end
      end
    end
  end

  context 'Auto DevOps notifications', :deliver_mails_inline do
    describe '#autodevops_disabled' do
      let(:owner) { create(:user) }
      let(:namespace) { create(:namespace, owner: owner) }
      let(:project) { create(:project, :repository, :auto_devops, namespace: namespace) }
      let(:pipeline_user) { create(:user) }
      let(:pipeline) { create(:ci_pipeline, :failed, project: project, user: pipeline_user) }

      it 'emails project owner and user that triggered the pipeline' do
        project.add_developer(pipeline_user)

        notification.autodevops_disabled(pipeline, [owner.email, pipeline_user.email])

        should_email(owner, times: 1)         # Once for the disable pipeline.
        should_email(pipeline_user, times: 2) # Once for the new permission, once for the disable.
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { project }
        let(:notification_trigger) { notification.autodevops_disabled(pipeline, [owner.email, pipeline_user.email]) }
      end
    end
  end

  describe 'Repository cleanup', :deliver_mails_inline do
    let(:user) { create(:user) }

    describe '#repository_cleanup_success' do
      it 'emails the specified user only' do
        notification.repository_cleanup_success(project, user)

        should_email(user)
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { project }
        let(:notification_trigger) { notification.repository_cleanup_success(project, user) }
      end
    end

    describe '#repository_cleanup_failure' do
      it 'emails the specified user only' do
        notification.repository_cleanup_failure(project, user, 'Some error')

        should_email(user)
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { project }
        let(:notification_trigger) { notification.repository_cleanup_failure(project, user, 'Some error') }
      end
    end
  end

  context 'Remote mirror notifications', :deliver_mails_inline do
    describe '#remote_mirror_update_failed' do
      let(:remote_mirror) { create(:remote_mirror, project: project) }
      let(:u_blocked) { create(:user, :blocked) }
      let(:u_silence) { create_user_with_notification(:disabled, 'silent-maintainer', project) }
      let(:u_owner)   { project.first_owner }
      let(:u_maintainer1) { create(:user) }
      let(:u_maintainer2) { create(:user) }
      let(:u_developer) { create(:user) }

      before do
        project.add_maintainer(u_blocked)
        project.add_maintainer(u_silence)
        project.add_maintainer(u_maintainer1)
        project.add_maintainer(u_maintainer2)
        project.add_developer(u_developer)

        reset_delivered_emails!
      end

      it 'emails current watching maintainers and owners' do
        notification.remote_mirror_update_failed(remote_mirror)

        should_only_email(u_maintainer1, u_maintainer2, u_owner)
      end

      it_behaves_like 'project emails are disabled' do
        let(:notification_target)  { project }
        let(:notification_trigger) { notification.remote_mirror_update_failed(remote_mirror) }
      end
    end
  end

  context 'with external authorization service', :deliver_mails_inline do
    let(:issue) { create(:issue) }
    let(:project) { issue.project }
    let(:note) { create(:note, noteable: issue, project: project) }
    let(:member) { create(:user) }

    subject { described_class.new }

    before do
      project.add_maintainer(member)
      member.global_notification_setting.update!(level: :watch)
    end

    it 'sends email when the service is not enabled' do
      expect(Notify).to receive(:new_issue_email).at_least(:once).with(member.id, issue.id, nil).and_call_original

      subject.new_issue(issue, member)
    end

    context 'when the service is enabled' do
      before do
        enable_external_authorization_service_check
      end

      it 'does not send an email' do
        expect(Notify).not_to receive(:new_issue_email)

        subject.new_issue(issue, member)
      end

      context 'with admin user' do
        before do
          member.update!(admin: true)
        end

        context 'when admin mode is enabled', :enable_admin_mode do
          it 'still delivers email to admins' do
            expect(Notify).to receive(:new_issue_email).at_least(:once).with(member.id, issue.id, nil).and_call_original

            subject.new_issue(issue, member)
          end
        end

        context 'when admin mode is disabled' do
          it 'does not send an email' do
            expect(Notify).not_to receive(:new_issue_email)

            subject.new_issue(issue, member)
          end
        end
      end
    end
  end

  describe '#prometheus_alerts_fired' do
    let_it_be(:project) { create(:project) }
    let_it_be(:master) { create(:user) }
    let_it_be(:developer) { create(:user) }
    let_it_be(:alert) { create(:alert_management_alert, project: project) }

    before do
      project.add_maintainer(master)
    end

    it 'sends the email to owners and masters' do
      expect(Notify).to receive(:prometheus_alert_fired_email).with(project, master, alert).and_call_original
      expect(Notify).to receive(:prometheus_alert_fired_email).with(project, project.first_owner, alert).and_call_original
      expect(Notify).not_to receive(:prometheus_alert_fired_email).with(project, developer, alert)

      subject.prometheus_alerts_fired(project, [alert])
    end

    it_behaves_like 'project emails are disabled' do
      let(:notification_target)  { project }
      let(:notification_trigger) { subject.prometheus_alerts_fired(project, [alert]) }

      around do |example|
        perform_enqueued_jobs { example.run }
      end
    end
  end

  describe '#new_review' do
    let(:project) { create(:project, :repository) }
    let(:user) { create(:user) }
    let(:user2) { create(:user) }
    let(:reviewer) { create(:user) }
    let(:merge_request) { create(:merge_request, source_project: project, assignees: [user, user2], author: create(:user)) }
    let(:review) { create(:review, merge_request: merge_request, project: project, author: reviewer) }
    let(:note) { create(:diff_note_on_merge_request, project: project, noteable: merge_request, author: reviewer, review: review) }

    before do
      build_team(review.project)
      add_users(review.project)
      add_user_subscriptions(merge_request)
      project.add_maintainer(merge_request.author)
      project.add_maintainer(reviewer)
      merge_request.assignees.each { |assignee| project.add_maintainer(assignee) }

      create(
        :diff_note_on_merge_request,
        project: project,
        noteable: merge_request,
        author: reviewer,
        review: review,
        note: ""cc @mention""
      )
    end

    it 'sends emails' do
      expect(Notify).not_to receive(:new_review_email).with(review.author.id, review.id)
      expect(Notify).not_to receive(:new_review_email).with(@unsubscriber.id, review.id)
      merge_request.assignee_ids.each do |assignee_id|
        expect(Notify).to receive(:new_review_email).with(assignee_id, review.id).and_call_original
      end
      expect(Notify).to receive(:new_review_email).with(merge_request.author.id, review.id).and_call_original
      expect(Notify).to receive(:new_review_email).with(@u_watcher.id, review.id).and_call_original
      expect(Notify).to receive(:new_review_email).with(@u_mentioned.id, review.id).and_call_original
      expect(Notify).to receive(:new_review_email).with(@subscriber.id, review.id).and_call_original
      expect(Notify).to receive(:new_review_email).with(@watcher_and_subscriber.id, review.id).and_call_original
      expect(Notify).to receive(:new_review_email).with(@subscribed_participant.id, review.id).and_call_original

      subject.new_review(review)
    end

    it_behaves_like 'project emails are disabled' do
      let(:notification_target)  { review }
      let(:notification_trigger) { subject.new_review(review) }

      around do |example|
        perform_enqueued_jobs { example.run }
      end
    end
  end

  describe '#inactive_project_deletion_warning' do
    let_it_be(:deletion_date) { Date.current }
    let_it_be(:project) { create(:project) }
    let_it_be(:maintainer) { create(:user) }
    let_it_be(:developer) { create(:user) }

    before do
      project.add_maintainer(maintainer)
    end

    subject { notification.inactive_project_deletion_warning(project, deletion_date) }

    it ""sends email to project owners and maintainers"" do
      expect { subject }.to have_enqueued_email(
        project,
        maintainer,
        deletion_date,
        mail: ""inactive_project_deletion_warning_email""
      )
      expect { subject }.not_to have_enqueued_email(
        project,
        developer,
        deletion_date,
        mail: ""inactive_project_deletion_warning_email""
      )
    end
  end

  def build_team(project)
    @u_watcher               = create_global_setting_for(create(:user), :watch)
    @u_participating         = create_global_setting_for(create(:user), :participating)
    @u_participant_mentioned = create_global_setting_for(create(:user, username: 'participant'), :participating)
    @u_disabled              = create_global_setting_for(create(:user), :disabled)
    @u_mentioned             = create_global_setting_for(create(:user, username: 'mention'), :mention)
    @u_committer             = create(:user, username: 'committer')
    @u_not_mentioned         = create_global_setting_for(create(:user, username: 'regular'), :participating)
    @u_outsider_mentioned    = create(:user, username: 'outsider')
    @u_custom_global         = create_global_setting_for(create(:user, username: 'custom_global'), :custom)

    # User to be participant by default
    # This user does not contain any record in notification settings table
    # It should be treated with a :participating notification_level
    @u_lazy_participant = create(:user, username: 'lazy-participant')

    @u_guest_watcher = create_user_with_notification(:watch, 'guest_watching')
    @u_guest_custom = create_user_with_notification(:custom, 'guest_custom')

    project.add_maintainer(@u_watcher)
    project.add_maintainer(@u_participating)
    project.add_maintainer(@u_participant_mentioned)
    project.add_maintainer(@u_disabled)
    project.add_maintainer(@u_mentioned)
    project.add_maintainer(@u_committer)
    project.add_maintainer(@u_not_mentioned)
    project.add_maintainer(@u_lazy_participant)
    project.add_maintainer(@u_custom_global)
  end

  # Users in the project's group but not part of project's team
  # with different notification settings
  def build_group(project, visibility: :public)
    group = create_nested_group(visibility)
    project.update!(namespace_id: group.id)

    # Group member: global=disabled, group=watch
    @g_watcher ||= create_user_with_notification(:watch, 'group_watcher', project.group)
    @g_watcher.notification_settings_for(nil).disabled!

    # Group member: global=watch, group=global
    @g_global_watcher ||= create_global_setting_for(create(:user), :watch)
    group.add_members([@g_watcher, @g_global_watcher], :maintainer)

    group
  end

  def create_nested_group(visibility)
    parent_group = create(:group, visibility)
    child_group = create(:group, visibility, parent: parent_group)

    # Parent group member: global=disabled, parent_group=watch, child_group=global
    @pg_watcher ||= create_user_with_notification(:watch, 'parent_group_watcher', parent_group)
    @pg_watcher.notification_settings_for(nil).disabled!

    # Parent group member: global=global, parent_group=disabled, child_group=global
    @pg_disabled ||= create_user_with_notification(:disabled, 'parent_group_disabled', parent_group)
    @pg_disabled.notification_settings_for(nil).global!

    # Parent group member: global=global, parent_group=mention, child_group=global
    @pg_mention ||= create_user_with_notification(:mention, 'parent_group_mention', parent_group)
    @pg_mention.notification_settings_for(nil).global!

    # Parent group member: global=global, parent_group=participating, child_group=global
    @pg_participant ||= create_user_with_notification(:participating, 'parent_group_participant', parent_group)
    @pg_mention.notification_settings_for(nil).global!

    child_group
  end

  def add_member_for_parent_group(user, project)
    project.reload

    project.group.parent.add_maintainer(user)
  end

  def should_email_nested_group_user(user, times: 1, recipients: email_recipients)
    should_email(user, times: times, recipients: recipients)
  end

  def should_not_email_nested_group_user(user, recipients: email_recipients)
    should_not_email(user, recipients: recipients)
  end

  def add_users(project)
    @subscriber = create :user
    @unsubscriber = create :user
    @unsubscribed_mentioned = create :user, username: 'unsubscribed_mentioned'
    @subscribed_participant = create_global_setting_for(create(:user, username: 'subscribed_participant'), :participating)
    @watcher_and_subscriber = create_global_setting_for(create(:user), :watch)

    project.add_maintainer(@subscribed_participant)
    project.add_maintainer(@subscriber)
    project.add_maintainer(@unsubscriber)
    project.add_maintainer(@watcher_and_subscriber)
    project.add_maintainer(@unsubscribed_mentioned)
  end

  def add_user_subscriptions(issuable)
    issuable.subscriptions.create!(user: @unsubscribed_mentioned, project: project, subscribed: false)
    issuable.subscriptions.create!(user: @subscriber, project: project, subscribed: true)
    issuable.subscriptions.create!(user: @subscribed_participant, project: project, subscribed: true)
    issuable.subscriptions.create!(user: @unsubscriber, project: project, subscribed: false)
    # Make the watcher a subscriber to detect dupes
    issuable.subscriptions.create!(user: @watcher_and_subscriber, project: project, subscribed: true)
  end

  def expectation_args_for_user(user)
    [user, *anything_args]
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class ResetProjectCacheService < BaseService
  def execute
    @project.increment!(:jobs_cache_index)
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ResetProjectCacheService, feature_category: :groups_and_projects do
  let(:project) { create(:project) }
  let(:user) { create(:user) }

  subject { described_class.new(project, user).execute }

  context 'when project cache_index is nil' do
    before do
      project.jobs_cache_index = nil
    end

    it 'sets project cache_index to one' do
      expect { subject }.to change { project.reload.jobs_cache_index }.from(nil).to(1)
    end
  end

  context 'when project cache_index is a numeric value' do
    before do
      project.update!(jobs_cache_index: 1)
    end

    it 'increments project cache index' do
      expect { subject }.to change { project.reload.jobs_cache_index }.by(1)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class BulkUpdateIntegrationService
  include Integrations::BulkOperationHashes

  def initialize(integration, batch)
    @integration = integration
    @batch = batch
  end

  # rubocop: disable CodeReuse/ActiveRecord
  def execute
    Integration.transaction do
      Integration.where(id: batch_ids).update_all(integration_hash(:update))

      if integration.data_fields_present?
        integration.data_fields.class.where(data_fields_foreign_key => batch_ids)
          .update_all(
            data_fields_hash(:update)
          )
      end
    end
  end
  # rubocop: enable CodeReuse/ActiveRecord

  private

  attr_reader :integration, :batch

  # service_id or integration_id
  def data_fields_foreign_key
    integration.data_fields.class.reflections['integration'].foreign_key
  end

  def batch_ids
    @batch_ids ||=
      if batch.is_a?(ActiveRecord::Relation)
        batch.select(:id)
      else
        batch.map(&:id)
      end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe BulkUpdateIntegrationService, feature_category: :integrations do
  include JiraIntegrationHelpers

  before_all do
    stub_jira_integration_test
  end

  let(:excluded_attributes) do
    %w[
      id project_id group_id inherit_from_id instance template
      created_at updated_at encrypted_properties encrypted_properties_iv
    ]
  end

  let(:batch) do
    Integration.inherited_descendants_from_self_or_ancestors_from(subgroup_integration).where(id: group_integration.id..integration.id)
  end

  let_it_be(:group) { create(:group) }
  let_it_be(:subgroup) { create(:group, parent: group) }
  let_it_be(:group_integration) { create(:jira_integration, :group, group: group, url: 'http://group.jira.com') }
  let_it_be(:excluded_integration) { create(:jira_integration, :group, group: create(:group), url: 'http://another.jira.com', push_events: false) }
  let_it_be(:subgroup_integration) do
    create(:jira_integration, :group,
      group: subgroup,
      inherit_from_id: group_integration.id,
      url: 'http://subgroup.jira.com',
      push_events: true
    )
  end

  let_it_be(:integration) do
    create(:jira_integration,
      project: create(:project, group: subgroup),
      inherit_from_id: subgroup_integration.id,
      url: 'http://project.jira.com',
      push_events: false
    )
  end

  context 'with inherited integration' do
    it 'updates the integration', :aggregate_failures do
      described_class.new(subgroup_integration.reload, batch).execute

      expect(integration.reload.inherit_from_id).to eq(group_integration.id)
      expect(integration.reload.attributes.except(*excluded_attributes))
        .to eq(subgroup_integration.reload.attributes.except(*excluded_attributes))

      expect(excluded_integration.reload.inherit_from_id).not_to eq(group_integration.id)
      expect(excluded_integration.reload.attributes.except(*excluded_attributes))
        .not_to eq(subgroup_integration.attributes.except(*excluded_attributes))
    end

    it 'does not change the created_at timestamp' do
      subgroup_integration.update_column(:created_at, Time.utc(2022, 1, 1))

      expect do
        described_class.new(subgroup_integration, batch).execute
      end.not_to change { integration.reload.created_at }
    end

    it 'sets the updated_at timestamp to the current time', time_travel_to: Time.utc(2022, 1, 1) do
      expect do
        described_class.new(subgroup_integration, batch).execute
      end.to change { integration.reload.updated_at }.to(Time.current)
    end

    context 'with integration with data fields' do
      let(:excluded_attributes) do
        %w[id integration_id created_at updated_at encrypted_properties encrypted_properties_iv]
      end

      it 'updates the data fields from the integration', :aggregate_failures do
        described_class.new(subgroup_integration, batch).execute

        expect(integration.reload.data_fields.attributes.except(*excluded_attributes))
          .to eq(subgroup_integration.reload.data_fields.attributes.except(*excluded_attributes))

        expect(integration.data_fields.attributes.except(*excluded_attributes))
          .not_to eq(excluded_integration.data_fields.attributes.except(*excluded_attributes))
      end

      it 'does not change the created_at timestamp' do
        subgroup_integration.data_fields.update_column(:created_at, Time.utc(2022, 1, 2))

        expect do
          described_class.new(subgroup_integration, batch).execute
        end.not_to change { integration.data_fields.reload.created_at }
      end

      it 'sets the updated_at timestamp to the current time', time_travel_to: Time.utc(2022, 1, 1) do
        expect do
          described_class.new(subgroup_integration, batch).execute
        end.to change { integration.data_fields.reload.updated_at }.to(Time.current)
      end
    end
  end

  it 'works with batch as an ActiveRecord::Relation' do
    expect do
      described_class.new(group_integration, Integration.where(id: integration.id)).execute
    end.to change { integration.reload.url }.to(group_integration.url)
  end

  it 'works with batch as an array of ActiveRecord objects' do
    expect do
      described_class.new(group_integration, [integration]).execute
    end.to change { integration.reload.url }.to(group_integration.url)
  end

  context 'with different foreign key of data_fields' do
    let(:integration) { create(:zentao_integration, project: create(:project, group: group)) }
    let(:group_integration) do
      create(:zentao_integration, :group,
        group: group,
        url: 'https://group.zentao.net',
        api_token: 'GROUP_TOKEN',
        zentao_product_xid: '1'
      )
    end

    it 'works with batch as an array of ActiveRecord objects' do
      expect do
        described_class.new(group_integration, [integration]).execute
      end.to change { integration.reload.url }.to(group_integration.url)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class ServiceResponse
  def self.success(message: nil, payload: {}, http_status: :ok)
    new(
      status: :success,
      message: message,
      payload: payload,
      http_status: http_status
    )
  end

  def self.error(message:, payload: {}, http_status: nil, reason: nil)
    new(
      status: :error,
      message: message,
      payload: payload,
      http_status: http_status,
      reason: reason
    )
  end

  attr_reader :status, :message, :http_status, :payload, :reason

  def initialize(status:, message: nil, payload: {}, http_status: nil, reason: nil)
    self.status = status
    self.message = message
    self.payload = payload
    self.http_status = http_status
    self.reason = reason
  end

  def log_and_raise_exception(as: StandardError, **extra_data)
    error_tracking(as) do |ex|
      Gitlab::ErrorTracking.log_and_raise_exception(ex, extra_data)
    end
  end

  def track_exception(as: StandardError, **extra_data)
    error_tracking(as) do |ex|
      Gitlab::ErrorTracking.track_exception(ex, extra_data)
    end
  end

  def track_and_raise_exception(as: StandardError, **extra_data)
    error_tracking(as) do |ex|
      Gitlab::ErrorTracking.track_and_raise_exception(ex, extra_data)
    end
  end

  def [](key)
    to_h[key]
  end

  def to_h
    (payload || {}).merge(
      status: status,
      message: message,
      http_status: http_status,
      reason: reason)
  end

  def deconstruct_keys(keys)
    to_h.slice(*keys)
  end

  def success?
    status == :success
  end

  def error?
    status == :error
  end

  def errors
    return [] unless error?

    Array.wrap(message)
  end

  private

  attr_writer :status, :message, :http_status, :payload, :reason

  def error_tracking(error_klass)
    if error?
      ex = error_klass.new(message)
      yield ex
    end

    self
  end
end

```","# frozen_string_literal: true

require 'fast_spec_helper'

require 're2'

require_relative '../../app/services/service_response'
require_relative '../../lib/gitlab/error_tracking'

RSpec.describe ServiceResponse, feature_category: :shared do
  describe '.success' do
    it 'creates a successful response without a message' do
      expect(described_class.success).to be_success
    end

    it 'creates a successful response with a message' do
      response = described_class.success(message: 'Good orange')

      expect(response).to be_success
      expect(response.message).to eq('Good orange')
    end

    it 'creates a successful response with payload' do
      response = described_class.success(payload: { good: 'orange' })

      expect(response).to be_success
      expect(response.payload).to eq(good: 'orange')
    end

    it 'creates a successful response with default HTTP status' do
      response = described_class.success

      expect(response).to be_success
      expect(response.http_status).to eq(:ok)
    end

    it 'creates a successful response with custom HTTP status' do
      response = described_class.success(http_status: 204)

      expect(response).to be_success
      expect(response.http_status).to eq(204)
    end
  end

  describe '.error' do
    it 'creates an error response without HTTP status' do
      response = described_class.error(message: 'Bad apple')

      expect(response).to be_error
      expect(response.message).to eq('Bad apple')
    end

    it 'creates an error response with HTTP status' do
      response = described_class.error(message: 'Bad apple', http_status: 400)

      expect(response).to be_error
      expect(response.message).to eq('Bad apple')
      expect(response.http_status).to eq(400)
    end

    it 'creates an error response with payload' do
      response = described_class.error(message: 'Bad apple', payload: { bad: 'apple' })

      expect(response).to be_error
      expect(response.message).to eq('Bad apple')
      expect(response.payload).to eq(bad: 'apple')
    end

    it 'creates an error response with a reason' do
      response = described_class.error(message: 'Bad apple', reason: :permission_denied)

      expect(response).to be_error
      expect(response.message).to eq('Bad apple')
      expect(response.reason).to eq(:permission_denied)
    end
  end

  describe '#success?' do
    it 'returns true for a successful response' do
      expect(described_class.success.success?).to eq(true)
    end

    it 'returns false for a failed response' do
      expect(described_class.error(message: 'Bad apple').success?).to eq(false)
    end
  end

  describe '#error?' do
    it 'returns false for a successful response' do
      expect(described_class.success.error?).to eq(false)
    end

    it 'returns true for a failed response' do
      expect(described_class.error(message: 'Bad apple').error?).to eq(true)
    end
  end

  describe '#errors' do
    it 'returns an empty array for a successful response' do
      expect(described_class.success.errors).to be_empty
    end

    it 'returns an array with a correct message for an error response' do
      expect(described_class.error(message: 'error message').errors).to eq(['error message'])
    end
  end

  describe '#track_and_raise_exception' do
    context 'when successful' do
      let(:response) { described_class.success }

      it 'returns self' do
        expect(response.track_and_raise_exception).to be response
      end
    end

    context 'when an error' do
      let(:response) { described_class.error(message: 'bang') }

      it 'tracks and raises' do
        expect(::Gitlab::ErrorTracking).to receive(:track_and_raise_exception)
          .with(StandardError.new('bang'), {})

        response.track_and_raise_exception
      end

      it 'allows specification of error class' do
        error = Class.new(StandardError)
        expect(::Gitlab::ErrorTracking).to receive(:track_and_raise_exception)
          .with(error.new('bang'), {})

        response.track_and_raise_exception(as: error)
      end

      it 'allows extra data for tracking' do
        expect(::Gitlab::ErrorTracking).to receive(:track_and_raise_exception)
          .with(StandardError.new('bang'), { foo: 1, bar: 2 })

        response.track_and_raise_exception(foo: 1, bar: 2)
      end
    end
  end

  describe '#track_exception' do
    context 'when successful' do
      let(:response) { described_class.success }

      it 'returns self' do
        expect(response.track_exception).to be response
      end
    end

    context 'when an error' do
      let(:response) { described_class.error(message: 'bang') }

      it 'tracks' do
        expect(::Gitlab::ErrorTracking).to receive(:track_exception)
          .with(StandardError.new('bang'), {})

        expect(response.track_exception).to be response
      end

      it 'allows specification of error class' do
        error = Class.new(StandardError)
        expect(::Gitlab::ErrorTracking).to receive(:track_exception)
          .with(error.new('bang'), {})

        expect(response.track_exception(as: error)).to be response
      end

      it 'allows extra data for tracking' do
        expect(::Gitlab::ErrorTracking).to receive(:track_exception)
          .with(StandardError.new('bang'), { foo: 1, bar: 2 })

        expect(response.track_exception(foo: 1, bar: 2)).to be response
      end
    end
  end

  describe '#log_and_raise_exception' do
    context 'when successful' do
      let(:response) { described_class.success }

      it 'returns self' do
        expect(response.log_and_raise_exception).to be response
      end
    end

    context 'when an error' do
      let(:response) { described_class.error(message: 'bang') }

      it 'logs' do
        expect(::Gitlab::ErrorTracking).to receive(:log_and_raise_exception)
          .with(StandardError.new('bang'), {})

        response.log_and_raise_exception
      end

      it 'allows specification of error class' do
        error = Class.new(StandardError)
        expect(::Gitlab::ErrorTracking).to receive(:log_and_raise_exception)
          .with(error.new('bang'), {})

        response.log_and_raise_exception(as: error)
      end

      it 'allows extra data for tracking' do
        expect(::Gitlab::ErrorTracking).to receive(:log_and_raise_exception)
          .with(StandardError.new('bang'), { foo: 1, bar: 2 })

        response.log_and_raise_exception(foo: 1, bar: 2)
      end
    end
  end

  describe '#deconstruct_keys' do
    it 'supports pattern matching' do
      status =
        case described_class.error(message: 'Bad apple')
        in { status: Symbol => status }
          status
        else
          raise
        end
      expect(status).to eq(:error)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class BulkCreateIntegrationService
  include Integrations::BulkOperationHashes

  def initialize(integration, batch, association)
    @integration = integration
    @batch = batch
    @association = association
  end

  def execute
    integration_list = Integrations::IntegrationList.new(batch, integration_hash(:create), association).to_array

    Integration.transaction do
      results = bulk_insert(*integration_list)

      if integration.data_fields_present?
        data_list = DataList.new(results, data_fields_hash(:create), integration.data_fields.class).to_array

        bulk_insert(*data_list)
      end
    end
  end

  private

  attr_reader :integration, :batch, :association

  def bulk_insert(klass, columns, values_array)
    items_to_insert = values_array.map { |array| Hash[columns.zip(array)] }

    klass.insert_all(items_to_insert, returning: [:id])
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe BulkCreateIntegrationService, feature_category: :integrations do
  include JiraIntegrationHelpers

  before_all do
    stub_jira_integration_test
  end

  let_it_be(:excluded_group) { create(:group) }
  let_it_be(:excluded_project) { create(:project, group: excluded_group) }

  let(:instance_integration) { create(:jira_integration, :instance) }
  let(:excluded_attributes) do
    %w[
      id project_id group_id inherit_from_id instance template
      created_at updated_at
      encrypted_properties encrypted_properties_iv
    ]
  end

  shared_examples 'creates integration successfully' do
    def attributes(record)
      record.reload.attributes.except(*excluded_attributes)
    end

    it 'updates the inherited integrations' do
      described_class.new(integration, batch, association).execute

      expect(attributes(created_integration)).to eq attributes(integration)
    end

    context 'integration with data fields' do
      let(:excluded_attributes) { %w[id service_id integration_id created_at updated_at] }

      it 'updates the data fields from inherited integrations' do
        described_class.new(integration, batch, association).execute

        expect(attributes(created_integration.data_fields))
          .to eq attributes(integration.data_fields)
      end

      it 'sets created_at and updated_at timestamps', :freeze_time do
        described_class.new(integration, batch, association).execute

        expect(created_integration.data_fields.reload).to have_attributes(
          created_at: eq(Time.current),
          updated_at: eq(Time.current)
        )
      end
    end

    it 'updates inherit_from_id attributes' do
      described_class.new(integration, batch, association).execute

      expect(created_integration.reload.inherit_from_id).to eq(inherit_from_id)
    end

    it 'sets created_at and updated_at timestamps', :freeze_time do
      described_class.new(integration, batch, association).execute

      expect(created_integration.reload).to have_attributes(
        created_at: eq(Time.current),
        updated_at: eq(Time.current)
      )
    end
  end

  context 'passing an instance-level integration' do
    let(:integration) { instance_integration }
    let(:inherit_from_id) { integration.id }

    context 'with a project association' do
      let!(:project) { create(:project) }
      let(:created_integration) { project.jira_integration }
      let(:batch) { Project.where(id: project.id) }
      let(:association) { 'project' }

      it_behaves_like 'creates integration successfully'
    end

    context 'with a group association' do
      let!(:group) { create(:group) }
      let(:created_integration) { Integration.find_by(group: group) }
      let(:batch) { Group.where(id: group.id) }
      let(:association) { 'group' }

      it_behaves_like 'creates integration successfully'
    end
  end

  context 'passing a group integration' do
    let_it_be(:group) { create(:group) }

    context 'with a project association' do
      let!(:project) { create(:project, group: group) }
      let(:integration) { create(:jira_integration, :group, group: group) }
      let(:created_integration) { project.jira_integration }
      let(:batch) { Project.where(id: Project.minimum(:id)..Project.maximum(:id)).without_integration(integration).in_namespace(integration.group.self_and_descendants) }
      let(:association) { 'project' }
      let(:inherit_from_id) { integration.id }

      it_behaves_like 'creates integration successfully'

      context 'with different foreign key of data_fields' do
        let(:integration) { create(:zentao_integration, :group, group: group) }
        let(:created_integration) { project.zentao_integration }

        it_behaves_like 'creates integration successfully'
      end
    end

    context 'with a group association' do
      let!(:subgroup) { create(:group, parent: group) }
      let(:integration) { create(:jira_integration, :group, group: group, inherit_from_id: instance_integration.id) }
      let(:created_integration) { Integration.find_by(group: subgroup) }
      let(:batch) { Group.where(id: subgroup.id) }
      let(:association) { 'group' }
      let(:inherit_from_id) { instance_integration.id }

      it_behaves_like 'creates integration successfully'

      context 'with different foreign key of data_fields' do
        let(:integration) { create(:zentao_integration, :group, group: group, inherit_from_id: instance_integration.id) }

        it_behaves_like 'creates integration successfully'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# PostReceiveService class
#
# Used for scheduling related jobs after a push action has been performed
class PostReceiveService
  attr_reader :user, :repository, :project, :params

  def initialize(user, repository, project, params)
    @user = user
    @repository = repository
    @project = project
    @params = params
  end

  def execute
    response = Gitlab::InternalPostReceive::Response.new

    push_options = Gitlab::PushOptions.new(params[:push_options])
    mr_options = push_options.get(:merge_request)

    response.reference_counter_decreased = Gitlab::ReferenceCounter.new(params[:gl_repository]).decrease

    # The PostReceive worker will normally invalidate the cache. However, it
    # runs asynchronously. If push options require us to create a new merge
    # request synchronously, we can't rely on that, so invalidate the cache here
    repository&.expire_branches_cache if mr_options&.fetch(:create, false)

    PostReceive.perform_async(params[:gl_repository], params[:identifier],
                              params[:changes], push_options.as_json)

    if mr_options.present?
      message = process_mr_push_options(mr_options, params[:changes])
      response.add_alert_message(message)
    end

    response.add_alert_message(broadcast_message)
    response.add_merge_request_urls(merge_request_urls)

    # Neither User nor Repository are guaranteed to be returned; an orphaned write deploy
    # key could be used
    if user && repository
      redirect_message = Gitlab::Checks::ContainerMoved.fetch_message(user, repository)
      project_created_message = Gitlab::Checks::ProjectCreated.fetch_message(user, repository)

      response.add_basic_message(redirect_message)
      response.add_basic_message(project_created_message)

      record_onboarding_progress
    end

    response
  end

  def process_mr_push_options(push_options, changes)
    Gitlab::QueryLimiting.disable!('https://gitlab.com/gitlab-org/gitlab/-/issues/28494')
    return unless repository

    unless repository.repo_type.project?
      return push_options_warning('Push options are only supported for projects')
    end

    service = ::MergeRequests::PushOptionsHandlerService.new(
      project: project, current_user: user, changes: changes, push_options: push_options
    ).execute

    if service.errors.present?
      push_options_warning(service.errors.join(""\n\n""))
    end
  end

  def push_options_warning(warning)
    options = Array.wrap(params[:push_options]).map { |p| ""'#{p}'"" }.join(' ')
    ""WARNINGS:\nError encountered with push options #{options}: #{warning}""
  end

  def merge_request_urls
    return [] unless repository&.repo_type&.project?

    ::MergeRequests::GetUrlsService.new(project: project).execute(params[:changes])
  end

  private

  def broadcast_message
    banner = nil

    if project
      scoped_messages =
        System::BroadcastMessage.current_banner_messages(current_path: project.full_path).select do |message|
          message.target_path.present? && message.matches_current_path(project.full_path) && message.show_in_cli?
        end

      banner = scoped_messages.last
    end

    banner ||= System::BroadcastMessage.current_show_in_cli_banner_messages.last

    banner&.message
  end

  def record_onboarding_progress
    return unless project

    Onboarding::ProgressService.new(project.namespace).execute(action: :git_write)
  end
end

PostReceiveService.prepend_mod_with('PostReceiveService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe PostReceiveService, feature_category: :team_planning do
  include GitlabShellHelpers
  include Gitlab::Routing

  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project, :repository, :wiki_repo, namespace: user.namespace) }
  let_it_be(:project_snippet) { create(:project_snippet, :repository, project: project, author: user) }
  let_it_be(:personal_snippet) { create(:personal_snippet, :repository, author: user) }

  let(:identifier) { 'key-123' }
  let(:gl_repository) { ""project-#{project.id}"" }
  let(:branch_name) { 'feature' }
  let(:reference_counter) { double('ReferenceCounter') }
  let(:push_options) { ['ci.skip', 'another push option'] }
  let(:repository) { project.repository }

  let(:changes) do
    ""#{Gitlab::Git::BLANK_SHA} 570e7b2abdd848b95f2f578043fc23bd6f6fd24d refs/heads/#{branch_name}""
  end

  let(:params) do
    {
      gl_repository: gl_repository,
      identifier: identifier,
      changes: changes,
      push_options: push_options
    }
  end

  let(:service) { described_class.new(user, repository, project, params) }
  let(:response) { service.execute }

  subject { response.messages.as_json }

  context 'when project is nil' do
    let(:gl_repository) { ""snippet-#{personal_snippet.id}"" }
    let(:project) { nil }
    let(:repository) { personal_snippet.repository }

    it 'does not return error' do
      expect(subject).to be_empty
    end

    it_behaves_like 'does not record an onboarding progress action'
  end

  context 'when repository is nil' do
    let(:repository) { nil }

    it 'does not return error' do
      expect(subject).to be_empty
    end
  end

  context 'when both repository and project are nil' do
    let(:gl_repository) { ""snippet-#{personal_snippet.id}"" }
    let(:project) { nil }
    let(:repository) { nil }

    it 'does not return error' do
      expect(subject).to be_empty
    end
  end

  shared_examples 'post_receive_service actions' do
    it 'enqueues a PostReceive worker job' do
      expect(PostReceive).to receive(:perform_async)
        .with(gl_repository, identifier, changes, { ci: { skip: true } })

      subject
    end

    it 'decreases the reference counter and returns the result' do
      expect(Gitlab::ReferenceCounter).to receive(:new).with(gl_repository)
        .and_return(reference_counter)
      expect(reference_counter).to receive(:decrease).and_return(true)

      expect(response.reference_counter_decreased).to be(true)
    end

    it_behaves_like 'records an onboarding progress action', :git_write do
      let(:namespace) { project.namespace }
    end
  end

  context 'with Project' do
    it_behaves_like 'post_receive_service actions'

    it 'returns link to create new merge request' do
      message = <<~MESSAGE.strip
        To create a merge request for #{branch_name}, visit:
          http://#{Gitlab.config.gitlab.host}/#{project.full_path}/-/merge_requests/new?merge_request%5Bsource_branch%5D=#{branch_name}
      MESSAGE

      expect(subject).to include(build_basic_message(message))
    end

    it 'returns the link to an existing merge request when it exists' do
      merge_request = create(:merge_request, source_project: project, source_branch: branch_name, target_branch: 'master')
      message = <<~MESSAGE.strip
        View merge request for feature:
          #{project_merge_request_url(project, merge_request)}
      MESSAGE

      expect(subject).to include(build_basic_message(message))
    end

    context 'when printing_merge_request_link_enabled is false' do
      let(:project) { create(:project, printing_merge_request_link_enabled: false) }

      it 'returns no merge request messages' do
        expect(subject).to be_blank
      end
    end

    it 'does not invoke MergeRequests::PushOptionsHandlerService' do
      expect(MergeRequests::PushOptionsHandlerService).not_to receive(:new)

      subject
    end

    context 'when there are merge_request push options' do
      let(:params) { super().merge(push_options: ['merge_request.create']) }

      before do
        project.add_developer(user)
      end

      it 'invalidates the branch name cache' do
        expect(service.repository).to receive(:expire_branches_cache).and_call_original

        subject
      end

      it 'invokes MergeRequests::PushOptionsHandlerService' do
        expect(MergeRequests::PushOptionsHandlerService).to receive(:new).and_call_original

        subject
      end

      it 'creates a new merge request' do
        expect { Sidekiq::Testing.fake! { subject } }.to change(MergeRequest, :count).by(1)
      end

      it 'links to the newly created merge request' do
        message = <<~MESSAGE.strip
          View merge request for #{branch_name}:
            http://#{Gitlab.config.gitlab.host}/#{project.full_path}/-/merge_requests/1
        MESSAGE

        expect(subject).to include(build_basic_message(message))
      end

      it 'adds errors on the service instance to warnings' do
        expect_any_instance_of(
          MergeRequests::PushOptionsHandlerService
        ).to receive(:errors).at_least(:once).and_return(['my error'])

        message = ""WARNINGS:\nError encountered with push options 'merge_request.create': my error""

        expect(subject).to include(build_alert_message(message))
      end

      it 'adds ActiveRecord errors on invalid MergeRequest records to warnings' do
        invalid_merge_request = MergeRequest.new
        invalid_merge_request.errors.add(:base, 'my error')
        message = ""WARNINGS:\nError encountered with push options 'merge_request.create': my error""

        expect_any_instance_of(
          MergeRequests::CreateService
        ).to receive(:execute).and_return(invalid_merge_request)

        expect(subject).to include(build_alert_message(message))
      end
    end
  end

  context 'with PersonalSnippet' do
    let(:gl_repository) { ""snippet-#{personal_snippet.id}"" }
    let(:repository) { personal_snippet.repository }

    it_behaves_like 'post_receive_service actions'

    it 'does not return link to create new merge request' do
      expect(subject).to be_empty
    end

    it 'does not return the link to an existing merge request when it exists' do
      create(:merge_request, source_project: project, source_branch: branch_name, target_branch: 'master')

      expect(subject).to be_empty
    end
  end

  context 'with ProjectSnippet' do
    let(:gl_repository) { ""snippet-#{project_snippet.id}"" }
    let(:repository) { project_snippet.repository }

    it_behaves_like 'post_receive_service actions'

    it 'does not return link to create new merge request' do
      expect(subject).to be_empty
    end

    it 'does not return the link to an existing merge request when it exists' do
      create(:merge_request, source_project: project, source_branch: branch_name, target_branch: 'master')

      expect(subject).to be_empty
    end
  end

  context 'broadcast message banner exists' do
    it 'outputs a broadcast message when show_in_cli is true' do
      broadcast_message = create(:broadcast_message, show_in_cli: true)

      expect(subject).to include(build_alert_message(broadcast_message.message))
    end

    it 'does not output a broadcast message when show_in_cli is false' do
      create(:broadcast_message, show_in_cli: false)

      expect(has_alert_messages?(subject)).to be_falsey
    end
  end

  context 'broadcast message notification exists' do
    it 'does not output a broadcast message' do
      create(:broadcast_message, :notification)

      expect(has_alert_messages?(subject)).to be_falsey
    end
  end

  context 'broadcast message does not exist' do
    it 'does not output a broadcast message' do
      expect(has_alert_messages?(subject)).to be_falsey
    end
  end

  context 'nil broadcast message' do
    it 'does not output a broadcast message' do
      allow(System::BroadcastMessage).to receive(:current).and_return(nil)

      expect(has_alert_messages?(subject)).to be_falsey
    end
  end

  context ""broadcast message has a target_path"" do
    let!(:older_scoped_message) do
      create(:broadcast_message, message: ""Old top secret"", target_path: ""/company/sekrit-project"")
    end

    let!(:latest_scoped_message) do
      create(:broadcast_message, message: ""Top secret"", target_path: ""/company/sekrit-project"")
    end

    let!(:unscoped_message) do
      create(:broadcast_message, message: ""Hi"")
    end

    context ""no project path matches"" do
      it ""does not output the scoped broadcast messages"" do
        expect(subject).not_to include(build_alert_message(older_scoped_message.message))
        expect(subject).not_to include(build_alert_message(latest_scoped_message.message))
      end

      it ""does output another message that doesn't have a target_path"" do
        expect(subject).to include(build_alert_message(unscoped_message.message))
      end
    end

    context ""project path matches"" do
      before do
        allow(project).to receive(:full_path).and_return(""company/sekrit-project"")
      end

      it ""does output the latest scoped broadcast message"" do
        expect(subject).to include(build_alert_message(latest_scoped_message.message))
      end

      it ""does not output the older scoped broadcast message"" do
        expect(subject).not_to include(build_alert_message(older_scoped_message.message))
      end

      it ""does not output another message that doesn't have a target_path"" do
        expect(subject).not_to include(build_alert_message(unscoped_message.message))
      end
    end
  end

  context 'with a redirected data' do
    it 'returns redirected message on the response' do
      project_moved = Gitlab::Checks::ContainerMoved.new(project.repository, user, 'http', 'foo/baz')
      project_moved.add_message

      expect(subject).to include(build_basic_message(project_moved.message))
    end
  end

  context 'with new project data' do
    it 'returns new project message on the response' do
      project_created = Gitlab::Checks::ProjectCreated.new(project.repository, user, 'http')
      project_created.add_message

      expect(subject).to include(build_basic_message(project_created.message))
    end
  end

  describe '#process_mr_push_options' do
    context 'when repository belongs to a snippet' do
      context 'with PersonalSnippet' do
        let(:repository) { personal_snippet.repository }

        it 'returns an error message' do
          result = service.process_mr_push_options(push_options, changes)

          expect(result).to match('Push options are only supported for projects')
        end
      end

      context 'with ProjectSnippet' do
        let(:repository) { project_snippet.repository }

        it 'returns an error message' do
          result = service.process_mr_push_options(push_options, changes)

          expect(result).to match('Push options are only supported for projects')
        end
      end
    end
  end

  describe '#merge_request_urls' do
    context 'when repository belongs to a snippet' do
      context 'with PersonalSnippet' do
        let(:repository) { personal_snippet.repository }

        it 'returns an empty array' do
          expect(service.merge_request_urls).to be_empty
        end
      end

      context 'with ProjectSnippet' do
        let(:repository) { project_snippet.repository }

        it 'returns an empty array' do
          expect(service.merge_request_urls).to be_empty
        end
      end
    end
  end

  def build_alert_message(message)
    { 'type' => 'alert', 'message' => message }
  end

  def build_basic_message(message)
    { 'type' => 'basic', 'message' => message }
  end

  def has_alert_messages?(messages)
    messages.any? do |message|
      message['type'] == 'alert'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class PreviewMarkdownService < BaseService
  def execute
    text, commands = explain_quick_actions(params[:text])
    users = find_user_references(text)
    suggestions = find_suggestions(text)

    success(
      text: text,
      users: users,
      suggestions: suggestions,
      commands: commands.join('<br>')
    )
  end

  private

  def quick_action_types
    %w[Issue MergeRequest Commit WorkItem]
  end

  def explain_quick_actions(text)
    return text, [] unless quick_action_types.include?(target_type)

    quick_actions_service = QuickActions::InterpretService.new(project, current_user)
    quick_actions_service.explain(text, find_commands_target, keep_actions: params[:render_quick_actions])
  end

  def find_user_references(text)
    extractor = Gitlab::ReferenceExtractor.new(project, current_user)
    extractor.analyze(text, author: current_user)
    extractor.users.map(&:username)
  end

  def find_suggestions(text)
    return [] unless preview_sugestions?

    position = Gitlab::Diff::Position.new(new_path: params[:file_path],
                                          new_line: params[:line].to_i,
                                          base_sha: params[:base_sha],
                                          head_sha: params[:head_sha],
                                          start_sha: params[:start_sha])

    Gitlab::Diff::SuggestionsParser.parse(text, position: position,
                                                project: project,
                                                supports_suggestion: params[:preview_suggestions])
  end

  def preview_sugestions?
    params[:preview_suggestions] &&
      target_type == 'MergeRequest' &&
      Ability.allowed?(current_user, :download_code, project)
  end

  def find_commands_target
    QuickActions::TargetService
      .new(project, current_user, group: params[:group])
      .execute(target_type, target_id)
  end

  def target_type
    params[:target_type]
  end

  def target_id
    params[:target_id]
  end
end

PreviewMarkdownService.prepend_mod_with('PreviewMarkdownService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe PreviewMarkdownService, feature_category: :team_planning do
  let(:user) { create(:user) }
  let(:project) { create(:project, :repository) }

  before do
    project.add_developer(user)
  end

  describe 'user references' do
    let(:params) { { text: ""Take a look #{user.to_reference}"" } }
    let(:service) { described_class.new(project, user, params) }

    it 'returns users referenced in text' do
      result = service.execute

      expect(result[:users]).to eq [user.username]
    end
  end

  describe 'suggestions' do
    let(:merge_request) do
      create(:merge_request, target_project: project, source_project: project)
    end

    let(:text) { ""```suggestion\nfoo\n```"" }
    let(:params) do
      suggestion_params.merge(
        text: text,
        target_type: 'MergeRequest',
        target_id: merge_request.iid
      )
    end

    let(:service) { described_class.new(project, user, params) }

    context 'when preview markdown param is present' do
      let(:path) { ""files/ruby/popen.rb"" }
      let(:line) { 10 }
      let(:diff_refs) { merge_request.diff_refs }

      let(:suggestion_params) do
        {
          preview_suggestions: true,
          file_path: path,
          line: line,
          base_sha: diff_refs.base_sha,
          start_sha: diff_refs.start_sha,
          head_sha: diff_refs.head_sha
        }
      end

      it 'returns suggestions referenced in text' do
        position = Gitlab::Diff::Position.new(new_path: path, new_line: line, diff_refs: diff_refs)

        expect(Gitlab::Diff::SuggestionsParser)
          .to receive(:parse)
          .with(
            text,
            position: position,
            project: merge_request.project,
            supports_suggestion: true
          )
          .and_call_original

        result = service.execute

        expect(result[:suggestions]).to all(be_a(Gitlab::Diff::Suggestion))
      end

      context 'when user is not authorized' do
        let(:another_user) { create(:user) }
        let(:service) { described_class.new(project, another_user, params) }

        before do
          project.add_guest(another_user)
        end

        it 'returns no suggestions' do
          result = service.execute

          expect(result[:suggestions]).to be_empty
        end
      end
    end

    context 'when preview markdown param is not present' do
      let(:suggestion_params) do
        {
          preview_suggestions: false
        }
      end

      it 'returns suggestions referenced in text' do
        result = service.execute

        expect(result[:suggestions]).to eq([])
      end
    end
  end

  context 'new note with quick actions' do
    let(:issue) { create(:issue, project: project) }
    let(:params) do
      {
        text: ""Please do it\n/assign #{user.to_reference}"",
        target_type: 'Issue',
        target_id: issue.id
      }
    end

    let(:service) { described_class.new(project, user, params) }

    it 'removes quick actions from text' do
      result = service.execute

      expect(result[:text]).to eq 'Please do it'
    end

    context 'when render_quick_actions' do
      it 'keeps quick actions' do
        params[:render_quick_actions] = true

        result = service.execute

        expect(result[:text]).to eq ""Please do it\n\n/assign #{user.to_reference}""
      end
    end

    it 'explains quick actions effect' do
      result = service.execute

      expect(result[:commands]).to eq ""Assigns #{user.to_reference}.""
    end
  end

  context 'merge request description' do
    let(:params) do
      {
        text: ""My work\n/estimate 2y"",
        target_type: 'MergeRequest'
      }
    end

    let(:service) { described_class.new(project, user, params) }

    it 'removes quick actions from text' do
      result = service.execute

      expect(result[:text]).to eq 'My work'
    end

    it 'explains quick actions effect' do
      result = service.execute

      expect(result[:commands]).to eq 'Sets time estimate to 2y.'
    end
  end

  context 'commit description' do
    let(:project) { create(:project, :repository) }
    let(:commit) { project.commit }
    let(:params) do
      {
        text: ""My work\n/tag v1.2.3 Stable release"",
        target_type: 'Commit',
        target_id: commit.id
      }
    end

    let(:service) { described_class.new(project, user, params) }

    it 'removes quick actions from text' do
      result = service.execute

      expect(result[:text]).to eq 'My work'
    end

    it 'explains quick actions effect' do
      result = service.execute

      expect(result[:commands]).to eq 'Tags this commit to v1.2.3 with ""Stable release"".'
    end
  end

  context 'note with multiple quick actions' do
    let(:issue) { create(:issue, project: project) }
    let(:params) do
      {
        text: ""/confidential\n/due 2001-12-31\n/estimate 2y\n/assign #{user.to_reference}"",
        target_type: 'Issue',
        target_id: issue.id
      }
    end

    let(:service) { described_class.new(project, user, params) }

    it 'renders quick actions on multiple lines' do
      result = service.execute

      expect(result[:commands]).to eq ""Makes this issue confidential.<br>Sets the due date to Dec 31, 2001.<br>"" \
        ""Sets time estimate to 2y.<br>Assigns #{user.to_reference}.""
    end
  end

  context 'work item quick action types' do
    let(:work_item) { create(:work_item, :task, project: project) }
    let(:params) do
      {
        text: ""/title new title"",
        target_type: 'WorkItem',
        target_id: work_item.iid
      }
    end

    let(:result) { described_class.new(project, user, params).execute }

    it 'renders the quick action preview' do
      expect(result[:commands]).to eq ""Changes the title to \""new title\"".""
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ProtectedBranches
  class CacheService < ProtectedBranches::BaseService
    CACHE_ROOT_KEY = 'cache:gitlab:protected_branch'
    TTL_UNSET = -1
    CACHE_EXPIRE_IN = 1.day
    CACHE_LIMIT = 1000

    def fetch(ref_name, dry_run: false, &block)
      record = OpenSSL::Digest::SHA256.hexdigest(ref_name)

      with_redis do |redis|
        cached_result = redis.hget(redis_key, record)

        if cached_result.nil?
          metrics.increment_cache_miss
        else
          metrics.increment_cache_hit

          decoded_result = Gitlab::Redis::Boolean.decode(cached_result)
        end

        # If we're dry-running, don't break because we need to check against
        # the real value to ensure the cache is working properly.
        # If the result is nil we'll need to run the block, so don't break yet.
        break decoded_result unless dry_run || decoded_result.nil?

        calculated_value = metrics.observe_cache_generation(&block)

        check_and_log_discrepancy(decoded_result, calculated_value, ref_name) if dry_run

        redis.hset(redis_key, record, Gitlab::Redis::Boolean.encode(calculated_value))

        # We don't want to extend cache expiration time
        if redis.ttl(redis_key) == TTL_UNSET
          redis.expire(redis_key, CACHE_EXPIRE_IN)
        end

        # If the cache record has too many elements, then something went wrong and
        # it's better to drop the cache key.
        if redis.hlen(redis_key) > CACHE_LIMIT
          redis.unlink(redis_key)
        end

        calculated_value
      end
    end

    def refresh
      with_redis { |redis| redis.unlink(redis_key) }
    end

    private

    def with_redis(&block)
      Gitlab::Redis::Cache.with(&block) # rubocop:disable CodeReuse/ActiveRecord
    end

    def check_and_log_discrepancy(cached_value, real_value, ref_name)
      return if cached_value.nil?
      return if cached_value == real_value

      encoded_ref_name = Gitlab::EncodingHelper.encode_utf8_with_replacement_character(ref_name)

      log_error(
        'class' => self.class.name,
        'message' => ""Cache mismatch '#{encoded_ref_name}': cached value: #{cached_value}, real value: #{real_value}"",
        'record_class' => project_or_group.class.name,
        'record_id' => project_or_group.id,
        'record_path' => project_or_group.full_path
      )
    end

    def redis_key
      group = project_or_group.is_a?(Group) ? project_or_group : project_or_group.group
      @redis_key ||= if allow_protected_branches_for_group?(group)
                       [CACHE_ROOT_KEY, project_or_group.class.name, project_or_group.id].join(':')
                     else
                       [CACHE_ROOT_KEY, project_or_group.id].join(':')
                     end
    end

    def allow_protected_branches_for_group?(group)
      Feature.enabled?(:group_protected_branches, group) ||
        Feature.enabled?(:allow_protected_branches_for_group, group)
    end

    def metrics
      @metrics ||= Gitlab::Cache::Metrics.new(cache_metadata)
    end

    def cache_metadata
      Gitlab::Cache::Metadata.new(
        cache_identifier: ""#{self.class}#fetch"",
        feature_category: :source_code_management,
        backing_resource: :cpu
      )
    end
  end
end

```","# frozen_string_literal: true
# rubocop:disable Style/RedundantFetchBlock
#
require 'spec_helper'

RSpec.describe ProtectedBranches::CacheService, :clean_gitlab_redis_cache, feature_category: :compliance_management do
  shared_examples 'execute with entity' do
    subject(:service) { described_class.new(entity, user) }

    let(:immediate_expiration) { 0 }

    describe '#fetch' do
      it 'caches the value' do
        expect(service.fetch('main') { true }).to eq(true)
        expect(service.fetch('not-found') { false }).to eq(false)

        # Uses cached values
        expect(service.fetch('main') { false }).to eq(true)
        expect(service.fetch('not-found') { true }).to eq(false)
      end

      it 'sets expiry on the key' do
        stub_const(""#{described_class.name}::CACHE_EXPIRE_IN"", immediate_expiration)

        expect(service.fetch('main') { true }).to eq(true)
        expect(service.fetch('not-found') { false }).to eq(false)

        expect(service.fetch('main') { false }).to eq(false)
        expect(service.fetch('not-found') { true }).to eq(true)
      end

      it 'does not set an expiry on the key after the hash is already created' do
        expect(service.fetch('main') { true }).to eq(true)

        stub_const(""#{described_class.name}::CACHE_EXPIRE_IN"", immediate_expiration)

        expect(service.fetch('not-found') { false }).to eq(false)

        expect(service.fetch('main') { false }).to eq(true)
        expect(service.fetch('not-found') { true }).to eq(false)
      end

      context 'when CACHE_LIMIT is exceeded' do
        before do
          stub_const(""#{described_class.name}::CACHE_LIMIT"", 2)
        end

        it 'recreates cache' do
          expect(service.fetch('main') { true }).to eq(true)
          expect(service.fetch('not-found') { false }).to eq(false)

          # Uses cached values
          expect(service.fetch('main') { false }).to eq(true)
          expect(service.fetch('not-found') { true }).to eq(false)

          # Overflow
          expect(service.fetch('new-branch') { true }).to eq(true)

          # Refreshes values
          expect(service.fetch('main') { false }).to eq(false)
          expect(service.fetch('not-found') { true }).to eq(true)
        end
      end

      context 'when dry_run is on' do
        it 'does not use cached value' do
          expect(service.fetch('main', dry_run: true) { true }).to eq(true)
          expect(service.fetch('main', dry_run: true) { false }).to eq(false)
        end

        context 'when cache mismatch' do
          it 'logs an error' do
            expect(service.fetch('main', dry_run: true) { true }).to eq(true)

            expect(Gitlab::AppLogger).to receive(:error).with(
              {
                'class' => described_class.name,
                'message' => /Cache mismatch/,
                'record_class' => entity.class.name,
                'record_id' => entity.id,
                'record_path' => entity.full_path
              }
            )

            expect(service.fetch('main', dry_run: true) { false }).to eq(false)
          end
        end

        context 'when cache matches' do
          it 'does not log an error' do
            expect(service.fetch('main', dry_run: true) { true }).to eq(true)

            expect(Gitlab::AppLogger).not_to receive(:error)

            expect(service.fetch('main', dry_run: true) { true }).to eq(true)
          end
        end
      end
    end

    describe '#refresh' do
      it 'clears cached values' do
        expect(service.fetch('main') { true }).to eq(true)
        expect(service.fetch('not-found') { false }).to eq(false)

        service.refresh

        # Recreates cache
        expect(service.fetch('main') { false }).to eq(false)
        expect(service.fetch('not-found') { true }).to eq(true)
      end
    end

    describe 'metrics' do
      it 'records hit ratio metrics' do
        expect_next_instance_of(Gitlab::Cache::Metrics) do |metrics|
          expect(metrics).to receive(:increment_cache_miss).once
          expect(metrics).to receive(:increment_cache_hit).exactly(4).times
        end

        5.times { service.fetch('main') { true } }
      end
    end
  end

  context 'with entity project' do
    let_it_be_with_reload(:entity) { create(:project) }
    let(:user) { entity.first_owner }

    it_behaves_like 'execute with entity'
  end

  context 'with entity group' do
    let_it_be_with_reload(:entity) { create(:group) }
    let_it_be_with_reload(:user) { create(:user) }

    before do
      entity.add_owner(user)
    end

    context 'when feature flag enabled' do
      it_behaves_like 'execute with entity'
    end

    context 'when feature flag disabled' do
      before do
        stub_feature_flags(group_protected_branches: false)
        stub_feature_flags(allow_protected_branches_for_group: false)
      end

      it_behaves_like 'execute with entity'
    end
  end
end
# rubocop:enable Style/RedundantFetchBlock
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ProtectedBranches
  class DestroyService < ProtectedBranches::BaseService
    def execute(protected_branch)
      raise Gitlab::Access::AccessDeniedError unless can?(current_user, :destroy_protected_branch, protected_branch)

      protected_branch.destroy.tap do
        refresh_cache
        after_execute
      end
    end
  end
end

ProtectedBranches::DestroyService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ProtectedBranches::DestroyService, feature_category: :compliance_management do
  shared_examples 'execute with entity' do
    subject(:service) { described_class.new(entity, user) }

    describe '#execute' do
      it 'destroys a protected branch' do
        service.execute(protected_branch)

        expect(protected_branch).to be_destroyed
      end

      it 'refreshes the cache' do
        expect_next_instance_of(ProtectedBranches::CacheService) do |cache_service|
          expect(cache_service).to receive(:refresh)
        end

        service.execute(protected_branch)
      end

      context 'when a policy restricts rule deletion' do
        it ""prevents deletion of the protected branch rule"" do
          disallow(:destroy_protected_branch, protected_branch)

          expect do
            service.execute(protected_branch)
          end.to raise_error(Gitlab::Access::AccessDeniedError)
        end
      end
    end
  end

  context 'with entity project' do
    let_it_be_with_reload(:entity) { create(:project) }
    let!(:protected_branch) { create(:protected_branch, project: entity) }
    let(:user) { entity.first_owner }

    it_behaves_like 'execute with entity'
  end

  context 'with entity group' do
    let_it_be_with_reload(:entity) { create(:group) }
    let_it_be_with_reload(:user) { create(:user) }
    let!(:protected_branch) { create(:protected_branch, group: entity, project: nil) }

    before do
      allow(Ability).to receive(:allowed?).with(user, :destroy_protected_branch, protected_branch).and_return(true)
    end

    it_behaves_like 'execute with entity'
  end

  def disallow(ability, protected_branch)
    allow(Ability).to receive(:allowed?).and_call_original
    allow(Ability).to receive(:allowed?).with(user, ability, protected_branch).and_return(false)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ProtectedBranches
  class UpdateService < ProtectedBranches::BaseService
    def execute(protected_branch)
      raise Gitlab::Access::AccessDeniedError unless can?(current_user, :update_protected_branch, protected_branch)

      old_merge_access_levels = protected_branch.merge_access_levels.map(&:clone)
      old_push_access_levels = protected_branch.push_access_levels.map(&:clone)

      if protected_branch.update(params)
        after_execute(protected_branch: protected_branch, old_merge_access_levels: old_merge_access_levels, old_push_access_levels: old_push_access_levels)

        refresh_cache
      end

      protected_branch
    end
  end
end

ProtectedBranches::UpdateService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ProtectedBranches::UpdateService, feature_category: :compliance_management do
  shared_examples 'execute with entity' do
    let(:params) { { name: new_name } }

    subject(:service) { described_class.new(entity, user, params) }

    describe '#execute' do
      let(:new_name) { 'new protected branch name' }
      let(:result) { service.execute(protected_branch) }

      it 'updates a protected branch' do
        expect(result.reload.name).to eq(params[:name])
      end

      it 'refreshes the cache' do
        expect_next_instance_of(ProtectedBranches::CacheService) do |cache_service|
          expect(cache_service).to receive(:refresh)
        end

        result
      end

      context 'when updating name of a protected branch to one that contains HTML tags' do
        let(:new_name) { 'foo<b>bar<\b>' }
        let(:result) { service.execute(protected_branch) }

        it 'updates a protected branch' do
          expect(result.reload.name).to eq(new_name)
        end
      end

      context 'when a policy restricts rule update' do
        it ""prevents update of the protected branch rule"" do
          disallow(:update_protected_branch, protected_branch)

          expect { service.execute(protected_branch) }.to raise_error(Gitlab::Access::AccessDeniedError)
        end
      end
    end
  end

  context 'with entity project' do
    let_it_be_with_reload(:entity) { create(:project) }
    let!(:protected_branch) { create(:protected_branch, project: entity) }
    let(:user) { entity.first_owner }

    it_behaves_like 'execute with entity'
  end

  context 'with entity group' do
    let_it_be_with_reload(:entity) { create(:group) }
    let_it_be_with_reload(:user) { create(:user) }
    let!(:protected_branch) { create(:protected_branch, group: entity, project: nil) }

    before do
      allow(Ability).to receive(:allowed?).with(user, :update_protected_branch, protected_branch).and_return(true)
    end

    it_behaves_like 'execute with entity'
  end

  def disallow(ability, protected_branch)
    allow(Ability).to receive(:allowed?).and_call_original
    allow(Ability).to receive(:allowed?).with(user, ability, protected_branch).and_return(false)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ProtectedBranches
  class CreateService < ProtectedBranches::BaseService
    def execute(skip_authorization: false)
      raise Gitlab::Access::AccessDeniedError unless skip_authorization || authorized?

      save_protected_branch

      refresh_cache

      protected_branch
    end

    def authorized?
      can?(current_user, :create_protected_branch, protected_branch)
    end

    private

    def save_protected_branch
      protected_branch.save
    end

    def protected_branch
      @protected_branch ||= project_or_group.protected_branches.new(params)
    end
  end
end

ProtectedBranches::CreateService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ProtectedBranches::CreateService, feature_category: :compliance_management do
  shared_examples 'execute with entity' do
    let(:params) do
      {
        name: name,
        merge_access_levels_attributes: [{ access_level: Gitlab::Access::MAINTAINER }],
        push_access_levels_attributes: [{ access_level: Gitlab::Access::MAINTAINER }]
      }
    end

    subject(:service) { described_class.new(entity, user, params) }

    describe '#execute' do
      let(:name) { 'master' }
      let(:group_cache_service_double) { instance_double(ProtectedBranches::CacheService) }
      let(:project_cache_service_double) { instance_double(ProtectedBranches::CacheService) }

      it 'creates a new protected branch' do
        expect { service.execute }.to change(ProtectedBranch, :count).by(1)
        expect(entity.protected_branches.last.push_access_levels.map(&:access_level)).to match_array([Gitlab::Access::MAINTAINER])
        expect(entity.protected_branches.last.merge_access_levels.map(&:access_level)).to match_array([Gitlab::Access::MAINTAINER])
      end

      it 'refreshes the cache' do
        expect(ProtectedBranches::CacheService).to receive(:new).with(entity, user, params).and_return(group_cache_service_double)
        expect(group_cache_service_double).to receive(:refresh)

        if entity.is_a?(Group)
          expect(ProtectedBranches::CacheService).to receive(:new).with(project, user, params).and_return(project_cache_service_double)
          expect(project_cache_service_double).to receive(:refresh)
        end

        service.execute
      end

      context 'when protecting a branch with a name that contains HTML tags' do
        let(:name) { 'foo<b>bar<\b>' }

        it 'creates a new protected branch' do
          expect { service.execute }.to change(ProtectedBranch, :count).by(1)
          expect(entity.protected_branches.last.name).to eq(name)
        end
      end

      context 'when a policy restricts rule creation' do
        it ""prevents creation of the protected branch rule"" do
          disallow(:create_protected_branch, an_instance_of(ProtectedBranch))

          expect do
            service.execute
          end.to raise_error(Gitlab::Access::AccessDeniedError)
        end

        it 'creates a new protected branch if we skip authorization step' do
          expect { service.execute(skip_authorization: true) }.to change(ProtectedBranch, :count).by(1)
        end
      end
    end
  end

  context 'with entity project' do
    let_it_be_with_reload(:entity) { create(:project) }
    let(:user) { entity.first_owner }

    it_behaves_like 'execute with entity'
  end

  context 'with entity group' do
    let_it_be_with_reload(:project) { create(:project, :in_group) }
    let_it_be_with_reload(:entity) { project.group }
    let_it_be_with_reload(:user) { create(:user) }

    before do
      allow(Ability).to receive(:allowed?).with(user, :create_protected_branch, instance_of(ProtectedBranch)).and_return(true)
    end

    it_behaves_like 'execute with entity'
  end

  def disallow(ability, protected_branch)
    allow(Ability).to receive(:allowed?).and_call_original
    allow(Ability).to receive(:allowed?).with(user, ability, protected_branch).and_return(false)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ProtectedBranches
  class ApiService < ProtectedBranches::BaseService
    def create
      ::ProtectedBranches::CreateService.new(project_or_group, @current_user, protected_branch_params).execute
    end

    def update(protected_branch)
      ::ProtectedBranches::UpdateService.new(project_or_group, @current_user,
protected_branch_params(with_defaults: false)).execute(protected_branch)
    end

    private

    def protected_branch_params(with_defaults: true)
      params.slice(*attributes).merge(
        {
          push_access_levels_attributes: access_level_attributes(:push, with_defaults),
          merge_access_levels_attributes: access_level_attributes(:merge, with_defaults)
        }
      )
    end

    def access_level_attributes(type, with_defaults)
      ::ProtectedRefs::AccessLevelParams.new(
        type,
        params,
        with_defaults: with_defaults
      ).access_levels
    end

    def attributes
      [:name, :allow_force_push]
    end
  end
end

ProtectedBranches::ApiService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ProtectedBranches::ApiService, feature_category: :compliance_management do
  shared_examples 'execute with entity' do
    it 'creates a protected branch with prefilled defaults' do
      expect(::ProtectedBranches::CreateService).to receive(:new).with(
        entity,
        user,
        hash_including(
          push_access_levels_attributes: [{ access_level: Gitlab::Access::MAINTAINER }],
          merge_access_levels_attributes: [{ access_level: Gitlab::Access::MAINTAINER }]
        )
      ).and_call_original

      expect(described_class.new(entity, user, { name: 'new name' }).create).to be_valid
    end

    it 'updates a protected branch without prefilled defaults' do
      expect(::ProtectedBranches::UpdateService).to receive(:new).with(
        entity,
        user,
        hash_including(
          push_access_levels_attributes: [],
          merge_access_levels_attributes: []
        )
      ).and_call_original

      expect do
        expect(described_class.new(entity, user, { name: 'new name' }).update(protected_branch)).to be_valid
      end.not_to change { protected_branch.reload.allow_force_push }
    end
  end

  context 'with entity project' do
    let_it_be_with_reload(:entity) { create(:project) }
    let_it_be_with_reload(:protected_branch) { create(:protected_branch, project: entity, allow_force_push: true) }
    let(:user) { entity.first_owner }

    it_behaves_like 'execute with entity'
  end

  context 'with entity group' do
    let_it_be_with_reload(:entity) { create(:group) }
    let_it_be_with_reload(:user) { create(:user) }
    let_it_be_with_reload(:protected_branch) do
      create(:protected_branch, group: entity, project: nil, allow_force_push: true)
    end

    before do
      allow(Ability).to receive(:allowed?).with(user, :update_protected_branch, protected_branch).and_return(true)
      allow(Ability)
        .to receive(:allowed?)
        .with(user, :create_protected_branch, instance_of(ProtectedBranch))
        .and_return(true)
    end

    it_behaves_like 'execute with entity'
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module AuditEvents
  class BuildService
    # Handle missing attributes
    MissingAttributeError = Class.new(StandardError)

    # @raise [MissingAttributeError] when required attributes are blank
    #
    # @return [BuildService]
    def initialize(
      author:, scope:, target:, message:,
      created_at: DateTime.current, additional_details: {}, ip_address: nil, target_details: nil)
      raise MissingAttributeError, ""author"" if author.blank?
      raise MissingAttributeError, ""scope"" if scope.blank?
      raise MissingAttributeError, ""target"" if target.blank?
      raise MissingAttributeError, ""message"" if message.blank?

      @author = build_author(author)
      @scope = scope
      @target = build_target(target)
      @ip_address = ip_address || build_ip_address
      @message = build_message(message)
      @created_at = created_at
      @additional_details = additional_details
      @target_details = target_details
    end

    # Create an instance of AuditEvent
    #
    # @return [AuditEvent]
    def execute
      AuditEvent.new(payload)
    end

    private

    def payload
      base_payload.merge(details: base_details_payload)
    end

    def base_payload
      {
        author_id: @author.id,
        author_name: @author.name,
        entity_id: @scope.id,
        entity_type: @scope.class.name,
        created_at: @created_at
      }
    end

    def base_details_payload
      @additional_details.merge({
                                  author_name: @author.name,
                                  author_class: @author.class.name,
                                  target_id: @target.id,
                                  target_type: @target.type,
                                  target_details: @target_details || @target.details,
                                  custom_message: @message
                                })
    end

    def build_author(author)
      author.id = -2 if author.instance_of? DeployToken
      author.id = -3 if author.instance_of? DeployKey

      author
    end

    def build_target(target)
      return target if target.is_a? ::Gitlab::Audit::NullTarget

      ::Gitlab::Audit::Target.new(target)
    end

    def build_message(message)
      message
    end

    def build_ip_address
      Gitlab::RequestContext.instance.client_ip || @author.current_sign_in_ip
    end
  end
end

AuditEvents::BuildService.prepend_mod_with('AuditEvents::BuildService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe AuditEvents::BuildService, feature_category: :audit_events do
  let(:author) { build_stubbed(:author, current_sign_in_ip: '127.0.0.1') }
  let(:deploy_token) { build_stubbed(:deploy_token, user: author) }
  let(:scope) { build_stubbed(:group) }
  let(:target) { build_stubbed(:project) }
  let(:ip_address) { '192.168.8.8' }
  let(:message) { 'Added an interesting field from project Gotham' }
  let(:additional_details) { { action: :custom } }

  subject(:service) do
    described_class.new(
      author: author,
      scope: scope,
      target: target,
      message: message,
      additional_details: additional_details,
      ip_address: ip_address
    )
  end

  describe '#execute', :request_store do
    subject(:event) { service.execute }

    before do
      allow(Gitlab::RequestContext.instance).to receive(:client_ip).and_return(ip_address)
    end

    it 'sets correct attributes', :aggregate_failures do
      freeze_time do
        expect(event).to have_attributes(
          author_id: author.id,
          author_name: author.name,
          entity_id: scope.id,
          entity_type: scope.class.name)

        expect(event.details).to eq(
          author_name: author.name,
          author_class: author.class.name,
          target_id: target.id,
          target_type: target.class.name,
          target_details: target.name,
          custom_message: message,
          action: :custom)

        expect(event.ip_address).to be_nil
        expect(event.created_at).to eq(DateTime.current)
      end
    end

    context 'when IP address is not provided' do
      let(:ip_address) { nil }

      it 'uses author current_sign_in_ip' do
        expect(event.ip_address).to be_nil
      end
    end

    context 'when overriding target details' do
      subject(:service) do
        described_class.new(
          author: author,
          scope: scope,
          target: target,
          message: message,
          target_details: ""This is my target details""
        )
      end

      it 'uses correct target details' do
        expect(event.target_details).to eq(""This is my target details"")
      end
    end

    context 'when deploy token is passed as author' do
      let(:service) do
        described_class.new(
          author: deploy_token,
          scope: scope,
          target: target,
          message: message
        )
      end

      it 'expect author to be user' do
        expect(event.author_id).to eq(-2)
        expect(event.author_name).to eq(deploy_token.name)
      end
    end

    context 'when deploy key is passed as author' do
      let(:deploy_key) { build_stubbed(:deploy_key, user: author) }

      let(:service) do
        described_class.new(
          author: deploy_key,
          scope: scope,
          target: target,
          message: message
        )
      end

      it 'expect author to be deploy key' do
        expect(event.author_id).to eq(-3)
        expect(event.author_name).to eq(deploy_key.name)
      end
    end

    context 'when author is passed as UnauthenticatedAuthor' do
      let(:service) do
        described_class.new(
          author: ::Gitlab::Audit::UnauthenticatedAuthor.new,
          scope: scope,
          target: target,
          message: message
        )
      end

      it 'sets author as unauthenticated user' do
        expect(event.author).to be_an_instance_of(::Gitlab::Audit::UnauthenticatedAuthor)
        expect(event.author_name).to eq('An unauthenticated user')
      end
    end

    context 'when attributes are missing' do
      context 'when author is missing' do
        let(:author) { nil }

        it { expect { service }.to raise_error(described_class::MissingAttributeError, ""author"") }
      end

      context 'when scope is missing' do
        let(:scope) { nil }

        it { expect { service }.to raise_error(described_class::MissingAttributeError, ""scope"") }
      end

      context 'when target is missing' do
        let(:target) { nil }

        it { expect { service }.to raise_error(described_class::MissingAttributeError, ""target"") }
      end

      context 'when message is missing' do
        let(:message) { nil }

        it { expect { service }.to raise_error(described_class::MissingAttributeError, ""message"") }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ide
  class TerminalConfigService < ::Ide::BaseConfigService
    private

    def success(pass_back = {})
      result = super(pass_back)
      result[:terminal] = config.terminal_value
      result
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ide::TerminalConfigService, feature_category: :web_ide do
  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:user) { create(:user) }

  let(:sha) { 'sha' }

  describe '#execute' do
    subject { described_class.new(project, user, sha: sha).execute }

    before do
      project.add_developer(user)

      allow(project.repository).to receive(:blob_data_at).with('sha', anything) do
        config_content
      end
    end

    context 'content is not valid' do
      let(:config_content) { 'invalid content' }

      it 'returns an error' do
        is_expected.to include(
          status: :error,
          message: ""Invalid configuration format"")
      end
    end

    context 'terminal not defined' do
      let(:config_content) { '{}' }

      it 'returns success' do
        is_expected.to include(
          status: :success,
          terminal: nil)
      end
    end

    context 'terminal enabled' do
      let(:config_content) { 'terminal: {}' }

      it 'returns success' do
        is_expected.to include(
          status: :success,
          terminal: {
            tag_list: [],
            job_variables: [],
            options: { script: [""sleep 60""] }
          })
      end
    end

    context 'custom terminal enabled' do
      let(:config_content) { 'terminal: { before_script: [ls] }' }

      it 'returns success' do
        is_expected.to include(
          status: :success,
          terminal: {
            tag_list: [],
            job_variables: [],
            options: { before_script: [""ls""], script: [""sleep 60""] }
          })
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ide
  class SchemasConfigService < ::Ide::BaseConfigService
    PREDEFINED_SCHEMAS = [{
      uri: 'https://json.schemastore.org/gitlab-ci',
      match: ['*.gitlab-ci.yml']
    }].freeze

    def execute
      schema = predefined_schema_for(params[:filename]) || {}
      success(schema: schema)
    rescue StandardError => e
      error(e.message)
    end

    private

    def find_schema(filename, schemas)
      match_flags = ::File::FNM_DOTMATCH | ::File::FNM_PATHNAME

      schemas.each do |schema|
        match = schema[:match].any? { |pattern| ::File.fnmatch?(pattern, filename, match_flags) }

        return Gitlab::Json.parse(get_cached(schema[:uri])) if match
      end

      nil
    end

    def predefined_schema_for(filename)
      find_schema(filename, predefined_schemas)
    end

    def predefined_schemas
      PREDEFINED_SCHEMAS
    end

    def get_cached(url)
      Rails.cache.fetch(""services:ide:schema:#{url}"", expires_in: 1.day) do
        Gitlab::HTTP.get(url).body
      end
    end
  end
end

Ide::SchemasConfigService.prepend_mod_with('Ide::SchemasConfigService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ide::SchemasConfigService, feature_category: :web_ide do
  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:user) { create(:user) }

  let(:filename) { 'sample.yml' }
  let(:schema_content) { double(body: '{""title"":""Sample schema""}') }

  describe '#execute' do
    before do
      project.add_developer(user)

      allow(Gitlab::HTTP).to receive(:get).with(anything) do
        schema_content
      end
    end

    subject { described_class.new(project, user, filename: filename).execute }

    context 'when no predefined schema exists for the given filename', unless: Gitlab.ee? do
      it 'returns an empty object' do
        is_expected.to include(
          status: :success,
          schema: {})
      end
    end

    context 'when a predefined schema exists for the given filename' do
      let(:filename) { '.gitlab-ci.yml' }

      it 'uses predefined schema matches' do
        expect(Gitlab::HTTP).to receive(:get).with('https://json.schemastore.org/gitlab-ci')
        expect(subject[:schema]['title']).to eq ""Sample schema""
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ide
  class BaseConfigService < ::BaseService
    ValidationError = Class.new(StandardError)

    WEBIDE_CONFIG_FILE = '.gitlab/.gitlab-webide.yml'

    attr_reader :config, :config_content

    def execute
      check_access_and_load_config!

      success
    rescue ValidationError => e
      error(e.message)
    end

    protected

    def check_access_and_load_config!
      check_access!
      load_config_content!
      load_config!
    end

    private

    def check_access!
      unless can?(current_user, :download_code, project)
        raise ValidationError, 'Insufficient permissions to read configuration'
      end
    end

    def load_config_content!
      @config_content = webide_yaml_from_repo

      unless config_content
        raise ValidationError, ""Failed to load Web IDE config file '#{WEBIDE_CONFIG_FILE}' for #{params[:sha]}""
      end
    end

    def load_config!
      @config = Gitlab::WebIde::Config.new(config_content)

      unless @config.valid?
        raise ValidationError, @config.errors.first
      end
    rescue Gitlab::WebIde::Config::ConfigError => e
      raise ValidationError, e.message
    end

    def webide_yaml_from_repo
      gitlab_webide_yml_for(params[:sha])
    rescue GRPC::NotFound, GRPC::Internal
      nil
    end

    def gitlab_webide_yml_for(sha)
      project.repository.blob_data_at(sha, WEBIDE_CONFIG_FILE)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ide::BaseConfigService, feature_category: :web_ide do
  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:user) { create(:user) }

  let(:sha) { 'sha' }

  describe '#execute' do
    subject { described_class.new(project, user, sha: sha).execute }

    context 'when insufficient permission' do
      it 'returns an error' do
        is_expected.to include(
          status: :error,
          message: 'Insufficient permissions to read configuration')
      end
    end

    context 'for developer' do
      before do
        project.add_developer(user)
      end

      context 'when file is missing' do
        it 'returns an error' do
          is_expected.to include(
            status: :error,
            message: ""Failed to load Web IDE config file '.gitlab/.gitlab-webide.yml' for sha"")
        end
      end

      context 'when file is present' do
        before do
          allow(project.repository).to receive(:blob_data_at).with('sha', anything) do
            config_content
          end
        end

        context 'content is not valid' do
          let(:config_content) { 'invalid content' }

          it 'returns an error' do
            is_expected.to include(
              status: :error,
              message: ""Invalid configuration format"")
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Commits
  class CommitPatchService < CreateService
    # Requires:
    # - project: `Project` to be committed into
    # - user: `User` that will be the committer
    # - params:
    #   - branch_name: `String` the branch that will be committed into
    #   - start_branch: `String` the branch that will be started from
    #   - patches: `Gitlab::Git::Patches::Collection` that contains the patches
    def initialize(*args)
      super

      @patches = Gitlab::Git::Patches::Collection.new(Array(params[:patches]))
    end

    private

    def new_branch?
      !repository.branch_exists?(@branch_name)
    end

    def create_commit!
      if @start_branch && new_branch?
        prepare_branch!
      end

      Gitlab::Git::Patches::CommitPatches
        .new(current_user, project.repository, @branch_name, @patches)
        .commit
    end

    def prepare_branch!
      branch_result = ::Branches::CreateService.new(project, current_user)
                        .execute(@branch_name, @start_branch)

      if branch_result[:status] != :success
        raise ChangeError, branch_result[:message]
      end
    end

    # Overridden from the Commits::CreateService, to skip some validations we
    # don't need:
    # - validate_on_branch!
    #   Not needed, the patches are applied on top of HEAD if the branch did not
    #   exist
    # - validate_branch_existence!
    #   Not needed because we continue applying patches on the branch if it
    #   already existed, and create it if it did not exist.
    def validate!
      validate_patches!
      validate_new_branch_name! if new_branch?
      validate_permissions!
    end

    def validate_patches!
      raise_error(""Patches are too big"") unless @patches.valid_size?
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Commits::CommitPatchService, feature_category: :source_code_management do
  describe '#execute' do
    let(:patches) do
      patches_folder = Rails.root.join('spec/fixtures/patchfiles')
      content_1 = File.read(File.join(patches_folder, ""0001-This-does-not-apply-to-the-feature-branch.patch""))
      content_2 = File.read(File.join(patches_folder, ""0001-A-commit-from-a-patch.patch""))

      [content_1, content_2]
    end

    let(:user) { project.creator }
    let(:branch_name) { 'branch-with-patches' }
    let(:project) { create(:project, :repository) }
    let(:start_branch) { nil }
    let(:params) { { branch_name: branch_name, patches: patches, start_branch: start_branch } }

    subject(:service) do
      described_class.new(project, user, params)
    end

    it 'returns a successful result' do
      result = service.execute

      branch = project.repository.find_branch(branch_name)

      expect(result[:status]).to eq(:success)
      expect(result[:result]).to eq(branch.target)
    end

    it 'is based off HEAD when no start ref is passed' do
      service.execute

      merge_base = project.repository.merge_base(project.repository.root_ref, branch_name)

      expect(merge_base).to eq(project.repository.commit('HEAD').sha)
    end

    context 'when specifying a different start branch' do
      let(:start_branch) { 'with-codeowners' }

      it 'is based of the correct branch' do
        service.execute

        merge_base = project.repository.merge_base(start_branch, branch_name)

        expect(merge_base).to eq(project.repository.commit(start_branch).sha)
      end
    end

    shared_examples 'an error response' do |expected_message|
      it 'returns the correct error' do
        result = service.execute

        expect(result[:status]).to eq(:error)
        expect(result[:message]).to match(expected_message)
      end
    end

    context 'when the user does not have access' do
      let(:user) { create(:user) }

      it_behaves_like 'an error response', 'You are not allowed to push into this branch'
    end

    context 'when the patches are not valid' do
      let(:patches) { ""a"" * 2.1.megabytes }

      it_behaves_like 'an error response', 'Patches are too big'
    end

    context 'when the new branch name is invalid' do
      let(:branch_name) { 'HEAD' }

      it_behaves_like 'an error response', 'Branch name is invalid'
    end

    context 'when the patches do not apply' do
      let(:branch_name) { 'feature' }

      it_behaves_like 'an error response', 'Patch failed at'
    end

    context 'when specifying a non existent start branch' do
      let(:start_branch) { 'does-not-exist' }

      it_behaves_like 'an error response', 'Failed to create branch'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Commits
  class CherryPickService < ChangeService
    def initialize(*args)
      super

      @start_project = params[:target_project] || @project
      @source_project = params[:source_project] || @project
    end

    def create_commit!
      Gitlab::Git::CrossRepo.new(@project.repository, @source_project.repository).execute(@commit.id) do
        commit_change(:cherry_pick).tap do |sha|
          track_mr_picking(sha)
        end
      end
    end

    private

    def track_mr_picking(pick_sha)
      merge_request = project.merge_requests.by_merge_commit_sha(@commit.sha).first
      return unless merge_request

      ::SystemNotes::MergeRequestsService.new(
        noteable: merge_request,
        project: project,
        author: current_user
      ).picked_into_branch(@branch_name, pick_sha)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Commits::CherryPickService, feature_category: :source_code_management do
  let(:project) { create(:project, :repository) }
  # *   ddd0f15ae83993f5cb66a927a28673882e99100b (HEAD -> master, origin/master, origin/HEAD) Merge branch 'po-fix-test-en
  # |\
  # | * 2d1db523e11e777e49377cfb22d368deec3f0793 Correct test_env.rb path for adding branch
  # |/
  # *   1e292f8fedd741b75372e19097c76d327140c312 Merge branch 'cherry-pick-ce369011' into 'master'

  let_it_be(:merge_commit_sha) { 'ddd0f15ae83993f5cb66a927a28673882e99100b' }
  let_it_be(:merge_base_sha)   { '1e292f8fedd741b75372e19097c76d327140c312' }
  let_it_be(:branch_name)      { 'stable' }

  let(:repository) { project.repository }
  let(:commit) { project.commit }
  let(:user) { create(:user) }

  before do
    project.add_maintainer(user)

    repository.add_branch(user, branch_name, merge_base_sha)
  end

  def cherry_pick(sha, branch_name, message: nil)
    commit = project.commit(sha)

    described_class.new(
      project,
      user,
      commit: commit,
      start_branch: branch_name,
      branch_name: branch_name,
      message: message
    ).execute
  end

  describe '#execute' do
    shared_examples 'successful cherry-pick' do
      it 'picks the commit into the branch' do
        result = cherry_pick(merge_commit_sha, branch_name)
        expect(result[:status]).to eq(:success), result[:message]

        head = repository.find_branch(branch_name).target
        expect(head).not_to eq(merge_base_sha)
      end

      it 'supports a custom commit message' do
        result = cherry_pick(merge_commit_sha, branch_name, message: 'foo')
        branch = repository.find_branch(branch_name)

        expect(result[:status]).to eq(:success)
        expect(branch.dereferenced_target.message).to eq('foo')
      end
    end

    it_behaves_like 'successful cherry-pick'

    context 'when picking a merge-request' do
      let!(:merge_request) { create(:merge_request, :simple, :merged, author: user, source_project: project, merge_commit_sha: merge_commit_sha) }

      it_behaves_like 'successful cherry-pick'

      it 'adds a system note' do
        result = cherry_pick(merge_commit_sha, branch_name)

        mr_notes = find_cherry_pick_notes(merge_request)
        expect(mr_notes.length).to eq(1)
        expect(mr_notes[0].commit_id).to eq(result[:result])
      end
    end

    def find_cherry_pick_notes(noteable)
      noteable
        .notes
        .joins(:system_note_metadata)
        .where(system_note_metadata: { action: 'cherry_pick' })
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Commits
  class TagService < BaseService
    def execute(commit)
      unless params[:tag_name]
        return error('Missing parameter tag_name')
      end

      tag_name = params[:tag_name]
      message = params[:tag_message]

      result = Tags::CreateService
        .new(commit.project, current_user)
        .execute(tag_name, commit.sha, message)

      if result[:status] == :success
        tag = result[:tag]
        SystemNoteService.tag_commit(commit, commit.project, current_user, tag.name)
      end

      result
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Commits::TagService, feature_category: :source_code_management do
  let(:project) { create(:project, :repository) }
  let(:user) { create(:user) }

  let(:commit) { project.commit }

  before do
    project.add_maintainer(user)
  end

  describe '#execute' do
    let(:service) { described_class.new(project, user, opts) }

    shared_examples 'tag failure' do
      it 'returns a hash with the :error status' do
        result = service.execute(commit)

        expect(result[:status]).to eq(:error)
        expect(result[:message]).to eq(error_message)
      end

      it 'does not add a system note' do
        service.execute(commit)

        description_notes = find_notes('tag')
        expect(description_notes).to be_empty
      end
    end

    def find_notes(action)
      commit
        .notes
        .joins(:system_note_metadata)
        .where(system_note_metadata: { action: action })
    end

    context 'valid params' do
      let(:opts) do
        {
          tag_name: 'v1.2.3',
          tag_message: 'Release'
        }
      end

      def find_notes(action)
        commit
          .notes
          .joins(:system_note_metadata)
          .where(system_note_metadata: { action: action })
      end

      context 'when tagging succeeds' do
        it 'returns a hash with the :success status and created tag' do
          result = service.execute(commit)

          expect(result[:status]).to eq(:success)

          tag = result[:tag]
          expect(tag.name).to eq(opts[:tag_name])
          expect(tag.message).to eq(opts[:tag_message])
        end

        it 'adds a system note' do
          service.execute(commit)

          description_notes = find_notes('tag')
          expect(description_notes.length).to eq(1)
        end
      end

      context 'when tagging fails' do
        let(:tag_error) { 'GitLab: You are not allowed to push code to this project.' }

        before do
          tag_stub = instance_double(Tags::CreateService)
          allow(Tags::CreateService).to receive(:new).and_return(tag_stub)
          allow(tag_stub).to receive(:execute).and_return({
            status: :error, message: tag_error
          })
        end

        it_behaves_like 'tag failure' do
          let(:error_message) { tag_error }
        end
      end
    end

    context 'invalid params' do
      let(:opts) do
        {}
      end

      it_behaves_like 'tag failure' do
        let(:error_message) { 'Missing parameter tag_name' }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ImportCsv
  class BaseService
    include Gitlab::Utils::StrongMemoize

    def initialize(user, project, csv_io)
      @user = user
      @project = project
      @csv_io = csv_io
      @results = { success: 0, error_lines: [], parse_error: false, preprocess_errors: {} }
    end

    PreprocessError = Class.new(StandardError)

    def execute
      process_csv
      email_results_to_user

      results
    end

    def email_results_to_user
      raise NotImplementedError
    end

    private

    attr_reader :user, :project, :csv_io, :results

    def attributes_for(row)
      raise NotImplementedError
    end

    def validate_headers_presence!(headers)
      raise NotImplementedError
    end

    def create_object_class
      raise NotImplementedError
    end

    def validate_structure!
      header_line = csv_data.lines.first
      raise CSV::MalformedCSVError.new('File is empty, no headers found', 1) if header_line.blank?

      validate_headers_presence!(header_line)
      detect_col_sep
    end

    def preprocess!
      # any logic can be added in subclasses if needed
      # hence just a no-op rather than NotImplementedError
    end

    def process_csv
      validate_structure!
      preprocess!

      with_csv_lines.each do |row, line_no|
        attributes = attributes_for(row)

        if create_object(attributes)&.persisted?
          results[:success] += 1
        else
          results[:error_lines].push(line_no)
        end
      end
    rescue ArgumentError, CSV::MalformedCSVError => e
      results[:parse_error] = true
      results[:error_lines].push(e.line_number) if e.respond_to?(:line_number)
    rescue PreprocessError
      results[:parse_error] = false
    end

    def with_csv_lines
      CSV.new(
        csv_data,
        col_sep: detect_col_sep,
        headers: true,
        header_converters: :symbol
      ).each.with_index(2)
    end

    def csv_data
      @csv_io.open(&:read).force_encoding(Encoding::UTF_8)
    end
    strong_memoize_attr :csv_data

    def detect_col_sep
      header = csv_data.lines.first

      if header.include?("","")
        "",""
      elsif header.include?("";"")
        "";""
      elsif header.include?(""\t"")
        ""\t""
      else
        raise CSV::MalformedCSVError.new('Invalid CSV format', 1)
      end
    end
    strong_memoize_attr :detect_col_sep

    def create_object(attributes)
      # default_params can be extracted into a method if we need
      # to support creation of objects that belongs to groups.
      default_params = { container: project,
                         current_user: user,
                         params: attributes,
                         perform_spam_check: false }

      create_service = create_object_class.new(**default_params.merge(extra_create_service_params))

      create_service.execute_without_rate_limiting
    end

    # Overidden in subclasses to support specific parameters
    def extra_create_service_params
      {}
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ImportCsv::BaseService, feature_category: :importers do
  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project) }
  let_it_be(:csv_io) { double }

  subject { described_class.new(user, project, csv_io) }

  shared_examples 'abstract method' do |method, args|
    it ""raises NotImplemented error when #{method} is called"" do
      if args
        expect { subject.send(method, args) }.to raise_error(NotImplementedError)
      else
        expect { subject.send(method) }.to raise_error(NotImplementedError)
      end
    end
  end

  it_behaves_like 'abstract method', :email_results_to_user
  it_behaves_like 'abstract method', :attributes_for, ""any""
  it_behaves_like 'abstract method', :validate_headers_presence!, ""any""
  it_behaves_like 'abstract method', :create_object_class

  context 'when given a class' do
    let(:importer_klass) do
      Class.new(described_class) do
        def attributes_for(row)
          { title: row[:title] }
        end

        def validate_headers_presence!(headers)
          raise CSV::MalformedCSVError.new(""Missing required headers"", 1) unless headers.present?
        end

        def create_object_class
          Class.new
        end

        def email_results_to_user
          # no-op
        end
      end
    end

    let(:service) do
      uploader = FileUploader.new(project)
      uploader.store!(file)

      importer_klass.new(user, project, uploader)
    end

    subject { service.execute }

    it_behaves_like 'correctly handles invalid files'

    describe '#detect_col_sep' do
      using RSpec::Parameterized::TableSyntax

      let(:file) { double }

      before do
        allow(service).to receive_message_chain('csv_data.lines.first').and_return(header)
      end

      where(:sep_character, :valid) do
        '&' | false
        '?' | false
        ';' | true
        ',' | true
        ""\t"" | true
      end

      with_them do
        let(:header) { ""Name#{sep_character}email"" }

        it 'responds appropriately' do
          if valid
            expect(service.send(:detect_col_sep)).to eq sep_character
          else
            expect { service.send(:detect_col_sep) }.to raise_error(CSV::MalformedCSVError)
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ImportCsv
  class PreprocessMilestonesService < BaseService
    def initialize(user, project, provided_titles)
      @user = user
      @project = project
      @provided_titles = provided_titles

      @results = { success: 0, errors: nil }
      @milestone_errors = { missing: { header: {}, titles: [] } }
    end

    attr_reader :user, :project, :provided_titles, :results, :milestone_errors

    def execute
      result = find_milestones_by_titles
      available_milestones = result.map(&:title).uniq.sort
      return ServiceResponse.success(payload: result) if provided_titles.sort == available_milestones

      milestone_errors[:missing][:header] = 'Milestone'
      milestone_errors[:missing][:titles] = provided_titles.difference(available_milestones) || []
      ServiceResponse.error(message: """", payload: milestone_errors)
    end

    def find_milestones_by_titles
      # Find if these milestones exist in the project or its group and group ancestors
      finder_params = {
        project_ids: [project.id],
        title: provided_titles
      }
      finder_params[:group_ids] = project.group.self_and_ancestors.select(:id) if project.group
      MilestonesFinder.new(finder_params).execute
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ImportCsv::PreprocessMilestonesService, feature_category: :importers do
  let_it_be(:group) { create(:group) }
  let_it_be(:project) { create(:project, group: group) }
  let_it_be(:user) { create(:user) }
  let_it_be(:provided_titles) { %w[15.10 10.1] }

  let(:service) { described_class.new(user, project, provided_titles) }

  subject { service.execute }

  describe '#execute' do
    let(:project_milestones) { ::MilestonesFinder.new({ project_ids: [project.id] }).execute }

    shared_examples 'csv import' do |is_success:, milestone_errors:|
      it 'does not create milestones' do
        expect { subject }.not_to change { project_milestones.count }
      end

      it 'reports any missing milestones' do
        result = subject

        if is_success
          expect(result).to be_success
        else
          expect(result[:status]).to eq(:error)
          expect(result.payload).to match(milestone_errors)
        end
      end
    end

    context 'with csv that has missing or unavailable milestones' do
      it_behaves_like 'csv import',
        { is_success: false, milestone_errors: { missing: { header: 'Milestone', titles: %w[15.10 10.1] } } }
    end

    context 'with csv that includes project milestones' do
      let!(:project_milestone) { create(:milestone, project: project, title: '15.10') }

      it_behaves_like 'csv import',
        { is_success: false, milestone_errors: { missing: { header: 'Milestone', titles: [""10.1""] } } }
    end

    context 'with csv that includes milestones column' do
      let!(:project_milestone) { create(:milestone, project: project, title: '15.10') }

      context 'when milestones exist in the importing projects group' do
        let!(:group_milestone) { create(:milestone, group: group, title: '10.1') }

        it_behaves_like 'csv import', { is_success: true, milestone_errors: nil }
      end

      context 'when milestones exist in a subgroup of the importing projects group' do
        let_it_be(:subgroup) { create(:group, parent: group) }
        let!(:group_milestone) { create(:milestone, group: subgroup, title: '10.1') }

        it_behaves_like 'csv import',
          { is_success: false, milestone_errors: { missing: { header: 'Milestone', titles: [""10.1""] } } }
      end

      context 'when milestones exist in a different project from the importing project' do
        let_it_be(:second_project) { create(:project, group: group) }
        let!(:second_project_milestone) { create(:milestone, project: second_project, title: '10.1') }

        it_behaves_like 'csv import',
          { is_success: false, milestone_errors: { missing: { header: 'Milestone', titles: [""10.1""] } } }
      end

      context 'when duplicate milestones exist in the projects group and parent group' do
        let_it_be(:sub_group) { create(:group, parent: group) }
        let_it_be(:project) { create(:project, group: sub_group) }
        let!(:ancestor_group_milestone) { create(:milestone, group: group, title: '15.10') }
        let!(:ancestor_group_milestone_two) { create(:milestone, group: group, title: '10.1') }
        let!(:group_milestone) { create(:milestone, group: sub_group, title: '10.1') }

        it_behaves_like 'csv import', { is_success: true, milestone_errors: nil }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module AutoMerge
  class MergeWhenPipelineSucceedsService < AutoMerge::BaseService
    def execute(merge_request)
      super do
        add_system_note(merge_request)
      end
    end

    def process(merge_request)
      logger.info(""Processing Automerge"")
      return unless merge_request.actual_head_pipeline_success?

      logger.info(""Pipeline Success"")
      return unless merge_request.mergeable?

      logger.info(""Merge request mergeable"")

      merge_request.merge_async(merge_request.merge_user_id, merge_request.merge_params)
    end

    def cancel(merge_request)
      super do
        SystemNoteService.cancel_merge_when_pipeline_succeeds(merge_request, project, current_user)
      end
    end

    def abort(merge_request, reason)
      super do
        SystemNoteService.abort_merge_when_pipeline_succeeds(merge_request, project, current_user, reason)
      end
    end

    def available_for?(merge_request)
      super do
        check_availability(merge_request)
      end
    end

    private

    def add_system_note(merge_request)
      SystemNoteService.merge_when_pipeline_succeeds(merge_request, project, current_user, merge_request.actual_head_pipeline.sha) if merge_request.saved_change_to_auto_merge_enabled?
    end

    def check_availability(merge_request)
      merge_request.actual_head_pipeline&.active?
    end

    def notify(merge_request)
      notification_service.async.merge_when_pipeline_succeeds(merge_request, current_user) if merge_request.saved_change_to_auto_merge_enabled?
    end

    def logger
      @logger ||= Gitlab::AppLogger
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe AutoMerge::MergeWhenPipelineSucceedsService, feature_category: :code_review_workflow do
  include_context 'for auto_merge strategy context'

  describe ""#available_for?"" do
    subject { service.available_for?(mr_merge_if_green_enabled) }

    let(:pipeline_status) { :running }

    before do
      create(
        :ci_pipeline,
        pipeline_status,
        ref: mr_merge_if_green_enabled.source_branch,
        sha: mr_merge_if_green_enabled.diff_head_sha,
        project: mr_merge_if_green_enabled.source_project
      )
      mr_merge_if_green_enabled.update_head_pipeline
    end

    it { is_expected.to be_truthy }

    it 'memoizes the result' do
      expect(mr_merge_if_green_enabled).to receive(:can_be_merged_by?).once.and_call_original

      2.times { is_expected.to be_truthy }
    end

    context 'when the head pipeline succeeded' do
      let(:pipeline_status) { :success }

      it { is_expected.to be_falsy }
    end

    context 'when the user does not have permission to merge' do
      before do
        allow(mr_merge_if_green_enabled).to receive(:can_be_merged_by?) { false }
      end

      it { is_expected.to be_falsy }
    end
  end

  describe ""#execute"" do
    it_behaves_like 'auto_merge service #execute', 'merge_when_pipeline_succeeds' do
      let(:auto_merge_strategy) { AutoMergeService::STRATEGY_MERGE_WHEN_PIPELINE_SUCCEEDS }
      let(:expected_note) do
        ""enabled an automatic merge when the pipeline for #{pipeline.sha}""
      end
    end
  end

  describe ""#process"" do
    it_behaves_like 'auto_merge service #process'
  end

  describe '#cancel' do
    it_behaves_like 'auto_merge service #cancel'
  end

  describe '#abort' do
    it_behaves_like 'auto_merge service #abort'
  end

  describe 'pipeline integration' do
    context 'when there are multiple stages in the pipeline' do
      let(:ref) { mr_merge_if_green_enabled.source_branch }
      let(:sha) { project.commit(ref).id }

      let(:build_stage) { create(:ci_stage, name: 'build', pipeline: pipeline) }

      let(:pipeline) do
        create(:ci_empty_pipeline, ref: ref, sha: sha, project: project)
      end

      let!(:build) do
        create(
          :ci_build,
          :created,
          pipeline: pipeline,
          ref: ref,
          name: 'build',
          ci_stage: build_stage
        )
      end

      let!(:test) do
        create(:ci_build, :created, pipeline: pipeline, ref: ref, name: 'test')
      end

      before do
        # This behavior of MergeRequest: we instantiate a new object
        #
        allow_any_instance_of(MergeRequest)
          .to receive(:head_pipeline)
          .and_wrap_original do
            Ci::Pipeline.find(pipeline.id)
          end
      end

      it ""doesn't merge if any of stages failed"" do
        expect(MergeWorker).not_to receive(:perform_async)

        build.success
        test.reload
        test.drop
      end

      it 'merges when all stages succeeded', :sidekiq_might_not_need_inline do
        expect(MergeWorker).to receive(:perform_async)

        build.success
        test.reload
        test.success
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module AutoMerge
  class BaseService < ::BaseService
    include Gitlab::Utils::StrongMemoize
    include MergeRequests::AssignsMergeParams

    def execute(merge_request)
      ApplicationRecord.transaction do
        register_auto_merge_parameters!(merge_request)
        yield if block_given?
      end

      notify(merge_request)
      AutoMergeProcessWorker.perform_async(merge_request.id)

      strategy.to_sym
    rescue StandardError => e
      track_exception(e, merge_request)
      :failed
    end

    def process(_)
      raise NotImplementedError
    end

    def update(merge_request)
      assign_allowed_merge_params(merge_request, params.merge(auto_merge_strategy: strategy))

      return :failed unless merge_request.save

      strategy.to_sym
    end

    def cancel(merge_request)
      ApplicationRecord.transaction do
        clear_auto_merge_parameters!(merge_request)
        yield if block_given?
      end

      success
    rescue StandardError => e
      track_exception(e, merge_request)
      error(""Can't cancel the automatic merge"", 406)
    end

    def abort(merge_request, reason)
      ApplicationRecord.transaction do
        clear_auto_merge_parameters!(merge_request)
        yield if block_given?
      end

      success
    rescue StandardError => e
      track_exception(e, merge_request)
      error(""Can't abort the automatic merge"", 406)
    end

    def available_for?(merge_request)
      strong_memoize(""available_for_#{merge_request.id}"") do
        merge_request.can_be_merged_by?(current_user) &&
          merge_request.open? &&
          !merge_request.broken? &&
          overrideable_available_for_checks(merge_request) &&
          yield
      end
    end

    private

    def overrideable_available_for_checks(merge_request)
      !merge_request.draft? &&
        merge_request.mergeable_discussions_state? &&
        !merge_request.merge_blocked_by_other_mrs?
    end

    # Overridden in child classes
    def notify(merge_request)
    end

    def strategy
      strong_memoize(:strategy) do
        self.class.name.demodulize.remove('Service').underscore
      end
    end

    def register_auto_merge_parameters!(merge_request)
      assign_allowed_merge_params(merge_request, params.merge(auto_merge_strategy: strategy))
      merge_request.auto_merge_enabled = true
      merge_request.merge_user = current_user
      merge_request.save!
    end

    def clear_auto_merge_parameters!(merge_request)
      merge_request.auto_merge_enabled = false
      merge_request.merge_user = nil

      merge_request.merge_params&.except!(*clearable_auto_merge_parameters)

      merge_request.save!
    end

    # Overridden in EE child classes
    def clearable_auto_merge_parameters
      %w[
        should_remove_source_branch
        commit_message
        squash_commit_message
        auto_merge_strategy
      ]
    end

    def track_exception(error, merge_request)
      Gitlab::ErrorTracking.track_exception(error, merge_request_id: merge_request&.id)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe AutoMerge::BaseService, feature_category: :code_review_workflow do
  let(:project) { create(:project) }
  let(:user) { create(:user) }
  let(:service) { described_class.new(project, user, params) }
  let(:merge_request) { create(:merge_request) }
  let(:params) { {} }

  describe '#execute' do
    subject { service.execute(merge_request) }

    before do
      allow(AutoMergeProcessWorker).to receive(:perform_async) {}
    end

    it 'sets properies to the merge request' do
      subject

      merge_request.reload
      expect(merge_request).to be_auto_merge_enabled
      expect(merge_request.merge_user).to eq(user)
      expect(merge_request.auto_merge_strategy).to eq('base')
    end

    it 'yields block' do
      expect { |b| service.execute(merge_request, &b) }.to yield_control.once
    end

    it 'returns activated strategy name' do
      is_expected.to eq(:base)
    end

    context 'when merge parameters are given' do
      let(:params) do
        {
          'commit_message' => ""Merge branch 'patch-12' into 'master'"",
          'sha' => ""200fcc9c260f7219eaf0daba87d818f0922c5b18"",
          'should_remove_source_branch' => false,
          'squash' => false,
          'squash_commit_message' => ""Update README.md""
        }
      end

      it 'sets merge parameters' do
        subject

        merge_request.reload
        expect(merge_request.merge_params['commit_message']).to eq(""Merge branch 'patch-12' into 'master'"")
        expect(merge_request.merge_params['sha']).to eq('200fcc9c260f7219eaf0daba87d818f0922c5b18')
        expect(merge_request.merge_params['should_remove_source_branch']).to eq(false)
        expect(merge_request.squash_on_merge?).to eq(false)
        expect(merge_request.merge_params['squash_commit_message']).to eq('Update README.md')
      end
    end

    context 'when strategy is merge when pipeline succeeds' do
      let(:service) { AutoMerge::MergeWhenPipelineSucceedsService.new(project, user) }

      before do
        pipeline = build(:ci_pipeline)
        allow(merge_request).to receive(:actual_head_pipeline) { pipeline }
      end

      it 'sets the auto merge strategy' do
        subject

        merge_request.reload
        expect(merge_request.auto_merge_strategy).to eq(AutoMergeService::STRATEGY_MERGE_WHEN_PIPELINE_SUCCEEDS)
      end

      it 'returns activated strategy name' do
        is_expected.to eq(AutoMergeService::STRATEGY_MERGE_WHEN_PIPELINE_SUCCEEDS.to_sym)
      end

      it 'calls AutoMergeProcessWorker' do
        expect(AutoMergeProcessWorker).to receive(:perform_async).with(merge_request.id).once

        subject
      end
    end

    context 'when failed to save merge request' do
      before do
        allow(merge_request).to receive(:save!) { raise ActiveRecord::RecordInvalid }
      end

      it 'does not yield block' do
        expect { |b| service.execute(merge_request, &b) }.not_to yield_control
      end

      it 'returns failed' do
        is_expected.to eq(:failed)
      end

      it 'tracks the exception' do
        expect(Gitlab::ErrorTracking)
          .to receive(:track_exception)
          .with(kind_of(ActiveRecord::RecordInvalid), merge_request_id: merge_request.id)

        subject
      end
    end

    context 'when exception happens in yield block' do
      def execute_with_error_in_yield
        service.execute(merge_request) { raise 'Something went wrong' }
      end

      it 'returns failed status' do
        expect(execute_with_error_in_yield).to eq(:failed)
      end

      it 'rollback the transaction' do
        execute_with_error_in_yield

        merge_request.reload
        expect(merge_request).not_to be_auto_merge_enabled
      end

      it 'tracks the exception' do
        expect(Gitlab::ErrorTracking)
          .to receive(:track_exception)
          .with(kind_of(RuntimeError), merge_request_id: merge_request.id)

        execute_with_error_in_yield
      end
    end
  end

  describe '#update' do
    subject { service.update(merge_request) } # rubocop:disable Rails/SaveBang

    let(:merge_request) { create(:merge_request, :merge_when_pipeline_succeeds) }

    context 'when merge params are specified' do
      let(:params) do
        {
          'commit_message' => ""Merge branch 'patch-12' into 'master'"",
          'sha' => ""200fcc9c260f7219eaf0daba87d818f0922c5b18"",
          'should_remove_source_branch' => false,
          'squash_commit_message' => ""Update README.md""
        }
      end

      it 'updates merge params' do
        expect { subject }.to change {
          merge_request.reload.merge_params.slice(*params.keys)
        }.from({}).to(params)
      end
    end
  end

  shared_examples_for 'Canceled or Dropped' do
    it 'removes properies from the merge request' do
      subject

      merge_request.reload
      expect(merge_request).not_to be_auto_merge_enabled
      expect(merge_request.merge_user).to be_nil
      expect(merge_request.auto_merge_strategy).to be_nil
    end

    it 'yields block' do
      expect { |b| service.cancel(merge_request, &b) }.to yield_control.once
    end

    it 'returns success status' do
      expect(subject[:status]).to eq(:success)
    end

    context 'when merge params are set' do
      before do
        merge_request.update!(merge_params:
          {
            'should_remove_source_branch' => false,
            'commit_message' => ""Merge branch 'patch-12' into 'master'"",
            'squash_commit_message' => ""Update README.md"",
            'auto_merge_strategy' => 'merge_when_pipeline_succeeds'
          })
      end

      it 'removes merge parameters' do
        subject

        merge_request.reload
        expect(merge_request.merge_params['should_remove_source_branch']).to be_nil
        expect(merge_request.merge_params['commit_message']).to be_nil
        expect(merge_request.merge_params['squash_commit_message']).to be_nil
        expect(merge_request.merge_params['auto_merge_strategy']).to be_nil
      end
    end

    context 'when failed to save' do
      before do
        allow(merge_request).to receive(:save!) { raise ActiveRecord::RecordInvalid }
      end

      it 'does not yield block' do
        expect { |b| service.execute(merge_request, &b) }.not_to yield_control
      end
    end
  end

  describe '#cancel' do
    subject { service.cancel(merge_request) }

    let(:merge_request) { create(:merge_request, :merge_when_pipeline_succeeds) }

    it_behaves_like 'Canceled or Dropped'

    context 'when failed to save merge request' do
      before do
        allow(merge_request).to receive(:save!) { raise ActiveRecord::RecordInvalid }
      end

      it 'returns error status' do
        expect(subject[:status]).to eq(:error)
        expect(subject[:message]).to eq(""Can't cancel the automatic merge"")
      end
    end

    context 'when exception happens in yield block' do
      def cancel_with_error_in_yield
        service.cancel(merge_request) { raise 'Something went wrong' }
      end

      it 'returns error' do
        result = cancel_with_error_in_yield
        expect(result[:status]).to eq(:error)
        expect(result[:message]).to eq(""Can't cancel the automatic merge"")
      end

      it 'rollback the transaction' do
        cancel_with_error_in_yield

        merge_request.reload
        expect(merge_request).to be_auto_merge_enabled
      end

      it 'tracks the exception' do
        expect(Gitlab::ErrorTracking)
          .to receive(:track_exception)
          .with(kind_of(RuntimeError), merge_request_id: merge_request.id)

        cancel_with_error_in_yield
      end
    end
  end

  describe '#abort' do
    subject { service.abort(merge_request, reason) }

    let(:merge_request) { create(:merge_request, :merge_when_pipeline_succeeds) }
    let(:reason) { 'an error' }

    it_behaves_like 'Canceled or Dropped'

    context 'when failed to save' do
      before do
        allow(merge_request).to receive(:save!) { raise ActiveRecord::RecordInvalid }
      end

      it 'returns error status' do
        expect(subject[:status]).to eq(:error)
        expect(subject[:message]).to eq(""Can't abort the automatic merge"")
      end
    end

    context 'when exception happens in yield block' do
      def abort_with_error_in_yield
        service.abort(merge_request, reason) { raise 'Something went wrong' }
      end

      it 'returns error' do
        result = abort_with_error_in_yield
        expect(result[:status]).to eq(:error)
        expect(result[:message]).to eq(""Can't abort the automatic merge"")
      end

      it 'rollback the transaction' do
        abort_with_error_in_yield

        merge_request.reload
        expect(merge_request).to be_auto_merge_enabled
      end

      it 'tracks the exception' do
        expect(Gitlab::ErrorTracking)
          .to receive(:track_exception)
          .with(kind_of(RuntimeError), merge_request_id: merge_request.id)

        abort_with_error_in_yield
      end
    end
  end

  describe '#process' do
    specify { expect(service).to respond_to :process }
    specify { expect { service.process(nil) }.to raise_error NotImplementedError }
  end

  describe '#available_for?' do
    using RSpec::Parameterized::TableSyntax

    subject(:available_for) { service.available_for?(merge_request) { true } }

    let(:merge_request) { create(:merge_request) }

    where(:can_be_merged, :open, :broken, :discussions, :blocked, :draft, :result) do
      true | true | false | true | false | false | true
      false | true | false | true | false | false | false
      true | false | false | true | false | false | false
      true | true | true | true | false | false | false
      true | true | false | false | false | false | false
      true | true | false | true | true | false | false
      true | true | false | true | false | true | false
    end

    with_them do
      before do
        allow(merge_request).to receive(:can_be_merged_by?).and_return(can_be_merged)
        allow(merge_request).to receive(:open?).and_return(open)
        allow(merge_request).to receive(:broken?).and_return(broken)
        allow(merge_request).to receive(:draft?).and_return(draft)
        allow(merge_request).to receive(:mergeable_discussions_state?).and_return(discussions)
        allow(merge_request).to receive(:merge_blocked_by_other_mrs?).and_return(blocked)
      end

      it 'returns the expected results' do
        expect(available_for).to eq(result)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module AuthorizedProjectUpdate
  class ProjectAccessChangedService
    def initialize(project_ids)
      @project_ids = Array.wrap(project_ids)
    end

    def execute
      return if @project_ids.empty?

      bulk_args = @project_ids.map { |id| [id] }

      AuthorizedProjectUpdate::ProjectRecalculateWorker.bulk_perform_async(bulk_args) # rubocop:disable Scalability/BulkPerformWithContext
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe AuthorizedProjectUpdate::ProjectAccessChangedService, feature_category: :groups_and_projects do
  describe '#execute' do
    it 'executes projects_authorizations refresh' do
      expect(AuthorizedProjectUpdate::ProjectRecalculateWorker).to receive(:bulk_perform_async)
        .with([[1], [2]])

      described_class.new([1, 2]).execute
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module AuthorizedProjectUpdate
  class ProjectRecalculatePerUserService < ProjectRecalculateService
    def initialize(project, user)
      @project = project
      @user = user
    end

    private

    attr_reader :user

    def apply_scopes(project_authorizations)
      super.where(user_id: user.id) # rubocop: disable CodeReuse/ActiveRecord
    end

    def effective_access_levels
      Projects::Members::EffectiveAccessLevelPerUserFinder.new(project, user).execute
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe AuthorizedProjectUpdate::ProjectRecalculatePerUserService, '#execute', feature_category: :groups_and_projects do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }
  let_it_be(:another_user) { create(:user) }

  subject(:execute) { described_class.new(project, user).execute }

  it 'returns success' do
    expect(execute.success?).to eq(true)
  end

  context 'when there are no changes to be made' do
    it 'does not change authorizations' do
      expect { execute }.not_to(change { ProjectAuthorization.count })
    end
  end

  context 'when there are changes to be made' do
    context 'when addition is required' do
      before do
        project.add_developer(user)
        project.add_developer(another_user)
        project.project_authorizations.where(user: [user, another_user]).delete_all
      end

      it 'adds a new authorization record for the specific user' do
        expect { execute }.to(
          change { project.project_authorizations.where(user: user).count }
          .from(0).to(1)
        )
      end

      it 'does not add a new authorization record for the other user' do
        expect { execute }.not_to(
          change { project.project_authorizations.where(user: another_user).count }
        )
      end

      it 'adds a new authorization record with the correct access level for the specific user' do
        execute

        project_authorization = project.project_authorizations.where(
          user: user,
          access_level: Gitlab::Access::DEVELOPER
        )

        expect(project_authorization).to exist
      end
    end

    context 'when removal is required' do
      before do
        create(:project_authorization, user: user, project: project)
        create(:project_authorization, user: another_user, project: project)
      end

      it 'removes the authorization record for the specific user' do
        expect { execute }.to(
          change { project.project_authorizations.where(user: user).count }
          .from(1).to(0)
        )
      end

      it 'does not remove the authorization record for the other user' do
        expect { execute }.not_to(
          change { project.project_authorizations.where(user: another_user).count }
        )
      end
    end

    context 'when an update in access level is required' do
      before do
        project.add_developer(user)
        project.add_developer(another_user)
        project.project_authorizations.where(user: [user, another_user]).delete_all
        create(:project_authorization, project: project, user: user, access_level: Gitlab::Access::GUEST)
        create(:project_authorization, project: project, user: another_user, access_level: Gitlab::Access::GUEST)
      end

      it 'updates the authorization of the specific user to the correct access level' do
        expect { execute }.to(
          change { project.project_authorizations.find_by(user: user).access_level }
            .from(Gitlab::Access::GUEST).to(Gitlab::Access::DEVELOPER)
        )
      end

      it 'does not update the authorization of the other user to the correct access level' do
        expect { execute }.not_to(
          change { project.project_authorizations.find_by(user: another_user).access_level }
            .from(Gitlab::Access::GUEST)
        )
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module AuthorizedProjectUpdate
  class PeriodicRecalculateService
    BATCH_SIZE = 450
    DELAY_INTERVAL = 50.seconds.to_i

    def execute
      # Using this approach (instead of eg. User.each_batch) keeps the arguments
      # the same for AuthorizedProjectUpdate::UserRefreshOverUserRangeWorker
      # even if the user list changes, so we can deduplicate these jobs.

      # Since UserRefreshOverUserRangeWorker has set data_consistency to delayed,
      # a job enqueued without a delay could fail because the replica could not catch up with the primary.
      # To prevent this, we start the index from `1` instead of `0` so as to ensure that
      # no UserRefreshOverUserRangeWorker job is enqueued without a delay.
      (1..User.maximum(:id)).each_slice(BATCH_SIZE).with_index(1) do |batch, index|
        delay = DELAY_INTERVAL * index
        AuthorizedProjectUpdate::UserRefreshOverUserRangeWorker.perform_in(delay, *batch.minmax)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe AuthorizedProjectUpdate::PeriodicRecalculateService, feature_category: :groups_and_projects do
  subject(:service) { described_class.new }

  describe '#execute' do
    let(:batch_size) { 2 }

    let_it_be(:users) { create_list(:user, 4) }

    before do
      stub_const('AuthorizedProjectUpdate::PeriodicRecalculateService::BATCH_SIZE', batch_size)

      User.delete([users[1], users[2]])
    end

    it 'calls AuthorizedProjectUpdate::UserRefreshOverUserRangeWorker' do
      (1..User.maximum(:id)).each_slice(batch_size).with_index(1) do |batch, index|
        delay = AuthorizedProjectUpdate::PeriodicRecalculateService::DELAY_INTERVAL * index

        expect(AuthorizedProjectUpdate::UserRefreshOverUserRangeWorker).to(
          receive(:perform_in).with(delay, *batch.minmax))
      end

      service.execute
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module AuthorizedProjectUpdate
  # Service for finding the authorized_projects records of a user that needs addition or removal.
  #
  # Usage:
  #
  #     user = User.find_by(username: 'alice')
  #     service = AuthorizedProjectUpdate::FindRecordsDueForRefreshService.new(some_user)
  #     service.execute
  class FindRecordsDueForRefreshService
    def initialize(user, source: nil, incorrect_auth_found_callback: nil, missing_auth_found_callback: nil)
      @user = user
      @source = source
      @incorrect_auth_found_callback = incorrect_auth_found_callback
      @missing_auth_found_callback = missing_auth_found_callback
    end

    def execute
      current = current_authorizations_per_project
      fresh = fresh_access_levels_per_project

      # Projects that have more than one authorizations associated with
      # the user needs to be deleted.
      # The correct authorization is added to the ``add`` array in the
      # next stage.
      remove = projects_with_duplicates
      current.except!(*projects_with_duplicates)

      remove |= current.each_with_object([]) do |(project_id, row), array|
        next if fresh[project_id] && fresh[project_id] == row.access_level

        # rows not in the new list or with a different access level should be
        # removed.

        if incorrect_auth_found_callback
          incorrect_auth_found_callback.call(project_id, row.access_level)
        end

        array << row.project_id
      end

      add = fresh.each_with_object([]) do |(project_id, level), array|
        next if current[project_id] && current[project_id].access_level == level

        # rows not in the old list or with a different access level should be
        # added.

        if missing_auth_found_callback
          missing_auth_found_callback.call(project_id, level)
        end

        array << {
          user_id: user.id,
          project_id: project_id,
          access_level: level
        }
      end

      [remove, add]
    end

    def needs_refresh?
      remove, add = execute

      remove.present? || add.present?
    end

    def fresh_access_levels_per_project
      fresh_authorizations.each_with_object({}) do |row, hash|
        hash[row.project_id] = row.access_level
      end
    end

    def current_authorizations_per_project
      current_authorizations.index_by(&:project_id)
    end

    def current_authorizations
      @current_authorizations ||= user.project_authorizations.select(:project_id, :access_level)
    end

    def fresh_authorizations
      Gitlab::ProjectAuthorizations.new(user).calculate
    end

    private

    attr_reader :user, :source, :incorrect_auth_found_callback, :missing_auth_found_callback

    def projects_with_duplicates
      @projects_with_duplicates ||= current_authorizations
                                      .group_by(&:project_id)
                                      .select { |project_id, authorizations| authorizations.count > 1 }
                                      .keys
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe AuthorizedProjectUpdate::FindRecordsDueForRefreshService, feature_category: :groups_and_projects do
  # We're using let! here so that any expectations for the service class are not
  # triggered twice.
  let!(:project) { create(:project) }

  let(:user) { project.namespace.owner }
  let(:service) { described_class.new(user) }

  describe '#execute' do
    context 'callbacks' do
      let(:callback) { double('callback') }

      context 'incorrect_auth_found_callback callback' do
        let(:user) { create(:user) }
        let(:service) do
          described_class.new(user, incorrect_auth_found_callback: callback)
        end

        it 'is called' do
          access_level = Gitlab::Access::DEVELOPER
          create(:project_authorization, user: user, project: project, access_level: access_level)

          expect(callback).to receive(:call).with(project.id, access_level).once

          service.execute
        end
      end

      context 'missing_auth_found_callback callback' do
        let(:service) do
          described_class.new(user, missing_auth_found_callback: callback)
        end

        it 'is called' do
          ProjectAuthorization.delete_all

          expect(callback).to receive(:call).with(project.id, Gitlab::Access::OWNER).once

          service.execute
        end
      end
    end

    context 'finding project authorizations due for refresh' do
      context 'when there are changes to be made' do
        before do
          user.project_authorizations.delete_all
        end

        it 'finds projects authorizations that needs to be refreshed' do
          project2 = create(:project)
          user.project_authorizations
            .create!(project: project2, access_level: Gitlab::Access::MAINTAINER)

          to_be_removed = [project2.id]
          to_be_added = [
            { user_id: user.id, project_id: project.id, access_level: Gitlab::Access::OWNER }
          ]

          expect(service.execute).to eq([to_be_removed, to_be_added])
        end

        it 'finds entries with wrong access levels' do
          user.project_authorizations
            .create!(project: project, access_level: Gitlab::Access::DEVELOPER)

          to_be_removed = [project.id]
          to_be_added = [
            { user_id: user.id, project_id: project.id, access_level: Gitlab::Access::OWNER }
          ]

          expect(service.execute).to eq([to_be_removed, to_be_added])
        end
      end

      context 'when there are no changes to be made' do
        it 'returns empty arrays' do
          expect(service.execute).to eq([[], []])
        end
      end
    end
  end

  describe '#needs_refresh?' do
    subject { service.needs_refresh? }

    context 'when there are records due for either removal or addition' do
      context 'when there are both removals and additions to be made' do
        before do
          user.project_authorizations.delete_all
          create(:project_authorization, user: user)
        end

        it { is_expected.to eq(true) }
      end

      context 'when there are no removals, but there are additions to be made' do
        before do
          user.project_authorizations.delete_all
        end

        it { is_expected.to eq(true) }
      end

      context 'when there are no additions, but there are removals to be made' do
        before do
          create(:project_authorization, user: user)
        end

        it { is_expected.to eq(true) }
      end
    end

    context 'when there are no additions or removals to be made' do
      it { is_expected.to eq(false) }
    end
  end

  describe '#fresh_access_levels_per_project' do
    let(:hash) { service.fresh_access_levels_per_project }

    it 'returns a Hash' do
      expect(hash).to be_an_instance_of(Hash)
    end

    it 'sets the keys to the project IDs' do
      expect(hash.keys).to match_array([project.id])
    end

    it 'sets the values to the access levels' do
      expect(hash.values).to match_array([Gitlab::Access::OWNER])
    end

    context 'personal projects' do
      it 'includes the project with the right access level' do
        expect(hash[project.id]).to eq(Gitlab::Access::OWNER)
      end
    end

    context 'projects the user is a member of' do
      let!(:other_project) { create(:project) }

      before do
        other_project.team.add_reporter(user)
      end

      it 'includes the project with the right access level' do
        expect(hash[other_project.id]).to eq(Gitlab::Access::REPORTER)
      end
    end

    context 'projects of groups the user is a member of' do
      let(:group) { create(:group) }
      let!(:other_project) { create(:project, group: group) }

      before do
        group.add_owner(user)
      end

      it 'includes the project with the right access level' do
        expect(hash[other_project.id]).to eq(Gitlab::Access::OWNER)
      end
    end

    context 'projects of subgroups of groups the user is a member of' do
      let(:group) { create(:group) }
      let(:nested_group) { create(:group, parent: group) }
      let!(:other_project) { create(:project, group: nested_group) }

      before do
        group.add_maintainer(user)
      end

      it 'includes the project with the right access level' do
        expect(hash[other_project.id]).to eq(Gitlab::Access::MAINTAINER)
      end
    end

    context 'projects shared with groups the user is a member of' do
      let(:group) { create(:group) }
      let(:other_project) { create(:project) }
      let!(:project_group_link) { create(:project_group_link, project: other_project, group: group, group_access: Gitlab::Access::GUEST) }

      before do
        group.add_maintainer(user)
      end

      it 'includes the project with the right access level' do
        expect(hash[other_project.id]).to eq(Gitlab::Access::GUEST)
      end
    end

    context 'projects shared with subgroups of groups the user is a member of' do
      let(:group) { create(:group) }
      let(:nested_group) { create(:group, parent: group) }
      let(:other_project) { create(:project) }
      let!(:project_group_link) { create(:project_group_link, project: other_project, group: nested_group, group_access: Gitlab::Access::DEVELOPER) }

      before do
        group.add_maintainer(user)
      end

      it 'includes the project with the right access level' do
        expect(hash[other_project.id]).to eq(Gitlab::Access::DEVELOPER)
      end
    end
  end

  describe '#current_authorizations_per_project' do
    let(:hash) { service.current_authorizations_per_project }

    it 'returns a Hash' do
      expect(hash).to be_an_instance_of(Hash)
    end

    it 'sets the keys to the project IDs' do
      expect(hash.keys).to eq([project.id])
    end

    it 'sets the values to the project authorization rows' do
      expect(hash.values.length).to eq(1)

      value = hash.values[0]

      expect(value.project_id).to eq(project.id)
      expect(value.access_level).to eq(Gitlab::Access::OWNER)
    end
  end

  describe '#current_authorizations' do
    context 'without authorizations' do
      it 'returns an empty list' do
        user.project_authorizations.delete_all

        expect(service.current_authorizations.empty?).to eq(true)
      end
    end

    context 'with an authorization' do
      let(:row) { service.current_authorizations.take }

      it 'returns the currently authorized projects' do
        expect(service.current_authorizations.length).to eq(1)
      end

      it 'includes the project ID for every row' do
        expect(row.project_id).to eq(project.id)
      end

      it 'includes the access level for every row' do
        expect(row.access_level).to eq(Gitlab::Access::OWNER)
      end
    end
  end

  describe '#fresh_authorizations' do
    it 'returns the new authorized projects' do
      expect(service.fresh_authorizations.length).to eq(1)
    end

    it 'returns the highest access level' do
      project.team.add_guest(user)

      rows = service.fresh_authorizations.to_a

      expect(rows.length).to eq(1)
      expect(rows.first.access_level).to eq(Gitlab::Access::OWNER)
    end

    context 'every returned row' do
      let(:row) { service.fresh_authorizations.take }

      it 'includes the project ID' do
        expect(row.project_id).to eq(project.id)
      end

      it 'includes the access level' do
        expect(row.access_level).to eq(Gitlab::Access::OWNER)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module AuthorizedProjectUpdate
  class ProjectRecalculateService
    # Service for refreshing all the authorizations to a particular project.
    include Gitlab::Utils::StrongMemoize
    BATCH_SIZE = 1000

    def initialize(project)
      @project = project
    end

    def execute
      refresh_authorizations if needs_refresh?
      ServiceResponse.success
    end

    private

    attr_reader :project

    def needs_refresh?
      user_ids_to_remove.any? ||
        authorizations_to_create.any?
    end

    def current_authorizations
      strong_memoize(:current_authorizations) do
        apply_scopes(project.project_authorizations)
          .pluck(:user_id, :access_level) # rubocop: disable CodeReuse/ActiveRecord
      end
    end

    def fresh_authorizations
      strong_memoize(:fresh_authorizations) do
        result = []

        effective_access_levels
          .each_batch(of: BATCH_SIZE, column: :user_id) do |member_batch|
            result += member_batch.pluck(:user_id, 'MAX(access_level)') # rubocop: disable CodeReuse/ActiveRecord
          end

        result
      end
    end

    def user_ids_to_remove
      strong_memoize(:user_ids_to_remove) do
        (current_authorizations - fresh_authorizations)
          .map { |user_id, _| user_id }
      end
    end

    def authorizations_to_create
      strong_memoize(:authorizations_to_create) do
        (fresh_authorizations - current_authorizations).map do |user_id, access_level|
          {
            user_id: user_id,
            access_level: access_level,
            project_id: project.id
          }
        end
      end
    end

    def refresh_authorizations
      ProjectAuthorizations::Changes.new do |changes|
        changes.add(authorizations_to_create)
        changes.remove_users_in_project(project, user_ids_to_remove)
      end.apply!
    end

    def apply_scopes(project_authorizations)
      project_authorizations
    end

    def effective_access_levels
      Projects::Members::EffectiveAccessLevelFinder.new(project).execute
    end
  end
end

AuthorizedProjectUpdate::ProjectRecalculateService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe AuthorizedProjectUpdate::ProjectRecalculateService, '#execute', feature_category: :groups_and_projects do
  let_it_be(:project) { create(:project) }

  subject(:execute) { described_class.new(project).execute }

  it 'returns success' do
    expect(execute.success?).to eq(true)
  end

  context 'when there are no changes to be made' do
    it 'does not change authorizations' do
      expect { execute }.not_to(change { ProjectAuthorization.count })
    end
  end

  context 'when there are changes to be made' do
    let(:user) { create(:user) }

    context 'when addition is required' do
      before do
        project.add_developer(user)
        project.project_authorizations.where(user: user).delete_all
      end

      it 'adds a new authorization record' do
        expect { execute }.to(
          change { project.project_authorizations.where(user: user).count }
          .from(0).to(1)
        )
      end

      it 'adds a new authorization record with the correct access level' do
        execute

        project_authorization = project.project_authorizations.where(
          user: user,
          access_level: Gitlab::Access::DEVELOPER
        )

        expect(project_authorization).to exist
      end
    end

    context 'when removal is required' do
      before do
        create(:project_authorization, user: user, project: project)
      end

      it 'removes the authorization record' do
        expect { execute }.to(
          change { project.project_authorizations.where(user: user).count }
          .from(1).to(0)
        )
      end
    end

    context 'when an update in access level is required' do
      before do
        project.add_developer(user)
        project.project_authorizations.where(user: user).delete_all
        create(:project_authorization, project: project, user: user, access_level: Gitlab::Access::GUEST)
      end

      it 'updates the authorization of the user to the correct access level' do
        expect { execute }.to(
          change { project.project_authorizations.find_by(user: user).access_level }
            .from(Gitlab::Access::GUEST).to(Gitlab::Access::DEVELOPER)
        )
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module SystemNotes
  class IssuablesService < ::SystemNotes::BaseService
    # We create cross-referenced system notes when a commit relates to an issue.
    # There are two options what time to use for the system note:
    # 1. The push date (default)
    # 2. The commit date
    #
    # The commit date is useful when an existing Git repository is imported to GitLab.
    # It helps to preserve an original order of all notes (comments, commits, status changes, e.t.c)
    # in the imported issues. Otherwise, all commits will be linked before or after all other imported notes.
    #
    # See also the discussion in https://gitlab.com/gitlab-org/gitlab/-/merge_requests/60700#note_612724683
    USE_COMMIT_DATE_FOR_CROSS_REFERENCE_NOTE = false

    def self.issuable_events
      {
        assigned: s_('IssuableEvents|assigned to'),
        unassigned: s_('IssuableEvents|unassigned'),
        review_requested: s_('IssuableEvents|requested review from'),
        review_request_removed: s_('IssuableEvents|removed review request for')
      }.freeze
    end

    #
    # noteable_ref - Referenced noteable object, or array of objects
    #
    # Example Note text:
    #
    #   ""marked this issue as related to gitlab-foss#9001""
    #   ""marked this issue as related to gitlab-foss#9001, gitlab-foss#9002, and gitlab-foss#9003""
    #
    # Returns the created Note object
    def relate_issuable(noteable_ref)
      body = ""marked this #{noteable_name} as related to #{extract_issuable_reference(noteable_ref)}""

      track_issue_event(:track_issue_related_action)

      create_note(NoteSummary.new(noteable, project, author, body, action: 'relate'))
    end

    #
    # noteable_ref - Referenced noteable object
    #
    # Example Note text:
    #
    #   ""removed the relation with gitlab-foss#9001""
    #
    # Returns the created Note object
    def unrelate_issuable(noteable_ref)
      body = ""removed the relation with #{noteable_ref.to_reference(noteable.resource_parent)}""

      track_issue_event(:track_issue_unrelated_action)

      create_note(NoteSummary.new(noteable, project, author, body, action: 'unrelate'))
    end

    # Called when the assignee of a Noteable is changed or removed
    #
    # assignee - User being assigned, or nil
    #
    # Example Note text:
    #
    #   ""removed assignee""
    #
    #   ""assigned to @rspeicher""
    #
    # Returns the created Note object
    def change_assignee(assignee)
      body = assignee.nil? ? 'removed assignee' : ""assigned to #{assignee.to_reference}""

      track_issue_event(:track_issue_assignee_changed_action)

      create_note(NoteSummary.new(noteable, project, author, body, action: 'assignee'))
    end

    # Called when the assignees of an issuable is changed or removed
    #
    # assignees - Users being assigned, or nil
    #
    # Example Note text:
    #
    #   ""removed all assignees""
    #
    #   ""assigned to @user1 additionally to @user2""
    #
    #   ""assigned to @user1, @user2 and @user3 and unassigned @user4 and @user5""
    #
    #   ""assigned to @user1 and @user2""
    #
    # Returns the created Note object
    def change_issuable_assignees(old_assignees)
      unassigned_users = old_assignees - noteable.assignees
      added_users = noteable.assignees.to_a - old_assignees
      text_parts = []

      Gitlab::I18n.with_default_locale do
        text_parts << ""#{self.class.issuable_events[:assigned]} #{added_users.map(&:to_reference).to_sentence}"" if added_users.any?
        text_parts << ""#{self.class.issuable_events[:unassigned]} #{unassigned_users.map(&:to_reference).to_sentence}"" if unassigned_users.any?
      end

      body = text_parts.join(' and ')

      track_issue_event(:track_issue_assignee_changed_action)

      create_note(NoteSummary.new(noteable, project, author, body, action: 'assignee'))
    end

    # Called when the reviewers of an issuable is changed or removed
    #
    # reviewers - Users being requested to review, or nil
    #
    # Example Note text:
    #
    #   ""requested review from @user1 and @user2""
    #
    #   ""requested review from @user1, @user2 and @user3 and removed review request for @user4 and @user5""
    #
    # Returns the created Note object
    def change_issuable_reviewers(old_reviewers)
      unassigned_users = old_reviewers - noteable.reviewers
      added_users = noteable.reviewers - old_reviewers
      text_parts = []

      Gitlab::I18n.with_default_locale do
        text_parts << ""#{self.class.issuable_events[:review_requested]} #{added_users.map(&:to_reference).to_sentence}"" if added_users.any?
        text_parts << ""#{self.class.issuable_events[:review_request_removed]} #{unassigned_users.map(&:to_reference).to_sentence}"" if unassigned_users.any?
      end

      body = text_parts.join(' and ')

      create_note(NoteSummary.new(noteable, project, author, body, action: 'reviewer'))
    end

    # Called when the contacts of an issuable are changed or removed
    # We intend to reference the contacts but for security we are just
    # going to state how many were added/removed for now. See discussion:
    # https://gitlab.com/gitlab-org/gitlab/-/merge_requests/77816#note_806114273
    #
    # added_count - number of contacts added, or 0
    # removed_count - number of contacts  removed, or 0
    #
    # Example Note text:
    #
    #   ""added 2 contacts""
    #
    #   ""added 3 contacts and removed one contact""
    #
    # Returns the created Note object
    def change_issuable_contacts(added_count, removed_count)
      text_parts = []

      Gitlab::I18n.with_default_locale do
        text_parts << ""added #{added_count} #{'contact'.pluralize(added_count)}"" if added_count > 0
        text_parts << ""removed #{removed_count} #{'contact'.pluralize(removed_count)}"" if removed_count > 0
      end

      return if text_parts.empty?

      body = text_parts.join(' and ')
      create_note(NoteSummary.new(noteable, project, author, body, action: 'contact'))
    end

    # Called when the title of a Noteable is changed
    #
    # old_title - Previous String title
    #
    # Example Note text:
    #
    #   ""changed title from **Old** to **New**""
    #
    # Returns the created Note object
    def change_title(old_title)
      new_title = noteable.title.dup

      old_diffs, new_diffs = Gitlab::Diff::InlineDiff.new(old_title, new_title).inline_diffs

      marked_old_title = Gitlab::Diff::InlineDiffMarkdownMarker.new(old_title).mark(old_diffs)
      marked_new_title = Gitlab::Diff::InlineDiffMarkdownMarker.new(new_title).mark(new_diffs)

      body = ""changed title from **#{marked_old_title}** to **#{marked_new_title}**""

      track_issue_event(:track_issue_title_changed_action)
      work_item_activity_counter.track_work_item_title_changed_action(author: author) if noteable.is_a?(WorkItem)

      create_note(NoteSummary.new(noteable, project, author, body, action: 'title'))
    end

    # Called when the hierarchy of a work item is changed
    #
    # noteable  - Noteable object that responds to `work_item_parent` and `work_item_children`
    # project   - Project owning noteable
    # author    - User performing the change
    #
    # Example Note text:
    #
    #   ""added #1 as child Task""
    #
    # Returns the created Note object
    def hierarchy_changed(work_item, action)
      params = hierarchy_note_params(action, noteable, work_item)

      create_note(NoteSummary.new(noteable, project, author, params[:parent_note_body], action: params[:parent_action]))
      create_note(NoteSummary.new(work_item, project, author, params[:child_note_body], action: params[:child_action]))
    end

    # Called when the description of a Noteable is changed
    #
    # noteable  - Noteable object that responds to `description`
    # project   - Project owning noteable
    # author    - User performing the change
    #
    # Example Note text:
    #
    #   ""changed the description""
    #
    # Returns the created Note object
    def change_description
      body = 'changed the description'

      track_issue_event(:track_issue_description_changed_action)

      create_note(NoteSummary.new(noteable, project, author, body, action: 'description'))
    end

    # Called when a Mentionable (the `mentioned_in`) references another Mentionable (the `mentioned`,
    # passed to this service as `noteable`).
    #
    # Example Note text:
    #
    #   ""mentioned in #1""
    #
    #   ""mentioned in !2""
    #
    #   ""mentioned in 54f7727c""
    #
    # See cross_reference_note_content.
    #
    # @param mentioned_in [Mentionable]
    # @return [Note]
    def cross_reference(mentioned_in)
      return if cross_reference_disallowed?(mentioned_in)

      gfm_reference = mentioned_in.gfm_reference(noteable.project || noteable.group)
      body = cross_reference_note_content(gfm_reference)

      if noteable.is_a?(ExternalIssue)
        Integrations::CreateExternalCrossReferenceWorker.perform_async(
          noteable.project_id,
          noteable.id,
          mentioned_in.class.name,
          mentioned_in.id,
          author.id
        )
      else
        track_cross_reference_action

        created_at = mentioner.created_at if USE_COMMIT_DATE_FOR_CROSS_REFERENCE_NOTE && mentioner.is_a?(Commit)
        create_note(NoteSummary.new(noteable, noteable.project, author, body, action: 'cross_reference', created_at: created_at))
      end
    end

    # Check if a cross-reference is disallowed
    #
    # This method prevents adding a ""mentioned in !1"" note on every single commit
    # in a merge request. Additionally, it prevents the creation of references to
    # external issues (which would fail).
    #
    # @param mentioned_in [Mentionable]
    # @return [Boolean]
    def cross_reference_disallowed?(mentioned_in)
      return true if noteable.is_a?(ExternalIssue) && !noteable.project&.external_references_supported?
      return false unless mentioned_in.is_a?(MergeRequest)
      return false unless noteable.is_a?(Commit)

      mentioned_in.commits.include?(noteable)
    end

    # Called when the status of a Task has changed
    #
    # new_task  - TaskList::Item object.
    #
    # Example Note text:
    #
    #   ""marked the checklist item Whatever as completed.""
    #
    # Returns the created Note object
    def change_task_status(new_task)
      status_label = new_task.complete? ? Taskable::COMPLETED : Taskable::INCOMPLETE
      body = ""marked the checklist item **#{new_task.source}** as #{status_label}""

      track_issue_event(:track_issue_description_changed_action)

      create_note(NoteSummary.new(noteable, project, author, body, action: 'task'))
    end

    # Called when noteable has been moved to another project
    #
    # noteable_ref - Referenced noteable
    # direction    - symbol, :to or :from
    #
    # Example Note text:
    #
    #   ""moved to some_namespace/project_new#11""
    #
    # Returns the created Note object
    def noteable_moved(noteable_ref, direction)
      unless [:to, :from].include?(direction)
        raise ArgumentError, ""Invalid direction `#{direction}`""
      end

      cross_reference = noteable_ref.to_reference(project)
      body = ""moved #{direction} #{cross_reference}""

      track_issue_event(:track_issue_moved_action)

      create_note(NoteSummary.new(noteable, project, author, body, action: 'moved'))
    end

    # Called when noteable has been cloned
    #
    # noteable_ref - Referenced noteable
    # direction    - symbol, :to or :from
    # created_at   - timestamp for the system note, defaults to current time
    #
    # Example Note text:
    #
    #   ""cloned to some_namespace/project_new#11""
    #
    # Returns the created Note object
    def noteable_cloned(noteable_ref, direction, created_at: nil)
      unless [:to, :from].include?(direction)
        raise ArgumentError, ""Invalid direction `#{direction}`""
      end

      cross_reference = noteable_ref.to_reference(project)
      body = ""cloned #{direction} #{cross_reference}""

      track_issue_event(:track_issue_cloned_action) if direction == :to

      create_note(NoteSummary.new(noteable, project, author, body, action: 'cloned', created_at: created_at))
    end

    # Called when the confidentiality changes
    #
    # Example Note text:
    #
    #   ""made the issue confidential""
    #
    # Returns the created Note object
    def change_issue_confidentiality
      if noteable.confidential
        body = ""made the #{noteable_name} confidential""
        action = 'confidential'

        track_issue_event(:track_issue_made_confidential_action)
      else
        body = ""made the #{noteable_name} visible to everyone""
        action = 'visible'

        track_issue_event(:track_issue_made_visible_action)
      end

      create_note(NoteSummary.new(noteable, project, author, body, action: action))
    end

    # Called when the status of a Noteable is changed
    #
    # status   - String status
    # source   - Mentionable performing the change, or nil
    #
    # Example Note text:
    #
    #   ""merged""
    #
    #   ""closed via bc17db76""
    #
    # Returns the created Note object
    def change_status(status, source = nil)
      create_resource_state_event(status: status, mentionable_source: source)
    end

    # Check if a cross reference to a Mentionable from the `mentioned_in` Mentionable
    # already exists.
    #
    # This method is used to prevent multiple notes being created for a mention
    # when a issue is updated, for example. The method also calls `existing_mentions_for`
    # to check if the mention is in a commit, and return matches only on commit hash
    # instead of project + commit, to avoid repeated mentions from forks.
    #
    # @param mentioned_in [Mentionable]
    # @return [Boolean]
    def cross_reference_exists?(mentioned_in)
      notes = noteable.notes.system
      existing_mentions_for(mentioned_in, noteable, notes).exists?
    end

    # Called when a Noteable has been marked as the canonical Issue of a duplicate
    #
    # duplicate_issue - Issue that was a duplicate of this
    #
    # Example Note text:
    #
    #   ""marked #1234 as a duplicate of this issue""
    #
    #   ""marked other_project#5678 as a duplicate of this issue""
    #
    # Returns the created Note object
    def mark_canonical_issue_of_duplicate(duplicate_issue)
      body = ""marked #{duplicate_issue.to_reference(project)} as a duplicate of this issue""
      create_note(NoteSummary.new(noteable, project, author, body, action: 'duplicate'))
    end

    # Called when a Noteable has been marked as a duplicate of another Issue
    #
    # canonical_issue - Issue that this is a duplicate of
    #
    # Example Note text:
    #
    #   ""marked this issue as a duplicate of #1234""
    #
    #   ""marked this issue as a duplicate of other_project#5678""
    #
    # Returns the created Note object
    def mark_duplicate_issue(canonical_issue)
      body = ""marked this issue as a duplicate of #{canonical_issue.to_reference(project)}""

      track_issue_event(:track_issue_marked_as_duplicate_action)

      create_note(NoteSummary.new(noteable, project, author, body, action: 'duplicate'))
    end

    def add_email_participants(body)
      create_note(NoteSummary.new(noteable, project, author, body))
    end

    def discussion_lock
      action = noteable.discussion_locked? ? 'locked' : 'unlocked'
      body = ""#{action} the discussion in this #{noteable.class.to_s.titleize.downcase}""

      if action == 'locked'
        track_issue_event(:track_issue_locked_action)
      else
        track_issue_event(:track_issue_unlocked_action)
      end

      create_note(NoteSummary.new(noteable, project, author, body, action: action))
    end

    def close_after_error_tracking_resolve
      create_resource_state_event(status: 'closed', close_after_error_tracking_resolve: true)
    end

    def auto_resolve_prometheus_alert
      create_resource_state_event(status: 'closed', close_auto_resolve_prometheus_alert: true)
    end

    def change_issue_type(previous_type)
      previous = previous_type.humanize(capitalize: false)
      new = noteable.issue_type.humanize(capitalize: false)
      body = ""changed type from #{previous} to #{new}""

      create_note(NoteSummary.new(noteable, project, author, body, action: 'issue_type'))
    end

    private

    def cross_reference_note_content(gfm_reference)
      ""#{self.class.cross_reference_note_prefix}#{gfm_reference}""
    end

    def existing_mentions_for(mentioned_in, noteable, notes)
      if mentioned_in.is_a?(Commit)
        text = ""#{self.class.cross_reference_note_prefix}%#{mentioned_in.to_reference(nil)}""
        notes.like_note_or_capitalized_note(text)
      else
        gfm_reference = mentioned_in.gfm_reference(noteable.project || noteable.group)
        text = cross_reference_note_content(gfm_reference)
        notes.for_note_or_capitalized_note(text)
      end
    end

    def self.cross_reference_note_prefix
      'mentioned in '
    end

    def self.cross_reference?(note_text)
      note_text =~ /\A#{cross_reference_note_prefix}/i
    end

    def create_resource_state_event(params)
      ResourceEvents::ChangeStateService.new(resource: noteable, user: author)
        .execute(params)
    end

    def issue_activity_counter
      Gitlab::UsageDataCounters::IssueActivityUniqueCounter
    end

    def work_item_activity_counter
      Gitlab::UsageDataCounters::WorkItemActivityUniqueCounter
    end

    def track_cross_reference_action
      track_issue_event(:track_issue_cross_referenced_action)
    end

    def hierarchy_note_params(action, parent, child)
      return {} unless child && parent

      child_type = child.issue_type.humanize(capitalize: false)
      parent_type = parent.issue_type.humanize(capitalize: false)

      if action == 'relate'
        {
          parent_note_body: ""added #{child.to_reference} as child #{child_type}"",
          child_note_body: ""added #{parent.to_reference} as parent #{parent_type}"",
          parent_action: 'relate_to_child',
          child_action: 'relate_to_parent'
        }
      else
        {
          parent_note_body: ""removed child #{child_type} #{child.to_reference}"",
          child_note_body: ""removed parent #{parent_type} #{parent.to_reference}"",
          parent_action: 'unrelate_from_child',
          child_action: 'unrelate_from_parent'
        }
      end
    end

    def track_issue_event(event_name)
      return unless noteable.is_a?(Issue)

      issue_activity_counter.public_send(event_name, author: author, project: project || noteable.project) # rubocop: disable GitlabSecurity/PublicSend
    end

    def noteable_name
      name = noteable.try(:issue_type) || noteable.to_ability_name

      name.humanize(capitalize: false)
    end

    def extract_issuable_reference(reference)
      if reference.is_a?(Array)
        reference.map { |item| item.to_reference(noteable.resource_parent) }.to_sentence
      else
        reference.to_reference(noteable.resource_parent)
      end
    end
  end
end

SystemNotes::IssuablesService.prepend_mod_with('SystemNotes::IssuablesService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::SystemNotes::IssuablesService, feature_category: :team_planning do
  include ProjectForksHelper

  let_it_be(:group)   { create(:group) }
  let_it_be(:project) { create(:project, :repository, group: group) }
  let_it_be(:author)  { create(:user) }

  let(:noteable)      { create(:issue, project: project) }
  let(:issue)         { noteable }

  let(:service) { described_class.new(noteable: noteable, project: project, author: author) }

  describe '#relate_issuable' do
    let_it_be(:issue1) { create(:issue, project: project) }
    let_it_be(:issue2) { create(:issue, project: project) }

    let(:noteable_ref) { issue1 }

    subject(:system_note) { service.relate_issuable(noteable_ref) }

    context 'when issue marks another as related' do
      it_behaves_like 'a system note' do
        let(:action) { 'relate' }
      end

      it 'sets the note text' do
        expect(system_note.note).to eq ""marked this issue as related to #{issue1.to_reference(project)}""
      end
    end

    context 'when issue marks several other issues as related' do
      let(:noteable_ref) { [issue1, issue2] }

      it_behaves_like 'a system note' do
        let(:action) { 'relate' }
      end

      it 'sets the note text' do
        expect(system_note.note).to eq(
          ""marked this issue as related to #{issue1.to_reference(project)} and #{issue2.to_reference(project)}""
        )
      end
    end

    context 'with work items' do
      let_it_be(:noteable) { create(:work_item, :task, project: project) }

      it 'sets the note text with the correct work item type' do
        expect(subject.note).to eq ""marked this task as related to #{noteable_ref.to_reference(project)}""
      end
    end
  end

  describe '#unrelate_issuable' do
    let(:noteable_ref) { create(:issue) }

    subject { service.unrelate_issuable(noteable_ref) }

    it_behaves_like 'a system note' do
      let(:action) { 'unrelate' }
    end

    context 'when issue relation is removed' do
      it 'sets the note text' do
        expect(subject.note).to eq ""removed the relation with #{noteable_ref.to_reference(project)}""
      end
    end
  end

  describe '#change_assignee' do
    subject { service.change_assignee(assignee) }

    let(:assignee) { create(:user) }

    it_behaves_like 'a system note' do
      let(:action) { 'assignee' }
    end

    context 'when assignee added' do
      it_behaves_like 'a note with overridable created_at'

      it 'sets the note text' do
        expect(subject.note).to eq ""assigned to @#{assignee.username}""
      end
    end

    context 'when assignee removed' do
      let(:assignee) { nil }

      it_behaves_like 'a note with overridable created_at'

      it 'sets the note text' do
        expect(subject.note).to eq 'removed assignee'
      end
    end
  end

  describe '#change_issuable_assignees' do
    subject { service.change_issuable_assignees([assignee]) }

    let(:assignee) { create(:user) }
    let(:assignee1) { create(:user) }
    let(:assignee2) { create(:user) }
    let(:assignee3) { create(:user) }

    it_behaves_like 'a system note' do
      let(:action) { 'assignee' }
    end

    def build_note(old_assignees, new_assignees)
      issue.assignees = new_assignees
      service.change_issuable_assignees(old_assignees).note
    end

    it_behaves_like 'a note with overridable created_at'

    it 'builds a correct phrase when an assignee is added to a non-assigned issue' do
      expect(build_note([], [assignee1])).to eq ""assigned to @#{assignee1.username}""
    end

    it 'builds a correct phrase when assignee removed' do
      expect(build_note([assignee1], [])).to eq ""unassigned @#{assignee1.username}""
    end

    it 'builds a correct phrase when assignees changed' do
      expect(build_note([assignee1], [assignee2])).to eq \
        ""assigned to @#{assignee2.username} and unassigned @#{assignee1.username}""
    end

    it 'builds a correct phrase when three assignees removed and one added' do
      expect(build_note([assignee, assignee1, assignee2], [assignee3])).to eq \
        ""assigned to @#{assignee3.username} and unassigned @#{assignee.username}, @#{assignee1.username}, and @#{assignee2.username}""
    end

    it 'builds a correct phrase when one assignee changed from a set' do
      expect(build_note([assignee, assignee1], [assignee, assignee2])).to eq \
        ""assigned to @#{assignee2.username} and unassigned @#{assignee1.username}""
    end

    it 'builds a correct phrase when one assignee removed from a set' do
      expect(build_note([assignee, assignee1, assignee2], [assignee, assignee1])).to eq \
        ""unassigned @#{assignee2.username}""
    end

    it 'builds a correct phrase when the locale is different' do
      Gitlab::I18n.with_locale('pt-BR') do
        expect(build_note([assignee, assignee1, assignee2], [assignee3])).to eq \
          ""assigned to @#{assignee3.username} and unassigned @#{assignee.username}, @#{assignee1.username}, and @#{assignee2.username}""
      end
    end
  end

  describe '#change_issuable_reviewers' do
    subject { service.change_issuable_reviewers([reviewer]) }

    let_it_be(:noteable) { create(:merge_request, :simple, source_project: project) }
    let_it_be(:reviewer) { create(:user) }
    let_it_be(:reviewer1) { create(:user) }
    let_it_be(:reviewer2) { create(:user) }
    let_it_be(:reviewer3) { create(:user) }

    it_behaves_like 'a system note' do
      let(:action) { 'reviewer' }
    end

    def build_note(old_reviewers, new_reviewers)
      noteable.reviewers = new_reviewers
      service.change_issuable_reviewers(old_reviewers).note
    end

    it 'builds a correct phrase when a reviewer is added to a non-assigned merge request' do
      expect(build_note([], [reviewer1])).to eq ""requested review from @#{reviewer1.username}""
    end

    it 'builds a correct phrase when reviewer is removed' do
      expect(build_note([reviewer], [])).to eq ""removed review request for @#{reviewer.username}""
    end

    it 'builds a correct phrase when reviewers changed' do
      expect(build_note([reviewer1], [reviewer2])).to(
        eq(""requested review from @#{reviewer2.username} and removed review request for @#{reviewer1.username}"")
      )
    end

    it 'builds a correct phrase when three reviewers removed and one added' do
      expect(build_note([reviewer, reviewer1, reviewer2], [reviewer3])).to(
        eq(""requested review from @#{reviewer3.username} and removed review request for @#{reviewer.username}, @#{reviewer1.username}, and @#{reviewer2.username}"")
      )
    end

    it 'builds a correct phrase when one reviewer is changed from a set' do
      expect(build_note([reviewer, reviewer1], [reviewer, reviewer2])).to(
        eq(""requested review from @#{reviewer2.username} and removed review request for @#{reviewer1.username}"")
      )
    end

    it 'builds a correct phrase when one reviewer removed from a set' do
      expect(build_note([reviewer, reviewer1, reviewer2], [reviewer, reviewer1])).to(
        eq(""removed review request for @#{reviewer2.username}"")
      )
    end

    it 'builds a correct phrase when the locale is different' do
      Gitlab::I18n.with_locale('pt-BR') do
        expect(build_note([reviewer, reviewer1, reviewer2], [reviewer3])).to(
          eq(""requested review from @#{reviewer3.username} and removed review request for @#{reviewer.username}, @#{reviewer1.username}, and @#{reviewer2.username}"")
        )
      end
    end
  end

  describe '#change_issuable_contacts' do
    subject { service.change_issuable_contacts(1, 1) }

    let_it_be(:noteable) { create(:issue, project: project) }

    it_behaves_like 'a system note' do
      let(:action) { 'contact' }
    end

    def build_note(added_count, removed_count)
      service.change_issuable_contacts(added_count, removed_count).note
    end

    it 'builds a correct phrase when one contact is added' do
      expect(build_note(1, 0)).to eq ""added 1 contact""
    end

    it 'builds a correct phrase when one contact is removed' do
      expect(build_note(0, 1)).to eq ""removed 1 contact""
    end

    it 'builds a correct phrase when one contact is added and one contact is removed' do
      expect(build_note(1, 1)).to(
        eq(""added 1 contact and removed 1 contact"")
      )
    end

    it 'builds a correct phrase when three contacts are added and one removed' do
      expect(build_note(3, 1)).to(
        eq(""added 3 contacts and removed 1 contact"")
      )
    end

    it 'builds a correct phrase when three contacts are removed and one added' do
      expect(build_note(1, 3)).to(
        eq(""added 1 contact and removed 3 contacts"")
      )
    end

    it 'builds a correct phrase when the locale is different' do
      Gitlab::I18n.with_locale('pt-BR') do
        expect(build_note(1, 3)).to(
          eq(""added 1 contact and removed 3 contacts"")
        )
      end
    end
  end

  describe '#change_status' do
    subject { service.change_status(status, source) }

    let(:status) { 'reopened' }
    let(:source) { nil }

    it 'creates a resource state event' do
      expect { subject }.to change { ResourceStateEvent.count }.by(1)
    end
  end

  describe '#change_title' do
    let(:noteable) { create(:issue, project: project, title: 'Lorem ipsum') }

    subject { service.change_title('Old title') }

    context 'when noteable responds to `title`' do
      it_behaves_like 'a system note' do
        let(:action) { 'title' }
      end

      it_behaves_like 'a note with overridable created_at'

      it 'sets the note text' do
        expect(subject.note)
          .to eq ""changed title from **{-Old title-}** to **{+Lorem ipsum+}**""
      end
    end
  end

  describe '#change_description' do
    subject { service.change_description }

    context 'when noteable responds to `description`' do
      it_behaves_like 'a system note' do
        let(:action) { 'description' }
      end

      it_behaves_like 'a note with overridable created_at'

      it 'sets the note text' do
        expect(subject.note).to eq('changed the description')
      end

      it 'associates the related description version' do
        noteable.update!(description: 'New description')

        description_version_id = subject.system_note_metadata.description_version_id

        expect(description_version_id).not_to be_nil
        expect(description_version_id).to eq(noteable.saved_description_version.id)
      end
    end
  end

  describe '#change_issue_confidentiality' do
    subject { service.change_issue_confidentiality }

    context 'issue has been made confidential' do
      before do
        noteable.update_attribute(:confidential, true)
      end

      it_behaves_like 'a system note' do
        let(:action) { 'confidential' }
      end

      it 'sets the note text' do
        expect(subject.note).to eq 'made the issue confidential'
      end
    end

    context 'issue has been made visible' do
      it_behaves_like 'a system note' do
        let(:action) { 'visible' }
      end

      it 'sets the note text' do
        expect(subject.note).to eq 'made the issue visible to everyone'
      end
    end
  end

  describe '#cross_reference' do
    let(:service) { described_class.new(noteable: noteable, author: author) }

    let(:mentioned_in) { create(:issue, project: project) }

    subject { service.cross_reference(mentioned_in) }

    it_behaves_like 'a system note' do
      let(:action) { 'cross_reference' }
    end

    context 'when cross-reference disallowed' do
      before do
        expect_next_instance_of(described_class) do |instance|
          expect(instance).to receive(:cross_reference_disallowed?).and_return(true)
        end
      end

      it 'returns nil' do
        expect(subject).to be_nil
      end

      it 'does not create a system note metadata record' do
        expect { subject }.not_to change { SystemNoteMetadata.count }
      end
    end

    context 'when cross-reference allowed' do
      before do
        expect_next_instance_of(described_class) do |instance|
          expect(instance).to receive(:cross_reference_disallowed?).and_return(false)
        end
      end

      it_behaves_like 'a system note' do
        let(:action) { 'cross_reference' }
      end

      it_behaves_like 'a note with overridable created_at'

      describe 'note_body' do
        context 'cross-project' do
          let(:project2) { create(:project, :repository) }
          let(:mentioned_in) { create(:issue, project: project2) }

          context 'from Commit' do
            let(:mentioned_in) { project2.repository.commit }

            it 'references the mentioning commit' do
              expect(subject.note).to eq ""mentioned in commit #{mentioned_in.to_reference(project)}""
            end
          end

          context 'from non-Commit' do
            it 'references the mentioning object' do
              expect(subject.note).to eq ""mentioned in issue #{mentioned_in.to_reference(project)}""
            end
          end
        end

        context 'within the same project' do
          context 'from Commit' do
            let(:mentioned_in) { project.repository.commit }

            it 'references the mentioning commit' do
              expect(subject.note).to eq ""mentioned in commit #{mentioned_in.to_reference}""
            end
          end

          context 'from non-Commit' do
            it 'references the mentioning object' do
              expect(subject.note).to eq ""mentioned in issue #{mentioned_in.to_reference}""
            end
          end
        end
      end

      context 'with external issue' do
        let(:noteable) { ExternalIssue.new('JIRA-123', project) }
        let(:mentioned_in) { project.commit }

        it 'queues a background worker' do
          expect(Integrations::CreateExternalCrossReferenceWorker).to receive(:perform_async).with(
            project.id,
            'JIRA-123',
            'Commit',
            mentioned_in.id,
            author.id
          )

          subject
        end
      end
    end
  end

  describe '#cross_reference_exists?' do
    let(:commit0) { project.commit }
    let(:commit1) { project.commit('HEAD~2') }

    context 'issue from commit' do
      before do
        # Mention issue (noteable) from commit0
        service.cross_reference(commit0)
      end

      it 'is truthy when already mentioned' do
        expect(service.cross_reference_exists?(commit0))
          .to be_truthy
      end

      it 'is falsey when not already mentioned' do
        expect(service.cross_reference_exists?(commit1))
          .to be_falsey
      end

      context 'legacy capitalized cross reference' do
        before do
          # Mention issue (noteable) from commit0
          system_note = service.cross_reference(commit0)
          system_note.update!(note: system_note.note.capitalize)
        end

        it 'is truthy when already mentioned' do
          expect(service.cross_reference_exists?(commit0))
            .to be_truthy
        end
      end
    end

    context 'commit from commit' do
      let(:service) { described_class.new(noteable: commit0, author: author) }

      before do
        # Mention commit1 from commit0
        service.cross_reference(commit1)
      end

      it 'is truthy when already mentioned' do
        expect(service.cross_reference_exists?(commit1))
          .to be_truthy
      end

      it 'is falsey when not already mentioned' do
        service = described_class.new(noteable: commit1, author: author)

        expect(service.cross_reference_exists?(commit0))
          .to be_falsey
      end

      context 'legacy capitalized cross reference' do
        before do
          # Mention commit1 from commit0
          system_note = service.cross_reference(commit1)
          system_note.update!(note: system_note.note.capitalize)
        end

        it 'is truthy when already mentioned' do
          expect(service.cross_reference_exists?(commit1))
            .to be_truthy
        end
      end
    end

    context 'commit with cross-reference from fork', :sidekiq_might_not_need_inline do
      let(:author2) { create(:project_member, :reporter, user: create(:user), project: project).user }
      let(:forked_project) { fork_project(project, author2, repository: true) }
      let(:commit2) { forked_project.commit }

      let(:service) { described_class.new(noteable: noteable, author: author2) }

      before do
        service.cross_reference(commit0)
      end

      it 'is true when a fork mentions an external issue' do
        expect(service.cross_reference_exists?(commit2))
            .to be true
      end

      context 'legacy capitalized cross reference' do
        before do
          system_note = service.cross_reference(commit0)
          system_note.update!(note: system_note.note.capitalize)
        end

        it 'is true when a fork mentions an external issue' do
          expect(service.cross_reference_exists?(commit2))
              .to be true
        end
      end
    end
  end

  describe '#change_task_status' do
    let(:noteable) { create(:issue, project: project) }
    let(:task)     { double(:task, complete?: true, source: 'task') }

    subject { service.change_task_status(task) }

    it_behaves_like 'a system note' do
      let(:action) { 'task' }
    end

    it ""posts the 'marked the checklist item as complete' system note"" do
      expect(subject.note).to eq(""marked the checklist item **task** as completed"")
    end
  end

  describe '#noteable_moved' do
    let(:new_project) { create(:project) }
    let(:new_noteable) { create(:issue, project: new_project) }

    subject do
      # service = described_class.new(noteable: noteable, project: project, author: author)
      service.noteable_moved(new_noteable, direction)
    end

    shared_examples 'cross project mentionable' do
      include MarkupHelper

      it 'contains cross reference to new noteable' do
        expect(subject.note).to include cross_project_reference(new_project, new_noteable)
      end

      it 'mentions referenced noteable' do
        expect(subject.note).to include new_noteable.to_reference
      end

      it 'mentions referenced project' do
        expect(subject.note).to include new_project.full_path
      end
    end

    context 'moved to' do
      let(:direction) { :to }

      it_behaves_like 'cross project mentionable'
      it_behaves_like 'a system note' do
        let(:action) { 'moved' }
      end

      it 'notifies about noteable being moved to' do
        expect(subject.note).to match('moved to')
      end
    end

    context 'moved from' do
      let(:direction) { :from }

      it_behaves_like 'cross project mentionable'
      it_behaves_like 'a system note' do
        let(:action) { 'moved' }
      end

      it 'notifies about noteable being moved from' do
        expect(subject.note).to match('moved from')
      end
    end

    context 'invalid direction' do
      let(:direction) { :invalid }

      it 'raises error' do
        expect { subject }.to raise_error StandardError, /Invalid direction/
      end
    end
  end

  describe '#noteable_cloned' do
    let_it_be(:new_project) { create(:project) }
    let_it_be(:new_noteable) { create(:issue, project: new_project) }

    subject do
      service.noteable_cloned(new_noteable, direction)
    end

    shared_examples 'cross project mentionable' do
      include MarkupHelper

      it 'contains cross reference to new noteable' do
        expect(subject.note).to include cross_project_reference(new_project, new_noteable)
      end

      it 'mentions referenced noteable' do
        expect(subject.note).to include new_noteable.to_reference
      end

      it 'mentions referenced project' do
        expect(subject.note).to include new_project.full_path
      end
    end

    context 'cloned to' do
      let(:direction) { :to }

      it_behaves_like 'cross project mentionable'

      it_behaves_like 'a system note' do
        let(:action) { 'cloned' }
      end

      it 'notifies about noteable being cloned to' do
        expect(subject.note).to match('cloned to')
      end
    end

    context 'cloned from' do
      let(:direction) { :from }

      it_behaves_like 'cross project mentionable'

      it_behaves_like 'a system note' do
        let(:action) { 'cloned' }
      end

      it 'notifies about noteable being cloned from' do
        expect(subject.note).to match('cloned from')
      end
    end

    context 'invalid direction' do
      let(:direction) { :invalid }

      it 'raises error' do
        expect { subject }.to raise_error StandardError, /Invalid direction/
      end
    end

    context 'custom created timestamp' do
      let(:direction) { :from }

      it 'allows setting of custom created_at value' do
        timestamp = 1.day.ago

        note = service.noteable_cloned(new_noteable, direction, created_at: timestamp)

        expect(note.created_at).to be_like_time(timestamp)
      end

      it 'defaults to current time when created_at is not given', :freeze_time do
        expect(subject.created_at).to be_like_time(Time.current)
      end
    end

    context 'metrics' do
      context 'cloned from' do
        let(:direction) { :from }

        it 'does not tracks usage' do
          expect(Gitlab::UsageDataCounters::IssueActivityUniqueCounter)
            .not_to receive(:track_issue_cloned_action).with(author: author)

          subject
        end
      end

      context 'cloned to', :snowplow do
        let(:direction) { :to }

        it 'tracks usage' do
          expect(Gitlab::UsageDataCounters::IssueActivityUniqueCounter)
            .to receive(:track_issue_cloned_action).with(author: author, project: project)

          subject
        end

        it_behaves_like 'internal event tracking' do
          let(:event) { Gitlab::UsageDataCounters::IssueActivityUniqueCounter::ISSUE_CLONED }
          let(:user) { author }
          let(:namespace) { project.namespace }
        end
      end
    end
  end

  describe '#mark_duplicate_issue' do
    subject { service.mark_duplicate_issue(canonical_issue) }

    context 'within the same project' do
      let(:canonical_issue) { create(:issue, project: project) }

      it_behaves_like 'a system note' do
        let(:action) { 'duplicate' }
      end

      it { expect(subject.note).to eq ""marked this issue as a duplicate of #{canonical_issue.to_reference}"" }
    end

    context 'across different projects' do
      let(:other_project) { create(:project) }
      let(:canonical_issue) { create(:issue, project: other_project) }

      it_behaves_like 'a system note' do
        let(:action) { 'duplicate' }
      end

      it { expect(subject.note).to eq ""marked this issue as a duplicate of #{canonical_issue.to_reference(project)}"" }
    end
  end

  describe '#mark_canonical_issue_of_duplicate' do
    subject { service.mark_canonical_issue_of_duplicate(duplicate_issue) }

    context 'within the same project' do
      let(:duplicate_issue) { create(:issue, project: project) }

      it_behaves_like 'a system note' do
        let(:action) { 'duplicate' }
      end

      it { expect(subject.note).to eq ""marked #{duplicate_issue.to_reference} as a duplicate of this issue"" }
    end

    context 'across different projects' do
      let(:other_project) { create(:project) }
      let(:duplicate_issue) { create(:issue, project: other_project) }

      it_behaves_like 'a system note' do
        let(:action) { 'duplicate' }
      end

      it { expect(subject.note).to eq ""marked #{duplicate_issue.to_reference(project)} as a duplicate of this issue"" }
    end
  end

  describe '#discussion_lock' do
    subject { service.discussion_lock }

    context 'discussion unlocked' do
      it_behaves_like 'a system note' do
        let(:action) { 'unlocked' }
      end

      it 'creates the note text correctly' do
        [:issue, :merge_request].each do |type|
          issuable = create(type) # rubocop:disable Rails/SaveBang

          service = described_class.new(noteable: issuable, author: author)
          expect(service.discussion_lock.note)
            .to eq(""unlocked the discussion in this #{type.to_s.titleize.downcase}"")
        end
      end
    end

    context 'discussion locked' do
      before do
        noteable.update_attribute(:discussion_locked, true)
      end

      it_behaves_like 'a system note' do
        let(:action) { 'locked' }
      end

      it 'creates the note text correctly' do
        [:issue, :merge_request].each do |type|
          issuable = create(type, discussion_locked: true)

          service = described_class.new(noteable: issuable, author: author)
          expect(service.discussion_lock.note)
            .to eq(""locked the discussion in this #{type.to_s.titleize.downcase}"")
        end
      end
    end
  end

  describe '#cross_reference_disallowed?' do
    context 'when mentioned_in is not a MergeRequest' do
      it 'is falsey' do
        mentioned_in = noteable.dup

        expect(service.cross_reference_disallowed?(mentioned_in)).to be_falsey
      end
    end

    context 'when mentioned_in is a MergeRequest' do
      let(:mentioned_in) { create(:merge_request, :simple, source_project: project) }
      let(:noteable) { project.commit }

      it 'is truthy when noteable is in commits' do
        expect(mentioned_in).to receive(:commits).and_return([noteable])

        expect(service.cross_reference_disallowed?(mentioned_in)).to be_truthy
      end

      it 'is falsey when noteable is not in commits' do
        expect(mentioned_in).to receive(:commits).and_return([])

        expect(service.cross_reference_disallowed?(mentioned_in)).to be_falsey
      end
    end

    context 'when notable is an ExternalIssue' do
      let(:project) { create(:project) }
      let(:noteable) { ExternalIssue.new('EXT-1234', project) }

      it 'is false with issue tracker supporting referencing' do
        create(:jira_integration, project: project)
        project.reload

        expect(service.cross_reference_disallowed?(noteable)).to be_falsey
      end

      it 'is true with issue tracker not supporting referencing' do
        create(:bugzilla_integration, project: project)
        project.reload

        expect(service.cross_reference_disallowed?(noteable)).to be_truthy
      end

      it 'is true without issue tracker' do
        expect(service.cross_reference_disallowed?(noteable)).to be_truthy
      end
    end
  end

  describe '#close_after_error_tracking_resolve' do
    subject { service.close_after_error_tracking_resolve }

    it 'creates the expected state event' do
      subject

      event = ResourceStateEvent.last

      expect(event.close_after_error_tracking_resolve).to eq(true)
      expect(event.state).to eq('closed')
    end
  end

  describe '#auto_resolve_prometheus_alert' do
    subject { service.auto_resolve_prometheus_alert }

    it 'creates the expected state event' do
      subject

      event = ResourceStateEvent.last

      expect(event.close_auto_resolve_prometheus_alert).to eq(true)
      expect(event.state).to eq('closed')
    end
  end

  describe '#change_issue_type' do
    context 'with issue' do
      let_it_be_with_reload(:noteable) { create(:issue, project: project) }

      subject { service.change_issue_type('incident') }

      it_behaves_like 'a system note' do
        let(:action) { 'issue_type' }
      end

      it { expect(subject.note).to eq ""changed type from incident to issue"" }
    end

    context 'with work item' do
      let_it_be_with_reload(:noteable) { create(:work_item, project: project) }

      subject { service.change_issue_type('task') }

      it_behaves_like 'a system note' do
        let(:action) { 'issue_type' }
      end

      it { expect(subject.note).to eq ""changed type from task to issue"" }
    end
  end

  describe '#hierarchy_changed' do
    let_it_be_with_reload(:work_item) { create(:work_item, project: project) }
    let_it_be_with_reload(:task) { create(:work_item, :task, project: project) }

    let(:service) { described_class.new(noteable: work_item, project: project, author: author) }

    subject { service.hierarchy_changed(task, hierarchy_change_action) }

    context 'when task is added as a child' do
      let(:hierarchy_change_action) { 'relate' }

      it_behaves_like 'a system note' do
        let(:expected_noteable) { task }
        let(:action) { 'relate_to_parent' }
      end

      it 'sets the correct note text' do
        expect { subject }.to change { Note.system.count }.by(2)
        expect(work_item.notes.last.note).to eq(""added ##{task.iid} as child task"")
        expect(task.notes.last.note).to eq(""added ##{work_item.iid} as parent issue"")
      end
    end

    context 'when child task is removed' do
      let(:hierarchy_change_action) { 'unrelate' }

      it_behaves_like 'a system note' do
        let(:expected_noteable) { task }
        let(:action) { 'unrelate_from_parent' }
      end

      it 'sets the correct note text' do
        expect { subject }.to change { Note.system.count }.by(2)
        expect(work_item.notes.last.note).to eq(""removed child task ##{task.iid}"")
        expect(task.notes.last.note).to eq(""removed parent issue ##{work_item.iid}"")
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module SystemNotes
  class DesignManagementService < ::SystemNotes::BaseService
    include ActionView::RecordIdentifier

    # Parameters:
    #   - version [DesignManagement::Version]
    #
    # Example Note text:
    #
    #   ""added [1 designs](link-to-version)""
    #   ""changed [2 designs](link-to-version)""
    #
    # Returns [Array<Note>]: the created Note objects
    def design_version_added(version)
      events = DesignManagement::Action.events
      link_href = designs_path(version: version.id)

      version.designs_by_event.map do |(event_name, designs)|
        note_data = self.class.design_event_note_data(events[event_name])
        icon_name = note_data[:icon]
        n = designs.size

        body = ""%s [%d %s](%s)"" % [note_data[:past_tense], n, 'design'.pluralize(n), link_href]

        create_note(NoteSummary.new(noteable, project, author, body, action: icon_name))
      end
    end

    # Called when a new discussion is created on a design
    #
    # discussion_note - DiscussionNote
    #
    # Example Note text:
    #
    #   ""started a discussion on screen.png""
    #
    # Returns the created Note object
    def design_discussion_added(discussion_note)
      design = discussion_note.noteable

      body = _('started a discussion on %{design_link}') % {
        design_link: '[%s](%s)' % [
          design.filename,
          designs_path(vueroute: design.filename, anchor: dom_id(discussion_note))
        ]
      }

      action = :designs_discussion_added

      create_note(NoteSummary.new(noteable, project, author, body, action: action))
    end

    # Take one of the `DesignManagement::Action.events` and
    # return:
    #   * an English past-tense verb.
    #   * the name of an icon used in renderin a system note
    #
    # We do not currently internationalize our system notes,
    # instead we just produce English-language descriptions.
    # See: https://gitlab.com/gitlab-org/gitlab/issues/30408
    # See: https://gitlab.com/gitlab-org/gitlab/issues/14056
    def self.design_event_note_data(event)
      case event
      when DesignManagement::Action.events[:creation]
        { icon: 'designs_added', past_tense: 'added' }
      when DesignManagement::Action.events[:modification]
        { icon: 'designs_modified', past_tense: 'updated' }
      when DesignManagement::Action.events[:deletion]
        { icon: 'designs_removed', past_tense: 'removed' }
      else
        raise ""Unknown event: #{event}""
      end
    end

    private

    def designs_path(params = {})
      url_helpers.designs_project_issue_path(project, noteable, params)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe SystemNotes::DesignManagementService, feature_category: :design_management do
  let(:project) { create(:project) }
  let(:issue) { create(:issue, project: project) }

  let(:instance) { described_class.new(noteable: instance_noteable, project: instance_project, author: instance_author) }

  describe '#design_version_added' do
    let(:instance_noteable) { version.issue }
    let(:instance_project) { version.issue.project }
    let(:instance_author) { version.author }

    subject { instance.design_version_added(version) }

    # default (valid) parameters:
    let(:n_designs) { 3 }
    let(:designs) { create_list(:design, n_designs, issue: issue) }
    let(:user) { build(:user) }
    let(:version) do
      create(:design_version, issue: issue, designs: designs)
    end

    before do
      # Avoid needing to call into gitaly
      allow(version).to receive(:author).and_return(user)
    end

    context 'with one kind of event' do
      before do
        DesignManagement::Action
          .where(design: designs).update_all(event: :modification)
      end

      it 'makes just one note' do
        expect(subject).to contain_exactly(Note)
      end

      it 'adds a new system note' do
        expect { subject }.to change { Note.system.count }.by(1)
      end
    end

    context 'with a mixture of events' do
      let(:n_designs) { DesignManagement::Action.events.size }

      before do
        designs.each_with_index do |design, i|
          design.actions.update_all(event: i)
        end
      end

      it 'makes one note for each kind of event' do
        expect(subject).to have_attributes(size: n_designs)
      end

      it 'adds a system note for each kind of event' do
        expect { subject }.to change { Note.system.count }.by(n_designs)
      end
    end

    describe 'icons' do
      where(:action) do
        [
          [:creation],
          [:modification],
          [:deletion]
        ]
      end

      with_them do
        before do
          version.actions.update_all(event: action)
        end

        subject(:metadata) do
          instance.design_version_added(version)
            .first.system_note_metadata
        end

        it 'has a valid action' do
          expect(::SystemNoteHelper::ICON_NAMES_BY_ACTION)
            .to include(metadata.action)
        end
      end
    end

    context 'it succeeds' do
      where(:action, :icon, :human_description) do
        [
          [:creation,     'designs_added',    'added'],
          [:modification, 'designs_modified', 'updated'],
          [:deletion,     'designs_removed',  'removed']
        ]
      end

      with_them do
        before do
          version.actions.update_all(event: action)
        end

        let(:anchor_tag) { %r{ <a[^>]*>#{link}</a>} }
        let(:href) { instance.send(:designs_path, { version: version.id }) }
        let(:link) { ""#{n_designs} designs"" }

        subject(:note) { instance.design_version_added(version).first }

        it 'has the correct data' do
          expect(note)
            .to be_system
            .and have_attributes(
              system_note_metadata: have_attributes(action: icon),
              note: include(human_description)
                      .and(include link)
                      .and(include href),
              note_html: a_string_matching(anchor_tag)
            )
        end
      end
    end
  end

  describe '#design_discussion_added' do
    let(:instance_noteable) { design.issue }
    let(:instance_project) { design.issue.project }
    let(:instance_author) { discussion_note.author }

    subject { instance.design_discussion_added(discussion_note) }

    let(:design) { create(:design, :with_file, issue: issue) }
    let(:author) { create(:user) }
    let(:discussion_note) do
      create(:diff_note_on_design, noteable: design, author: author)
    end

    let(:action) { 'designs_discussion_added' }

    it_behaves_like 'a system note' do
      let(:noteable) { discussion_note.noteable.issue }
    end

    it 'adds a new system note' do
      expect { subject }.to change { Note.system.count }.by(1)
    end

    it 'has the correct note text' do
      href = instance.send(:designs_path,
        { vueroute: design.filename, anchor: ActionView::RecordIdentifier.dom_id(discussion_note) }
      )

      expect(subject.note).to eq(""started a discussion on [#{design.filename}](#{href})"")
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module SystemNotes
  class IncidentsService < ::SystemNotes::BaseService
    CHANGED_TEXT = {
      occurred_at: 'the event time/date on ',
      note: 'the text on ',
      occurred_at_and_note: 'the event time/date and text on '
    }.freeze

    def initialize(noteable:)
      @noteable = noteable
      @project = noteable.project
    end

    def add_timeline_event(timeline_event)
      author = timeline_event.author
      body = 'added an incident timeline event'

      create_note(NoteSummary.new(noteable, project, author, body, action: 'timeline_event'))
    end

    def edit_timeline_event(timeline_event, author, was_changed:)
      changed_text = CHANGED_TEXT.fetch(was_changed, '')
      body = ""edited #{changed_text}incident timeline event""

      create_note(NoteSummary.new(noteable, project, author, body, action: 'timeline_event'))
    end

    def delete_timeline_event(author)
      body = 'deleted an incident timeline event'

      create_note(NoteSummary.new(noteable, project, author, body, action: 'timeline_event'))
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe SystemNotes::IncidentsService, feature_category: :incident_management do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }
  let_it_be(:author) { create(:user) }
  let_it_be(:incident) { create(:incident, project: project, author: user) }
  let_it_be(:timeline_event) do
    create(:incident_management_timeline_event, project: project, incident: incident, author: author)
  end

  describe '#add_timeline_event' do
    subject { described_class.new(noteable: incident).add_timeline_event(timeline_event) }

    it_behaves_like 'a system note' do
      let(:noteable) { incident }
      let(:action) { 'timeline_event' }
    end

    it 'posts the correct text to the system note' do
      expect(subject.note).to match(""added an incident timeline event"")
    end
  end

  describe '#edit_timeline_event' do
    let(:was_changed) { :unknown }

    subject do
      described_class.new(noteable: incident).edit_timeline_event(timeline_event, author, was_changed: was_changed)
    end

    it_behaves_like 'a system note' do
      let(:noteable) { incident }
      let(:action) { 'timeline_event' }
    end

    context ""when only timeline event's occurred_at was changed"" do
      let(:was_changed) { :occurred_at }

      it 'posts the correct text to the system note' do
        expect(subject.note).to match(""edited the event time/date on incident timeline event"")
      end
    end

    context ""when only timeline event's note was changed"" do
      let(:was_changed) { :note }

      it 'posts the correct text to the system note' do
        expect(subject.note).to match(""edited the text on incident timeline event"")
      end
    end

    context ""when both timeline events occurred_at and note was changed"" do
      let(:was_changed) { :occurred_at_and_note }

      it 'posts the correct text to the system note' do
        expect(subject.note).to match(""edited the event time/date and text on incident timeline event"")
      end
    end

    context ""when was changed reason is unknown"" do
      let(:was_changed) { :unknown }

      it 'posts the correct text to the system note' do
        expect(subject.note).to match(""edited incident timeline event"")
      end
    end
  end

  describe '#delete_timeline_event' do
    subject { described_class.new(noteable: incident).delete_timeline_event(author) }

    it_behaves_like 'a system note' do
      let(:noteable) { incident }
      let(:action) { 'timeline_event' }
    end

    it 'posts the correct text to the system note' do
      expect(subject.note).to match('deleted an incident timeline event')
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module SystemNotes
  class CommitService < ::SystemNotes::BaseService
    NEW_COMMIT_DISPLAY_LIMIT = 10

    # Called when commits are added to a merge request
    #
    # new_commits      - Array of Commits added since last push
    # existing_commits - Array of Commits added in a previous push
    # oldrev           - Optional String SHA of a previous Commit
    #
    # See new_commit_summary and existing_commit_summary.
    #
    # Returns the created Note object
    def add_commits(new_commits, existing_commits = [], oldrev = nil)
      total_count  = new_commits.length + existing_commits.length
      commits_text = ""#{total_count} commit"".pluralize(total_count)

      text_parts = [""added #{commits_text}""]
      text_parts << commits_list(noteable, new_commits, existing_commits, oldrev)
      text_parts << ""[Compare with previous version](#{diff_comparison_path(noteable, project, oldrev)})""

      body = text_parts.join(""\n\n"")

      create_note(NoteSummary.new(noteable, project, author, body, action: 'commit', commit_count: total_count))
    end

    # Called when a commit was tagged
    #
    # tag_name  - The created tag name
    #
    # Returns the created Note object
    def tag_commit(tag_name)
      link = url_helpers.project_tag_path(project, id: tag_name)
      body = ""tagged commit #{noteable.sha} to [`#{tag_name}`](#{link})""

      create_note(NoteSummary.new(noteable, project, author, body, action: 'tag'))
    end

    private

    # Build an Array of lines detailing each commit added in a merge request
    #
    # new_commits - Array of new Commit objects
    #
    # Returns an Array of Strings
    def new_commits_list(new_commits)
      new_commits.collect do |commit|
        content_tag('li', ""#{commit.short_id} - #{commit.title}"")
      end
    end

    # Builds an Array of lines describing each commit and truncate them based on the limit
    # to avoid creating a note with a large number of commits.
    #
    # commits - Array of Commit objects
    #
    # Returns an Array of Strings
    #
    # rubocop: disable CodeReuse/ActiveRecord
    def new_commit_summary(commits, start_rev)
      if commits.size > NEW_COMMIT_DISPLAY_LIMIT
        no_of_commits_to_truncate = commits.size - NEW_COMMIT_DISPLAY_LIMIT
        commits_to_truncate = commits.take(no_of_commits_to_truncate)
        remaining_commits = commits.drop(no_of_commits_to_truncate)

        [truncated_new_commits(commits_to_truncate, start_rev)] + new_commits_list(remaining_commits)
      else
        new_commits_list(commits)
      end
    end
    # rubocop: enable CodeReuse/ActiveRecord

    # Builds a summary line that describes given truncated commits.
    #
    # commits - Array of Commit objects
    # start_rev - String SHA of a Commit that will be used as the starting SHA of the range
    #
    # Returns a String wrapped in 'li' tag.
    def truncated_new_commits(commits, start_rev)
      count = commits.size

      commit_ids = if count == 1
                     commits.first.short_id
                   elsif start_rev && !Gitlab::Git.blank_ref?(start_rev)
                     ""#{Commit.truncate_sha(start_rev)}...#{commits.last.short_id}""
                   else
                     # This two-dots notation seems to be not functioning as expected, but we should
                     # fallback to it as start_rev can be empty.
                     #
                     # For more information, please see https://gitlab.com/gitlab-org/gitlab/-/issues/391809
                     ""#{commits.first.short_id}..#{commits.last.short_id}""
                   end

      commits_text = ""#{count} earlier commit"".pluralize(count)

      content_tag('li', ""#{commit_ids} - #{commits_text}"")
    end

    # Builds a list of existing and new commits according to existing_commits and
    # new_commits methods.
    # Returns a String wrapped in `ul` and `li` tags.
    def commits_list(noteable, new_commits, existing_commits, oldrev)
      existing_commit_summary = existing_commit_summary(noteable, existing_commits, oldrev)
      start_rev = existing_commits.empty? ? oldrev : existing_commits.last.id
      new_commit_summary = new_commit_summary(new_commits, start_rev).join

      content_tag('ul', ""#{existing_commit_summary}#{new_commit_summary}"".html_safe)
    end

    # Build a single line summarizing existing commits being added in a merge
    # request
    #
    # existing_commits - Array of existing Commit objects
    # oldrev           - Optional String SHA of a previous Commit
    #
    # Examples:
    #
    #   ""* ea0f8418...2f4426b7 - 24 commits from branch `master`""
    #
    #   ""* ea0f8418..4188f0ea - 15 commits from branch `fork:master`""
    #
    #   ""* ea0f8418 - 1 commit from branch `feature`""
    #
    # Returns a newline-terminated String
    def existing_commit_summary(noteable, existing_commits, oldrev = nil)
      return '' if existing_commits.empty?

      count = existing_commits.size

      commit_ids = if count == 1
                     existing_commits.first.short_id
                   elsif oldrev && !Gitlab::Git.blank_ref?(oldrev)
                     ""#{Commit.truncate_sha(oldrev)}...#{existing_commits.last.short_id}""
                   else
                     ""#{existing_commits.first.short_id}..#{existing_commits.last.short_id}""
                   end

      commits_text = ""#{count} commit"".pluralize(count)

      branch = noteable.target_branch
      branch = ""#{noteable.target_project_namespace}:#{branch}"" if noteable.for_fork?

      branch_name = content_tag('code', branch)
      content_tag('li', ""#{commit_ids} - #{commits_text} from branch #{branch_name}"".html_safe)
    end

    def diff_comparison_path(merge_request, project, oldrev)
      diff_id = merge_request.merge_request_diff.id

      url_helpers.diffs_project_merge_request_path(
        project,
        merge_request,
        diff_id: diff_id,
        start_sha: oldrev
      )
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe SystemNotes::CommitService, feature_category: :code_review_workflow do
  let_it_be(:group)    { create(:group) }
  let_it_be(:project)  { create(:project, :repository, group: group) }
  let_it_be(:author)   { create(:user) }

  let(:commit_service) { described_class.new(noteable: noteable, project: project, author: author) }

  describe '#add_commits' do
    subject { commit_service.add_commits(new_commits, old_commits, oldrev) }

    let(:noteable)    { create(:merge_request, source_project: project, target_project: project) }
    let(:new_commits) { create_commits(10) }
    let(:old_commits) { [] }
    let(:oldrev)      { nil }

    it_behaves_like 'a system note' do
      let(:commit_count) { new_commits.size }
      let(:action)       { 'commit' }
    end

    describe 'note body' do
      let(:note_lines) { subject.note.split(""\n"").reject(&:blank?) }

      describe 'comparison diff link line' do
        it 'adds the comparison text' do
          expect(note_lines[2]).to match ""[Compare with previous version]""
        end
      end

      context 'without existing commits' do
        it 'adds a message header' do
          expect(note_lines[0]).to eq ""added #{new_commits.size} commits""
        end

        it 'adds a message for each commit' do
          decoded_note_content = HTMLEntities.new.decode(subject.note)

          new_commits.each do |commit|
            expect(decoded_note_content).to include(""<li>#{commit.short_id} - #{commit.title}</li>"")
          end
        end

        context 'with HTML content' do
          let(:new_commits) { [double(title: '<pre>This is a test</pre>', short_id: '12345678')] }

          it 'escapes HTML titles' do
            expect(note_lines[1]).to eq(""<ul><li>12345678 - &lt;pre&gt;This is a test&lt;/pre&gt;</li></ul>"")
          end
        end

        context 'with one commit exceeding the NEW_COMMIT_DISPLAY_LIMIT' do
          let(:new_commits) { create_commits(11) }
          let(:earlier_commit_summary_line) { note_lines[1] }

          it 'includes the truncated new commits summary' do
            expect(earlier_commit_summary_line).to start_with(""<ul><li>#{new_commits[0].short_id} - 1 earlier commit"")
          end

          context 'with oldrev' do
            let(:oldrev) { '12345678abcd' }

            it 'includes the truncated new commits summary with the oldrev' do
              expect(earlier_commit_summary_line).to start_with(""<ul><li>#{new_commits[0].short_id} - 1 earlier commit"")
            end
          end
        end

        context 'with multiple commits exceeding the NEW_COMMIT_DISPLAY_LIMIT' do
          let(:new_commits) { create_commits(13) }
          let(:earlier_commit_summary_line) { note_lines[1] }

          it 'includes the truncated new commits summary' do
            expect(earlier_commit_summary_line).to start_with(""<ul><li>#{new_commits[0].short_id}..#{new_commits[2].short_id} - 3 earlier commits"")
          end

          context 'with oldrev' do
            let(:oldrev) { '12345678abcd' }

            it 'includes the truncated new commits summary with the oldrev' do
              expect(earlier_commit_summary_line).to start_with(""<ul><li>12345678...#{new_commits[2].short_id} - 3 earlier commits"")
            end
          end
        end
      end

      describe 'summary line for existing commits' do
        let(:summary_line) { note_lines[1] }

        context 'with one existing commit' do
          let(:old_commits) { [noteable.commits.last] }

          it 'includes the existing commit' do
            expect(summary_line).to start_with(""<ul><li>#{old_commits.first.short_id} - 1 commit from branch <code>feature</code>"")
          end

          context 'with new commits exceeding the display limit' do
            let(:summary_line) { note_lines[1] }
            let(:new_commits) { create_commits(13) }

            it 'includes the existing commit as well as the truncated new commit summary' do
              expect(summary_line).to start_with(""<ul><li>#{old_commits.first.short_id} - 1 commit from branch <code>feature</code></li><li>#{old_commits.last.short_id}...#{new_commits[2].short_id} - 3 earlier commits"")
            end
          end
        end

        context 'with multiple existing commits' do
          let(:old_commits) { noteable.commits[3..] }

          context 'with oldrev' do
            let(:oldrev) { noteable.commits[2].id }

            it 'includes a commit range and count' do
              expect(summary_line)
                .to start_with(""<ul><li>#{Commit.truncate_sha(oldrev)}...#{old_commits.last.short_id} - 26 commits from branch <code>feature</code>"")
            end

            context 'with new commits exceeding the display limit' do
              let(:new_commits) { create_commits(13) }

              it 'includes the existing commit as well as the truncated new commit summary' do
                expect(summary_line)
                  .to start_with(""<ul><li>#{Commit.truncate_sha(oldrev)}...#{old_commits.last.short_id} - 26 commits from branch <code>feature</code></li><li>#{old_commits.last.short_id}...#{new_commits[2].short_id} - 3 earlier commits"")
              end
            end
          end

          context 'without oldrev' do
            it 'includes a commit range and count' do
              expect(summary_line)
                .to start_with(""<ul><li>#{old_commits[0].short_id}..#{old_commits[-1].short_id} - 26 commits from branch <code>feature</code>"")
            end

            context 'with new commits exceeding the display limit' do
              let(:new_commits) { create_commits(13) }

              it 'includes the existing commit as well as the truncated new commit summary' do
                expect(summary_line)
                  .to start_with(""<ul><li>#{old_commits.first.short_id}..#{old_commits.last.short_id} - 26 commits from branch <code>feature</code></li><li>#{old_commits.last.short_id}...#{new_commits[2].short_id} - 3 earlier commits"")
              end
            end
          end

          context 'on a fork' do
            before do
              expect(noteable).to receive(:for_fork?).and_return(true)
            end

            it 'includes the project namespace' do
              expect(summary_line).to include(""<code>#{noteable.target_project_namespace}:feature</code>"")
            end
          end
        end
      end
    end
  end

  describe '#tag_commit' do
    let(:noteable) { project.commit }
    let(:tag_name) { 'v1.2.3' }

    subject { commit_service.tag_commit(tag_name) }

    it_behaves_like 'a system note' do
      let(:action) { 'tag' }
    end

    it 'sets the note text' do
      link = ""/#{project.full_path}/-/tags/#{tag_name}""

      expect(subject.note).to eq ""tagged commit #{noteable.sha} to [`#{tag_name}`](#{link})""
    end
  end

  def create_commits(count)
    Array.new(count) do |i|
      double(title: ""Test commit #{i}"", short_id: ""abcd00#{i}"")
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module SystemNotes
  class AlertManagementService < ::SystemNotes::BaseService
    # Called when the a new AlertManagement::Alert has been created
    #
    # alert - AlertManagement::Alert object.
    #
    # Example Note text:
    #
    #   ""GitLab Alert Bot logged an alert from Prometheus""
    #
    # Returns the created Note object
    def create_new_alert(monitoring_tool)
      body = ""logged an alert from **#{monitoring_tool}**""

      create_note(NoteSummary.new(noteable, project, Users::Internal.alert_bot, body, action: 'new_alert_added'))
    end

    # Called when the status of an AlertManagement::Alert has changed
    #
    # alert - AlertManagement::Alert object.
    #
    # Example Note text:
    #
    #   ""changed the status to Acknowledged""
    #   ""changed the status to Acknowledged by changing the incident status of #540""
    #
    # Returns the created Note object
    def change_alert_status(reason)
      status = noteable.state.to_s.titleize
      body = ""changed the status to **#{status}**#{reason}""

      create_note(NoteSummary.new(noteable, project, author, body, action: 'status'))
    end

    # Called when an issue is created based on an AlertManagement::Alert
    #
    # issue - Issue object.
    #
    # Example Note text:
    #
    #   ""created incident #17 for this alert""
    #
    # Returns the created Note object
    def new_alert_issue(issue)
      body = ""created incident #{issue.to_reference(project)} for this alert""

      create_note(NoteSummary.new(noteable, project, author, body, action: 'alert_issue_added'))
    end

    # Called when an alert is resolved due to received resolving alert payload
    #
    # alert - AlertManagement::Alert object.
    #
    # Example Note text:
    #
    #   ""changed the status to Resolved by closing issue #17""
    #
    # Returns the created Note object
    def log_resolving_alert(monitoring_tool)
      body = ""logged a recovery alert from **#{monitoring_tool}**""

      create_note(NoteSummary.new(noteable, project, Users::Internal.alert_bot, body, action: 'new_alert_added'))
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::SystemNotes::AlertManagementService, feature_category: :groups_and_projects do
  let_it_be(:author)   { create(:user) }
  let_it_be(:project)  { create(:project, :repository) }
  let_it_be(:noteable) { create(:alert_management_alert, :with_incident, :acknowledged, project: project) }

  describe '#create_new_alert' do
    subject { described_class.new(noteable: noteable, project: project).create_new_alert('Some Service') }

    it_behaves_like 'a system note' do
      let(:author) { Users::Internal.alert_bot }
      let(:action) { 'new_alert_added' }
    end

    it 'has the appropriate message' do
      expect(subject.note).to eq('logged an alert from **Some Service**')
    end
  end

  describe '#change_alert_status' do
    subject { described_class.new(noteable: noteable, project: project, author: author).change_alert_status(reason) }

    context 'with no specified reason' do
      let(:reason) { nil }

      it_behaves_like 'a system note' do
        let(:action) { 'status' }
      end

      it 'has the appropriate message' do
        expect(subject.note).to eq(""changed the status to **Acknowledged**"")
      end
    end

    context 'with reason provided' do
      let(:reason) { ' by changing incident status' }

      it 'has the appropriate message' do
        expect(subject.note).to eq(""changed the status to **Acknowledged** by changing incident status"")
      end
    end
  end

  describe '#new_alert_issue' do
    let_it_be(:issue) { noteable.issue }

    subject { described_class.new(noteable: noteable, project: project, author: author).new_alert_issue(issue) }

    it_behaves_like 'a system note' do
      let(:action) { 'alert_issue_added' }
    end

    it 'has the appropriate message' do
      expect(subject.note).to eq(""created incident #{issue.to_reference(project)} for this alert"")
    end
  end

  describe '#log_resolving_alert' do
    subject { described_class.new(noteable: noteable, project: project).log_resolving_alert('Some Service') }

    it_behaves_like 'a system note' do
      let(:author) { Users::Internal.alert_bot }
      let(:action) { 'new_alert_added' }
    end

    it 'has the appropriate message' do
      expect(subject.note).to eq('logged a recovery alert from **Some Service**')
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module SystemNotes
  class MergeRequestsService < ::SystemNotes::BaseService
    # Called when 'merge when pipeline succeeds' is executed
    def merge_when_pipeline_succeeds(sha)
      body = ""enabled an automatic merge when the pipeline for #{sha} succeeds""

      create_note(NoteSummary.new(noteable, project, author, body, action: 'merge'))
    end

    # Called when 'merge when pipeline succeeds' is canceled
    def cancel_merge_when_pipeline_succeeds
      body = 'canceled the automatic merge'

      create_note(NoteSummary.new(noteable, project, author, body, action: 'merge'))
    end

    # Called when 'merge when pipeline succeeds' is aborted
    def abort_merge_when_pipeline_succeeds(reason)
      body = ""aborted the automatic merge because #{reason}""

      ##
      # TODO: Abort message should be sent by the system, not a particular user.
      # See https://gitlab.com/gitlab-org/gitlab-foss/issues/63187.
      create_note(NoteSummary.new(noteable, project, author, body, action: 'merge'))
    end

    def handle_merge_request_draft
      action = noteable.draft? ? ""draft"" : ""ready""

      body = ""marked this merge request as **#{action}**""

      create_note(NoteSummary.new(noteable, project, author, body, action: 'title'))
    end

    def add_merge_request_draft_from_commit(commit)
      body = ""marked this merge request as **draft** from #{commit.to_reference(project)}""

      create_note(NoteSummary.new(noteable, project, author, body, action: 'title'))
    end

    def resolve_all_discussions
      body = ""resolved all threads""

      create_note(NoteSummary.new(noteable, project, author, body, action: 'discussion'))
    end

    def discussion_continued_in_issue(discussion, issue)
      body = ""created #{issue.to_reference} to continue this discussion""
      note_attributes = discussion.reply_attributes.merge(project: project, author: author, note: body)

      Note.create(note_attributes.merge(system: true, created_at: issue.system_note_timestamp)).tap do |note|
        note.system_note_metadata = SystemNoteMetadata.new(action: 'discussion')
      end
    end

    def diff_discussion_outdated(discussion, change_position)
      merge_request = discussion.noteable
      diff_refs = change_position.diff_refs
      version_index = merge_request.merge_request_diffs.viewable.count
      position_on_text = change_position.on_text?
      text_parts = [""changed this #{position_on_text ? 'line' : 'file'} in""]

      if version_params = merge_request.version_params_for(diff_refs)
        repository = project.repository
        anchor = position_on_text ? change_position.line_code(repository) : change_position.file_hash
        url = url_helpers.diffs_project_merge_request_path(project, merge_request, version_params.merge(anchor: anchor))

        text_parts << ""[version #{version_index} of the diff](#{url})""
      else
        text_parts << ""version #{version_index} of the diff""
      end

      body = text_parts.join(' ')
      note_attributes = discussion.reply_attributes.merge(project: project, author: author, note: body)

      Note.create(note_attributes.merge(system: true)).tap do |note|
        note.system_note_metadata = SystemNoteMetadata.new(action: 'outdated')
      end
    end

    # Called when a branch in Noteable is changed
    #
    # branch_type - 'source' or 'target'
    # event_type  - the source of event: 'update' or 'delete'
    # old_branch  - old branch name
    # new_branch  - new branch name

    # Example Note text is based on event_type:
    #
    #   update: ""changed target branch from `Old` to `New`""
    #   delete: ""deleted the `Old` branch. This merge request now targets the `New` branch""
    #
    # Returns the created Note object
    def change_branch(branch_type, event_type, old_branch, new_branch)
      body =
        case event_type.to_s
        when 'delete'
          ""deleted the `#{old_branch}` branch. This merge request now targets the `#{new_branch}` branch""
        when 'update'
          ""changed #{branch_type} branch from `#{old_branch}` to `#{new_branch}`""
        else
          raise ArgumentError, ""invalid value for event_type: #{event_type}""
        end

      create_note(NoteSummary.new(noteable, project, author, body, action: 'branch'))
    end

    # Called when a branch in Noteable is added or deleted
    #
    # branch_type - :source or :target
    # branch      - branch name
    # presence    - :add or :delete
    #
    # Example Note text:
    #
    #   ""restored target branch `feature`""
    #
    # Returns the created Note object
    def change_branch_presence(branch_type, branch, presence)
      verb =
        if presence == :add
          'restored'
        else
          'deleted'
        end

      body = ""#{verb} #{branch_type} branch `#{branch}`""

      create_note(NoteSummary.new(noteable, project, author, body, action: 'branch'))
    end

    # Called when a branch is created from the 'new branch' button on a issue
    # Example note text:
    #
    #   ""created branch `201-issue-branch-button`""
    def new_issue_branch(branch, branch_project: nil)
      branch_project ||= project
      link = url_helpers.project_compare_path(branch_project, from: branch_project.default_branch, to: branch)

      body = ""created branch [`#{branch}`](#{link}) to address this issue""

      create_note(NoteSummary.new(noteable, project, author, body, action: 'branch'))
    end

    def new_merge_request(merge_request)
      body = ""created merge request #{merge_request.to_reference(project)} to address this issue""

      create_note(NoteSummary.new(noteable, project, author, body, action: 'merge'))
    end

    def picked_into_branch(branch_name, pick_commit)
      link = url_helpers.project_tree_path(project, branch_name)

      body = ""picked the changes into the branch [`#{branch_name}`](#{link}) with commit #{pick_commit}""

      summary = NoteSummary.new(noteable, project, author, body, action: 'cherry_pick')
      summary.note[:commit_id] = pick_commit

      create_note(summary)
    end

    # Called when the merge request is approved by user
    #
    # Example Note text:
    #
    #   ""approved this merge request""
    #
    # Returns the created Note object
    def approve_mr
      body = ""approved this merge request""

      create_note(NoteSummary.new(noteable, project, author, body, action: 'approved'))
    end

    def unapprove_mr
      body = ""unapproved this merge request""

      create_note(NoteSummary.new(noteable, project, author, body, action: 'unapproved'))
    end
  end
end

SystemNotes::MergeRequestsService.prepend_mod_with('SystemNotes::MergeRequestsService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::SystemNotes::MergeRequestsService, feature_category: :code_review_workflow do
  include Gitlab::Routing

  let_it_be(:group) { create(:group) }
  let_it_be(:project) { create(:project, :repository, group: group) }
  let_it_be(:author) { create(:user) }

  let(:noteable) { create(:merge_request, source_project: project, target_project: project) }

  let(:service) { described_class.new(noteable: noteable, project: project, author: author) }

  describe '.merge_when_pipeline_succeeds' do
    let(:pipeline) { build(:ci_pipeline) }

    subject { service.merge_when_pipeline_succeeds(pipeline.sha) }

    it_behaves_like 'a system note' do
      let(:action) { 'merge' }
    end

    it ""posts the 'merge when pipeline succeeds' system note"" do
      expect(subject.note).to match(%r{enabled an automatic merge when the pipeline for (\w+/\w+@)?\h{40} succeeds})
    end
  end

  describe '.cancel_merge_when_pipeline_succeeds' do
    subject { service.cancel_merge_when_pipeline_succeeds }

    it_behaves_like 'a system note' do
      let(:action) { 'merge' }
    end

    it ""posts the 'merge when pipeline succeeds' system note"" do
      expect(subject.note).to eq ""canceled the automatic merge""
    end
  end

  describe '.abort_merge_when_pipeline_succeeds' do
    subject { service.abort_merge_when_pipeline_succeeds('merge request was closed') }

    it_behaves_like 'a system note' do
      let(:action) { 'merge' }
    end

    it ""posts the 'merge when pipeline succeeds' system note"" do
      expect(subject.note).to eq ""aborted the automatic merge because merge request was closed""
    end
  end

  describe '.handle_merge_request_draft' do
    context 'adding draft note' do
      let(:noteable) { create(:merge_request, source_project: project, title: 'Draft: Lorem ipsum') }

      subject { service.handle_merge_request_draft }

      it_behaves_like 'a system note' do
        let(:action) { 'title' }
      end

      it 'sets the note text' do
        expect(subject.note).to eq 'marked this merge request as **draft**'
      end
    end

    context 'removing draft note' do
      subject { service.handle_merge_request_draft }

      it_behaves_like 'a system note' do
        let(:action) { 'title' }
      end

      it 'sets the note text' do
        expect(subject.note).to eq 'marked this merge request as **ready**'
      end
    end
  end

  describe '.add_merge_request_draft_from_commit' do
    subject { service.add_merge_request_draft_from_commit(noteable.diff_head_commit) }

    it_behaves_like 'a system note' do
      let(:action) { 'title' }
    end

    it ""posts the 'marked this merge request as draft from commit' system note"" do
      expect(subject.note).to match(
        /marked this merge request as \*\*draft\*\* from #{Commit.reference_pattern}/
      )
    end
  end

  describe '.resolve_all_discussions' do
    subject { service.resolve_all_discussions }

    it_behaves_like 'a system note' do
      let(:action) { 'discussion' }
    end

    it 'sets the note text' do
      expect(subject.note).to eq 'resolved all threads'
    end
  end

  describe '.diff_discussion_outdated' do
    let(:discussion) { create(:diff_note_on_merge_request, project: project).to_discussion }
    let(:merge_request) { discussion.noteable }
    let(:change_position) { discussion.position }

    def reloaded_merge_request
      MergeRequest.find(merge_request.id)
    end

    let(:service) { described_class.new(project: project, author: author) }

    subject { service.diff_discussion_outdated(discussion, change_position) }

    it_behaves_like 'a system note' do
      let(:expected_noteable) { discussion.first_note.noteable }
      let(:action)            { 'outdated' }
    end

    context 'when the change_position is valid for the discussion' do
      it 'creates a new note in the discussion' do
        # we need to completely rebuild the merge request object, or the `@discussions` on the merge request are not reloaded.
        expect { subject }.to change { reloaded_merge_request.discussions.first.notes.size }.by(1)
      end

      it 'links to the diff in the system note' do
        diff_id = merge_request.merge_request_diff.id
        line_code = change_position.line_code(project.repository)
        link = diffs_project_merge_request_path(project, merge_request, diff_id: diff_id, anchor: line_code)

        expect(subject.note).to eq(""changed this line in [version 1 of the diff](#{link})"")
      end

      context 'discussion is on an image' do
        let(:discussion) { create(:image_diff_note_on_merge_request, project: project).to_discussion }

        it 'links to the diff in the system note' do
          diff_id = merge_request.merge_request_diff.id
          file_hash = change_position.file_hash
          link = diffs_project_merge_request_path(project, merge_request, diff_id: diff_id, anchor: file_hash)

          expect(subject.note).to eq(""changed this file in [version 1 of the diff](#{link})"")
        end
      end
    end

    context 'when the change_position does not point to a valid version' do
      before do
        allow(merge_request).to receive(:version_params_for).and_return(nil)
      end

      it 'creates a new note in the discussion' do
        # we need to completely rebuild the merge request object, or the `@discussions` on the merge request are not reloaded.
        expect { subject }.to change { reloaded_merge_request.discussions.first.notes.size }.by(1)
      end

      it 'does not create a link' do
        expect(subject.note).to eq('changed this line in version 1 of the diff')
      end
    end
  end

  describe '.change_branch' do
    let(:old_branch) { 'old_branch' }
    let(:new_branch) { 'new_branch' }

    it_behaves_like 'a system note' do
      let(:action) { 'branch' }

      subject { service.change_branch('target', 'update', old_branch, new_branch) }
    end

    context 'when target branch name changed' do
      context 'on update' do
        subject { service.change_branch('target', 'update', old_branch, new_branch) }

        it 'sets the note text' do
          expect(subject.note).to eq ""changed target branch from `#{old_branch}` to `#{new_branch}`""
        end
      end

      context 'on delete' do
        subject { service.change_branch('target', 'delete', old_branch, new_branch) }

        it 'sets the note text' do
          expect(subject.note).to eq ""deleted the `#{old_branch}` branch. This merge request now targets the `#{new_branch}` branch""
        end
      end

      context 'for invalid event_type' do
        subject { service.change_branch('target', 'invalid', old_branch, new_branch) }

        it 'raises exception' do
          expect { subject }.to raise_error /invalid value for event_type/
        end
      end
    end
  end

  describe '.change_branch_presence' do
    subject { service.change_branch_presence(:source, 'feature', :delete) }

    it_behaves_like 'a system note' do
      let(:action) { 'branch' }
    end

    context 'when source branch deleted' do
      it 'sets the note text' do
        expect(subject.note).to eq ""deleted source branch `feature`""
      end
    end
  end

  describe '.new_issue_branch' do
    let(:branch) { '1-mepmep' }

    subject { service.new_issue_branch(branch, branch_project: branch_project) }

    shared_examples_for 'a system note for new issue branch' do
      it_behaves_like 'a system note' do
        let(:action) { 'branch' }
      end

      context 'when a branch is created from the new branch button' do
        it 'sets the note text' do
          expect(subject.note).to start_with(""created branch [`#{branch}`]"")
        end
      end
    end

    context 'branch_project is set' do
      let(:branch_project) { create(:project, :repository) }

      it_behaves_like 'a system note for new issue branch'
    end

    context 'branch_project is not set' do
      let(:branch_project) { nil }

      it_behaves_like 'a system note for new issue branch'
    end
  end

  describe '.new_merge_request' do
    subject { service.new_merge_request(merge_request) }

    let!(:merge_request) { create(:merge_request, source_project: project, source_branch: generate(:branch), target_project: project) }

    it_behaves_like 'a system note' do
      let(:action) { 'merge' }
    end

    it 'sets the new merge request note text' do
      expect(subject.note).to eq(""created merge request #{merge_request.to_reference(project)} to address this issue"")
    end
  end

  describe '.picked_into_branch' do
    let(:branch_name) { 'a-branch' }
    let(:commit_sha) { project.commit.sha }
    let(:merge_request) { noteable }

    subject { service.picked_into_branch(branch_name, commit_sha) }

    it_behaves_like 'a system note' do
      let(:action) { 'cherry_pick' }
    end

    it ""posts the 'picked merge request' system note"" do
      expect(subject.note).to eq(""picked the changes into the branch [`#{branch_name}`](/#{project.full_path}/-/tree/#{branch_name}) with commit #{commit_sha}"")
    end

    it 'links the merge request and the cherry-pick commit' do
      expect(subject.noteable).to eq(merge_request)
      expect(subject.commit_id).to eq(commit_sha)
    end
  end

  describe '#approve_mr' do
    subject { described_class.new(noteable: noteable, project: project, author: author).approve_mr }

    it_behaves_like 'a system note' do
      let(:action) { 'approved' }
    end

    context 'when merge request approved' do
      it 'sets the note text' do
        expect(subject.note).to eq ""approved this merge request""
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module SystemNotes
  class BaseService
    attr_reader :noteable, :project, :author

    def initialize(noteable: nil, author: nil, project: nil)
      @noteable = noteable
      @project = project
      @author = author
    end

    protected

    def create_note(note_summary)
      note_params = note_summary.note.merge(system: true)
      note_params[:system_note_metadata] = SystemNoteMetadata.new(note_summary.metadata) if note_summary.metadata?

      Note.create(note_params)
    end

    def content_tag(...)
      ActionController::Base.helpers.content_tag(...)
    end

    def url_helpers
      @url_helpers ||= Gitlab::Routing.url_helpers
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe SystemNotes::BaseService, feature_category: :groups_and_projects do
  let(:noteable) { double }
  let(:project) { double }
  let(:author) { double }

  let(:base_service) { described_class.new(noteable: noteable, project: project, author: author) }

  describe '#noteable' do
    subject { base_service.noteable }

    it { is_expected.to eq(noteable) }

    it 'returns nil if no arguments are given' do
      instance = described_class.new
      expect(instance.noteable).to be_nil
    end
  end

  describe '#project' do
    subject { base_service.project }

    it { is_expected.to eq(project) }

    it 'returns nil if no arguments are given' do
      instance = described_class.new
      expect(instance.project).to be_nil
    end
  end

  describe '#author' do
    subject { base_service.author }

    it { is_expected.to eq(author) }

    it 'returns nil if no arguments are given' do
      instance = described_class.new
      expect(instance.author).to be_nil
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module SystemNotes
  class TimeTrackingService < ::SystemNotes::BaseService
    # Called when the start_date or due_date of an Issue/WorkItem is changed
    #
    # start_date  - Start date being assigned, or nil
    # due_date  - Due date being assigned, or nil
    #
    # Example Note text:
    #
    #   ""removed due date""
    #
    #   ""changed due date to September 20, 2018""

    #   ""changed start date to September 20, 2018 and changed due date to September 25, 2018""
    #
    # Returns the created Note object
    def change_start_date_or_due_date(changed_dates = {})
      return if changed_dates.empty?

      # Using instance_of because WorkItem < Issue. We don't want to track work item updates as issue updates
      if noteable.instance_of?(Issue) && changed_dates.key?('due_date')
        issue_activity_counter.track_issue_due_date_changed_action(author: author, project: project)
      end

      work_item_activity_counter.track_work_item_date_changed_action(author: author) if noteable.is_a?(WorkItem)

      create_note(
        NoteSummary.new(noteable, project, author, changed_date_body(changed_dates), action: 'start_date_or_due_date')
      )
    end

    # Called when the estimated time of a Noteable is changed
    #
    # time_estimate - Estimated time
    #
    # Example Note text:
    #
    #   ""removed time estimate""
    #
    #   ""changed time estimate to 3d 5h""
    #
    # Returns the created Note object
    def change_time_estimate
      parsed_time = Gitlab::TimeTrackingFormatter.output(noteable.time_estimate)
      body = if noteable.time_estimate == 0
               ""removed time estimate""
             else
               ""changed time estimate to #{parsed_time}""
             end

      if noteable.is_a?(Issue)
        issue_activity_counter.track_issue_time_estimate_changed_action(author: author, project: project)
      end

      create_note(NoteSummary.new(noteable, project, author, body, action: 'time_tracking'))
    end

    # Called when the spent time of a Noteable is changed
    #
    # time_spent - Spent time
    #
    # Example Note text:
    #
    #   ""removed time spent""
    #
    #   ""added 2h 30m of time spent""
    #
    # Returns the created Note object
    def change_time_spent
      time_spent = noteable.time_spent

      if time_spent == :reset
        body = ""removed time spent""
      else
        spent_at = noteable.spent_at&.to_date
        parsed_time = Gitlab::TimeTrackingFormatter.output(time_spent.abs)
        action = time_spent > 0 ? 'added' : 'subtracted'

        text_parts = [""#{action} #{parsed_time} of time spent""]
        text_parts << ""at #{spent_at}"" if spent_at && spent_at != DateTime.current.to_date
        body = text_parts.join(' ')
      end

      if noteable.is_a?(Issue)
        issue_activity_counter.track_issue_time_spent_changed_action(author: author, project: project)
      end

      create_note(NoteSummary.new(noteable, project, author, body, action: 'time_tracking'))
    end

    # Called when a timelog is added to an issuable
    #
    # timelog - Added timelog
    #
    # Example Note text:
    #
    #   ""subtracted 1h 15m of time spent""
    #
    #   ""added 2h 30m of time spent""
    #
    # Returns the created Note object
    def created_timelog(timelog)
      time_spent = timelog.time_spent
      spent_at = timelog.spent_at&.to_date
      parsed_time = Gitlab::TimeTrackingFormatter.output(time_spent.abs)
      action = time_spent > 0 ? 'added' : 'subtracted'

      text_parts = [""#{action} #{parsed_time} of time spent""]
      text_parts << ""at #{spent_at}"" if spent_at && spent_at != DateTime.current.to_date
      body = text_parts.join(' ')

      if noteable.is_a?(Issue)
        issue_activity_counter.track_issue_time_spent_changed_action(author: author, project: project)
      end

      create_note(NoteSummary.new(noteable, project, author, body, action: 'time_tracking'))
    end

    def remove_timelog(timelog)
      time_spent = timelog.time_spent
      spent_at = timelog.spent_at&.to_date

      parsed_time = Gitlab::TimeTrackingFormatter.output(time_spent)

      body = ""deleted #{parsed_time} of spent time""
      body += "" from #{spent_at}"" if spent_at

      create_note(NoteSummary.new(noteable, project, author, body, action: 'time_tracking'))
    end

    private

    def changed_date_body(changed_dates)
      %w[start_date due_date].each_with_object([]) do |date_field, word_array|
        next unless changed_dates.key?(date_field)

        word_array << 'and' if word_array.any?

        word_array << message_for_changed_date(changed_dates, date_field)
      end.join(' ')
    end

    def message_for_changed_date(changed_dates, date_key)
      changed_date = changed_dates[date_key].last
      readable_date = date_key.humanize.downcase

      if changed_date.nil?
        ""removed #{readable_date} #{changed_dates[date_key].first.to_fs(:long)}""
      else
        ""changed #{readable_date} to #{changed_date.to_fs(:long)}""
      end
    end

    def issue_activity_counter
      Gitlab::UsageDataCounters::IssueActivityUniqueCounter
    end

    def work_item_activity_counter
      Gitlab::UsageDataCounters::WorkItemActivityUniqueCounter
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::SystemNotes::TimeTrackingService, feature_category: :team_planning do
  let_it_be(:author)  { create(:user) }
  let_it_be(:project) { create(:project, :repository) }

  describe '#change_start_date_or_due_date' do
    let_it_be(:issue)     { create(:issue, project: project) }
    let_it_be(:work_item) { create(:work_item, project: project) }

    subject(:note) { described_class.new(noteable: noteable, project: project, author: author).change_start_date_or_due_date(changed_dates) }

    let(:start_date) { Date.today }
    let(:due_date) { 1.week.from_now.to_date }
    let(:changed_dates) { { 'due_date' => [nil, due_date], 'start_date' => [nil, start_date] } }

    shared_examples 'issuable getting date change notes' do
      it_behaves_like 'a note with overridable created_at'

      it_behaves_like 'a system note' do
        let(:action) { 'start_date_or_due_date' }
      end

      context 'when both dates are added' do
        it 'sets the correct note message' do
          expect(note.note).to eq(""changed start date to #{start_date.to_fs(:long)} and changed due date to #{due_date.to_fs(:long)}"")
        end
      end

      context 'when both dates are removed' do
        let(:changed_dates) { { 'due_date' => [due_date, nil], 'start_date' => [start_date, nil] } }

        before do
          noteable.update!(start_date: start_date, due_date: due_date)
        end

        it 'sets the correct note message' do
          expect(note.note).to eq(""removed start date #{start_date.to_fs(:long)} and removed due date #{due_date.to_fs(:long)}"")
        end
      end

      context 'when due date is added' do
        let(:changed_dates) { { 'due_date' => [nil, due_date] } }

        it 'sets the correct note message' do
          expect(note.note).to eq(""changed due date to #{due_date.to_fs(:long)}"")
        end

        context 'and start date removed' do
          let(:changed_dates) { { 'due_date' => [nil, due_date], 'start_date' => [start_date, nil] } }

          it 'sets the correct note message' do
            expect(note.note).to eq(""removed start date #{start_date.to_fs(:long)} and changed due date to #{due_date.to_fs(:long)}"")
          end
        end
      end

      context 'when start_date is added' do
        let(:changed_dates) { { 'start_date' => [nil, start_date] } }

        it 'does not track the issue event' do
          expect(Gitlab::UsageDataCounters::IssueActivityUniqueCounter).not_to receive(:track_issue_due_date_changed_action)

          subject
        end

        it 'does not emit snowplow event', :snowplow do
          expect_no_snowplow_event

          subject
        end

        it 'sets the correct note message' do
          expect(note.note).to eq(""changed start date to #{start_date.to_fs(:long)}"")
        end

        context 'and due date removed' do
          let(:changed_dates) { { 'due_date' => [due_date, nil], 'start_date' => [nil, start_date] } }

          it 'sets the correct note message' do
            expect(note.note).to eq(""changed start date to #{start_date.to_fs(:long)} and removed due date #{due_date.to_fs(:long)}"")
          end
        end
      end

      context 'when no dates are changed' do
        let(:changed_dates) { {} }

        it 'does not create a note and returns nil' do
          expect do
            note
          end.to not_change(Note, :count)

          expect(note).to be_nil
        end
      end
    end

    context 'when noteable is an issue' do
      let(:noteable) { issue }
      let(:activity_counter_class) { Gitlab::UsageDataCounters::IssueActivityUniqueCounter }
      let(:activity_counter_method) { :track_issue_due_date_changed_action }

      it_behaves_like 'issuable getting date change notes'

      it 'does not track the work item event in usage ping' do
        expect(Gitlab::UsageDataCounters::WorkItemActivityUniqueCounter).not_to receive(:track_work_item_date_changed_action)

        subject
      end

      it 'tracks the issue event' do
        expect(Gitlab::UsageDataCounters::IssueActivityUniqueCounter).to receive(:track_issue_due_date_changed_action)
                                                                           .with(author: author, project: project)

        subject
      end

      it_behaves_like 'internal event tracking' do
        let(:event) { Gitlab::UsageDataCounters::IssueActivityUniqueCounter::ISSUE_DUE_DATE_CHANGED }
        let(:user) { author }
        let(:namespace) { project.namespace }
      end

      context 'when only start_date is added' do
        let(:changed_dates) { { 'start_date' => [nil, start_date] } }

        it 'does not track the issue event in usage ping' do
          expect(activity_counter_class).not_to receive(activity_counter_method)

          subject
        end
      end
    end

    context 'when noteable is a work item' do
      let(:noteable) { work_item }
      let(:activity_counter_class) { Gitlab::UsageDataCounters::WorkItemActivityUniqueCounter }
      let(:activity_counter_method) { :track_work_item_date_changed_action }

      it_behaves_like 'issuable getting date change notes'

      it 'does not track the issue event' do
        expect(Gitlab::UsageDataCounters::IssueActivityUniqueCounter).not_to receive(:track_issue_due_date_changed_action)

        subject
      end

      it 'does not emit snowplow event', :snowplow do
        expect_no_snowplow_event

        subject
      end

      context 'when only start_date is added' do
        let(:changed_dates) { { 'start_date' => [nil, start_date] } }

        it 'tracks the issue event in usage ping' do
          expect(activity_counter_class).to receive(activity_counter_method).with(author: author)

          subject
        end
      end
    end

    context 'when noteable is a merge request' do
      let(:noteable) { create(:merge_request, source_project: project) }

      it 'does not track the issue event' do
        expect(Gitlab::UsageDataCounters::IssueActivityUniqueCounter).not_to receive(:track_issue_due_date_changed_action)

        subject
      end

      it 'does not track the work item event in usage ping' do
        expect(Gitlab::UsageDataCounters::WorkItemActivityUniqueCounter).not_to receive(:track_work_item_date_changed_action)

        subject
      end

      it 'does not emit snowplow event', :snowplow do
        expect_no_snowplow_event

        subject
      end
    end
  end

  describe '#change_time_estimate' do
    subject { described_class.new(noteable: noteable, project: project, author: author).change_time_estimate }

    context 'when noteable is an issue' do
      let_it_be(:noteable, reload: true) { create(:issue, project: project) }

      it_behaves_like 'a system note' do
        let(:action) { 'time_tracking' }
      end

      context 'with a time estimate' do
        it 'sets the note text' do
          noteable.update_attribute(:time_estimate, 277200)

          expect(subject.note).to eq ""changed time estimate to 1w 4d 5h""
        end

        context 'when time_tracking_limit_to_hours setting is true' do
          before do
            stub_application_setting(time_tracking_limit_to_hours: true)
          end

          it 'sets the note text' do
            noteable.update_attribute(:time_estimate, 277200)

            expect(subject.note).to eq ""changed time estimate to 77h""
          end
        end
      end

      context 'without a time estimate' do
        it 'sets the note text' do
          expect(subject.note).to eq ""removed time estimate""
        end
      end

      it 'tracks the issue event in usage ping' do
        expect(Gitlab::UsageDataCounters::IssueActivityUniqueCounter).to receive(:track_issue_time_estimate_changed_action)
                                                                           .with(author: author, project: project)

        subject
      end

      it_behaves_like 'internal event tracking' do
        let(:event) { Gitlab::UsageDataCounters::IssueActivityUniqueCounter::ISSUE_TIME_ESTIMATE_CHANGED }
        let(:user) { author }
        let(:namespace) { project.namespace }
      end
    end

    context 'when noteable is a merge request' do
      let_it_be(:noteable) { create(:merge_request, source_project: project) }

      it 'does not track the issue event' do
        expect(Gitlab::UsageDataCounters::IssueActivityUniqueCounter).not_to receive(:track_issue_time_estimate_changed_action)
                                                                               .with(author: author, project: project)

        subject
      end

      it 'does not emit snowplow event', :snowplow do
        expect_no_snowplow_event

        subject
      end
    end
  end

  describe '#create_timelog' do
    subject { described_class.new(noteable: noteable, project: project, author: author).created_timelog(timelog) }

    context 'when the timelog has a positive time spent value' do
      let_it_be(:noteable, reload: true) { create(:issue, project: project) }

      let(:timelog) { create(:timelog, user: author, issue: noteable, time_spent: 1800, spent_at: '2022-03-30T00:00:00.000Z') }

      it 'sets the note text' do
        expect(subject.note).to eq ""added 30m of time spent at 2022-03-30""
      end
    end

    context 'when the timelog has a negative time spent value' do
      let_it_be(:noteable, reload: true) { create(:issue, project: project) }

      let(:timelog) { create(:timelog, user: author, issue: noteable, time_spent: -1800, spent_at: '2022-03-30T00:00:00.000Z') }

      it 'sets the note text' do
        expect(subject.note).to eq ""subtracted 30m of time spent at 2022-03-30""
      end
    end
  end

  describe '#remove_timelog' do
    subject { described_class.new(noteable: noteable, project: project, author: author).remove_timelog(timelog) }

    context 'when the timelog has a positive time spent value' do
      let_it_be(:noteable, reload: true) { create(:issue, project: project) }

      let(:timelog) { create(:timelog, user: author, issue: noteable, time_spent: 1800, spent_at: '2022-03-30T00:00:00.000Z') }

      it 'sets the note text' do
        expect(subject.note).to eq ""deleted 30m of spent time from 2022-03-30""
      end
    end

    context 'when the timelog has a negative time spent value' do
      let_it_be(:noteable, reload: true) { create(:issue, project: project) }

      let(:timelog) { create(:timelog, user: author, issue: noteable, time_spent: -1800, spent_at: '2022-03-30T00:00:00.000Z') }

      it 'sets the note text' do
        expect(subject.note).to eq ""deleted -30m of spent time from 2022-03-30""
      end
    end
  end

  describe '#change_time_spent' do
    subject { described_class.new(noteable: noteable, project: project, author: author).change_time_spent }

    context 'when noteable is an issue' do
      let_it_be(:noteable, reload: true) { create(:issue, project: project) }

      it_behaves_like 'a system note' do
        let(:action) { 'time_tracking' }

        before do
          spend_time!(277200)
        end
      end

      context 'when time was added' do
        it 'sets the note text' do
          spend_time!(277200)

          expect(subject.note).to eq ""added 1w 4d 5h of time spent""
        end

        context 'when time was subtracted' do
          it 'sets the note text' do
            spend_time!(360000)
            spend_time!(-277200)

            expect(subject.note).to eq ""subtracted 1w 4d 5h of time spent""
          end
        end

        context 'when time was removed' do
          it 'sets the note text' do
            spend_time!(:reset)

            expect(subject.note).to eq ""removed time spent""
          end
        end

        context 'when time_tracking_limit_to_hours setting is true' do
          before do
            stub_application_setting(time_tracking_limit_to_hours: true)
          end

          it 'sets the note text' do
            spend_time!(277200)

            expect(subject.note).to eq ""added 77h of time spent""
          end
        end

        it 'tracks the issue event' do
          expect(Gitlab::UsageDataCounters::IssueActivityUniqueCounter).to receive(:track_issue_time_spent_changed_action)
                                                                             .with(author: author, project: project)

          spend_time!(277200)

          subject
        end

        it_behaves_like 'internal event tracking' do
          let(:event) { Gitlab::UsageDataCounters::IssueActivityUniqueCounter::ISSUE_TIME_SPENT_CHANGED }
          let(:user) { author }
          let(:namespace) { project.namespace }
        end
      end

      context 'when noteable is a merge request' do
        let_it_be(:noteable) { create(:merge_request, source_project: project) }

        it 'does not track the issue event' do
          expect(Gitlab::UsageDataCounters::IssueActivityUniqueCounter).not_to receive(:track_issue_time_estimate_changed_action)
                                                                                 .with(author: author, project: project)

          spend_time!(277200)

          subject
        end

        it 'does not emit snowplow event', :snowplow do
          expect_no_snowplow_event

          subject
        end
      end

      def spend_time!(seconds)
        noteable.spend_time(duration: seconds, user_id: author.id)
        noteable.save!
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module SystemNotes
  class ZoomService < ::SystemNotes::BaseService
    def zoom_link_added
      create_note(NoteSummary.new(noteable, project, author, _('added a Zoom call to this issue'), action: 'pinned_embed'))
    end

    def zoom_link_removed
      create_note(NoteSummary.new(noteable, project, author, _('removed a Zoom call from this issue'), action: 'pinned_embed'))
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::SystemNotes::ZoomService, feature_category: :integrations do
  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:author)  { create(:user) }

  let(:noteable)      { create(:issue, project: project) }

  let(:service) { described_class.new(noteable: noteable, project: project, author: author) }

  describe '#zoom_link_added' do
    subject { service.zoom_link_added }

    it_behaves_like 'a system note' do
      let(:action) { 'pinned_embed' }
    end

    it 'sets the zoom link added note text' do
      expect(subject.note).to eq('added a Zoom call to this issue')
    end
  end

  describe '#zoom_link_removed' do
    subject { service.zoom_link_removed }

    it_behaves_like 'a system note' do
      let(:action) { 'pinned_embed' }
    end

    it 'sets the zoom link removed note text' do
      expect(subject.note).to eq('removed a Zoom call from this issue')
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module SystemNotes
  class IncidentService < ::SystemNotes::BaseService
    # Called when the severity of an Incident has changed
    #
    # Example Note text:
    #
    #   ""changed the severity to Medium - S3""
    #
    # Returns the created Note object
    def change_incident_severity
      severity = noteable.severity

      if severity_label = IssuableSeverity::SEVERITY_LABELS[severity.to_sym]
        body = ""changed the severity to **#{severity_label}**""

        create_note(NoteSummary.new(noteable, project, author, body, action: 'severity'))
      else
        Gitlab::AppLogger.error(
          message: 'Cannot create a system note for severity change',
          noteable_class: noteable.class.to_s,
          noteable_id: noteable.id,
          severity: severity
        )
      end
    end

    # Called when the status of an IncidentManagement::IssuableEscalationStatus has changed
    #
    # reason - String.
    #
    # Example Note text:
    #
    #   ""changed the incident status to Acknowledged""
    #   ""changed the incident status to Acknowledged by changing the status of ^alert#540""
    #
    # Returns the created Note object
    def change_incident_status(reason)
      status = noteable.escalation_status.status_name.to_s.titleize
      body = ""changed the incident status to **#{status}**#{reason}""

      create_note(NoteSummary.new(noteable, project, author, body, action: 'status'))
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::SystemNotes::IncidentService, feature_category: :incident_management do
  let_it_be(:author) { create(:user) }
  let_it_be(:project) { create(:project) }
  let_it_be(:noteable) { create(:incident, project: project) }
  let_it_be(:issuable_severity) { create(:issuable_severity, issue: noteable, severity: :medium) }

  describe '#change_incident_severity' do
    subject(:change_severity) { described_class.new(noteable: noteable, project: project, author: author).change_incident_severity }

    before do
      allow(Gitlab::AppLogger).to receive(:error).and_call_original
    end

    it_behaves_like 'a system note' do
      let(:action) { 'severity' }
    end

    IssuableSeverity.severities.keys.each do |severity|
      context ""with #{severity} severity"" do
        before do
          issuable_severity.update!(severity: severity)
        end

        it 'has the appropriate message' do
          severity_label = IssuableSeverity::SEVERITY_LABELS.fetch(severity.to_sym)

          expect(change_severity.note).to eq(""changed the severity to **#{severity_label}**"")
        end
      end
    end

    context 'when severity is invalid' do
      let(:invalid_severity) { 'invalid-severity' }

      before do
        allow(noteable).to receive(:severity).and_return(invalid_severity)
      end

      it 'does not create system note' do
        expect { change_severity }.not_to change { noteable.notes.count }
      end

      it 'writes error to logs' do
        change_severity

        expect(Gitlab::AppLogger).to have_received(:error).with(
          message: 'Cannot create a system note for severity change',
          noteable_class: noteable.class.to_s,
          noteable_id: noteable.id,
          severity: invalid_severity
        )
      end
    end
  end

  describe '#change_incident_status' do
    let_it_be(:escalation_status) { create(:incident_management_issuable_escalation_status, issue: noteable) }

    let(:service) { described_class.new(noteable: noteable, project: project, author: author) }

    context 'with a provided reason' do
      subject(:change_incident_status) { service.change_incident_status(' by changing the alert status') }

      it 'creates a new note for an incident status change', :aggregate_failures do
        expect { change_incident_status }.to change { noteable.notes.count }.by(1)
        expect(noteable.notes.last.note).to eq(""changed the incident status to **Triggered** by changing the alert status"")
      end
    end

    context 'without provided reason' do
      subject(:change_incident_status) { service.change_incident_status(nil) }

      it 'creates a new note for an incident status change', :aggregate_failures do
        expect { change_incident_status }.to change { noteable.notes.count }.by(1)
        expect(noteable.notes.last.note).to eq(""changed the incident status to **Triggered**"")
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Organizations
  class UpdateService < ::Organizations::BaseService
    attr_reader :organization

    def initialize(organization, current_user:, params: {})
      @organization = organization
      @current_user = current_user
      @params = params.dup
      return unless @params.key?(:description)

      organization_detail_attributes = { description: @params.delete(:description) }
      # TODO: Remove explicit passing of id once https://github.com/rails/rails/issues/48714 is resolved.
      organization_detail_attributes[:id] = organization.id
      @params[:organization_detail_attributes] ||= {}
      @params[:organization_detail_attributes].merge!(organization_detail_attributes)
    end

    def execute
      return error_no_permissions unless allowed?

      if organization.update(params)
        ServiceResponse.success(payload: organization)
      else
        error_updating
      end
    end

    private

    def allowed?
      current_user&.can?(:admin_organization, organization)
    end

    def error_no_permissions
      ServiceResponse.error(message: [_('You have insufficient permissions to update the organization')])
    end

    def error_updating
      message = organization.errors.full_messages || _('Failed to update organization')

      ServiceResponse.error(payload: organization, message: Array(message))
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Organizations::UpdateService, feature_category: :cell do
  describe '#execute' do
    let_it_be(:user) { create(:user) }
    let_it_be_with_reload(:organization) { create(:organization) }

    let(:current_user) { user }
    let(:name) { 'Name' }
    let(:path) { 'path' }
    let(:description) { nil }
    let(:params) { { name: name, path: path } }

    subject(:response) do
      described_class.new(organization, current_user: current_user, params: params).execute
    end

    context 'when user does not have permission' do
      let(:current_user) { nil }

      it 'returns an error' do
        expect(response).to be_error

        expect(response.message).to match_array(['You have insufficient permissions to update the organization'])
      end
    end

    context 'when user has permission' do
      before do
        create(:organization_user, organization: organization, user: current_user)
      end

      shared_examples 'updating an organization' do
        it 'updates the organization' do
          response
          organization.reset

          expect(response).to be_success
          expect(organization.name).to eq(name)
          expect(organization.path).to eq(path)
          expect(organization.description).to eq(description)
        end
      end

      context 'with description' do
        let(:description) { 'Organization description' }
        let(:params) do
          {
            name: name,
            path: path,
            description: description
          }
        end

        it_behaves_like 'updating an organization'
      end

      include_examples 'updating an organization'

      it 'returns an error when the organization is not updated' do
        params[:name] = nil

        expect(response).to be_error
        expect(response.message).to match_array([""Name can't be blank""])
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Organizations
  class CreateService < ::Organizations::BaseService
    def execute
      return error_no_permissions unless current_user&.can?(:create_organization)

      organization = Organization.create(params)

      return error_creating(organization) unless organization.persisted?

      ServiceResponse.success(payload: organization)
    end

    private

    def error_no_permissions
      ServiceResponse.error(message: [_('You have insufficient permissions to create organizations')])
    end

    def error_creating(organization)
      message = organization.errors.full_messages || _('Failed to create organization')

      ServiceResponse.error(message: Array(message))
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Organizations::CreateService, feature_category: :cell do
  describe '#execute' do
    let_it_be(:user) { create(:user) }

    let(:current_user) { user }
    let(:params) { attributes_for(:organization) }

    subject(:response) { described_class.new(current_user: current_user, params: params).execute }

    context 'when user does not have permission' do
      let(:current_user) { nil }

      it 'returns an error' do
        expect(response).to be_error

        expect(response.message).to match_array(
          ['You have insufficient permissions to create organizations'])
      end
    end

    context 'when user has permission' do
      it 'creates an organization' do
        expect { response }.to change { Organizations::Organization.count }

        expect(response).to be_success
      end

      it 'returns an error when the organization is not persisted' do
        params[:name] = nil

        expect(response).to be_error
        expect(response.message).to match_array([""Name can't be blank""])
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Terraform
  class RemoteStateHandler < BaseService
    include Gitlab::OptimisticLocking

    StateLockedError = Class.new(StandardError)
    StateDeletedError = Class.new(StandardError)
    UnauthorizedError = Class.new(StandardError)

    def find_with_lock
      retrieve_with_lock(find_only: true) do |state|
        yield state if block_given?
      end
    end

    def handle_with_lock
      raise UnauthorizedError unless can_modify_state?

      retrieve_with_lock do |state|
        raise StateLockedError unless lock_matches?(state)

        yield state if block_given?

        state.save! unless state.destroyed?
      end

      nil
    end

    def lock!
      raise ArgumentError if params[:lock_id].blank?
      raise UnauthorizedError unless can_modify_state?

      retrieve_with_lock do |state|
        raise StateLockedError if state.locked?

        state.lock_xid = params[:lock_id]
        state.locked_by_user = current_user
        state.locked_at = Time.current

        state.save!
      end
    end

    def unlock!
      raise UnauthorizedError unless can_modify_state?

      retrieve_with_lock do |state|
        # force-unlock does not pass ID, so we ignore it if it is missing
        raise StateLockedError unless params[:lock_id].nil? || lock_matches?(state)

        state.lock_xid = nil
        state.locked_by_user = nil
        state.locked_at = nil

        state.save!
      end
    end

    private

    def retrieve_with_lock(find_only: false)
      create_or_find!(find_only: find_only).tap do |state|
        retry_lock(state, name: ""Terraform state: #{state.id}"") { yield state }
      end
    end

    def create_or_find!(find_only:)
      raise ArgumentError unless params[:name].present?

      find_params = { project: project, name: params[:name] }

      state = if find_only
                find_state!(find_params)
              else
                Terraform::State.safe_find_or_create_by(find_params)
              end

      raise StateDeletedError if state.deleted_at?

      state
    end

    def lock_matches?(state)
      return true if state.lock_xid.nil? && params[:lock_id].nil?

      ActiveSupport::SecurityUtils
        .secure_compare(state.lock_xid.to_s, params[:lock_id].to_s)
    end

    def can_modify_state?
      current_user.can?(:admin_terraform_state, project)
    end

    def find_state(find_params)
      Terraform::State.find_by(find_params) # rubocop: disable CodeReuse/ActiveRecord
    end

    def find_state!(find_params)
      find_state(find_params) || raise(ActiveRecord::RecordNotFound, ""Couldn't find state"")
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Terraform::RemoteStateHandler, feature_category: :infrastructure_as_code do
  let_it_be(:project) { create(:project) }
  let_it_be(:developer) { create(:user, developer_projects: [project]) }
  let_it_be(:maintainer) { create(:user, maintainer_projects: [project]) }

  let_it_be(:user) { maintainer }

  describe '#find_with_lock' do
    context 'without a state name' do
      subject { described_class.new(project, user) }

      it 'raises an exception' do
        expect { subject.find_with_lock }.to raise_error(ArgumentError)
      end
    end

    context 'with a state name' do
      subject { described_class.new(project, user, name: 'state') }

      context 'with no matching state' do
        it 'raises an exception' do
          expect { subject.find_with_lock }.to raise_error(ActiveRecord::RecordNotFound)
        end
      end

      context 'with a matching state' do
        let!(:state) { create(:terraform_state, project: project, name: 'state') }

        it 'returns the state' do
          expect(subject.find_with_lock).to eq(state)
        end

        context 'with a state scheduled for deletion' do
          let!(:state) { create(:terraform_state, :deletion_in_progress, project: project, name: 'state') }

          it 'raises an exception' do
            expect { subject.find_with_lock }.to raise_error(described_class::StateDeletedError)
          end
        end
      end
    end
  end

  context 'when state locking is not being used' do
    subject { described_class.new(project, user, name: 'my-state') }

    describe '#handle_with_lock' do
      it 'allows to modify a state using database locking' do
        record = nil
        subject.handle_with_lock do |state|
          record = state
          state.name = 'updated-name'
        end

        expect(record.reload.name).to eq 'updated-name'
      end

      it 'returns nil' do
        expect(subject.handle_with_lock).to be_nil
      end
    end

    describe '#lock!' do
      it 'raises an error' do
        expect { subject.lock! }.to raise_error(ArgumentError)
      end
    end
  end

  context 'when using locking' do
    describe '#handle_with_lock' do
      subject(:handler) { described_class.new(project, user, name: 'new-state', lock_id: 'abc-abc') }

      it 'handles a locked state using exclusive read lock' do
        handler.lock!

        record = nil
        handler.handle_with_lock do |state|
          record = state
          state.name = 'new-name'
        end

        expect(record.reload.name).to eq 'new-name'
        expect(record.reload.project).to eq project
      end

      it 'raises exception if lock has not been acquired before' do
        expect { handler.handle_with_lock }
          .to raise_error(described_class::StateLockedError)
      end

      it 'raises an exception if the state is scheduled for deletion' do
        create(:terraform_state, :deletion_in_progress, project: project, name: 'new-state')

        expect { handler.handle_with_lock }
          .to raise_error(described_class::StateDeletedError)
      end

      context 'user does not have permission to modify state' do
        let(:user) { developer }

        it 'raises an exception' do
          expect { handler.handle_with_lock }
            .to raise_error(described_class::UnauthorizedError)
        end
      end
    end

    describe '#lock!' do
      let(:lock_id) { 'abc-abc' }

      subject(:handler) do
        described_class.new(
          project,
          user,
          name: 'new-state',
          lock_id: lock_id
        )
      end

      it 'allows to lock state if it does not exist yet' do
        state = handler.lock!

        expect(state).to be_persisted
        expect(state.name).to eq 'new-state'
      end

      it 'allows to lock state if it exists and is not locked' do
        state = create(:terraform_state, project: project, name: 'new-state')

        handler.lock!

        expect(state.reload.lock_xid).to eq lock_id
        expect(state).to be_locked
      end

      it 'raises an exception when trying to unlocked state locked by someone else' do
        described_class.new(project, user, name: 'new-state', lock_id: '12a-23f').lock!

        expect { handler.lock! }.to raise_error(described_class::StateLockedError)
      end

      it 'raises an exception when the state exists and is scheduled for deletion' do
        create(:terraform_state, :deletion_in_progress, project: project, name: 'new-state')

        expect { handler.lock! }.to raise_error(described_class::StateDeletedError)
      end
    end

    describe '#unlock!' do
      let_it_be(:state) { create(:terraform_state, :locked, project: project, name: 'new-state', lock_xid: 'abc-abc') }

      let(:lock_id) { state.lock_xid }

      subject(:handler) do
        described_class.new(
          project,
          user,
          name: state.name,
          lock_id: lock_id
        )
      end

      it 'unlocks the state' do
        state = handler.unlock!

        expect(state.lock_xid).to be_nil
      end

      context 'with no lock ID (force-unlock)' do
        let(:lock_id) {}

        it 'unlocks the state' do
          state = handler.unlock!

          expect(state.lock_xid).to be_nil
        end
      end

      context 'with different lock ID' do
        let(:lock_id) { 'other' }

        it 'raises an exception' do
          expect { handler.unlock! }
            .to raise_error(described_class::StateLockedError)
        end
      end

      context 'with a state scheduled for deletion' do
        it 'raises an exception' do
          state.update!(deleted_at: Time.current)

          expect { handler.unlock! }
            .to raise_error(described_class::StateDeletedError)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Terraform
  module States
    class TriggerDestroyService
      def initialize(state, current_user:)
        @state = state
        @current_user = current_user
      end

      def execute
        return unauthorized_response unless can_destroy_state?
        return state_locked_response if state.locked?

        state.run_after_commit do
          Terraform::States::DestroyWorker.perform_async(id)
        end

        state.update!(deleted_at: Time.current)

        ServiceResponse.success
      end

      private

      attr_reader :state, :current_user

      def can_destroy_state?
        current_user.can?(:admin_terraform_state, state.project)
      end

      def unauthorized_response
        error_response(s_('Terraform|You have insufficient permissions to delete this state'))
      end

      def state_locked_response
        error_response(s_('Terraform|Cannot remove a locked state'))
      end

      def error_response(message)
        ServiceResponse.error(message: message)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Terraform::States::TriggerDestroyService, feature_category: :infrastructure_as_code do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user, maintainer_projects: [project]) }

  describe '#execute', :aggregate_failures do
    let_it_be(:state) { create(:terraform_state, project: project) }

    let(:service) { described_class.new(state, current_user: user) }

    subject { service.execute }

    it 'marks the state as deleted and schedules a cleanup worker' do
      expect(Terraform::States::DestroyWorker).to receive(:perform_async).with(state.id).once

      expect(subject).to be_success
      expect(state.deleted_at).to be_like_time(Time.current)
    end

    context 'within a database transaction' do
      subject { state.with_lock { service.execute } }

      it 'does not raise an EnqueueFromTransactionError' do
        expect { subject }.not_to raise_error
        expect(state.deleted_at).to be_like_time(Time.current)
      end
    end

    shared_examples 'unable to delete state' do
      it 'does not modify the state' do
        expect(Terraform::States::DestroyWorker).not_to receive(:perform_async)

        expect { subject }.not_to change(state, :deleted_at)
        expect(subject).to be_error
        expect(subject.message).to eq(message)
      end
    end

    context 'user does not have permission' do
      let(:user) { create(:user, developer_projects: [project]) }
      let(:message) { 'You have insufficient permissions to delete this state' }

      include_examples 'unable to delete state'
    end

    context 'state is locked' do
      let(:state) { create(:terraform_state, :locked, project: project) }
      let(:message) { 'Cannot remove a locked state' }

      include_examples 'unable to delete state'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Terraform
  module States
    class DestroyService
      def initialize(state)
        @state = state
      end

      def execute
        return unless state.deleted_at?

        state.versions.each_batch(column: :version) do |batch|
          process_batch(batch)
        end

        state.destroy!
      end

      private

      attr_reader :state

      # Overridden in EE
      def process_batch(batch)
        batch.each do |version|
          version.file.remove!
        end
      end
    end
  end
end

Terraform::States::DestroyService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Terraform::States::DestroyService, feature_category: :infrastructure_as_code do
  let_it_be(:state) { create(:terraform_state, :with_version, :deletion_in_progress) }

  let(:file) { instance_double(Terraform::StateUploader, relative_path: 'path') }

  before do
    allow_next_found_instance_of(Terraform::StateVersion) do |version|
      allow(version).to receive(:file).and_return(file)
    end
  end

  describe '#execute' do
    subject { described_class.new(state).execute }

    it 'removes version files from object storage, followed by the state record' do
      expect(file).to receive(:remove!).once
      expect(state).to receive(:destroy!)

      subject
    end

    context 'state is not marked for deletion' do
      let(:state) { create(:terraform_state) }

      it 'does not delete the state' do
        expect(state).not_to receive(:destroy!)

        subject
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Snippets
  class UpdateRepositoryStorageService
    include UpdateRepositoryStorageMethods

    delegate :snippet, to: :repository_storage_move

    private

    def track_repository(destination_storage_name)
      snippet.track_snippet_repository(destination_storage_name)
    end

    def mirror_repositories
      return unless snippet.repository_exists?

      mirror_repository(type: Gitlab::GlRepository::SNIPPET)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Snippets::UpdateRepositoryStorageService, feature_category: :source_code_management do
  subject { described_class.new(repository_storage_move) }

  describe ""#execute"" do
    let_it_be_with_reload(:snippet) { create(:snippet, :repository) }
    let_it_be(:destination) { 'test_second_storage' }
    let_it_be(:checksum) { snippet.repository.checksum }

    let(:repository_storage_move_state) { :scheduled }
    let(:repository_storage_move) { create(:snippet_repository_storage_move, repository_storage_move_state, container: snippet, destination_storage_name: destination) }
    let(:snippet_repository_double) { double(:repository) }
    let(:original_snippet_repository_double) { double(:repository) }

    before do
      allow(Gitlab.config.repositories.storages).to receive(:keys).and_return(%w[default test_second_storage])
      allow(Gitlab::GitalyClient).to receive(:filesystem_id).with('default').and_call_original
      allow(Gitlab::GitalyClient).to receive(:filesystem_id).with(destination).and_return(SecureRandom.uuid)
      allow(Gitlab::Git::Repository).to receive(:new).and_call_original
      allow(Gitlab::Git::Repository).to receive(:new)
        .with(destination, snippet.repository.raw.relative_path, snippet.repository.gl_repository, snippet.repository.full_path)
        .and_return(snippet_repository_double)
      allow(Gitlab::Git::Repository).to receive(:new)
        .with('default', snippet.repository.raw.relative_path, nil, nil)
        .and_return(original_snippet_repository_double)
    end

    context 'when the move succeeds' do
      it 'moves the repository to the new storage and unmarks the repository as read-only' do
        expect(snippet_repository_double).to receive(:replicate)
          .with(snippet.repository.raw)
        expect(snippet_repository_double).to receive(:checksum)
          .and_return(checksum)
        expect(original_snippet_repository_double).to receive(:remove)

        result = subject.execute
        snippet.reload

        expect(result).to be_success
        expect(snippet).not_to be_repository_read_only
        expect(snippet.repository_storage).to eq(destination)
        expect(snippet.snippet_repository.shard_name).to eq(destination)
        expect(repository_storage_move.reload).to be_finished
        expect(repository_storage_move.error_message).to be_nil
      end
    end

    context 'when the filesystems are the same' do
      before do
        expect(Gitlab::GitalyClient).to receive(:filesystem_id).twice.and_return(SecureRandom.uuid)
      end

      it 'updates the database without trying to move the repostory', :aggregate_failures do
        result = subject.execute
        snippet.reload

        expect(result).to be_success
        expect(snippet).not_to be_repository_read_only
        expect(snippet.repository_storage).to eq(destination)
        expect(snippet.snippet_repository.shard_name).to eq(destination)
      end
    end

    context 'when the move fails' do
      it 'unmarks the repository as read-only without updating the repository storage' do
        expect(snippet_repository_double).to receive(:replicate)
          .with(snippet.repository.raw)
          .and_raise(Gitlab::Git::CommandError, 'Boom')
        expect(snippet_repository_double).to receive(:remove)

        expect do
          subject.execute
        end.to raise_error(Gitlab::Git::CommandError)

        expect(snippet).not_to be_repository_read_only
        expect(snippet.repository_storage).to eq('default')
        expect(repository_storage_move).to be_failed
        expect(repository_storage_move.error_message).to eq('Boom')
      end
    end

    context 'when the cleanup fails' do
      it 'sets the correct state' do
        expect(snippet_repository_double).to receive(:replicate)
          .with(snippet.repository.raw)
        expect(snippet_repository_double).to receive(:checksum)
          .and_return(checksum)
        expect(original_snippet_repository_double).to receive(:remove)
          .and_raise(Gitlab::Git::CommandError)

        expect do
          subject.execute
        end.to raise_error(Gitlab::Git::CommandError)

        expect(repository_storage_move).to be_cleanup_failed
      end
    end

    context 'when the checksum does not match' do
      it 'unmarks the repository as read-only without updating the repository storage' do
        expect(snippet_repository_double).to receive(:replicate)
          .with(snippet.repository.raw)
        expect(snippet_repository_double).to receive(:checksum)
          .and_return('not matching checksum')
        expect(snippet_repository_double).to receive(:remove)

        expect do
          subject.execute
        end.to raise_error(Repositories::ReplicateService::Error, /Failed to verify snippet repository checksum from \w+ to not matching checksum/)

        expect(snippet).not_to be_repository_read_only
        expect(snippet.repository_storage).to eq('default')
      end
    end

    context 'when the repository move is finished' do
      let(:repository_storage_move_state) { :finished }

      it 'is idempotent' do
        expect do
          result = subject.execute

          expect(result).to be_success
        end.not_to change(repository_storage_move, :state)
      end
    end

    context 'when the repository move is failed' do
      let(:repository_storage_move_state) { :failed }

      it 'is idempotent' do
        expect do
          result = subject.execute

          expect(result).to be_success
        end.not_to change(repository_storage_move, :state)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Snippets
  class RepositoryValidationService
    attr_reader :current_user, :snippet, :repository

    RepositoryValidationError = Class.new(StandardError)

    def initialize(user, snippet)
      @current_user = user
      @snippet = snippet
      @repository = snippet.repository
    end

    def execute
      if snippet.nil?
        return service_response_error('No snippet found.', 404)
      end

      check_branch_count!
      check_branch_name_default!
      check_tag_count!
      check_file_count!
      check_size!

      ServiceResponse.success(message: 'Valid snippet repository.')
    rescue RepositoryValidationError => e
      ServiceResponse.error(message: ""Error: #{e.message}"", http_status: 400)
    end

    private

    def check_branch_count!
      return if repository.branch_count == 1

      raise RepositoryValidationError, _('Repository has more than one branch.')
    end

    def check_branch_name_default!
      branches = repository.branch_names

      return if branches.first == snippet.default_branch

      raise RepositoryValidationError, _('Repository has an invalid default branch name.')
    end

    def check_tag_count!
      return if repository.tag_count == 0

      raise RepositoryValidationError, _('Repository has tags.')
    end

    def check_file_count!
      file_count = repository.ls_files(snippet.default_branch).size
      limit = Snippet.max_file_limit

      if file_count > limit
        raise RepositoryValidationError, _('Repository files count over the limit')
      end

      if file_count == 0
        raise RepositoryValidationError, _('Repository must contain at least 1 file.')
      end
    end

    def check_size!
      return unless snippet.repository_size_checker.above_size_limit?

      raise RepositoryValidationError, _('Repository size is above the limit.')
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Snippets::RepositoryValidationService, feature_category: :source_code_management do
  describe '#execute' do
    let_it_be(:user)    { create(:user) }
    let_it_be(:snippet) { create(:personal_snippet, :empty_repo, author: user) }

    let(:repository)    { snippet.repository }
    let(:service)       { described_class.new(user, snippet) }

    subject { service.execute }

    before do
      allow(repository).to receive(:branch_count).and_return(1)
      allow(repository).to receive(:ls_files).and_return(['foo'])
      allow(repository).to receive(:branch_names).and_return(['master'])
    end

    it 'returns error when the repository has more than one branch' do
      allow(repository).to receive(:branch_count).and_return(2)

      expect(subject).to be_error
      expect(subject.message).to match /Repository has more than one branch/
    end

    it 'returns error when existing branch name is not the default one' do
      allow(repository).to receive(:branch_names).and_return(['foo'])

      expect(subject).to be_error
      expect(subject.message).to match /Repository has an invalid default branch name/
    end

    it 'returns error when the repository has tags' do
      allow(repository).to receive(:tag_count).and_return(1)

      expect(subject).to be_error
      expect(subject.message).to match /Repository has tags/
    end

    it 'returns error when the repository has more file than the limit' do
      limit = Snippet.max_file_limit + 1
      files = Array.new(limit) { FFaker::Filesystem.file_name }
      allow(repository).to receive(:ls_files).and_return(files)

      expect(subject).to be_error
      expect(subject.message).to match /Repository files count over the limit/
    end

    it 'returns error when the repository has no files' do
      allow(repository).to receive(:ls_files).and_return([])

      expect(subject).to be_error
      expect(subject.message).to match /Repository must contain at least 1 file/
    end

    it 'returns error when the repository size is over the limit' do
      expect_next_instance_of(Gitlab::RepositorySizeChecker) do |checker|
        expect(checker).to receive(:above_size_limit?).and_return(true)
      end

      expect(subject).to be_error
      expect(subject.message).to match /Repository size is above the limit/
    end

    it 'returns success when no validation errors are raised' do
      expect(subject).to be_success
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Snippets
  # Tries to schedule a move for every snippet with repositories on the source shard
  class ScheduleBulkRepositoryShardMovesService
    include ScheduleBulkRepositoryShardMovesMethods
    extend ::Gitlab::Utils::Override

    private

    override :repository_klass
    def repository_klass
      SnippetRepository
    end

    override :container_klass
    def container_klass
      Snippet
    end

    override :container_column
    def container_column
      :snippet_id
    end

    override :schedule_bulk_worker_klass
    def self.schedule_bulk_worker_klass
      ::Snippets::ScheduleBulkRepositoryShardMovesWorker
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Snippets::ScheduleBulkRepositoryShardMovesService, feature_category: :source_code_management do
  it_behaves_like 'moves repository shard in bulk' do
    let_it_be_with_reload(:container) { create(:snippet, :repository) }

    let(:move_service_klass) { Snippets::RepositoryStorageMove }
    let(:bulk_worker_klass) { ::Snippets::ScheduleBulkRepositoryShardMovesWorker }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Snippets
  class DestroyService
    include Gitlab::Allowable

    attr_reader :current_user, :snippet

    DestroyError = Class.new(StandardError)

    def initialize(user, snippet)
      @current_user = user
      @snippet = snippet
    end

    def execute
      if snippet.nil?
        return service_response_error('No snippet found.', 404)
      end

      unless user_can_delete_snippet?
        return service_response_error(
          ""You don't have access to delete this snippet."",
          403
        )
      end

      attempt_destroy!

      ServiceResponse.success(message: 'Snippet was deleted.')
    rescue DestroyError
      service_response_error('Failed to remove snippet repository.', 400)
    rescue StandardError
      service_response_error('Failed to remove snippet.', 400)
    end

    private

    def attempt_destroy!
      result = Repositories::DestroyService.new(snippet.repository).execute

      raise DestroyError if result[:status] == :error

      snippet.destroy!
    end

    def user_can_delete_snippet?
      can?(current_user, :admin_snippet, snippet)
    end

    def service_response_error(message, http_status)
      ServiceResponse.error(message: message, http_status: http_status)
    end
  end
end

Snippets::DestroyService.prepend_mod_with('Snippets::DestroyService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Snippets::DestroyService, feature_category: :source_code_management do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }
  let_it_be(:other_user) { create(:user) }

  describe '#execute' do
    subject { described_class.new(user, snippet).execute }

    context 'when snippet is nil' do
      let(:snippet) { nil }

      it 'returns a ServiceResponse error' do
        expect(subject).to be_error
      end
    end

    shared_examples 'a successful destroy' do
      it 'deletes the snippet' do
        expect { subject }.to change { Snippet.count }.by(-1)
      end

      it 'returns ServiceResponse success' do
        expect(subject).to be_success
      end
    end

    shared_examples 'an unsuccessful destroy' do
      it 'does not delete the snippet' do
        expect { subject }.not_to change { Snippet.count }
      end

      it 'returns ServiceResponse error' do
        expect(subject).to be_error
      end
    end

    shared_examples 'deletes the snippet repository' do
      it 'removes the snippet repository' do
        expect(snippet.repository.exists?).to be_truthy
        expect_next_instance_of(Repositories::DestroyService) do |instance|
          expect(instance).to receive(:execute).and_call_original
        end

        expect(subject).to be_success
      end

      context 'when the repository deletion service raises an error' do
        before do
          allow_next_instance_of(Repositories::DestroyService) do |instance|
            allow(instance).to receive(:execute).and_return({ status: :error })
          end
        end

        it_behaves_like 'an unsuccessful destroy'
      end

      context 'when a destroy error is raised' do
        before do
          allow(snippet).to receive(:destroy!).and_raise(ActiveRecord::ActiveRecordError)
        end

        it_behaves_like 'an unsuccessful destroy'
      end

      context 'when repository is nil' do
        it 'does not schedule anything and return success' do
          allow(snippet).to receive(:repository).and_return(nil)

          expect_next_instance_of(Repositories::DestroyService) do |instance|
            expect(instance).to receive(:execute).and_call_original
          end

          expect(subject).to be_success
        end
      end
    end

    context 'when ProjectSnippet' do
      let!(:snippet) { create(:project_snippet, :repository, project: project, author: author) }

      context 'when user is able to admin_project_snippet' do
        let(:author) { user }

        before do
          project.add_developer(user)
        end

        it_behaves_like 'a successful destroy'
        it_behaves_like 'deletes the snippet repository'

        context 'project statistics' do
          before do
            snippet.statistics.refresh!
          end

          it 'updates stats after deletion' do
            expect(project.reload.statistics.snippets_size).not_to be_zero

            subject

            expect(project.reload.statistics.snippets_size).to be_zero
          end

          it 'schedules a namespace statistics update' do
            expect(Namespaces::ScheduleAggregationWorker).to receive(:perform_async).with(project.namespace_id).once

            subject
          end
        end
      end

      context 'when user is not able to admin_project_snippet' do
        let(:author) { other_user }

        it_behaves_like 'an unsuccessful destroy'
      end
    end

    context 'when PersonalSnippet' do
      let!(:snippet) { create(:personal_snippet, :repository, author: author) }

      context 'when user is able to admin_personal_snippet' do
        let(:author) { user }

        it_behaves_like 'a successful destroy'
        it_behaves_like 'deletes the snippet repository'

        it 'schedules a namespace statistics update' do
          expect(Namespaces::ScheduleAggregationWorker).to receive(:perform_async).with(author.namespace_id)

          subject
        end
      end

      context 'when user is not able to admin_personal_snippet' do
        let(:author) { other_user }

        it_behaves_like 'an unsuccessful destroy'
      end
    end

    context 'when the repository does not exist' do
      let(:snippet) { create(:personal_snippet, author: user) }

      it 'does not schedule anything and return success' do
        expect(snippet.repository).not_to be_nil
        expect(snippet.repository.exists?).to be_falsey

        expect_next_instance_of(Repositories::DestroyService) do |instance|
          expect(instance).to receive(:execute).and_call_original
        end

        expect(subject).to be_success
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Snippets
  class UpdateService < Snippets::BaseService
    COMMITTABLE_ATTRIBUTES = %w[file_name content].freeze

    UpdateError = Class.new(StandardError)

    def initialize(project:, current_user: nil, params: {}, perform_spam_check: false)
      super(project: project, current_user: current_user, params: params)
      @perform_spam_check = perform_spam_check
    end

    def execute(snippet)
      return invalid_params_error(snippet) unless valid_params?

      if visibility_changed?(snippet) && !visibility_allowed?(visibility_level)
        return forbidden_visibility_error(snippet)
      end

      update_snippet_attributes(snippet)

      files = snippet.all_files.map { |f| { path: f } } + file_paths_to_commit

      if perform_spam_check
        snippet.check_for_spam(user: current_user, action: :update, extra_features: { files: files })
      end

      if save_and_commit(snippet)
        Gitlab::UsageDataCounters::SnippetCounter.count(:update)

        ServiceResponse.success(payload: { snippet: snippet })
      else
        snippet_error_response(snippet, 400)
      end
    end

    private

    attr_reader :perform_spam_check

    def visibility_changed?(snippet)
      visibility_level && visibility_level.to_i != snippet.visibility_level
    end

    def update_snippet_attributes(snippet)
      # We can remove the following condition once
      # https://gitlab.com/gitlab-org/gitlab/-/issues/217801
      # is implemented.
      # Once we can perform different operations through this service
      # we won't need to keep track of the `content` and `file_name` fields
      #
      # If the repository does not exist we don't need to update `params`
      # because we need to commit the information from the database
      if snippet_actions.any? && snippet.repository_exists?
        params[:content] = snippet_actions[0].content if snippet_actions[0].content
        params[:file_name] = snippet_actions[0].file_path
      end

      snippet.assign_attributes(params)
    end

    def save_and_commit(snippet)
      return false unless snippet.save

      # If the updated attributes does not need to update
      # the repository we can just return
      return true unless committable_attributes?

      unless snippet.repository_exists?
        create_repository_for(snippet)
        create_first_commit_using_db_data(snippet)
      end

      create_commit(snippet)

      true
    rescue StandardError => e
      # Restore old attributes but re-assign changes so they're not lost
      unless snippet.previous_changes.empty?
        snippet.previous_changes.each { |attr, value| snippet[attr] = value[0] }
        snippet.save

        snippet.assign_attributes(params)
      end

      add_snippet_repository_error(snippet: snippet, error: e)

      Gitlab::ErrorTracking.log_exception(e, service: 'Snippets::UpdateService')

      # If the commit action failed we remove it because
      # we don't want to leave empty repositories
      # around, to allow cloning them.
      delete_repository(snippet) if repository_empty?(snippet)

      false
    end

    def create_repository_for(snippet)
      snippet.create_repository

      raise CreateRepositoryError, 'Repository could not be created' unless snippet.repository_exists?
    end

    # If the user provides `snippet_actions` and the repository
    # does not exist, we need to commit first the snippet info stored
    # in the database.  Mostly because the content inside `snippet_actions`
    # would assume that the file is already in the repository.
    def create_first_commit_using_db_data(snippet)
      return if snippet_actions.empty?

      attrs = commit_attrs(snippet, INITIAL_COMMIT_MSG)
      actions = [{ file_path: snippet.file_name, content: snippet.content }]

      snippet.snippet_repository.multi_files_action(current_user, actions, **attrs)
    end

    def create_commit(snippet)
      raise UpdateError unless snippet.snippet_repository

      attrs = commit_attrs(snippet, UPDATE_COMMIT_MSG)

      snippet.snippet_repository.multi_files_action(current_user, files_to_commit(snippet), **attrs)
    end

    # Because we are removing repositories we don't want to remove
    # any existing repository with data. Therefore, we cannot
    # rely on cached methods for that check in order to avoid losing
    # data.
    def repository_empty?(snippet)
      snippet.repository._uncached_exists? && !snippet.repository._uncached_has_visible_content?
    end

    def committable_attributes?
      (params.stringify_keys.keys & COMMITTABLE_ATTRIBUTES).present? || snippet_actions.any?
    end

    def build_actions_from_params(snippet)
      file_name_on_repo = snippet.file_name_on_repo

      [{ previous_path: file_name_on_repo,
         file_path: params[:file_name] || file_name_on_repo,
         content: params[:content] }]
    end
  end
end

Snippets::UpdateService.prepend_mod_with('Snippets::UpdateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Snippets::UpdateService, feature_category: :source_code_management do
  describe '#execute', :aggregate_failures do
    let_it_be(:user) { create(:user) }
    let_it_be(:admin) { create :user, admin: true }

    let(:action) { :update }
    let(:visibility_level) { Gitlab::VisibilityLevel::PRIVATE }
    let(:base_opts) do
      {
        title: 'Test snippet',
        file_name: 'snippet.rb',
        content: 'puts ""hello world""',
        visibility_level: visibility_level
      }
    end

    let(:extra_opts) { {} }
    let(:options) { base_opts.merge(extra_opts) }
    let(:updater) { user }

    let(:service) { described_class.new(project: project, current_user: updater, params: options, perform_spam_check: true) }

    subject { service.execute(snippet) }

    shared_examples 'a service that updates a snippet' do
      it 'updates a snippet with the provided attributes' do
        expect { subject }.to change { snippet.title }.from(snippet.title).to(options[:title])
          .and change { snippet.file_name }.from(snippet.file_name).to(options[:file_name])
          .and change { snippet.content }.from(snippet.content).to(options[:content])
      end
    end

    shared_examples 'public visibility level restrictions apply' do
      let(:visibility_level) { Gitlab::VisibilityLevel::PUBLIC }

      before do
        stub_application_setting(restricted_visibility_levels: [Gitlab::VisibilityLevel::PUBLIC])
      end

      context 'when user is not an admin' do
        it 'responds with an error' do
          expect(subject).to be_error
        end

        it 'does not update snippet to public visibility' do
          original_visibility = snippet.visibility_level

          expect(subject.message).to match('has been restricted')
          expect(snippet.visibility_level).to eq(original_visibility)
        end
      end

      context 'when user is an admin' do
        let(:updater) { admin }

        it 'responds with success' do
          expect(subject).to be_success
        end

        it 'updates the snippet to public visibility' do
          old_visibility = snippet.visibility_level

          expect(subject.payload[:snippet]).not_to be_nil
          expect(snippet.visibility_level).not_to eq(old_visibility)
          expect(snippet.visibility_level).to eq(Gitlab::VisibilityLevel::PUBLIC)
        end
      end

      context 'when visibility level is passed as a string' do
        before do
          options[:visibility] = 'internal'
          options.delete(:visibility_level)
        end

        it 'assigns the correct visibility level' do
          expect(subject).to be_success
          expect(snippet.visibility_level).to eq(Gitlab::VisibilityLevel::INTERNAL)
        end
      end
    end

    shared_examples 'snippet update data is tracked' do
      let(:counter) { Gitlab::UsageDataCounters::SnippetCounter }

      it 'increments count when create succeeds' do
        expect { subject }.to change { counter.read(:update) }.by 1
      end

      context 'when update fails' do
        let(:extra_opts) { { title: '' } }

        it 'does not increment count' do
          expect { subject }.not_to change { counter.read(:update) }
        end
      end
    end

    shared_examples 'creates repository and creates file' do
      context 'when file_name and content params are used' do
        it 'creates repository' do
          expect(snippet.repository).not_to exist

          subject

          expect(snippet.repository).to exist
        end

        it 'commits the files to the repository' do
          subject

          expect(snippet.blobs.count).to eq 1

          blob = snippet.repository.blob_at('master', options[:file_name])

          expect(blob.data).to eq options[:content]
        end

        context 'when the repository creation fails' do
          before do
            allow(snippet).to receive(:repository_exists?).and_return(false)
          end

          it 'raise an error' do
            expect(subject).to be_error
            expect(subject.payload[:snippet].errors[:repository].to_sentence).to eq 'Error updating the snippet - Repository could not be created'
          end

          it 'does not try to commit file' do
            expect(service).not_to receive(:create_commit)

            subject
          end
        end
      end

      context 'when snippet_actions param is used' do
        let(:file_path) { 'CHANGELOG' }
        let(:created_file_path) { 'New file' }
        let(:content) { 'foobar' }
        let(:snippet_actions) { [{ action: :move, previous_path: snippet.file_name, file_path: file_path }, { action: :create, file_path: created_file_path, content: content }] }
        let(:base_opts) do
          {
            snippet_actions: snippet_actions
          }
        end

        it 'performs operation without raising errors' do
          db_content = snippet.content

          expect(subject).to be_success

          new_blob = snippet.repository.blob_at('master', file_path)
          created_file = snippet.repository.blob_at('master', created_file_path)

          expect(new_blob.data).to eq db_content
          expect(created_file.data).to eq content
        end

        context 'when the repository is not created' do
          it 'keeps snippet database data' do
            old_file_name = snippet.file_name
            old_file_content = snippet.content

            expect_next_instance_of(described_class) do |instance|
              expect(instance).to receive(:create_repository_for).and_raise(StandardError)
            end

            snippet = subject.payload[:snippet]

            expect(subject).to be_error
            expect(snippet.file_name).to eq(old_file_name)
            expect(snippet.content).to eq(old_file_content)
          end
        end
      end
    end

    shared_examples 'commit operation fails' do
      let_it_be(:gitlab_shell) { Gitlab::Shell.new }

      before do
        allow(service).to receive(:create_commit).and_raise(SnippetRepository::CommitError)
      end

      it 'returns error' do
        response = subject

        expect(response).to be_error
        expect(response.payload[:snippet].errors[:repository].to_sentence).to eq 'Error updating the snippet'
      end

      context 'when repository is empty' do
        before do
          allow(service).to receive(:repository_empty?).and_return(true)
        end

        it 'destroys the created repository in disk' do
          subject

          expect(gitlab_shell.repository_exists?(snippet.repository.storage, ""#{snippet.disk_path}.git"")).to be_falsey
        end

        it 'destroys the SnippetRepository object' do
          subject

          expect(snippet.reload.snippet_repository).to be_nil
        end

        it 'expires the repository exists method cache' do
          response = subject

          expect(response).to be_error
          expect(response.payload[:snippet].repository_exists?).to be_falsey
        end
      end

      context 'when repository is not empty' do
        before do
          allow(service).to receive(:repository_empty?).and_return(false)
        end

        it 'does not destroy the repository' do
          subject

          expect(gitlab_shell.repository_exists?(snippet.repository.storage, ""#{snippet.disk_path}.git"")).to be_truthy
        end

        it 'does not destroy the snippet repository' do
          subject

          expect(snippet.reload.snippet_repository).not_to be_nil
        end

        it 'expires the repository exists method cache' do
          response = subject

          expect(response).to be_error
          expect(response.payload[:snippet].repository_exists?).to be_truthy
        end
      end

      context 'with snippet modifications' do
        let(:option_keys) { options.stringify_keys.keys }

        it 'rolls back any snippet modifications' do
          orig_attrs = snippet.attributes.select { |k, v| k.in?(option_keys) }

          subject

          persisted_attrs = snippet.reload.attributes.select { |k, v| k.in?(option_keys) }
          expect(orig_attrs).to eq persisted_attrs
        end

        it 'keeps any snippet modifications' do
          subject

          instance_attrs = snippet.attributes.select { |k, v| k.in?(option_keys) }
          expect(options.stringify_keys).to eq instance_attrs
        end
      end
    end

    shared_examples 'updates repository content' do
      it 'commit the files to the repository' do
        blob = snippet.blobs.first
        options[:file_name] = blob.path + '_new'

        expect(blob.data).not_to eq(options[:content])

        subject

        blob = snippet.blobs.first

        expect(blob.path).to eq(options[:file_name])
        expect(blob.data).to eq(options[:content])
      end

      context 'when an error is raised' do
        let(:error) { SnippetRepository::CommitError.new('foobar') }

        before do
          allow(snippet.snippet_repository).to receive(:multi_files_action).and_raise(error)
        end

        it 'logs the error' do
          expect(Gitlab::ErrorTracking).to receive(:log_exception).with(error, service: 'Snippets::UpdateService')

          subject
        end

        it 'returns error with generic error message' do
          response = subject

          expect(response).to be_error
          expect(response.payload[:snippet].errors[:repository].to_sentence).to eq 'Error updating the snippet'
        end
      end

      it 'returns error if snippet does not have a snippet_repository' do
        allow(snippet).to receive(:snippet_repository).and_return(nil)
        allow(snippet).to receive(:track_snippet_repository).and_return(nil)

        expect(subject).to be_error
      end

      context 'when the repository does not exist' do
        it 'does not try to commit file' do
          allow(snippet).to receive(:repository_exists?).and_return(false)

          expect(service).not_to receive(:create_commit)

          subject
        end
      end
    end

    shared_examples 'committable attributes' do
      context 'when file_name is updated' do
        let(:extra_opts) { { file_name: 'snippet.rb' } }

        it 'commits to repository' do
          expect(service).to receive(:create_commit)
          expect(subject).to be_success
        end
      end

      context 'when content is updated' do
        let(:extra_opts) { { content: 'puts ""hello world""' } }

        it 'commits to repository' do
          expect(service).to receive(:create_commit)
          expect(subject).to be_success
        end
      end

      context 'when content or file_name is not updated' do
        let(:options) { { title: 'Test snippet' } }

        it 'does not perform any commit' do
          expect(service).not_to receive(:create_commit)
          expect(subject).to be_success
        end
      end
    end

    shared_examples 'when snippet_actions param is present' do
      let(:file_path) { 'CHANGELOG' }
      let(:content) { 'snippet_content' }
      let(:new_title) { 'New title' }
      let(:snippet_actions) { [{ action: 'update', previous_path: file_path, file_path: file_path, content: content }] }
      let(:base_opts) do
        {
          title: new_title,
          snippet_actions: snippet_actions
        }
      end

      it 'updates a snippet with the provided attributes' do
        file_path = 'foo'
        snippet_actions[0][:action] = 'move'
        snippet_actions[0][:file_path] = file_path

        response = subject
        snippet = response.payload[:snippet]

        expect(response).to be_success
        expect(snippet.title).to eq(new_title)
        expect(snippet.file_name).to eq(file_path)
        expect(snippet.content).to eq(content)
      end

      it 'commits the files to the repository' do
        subject

        blob = snippet.repository.blob_at('master', file_path)

        expect(blob.data).to eq content
      end

      context 'when content or file_name params are present' do
        let(:extra_opts) { { content: 'foo', file_name: 'path' } }

        it 'raises a validation error' do
          response = subject
          snippet = response.payload[:snippet]

          expect(response).to be_error
          expect(snippet.errors.full_messages_for(:content)).to eq ['Content and snippet files cannot be used together']
          expect(snippet.errors.full_messages_for(:file_name)).to eq ['File name and snippet files cannot be used together']
        end
      end

      context 'when snippet_file content is not present' do
        let(:snippet_actions) { [{ action: :move, previous_path: file_path, file_path: 'new_file_path' }] }

        it 'does not update snippet content' do
          content = snippet.content

          expect(subject).to be_success

          expect(snippet.reload.content).to eq content
        end
      end

      context 'when snippet_actions param is invalid' do
        let(:snippet_actions) { [{ action: 'invalid_action' }] }

        it 'raises a validation error' do
          snippet = subject.payload[:snippet]

          expect(subject).to be_error
          expect(snippet.errors.full_messages_for(:snippet_actions)).to eq ['Snippet actions have invalid data']
        end
      end

      context 'when an error is raised committing the file' do
        it 'keeps any snippet modifications' do
          expect_next_instance_of(described_class) do |instance|
            expect(instance).to receive(:create_commit).and_raise(StandardError)
          end

          snippet = subject.payload[:snippet]

          expect(subject).to be_error
          expect(snippet.title).to eq(new_title)
          expect(snippet.file_name).to eq(file_path)
          expect(snippet.content).to eq(content)
        end
      end

      context 'commit actions' do
        let(:new_path) { 'created_new_file' }
        let(:base_opts) { { snippet_actions: snippet_actions } }

        shared_examples 'returns an error' do |error_msg|
          specify do
            response = subject

            expect(response).to be_error
            expect(response.message).to eq error_msg
          end
        end

        context 'update action' do
          let(:snippet_actions) { [{ action: :update, file_path: file_path, content: content }] }

          it 'updates the file content' do
            expect(subject).to be_success

            blob = blob(file_path)

            expect(blob.data).to eq content
          end

          context 'when previous_path is present' do
            let(:snippet_actions) { [{ action: :update, previous_path: file_path, file_path: file_path, content: content }] }

            it 'updates the file content' do
              expect(subject).to be_success

              blob = blob(file_path)

              expect(blob.data).to eq content
            end
          end

          context 'when content is not present' do
            let(:snippet_actions) { [{ action: :update, file_path: file_path }] }

            it_behaves_like 'returns an error', 'Snippet actions have invalid data'
          end

          context 'when file_path does not exist' do
            let(:snippet_actions) { [{ action: :update, file_path: 'makeup_name', content: content }] }

            it_behaves_like 'returns an error', 'Repository Error updating the snippet'
          end
        end

        context 'move action' do
          context 'when file_path and previous_path are the same' do
            let(:snippet_actions) { [{ action: :move, previous_path: file_path, file_path: file_path }] }

            it_behaves_like 'returns an error', 'Snippet actions have invalid data'
          end

          context 'when file_path and previous_path are different' do
            let(:snippet_actions) { [{ action: :move, previous_path: file_path, file_path: new_path }] }

            it 'renames the file' do
              old_blob = blob(file_path)

              expect(subject).to be_success

              blob = blob(new_path)

              expect(blob).to be_present
              expect(blob.data).to eq old_blob.data
            end
          end

          context 'when previous_path does not exist' do
            let(:snippet_actions) { [{ action: :move, previous_path: 'makeup_name', file_path: new_path }] }

            it_behaves_like 'returns an error', 'Repository Error updating the snippet'
          end

          context 'when user wants to rename the file and update content' do
            let(:snippet_actions) { [{ action: :move, previous_path: file_path, file_path: new_path, content: content }] }

            it 'performs both operations' do
              expect(subject).to be_success

              blob = blob(new_path)

              expect(blob).to be_present
              expect(blob.data).to eq content
            end
          end

          context 'when the file_path is not present' do
            let(:snippet_actions) { [{ action: :move, previous_path: file_path }] }

            it 'generates the name for the renamed file' do
              old_blob = blob(file_path)

              expect(blob('snippetfile1.txt')).to be_nil
              expect(subject).to be_success

              new_blob = blob('snippetfile1.txt')

              expect(new_blob).to be_present
              expect(new_blob.data).to eq old_blob.data
            end
          end
        end

        context 'delete action' do
          let(:snippet_actions) { [{ action: :delete, file_path: file_path }] }

          shared_examples 'deletes the file' do
            specify do
              old_blob = blob(file_path)
              expect(old_blob).to be_present

              expect(subject).to be_success
              expect(blob(file_path)).to be_nil
            end
          end

          it_behaves_like 'deletes the file'

          context 'when previous_path is present and same as file_path' do
            let(:snippet_actions) { [{ action: :delete, previous_path: file_path, file_path: file_path }] }

            it_behaves_like 'deletes the file'
          end

          context 'when previous_path is present and is different from file_path' do
            let(:snippet_actions) { [{ action: :delete, previous_path: 'foo', file_path: file_path }] }

            it_behaves_like 'deletes the file'
          end

          context 'when content is present' do
            let(:snippet_actions) { [{ action: :delete, file_path: file_path, content: 'foo' }] }

            it_behaves_like 'deletes the file'
          end

          context 'when file_path does not exist' do
            let(:snippet_actions) { [{ action: :delete, file_path: 'makeup_name' }] }

            it_behaves_like 'returns an error', 'Repository Error updating the snippet'
          end
        end

        context 'create action' do
          let(:snippet_actions) { [{ action: :create, file_path: new_path, content: content }] }

          it 'creates the file' do
            expect(subject).to be_success

            blob = blob(new_path)
            expect(blob).to be_present
            expect(blob.data).to eq content
          end

          context 'when content is not present' do
            let(:snippet_actions) { [{ action: :create, file_path: new_path }] }

            it_behaves_like 'returns an error', 'Snippet actions have invalid data'
          end

          context 'when file_path is not present or empty' do
            let(:snippet_actions) { [{ action: :create, content: content }, { action: :create, file_path: '', content: content }] }

            it 'generates the file path for the files' do
              expect(blob('snippetfile1.txt')).to be_nil
              expect(blob('snippetfile2.txt')).to be_nil

              expect(subject).to be_success

              expect(blob('snippetfile1.txt').data).to eq content
              expect(blob('snippetfile2.txt').data).to eq content
            end
          end

          context 'when file_path already exists in the repository' do
            let(:snippet_actions) { [{ action: :create, file_path: file_path, content: content }] }

            it_behaves_like 'returns an error', 'Repository Error updating the snippet'
          end

          context 'when previous_path is present' do
            let(:snippet_actions) { [{ action: :create, previous_path: 'foo', file_path: new_path, content: content }] }

            it 'creates the file' do
              expect(subject).to be_success

              blob = blob(new_path)
              expect(blob).to be_present
              expect(blob.data).to eq content
            end
          end
        end

        context 'combination of actions' do
          let(:delete_file_path) { 'CHANGELOG' }
          let(:create_file_path) { 'created_new_file' }
          let(:update_file_path) { 'LICENSE' }
          let(:move_previous_path) { 'VERSION' }
          let(:move_file_path) { 'VERSION_new' }

          let(:snippet_actions) do
            [
              { action: :create, file_path: create_file_path, content: content },
              { action: :update, file_path: update_file_path, content: content },
              { action: :delete, file_path: delete_file_path },
              { action: :move, previous_path: move_previous_path, file_path: move_file_path, content: content }
            ]
          end

          it 'performs all operations' do
            expect(subject).to be_success

            expect(blob(delete_file_path)).to be_nil

            created_blob = blob(create_file_path)
            expect(created_blob.data).to eq content

            updated_blob = blob(update_file_path)
            expect(updated_blob.data).to eq content

            expect(blob(move_previous_path)).to be_nil

            moved_blob = blob(move_file_path)
            expect(moved_blob.data).to eq content
          end
        end

        def blob(path)
          snippet.repository.blob_at('master', path)
        end
      end
    end

    shared_examples 'only file_name is present' do
      let(:base_opts) do
        {
          file_name: file_name
        }
      end

      shared_examples 'content is not updated' do
        specify do
          existing_content = snippet.blobs.first.data
          response = subject
          snippet = response.payload[:snippet]

          blob = snippet.repository.blob_at('master', file_name)

          expect(blob).not_to be_nil
          expect(response).to be_success
          expect(blob.data).to eq existing_content
        end
      end

      context 'when renaming the file_name' do
        let(:file_name) { 'new_file_name' }

        it_behaves_like 'content is not updated'
      end

      context 'when file_name does not change' do
        let(:file_name) { snippet.blobs.first.path }

        it_behaves_like 'content is not updated'
      end
    end

    shared_examples 'only content is present' do
      let(:content) { 'new_content' }
      let(:base_opts) do
        {
          content: content
        }
      end

      it 'updates the content' do
        response = subject
        snippet = response.payload[:snippet]

        blob = snippet.repository.blob_at('master', snippet.blobs.first.path)

        expect(blob).not_to be_nil
        expect(response).to be_success
        expect(blob.data).to eq content
      end
    end

    context 'when Project Snippet' do
      let_it_be(:project) { create(:project) }

      let!(:snippet) { create(:project_snippet, :repository, author: user, project: project) }

      before do
        project.add_developer(user)
      end

      it_behaves_like 'a service that updates a snippet'
      it_behaves_like 'public visibility level restrictions apply'
      it_behaves_like 'snippet update data is tracked'
      it_behaves_like 'updates repository content'
      it_behaves_like 'commit operation fails'
      it_behaves_like 'committable attributes'
      it_behaves_like 'when snippet_actions param is present'
      it_behaves_like 'only file_name is present'
      it_behaves_like 'only content is present'
      it_behaves_like 'invalid params error response'
      it_behaves_like 'checking spam'

      context 'when snippet does not have a repository' do
        let!(:snippet) { create(:project_snippet, author: user, project: project) }

        it_behaves_like 'creates repository and creates file'
        it_behaves_like 'commit operation fails'
      end
    end

    context 'when PersonalSnippet' do
      let(:project) { nil }
      let!(:snippet) { create(:personal_snippet, :repository, author: user) }

      it_behaves_like 'a service that updates a snippet'
      it_behaves_like 'public visibility level restrictions apply'
      it_behaves_like 'snippet update data is tracked'
      it_behaves_like 'updates repository content'
      it_behaves_like 'commit operation fails'
      it_behaves_like 'committable attributes'
      it_behaves_like 'when snippet_actions param is present'
      it_behaves_like 'only file_name is present'
      it_behaves_like 'only content is present'
      it_behaves_like 'invalid params error response'
      it_behaves_like 'checking spam'

      context 'when snippet does not have a repository' do
        let!(:snippet) { create(:personal_snippet, author: user, project: project) }

        it_behaves_like 'creates repository and creates file'
        it_behaves_like 'commit operation fails'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Snippets
  class BulkDestroyService
    include Gitlab::Allowable

    attr_reader :current_user, :snippets

    DeleteRepositoryError = Class.new(StandardError)
    SnippetAccessError = Class.new(StandardError)

    def initialize(user, snippets)
      @current_user = user
      @snippets = snippets
    end

    def execute(skip_authorization: false)
      return ServiceResponse.success(message: 'No snippets found.') if snippets.empty?

      user_can_delete_snippets! unless skip_authorization
      attempt_delete_repositories!
      snippets.destroy_all # rubocop: disable Cop/DestroyAll

      ServiceResponse.success(message: 'Snippets were deleted.')
    rescue SnippetAccessError
      service_response_error(""You don't have access to delete these snippets."", 403)
    rescue DeleteRepositoryError
      service_response_error('Failed to delete snippet repositories.', 400)
    rescue StandardError
      # In case the delete operation fails
      service_response_error('Failed to remove snippets.', 400)
    end

    private

    def user_can_delete_snippets!
      allowed = DeclarativePolicy.user_scope do
        snippets.find_each.all? { |snippet| user_can_delete_snippet?(snippet) }
      end

      raise SnippetAccessError unless allowed
    end

    def user_can_delete_snippet?(snippet)
      can?(current_user, :admin_snippet, snippet)
    end

    def attempt_delete_repositories!
      snippets.each do |snippet|
        result = Repositories::DestroyService.new(snippet.repository).execute

        raise DeleteRepositoryError if result[:status] == :error
      end
    end

    def service_response_error(message, http_status)
      ServiceResponse.error(message: message, http_status: http_status)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Snippets::BulkDestroyService, feature_category: :source_code_management do
  let_it_be(:project) { create(:project) }

  let(:user) { create(:user) }
  let!(:personal_snippet) { create(:personal_snippet, :repository, author: user) }
  let!(:project_snippet) { create(:project_snippet, :repository, project: project, author: user) }
  let(:snippets) { user.snippets }
  let(:gitlab_shell) { Gitlab::Shell.new }
  let(:service_user) { user }

  before do
    project.add_developer(user)
  end

  subject { described_class.new(service_user, snippets) }

  describe '#execute' do
    it 'deletes the snippets in bulk' do
      response = nil

      expect(Repositories::DestroyService).to receive(:new).with(personal_snippet.repository).and_call_original
      expect(Repositories::DestroyService).to receive(:new).with(project_snippet.repository).and_call_original

      aggregate_failures do
        expect do
          response = subject.execute
        end.to change(Snippet, :count).by(-2)

        expect(response).to be_success
        expect(repository_exists?(personal_snippet)).to be_falsey
        expect(repository_exists?(project_snippet)).to be_falsey
      end
    end

    context 'when snippets is empty' do
      let(:snippets) { Snippet.none }

      it 'returns a ServiceResponse success response' do
        response = subject.execute

        expect(response).to be_success
        expect(response.message).to eq 'No snippets found.'
      end
    end

    shared_examples 'error is raised' do
      it 'returns error' do
        response = subject.execute

        aggregate_failures do
          expect(response).to be_error
          expect(response.message).to eq error_message
        end
      end

      it 'no record is deleted' do
        expect do
          subject.execute
        end.not_to change(Snippet, :count)
      end
    end

    context 'when user does not have access to remove the snippet' do
      let(:service_user) { create(:user) }

      it_behaves_like 'error is raised' do
        let(:error_message) { ""You don't have access to delete these snippets."" }
      end

      context 'when skip_authorization option is passed' do
        subject { described_class.new(service_user, snippets).execute(skip_authorization: true) }

        it 'returns a ServiceResponse success response' do
          expect(subject).to be_success
        end

        it 'deletes all the snippets that belong to the user' do
          expect { subject }.to change(Snippet, :count).by(-2)
        end
      end
    end

    context 'when an error is raised deleting the repository' do
      before do
        allow_next_instance_of(Repositories::DestroyService) do |instance|
          allow(instance).to receive(:execute).and_return({ status: :error })
        end
      end

      it_behaves_like 'error is raised' do
        let(:error_message) { 'Failed to delete snippet repositories.' }
      end
    end

    context 'when an error is raised deleting the records' do
      before do
        allow(snippets).to receive(:destroy_all).and_raise(ActiveRecord::ActiveRecordError)
      end

      it_behaves_like 'error is raised' do
        let(:error_message) { 'Failed to remove snippets.' }
      end
    end

    context 'when snippet does not have a repository attached' do
      let!(:snippet_without_repo) { create(:personal_snippet, author: user) }

      it 'returns success' do
        response = nil

        expect(Repositories::DestroyService).to receive(:new).with(personal_snippet.repository).and_call_original
        expect(Repositories::DestroyService).to receive(:new).with(project_snippet.repository).and_call_original
        expect(Repositories::DestroyService).to receive(:new).with(snippet_without_repo.repository).and_call_original

        expect do
          response = subject.execute
        end.to change(Snippet, :count).by(-3)

        expect(response).to be_success
      end
    end
  end

  def repository_exists?(snippet, path = snippet.disk_path + "".git"")
    gitlab_shell.repository_exists?(snippet.snippet_repository.shard_name, path)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Snippets
  class UpdateStatisticsService
    attr_reader :snippet

    def initialize(snippet)
      @snippet = snippet
    end

    def execute
      unless snippet.repository_exists?
        return ServiceResponse.error(message: 'Invalid snippet repository', http_status: 400)
      end

      snippet.repository.expire_statistics_caches
      statistics.refresh!

      ServiceResponse.success(message: 'Snippet statistics successfully updated.')
    end

    private

    def statistics
      @statistics ||= snippet.statistics || snippet.build_statistics
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Snippets::UpdateStatisticsService, feature_category: :source_code_management do
  describe '#execute' do
    subject { described_class.new(snippet).execute }

    shared_examples 'updates statistics' do
      it 'returns a successful response' do
        expect(subject).to be_success
      end

      it 'expires statistics cache' do
        expect(snippet.repository).to receive(:expire_statistics_caches)

        subject
      end

      context 'when snippet statistics does not exist' do
        it 'creates snippet statistics' do
          snippet.statistics.delete
          snippet.reload

          expect do
            subject
          end.to change(SnippetStatistics, :count).by(1)

          expect(snippet.statistics.commit_count).not_to be_zero
          expect(snippet.statistics.file_count).not_to be_zero
          expect(snippet.statistics.repository_size).not_to be_zero
        end
      end

      context 'when snippet statistics exists' do
        it 'updates snippet statistics' do
          expect(snippet.statistics.commit_count).to be_zero
          expect(snippet.statistics.file_count).to be_zero
          expect(snippet.statistics.repository_size).to be_zero

          subject

          expect(snippet.statistics.commit_count).not_to be_zero
          expect(snippet.statistics.file_count).not_to be_zero
          expect(snippet.statistics.repository_size).not_to be_zero
        end
      end

      context 'when snippet does not have a repository' do
        it 'returns an error response' do
          expect(snippet).to receive(:repository_exists?).and_return(false)

          expect(subject).to be_error
        end
      end

      it 'schedules a namespace storage statistics update' do
        expect(Namespaces::ScheduleAggregationWorker)
            .to receive(:perform_async).once

        subject
      end
    end

    context 'with PersonalSnippet' do
      let!(:snippet) { create(:personal_snippet, :repository) }

      it_behaves_like 'updates statistics'
    end

    context 'with ProjectSnippet' do
      let!(:snippet) { create(:project_snippet, :repository) }
      let(:project_statistics) { snippet.project.statistics }

      it_behaves_like 'updates statistics'

      it 'updates projects statistics ""snippets_size""' do
        expect(project_statistics.snippets_size).to be_zero

        subject

        expect(snippet.reload.statistics.repository_size).to eq project_statistics.reload.snippets_size
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Service for calculating visible Snippet counts via one query
# for the given user or project.
#
# Authorisation level checks will be included, ensuring the correct
# counts will be returned for the given user (if any).
#
# Basic usage:
#
#   user = User.find(1)
#
#   Snippets::CountService.new(user, author: user).execute
#   #=> {
#     are_public: 1,
#     are_internal: 1,
#     are_private: 1,
#     all: 3
#   }
#
# Counts can be scoped to a project:
#
#   user = User.find(1)
#   project = Project.find(1)
#
#   Snippets::CountService.new(user, project: project).execute
#   #=> {
#     are_public: 1,
#     are_internal: 1,
#     are_private: 0,
#     all: 2
#   }
#
# Either a project or an author *must* be supplied.
module Snippets
  class CountService
    def initialize(current_user, author: nil, project: nil)
      if !author && !project
        raise(
          ArgumentError, 'Must provide either an author or a project'
        )
      end

      @snippets_finder = SnippetsFinder.new(current_user, author: author, project: project)
    end

    def execute
      counts = snippet_counts
      return {} unless counts

      counts.slice(
        :are_public,
        :are_private,
        :are_internal,
        :are_public_or_internal,
        :total
      )
    end

    private

    # rubocop: disable CodeReuse/ActiveRecord
    def snippet_counts
      @snippets_finder.execute
        .reorder(nil)
        .select(""
          count(case when snippets.visibility_level=#{Snippet::PUBLIC} and snippets.secret is FALSE then 1 else null end) as are_public,
          count(case when snippets.visibility_level=#{Snippet::INTERNAL} then 1 else null end) as are_internal,
          count(case when snippets.visibility_level=#{Snippet::PRIVATE} then 1 else null end) as are_private,
          count(case when visibility_level=#{Snippet::PUBLIC} OR visibility_level=#{Snippet::INTERNAL} then 1 else null end) as are_public_or_internal,
          count(*) as total
        "")
        .take
    end
    # rubocop: enable CodeReuse/ActiveRecord
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Snippets::CountService, feature_category: :source_code_management do
  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project, :public) }

  describe '#new' do
    it 'raises an error if no author or project' do
      expect { described_class.new(user) }.to raise_error(ArgumentError)
    end

    it 'uses the SnippetsFinder to scope snippets by user' do
      expect(SnippetsFinder)
        .to receive(:new)
        .with(user, author: user, project: nil)

      described_class.new(user, author: user)
    end

    it 'allows scoping to project' do
      expect(SnippetsFinder)
        .to receive(:new)
        .with(user, author: nil, project: project)

      described_class.new(user, project: project)
    end
  end

  describe '#execute' do
    subject { described_class.new(user, author: user).execute }

    it 'returns a hash of counts' do
      expect(subject).to match({
        are_public: 0,
        are_internal: 0,
        are_private: 0,
        are_public_or_internal: 0,
        total: 0
      })
    end

    it 'only counts snippets the user has access to' do
      create(:personal_snippet, :private, author: user)
      create(:project_snippet, :private, author: user)
      create(:project_snippet, :private, author: create(:user))

      expect(subject).to match({
        are_public: 0,
        are_internal: 0,
        are_private: 1,
        are_public_or_internal: 0,
        total: 1
      })
    end

    it 'returns an empty hash if select returns nil' do
      allow_next_instance_of(described_class) do |instance|
        allow(instance).to receive(:snippet_counts).and_return(nil)
      end

      expect(subject).to match({})
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Snippets
  class CreateService < Snippets::BaseService
    def initialize(project:, current_user: nil, params: {}, perform_spam_check: true)
      super(project: project, current_user: current_user, params: params)
      @perform_spam_check = perform_spam_check
    end

    def execute
      @snippet = build_from_params

      return invalid_params_error(@snippet) unless valid_params?

      unless visibility_allowed?(snippet.visibility_level)
        return forbidden_visibility_error(snippet)
      end

      @snippet.author = current_user

      if perform_spam_check
        @snippet.check_for_spam(user: current_user, action: :create, extra_features: { files: file_paths_to_commit })
      end

      if save_and_commit
        UserAgentDetailService.new(spammable: @snippet, perform_spam_check: perform_spam_check).create
        Gitlab::UsageDataCounters::SnippetCounter.count(:create)

        move_temporary_files

        ServiceResponse.success(payload: { snippet: @snippet })
      else
        snippet_error_response(@snippet, 400)
      end
    end

    private

    attr_reader :snippet, :perform_spam_check

    def build_from_params
      if project
        project.snippets.build(create_params)
      else
        PersonalSnippet.new(create_params)
      end
    end

    # If the snippet_actions param is present
    # we need to fill content and file_name from
    # the model
    def create_params
      return params if snippet_actions.empty?

      params.merge(content: snippet_actions[0].content, file_name: snippet_actions[0].file_path)
    end

    def save_and_commit
      snippet_saved = @snippet.save

      if snippet_saved
        create_repository
        create_commit
      end

      snippet_saved
    rescue StandardError => e # Rescuing all because we can receive Creation exceptions, GRPC exceptions, Git exceptions, ...
      Gitlab::ErrorTracking.log_exception(e, service: 'Snippets::CreateService')

      # If the commit action failed we need to remove the repository if exists
      delete_repository(@snippet) if @snippet.repository_exists?

      # If the snippet was created, we need to remove it as we
      # would do like if it had had any validation error
      # and reassign a dupe so we don't return the deleted snippet
      if @snippet.persisted?
        @snippet.delete
        @snippet = @snippet.dup
      end

      add_snippet_repository_error(snippet: @snippet, error: e)

      false
    end

    def create_repository
      @snippet.create_repository

      raise CreateRepositoryError, 'Repository could not be created' unless @snippet.repository_exists?
    end

    def create_commit
      attrs = commit_attrs(@snippet, INITIAL_COMMIT_MSG)

      @snippet.snippet_repository.multi_files_action(current_user, files_to_commit(@snippet), **attrs)
    end

    def move_temporary_files
      return unless @snippet.is_a?(PersonalSnippet)

      uploaded_assets.each do |file|
        FileMover.new(file, from_model: current_user, to_model: @snippet).execute
      end
    end

    def build_actions_from_params(_snippet)
      [{ file_path: params[:file_name], content: params[:content] }]
    end

    def restricted_files_actions
      :create
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Snippets::CreateService, feature_category: :source_code_management do
  describe '#execute' do
    let_it_be(:user) { create(:user) }
    let_it_be(:admin) { create(:user, :admin) }

    let(:action) { :create }
    let(:opts) { base_opts.merge(extra_opts) }
    let(:base_opts) do
      {
        title: 'Test snippet',
        file_name: 'snippet.rb',
        content: 'puts ""hello world""',
        visibility_level: Gitlab::VisibilityLevel::PRIVATE
      }
    end

    let(:extra_opts) { {} }
    let(:creator) { admin }

    subject { described_class.new(project: project, current_user: creator, params: opts).execute }

    let(:snippet) { subject.payload[:snippet] }

    shared_examples 'a service that creates a snippet' do
      it 'creates a snippet with the provided attributes' do
        expect(snippet.title).to eq(opts[:title])
        expect(snippet.file_name).to eq(opts[:file_name])
        expect(snippet.content).to eq(opts[:content])
        expect(snippet.visibility_level).to eq(opts[:visibility_level])
      end
    end

    shared_examples 'public visibility level restrictions apply' do
      let(:extra_opts) { { visibility_level: Gitlab::VisibilityLevel::PUBLIC } }

      before do
        stub_application_setting(restricted_visibility_levels: [Gitlab::VisibilityLevel::PUBLIC])
      end

      context 'when user is not an admin' do
        let(:creator) { user }

        it 'responds with an error' do
          expect(subject).to be_error
        end

        it 'does not create a public snippet' do
          expect(subject.message).to match('has been restricted')
        end
      end

      context 'when user is an admin' do
        it 'responds with success' do
          expect(subject).to be_success
        end

        it 'creates a public snippet' do
          expect(snippet.visibility_level).to eq(Gitlab::VisibilityLevel::PUBLIC)
        end
      end

      describe 'when visibility level is passed as a string' do
        let(:extra_opts) { { visibility: 'internal' } }

        before do
          base_opts.delete(:visibility_level)
        end

        it 'assigns the correct visibility level' do
          expect(subject).to be_success
          expect(snippet.visibility_level).to eq(Gitlab::VisibilityLevel::INTERNAL)
        end
      end
    end

    shared_examples 'snippet create data is tracked' do
      let(:counter) { Gitlab::UsageDataCounters::SnippetCounter }

      it 'increments count when create succeeds' do
        expect { subject }.to change { counter.read(:create) }.by 1
      end

      context 'when create fails' do
        let(:opts) { {} }

        it 'does not increment count' do
          expect { subject }.not_to change { counter.read(:create) }
        end
      end
    end

    shared_examples 'an error service response when save fails' do
      let(:extra_opts) { { content: nil } }

      it 'responds with an error' do
        expect(subject).to be_error
      end

      it 'does not create the snippet' do
        expect { subject }.not_to change { Snippet.count }
      end
    end

    shared_examples 'creates repository and files' do
      it 'creates repository' do
        subject

        expect(snippet.repository.exists?).to be_truthy
      end

      it 'commits the files to the repository' do
        subject

        blob = snippet.repository.blob_at('master', base_opts[:file_name])

        expect(blob.data).to eq base_opts[:content]
      end

      context 'when repository creation action fails' do
        before do
          allow_next_instance_of(Snippet) do |instance|
            allow(instance).to receive(:create_repository).and_return(nil)
          end
        end

        it 'does not create the snippet' do
          expect { subject }.not_to change { Snippet.count }
        end

        it 'returns a generic creation error' do
          expect(snippet.errors[:repository]).to eq ['Error creating the snippet - Repository could not be created']
        end

        it 'does not return a snippet with an id' do
          expect(snippet.id).to be_nil
        end
      end

      context 'when repository creation fails with invalid file name' do
        let(:extra_opts) { { file_name: 'invalid://file/name/here' } }

        it 'returns an appropriate error' do
          expect(snippet.errors[:repository]).to eq ['Error creating the snippet - Invalid file name']
        end
      end

      context 'when the commit action fails' do
        let(:error) { SnippetRepository::CommitError.new('foobar') }

        before do
          allow_next_instance_of(SnippetRepository) do |instance|
            allow(instance).to receive(:multi_files_action).and_raise(error)
          end
        end

        it 'does not create the snippet' do
          expect { subject }.not_to change { Snippet.count }
        end

        it 'destroys the created repository' do
          expect_next_instance_of(Repository) do |instance|
            expect(instance).to receive(:remove).and_call_original
          end

          subject
        end

        it 'destroys the snippet_repository' do
          subject

          expect(SnippetRepository.count).to be_zero
        end

        it 'logs the error' do
          expect(Gitlab::ErrorTracking).to receive(:log_exception).with(error, service: 'Snippets::CreateService')

          subject
        end

        it 'returns a generic error' do
          expect(subject).to be_error
          expect(snippet.errors[:repository]).to eq ['Error creating the snippet']
        end
      end

      context 'when snippet creation fails' do
        let(:extra_opts) { { content: nil } }

        it 'does not create repository' do
          expect do
            subject
          end.not_to change(Snippet, :count)

          expect(snippet.repository_exists?).to be_falsey
        end
      end
    end

    shared_examples 'after_save callback to store_mentions' do |mentionable_class|
      context 'when mentionable attributes change' do
        let(:extra_opts) { { description: ""Description with #{user.to_reference}"" } }

        it 'saves mentions' do
          expect_next_instance_of(mentionable_class) do |instance|
            expect(instance).to receive(:store_mentions!).and_call_original
          end
          expect(snippet.user_mentions.count).to eq 1
        end
      end

      context 'when mentionable attributes do not change' do
        it 'does not call store_mentions' do
          expect_next_instance_of(mentionable_class) do |instance|
            expect(instance).not_to receive(:store_mentions!)
          end
          expect(snippet.user_mentions.count).to eq 0
        end
      end

      context 'when save fails' do
        it 'does not call store_mentions' do
          base_opts.delete(:title)

          expect_next_instance_of(mentionable_class) do |instance|
            expect(instance).not_to receive(:store_mentions!)
          end
          expect(snippet.valid?).to be false
        end
      end
    end

    shared_examples 'when snippet_actions param is present' do
      let(:file_path) { 'snippet_file_path.rb' }
      let(:content) { 'snippet_content' }
      let(:snippet_actions) { [{ action: 'create', file_path: file_path, content: content }] }
      let(:base_opts) do
        {
          title: 'Test snippet',
          visibility_level: Gitlab::VisibilityLevel::PRIVATE,
          snippet_actions: snippet_actions
        }
      end

      it 'creates a snippet with the provided attributes' do
        expect(snippet.title).to eq(opts[:title])
        expect(snippet.visibility_level).to eq(opts[:visibility_level])
        expect(snippet.file_name).to eq(file_path)
        expect(snippet.content).to eq(content)
      end

      it 'commit the files to the repository' do
        expect(subject).to be_success

        blob = snippet.repository.blob_at('master', file_path)

        expect(blob.data).to eq content
      end

      context 'when content or file_name params are present' do
        let(:extra_opts) { { content: 'foo', file_name: 'path' } }

        it 'a validation error is raised' do
          expect(subject).to be_error
          expect(snippet.errors.full_messages_for(:content)).to eq ['Content and snippet files cannot be used together']
          expect(snippet.errors.full_messages_for(:file_name)).to eq ['File name and snippet files cannot be used together']
          expect(snippet.repository.exists?).to be_falsey
        end
      end

      context 'when snippet_actions param is invalid' do
        let(:snippet_actions) { [{ action: 'invalid_action', file_path: 'snippet_file_path.rb', content: 'snippet_content' }] }

        it 'a validation error is raised' do
          expect(subject).to be_error
          expect(snippet.errors.full_messages_for(:snippet_actions)).to eq ['Snippet actions have invalid data']
          expect(snippet.repository.exists?).to be_falsey
        end
      end

      context 'when snippet_actions contain an action different from ""create""' do
        let(:snippet_actions) { [{ action: 'delete', file_path: 'snippet_file_path.rb' }] }

        it 'a validation error is raised' do
          expect(subject).to be_error
          expect(snippet.errors.full_messages_for(:snippet_actions)).to eq ['Snippet actions have invalid data']
          expect(snippet.repository.exists?).to be_falsey
        end
      end

      context 'when ""create"" operation does not have file_path or is empty' do
        let(:snippet_actions) { [{ action: 'create', content: content }, { action: 'create', content: content, file_path: '' }] }

        it 'generates the file path for the files' do
          expect(subject).to be_success
          expect(snippet.repository.blob_at('master', 'snippetfile1.txt').data).to eq content
          expect(snippet.repository.blob_at('master', 'snippetfile2.txt').data).to eq content
        end
      end
    end

    context 'when ProjectSnippet' do
      let_it_be(:project) { create(:project) }

      before do
        project.add_developer(user)
      end

      it_behaves_like 'a service that creates a snippet'
      it_behaves_like 'public visibility level restrictions apply'
      it_behaves_like 'checking spam'
      it_behaves_like 'snippet create data is tracked'
      it_behaves_like 'an error service response when save fails'
      it_behaves_like 'creates repository and files'
      it_behaves_like 'after_save callback to store_mentions', ProjectSnippet
      it_behaves_like 'when snippet_actions param is present'
      it_behaves_like 'invalid params error response'

      context 'when uploaded files are passed to the service' do
        let(:extra_opts) { { files: ['foo'] } }

        it 'does not move uploaded files to the snippet' do
          expect_next_instance_of(described_class) do |instance|
            expect(instance).to receive(:move_temporary_files).and_call_original
          end

          expect_any_instance_of(FileMover).not_to receive(:execute)

          subject
        end
      end
    end

    context 'when PersonalSnippet' do
      let(:project) { nil }

      it_behaves_like 'a service that creates a snippet'
      it_behaves_like 'public visibility level restrictions apply'
      it_behaves_like 'checking spam'
      it_behaves_like 'snippet create data is tracked'
      it_behaves_like 'an error service response when save fails'
      it_behaves_like 'creates repository and files'
      it_behaves_like 'after_save callback to store_mentions', PersonalSnippet
      it_behaves_like 'when snippet_actions param is present'
      it_behaves_like 'invalid params error response'

      context 'when the snippet description contains files' do
        include FileMoverHelpers

        let(:title) { 'Title' }
        let(:picture_secret) { SecureRandom.hex }
        let(:text_secret) { SecureRandom.hex }
        let(:picture_file) { ""/-/system/user/#{creator.id}/#{picture_secret}/picture.jpg"" }
        let(:text_file) { ""/-/system/user/#{creator.id}/#{text_secret}/text.txt"" }
        let(:files) { [picture_file, text_file] }
        let(:description) do
          ""Description with picture: ![picture](/uploads#{picture_file}) and ""\
          ""text: [text.txt](/uploads#{text_file})""
        end

        before do
          allow(FileUtils).to receive(:mkdir_p)
          allow(FileUtils).to receive(:move)
        end

        let(:extra_opts) { { description: description, title: title, files: files } }

        it 'stores the snippet description correctly' do
          stub_file_mover(text_file)
          stub_file_mover(picture_file)

          snippet = subject.payload[:snippet]

          expected_description = ""Description with picture: ""\
            ""![picture](/uploads/-/system/personal_snippet/#{snippet.id}/#{picture_secret}/picture.jpg) and ""\
            ""text: [text.txt](/uploads/-/system/personal_snippet/#{snippet.id}/#{text_secret}/text.txt)""

          expect(snippet.description).to eq(expected_description)
        end

        context 'when there is a validation error' do
          let(:title) { nil }

          it 'does not move uploaded files to the snippet' do
            expect_any_instance_of(described_class).not_to receive(:move_temporary_files)

            subject
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Database
  class ConsistencyFixService
    def initialize(source_model:, target_model:, sync_event_class:, source_sort_key:, target_sort_key:)
      @source_model = source_model
      @target_model = target_model
      @sync_event_class = sync_event_class
      @source_sort_key = source_sort_key
      @target_sort_key = target_sort_key
    end

    attr_accessor :source_model, :target_model, :sync_event_class, :source_sort_key, :target_sort_key

    def execute(ids:)
      ids.each do |id|
        if source_object(id) && target_object(id)
          create_sync_event_for(id)
        elsif target_object(id)
          target_object(id).destroy!
        end
      end
      sync_event_class.enqueue_worker
    end

    private

    # rubocop: disable CodeReuse/ActiveRecord
    def source_object(id)
      source_model.find_by(source_sort_key => id)
    end

    def target_object(id)
      target_model.find_by(target_sort_key => id)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def create_sync_event_for(id)
      if source_model == Namespace
        sync_event_class.create!(namespace_id: id)
      elsif source_model == Project
        sync_event_class.create!(project_id: id)
      else
        raise(""Unknown Source Model #{source_model.name}"")
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Database::ConsistencyFixService, feature_category: :cell do
  describe '#execute' do
    context 'fixing namespaces inconsistencies' do
      subject(:consistency_fix_service) do
        described_class.new(
          source_model: Namespace,
          target_model: Ci::NamespaceMirror,
          sync_event_class: Namespaces::SyncEvent,
          source_sort_key: :id,
          target_sort_key: :namespace_id
        )
      end

      let(:table) { 'public.namespaces' }
      let!(:namespace) { create(:namespace) }
      let!(:namespace_mirror) { Ci::NamespaceMirror.find_by(namespace_id: namespace.id) }

      context 'when both objects exist' do
        it 'creates a Namespaces::SyncEvent to modify the target object' do
          expect do
            consistency_fix_service.execute(ids: [namespace.id])
          end.to change {
            Namespaces::SyncEvent.where(namespace_id: namespace.id).count
          }.by(1)
        end

        it 'enqueues the worker to process the Namespaces::SyncEvents' do
          expect(::Namespaces::ProcessSyncEventsWorker).to receive(:perform_async)
          consistency_fix_service.execute(ids: [namespace.id])
        end
      end

      context 'when the source object has been deleted, but not the target' do
        before do
          namespace.delete
        end

        it 'deletes the target object' do
          expect do
            consistency_fix_service.execute(ids: [namespace.id])
          end.to change { Ci::NamespaceMirror.where(namespace_id: namespace.id).count }.by(-1)
        end
      end
    end

    context 'fixing projects inconsistencies' do
      subject(:consistency_fix_service) do
        described_class.new(
          source_model: Project,
          target_model: Ci::ProjectMirror,
          sync_event_class: Projects::SyncEvent,
          source_sort_key: :id,
          target_sort_key: :project_id
        )
      end

      let(:table) { 'public.projects' }
      let!(:project) { create(:project) }
      let!(:project_mirror) { Ci::ProjectMirror.find_by(project_id: project.id) }

      context 'when both objects exist' do
        it 'creates a Projects::SyncEvent to modify the target object' do
          expect do
            consistency_fix_service.execute(ids: [project.id])
          end.to change {
            Projects::SyncEvent.where(project_id: project.id).count
          }.by(1)
        end

        it 'enqueues the worker to process the Projects::SyncEvents' do
          expect(::Projects::ProcessSyncEventsWorker).to receive(:perform_async)
          consistency_fix_service.execute(ids: [project.id])
        end
      end

      context 'when the source object has been deleted, but not the target' do
        before do
          project.delete
        end

        it 'deletes the target object' do
          expect do
            consistency_fix_service.execute(ids: [project.id])
          end.to change { Ci::ProjectMirror.where(project_id: project.id).count }.by(-1)
        end
      end
    end
  end

  describe '#create_sync_event_for' do
    context 'when the source model is Namespace' do
      let(:namespace) { create(:namespace) }

      let(:service) do
        described_class.new(
          source_model: Namespace,
          target_model: Ci::NamespaceMirror,
          sync_event_class: Namespaces::SyncEvent,
          source_sort_key: :id,
          target_sort_key: :namespace_id
        )
      end

      it 'creates a Namespaces::SyncEvent object' do
        expect do
          service.send(:create_sync_event_for, namespace.id)
        end.to change { Namespaces::SyncEvent.where(namespace_id: namespace.id).count }.by(1)
      end
    end

    context 'when the source model is Project' do
      let(:project) { create(:project) }

      let(:service) do
        described_class.new(
          source_model: Project,
          target_model: Ci::ProjectMirror,
          sync_event_class: Projects::SyncEvent,
          source_sort_key: :id,
          target_sort_key: :project_id
        )
      end

      it 'creates a Projects::SyncEvent object' do
        expect do
          service.send(:create_sync_event_for, project.id)
        end.to change { Projects::SyncEvent.where(project_id: project.id).count }.by(1)
      end
    end
  end

  context 'when the source model is User' do
    let(:service) do
      described_class.new(
        source_model: User,
        target_model: Ci::ProjectMirror,
        sync_event_class: Projects::SyncEvent,
        source_sort_key: :id,
        target_sort_key: :project_id
      )
    end

    it 'raises an error' do
      expect do
        service.send(:create_sync_event_for, 1)
      end.to raise_error(""Unknown Source Model User"")
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Database
  class ConsistencyCheckService
    CURSOR_REDIS_KEY_TTL = 7.days
    EMPTY_RESULT = { matches: 0, mismatches: 0, batches: 0, mismatches_details: [] }.freeze

    def initialize(source_model:, target_model:, source_columns:, target_columns:)
      @source_model = source_model
      @target_model = target_model
      @source_columns = source_columns
      @target_columns = target_columns
      @source_sort_column = source_columns.first
      @target_sort_column = target_columns.first
    end

    # This class takes two ActiveRecord models, and compares the selected columns
    # of the two models tables, for the purposes of checking the consistency of
    # mirroring of tables. For example Namespace and Ci::NamepaceMirror
    #
    # It compares up to 25 batches (1000 records / batch), or up to 30 seconds
    # for all the batches in total.
    #
    # It saves the cursor of the next start_id (cusror) in Redis. If the start_id
    # wasn't saved in Redis, for example, in the first run, it will choose some random start_id
    #
    # Example:
    #    service = Database::ConsistencyCheckService.new(
    #      source_model: Namespace,
    #      target_model: Ci::NamespaceMirror,
    #      source_columns: %w[id traversal_ids],
    #      target_columns: %w[namespace_id traversal_ids],
    #    )
    #    result = service.execute
    #
    # result is a hash that has the following fields:
    # - batches: Number of batches checked
    # - matches: The number of matched records
    # - mismatches: The number of mismatched records
    # - mismatches_details: It's an array that contains details about the mismatched records.
    #     each record in this array is a hash of format {id: ID, source_table: [...], target_table: [...]}
    #     Each record represents the attributes of the records in the two tables.
    # - start_id: The start id cursor of the current batch. <nil> means no records.
    # - next_start_id: The ID that can be used for the next batch iteration check. <nil> means no records
    def execute
      start_id = next_start_id

      return EMPTY_RESULT if start_id.nil?

      result = consistency_checker.execute(start_id: start_id)
      result[:start_id] = start_id

      save_next_start_id(result[:next_start_id])

      result
    end

    private

    attr_reader :source_model, :target_model, :source_columns, :target_columns, :source_sort_column, :target_sort_column

    def consistency_checker
      @consistency_checker ||= Gitlab::Database::ConsistencyChecker.new(
        source_model: source_model,
        target_model: target_model,
        source_columns: source_columns,
        target_columns: target_columns
      )
    end

    def next_start_id
      return if min_id.nil?

      fetch_next_start_id || random_start_id
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def min_id
      @min_id ||= source_model.minimum(source_sort_column)
    end

    def max_id
      @max_id ||= source_model.maximum(source_sort_column)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def fetch_next_start_id
      Gitlab::Redis::SharedState.with { |redis| redis.get(cursor_redis_shared_state_key)&.to_i }
    end

    # This returns some random start_id, so that we don't always start checking
    # from the start of the table, in case we lose the cursor in Redis.
    def random_start_id
      range_start = min_id
      range_end = [min_id, max_id - Gitlab::Database::ConsistencyChecker::BATCH_SIZE].max
      rand(range_start..range_end)
    end

    def save_next_start_id(start_id)
      Gitlab::Redis::SharedState.with do |redis|
        redis.set(cursor_redis_shared_state_key, start_id, ex: CURSOR_REDIS_KEY_TTL)
      end
    end

    def cursor_redis_shared_state_key
      ""consistency_check_cursor:#{source_model.table_name}:#{target_model.table_name}""
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Database::ConsistencyCheckService, feature_category: :cell do
  let(:batch_size) { 5 }
  let(:max_batches) { 2 }

  before do
    stub_const(""Gitlab::Database::ConsistencyChecker::BATCH_SIZE"", batch_size)
    stub_const(""Gitlab::Database::ConsistencyChecker::MAX_BATCHES"", max_batches)
  end

  after do
    redis_shared_state_cleanup!
  end

  subject(:consistency_check_service) do
    described_class.new(
      source_model: Namespace,
      target_model: Ci::NamespaceMirror,
      source_columns: %w[id traversal_ids],
      target_columns: %w[namespace_id traversal_ids]
    )
  end

  describe '#min_id' do
    before do
      create_list(:namespace, 3)
    end

    it 'returns the id of the first record in the database' do
      expect(subject.send(:min_id)).to eq(Namespace.first.id)
    end
  end

  describe '#max_id' do
    before do
      create_list(:namespace, 3)
    end

    it 'returns the id of the first record in the database' do
      expect(subject.send(:max_id)).to eq(Namespace.last.id)
    end
  end

  describe '#random_start_id' do
    before do
      create_list(:namespace, 50) # This will also create Ci::NameSpaceMirror objects
    end

    it 'generates a random start_id within the records ids' do
      10.times do
        start_id = subject.send(:random_start_id)
        expect(start_id).to be_between(Namespace.first.id, Namespace.last.id).inclusive
      end
    end
  end

  describe '#execute' do
    let(:empty_results) do
      { batches: 0, matches: 0, mismatches: 0, mismatches_details: [] }
    end

    context 'when empty tables' do
      it 'returns results with zero counters' do
        result = consistency_check_service.execute

        expect(result).to eq(empty_results)
      end

      it 'does not call the ConsistencyCheckService' do
        expect(Gitlab::Database::ConsistencyChecker).not_to receive(:new)
        consistency_check_service.execute
      end
    end

    context 'no cursor has been saved before' do
      let(:min_id) { Namespace.first.id }
      let(:max_id) { Namespace.last.id }

      before do
        create_list(:namespace, 50) # This will also create Ci::NameSpaceMirror objects
      end

      it 'picks a random start_id' do
        expected_result = {
          batches: 2,
          matches: 10,
          mismatches: 0,
          mismatches_details: [],
          start_id: be_between(min_id, max_id),
          next_start_id: be_between(min_id, max_id)
        }
        expect(consistency_check_service).to receive(:rand).with(min_id..max_id).and_call_original
        result = consistency_check_service.execute
        expect(result).to match(expected_result)
      end

      it 'calls the ConsistencyCheckService with the expected parameters' do
        expect(consistency_check_service).to receive(:random_start_id).and_return(min_id)

        allow_next_instance_of(Gitlab::Database::ConsistencyChecker) do |instance|
          expect(instance).to receive(:execute).with(start_id: min_id).and_return({
            batches: 2,
            next_start_id: min_id + batch_size,
            matches: 10,
            mismatches: 0,
            mismatches_details: []
          })
        end

        expect(Gitlab::Database::ConsistencyChecker).to receive(:new).with(
          source_model: Namespace,
          target_model: Ci::NamespaceMirror,
          source_columns: %w[id traversal_ids],
          target_columns: %w[namespace_id traversal_ids]
        ).and_call_original

        expected_result = {
          batches: 2,
          matches: 10,
          mismatches: 0,
          mismatches_details: [],
          start_id: be_between(min_id, max_id),
          next_start_id: be_between(min_id, max_id)
        }
        result = consistency_check_service.execute
        expect(result).to match(expected_result)
      end

      it 'saves the next_start_id in Redis for he next iteration' do
        expect(consistency_check_service).to receive(:save_next_start_id)
          .with(be_between(min_id, max_id)).and_call_original
        consistency_check_service.execute
      end
    end

    context 'cursor saved in Redis and moving' do
      let(:first_namespace_id) { Namespace.order(:id).first.id }
      let(:second_namespace_id) { Namespace.order(:id).second.id }

      before do
        create_list(:namespace, 30) # This will also create Ci::NameSpaceMirror objects
      end

      it ""keeps moving the cursor with each call to the service"" do
        expect(consistency_check_service).to receive(:random_start_id).at_most(:once).and_return(first_namespace_id)

        allow_next_instance_of(Gitlab::Database::ConsistencyChecker) do |instance|
          expect(instance).to receive(:execute).ordered.with(start_id: first_namespace_id).and_call_original
          expect(instance).to receive(:execute).ordered.with(start_id: first_namespace_id + 10).and_call_original
          expect(instance).to receive(:execute).ordered.with(start_id: first_namespace_id + 20).and_call_original
          # Gets back to the start of the table
          expect(instance).to receive(:execute).ordered.with(start_id: first_namespace_id).and_call_original
        end

        4.times do
          consistency_check_service.execute
        end
      end

      it ""keeps moving the cursor from any start point"" do
        expect(consistency_check_service).to receive(:random_start_id).at_most(:once).and_return(second_namespace_id)

        allow_next_instance_of(Gitlab::Database::ConsistencyChecker) do |instance|
          expect(instance).to receive(:execute).ordered.with(start_id: second_namespace_id).and_call_original
          expect(instance).to receive(:execute).ordered.with(start_id: second_namespace_id + 10).and_call_original
        end

        2.times do
          consistency_check_service.execute
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Database
  class MarkMigrationService
    def initialize(connection:, version:)
      @connection = connection
      @version = version
    end

    def execute
      return error(reason: :not_found) unless migration.present?
      return error(reason: :invalid) if all_versions.include?(migration.version)

      if create_version(version)
        ServiceResponse.success
      else
        error(reason: :invalid)
      end
    end

    private

    attr_reader :connection, :version

    def migration
      @migration ||= connection
        .migration_context
        .migrations
        .find { |migration| migration.version == version }
    end

    def all_versions
      all_executed_migrations.map(&:to_i)
    end

    def all_executed_migrations
      sm = Arel::SelectManager.new(arel_table)
      sm.project(arel_table[:version])
      sm.order(arel_table[:version].asc) # rubocop: disable CodeReuse/ActiveRecord
      connection.select_values(sm, ""#{self.class} Load"")
    end

    def create_version(version)
      im = Arel::InsertManager.new
      im.into(arel_table)
      im.insert(arel_table[:version] => version)
      connection.insert(im, ""#{self.class} Create"", :version, version)
    end

    def arel_table
      @arel_table ||= Arel::Table.new(:schema_migrations)
    end

    def error(reason:)
      ServiceResponse.error(message: 'error', reason: reason)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Database::MarkMigrationService, feature_category: :database do
  let(:service) { described_class.new(connection: connection, version: version) }
  let(:version) { 1 }
  let(:connection) { ApplicationRecord.connection }

  let(:migrations) do
    [
      instance_double(
        ActiveRecord::MigrationProxy,
        version: 1,
        name: 'migration_pending',
        filename: 'db/migrate/1_migration_pending.rb'
      )
    ]
  end

  before do
    ctx = instance_double(ActiveRecord::MigrationContext, migrations: migrations)
    allow(connection).to receive(:migration_context).and_return(ctx)
  end

  describe '#execute' do
    subject(:execute) { service.execute }

    it 'marks the migration as successful' do
      expect { execute }
        .to change { ActiveRecord::SchemaMigration.where(version: version).count }
        .by(1)

      is_expected.to be_success
    end

    context 'when the migration does not exist' do
      let(:version) { 123 }

      it { is_expected.to be_error }
      it { expect(execute.reason).to eq(:not_found) }

      it 'does not insert records' do
        expect { execute }
          .not_to change { ActiveRecord::SchemaMigration.where(version: version).count }
      end
    end

    context 'when the migration was already executed' do
      before do
        allow(service).to receive(:all_versions).and_return([version])
      end

      it { is_expected.to be_error }
      it { expect(execute.reason).to eq(:invalid) }

      it 'does not insert records' do
        expect { execute }
          .not_to change { ActiveRecord::SchemaMigration.where(version: version).count }
      end
    end

    context 'when the insert fails' do
      it 'returns an error response' do
        expect(service).to receive(:create_version).with(version).and_return(false)

        is_expected.to be_error
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module FeatureFlags
  class HookService
    HOOK_NAME = :feature_flag_hooks

    def initialize(feature_flag, current_user)
      @feature_flag = feature_flag
      @current_user = current_user
    end

    def execute
      project.execute_hooks(hook_data, HOOK_NAME)
    end

    private

    attr_reader :feature_flag, :current_user

    def project
      @project ||= feature_flag.project
    end

    def hook_data
      Gitlab::DataBuilder::FeatureFlag.build(feature_flag, current_user)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe FeatureFlags::HookService, feature_category: :feature_flags do
  describe '#execute_hooks' do
    let_it_be(:namespace) { create(:namespace) }
    let_it_be(:project) { create(:project, :repository, namespace: namespace) }
    let_it_be(:feature_flag) { create(:operations_feature_flag, project: project) }
    let_it_be(:user) { namespace.first_owner }

    let!(:hook) { create(:project_hook, project: project) }
    let(:hook_data) { double }

    subject(:service) { described_class.new(feature_flag, user) }

    before do
      allow(Gitlab::DataBuilder::FeatureFlag).to receive(:build).with(feature_flag, user).once.and_return(hook_data)
    end

    describe 'HOOK_NAME' do
      specify { expect(described_class::HOOK_NAME).to eq(:feature_flag_hooks) }
    end

    it 'calls feature_flag.project.execute_hooks' do
      expect(feature_flag.project).to receive(:execute_hooks).with(hook_data, described_class::HOOK_NAME)

      service.execute
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module FeatureFlags
  class DestroyService < FeatureFlags::BaseService
    def execute(feature_flag)
      destroy_feature_flag(feature_flag)
    end

    private

    def destroy_feature_flag(feature_flag)
      return error('Access Denied', 403) unless can_destroy?(feature_flag)

      ApplicationRecord.transaction do
        if feature_flag.destroy
          update_last_feature_flag_updated_at!

          success(feature_flag: feature_flag)
        else
          error(feature_flag.errors.full_messages)
        end
      end
    end

    def audit_context(feature_flag)
      {
        name: 'feature_flag_deleted',
        message: audit_message(feature_flag),
        author: current_user,
        scope: feature_flag.project,
        target: feature_flag
      }
    end

    def audit_message(feature_flag)
      ""Deleted feature flag #{feature_flag.name}.""
    end

    def can_destroy?(feature_flag)
      Ability.allowed?(current_user, :destroy_feature_flag, feature_flag)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe FeatureFlags::DestroyService, feature_category: :feature_flags do
  include FeatureFlagHelpers

  let_it_be(:project) { create(:project) }
  let_it_be(:developer) { create(:user) }
  let_it_be(:reporter) { create(:user) }

  let(:user) { developer }
  let!(:feature_flag) { create(:operations_feature_flag, project: project) }

  before_all do
    project.add_developer(developer)
    project.add_reporter(reporter)
  end

  describe '#execute' do
    subject { described_class.new(project, user, params).execute(feature_flag) }

    let(:audit_event_details) { AuditEvent.last.details }
    let(:audit_event_message) { audit_event_details[:custom_message] }
    let(:params) { {} }

    it 'returns status success' do
      expect(subject[:status]).to eq(:success)
    end

    it 'destroys feature flag' do
      expect { subject }.to change { Operations::FeatureFlag.count }.by(-1)
    end

    it 'creates audit log', :with_license do
      expect { subject }.to change { AuditEvent.count }.by(1)
      expect(audit_event_message).to eq(""Deleted feature flag #{feature_flag.name}."")
    end

    it_behaves_like 'update feature flag client'

    context 'when user is reporter' do
      let(:user) { reporter }

      it 'returns error status' do
        expect(subject[:status]).to eq(:error)
        expect(subject[:message]).to eq('Access Denied')
      end
    end

    context 'when feature flag can not be destroyed' do
      before do
        allow(feature_flag).to receive(:destroy).and_return(false)
      end

      it 'returns status error' do
        expect(subject[:status]).to eq(:error)
      end

      it 'does not create audit log' do
        expect { subject }.not_to change { AuditEvent.count }
      end

      it_behaves_like 'does not update feature flag client'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module FeatureFlags
  class UpdateService < FeatureFlags::BaseService
    AUDITABLE_STRATEGY_ATTRIBUTES_HUMAN_NAMES = {
      'scopes' => 'environment scopes',
      'parameters' => 'parameters'
    }.freeze

    def success(**args)
      execute_hooks_after_commit(args[:feature_flag])
      super
    end

    def execute(feature_flag)
      return error('Access Denied', 403) unless can_update?(feature_flag)
      return error('Not Found', 404) unless valid_user_list_ids?(feature_flag, user_list_ids(params))

      ApplicationRecord.transaction do
        feature_flag.assign_attributes(params)

        feature_flag.strategies.each do |strategy|
          if strategy.name_changed? && strategy.name_was == ::Operations::FeatureFlags::Strategy::STRATEGY_GITLABUSERLIST
            strategy.user_list = nil
          end
        end

        # We generate the audit context before the feature flag is saved as #changed_strategies_messages depends on the strategies' states before save
        saved_audit_context = audit_context feature_flag

        if feature_flag.save
          update_last_feature_flag_updated_at!

          success(feature_flag: feature_flag, audit_context: saved_audit_context)
        else
          error(feature_flag.errors.full_messages, :bad_request)
        end
      end
    end

    private

    def execute_hooks_after_commit(feature_flag)
      return unless feature_flag.active_previously_changed?

      # The `current_user` method (defined in `BaseService`) is not available within the `run_after_commit` block
      user = current_user
      feature_flag.run_after_commit do
        HookService.new(feature_flag, user).execute
      end
    end

    def audit_context(feature_flag)
      {
        name: 'feature_flag_updated',
        message: audit_message(feature_flag),
        author: current_user,
        scope: feature_flag.project,
        target: feature_flag
      }
    end

    def audit_message(feature_flag)
      changes = changed_attributes_messages(feature_flag)
      changes += changed_strategies_messages(feature_flag)

      return if changes.empty?

      ""Updated feature flag #{feature_flag.name}. "" + changes.join("" "")
    end

    def changed_attributes_messages(feature_flag)
      feature_flag.changes.slice(*AUDITABLE_ATTRIBUTES).map do |attribute_name, changes|
        ""Updated #{attribute_name} ""\
        ""from \""#{changes.first}\"" to ""\
        ""\""#{changes.second}\"".""
      end
    end

    def changed_strategies_messages(feature_flag)
      feature_flag.strategies.map do |strategy|
        if strategy.new_record?
          created_strategy_message(strategy)
        elsif strategy.marked_for_destruction?
          deleted_strategy_message(strategy)
        else
          updated_strategy_message(strategy)
        end
      end.compact # updated_strategy_message can return nil if nothing has been changed
    end

    def deleted_strategy_message(strategy)
      scopes = strategy.scopes.map { |scope| scope.environment_scope }.join(', ')
      ""Deleted strategy #{strategy.name} with environment scopes #{scopes}.""
    end

    def updated_strategy_message(strategy)
      changes = strategy.changes.slice(*AUDITABLE_STRATEGY_ATTRIBUTES_HUMAN_NAMES.keys)
      return if changes.empty?

      message = ""Updated strategy #{strategy.name} ""
      message += changes.map do |attribute_name, change|
        name = AUDITABLE_STRATEGY_ATTRIBUTES_HUMAN_NAMES[attribute_name]
        ""#{name} from #{change.first} to #{change.second}""
      end.join(' ')

      message + '.'
    end

    def can_update?(feature_flag)
      Ability.allowed?(current_user, :update_feature_flag, feature_flag)
    end

    def user_list_ids(params)
      params.fetch(:strategies_attributes, [])
        .select { |s| s[:user_list_id].present? }
        .map { |s| s[:user_list_id] }
    end

    def valid_user_list_ids?(feature_flag, user_list_ids)
      user_list_ids.empty? || ::Operations::FeatureFlags::UserList.belongs_to?(feature_flag.project_id, user_list_ids)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe FeatureFlags::UpdateService, :with_license, feature_category: :feature_flags do
  let_it_be(:project) { create(:project) }
  let_it_be(:developer) { create(:user) }
  let_it_be(:reporter) { create(:user) }

  let(:user) { developer }
  let(:feature_flag) { create(:operations_feature_flag, project: project, active: true) }

  before_all do
    project.add_developer(developer)
    project.add_reporter(reporter)
  end

  describe '#execute' do
    subject { described_class.new(project, user, params).execute(feature_flag) }

    let(:params) { { name: 'new_name' } }
    let(:audit_event_details) { AuditEvent.last.details }
    let(:audit_event_message) { audit_event_details[:custom_message] }

    it 'returns success status' do
      expect(subject[:status]).to eq(:success)
    end

    context 'when Jira Connect subscription does not exist' do
      it 'does not sync the feature flag to Jira' do
        expect(::JiraConnect::SyncFeatureFlagsWorker).not_to receive(:perform_async)

        subject
      end
    end

    context 'when Jira Connect subscription exists' do
      before do
        create(:jira_connect_subscription, namespace: project.namespace)
      end

      it 'syncs the feature flag to Jira' do
        expect(::JiraConnect::SyncFeatureFlagsWorker).to receive(:perform_async).with(Integer, Integer)

        subject
      end
    end

    it 'creates audit event with correct message' do
      name_was = feature_flag.name

      expect { subject }.to change { AuditEvent.count }.by(1)
      expect(audit_event_message).to(
        eq(""Updated feature flag new_name. ""\
           ""Updated name from \""#{name_was}\"" ""\
           ""to \""new_name\""."")
      )
    end

    it_behaves_like 'update feature flag client'

    context 'with invalid params' do
      let(:params) { { name: nil } }

      it 'returns error status' do
        expect(subject[:status]).to eq(:error)
        expect(subject[:http_status]).to eq(:bad_request)
      end

      it 'returns error messages' do
        expect(subject[:message]).to include(""Name can't be blank"")
      end

      it 'does not create audit event' do
        expect { subject }.not_to change { AuditEvent.count }
      end

      it 'does not sync the feature flag to Jira' do
        expect(::JiraConnect::SyncFeatureFlagsWorker).not_to receive(:perform_async)

        subject
      end

      it_behaves_like 'does not update feature flag client'
    end

    context 'when user is reporter' do
      let(:user) { reporter }

      it 'returns error status' do
        expect(subject[:status]).to eq(:error)
        expect(subject[:message]).to eq('Access Denied')
      end
    end

    context 'when nothing is changed' do
      let(:params) { {} }

      it 'returns success status' do
        expect(subject[:status]).to eq(:success)
      end

      it 'does not create audit event' do
        expect { subject }.not_to change { AuditEvent.count }
      end
    end

    context 'description is being changed' do
      let(:params) { { description: 'new description' } }

      it 'creates audit event with changed description' do
        expect { subject }.to change { AuditEvent.count }.by(1)
        expect(audit_event_message).to(
          include(""Updated description from \""\""""\
                  "" to \""new description\""."")
        )
      end
    end

    context 'when flag active state is changed' do
      let(:params) do
        {
          active: false
        }
      end

      it 'creates audit event about changing active state' do
        expect { subject }.to change { AuditEvent.count }.by(1)
        expect(audit_event_message).to(
          include('Updated active from ""true"" to ""false"".')
        )
      end

      it 'executes hooks' do
        hook = create(:project_hook, :all_events_enabled, project: project)
        expect(WebHookWorker).to receive(:perform_async).with(hook.id, an_instance_of(Hash), 'feature_flag_hooks', an_instance_of(Hash))

        subject
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module FeatureFlags
  class CreateService < FeatureFlags::BaseService
    def execute
      return error('Access Denied', 403) unless can_create?
      return error('Version is invalid', :bad_request) unless valid_version?

      ApplicationRecord.transaction do
        feature_flag = project.operations_feature_flags.new(params)

        if feature_flag.save
          update_last_feature_flag_updated_at!

          success(feature_flag: feature_flag)
        else
          error(feature_flag.errors.full_messages, 400)
        end
      end
    end

    private

    def audit_context(feature_flag)
      {
        name: 'feature_flag_created',
        message: audit_message(feature_flag),
        author: current_user,
        scope: feature_flag.project,
        target: feature_flag
      }
    end

    def audit_message(feature_flag)
      message_parts = [""Created feature flag #{feature_flag.name} with description \""#{feature_flag.description}\"".""]

      message_parts += feature_flag.strategies.map do |strategy|
        created_strategy_message(strategy)
      end

      message_parts.join("" "")
    end

    def can_create?
      Ability.allowed?(current_user, :create_feature_flag, project)
    end

    def valid_version?
      !params.key?(:version) || Operations::FeatureFlag.versions.key?(params[:version])
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe FeatureFlags::CreateService, feature_category: :feature_flags do
  let_it_be(:project) { create(:project) }
  let_it_be(:developer) { create(:user) }
  let_it_be(:reporter) { create(:user) }

  let(:user) { developer }

  before_all do
    project.add_developer(developer)
    project.add_reporter(reporter)
  end

  describe '#execute' do
    subject do
      described_class.new(project, user, params).execute
    end

    let(:feature_flag) { subject[:feature_flag] }

    context 'when feature flag can not be created' do
      let(:params) { {} }

      it 'returns status error' do
        expect(subject[:status]).to eq(:error)
      end

      it 'returns validation errors' do
        expect(subject[:message]).to include(""Name can't be blank"")
      end

      it 'does not create audit log' do
        expect { subject }.not_to change { AuditEvent.count }
      end

      it 'does not sync the feature flag to Jira' do
        expect(::JiraConnect::SyncFeatureFlagsWorker).not_to receive(:perform_async)

        subject
      end

      it_behaves_like 'does not update feature flag client'
    end

    context 'when feature flag is saved correctly' do
      let(:audit_event_details) { AuditEvent.last.details }
      let(:audit_event_message) { audit_event_details[:custom_message] }
      let(:params) do
        {
          name: 'feature_flag',
          description: 'description',
          version: 'new_version_flag',
          strategies_attributes: [{ name: 'default', scopes_attributes: [{ environment_scope: '*' }], parameters: {} },
                                  { name: 'default', parameters: {}, scopes_attributes: [{ environment_scope: 'production' }] }]
        }
      end

      it 'returns status success' do
        expect(subject[:status]).to eq(:success)
      end

      it 'creates feature flag' do
        expect { subject }.to change { Operations::FeatureFlag.count }.by(1)
      end

      it_behaves_like 'update feature flag client'

      context 'when Jira Connect subscription does not exist' do
        it 'does not sync the feature flag to Jira' do
          expect(::JiraConnect::SyncFeatureFlagsWorker).not_to receive(:perform_async)

          subject
        end
      end

      context 'when Jira Connect subscription exists' do
        before do
          create(:jira_connect_subscription, namespace: project.namespace)
        end

        it 'syncs the feature flag to Jira' do
          expect(::JiraConnect::SyncFeatureFlagsWorker).to receive(:perform_async).with(Integer, Integer)

          subject
        end
      end

      it 'creates audit event', :with_license do
        expect { subject }.to change { AuditEvent.count }.by(1)
        expect(audit_event_message).to start_with('Created feature flag feature_flag with description ""description"".')
        expect(audit_event_message).to include('Created strategy ""default"" with scopes ""*"".')
        expect(audit_event_message).to include('Created strategy ""default"" with scopes ""production"".')
      end

      context 'when user is reporter' do
        let(:user) { reporter }

        it 'returns error status' do
          expect(subject[:status]).to eq(:error)
          expect(subject[:message]).to eq('Access Denied')
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module IssueLinks
  class DestroyService < IssuableLinks::DestroyService
    include IncidentManagement::UsageData

    private

    def permission_to_remove_relation?
      can?(current_user, :admin_issue_link, source) && can?(current_user, :admin_issue_link, target)
    end

    def track_event
      track_incident_action(current_user, target, :incident_unrelate)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe IssueLinks::DestroyService, feature_category: :team_planning do
  describe '#execute' do
    let_it_be(:project) { create(:project_empty_repo, :private) }
    let_it_be(:reporter) { create(:user).tap { |user| project.add_reporter(user) } }
    let_it_be(:issue_a) { create(:issue, project: project) }
    let_it_be(:issue_b) { create(:issue, project: project) }

    let!(:issuable_link) { create(:issue_link, source: issue_a, target: issue_b) }
    let(:user) { reporter }

    subject { described_class.new(issuable_link, user).execute }

    it_behaves_like 'a destroyable issuable link'

    context 'when target is an incident' do
      let(:issue_b) { create(:incident, project: project) }

      it_behaves_like 'an incident management tracked event', :incident_management_incident_unrelate do
        let(:current_user) { reporter }
      end

      it_behaves_like 'Snowplow event tracking with RedisHLL context' do
        let(:namespace) { issue_b.namespace }
        let(:category) { described_class.to_s }
        let(:action) { 'incident_management_incident_unrelate' }
        let(:label) { 'redis_hll_counters.incident_management.incident_management_total_unique_counts_monthly' }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module IssueLinks
  class ListService < IssuableLinks::ListService
    extend ::Gitlab::Utils::Override

    private

    def child_issuables
      issuable.related_issues(current_user, preload: preload_for_collection)
    end

    override :serializer
    def serializer
      LinkedProjectIssueSerializer
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe IssueLinks::ListService, feature_category: :team_planning do
  let(:user) { create :user }
  let(:project) { create(:project_empty_repo, :private) }
  let(:issue) { create :issue, project: project }
  let(:user_role) { :developer }

  before do
    project.add_role(user, user_role)
  end

  describe '#execute' do
    subject { described_class.new(issue, user).execute }

    context 'user can see all issues' do
      let(:issue_b) { create :issue, project: project }
      let(:issue_c) { create :issue, project: project }
      let(:issue_d) { create :issue, project: project }

      let!(:issue_link_c) do
        create(:issue_link, source: issue_d, target: issue)
      end

      let!(:issue_link_b) do
        create(:issue_link, source: issue, target: issue_c)
      end

      let!(:issue_link_a) do
        create(:issue_link, source: issue, target: issue_b)
      end

      it 'ensures no N+1 queries are made' do
        control_count = ActiveRecord::QueryRecorder.new { subject }.count

        project = create :project, :public
        milestone = create :milestone, project: project
        issue_x = create :issue, project: project, milestone: milestone
        issue_y = create :issue, project: project, assignees: [user]
        issue_z = create :issue, project: project
        create :issue_link, source: issue_x, target: issue_y
        create :issue_link, source: issue_x, target: issue_z
        create :issue_link, source: issue_y, target: issue_z

        expect { subject }.not_to exceed_query_limit(control_count)
      end

      it 'returns related issues JSON' do
        expect(subject.size).to eq(3)

        expect(subject).to include(include(
          id: issue_b.id,
          title: issue_b.title,
          state: issue_b.state,
          reference: issue_b.to_reference(project),
          path: ""/#{project.full_path}/-/issues/#{issue_b.iid}"",
          relation_path: ""/#{project.full_path}/-/issues/#{issue.iid}/links/#{issue_link_a.id}""
        ))

        expect(subject).to include(include(
          id: issue_c.id,
          title: issue_c.title,
          state: issue_c.state,
          reference: issue_c.to_reference(project),
          path: ""/#{project.full_path}/-/issues/#{issue_c.iid}"",
          relation_path: ""/#{project.full_path}/-/issues/#{issue.iid}/links/#{issue_link_b.id}""
        ))

        expect(subject).to include(include(
          id: issue_d.id,
          title: issue_d.title,
          state: issue_d.state,
          reference: issue_d.to_reference(project),
          path: ""/#{project.full_path}/-/issues/#{issue_d.iid}"",
          relation_path: ""/#{project.full_path}/-/issues/#{issue.iid}/links/#{issue_link_c.id}""
        ))
      end
    end

    context 'referencing a public project issue' do
      let(:public_project) { create :project, :public }
      let(:issue_b) { create :issue, project: public_project }

      let!(:issue_link) do
        create(:issue_link, source: issue, target: issue_b)
      end

      it 'presents issue' do
        expect(subject.size).to eq(1)
      end
    end

    context 'referencing issue with removed relationships' do
      context 'when referenced a deleted issue' do
        let(:issue_b) { create :issue, project: project }
        let!(:issue_link) do
          create(:issue_link, source: issue, target: issue_b)
        end

        it 'ignores issue' do
          issue_b.destroy!

          is_expected.to eq([])
        end
      end

      context 'when referenced an issue with deleted project' do
        let(:issue_b) { create :issue, project: project }
        let!(:issue_link) do
          create(:issue_link, source: issue, target: issue_b)
        end

        it 'ignores issue' do
          project.destroy!

          is_expected.to eq([])
        end
      end

      context 'when referenced an issue with deleted namespace' do
        let(:issue_b) { create :issue, project: project }
        let!(:issue_link) do
          create(:issue_link, source: issue, target: issue_b)
        end

        it 'ignores issue' do
          project.namespace.destroy!

          is_expected.to eq([])
        end
      end
    end

    context 'user cannot see relations' do
      context 'when user cannot see the referenced issue' do
        let!(:issue_link) do
          create(:issue_link, source: issue)
        end

        it 'returns an empty list' do
          is_expected.to eq([])
        end
      end

      context 'when user cannot see the issue that referenced' do
        let!(:issue_link) do
          create(:issue_link, target: issue)
        end

        it 'returns an empty list' do
          is_expected.to eq([])
        end
      end
    end

    context 'remove relations' do
      let!(:issue_link) do
        create(:issue_link, source: issue, target: referenced_issue)
      end

      context 'user can admin related issues just on target project' do
        let(:user_role) { :guest }
        let(:target_project) { create :project }
        let(:referenced_issue) { create :issue, project: target_project }

        it 'returns no destroy relation path' do
          target_project.add_developer(user)

          expect(subject.first[:relation_path]).to be_nil
        end
      end

      context 'user can admin related issues just on source project' do
        let(:user_role) { :developer }
        let(:target_project) { create :project }
        let(:referenced_issue) { create :issue, project: target_project }

        it 'returns no destroy relation path' do
          target_project.add_guest(user)

          expect(subject.first[:relation_path]).to be_nil
        end
      end

      context 'when user can admin related issues on both projects' do
        let(:referenced_issue) { create :issue, project: project }

        it 'returns related issue destroy relation path' do
          expect(subject.first[:relation_path])
            .to eq(""/#{project.full_path}/-/issues/#{issue.iid}/links/#{issue_link.id}"")
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module IssueLinks
  class CreateService < IssuableLinks::CreateService
    include IncidentManagement::UsageData

    def linkable_issuables(issues)
      @linkable_issuables ||= issues.select { |issue| can?(current_user, :admin_issue_link, issue) }
    end

    def previous_related_issuables
      @related_issues ||= issuable.related_issues(authorize: false).to_a
    end

    private

    def readonly_issuables(issuables)
      @readonly_issuables ||= issuables.select { |issuable| issuable.readable_by?(current_user) }
    end

    def track_event
      track_incident_action(current_user, issuable, :incident_relate)
    end

    def link_class
      IssueLink
    end
  end
end

IssueLinks::CreateService.prepend_mod_with('IssueLinks::CreateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe IssueLinks::CreateService, feature_category: :team_planning do
  describe '#execute' do
    let_it_be(:user) { create :user }
    let_it_be(:namespace) { create :namespace }
    let_it_be(:project) { create :project, namespace: namespace }
    let_it_be(:issuable) { create :issue, project: project }
    let_it_be(:issuable2) { create :issue, project: project }
    let_it_be(:restricted_issuable) { create :issue }
    let_it_be(:another_project) { create :project, namespace: project.namespace }
    let_it_be(:issuable3) { create :issue, project: another_project }
    let_it_be(:issuable_a) { create :issue, project: project }
    let_it_be(:issuable_b) { create :issue, project: project }
    let_it_be(:issuable_link) { create :issue_link, source: issuable, target: issuable_b, link_type: IssueLink::TYPE_RELATES_TO }

    let(:issuable_parent) { issuable.project }
    let(:issuable_type) { :issue }
    let(:issuable_link_class) { IssueLink }
    let(:params) { {} }

    before do
      project.add_developer(user)
      restricted_issuable.project.add_guest(user)
      another_project.add_developer(user)
    end

    it_behaves_like 'issuable link creation'

    context 'when target is an incident' do
      let_it_be(:issue) { create(:incident, project: project) }

      let(:params) do
        { issuable_references: [issuable2.to_reference, issuable3.to_reference(another_project)] }
      end

      subject { described_class.new(issue, user, params).execute }

      it_behaves_like 'an incident management tracked event', :incident_management_incident_relate do
        let(:current_user) { user }
      end

      it_behaves_like 'Snowplow event tracking with RedisHLL context' do
        let(:namespace) { issue.namespace }
        let(:category) { described_class.to_s }
        let(:action) { 'incident_management_incident_relate' }
        let(:label) { 'redis_hll_counters.incident_management.incident_management_total_unique_counts_monthly' }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Spam
  class SpamActionService
    include SpamConstants

    def initialize(spammable:, user:, action:, extra_features: {})
      @target = spammable
      @user = user
      @action = action
      @extra_features = extra_features
    end

    def execute
      return ServiceResponse.success(message: 'Skipped spam check because user was not present') unless user

      if target.supports_recaptcha? && spam_params
        execute_with_captcha_support
      else
        execute_spam_check
      end
    end

    delegate :check_for_spam?, to: :target

    private

    attr_reader :user, :action, :target, :spam_log, :extra_features

    def spam_params
      Gitlab::RequestContext.instance.spam_params
    end

    def execute_with_captcha_support
      recaptcha_verified = Captcha::CaptchaVerificationService.new(spam_params: spam_params).execute

      if recaptcha_verified
        # If it's a request which is already verified through CAPTCHA,
        # update the spam log accordingly.
        SpamLog.verify_recaptcha!(user_id: user.id, id: spam_params.spam_log_id)
        ServiceResponse.success(message: ""CAPTCHA successfully verified"")
      else
        execute_spam_check
      end
    end

    def execute_spam_check
      return ServiceResponse.success(message: 'Skipped spam check because user was allowlisted') if allowlisted?(user)
      return ServiceResponse.success(message: 'Skipped spam check because it was not required') unless check_for_spam?(user: user)

      perform_spam_service_check
      ServiceResponse.success(message: ""Spam check performed. Check #{target.class.name} spammable model for any errors or CAPTCHA requirement"")
    end

    ##
    # In order to be proceed to the spam check process, the target must be
    # a dirty instance, which means it should be already assigned with the new
    # attribute values.
    def ensure_target_is_dirty
      msg = ""Target instance of #{target.class.name} must be dirty (must have changes to save)""
      raise(msg) unless target.has_changes_to_save?
    end

    def allowlisted?(user)
      user.try(:gitlab_bot?) || user.try(:gitlab_service_user?)
    end

    ##
    # Performs the spam check using the spam verdict service, and modifies the target model
    # accordingly based on the result.
    def perform_spam_service_check
      ensure_target_is_dirty

      # since we can check for spam, and recaptcha is not verified,
      # ask the SpamVerdictService what to do with the target.
      spam_verdict_service.execute.tap do |result|
        case result
        when BLOCK_USER
          target.spam!
          create_spam_log
          create_spam_abuse_event(result)
          ban_user!
        when DISALLOW
          target.spam!
          create_spam_log
          create_spam_abuse_event(result)
        when CONDITIONAL_ALLOW
          # This means ""require a CAPTCHA to be solved""
          target.needs_recaptcha!
          create_spam_log
          create_spam_abuse_event(result)
        when OVERRIDE_VIA_ALLOW_POSSIBLE_SPAM
          create_spam_log
        when ALLOW
          target.clear_spam_flags!
        when NOOP
          # spamcheck is not explicitly rendering a verdict & therefore can't make a decision
          target.clear_spam_flags!
        end
      end
    end

    def create_spam_log
      @spam_log = SpamLog.create!(
        {
          user_id: user.id,
          title: target.spam_title,
          description: target.spam_description,
          source_ip: spam_params&.ip_address,
          user_agent: spam_params&.user_agent,
          noteable_type: noteable_type,
          # Now, all requests are via the API, so hardcode it to true to simplify the logic and API
          # of this service.  See https://gitlab.com/gitlab-org/gitlab-foss/-/merge_requests/2266
          # for original introduction of `via_api` field.
          # See discussion here about possibly deprecating this field:
          # https://gitlab.com/gitlab-org/gitlab-foss/-/merge_requests/2266#note_542527450
          via_api: true
        }
      )

      target.spam_log = spam_log
    end

    def create_spam_abuse_event(result)
      params = {
        user_id: user.id,
        title: target.spam_title,
        description: target.spam_description,
        source_ip: spam_params&.ip_address,
        user_agent: spam_params&.user_agent,
        noteable_type: noteable_type,
        verdict: result
      }

      target.run_after_commit_or_now do
        Abuse::SpamAbuseEventsWorker.perform_async(params)
      end
    end

    def ban_user!
      UserCustomAttribute.set_banned_by_spam_log(target.spam_log)

      user.ban!
    end

    def spam_verdict_service
      context = {
        action: action,
        target_type: noteable_type
      }

      options = {
        ip_address: spam_params&.ip_address,
        user_agent: spam_params&.user_agent,
        referer: spam_params&.referer
      }

      SpamVerdictService.new(
        target: target,
        user: user,
        options: options,
        context: context,
        extra_features: extra_features
      )
    end

    def noteable_type
      @notable_type ||= target.class.to_s
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Spam::SpamActionService, feature_category: :instance_resiliency do
  include_context 'includes Spam constants'

  let(:issue) { create(:issue, project: project, author: author) }
  let(:personal_snippet) { create(:personal_snippet, :public, author: author) }
  let(:project_snippet) { create(:project_snippet, :public, author: author) }
  let(:fake_ip) { '1.2.3.4' }
  let(:fake_user_agent) { 'fake-user-agent' }
  let(:fake_referer) { 'fake-http-referer' }
  let(:captcha_response) { 'abc123' }
  let(:spam_log_id) { existing_spam_log.id }
  let(:spam_params) do
    ::Spam::SpamParams.new(
      captcha_response: captcha_response,
      spam_log_id: spam_log_id,
      ip_address: fake_ip,
      user_agent: fake_user_agent,
      referer: fake_referer
    )
  end

  let_it_be(:project) { create(:project, :public) }
  let_it_be(:user) { create(:user) }
  let_it_be(:author) { create(:user) }

  before do
    issue.spam = false
    personal_snippet.spam = false

    allow_next_instance_of(described_class) do |service|
      allow(service).to receive(:spam_params).and_return(spam_params)
    end
  end

  describe 'constructor argument validation' do
    subject do
      described_service = described_class.new(spammable: issue, user: user, action: :create)
      described_service.execute
    end

    context 'when user is nil' do
      let(:spam_params) { true }
      let(:user) { nil }
      let(:expected_service_user_not_present_message) do
        /Skipped spam check because user was not present/
      end

      it ""returns success with a messaage"" do
        response = subject

        expect(response.message).to match(expected_service_user_not_present_message)
        expect(issue).not_to be_spam
      end
    end
  end

  shared_examples 'allows user' do
    it 'does not perform spam check' do
      expect(Spam::SpamVerdictService).not_to receive(:new)

      response = subject

      expect(response.message).to match(/user was allowlisted/)
    end
  end

  shared_examples 'creates a spam log' do |target_type|
    it do
      expect { subject }
        .to log_spam(title: target.title, description: target.description, noteable_type: target_type)

      # TODO: These checks should be incorporated into the `log_spam` RSpec matcher above
      new_spam_log = SpamLog.last
      expect(new_spam_log.user_id).to eq(user.id)
      expect(new_spam_log.title).to eq(target.title)
      expect(new_spam_log.description).to eq(target.spam_description)
      expect(new_spam_log.source_ip).to eq(fake_ip)
      expect(new_spam_log.user_agent).to eq(fake_user_agent)
      expect(new_spam_log.noteable_type).to eq(target_type)
      expect(new_spam_log.via_api).to eq(true)
    end
  end

  shared_examples 'calls SpamAbuseEventsWorker with correct arguments' do
    let(:params) do
      {
        user_id: user.id,
        title: target.title,
        description: target.spam_description,
        source_ip: fake_ip,
        user_agent: fake_user_agent,
        noteable_type: target_type,
        verdict: verdict
      }
    end

    it do
      expect(::Abuse::SpamAbuseEventsWorker).to receive(:perform_async).with(params)

      subject
    end
  end

  shared_examples 'execute spam action service' do |target_type|
    let(:fake_captcha_verification_service) { double(:captcha_verification_service) }
    let(:fake_verdict_service) { double(:spam_verdict_service) }

    let(:verdict_service_opts) do
      {
        ip_address: fake_ip,
        user_agent: fake_user_agent,
        referer: fake_referer
      }
    end

    let(:verdict_service_args) do
      {
        target: target,
        user: user,
        options: verdict_service_opts,
        context: {
          action: :create,
          target_type: target_type
        },
        extra_features: extra_features
      }
    end

    let_it_be(:existing_spam_log) { create(:spam_log, user: user, recaptcha_verified: false) }

    subject do
      described_service = described_class.new(spammable: target, extra_features:
                                              extra_features, user: user, action: :create)
      described_service.execute
    end

    before do
      allow(Captcha::CaptchaVerificationService).to receive(:new).with(spam_params: spam_params) { fake_captcha_verification_service }
      allow(Spam::SpamVerdictService).to receive(:new).with(verdict_service_args).and_return(fake_verdict_service)
      allow(fake_verdict_service).to receive(:execute).and_return({})
    end

    context 'when captcha response verification returns true' do
      before do
        allow(fake_captcha_verification_service)
          .to receive(:execute).and_return(true)
      end

      it ""doesn't check with the SpamVerdictService"" do
        aggregate_failures do
          expect(SpamLog).to receive(:verify_recaptcha!).with(
            user_id: user.id,
            id: spam_log_id
          )
          expect(fake_verdict_service).not_to receive(:execute)
        end

        subject
      end

      it 'updates spam log' do
        expect { subject }.to change { existing_spam_log.reload.recaptcha_verified }.from(false).to(true)
      end
    end

    context 'when captcha response verification returns false' do
      before do
        allow(fake_captcha_verification_service)
          .to receive(:execute).and_return(false)
      end

      context 'when spammable attributes have not changed' do
        before do
          allow(target).to receive(:has_changes_to_save?).and_return(true)
        end

        it 'does not create a spam log' do
          expect { subject }.not_to change(SpamLog, :count)
        end

        it 'does not call SpamAbuseEventsWorker' do
          expect(::Abuse::SpamAbuseEventsWorker).not_to receive(:perform_async)

          subject
        end
      end

      context 'when spammable attributes have changed' do
        let(:expected_service_check_response_message) do
          /Check #{target_type} spammable model for any errors or CAPTCHA requirement/
        end

        before do
          target.description = 'Lovely Spam! Wonderful Spam!'
        end

        context 'when captcha is not supported' do
          before do
            allow(target).to receive(:supports_recaptcha?).and_return(false)
          end

          it ""does not execute with captcha support"" do
            expect(Captcha::CaptchaVerificationService).not_to receive(:new)

            subject
          end

          it ""executes a spam check"" do
            expect(fake_verdict_service).to receive(:execute)

            subject
          end
        end

        context 'when user is a gitlab bot' do
          before do
            allow(user).to receive(:gitlab_bot?).and_return(true)
          end

          it_behaves_like 'allows user'
        end

        context 'when user is a gitlab service user' do
          before do
            allow(user).to receive(:gitlab_service_user?).and_return(true)
          end

          it_behaves_like 'allows user'
        end

        context 'when disallowed by the spam verdict service' do
          before do
            allow(fake_verdict_service).to receive(:execute).and_return(DISALLOW)
          end

          it_behaves_like 'creates a spam log', target_type

          it_behaves_like 'calls SpamAbuseEventsWorker with correct arguments' do
            let(:verdict) { DISALLOW }
            let(:target_type) { target_type }
          end

          it 'marks as spam' do
            response = subject

            expect(response.message).to match(expected_service_check_response_message)
            expect(target).to be_spam
          end
        end

        context 'spam verdict service advises to block the user' do
          # create a fresh user to ensure it is in the unbanned state
          let(:user) { create(:user) }

          before do
            allow(fake_verdict_service).to receive(:execute).and_return(BLOCK_USER)
          end

          it_behaves_like 'creates a spam log', target_type

          it_behaves_like 'calls SpamAbuseEventsWorker with correct arguments' do
            let(:verdict) { BLOCK_USER }
            let(:target_type) { target_type }
          end

          it 'marks as spam' do
            response = subject

            expect(response.message).to match(expected_service_check_response_message)
            expect(target).to be_spam
          end

          it 'bans the user' do
            subject

            custom_attribute = user.custom_attributes.by_key(UserCustomAttribute::AUTO_BANNED_BY_SPAM_LOG_ID).first
            expect(custom_attribute.value).to eq(target.spam_log.id.to_s)
            expect(user).to be_banned
          end
        end

        context 'when spam verdict service conditionally allows' do
          before do
            allow(fake_verdict_service).to receive(:execute).and_return(CONDITIONAL_ALLOW)
          end

          it_behaves_like 'creates a spam log', target_type

          it_behaves_like 'calls SpamAbuseEventsWorker with correct arguments' do
            let(:verdict) { CONDITIONAL_ALLOW }
            let(:target_type) { target_type }
          end

          it 'does not mark as spam' do
            response = subject

            expect(response.message).to match(expected_service_check_response_message)
            expect(target).not_to be_spam
          end

          it 'marks as needing reCAPTCHA' do
            response = subject

            expect(response.message).to match(expected_service_check_response_message)
            expect(target).to be_needs_recaptcha
          end
        end

        context 'when spam verdict service returns OVERRIDE_VIA_ALLOW_POSSIBLE_SPAM' do
          before do
            allow(fake_verdict_service).to receive(:execute).and_return(OVERRIDE_VIA_ALLOW_POSSIBLE_SPAM)
          end

          it_behaves_like 'creates a spam log', target_type

          it 'does not call SpamAbuseEventsWorker' do
            expect(::Abuse::SpamAbuseEventsWorker).not_to receive(:perform_async)

            subject
          end

          it 'does not mark as spam' do
            response = subject

            expect(response.message).to match(expected_service_check_response_message)
            expect(target).not_to be_spam
          end

          it 'does not mark as needing CAPTCHA' do
            response = subject

            expect(response.message).to match(expected_service_check_response_message)
            expect(target).not_to be_needs_recaptcha
          end
        end

        context 'when spam verdict service allows creation' do
          before do
            allow(fake_verdict_service).to receive(:execute).and_return(ALLOW)
          end

          it 'does not create a spam log' do
            expect { subject }.not_to change(SpamLog, :count)
          end

          it 'does not call SpamAbuseEventsWorker' do
            expect(::Abuse::SpamAbuseEventsWorker).not_to receive(:perform_async)

            subject
          end

          it 'clears spam flags' do
            expect(target).to receive(:clear_spam_flags!)

            subject
          end
        end

        context 'when spam verdict service returns noop' do
          before do
            allow(fake_verdict_service).to receive(:execute).and_return(NOOP)
          end

          it 'does not create a spam log' do
            expect { subject }.not_to change(SpamLog, :count)
          end

          it 'does not call SpamAbuseEventsWorker' do
            expect(::Abuse::SpamAbuseEventsWorker).not_to receive(:perform_async)

            subject
          end

          it 'clears spam flags' do
            expect(target).to receive(:clear_spam_flags!)

            subject
          end
        end

        context 'with spam verdict service options' do
          before do
            allow(fake_verdict_service).to receive(:execute).and_return(ALLOW)
          end

          it 'assembles the options with information from the request' do
            expect(Spam::SpamVerdictService).to receive(:new).with(verdict_service_args)

            subject
          end
        end
      end
    end
  end

  describe '#execute' do
    describe 'issue' do
      let(:target) { issue }
      let(:extra_features) { {} }

      it_behaves_like 'execute spam action service', 'Issue'
    end

    describe 'project snippet' do
      let(:target) { project_snippet }
      let(:extra_features) { { files: [{ path: 'project.rb' }] } }

      it_behaves_like 'execute spam action service', 'ProjectSnippet'
    end

    describe 'personal snippet' do
      let(:target) { personal_snippet }
      let(:extra_features) { { files: [{ path: 'personal.rb' }] } }

      it_behaves_like 'execute spam action service', 'PersonalSnippet'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Spam
  class HamService
    include AkismetMethods

    attr_accessor :spam_log, :options

    def initialize(spam_log)
      @spam_log = spam_log
      @user = spam_log.user
      @options = {
          ip_address: spam_log.source_ip,
          user_agent: spam_log.user_agent
      }
    end

    def execute
      if akismet.submit_ham
        spam_log.update_attribute(:submitted_as_ham, true)
      else
        false
      end
    end

    alias_method :target, :spam_log
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Spam::HamService, feature_category: :instance_resiliency do
  let_it_be(:user) { create(:user) }

  let!(:spam_log) { create(:spam_log, user: user, submitted_as_ham: false) }
  let(:fake_akismet_service) { double(:akismet_service) }

  subject { described_class.new(spam_log) }

  before do
    allow(Spam::AkismetService).to receive(:new).and_return fake_akismet_service
  end

  describe '#execute' do
    context 'AkismetService returns false (Akismet cannot be reached, etc)' do
      before do
        allow(fake_akismet_service).to receive(:submit_ham).and_return false
      end

      it 'returns false' do
        expect(subject.execute).to be_falsey
      end

      it 'does not update the record' do
        expect { subject.execute }.not_to change { spam_log.submitted_as_ham }
      end

      context 'if spam log record has already been marked as spam' do
        before do
          spam_log.update_attribute(:submitted_as_ham, true)
        end

        it 'does not update the record' do
          expect { subject.execute }.not_to change { spam_log.submitted_as_ham }
        end
      end
    end

    context 'Akismet ham submission is successful' do
      before do
        spam_log.update_attribute(:submitted_as_ham, false)
        allow(fake_akismet_service).to receive(:submit_ham).and_return true
      end

      it 'returns true' do
        expect(subject.execute).to be_truthy
      end

      it 'updates the record' do
        expect { subject.execute }.to change { spam_log.submitted_as_ham }.from(false).to(true)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Spam
  class AkismetService
    attr_accessor :text, :options

    def initialize(owner_name, owner_email, text, options = {})
      @owner_name = owner_name
      @owner_email = owner_email
      @text = text
      @options = options
    end

    def spam?
      return false unless akismet_enabled?

      params = {
        type: 'comment',
        text: text,
        created_at: DateTime.current,
        author: owner_name,
        author_email: owner_email,
        # NOTE: The akismet_client needs the option to be named `:referrer`, not `:referer`
        referrer: options[:referer]
      }

      begin
        is_spam, is_blatant = akismet_client.check(options[:ip_address], options[:user_agent], params)
        is_spam || is_blatant
      rescue ArgumentError => e
        Gitlab::ErrorTracking.track_and_raise_for_dev_exception(e)
        false
      rescue StandardError => e
        Gitlab::ErrorTracking.track_exception(e)
        Gitlab::AppLogger.error(""Error during Akismet spam check, flagging as not spam: #{e}"")
        false
      end
    end

    def submit_ham
      submit(:ham)
    end

    def submit_spam
      submit(:spam)
    end

    private

    attr_accessor :owner_name, :owner_email

    def akismet_client
      @akismet_client ||= ::Akismet::Client.new(
        Gitlab::CurrentSettings.akismet_api_key,
        Gitlab.config.gitlab.url
      )
    end

    def akismet_enabled?
      Gitlab::CurrentSettings.akismet_enabled
    end

    def submit(type)
      return false unless akismet_enabled?

      params = {
        type: 'comment',
        text: text,
        author: owner_name,
        author_email: owner_email
      }

      begin
        akismet_client.public_send(type, options[:ip_address], options[:user_agent], params) # rubocop:disable GitlabSecurity/PublicSend
        true
      rescue StandardError => e
        Gitlab::AppLogger.error(""Unable to connect to Akismet: #{e}, skipping!"")
        false
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Spam::AkismetService, feature_category: :instance_resiliency do
  let(:fake_akismet_client) { double(:akismet_client) }
  let(:ip) { '1.2.3.4' }
  let(:user_agent) { 'some user_agent' }
  let(:referer) { 'some referer' }

  let_it_be(:text) { ""Would you like to buy some tinned meat product?"" }
  let_it_be(:spam_owner) { create(:user) }

  subject do
    options = { ip_address: ip, user_agent: user_agent, referer: referer }
    described_class.new(spam_owner.name, spam_owner.email, text, options)
  end

  before do
    stub_application_setting(akismet_enabled: true)
    allow(subject).to receive(:akismet_client).and_return(fake_akismet_client)
  end

  shared_examples 'no activity if Akismet is not enabled' do |method_call|
    before do
      stub_application_setting(akismet_enabled: false)
    end

    it 'is automatically false' do
      expect(subject.send(method_call)).to be_falsey
    end

    it 'performs no check' do
      expect(fake_akismet_client).not_to receive(:public_send)

      subject.send(method_call)
    end
  end

  shared_examples 'false if Akismet is not available' do |method_call|
    context 'if Akismet is not available' do
      before do
        allow(fake_akismet_client).to receive(:public_send).and_raise(StandardError.new(""oh noes!""))
      end

      specify do
        expect(subject.send(method_call)).to be_falsey
      end

      it 'logs an error' do
        expect(Gitlab::AppLogger).to receive(:error).with(/skipping/)

        subject.send(method_call)
      end
    end
  end

  describe '#spam?' do
    it_behaves_like 'no activity if Akismet is not enabled', :spam?, :check

    context 'if Akismet is enabled' do
      it 'correctly transforms options for the akismet client, including spelling of referrer key' do
        expected_check_params = {
          type: 'comment',
          text: text,
          created_at: anything,
          author: spam_owner.name,
          author_email: spam_owner.email,
          # NOTE: The akismet_client needs the option to be named `:referrer`, not `:referer`
          referrer: referer
        }

        expect(fake_akismet_client).to receive(:check).with(ip, user_agent, expected_check_params)
        subject.spam?
      end

      context 'the text is spam' do
        before do
          allow(fake_akismet_client).to receive(:check).and_return([true, false])
        end

        specify do
          expect(subject.spam?).to be_truthy
        end
      end

      context 'the text is blatant spam' do
        before do
          allow(fake_akismet_client).to receive(:check).and_return([false, true])
        end

        specify do
          expect(subject.spam?).to be_truthy
        end
      end

      context 'the text is not spam' do
        before do
          allow(fake_akismet_client).to receive(:check).and_return([false, false])
        end

        specify do
          expect(subject.spam?).to be_falsey
        end
      end

      describe 'error handling' do
        before do
          allow(fake_akismet_client).to receive(:check).and_raise(error)
        end

        context 'StandardError other than ArgumentError is raised' do
          let(:error) { Akismet::Error.new(""Lovely spam! Wonderful spam!"") }

          specify do
            expect(subject.spam?).to be_falsey
          end

          it 'logs an error' do
            expect(Gitlab::AppLogger).to receive(:error).with(/Error during Akismet.*flagging as not spam.*Lovely spam/)

            subject.spam?
          end
        end

        context 'ArgumentError is raised in dev' do
          let(:error) { ArgumentError }

          it 'raises original error' do
            expect { subject.spam? }.to raise_error(error)
          end
        end
      end
    end
  end

  describe '#submit_ham' do
    it_behaves_like 'no activity if Akismet is not enabled', :submit_ham
    it_behaves_like 'false if Akismet is not available', :submit_ham

    context 'if Akismet is available' do
      specify do
        expect(fake_akismet_client).to receive(:public_send).with(:ham, any_args)

        expect(subject.submit_ham).to be_truthy
      end
    end
  end

  describe '#submit_spam' do
    it_behaves_like 'no activity if Akismet is not enabled', :submit_spam
    it_behaves_like 'false if Akismet is not available', :submit_spam

    context 'if Akismet is available' do
      specify do
        expect(fake_akismet_client).to receive(:public_send).with(:spam, any_args)

        expect(subject.submit_spam).to be_truthy
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Spam
  class SpamVerdictService
    include AkismetMethods
    include SpamConstants

    def initialize(user:, target:, options:, context: {}, extra_features: {})
      @target = target
      @user = user
      @options = options
      @context = context
      @extra_features = extra_features
    end

    def execute
      spamcheck_verdict = nil

      external_spam_check_round_trip_time = Benchmark.realtime do
        spamcheck_verdict = get_spamcheck_verdict
      end

      histogram.observe({ result: spamcheck_verdict.upcase }, external_spam_check_round_trip_time) if spamcheck_verdict

      akismet_verdict = get_akismet_verdict

      # filter out anything we don't recognise, including nils.
      valid_verdicts = [spamcheck_verdict, akismet_verdict].compact.select { |r| SUPPORTED_VERDICTS.key?(r) }

      # Treat nils - such as service unavailable - as ALLOW
      return ALLOW unless valid_verdicts.any?

      # Favour the most restrictive verdict
      final_verdict = valid_verdicts.min_by { |v| SUPPORTED_VERDICTS[v][:priority] }

      # The target can override the verdict via the `allow_possible_spam` application setting
      final_verdict = OVERRIDE_VIA_ALLOW_POSSIBLE_SPAM if override_via_allow_possible_spam?(verdict: final_verdict)

      logger.info(
        class: self.class.name,
        akismet_verdict: akismet_verdict,
        spam_check_verdict: spamcheck_verdict,
        spam_check_rtt: external_spam_check_round_trip_time.real,
        final_verdict: final_verdict,
        username: user.username,
        user_id: user.id,
        target_type: target.class.to_s,
        project_id: target.project_id
      )

      final_verdict
    end

    private

    attr_reader :user, :target, :options, :context, :extra_features

    def get_akismet_verdict
      if akismet.spam?
        Gitlab::Recaptcha.enabled? ? CONDITIONAL_ALLOW : DISALLOW
      else
        ALLOW
      end
    end

    def get_spamcheck_verdict
      return unless Gitlab::CurrentSettings.spam_check_endpoint_enabled

      begin
        result = spamcheck_client.spam?(spammable: target, user: user, context: context, extra_features: extra_features)

        if result.evaluated?
          Abuse::TrustScore.create!(user: user, score: result.score, source: :spamcheck)
        end

        result.verdict

      rescue StandardError => e
        Gitlab::ErrorTracking.log_exception(e, error: ERROR_TYPE)
        nil
      end
    end

    def override_via_allow_possible_spam?(verdict:)
      # If the verdict is already going to allow (because current verdict's priority value is greater
      # than the override verdict's priority value), then we don't need to override it.
      return false if SUPPORTED_VERDICTS[verdict][:priority] > SUPPORTED_VERDICTS[OVERRIDE_VIA_ALLOW_POSSIBLE_SPAM][:priority]

      allow_possible_spam?
    end

    def allow_possible_spam?
      target.allow_possible_spam?(user) || user.trusted?
    end

    def spamcheck_client
      @spamcheck_client ||= Gitlab::Spamcheck::Client.new
    end

    def logger
      @logger ||= Gitlab::AppJsonLogger.build
    end

    def histogram
      @histogram ||= Gitlab::Metrics.histogram(:gitlab_spamcheck_request_duration_seconds, 'Request duration to the anti-spam service')
    end
  end
end

Spam::SpamVerdictService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Spam::SpamVerdictService, feature_category: :instance_resiliency do
  include_context 'includes Spam constants'

  let(:fake_ip) { '1.2.3.4' }
  let(:fake_user_agent) { 'fake-user-agent' }
  let(:fake_referer) { 'fake-http-referer' }
  let(:env) do
    { 'action_dispatch.remote_ip' => fake_ip,
      'HTTP_USER_AGENT' => fake_user_agent,
      'HTTP_REFERER' => fake_referer }
  end

  let(:verdict_value) { ::Spamcheck::SpamVerdict::Verdict::ALLOW }
  let(:verdict_score) { 0.01 }
  let(:verdict_evaluated) { true }

  let(:response) do
    response = ::Spamcheck::SpamVerdict.new
    response.verdict = verdict_value
    response.score = verdict_score
    response.evaluated = verdict_evaluated
    response
  end

  let(:spam_client_result) do
    Gitlab::Spamcheck::Result.new(response)
  end

  let(:check_for_spam) { true }
  let_it_be_with_reload(:user) { create(:user) }
  let_it_be(:issue) { create(:issue, author: user) }
  let_it_be(:snippet) { create(:personal_snippet, :public, author: user) }

  let(:service) do
    described_class.new(user: user, target: target, options: {})
  end

  shared_examples 'execute spam verdict service' do
    subject(:execute) { service.execute }

    before do
      allow(service).to receive(:get_akismet_verdict).and_return(nil)
      allow(service).to receive(:get_spamcheck_verdict).and_return(nil)
    end

    context 'if all services return nil' do
      it 'renders ALLOW verdict' do
        is_expected.to eq ALLOW
      end
    end

    context 'if only one service returns a verdict' do
      context 'and it is supported' do
        before do
          allow(service).to receive(:get_akismet_verdict).and_return(DISALLOW)
        end

        it 'renders that verdict' do
          is_expected.to eq DISALLOW
        end
      end

      context 'and it is unexpected' do
        before do
          allow(service).to receive(:get_akismet_verdict).and_return(""unexpected"")
        end

        it 'allows' do
          is_expected.to eq ALLOW
        end
      end
    end

    context 'if more than one service returns a verdict' do
      context 'and they are supported' do
        before do
          allow(service).to receive(:get_akismet_verdict).and_return(DISALLOW)
          allow(service).to receive(:get_spamcheck_verdict).and_return(BLOCK_USER)
        end

        it 'renders the more restrictive verdict' do
          is_expected.to eq BLOCK_USER
        end
      end

      context 'and one is supported' do
        before do
          allow(service).to receive(:get_akismet_verdict).and_return('nonsense')
          allow(service).to receive(:get_spamcheck_verdict).and_return(BLOCK_USER)
        end

        it 'renders the more restrictive verdict' do
          is_expected.to eq BLOCK_USER
        end
      end

      context 'and none are supported' do
        before do
          allow(service).to receive(:get_akismet_verdict).and_return('nonsense')
          allow(service).to receive(:get_spamcheck_verdict).and_return('rubbish')
        end

        it 'renders the more restrictive verdict' do
          is_expected.to eq ALLOW
        end
      end
    end

    context 'if allow_possible_spam application setting is true' do
      before do
        stub_application_setting(allow_possible_spam: true)
      end

      context 'and a service returns a verdict that should be overridden' do
        before do
          allow(service).to receive(:get_spamcheck_verdict).and_return(BLOCK_USER)
        end

        it 'overrides and renders the override verdict' do
          is_expected.to eq OVERRIDE_VIA_ALLOW_POSSIBLE_SPAM
        end
      end

      context 'and a service returns a verdict that does not need to be overridden' do
        before do
          allow(service).to receive(:get_spamcheck_verdict).and_return(ALLOW)
        end

        it 'does not override and renders the original verdict' do
          is_expected.to eq ALLOW
        end
      end
    end

    context 'if user is trusted to create possible spam' do
      before do
        user.custom_attributes.create!(key: 'trusted_by', value: 'does not matter')
      end

      context 'and a service returns a verdict that should be overridden' do
        before do
          allow(service).to receive(:get_spamcheck_verdict).and_return(BLOCK_USER)
        end

        it 'overrides and renders the override verdict' do
          is_expected.to eq OVERRIDE_VIA_ALLOW_POSSIBLE_SPAM
        end
      end

      context 'and a service returns a verdict that does not need to be overridden' do
        before do
          allow(service).to receive(:get_spamcheck_verdict).and_return(ALLOW)
        end

        it 'does not override and renders the original verdict' do
          is_expected.to eq ALLOW
        end
      end
    end

    context 'records metrics' do
      let(:histogram) { instance_double(Prometheus::Client::Histogram) }

      using RSpec::Parameterized::TableSyntax

      where(:verdict, :label) do
        Spam::SpamConstants::ALLOW             |  'ALLOW'
        Spam::SpamConstants::CONDITIONAL_ALLOW |  'CONDITIONAL_ALLOW'
        Spam::SpamConstants::BLOCK_USER        |  'BLOCK'
        Spam::SpamConstants::DISALLOW          |  'DISALLOW'
        Spam::SpamConstants::NOOP              |  'NOOP'
      end

      with_them do
        before do
          allow(Gitlab::Metrics).to receive(:histogram).with(:gitlab_spamcheck_request_duration_seconds, anything).and_return(histogram)
          allow(service).to receive(:get_spamcheck_verdict).and_return(verdict)
        end

        it 'records duration with labels' do
          expect(histogram).to receive(:observe).with(a_hash_including(result: label), anything)
          execute
        end
      end
    end
  end

  shared_examples 'akismet verdict' do
    let(:target) { issue }

    subject(:get_akismet_verdict) { service.send(:get_akismet_verdict) }

    context 'if Akismet is enabled' do
      before do
        stub_application_setting(akismet_enabled: true)
        allow_next_instance_of(Spam::AkismetService) do |service|
          allow(service).to receive(:spam?).and_return(akismet_result)
        end
      end

      context 'if Akismet considers it spam' do
        let(:akismet_result) { true }

        context 'if reCAPTCHA is enabled' do
          before do
            stub_application_setting(recaptcha_enabled: true)
          end

          it 'returns conditionally allow verdict' do
            is_expected.to eq CONDITIONAL_ALLOW
          end
        end

        context 'if reCAPTCHA is not enabled' do
          before do
            stub_application_setting(recaptcha_enabled: false)
          end

          it 'renders disallow verdict' do
            is_expected.to eq DISALLOW
          end
        end
      end

      context 'if Akismet does not consider it spam' do
        let(:akismet_result) { false }

        it 'renders allow verdict' do
          is_expected.to eq ALLOW
        end
      end
    end

    context 'if Akismet is not enabled' do
      before do
        stub_application_setting(akismet_enabled: false)
      end

      it 'renders allow verdict' do
        is_expected.to eq ALLOW
      end
    end
  end

  shared_examples 'spamcheck verdict' do
    subject(:get_spamcheck_verdict) { service.send(:get_spamcheck_verdict) }

    context 'if a Spam Check endpoint enabled and set to a URL' do
      let(:spam_check_body) { {} }
      let(:endpoint_url) { ""grpc://www.spamcheckurl.com/spam_check"" }

      let(:spam_client) do
        Gitlab::Spamcheck::Client.new
      end

      before do
        stub_application_setting(spam_check_endpoint_enabled: true)
        stub_application_setting(spam_check_endpoint_url: endpoint_url)
      end

      context 'if the endpoint is accessible' do
        let(:user_scores) { Abuse::UserTrustScore.new(user) }

        before do
          allow(service).to receive(:spamcheck_client).and_return(spam_client)
          allow(spam_client).to receive(:spam?).and_return(spam_client_result)
        end

        context 'if the result is a NOOP verdict' do
          let(:verdict_evaluated) { false }
          let(:verdict_value) { ::Spamcheck::SpamVerdict::Verdict::NOOP }

          it 'returns the verdict' do
            is_expected.to eq(NOOP)
            expect(user_scores.spam_score).to eq(0.0)
          end
        end

        context 'the result is a valid verdict' do
          let(:verdict_score) { 0.05 }
          let(:verdict_value) { ::Spamcheck::SpamVerdict::Verdict::ALLOW }

          context 'the result was evaluated' do
            it 'returns the verdict and updates the spam score' do
              is_expected.to eq(ALLOW)
              expect(user_scores.spam_score).to be_within(0.000001).of(verdict_score)
            end
          end

          context 'the result was not evaluated' do
            let(:verdict_evaluated) { false }

            it 'returns the verdict and does not update the spam score' do
              expect(subject).to eq(ALLOW)
              expect(user_scores.spam_score).to eq(0.0)
            end
          end
        end

        context 'when recaptcha is enabled' do
          before do
            allow(Gitlab::Recaptcha).to receive(:enabled?).and_return(true)
          end

          using RSpec::Parameterized::TableSyntax

          where(:verdict_value, :expected, :verdict_score) do
            ::Spamcheck::SpamVerdict::Verdict::ALLOW              | ::Spam::SpamConstants::ALLOW              | 0.1
            ::Spamcheck::SpamVerdict::Verdict::CONDITIONAL_ALLOW  | ::Spam::SpamConstants::CONDITIONAL_ALLOW  | 0.5
            ::Spamcheck::SpamVerdict::Verdict::DISALLOW           | ::Spam::SpamConstants::DISALLOW           | 0.8
            ::Spamcheck::SpamVerdict::Verdict::BLOCK              | ::Spam::SpamConstants::BLOCK_USER         | 0.9
          end

          with_them do
            it ""returns expected spam constant and updates the spam score"" do
              is_expected.to eq(expected)
              expect(user_scores.spam_score).to be_within(0.000001).of(verdict_score)
            end
          end
        end

        context 'when recaptcha is disabled' do
          before do
            allow(Gitlab::Recaptcha).to receive(:enabled?).and_return(false)
          end

          using RSpec::Parameterized::TableSyntax

          where(:verdict_value, :expected) do
            ::Spamcheck::SpamVerdict::Verdict::ALLOW              | ::Spam::SpamConstants::ALLOW
            ::Spamcheck::SpamVerdict::Verdict::CONDITIONAL_ALLOW  | ::Spam::SpamConstants::CONDITIONAL_ALLOW
            ::Spamcheck::SpamVerdict::Verdict::DISALLOW           | ::Spam::SpamConstants::DISALLOW
            ::Spamcheck::SpamVerdict::Verdict::BLOCK              | ::Spam::SpamConstants::BLOCK_USER
          end

          with_them do
            it ""returns expected spam constant"" do
              is_expected.to eq(expected)
            end
          end
        end

        context 'the requested is aborted' do
          before do
            allow(spam_client).to receive(:spam?).and_raise(GRPC::Aborted)
          end

          it 'returns nil' do
            expect(Gitlab::ErrorTracking).to receive(:log_exception).with(
              an_instance_of(GRPC::Aborted), error: ::Spam::SpamConstants::ERROR_TYPE
            )
            is_expected.to be_nil
          end
        end

        context 'if the endpoint times out' do
          before do
            allow(spam_client).to receive(:spam?).and_raise(GRPC::DeadlineExceeded)
          end

          it 'returns nil' do
            expect(Gitlab::ErrorTracking).to receive(:log_exception).with(
              an_instance_of(GRPC::DeadlineExceeded), error: ::Spam::SpamConstants::ERROR_TYPE
            )
            is_expected.to be_nil
          end
        end
      end
    end

    context 'if a Spam Check endpoint is not set' do
      before do
        stub_application_setting(spam_check_endpoint_url: nil)
      end

      it 'returns nil' do
        is_expected.to be_nil
      end
    end

    context 'if Spam Check endpoint is not enabled' do
      before do
        stub_application_setting(spam_check_endpoint_enabled: false)
      end

      it 'returns nil' do
        is_expected.to be_nil
      end
    end
  end

  describe '#execute' do
    describe 'issue' do
      let(:target) { issue }

      context 'when issue is publicly visible' do
        before do
          allow(issue).to receive(:publicly_visible?).and_return(true)
        end

        it_behaves_like 'execute spam verdict service'
      end

      context 'when issue is not publicly visible' do
        before do
          allow(issue).to receive(:publicly_visible?).and_return(false)
          allow(service).to receive(:get_spamcheck_verdict).and_return(BLOCK_USER)
        end

        it 'overrides and renders the override verdict' do
          expect(service.execute).to eq OVERRIDE_VIA_ALLOW_POSSIBLE_SPAM
        end
      end
    end

    describe 'snippet' do
      let(:target) { snippet }

      it_behaves_like 'execute spam verdict service'
    end
  end

  describe '#get_akismet_verdict' do
    describe 'issue' do
      let(:target) { issue }

      it_behaves_like 'akismet verdict'
    end

    describe 'snippet' do
      let(:target) { snippet }

      it_behaves_like 'akismet verdict'
    end
  end

  describe '#get_spamcheck_verdict' do
    describe 'issue' do
      let(:target) { issue }

      it_behaves_like 'spamcheck verdict'
    end

    describe 'snippet' do
      let(:target) { snippet }

      it_behaves_like 'spamcheck verdict'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Spam
  class AkismetMarkAsSpamService
    include ::AkismetMethods

    attr_accessor :target, :options

    def initialize(target:)
      @target = target
      @options = {}
    end

    def execute
      @options[:ip_address] = @target.ip_address
      @options[:user_agent] = @target.user_agent

      return unless target.submittable_as_spam?
      return unless akismet.submit_spam

      target.user_agent_detail.update_attribute(:submitted, true)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Spam::AkismetMarkAsSpamService, feature_category: :instance_resiliency do
  let(:user_agent_detail) { build(:user_agent_detail) }
  let(:spammable) { build(:issue, user_agent_detail: user_agent_detail) }
  let(:fake_akismet_service) { double(:akismet_service, submit_spam: true) }

  subject { described_class.new(target: spammable) }

  describe '#execute' do
    before do
      allow(subject).to receive(:akismet).and_return(fake_akismet_service)
    end

    context 'when the spammable object is not submittable' do
      before do
        allow(spammable).to receive(:submittable_as_spam?).and_return false
      end

      it 'does not submit as spam' do
        expect(subject.execute).to be_falsey
      end
    end

    context 'spam is submitted successfully' do
      before do
        allow(spammable).to receive(:submittable_as_spam?).and_return true
        allow(fake_akismet_service).to receive(:submit_spam).and_return true
      end

      it 'submits as spam' do
        expect(subject.execute).to be_truthy
      end

      it ""updates the spammable object's user agent detail as being submitted as spam"" do
        expect(user_agent_detail).to receive(:update_attribute)

        subject.execute
      end

      context 'when Akismet does not consider it spam' do
        it 'does not update the spammable object as spam' do
          allow(fake_akismet_service).to receive(:submit_spam).and_return false

          expect(subject.execute).to be_falsey
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Spam
  ##
  # This class is a Parameter Object (https://refactoring.com/catalog/introduceParameterObject.html)
  # which acts as an container abstraction for multiple values related to spam and
  # captcha processing for a provided HTTP request object.
  #
  # It is used to encapsulate these values and allow them to be passed from the Controller/GraphQL
  # layers down into to the Service layer, without needing to pass the entire request and therefore
  # unnecessarily couple the Service layer to the HTTP request.
  #
  # Values contained are:
  #
  # captcha_response: The response resulting from the user solving a captcha.  Currently it is
  #   a scalar reCAPTCHA response string, but it can be expanded to an object in the future to
  #   support other captcha implementations such as FriendlyCaptcha. Obtained from
  #   request.headers['X-GitLab-Captcha-Response']
  # spam_log_id: The id of a SpamLog record. Obtained from request.headers['X-GitLab-Spam-Log-Id']
  # ip_address = The remote IP. Obtained from request.env['action_dispatch.remote_ip']
  # user_agent = The user agent. Obtained from request.env['HTTP_USER_AGENT']
  # referer = The HTTP referer. Obtained from request.env['HTTP_REFERER']
  #
  # NOTE: The presence of these values in the request is not currently enforced. If they are missing,
  #      then the spam check may fail, or the SpamLog or UserAgentDetail may have missing fields.
  class SpamParams
    def self.new_from_request(request:)
      self.normalize_grape_request_headers(request: request)
      self.new(
        captcha_response: request.headers['X-GitLab-Captcha-Response'],
        spam_log_id: request.headers['X-GitLab-Spam-Log-Id'],
        ip_address: request.env['action_dispatch.remote_ip'].to_s,
        user_agent: request.env['HTTP_USER_AGENT'],
        referer: request.env['HTTP_REFERER']
      )
    end

    attr_reader :captcha_response, :spam_log_id, :ip_address, :user_agent, :referer

    def initialize(captcha_response:, spam_log_id:, ip_address:, user_agent:, referer:)
      @captcha_response = captcha_response
      @spam_log_id = spam_log_id
      @ip_address = ip_address
      @user_agent = user_agent
      @referer = referer
    end

    def ==(other)
      other.class <= self.class &&
        other.captcha_response == captcha_response &&
        other.spam_log_id == spam_log_id &&
        other.ip_address == ip_address &&
        other.user_agent == user_agent &&
        other.referer == referer
    end

    def self.normalize_grape_request_headers(request:)
      # If needed, make a normalized copy of Grape headers with the case of 'GitLab' (with an
      # uppercase 'L') instead of 'Gitlab' (with a lowercase 'l'), because Grape header helper keys
      # are ""coerced into a capitalized kebab case"". See https://github.com/ruby-grape/grape#request
      %w[X-Gitlab-Captcha-Response X-Gitlab-Spam-Log-Id].each do |header|
        request.headers[header.gsub('Gitlab', 'GitLab')] = request.headers[header] if request.headers.key?(header)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Spam::SpamParams, feature_category: :instance_resiliency do
  shared_examples 'constructs from a request' do
    it 'constructs from a request' do
      expected = ::Spam::SpamParams.new(
        captcha_response: captcha_response,
        spam_log_id: spam_log_id,
        ip_address: ip_address,
        user_agent: user_agent,
        referer: referer
      )
      expect(described_class.new_from_request(request: request)).to eq(expected)
    end
  end

  describe '.new_from_request' do
    let(:captcha_response) { 'abc123' }
    let(:spam_log_id) { 42 }
    let(:ip_address) { '0.0.0.0' }
    let(:user_agent) { 'Lynx' }
    let(:referer) { 'http://localhost' }

    let(:env) do
      {
        'action_dispatch.remote_ip' => ip_address,
        'HTTP_USER_AGENT' => user_agent,
        'HTTP_REFERER' => referer
      }
    end

    let(:request) { double(:request, headers: headers, env: env) }

    context 'with a normal Rails request' do
      let(:headers) do
        {
          'X-GitLab-Captcha-Response' => captcha_response,
          'X-GitLab-Spam-Log-Id' => spam_log_id
        }
      end

      it_behaves_like 'constructs from a request'
    end

    context 'with a grape request' do
      let(:headers) do
        {
          'X-Gitlab-Captcha-Response' => captcha_response,
          'X-Gitlab-Spam-Log-Id' => spam_log_id
        }
      end

      it_behaves_like 'constructs from a request'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Releases
  class CreateEvidenceService
    def initialize(release, pipeline: nil)
      @release = release
      @pipeline = pipeline
    end

    def execute
      evidence = release.evidences.build

      summary = ::Evidences::EvidenceSerializer.new.represent(evidence, evidence_options) # rubocop: disable CodeReuse/Serializer
      evidence.summary = summary
      # TODO: fix the sha generation https://gitlab.com/groups/gitlab-org/-/epics/3683
      evidence.summary_sha = Gitlab::CryptoHelper.sha256(summary)

      evidence.save!
    end

    private

    attr_reader :release, :pipeline

    def evidence_options
      {}
    end
  end
end

Releases::CreateEvidenceService.prepend_mod_with('Releases::CreateEvidenceService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Releases::CreateEvidenceService, feature_category: :release_orchestration do
  let_it_be(:project) { create(:project) }

  let(:release) { create(:release, project: project) }
  let(:service) { described_class.new(release) }

  it 'creates evidence' do
    expect { service.execute }.to change { release.reload.evidences.count }.by(1)
  end

  it 'saves evidence summary' do
    service.execute
    evidence = Releases::Evidence.last

    expect(release.tag).not_to be_nil
    expect(evidence.summary[""release""][""tag_name""]).to eq(release.tag)
  end

  it 'saves sha' do
    service.execute
    evidence = Releases::Evidence.last

    expect(evidence.summary_sha).not_to be_nil
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Releases
  class DestroyService < Releases::BaseService
    def execute
      return error(_('Release does not exist'), 404) unless release
      return error(_('Access Denied'), 403) unless allowed?

      if release.destroy
        update_catalog_resource!

        execute_hooks(release, 'delete')

        audit(release, action: :deleted)

        success(tag: existing_tag, release: release)
      else
        error(release.errors.messages || '400 Bad request', 400)
      end
    end

    private

    def update_catalog_resource!
      return unless project.catalog_resource

      return unless project.catalog_resource.versions.none?

      project.catalog_resource.update!(state: 'draft')
    end

    def allowed?
      Ability.allowed?(current_user, :destroy_release, release)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Releases::DestroyService, feature_category: :release_orchestration do
  let(:project) { create(:project, :repository) }
  let(:mainatiner) { create(:user) }
  let(:repoter) { create(:user) }
  let(:tag) { 'v1.1.0' }
  let!(:release) { create(:release, project: project, tag: tag) }
  let(:service) { described_class.new(project, user, params) }
  let(:params) { { tag: tag } }
  let(:user) { mainatiner }

  before do
    project.add_maintainer(mainatiner)
    project.add_reporter(repoter)
  end

  describe '#execute' do
    subject { service.execute }

    context 'when there is a release' do
      it 'removes the release' do
        expect { subject }.to change { project.releases.count }.by(-1)
      end

      it 'returns the destroyed object' do
        is_expected.to include(status: :success, release: release)
      end

      context 'when the release is for a catalog resource' do
        let!(:catalog_resource) { create(:ci_catalog_resource, :published, project: project) }
        let!(:version) { create(:ci_catalog_resource_version, catalog_resource: catalog_resource, release: release) }

        it 'does not update the catalog resources if there are still releases' do
          second_release = create(:release, project: project, tag: 'v1.2.0')
          create(:ci_catalog_resource_version, catalog_resource: catalog_resource, release: second_release)

          subject

          expect(catalog_resource.reload.state).to eq('published')
        end

        it 'updates the catalog resource if there are no more releases' do
          subject

          expect(catalog_resource.reload.state).to eq('draft')
        end
      end
    end

    context 'when tag does not exist in the repository' do
      let(:tag) { 'v1.1.1' }

      it 'removes the orphaned release' do
        expect { subject }.to change { project.releases.count }.by(-1)
      end
    end

    context 'when release is not found' do
      let!(:release) {}

      it 'returns an error' do
        is_expected.to include(status: :error, message: 'Release does not exist', http_status: 404)
      end
    end

    context 'when user does not have permission' do
      let(:user) { repoter }

      it 'returns an error' do
        is_expected.to include(status: :error, message: 'Access Denied', http_status: 403)
      end
    end

    context 'when a milestone is tied to the release' do
      let!(:milestone) { create(:milestone, :active, project: project, title: 'v1.0') }
      let!(:release) { create(:release, milestones: [milestone], project: project, tag: tag) }

      it 'destroys the release but leave the milestone intact' do
        expect { subject }.not_to change { Milestone.count }
        expect(milestone.reload).to be_persisted
      end
    end

    it 'executes hooks' do
      expect(service.release).to receive(:execute_hooks).with('delete')

      service.execute
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Releases
  class UpdateService < Releases::BaseService
    def execute
      if error = validate
        return error
      end

      if param_for_milestones_provided?
        previous_milestones = release.milestones.map(&:id)
        params[:milestones] = milestones
      end

      # transaction needed as Rails applies `save!` to milestone_releases
      # when it does assign_attributes instead of actual saving
      # this leads to the validation error being raised
      # see https://gitlab.com/gitlab-org/gitlab/-/merge_requests/43385
      ApplicationRecord.transaction do
        if release.update(params)
          execute_hooks(release, 'update')
          audit(release, action: :updated)
          audit(release, action: :milestones_updated) if milestones_updated?(previous_milestones)
          success(tag: existing_tag, release: release, milestones_updated: milestones_updated?(previous_milestones))
        else
          error(release.errors.messages || '400 Bad request', 400)
        end
      rescue ActiveRecord::RecordInvalid => e
        error(e.message || '400 Bad request', 400)
      end
    end

    private

    def validate
      return error(_('Tag does not exist'), 404) unless existing_tag
      return error(_('Release does not exist'), 404) unless release
      return error(_('Access Denied'), 403) unless allowed?
      return error(_('params is empty'), 400) if empty_params?
      return error(format(_(""Milestone(s) not found: %{milestones}""), milestones: inexistent_milestone_titles.join(', ')), 400) if inexistent_milestone_titles.any? # rubocop:disable Layout/LineLength
      return error(format(_(""Milestone id(s) not found: %{milestones}""), milestones: inexistent_milestone_ids.join(', ')), 400) if inexistent_milestone_ids.any? # rubocop:disable Layout/LineLength
    end

    def allowed?
      Ability.allowed?(current_user, :update_release, release)
    end

    def empty_params?
      params.except(:tag).empty?
    end

    def milestones_updated?(previous_milestones)
      return false unless param_for_milestones_provided?

      previous_milestones.to_set != release.milestones.map(&:id)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Releases::UpdateService, feature_category: :continuous_integration do
  let(:project) { create(:project, :repository) }
  let(:user) { create(:user) }
  let(:new_name) { 'A new name' }
  let(:new_description) { 'The best release!' }
  let(:params) { { name: new_name, description: new_description, tag: tag_name } }
  let(:service) { described_class.new(project, user, params) }
  let!(:release) { create(:release, project: project, author: user, tag: tag_name) }
  let(:tag_name) { 'v1.1.0' }

  before do
    project.add_developer(user)
  end

  describe '#execute' do
    shared_examples 'a failed update' do
      it 'raises an error' do
        result = service.execute
        expect(result[:status]).to eq(:error)
        expect(result[:milestones_updated]).to be_falsy
      end
    end

    it 'successfully updates an existing release' do
      result = service.execute
      expect(result[:status]).to eq(:success)
      expect(result[:release].name).to eq(new_name)
      expect(result[:release].description).to eq(new_description)
    end

    it 'executes hooks' do
      expect(service.release).to receive(:execute_hooks).with('update')

      service.execute
    end

    context 'when the tag does not exists' do
      let(:tag_name) { 'foobar' }

      it_behaves_like 'a failed update'
    end

    context 'when the release does not exist' do
      let!(:release) {}

      it_behaves_like 'a failed update'
    end

    context 'when a milestone is passed in' do
      let(:milestone) { create(:milestone, project: project, title: 'v1.0') }
      let(:params_with_milestone) { params.merge!({ milestones: [new_title] }) }
      let(:new_milestone) { create(:milestone, project: project, title: new_title) }
      let(:service) { described_class.new(new_milestone.project, user, params_with_milestone) }

      before do
        release.milestones << milestone
      end

      shared_examples 'updates milestones' do
        it 'updates the related milestone accordingly' do
          release.reload
          result = service.execute

          expect(release.milestones.first.title).to eq(new_title)
          expect(result[:milestones_updated]).to be_truthy
        end
      end

      context 'a different milestone' do
        let(:new_title) { 'v2.0' }

        it_behaves_like 'updates milestones'
      end

      context 'an identical milestone' do
        let(:new_title) { 'v1.0' }

        it ""raises an error"" do
          expect { service.execute }.to raise_error(ActiveRecord::RecordInvalid)
        end
      end

      context 'by ids' do
        let(:new_title) { 'v2.0' }
        let(:params_with_milestone) { params.merge!({ milestone_ids: [new_milestone.id] }) }

        it_behaves_like 'updates milestones'
      end
    end

    context ""when an 'empty' milestone is passed in"" do
      let(:milestone) { create(:milestone, project: project, title: 'v1.0') }

      before do
        release.milestones << milestone

        service.params = params_with_empty_milestone
      end

      shared_examples 'removes milestones' do
        it 'removes the old milestone and does not associate any new milestone' do
          result = service.execute
          release.reload

          expect(release.milestones).not_to be_present
          expect(result[:milestones_updated]).to be_truthy
        end
      end

      context 'by title' do
        let(:params_with_empty_milestone) { params.merge!({ milestones: [] }) }

        it_behaves_like 'removes milestones'
      end

      context 'by id' do
        let(:params_with_empty_milestone) { params.merge!({ milestone_ids: [] }) }

        it_behaves_like 'removes milestones'
      end
    end

    context ""when multiple new milestones are passed in"" do
      let(:new_title_1) { 'v2.0' }
      let(:new_title_2) { 'v2.0-rc' }
      let(:milestone) { create(:milestone, project: project, title: 'v1.0') }
      let(:service) { described_class.new(project, user, params_with_milestones) }
      let!(:new_milestone_1) { create(:milestone, project: project, title: new_title_1) }
      let!(:new_milestone_2) { create(:milestone, project: project, title: new_title_2) }

      before do
        release.milestones << milestone
      end

      shared_examples 'updates multiple milestones' do
        it 'removes the old milestone and update the release with the new ones' do
          result = service.execute
          release.reload

          milestone_titles = release.milestones.map(&:title)
          expect(milestone_titles).to match_array([new_title_1, new_title_2])
          expect(result[:milestones_updated]).to be_truthy
        end
      end

      context 'by title' do
        let(:params_with_milestones) { params.merge!({ milestones: [new_title_1, new_title_2] }) }

        it_behaves_like 'updates multiple milestones'
      end

      context 'by id' do
        let(:params_with_milestones) { params.merge!({ milestone_ids: [new_milestone_1.id, new_milestone_2.id] }) }

        it_behaves_like 'updates multiple milestones'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Releases
  class CreateService < Releases::BaseService
    def execute
      return error(_('Access Denied'), 403) unless allowed?
      return error(_('You are not allowed to create this tag as it is protected.'), 403) unless can_create_tag?
      return error(_('Release already exists'), 409) if release
      return error(format(_(""Milestone(s) not found: %{milestones}""), milestones: inexistent_milestone_titles.join(', ')), 400) if inexistent_milestone_titles.any? # rubocop:disable Layout/LineLength
      return error(format(_(""Milestone id(s) not found: %{milestones}""), milestones: inexistent_milestone_ids.join(', ')), 400) if inexistent_milestone_ids.any? # rubocop:disable Layout/LineLength

      # should be found before the creation of new tag
      # because tag creation can spawn new pipeline
      # which won't have any data for evidence yet
      evidence_pipeline = Releases::EvidencePipelineFinder.new(project, params).execute

      tag = ensure_tag

      return tag unless tag.is_a?(Gitlab::Git::Tag)

      create_release(tag, evidence_pipeline)
    end

    private

    def ensure_tag
      existing_tag || create_tag
    end

    def create_tag
      return error('Ref is not specified', 422) unless ref

      result = Tags::CreateService
        .new(project, current_user)
        .execute(tag_name, ref, tag_message)

      return result unless result[:status] == :success

      result[:tag]
    end

    def allowed?
      Ability.allowed?(current_user, :create_release, project)
    end

    def can_create_tag?
      ::Gitlab::UserAccess.new(current_user, container: project).can_create_tag?(tag_name)
    end

    def create_release(tag, evidence_pipeline)
      release = build_release(tag)

      if project.catalog_resource && release.valid?
        response = Ci::Catalog::Resources::ReleaseService.new(release).execute

        return error(response.message, 422) if response.error?
      end

      release.save!

      notify_create_release(release)

      execute_hooks(release, 'create')

      create_evidence!(release, evidence_pipeline)

      audit(release, action: :created)

      success(tag: tag, release: release)
    rescue StandardError => e
      error(e.message, 400)
    end

    def notify_create_release(release)
      NotificationService.new.async.send_new_release_notifications(release)
    end

    def build_release(tag)
      project.releases.build(
        name: name,
        description: description,
        author: current_user,
        tag: tag.name,
        sha: tag.dereferenced_target.sha,
        released_at: released_at,
        links_attributes: links_attributes,
        milestones: milestones
      )
    end

    def links_attributes
      (params.dig(:assets, 'links') || []).map do |link_params|
        Releases::Links::Params.new(link_params).allowed_params
      end
    end

    def create_evidence!(release, pipeline)
      return if release.historical_release? || release.upcoming_release?

      ::Releases::CreateEvidenceWorker.perform_async(release.id, pipeline&.id)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Releases::CreateService, feature_category: :continuous_integration do
  let(:project) { create(:project, :repository) }
  let(:user) { create(:user) }
  let(:tag_name) { project.repository.tag_names.first }
  let(:tag_message) { nil }
  let(:tag_sha) { project.repository.find_tag(tag_name).dereferenced_target.sha }
  let(:name) { 'Bionic Beaver' }
  let(:description) { 'Awesome release!' }
  let(:params) { { tag: tag_name, name: name, description: description, ref: ref, tag_message: tag_message } }
  let(:ref) { nil }
  let(:service) { described_class.new(project, user, params) }

  before do
    project.add_maintainer(user)
  end

  describe '#execute' do
    shared_examples 'a successful release creation' do
      it 'creates a new release' do
        expected_job_count = MailScheduler::NotificationServiceWorker.jobs.size + 1

        expect_next_instance_of(Release) do |release|
          expect(release)
            .to receive(:execute_hooks)
            .with('create')
        end

        result = service.execute

        expect(project.releases.count).to eq(1)
        expect(result[:status]).to eq(:success)
        expect(result[:tag]).not_to be_nil
        expect(result[:release]).not_to be_nil
        expect(result[:release].description).to eq(description)
        expect(result[:release].name).to eq(name)
        expect(result[:release].author).to eq(user)
        expect(result[:release].sha).to eq(tag_sha)
        expect(MailScheduler::NotificationServiceWorker.jobs.size).to eq(expected_job_count)
      end
    end

    it_behaves_like 'a successful release creation'

    context 'when the tag does not exist' do
      let(:tag_name) { 'non-exist-tag' }

      it 'raises an error' do
        result = service.execute

        expect(result[:status]).to eq(:error)
      end
    end

    context 'when project is a catalog resource' do
      let(:project) { create(:project, :catalog_resource_with_components, create_tag: 'final') }
      let!(:ci_catalog_resource) { create(:ci_catalog_resource, project: project) }
      let(:ref) { 'master' }

      context 'and it is valid' do
        it_behaves_like 'a successful release creation'
      end

      context 'and it is an invalid resource' do
        let_it_be(:project) { create(:project, :repository) }

        it 'raises an error and does not update the release' do
          result = service.execute

          expect(result[:status]).to eq(:error)
          expect(result[:http_status]).to eq(422)
          expect(result[:message]).to eq(
            'Project must have a description, ' \
            'Project must contain components. Ensure you are using the correct directory structure')
        end
      end
    end

    context 'when ref is provided' do
      let(:ref) { 'master' }
      let(:tag_name) { 'foobar' }

      it_behaves_like 'a successful release creation'

      it 'creates a tag if the tag does not exist' do
        expect(project.repository.ref_exists?(""refs/tags/#{tag_name}"")).to be_falsey

        result = service.execute
        expect(result[:status]).to eq(:success)
        expect(result[:tag]).not_to be_nil
        expect(result[:release]).not_to be_nil
      end

      context 'and the tag would be protected' do
        let!(:protected_tag) { create(:protected_tag, project: project, name: tag_name) }

        context 'and the user does not have permissions' do
          let(:user) { create(:user) }

          before do
            project.add_developer(user)
          end

          it 'raises an error' do
            result = service.execute

            expect(result[:status]).to eq(:error)
            expect(result[:http_status]).to eq(403)
          end
        end

        context 'and the user has permissions' do
          it_behaves_like 'a successful release creation'
        end
      end

      context 'and tag_message is provided' do
        let(:ref) { 'master' }
        let(:tag_name) { 'foobar' }
        let(:tag_message) { 'Annotated tag message' }

        it_behaves_like 'a successful release creation'

        it 'creates a tag if the tag does not exist' do
          expect(project.repository.ref_exists?(""refs/tags/#{tag_name}"")).to be_falsey

          result = service.execute
          expect(result[:status]).to eq(:success)
          expect(result[:tag]).not_to be_nil
          expect(result[:release]).not_to be_nil
          expect(project.repository.find_tag(tag_name).message).to eq(tag_message)
        end
      end
    end

    context 'there already exists a release on a tag' do
      let!(:release) do
        create(:release, project: project, tag: tag_name, description: description)
      end

      it 'raises an error and does not update the release' do
        result = service.execute
        expect(result[:status]).to eq(:error)
        expect(result[:http_status]).to eq(409)
        expect(project.releases.find_by(tag: tag_name).description).to eq(description)
      end
    end

    context 'when a passed-in milestone does not exist for this project' do
      it 'raises an error saying the milestone is inexistent' do
        inexistent_milestone_tag = 'v111.0'
        service = described_class.new(project, user, params.merge!({ milestones: [inexistent_milestone_tag] }))
        result = service.execute

        expect(result[:status]).to eq(:error)
        expect(result[:http_status]).to eq(400)
        expect(result[:message]).to eq(""Milestone(s) not found: #{inexistent_milestone_tag}"")
      end

      it 'raises an error saying the milestone id is inexistent' do
        inexistent_milestone_id = non_existing_record_id
        service = described_class.new(project, user, params.merge!({ milestone_ids: [inexistent_milestone_id] }))
        result = service.execute

        expect(result[:status]).to eq(:error)
        expect(result[:http_status]).to eq(400)
        expect(result[:message]).to eq(""Milestone id(s) not found: #{inexistent_milestone_id}"")
      end
    end

    context 'when existing milestone is passed in' do
      let(:title) { 'v1.0' }
      let(:milestone) { create(:milestone, :active, project: project, title: title) }
      let(:params_with_milestone) { params.merge!({ milestones: [title] }) }
      let(:service) { described_class.new(milestone.project, user, params_with_milestone) }

      shared_examples 'creates release' do
        it 'creates a release and ties this milestone to it' do
          result = service.execute

          expect(project.releases.count).to eq(1)
          expect(result[:status]).to eq(:success)

          release = project.releases.last

          expect(release.milestones).to match_array([milestone])
        end
      end

      context 'by title' do
        it_behaves_like 'creates release'
      end

      context 'by ids' do
        let(:params_with_milestone) { params.merge!({ milestone_ids: [milestone.id] }) }

        it_behaves_like 'creates release'
      end

      context 'when another release was previously created with that same milestone linked' do
        it 'also creates another release tied to that same milestone' do
          other_release = create(:release, milestones: [milestone], project: project, tag: 'v1.0')
          service.execute
          release = project.releases.last

          expect(release.milestones).to match_array([milestone])
          expect(other_release.milestones).to match_array([milestone])
          expect(release.id).not_to eq(other_release.id)
        end
      end
    end

    context 'when multiple existing milestones are passed in' do
      let(:title_1) { 'v1.0' }
      let(:title_2) { 'v1.0-rc' }
      let!(:milestone_1) { create(:milestone, :active, project: project, title: title_1) }
      let!(:milestone_2) { create(:milestone, :active, project: project, title: title_2) }

      shared_examples 'creates multiple releases' do
        it 'creates a release and ties it to these milestones' do
          described_class.new(project, user, params_with_milestones).execute
          release = project.releases.last

          expect(release.milestones.map(&:title)).to include(title_1, title_2)
        end
      end

      context 'by title' do
        let!(:params_with_milestones) { params.merge!({ milestones: [title_1, title_2] }) }

        it_behaves_like 'creates multiple releases'
      end

      context 'by ids' do
        let!(:params_with_milestones) { params.merge!({ milestone_ids: [milestone_1.id, milestone_2.id] }) }

        it_behaves_like 'creates multiple releases'
      end
    end

    context 'when multiple milestone titles are passed in but one of them does not exist' do
      let(:title) { 'v1.0' }
      let(:inexistent_title) { 'v111.0' }
      let!(:milestone) { create(:milestone, :active, project: project, title: title) }
      let!(:params_with_milestones) { params.merge!({ milestones: [title, inexistent_title] }) }
      let(:service) { described_class.new(milestone.project, user, params_with_milestones) }

      it 'raises an error' do
        result = service.execute

        expect(result[:status]).to eq(:error)
        expect(result[:http_status]).to eq(400)
        expect(result[:message]).to eq(""Milestone(s) not found: #{inexistent_title}"")
      end

      it 'does not create any release' do
        expect do
          service.execute
        end.not_to change(Release, :count)
      end

      context 'with milestones as ids' do
        let!(:params_with_milestones) { params.merge!({ milestone_ids: [milestone.id, non_existing_record_id] }) }

        it 'raises an error' do
          result = service.execute

          expect(result[:status]).to eq(:error)
          expect(result[:http_status]).to eq(400)
          expect(result[:message]).to eq(""Milestone id(s) not found: #{non_existing_record_id}"")
        end
      end
    end

    context 'no milestone association behavior' do
      let(:title_1) { 'v1.0' }
      let(:title_2) { 'v1.0-rc' }
      let!(:milestone_1) { create(:milestone, :active, project: project, title: title_1) }
      let!(:milestone_2) { create(:milestone, :active, project: project, title: title_2) }

      context 'when no milestones parameter is passed' do
        it 'creates a release without a milestone tied to it' do
          expect(service.param_for_milestone_titles_provided?).to be_falsey

          service.execute
          release = project.releases.last

          expect(release.milestones).to be_empty
        end

        it 'does not create any new MilestoneRelease object' do
          expect { service.execute }.not_to change { MilestoneRelease.count }
        end
      end

      context 'when an empty array is passed as the milestones parameter' do
        it 'creates a release without a milestone tied to it' do
          service = described_class.new(project, user, params.merge!({ milestones: [] }))
          service.execute
          release = project.releases.last

          expect(release.milestones).to be_empty
        end
      end

      context 'when nil is passed as the milestones parameter' do
        it 'creates a release without a milestone tied to it' do
          expect(service.param_for_milestone_titles_provided?).to be_falsey

          service = described_class.new(project, user, params.merge!({ milestones: nil }))
          service.execute
          release = project.releases.last

          expect(release.milestones).to be_empty
        end
      end
    end
  end

  context 'Evidence collection' do
    let(:sha) { project.repository.commit('master').sha }
    let(:params) do
      {
        name: 'New release',
        ref: 'master',
        tag: 'v0.1',
        description: 'Super nice release',
        released_at: released_at
      }.compact
    end

    let(:last_release) { project.releases.last }

    around do |example|
      freeze_time { example.run }
    end

    subject { service.execute }

    context 'historical release' do
      let(:released_at) { 3.weeks.ago }

      it 'does not execute CreateEvidenceWorker' do
        expect { subject }.not_to change(Releases::CreateEvidenceWorker.jobs, :size)
      end

      it 'does not create an Evidence object', :sidekiq_inline do
        expect { subject }.not_to change(Releases::Evidence, :count)
      end

      it 'is a historical release' do
        subject

        expect(last_release.historical_release?).to be_truthy
      end

      it 'is not an upcoming release' do
        subject

        expect(last_release.upcoming_release?).to be_falsy
      end
    end

    shared_examples 'uses the right pipeline for evidence' do
      it 'creates evidence without pipeline if it does not exist', :sidekiq_inline do
        expect_next_instance_of(Releases::CreateEvidenceService, anything, pipeline: nil) do |service|
          expect(service).to receive(:execute).and_call_original
        end

        expect { subject }.to change(Releases::Evidence, :count).by(1)
      end

      it 'uses the last pipeline for evidence', :sidekiq_inline do
        create(:ci_empty_pipeline, sha: sha, project: project) # old pipeline
        pipeline = create(:ci_empty_pipeline, sha: sha, project: project)

        expect_next_instance_of(Releases::CreateEvidenceService, anything, pipeline: pipeline) do |service|
          expect(service).to receive(:execute).and_call_original
        end

        expect { subject }.to change(Releases::Evidence, :count).by(1)
      end

      context 'when old evidence_pipeline is passed to service' do
        let!(:old_pipeline) { create(:ci_empty_pipeline, sha: sha, project: project) }
        let!(:new_pipeline) { create(:ci_empty_pipeline, sha: sha, project: project) }
        let(:params) do
          super().merge(
            evidence_pipeline: old_pipeline
          )
        end

        it 'uses the old pipeline for evidence', :sidekiq_inline do
          expect_next_instance_of(Releases::CreateEvidenceService, anything, pipeline: old_pipeline) do |service|
            expect(service).to receive(:execute).and_call_original
          end

          expect { subject }.to change(Releases::Evidence, :count).by(1)
        end
      end

      it 'pipeline is still being used for evidence if new pipeline is being created for tag', :sidekiq_inline do
        pipeline = create(:ci_empty_pipeline, sha: sha, project: project)

        expect(project.repository).to receive(:add_tag).and_wrap_original do |m, *args|
          create(:ci_empty_pipeline, sha: sha, project: project)
          m.call(*args)
        end

        expect_next_instance_of(Releases::CreateEvidenceService, anything, pipeline: pipeline) do |service|
          expect(service).to receive(:execute).and_call_original
        end

        expect { subject }.to change(Releases::Evidence, :count).by(1)
      end

      it 'uses the last pipeline for evidence when tag is already created', :sidekiq_inline do
        Tags::CreateService.new(project, user).execute('v0.1', 'master', nil)

        expect(project.repository.find_tag('v0.1')).to be_present

        create(:ci_empty_pipeline, sha: sha, project: project) # old pipeline
        pipeline = create(:ci_empty_pipeline, sha: sha, project: project)

        expect_next_instance_of(Releases::CreateEvidenceService, anything, pipeline: pipeline) do |service|
          expect(service).to receive(:execute).and_call_original
        end

        expect { subject }.to change(Releases::Evidence, :count).by(1)
      end
    end

    context 'immediate release' do
      let(:released_at) { nil }

      it 'sets `released_at` to the current dttm' do
        subject

        expect(last_release.updated_at).to be_like_time(Time.current)
      end

      it 'queues CreateEvidenceWorker' do
        expect { subject }.to change(Releases::CreateEvidenceWorker.jobs, :size).by(1)
      end

      it 'creates Evidence', :sidekiq_inline do
        expect { subject }.to change(Releases::Evidence, :count).by(1)
      end

      it 'is not a historical release' do
        subject

        expect(last_release.historical_release?).to be_falsy
      end

      it 'is not an upcoming release' do
        subject

        expect(last_release.upcoming_release?).to be_falsy
      end

      include_examples 'uses the right pipeline for evidence'
    end

    context 'upcoming release' do
      let(:released_at) { 1.day.from_now }

      it 'does not execute CreateEvidenceWorker' do
        expect { subject }.not_to change(Releases::CreateEvidenceWorker.jobs, :size)
      end

      it 'does not create an Evidence object', :sidekiq_inline do
        expect { subject }.not_to change(Releases::Evidence, :count)
      end

      it 'is not a historical release' do
        subject

        expect(last_release.historical_release?).to be_falsy
      end

      it 'is an upcoming release' do
        subject

        expect(last_release.upcoming_release?).to be_truthy
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Releases
  module Links
    class DestroyService < BaseService
      def execute(link)
        return ServiceResponse.error(reason: REASON_FORBIDDEN, message: _('Access Denied')) unless allowed?
        return ServiceResponse.error(reason: REASON_NOT_FOUND, message: _('Link does not exist')) unless link

        if link.destroy
          ServiceResponse.success(payload: { link: link })
        else
          ServiceResponse.error(reason: REASON_BAD_REQUEST, message: link.errors.full_messages)
        end
      end

      private

      def allowed?
        Ability.allowed?(current_user, :destroy_release, release)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Releases::Links::DestroyService, feature_category: :release_orchestration do
  let(:service) { described_class.new(release, user, {}) }
  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:user) { create(:user) }
  let_it_be(:release) { create(:release, project: project, author: user, tag: 'v1.1.0') }

  let!(:release_link) do
    create(
      :release_link,
      release: release,
      name: 'awesome-app.dmg',
      url: 'https://example.com/download/awesome-app.dmg'
    )
  end

  before do
    project.add_developer(user)
  end

  describe '#execute' do
    subject(:execute) { service.execute(release_link) }

    it 'successfully deletes a release link' do
      expect { execute }.to change { release.links.count }.by(-1)

      is_expected.to be_success
    end

    context 'when user does not have access to delete release link' do
      before do
        project.add_guest(user)
      end

      it 'returns an error' do
        expect { execute }.not_to change { release.links.count }

        is_expected.to be_error
        expect(execute.message).to include('Access Denied')
        expect(execute.reason).to eq(:forbidden)
      end
    end

    context 'when release link does not exist' do
      let(:release_link) { nil }

      it 'returns an error' do
        expect { execute }.not_to change { release.links.count }

        is_expected.to be_error
        expect(execute.message).to eq('Link does not exist')
        expect(execute.reason).to eq(:not_found)
      end
    end

    context 'when release link deletion failed' do
      before do
        allow(release_link).to receive(:destroy).and_return(false)
      end

      it 'returns an error' do
        expect { execute }.not_to change { release.links.count }

        is_expected.to be_error
        expect(execute.reason).to eq(:bad_request)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Releases
  module Links
    class UpdateService < BaseService
      def execute(link)
        return ServiceResponse.error(reason: REASON_FORBIDDEN, message: _('Access Denied')) unless allowed?
        return ServiceResponse.error(reason: REASON_NOT_FOUND, message: _('Link does not exist')) unless link

        if link.update(allowed_params)
          ServiceResponse.success(payload: { link: link })
        else
          ServiceResponse.error(reason: REASON_BAD_REQUEST, message: link.errors.full_messages)
        end
      end

      private

      def allowed?
        Ability.allowed?(current_user, :update_release, release)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Releases::Links::UpdateService, feature_category: :release_orchestration do
  let(:service) { described_class.new(release, user, params) }
  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:user) { create(:user) }
  let_it_be(:release) { create(:release, project: project, author: user, tag: 'v1.1.0') }

  let(:release_link) do
    create(
      :release_link,
      release: release,
      name: 'awesome-app.dmg',
      url: 'https://example.com/download/awesome-app.dmg'
    )
  end

  let(:params) { { name: name, url: url, direct_asset_path: direct_asset_path, link_type: link_type } }
  let(:name) { 'link' }
  let(:url) { 'https://example.com' }
  let(:direct_asset_path) { '/path' }
  let(:link_type) { 'other' }

  before do
    project.add_developer(user)
  end

  describe '#execute' do
    subject(:execute) { service.execute(release_link) }

    let(:updated_link) { execute.payload[:link] }

    it 'successfully updates a release link' do
      is_expected.to be_success

      expect(updated_link).to have_attributes(
        name: name,
        url: url,
        filepath: direct_asset_path,
        link_type: link_type
      )
    end

    context 'when user does not have access to update release link' do
      before do
        project.add_guest(user)
      end

      it 'returns an error' do
        is_expected.to be_error
        expect(execute.message).to include('Access Denied')
        expect(execute.reason).to eq(:forbidden)
      end
    end

    context 'when url is invalid' do
      let(:url) { 'not_a_url' }

      it 'returns an error' do
        is_expected.to be_error
        expect(execute.message[0]).to include('Url is blocked')
        expect(execute.reason).to eq(:bad_request)
      end
    end

    context 'when both direct_asset_path and filepath are provided' do
      let(:params) { super().merge(filepath: '/filepath') }

      it 'prefers direct_asset_path' do
        is_expected.to be_success

        expect(updated_link.filepath).to eq(direct_asset_path)
      end
    end

    context 'when only filepath is set' do
      let(:params) { super().merge(filepath: '/filepath') }
      let(:direct_asset_path) { nil }

      it 'uses filepath' do
        is_expected.to be_success

        expect(updated_link.filepath).to eq('/filepath')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Releases
  module Links
    class CreateService < BaseService
      def execute
        return ServiceResponse.error(reason: REASON_FORBIDDEN, message: _('Access Denied')) unless allowed?

        link = release.links.create(allowed_params)

        if link.persisted?
          ServiceResponse.success(payload: { link: link })
        else
          ServiceResponse.error(reason: REASON_BAD_REQUEST, message: link.errors.full_messages)
        end
      end

      private

      def allowed?
        Ability.allowed?(current_user, :create_release, release)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Releases::Links::CreateService, feature_category: :release_orchestration do
  let(:service) { described_class.new(release, user, params) }
  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:user) { create(:user) }
  let_it_be(:release) { create(:release, project: project, author: user, tag: 'v1.1.0') }

  let(:params) { { name: name, url: url, direct_asset_path: direct_asset_path, link_type: link_type } }
  let(:name) { 'link' }
  let(:url) { 'https://example.com' }
  let(:direct_asset_path) { '/path' }
  let(:link_type) { 'other' }

  before do
    project.add_developer(user)
  end

  describe '#execute' do
    subject(:execute) { service.execute }

    let(:link) { subject.payload[:link] }

    it 'successfully creates a release link' do
      expect { execute }.to change { Releases::Link.count }.by(1)

      expect(link).to have_attributes(
        name: name,
        url: url,
        filepath: direct_asset_path,
        link_type: link_type
      )
    end

    context 'when user does not have access to create release link' do
      before do
        project.add_guest(user)
      end

      it 'returns an error' do
        expect { execute }.not_to change { Releases::Link.count }

        is_expected.to be_error
        expect(execute.message).to include('Access Denied')
        expect(execute.reason).to eq(:forbidden)
      end
    end

    context 'when url is invalid' do
      let(:url) { 'not_a_url' }

      it 'returns an error' do
        expect { execute }.not_to change { Releases::Link.count }

        is_expected.to be_error
        expect(execute.message[0]).to include('Url is blocked')
        expect(execute.reason).to eq(:bad_request)
      end
    end

    context 'when both direct_asset_path and filepath are provided' do
      let(:params) { super().merge(filepath: '/filepath') }

      it 'prefers direct_asset_path' do
        is_expected.to be_success

        expect(link.filepath).to eq(direct_asset_path)
      end
    end

    context 'when only filepath is set' do
      let(:params) { super().merge(filepath: '/filepath') }
      let(:direct_asset_path) { nil }

      it 'uses filepath' do
        is_expected.to be_success

        expect(link.filepath).to eq('/filepath')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Releases
  module Links
    class Params
      def initialize(params)
        @params = params.with_indifferent_access
      end

      def allowed_params
        @allowed_params ||= params.slice(:name, :url, :link_type).tap do |hash|
          hash[:filepath] = filepath if provided_filepath?
        end
      end

      private

      attr_reader :params

      def provided_filepath?
        params.key?(:direct_asset_path) || params.key?(:filepath)
      end

      def filepath
        params[:direct_asset_path] || params[:filepath]
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Releases::Links::Params, feature_category: :release_orchestration do
  subject(:filter) { described_class.new(params) }

  let(:params) { { name: name, url: url, direct_asset_path: direct_asset_path, link_type: link_type, unknown: '?' } }
  let(:name) { 'link' }
  let(:url) { 'https://example.com' }
  let(:direct_asset_path) { '/path' }
  let(:link_type) { 'other' }

  describe '#allowed_params' do
    subject { filter.allowed_params }

    it 'returns only allowed params' do
      is_expected.to eq('name' => name, 'url' => url, 'filepath' => direct_asset_path, 'link_type' => link_type)
    end

    context 'when deprecated filepath is used' do
      let(:params) { super().merge(direct_asset_path: nil, filepath: 'filepath') }

      it 'uses filepath value' do
        is_expected.to eq('name' => name, 'url' => url, 'filepath' => 'filepath', 'link_type' => link_type)
      end
    end

    context 'when both direct_asset_path and filepath are provided' do
      let(:params) { super().merge(filepath: 'filepath') }

      it 'uses direct_asset_path value' do
        is_expected.to eq('name' => name, 'url' => url, 'filepath' => direct_asset_path, 'link_type' => link_type)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ChatNames
  class FindUserService
    def initialize(team_id, user_id)
      @team_id = team_id
      @user_id = user_id
    end

    def execute
      chat_name = find_chat_name
      return unless chat_name

      record_chat_activity(chat_name)
      chat_name
    end

    private

    attr_reader :team_id, :user_id

    # rubocop: disable CodeReuse/ActiveRecord
    def find_chat_name
      ChatName.find_by(
        team_id: team_id,
        chat_id: user_id
      )
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def record_chat_activity(chat_name)
      chat_name.update_last_used_at
      Users::ActivityService.new(author: chat_name.user).execute
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ChatNames::FindUserService, :clean_gitlab_redis_shared_state, feature_category: :user_profile do
  describe '#execute' do
    subject { described_class.new(team_id, user_id).execute }

    context 'find user mapping' do
      let_it_be(:user) { create(:user) }
      let(:chat_name) { create(:chat_name, user: user) }

      let(:team_id) { chat_name.team_id }
      let(:user_id) { chat_name.chat_id }

      context 'when existing user is requested' do
        it 'returns the existing chat_name' do
          is_expected.to eq(chat_name)
        end

        it 'updates the last used timestamp if one is not already set' do
          expect { subject }.to change { chat_name.reload.last_used_at }.from(nil)
        end

        it 'only updates an existing timestamp once within a certain time frame' do
          expect { described_class.new(team_id, user_id).execute }.to change { chat_name.reload.last_used_at }.from(nil)
          expect { described_class.new(team_id, user_id).execute }.not_to change { chat_name.reload.last_used_at }
        end

        it 'records activity for the related user' do
          expect_next_instance_of(Users::ActivityService, author: user) do |activity_service|
            expect(activity_service).to receive(:execute)
          end

          subject
        end
      end

      context 'when different user is requested' do
        let(:user_id) { 'non-existing-user' }

        it 'returns nil' do
          is_expected.to be_nil
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ChatNames
  class AuthorizeUserService
    include Gitlab::Routing

    def initialize(params)
      @params = params
    end

    def execute
      return unless chat_name_params.values.all?(&:present?)

      token = request_token

      new_profile_chat_name_url(token: token) if token
    end

    private

    def request_token
      chat_name_token.store!(chat_name_params)
    end

    def chat_name_token
      @chat_name_token ||= Gitlab::ChatNameToken.new
    end

    def chat_name_params
      {
        team_id: @params[:team_id],
        team_domain: @params[:team_domain],
        chat_id: @params[:user_id],
        chat_name: @params[:user_name]
      }
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ChatNames::AuthorizeUserService, feature_category: :user_profile do
  describe '#execute' do
    let(:result) { subject.execute }

    subject { described_class.new(params) }

    context 'when all parameters are valid' do
      let(:params) { { team_id: 'T0001', team_domain: 'myteam', user_id: 'U0001', user_name: 'user' } }

      it 'produces a valid HTTP URL' do
        expect(result).to be_http_url
      end

      it 'requests a new token' do
        expect(subject).to receive(:request_token).once.and_call_original

        subject.execute
      end
    end

    context 'when there are missing parameters' do
      let(:params) { {} }

      it 'does not produce a URL' do
        expect(result).to be_nil
      end

      it 'does not request a new token' do
        expect(subject).not_to receive(:request_token)

        subject.execute
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ErrorTracking
  class IssueDetailsService < ErrorTracking::BaseService
    include Gitlab::Routing
    include Gitlab::Utils::StrongMemoize

    private

    def perform
      response = find_issue_details(params[:issue_id])

      compose_response(response) do
        # The gitlab_issue attribute can contain an absolute GitLab url from the Sentry Client
        # here we overwrite that in favor of our own data if we have it
        response[:issue].gitlab_issue = gitlab_issue_url if gitlab_issue_url
      end
    end

    def gitlab_issue_url
      strong_memoize(:gitlab_issue_url) do
        # Use the absolute url to match the GitLab issue url that the Sentry api provides
        project_issue_url(project, gitlab_issue.iid) if gitlab_issue
      end
    end

    def gitlab_issue
      strong_memoize(:gitlab_issue) do
        SentryIssueFinder
          .new(project, current_user: current_user)
          .execute(params[:issue_id])
          &.issue
      end
    end

    def parse_response(response)
      { issue: response[:issue] }
    end

    def find_issue_details(issue_id)
      # There are 2 types of the data source for the error tracking feature:
      #
      # * When integrated error tracking is enabled, we use the application database
      #   to read and save error tracking data.
      #
      # * When integrated error tracking is disabled we call
      #   project_error_tracking_setting method which works with Sentry API.
      #
      # Issue https://gitlab.com/gitlab-org/gitlab/-/issues/329596
      #
      if project_error_tracking_setting.integrated_client?
        handle_error_repository_exceptions do
          error = error_repository.find_error(issue_id)
          { issue: error }
        end
      else
        project_error_tracking_setting.issue_details(issue_id: issue_id)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ErrorTracking::IssueDetailsService, feature_category: :error_tracking do
  include_context 'sentry error tracking context'

  subject(:service) { described_class.new(project, user, params) }

  describe '#execute' do
    context 'with authorized user' do
      context 'when issue_details returns a detailed error' do
        let(:detailed_error) { build(:error_tracking_sentry_detailed_error) }
        let(:params) { { issue_id: detailed_error.id } }

        before do
          allow(error_tracking_setting)
            .to receive(:issue_details).and_return(issue: detailed_error)
        end

        it 'returns the detailed error' do
          expect(result).to eq(status: :success, issue: detailed_error)
        end

        it 'returns the gitlab_issue when the error has a sentry_issue' do
          gitlab_issue = create(:issue, project: project)
          create(:sentry_issue, issue: gitlab_issue, sentry_issue_identifier: detailed_error.id)

          expect(result[:issue].gitlab_issue).to include(
            ""http"", ""/#{project.full_path}/-/issues/#{gitlab_issue.iid}""
          )
        end

        it 'returns the gitlab_issue path from sentry when the error has no sentry_issue' do
          expect(result[:issue].gitlab_issue).to eq(detailed_error.gitlab_issue)
        end
      end

      include_examples 'error tracking service data not ready', :issue_details
      include_examples 'error tracking service sentry error handling', :issue_details
      include_examples 'error tracking service http status handling', :issue_details

      context 'with integrated error tracking' do
        let(:error_repository) { instance_double(Gitlab::ErrorTracking::ErrorRepository) }
        let(:params) { { issue_id: issue_id } }

        before do
          error_tracking_setting.update!(integrated: true)

          allow(service).to receive(:error_repository).and_return(error_repository)
        end

        context 'when error is found' do
          let(:error) { build_stubbed(:error_tracking_open_api_error, project_id: project.id) }
          let(:issue_id) { error.fingerprint }

          before do
            allow(error_repository).to receive(:find_error).with(issue_id).and_return(error)
          end

          it 'returns the error in detailed format' do
            expect(result[:status]).to eq(:success)
            expect(result[:issue]).to eq(error)
          end
        end

        context 'when error does not exist' do
          let(:issue_id) { non_existing_record_id }

          before do
            allow(error_repository).to receive(:find_error).with(issue_id)
              .and_raise(Gitlab::ErrorTracking::ErrorRepository::DatabaseError.new('Error not found'))
          end

          it 'returns the error in detailed format' do
            expect(result).to match(
              status: :error,
              message: /Error not found/,
              http_status: :bad_request
            )
          end
        end
      end
    end

    include_examples 'error tracking service unauthorized user'
    include_examples 'error tracking service disabled'
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ErrorTracking
  class ListProjectsService < ErrorTracking::BaseService
    private

    def perform
      return error('Access denied', :unauthorized) unless can?(current_user, :admin_sentry, project)

      unless project_error_tracking_setting.valid?
        return error(project_error_tracking_setting.errors.full_messages.join(', '), :bad_request)
      end

      response = project_error_tracking_setting.list_sentry_projects

      compose_response(response)
    end

    def parse_response(response)
      { projects: response[:projects] }
    end

    def project_error_tracking_setting
      (super || project.build_error_tracking_setting).tap do |setting|
        setting.api_url = ErrorTracking::ProjectErrorTrackingSetting.build_api_url_from(
          api_host: params[:api_host],
          organization_slug: 'org',
          project_slug: 'proj'
        )

        setting.token = token(setting)
        setting.enabled = true
      end
    end
    strong_memoize_attr :project_error_tracking_setting

    def token(setting)
      return if setting.api_url_changed? && masked_token?

      # Use param token if not masked, otherwise use database token
      return params[:token] unless masked_token?

      setting.token
    end

    def masked_token?
      ErrorTracking::SentryClient::Token.masked_token?(params[:token])
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ErrorTracking::ListProjectsService, feature_category: :integrations do
  let_it_be(:user) { create(:user) }
  let_it_be(:project, reload: true) { create(:project) }

  let(:sentry_url) { 'https://sentrytest.gitlab.com/api/0/projects/org/proj/' }
  let(:token) { 'test-token' }
  let(:new_api_host) { 'https://gitlab.com/' }
  let(:new_token) { 'new-token' }
  let(:params) { ActionController::Parameters.new(api_host: new_api_host, token: new_token) }

  let(:error_tracking_setting) do
    create(:project_error_tracking_setting, api_url: sentry_url, token: token, project: project)
  end

  subject { described_class.new(project, user, params) }

  before do
    project.add_maintainer(user)
  end

  describe '#execute' do
    let(:result) { subject.execute }

    context 'with authorized user' do
      before do
        expect(project).to receive(:error_tracking_setting).at_least(:once)
          .and_return(error_tracking_setting)
      end

      context 'set model attributes to new values' do
        let(:new_api_url) { new_api_host + 'api/0/projects/org/proj/' }

        before do
          expect(error_tracking_setting).to receive(:list_sentry_projects)
            .and_return({ projects: [] })
        end

        it 'uses new api_url and token' do
          subject.execute

          expect(error_tracking_setting.api_url).to eq(new_api_url)
          expect(error_tracking_setting.token).to eq(new_token)
          error_tracking_setting.reload
          expect(error_tracking_setting.api_url).to eq(sentry_url)
          expect(error_tracking_setting.token).to eq(token)
        end
      end

      context 'masked param token' do
        let(:params) { ActionController::Parameters.new(token: ""*********"", api_host: api_host) }

        context 'with the current api host' do
          let(:api_host) { 'https://sentrytest.gitlab.com' }

          before do
            expect(error_tracking_setting).to receive(:list_sentry_projects)
            .and_return({ projects: [] })
          end

          it 'uses database token' do
            expect { subject.execute }.not_to change { error_tracking_setting.token }
          end
        end

        context 'with the similar api host' do
          let(:api_host) { 'https://sentrytest.gitlab.co' }

          it 'returns an error' do
            expect(result[:message]).to start_with('Token is a required field')
            expect(error_tracking_setting).not_to be_valid
            expect(error_tracking_setting).not_to receive(:list_sentry_projects)
          end

          it 'resets the token' do
            expect { subject.execute }.to change { error_tracking_setting.token }.from(token).to(nil)
          end
        end

        context 'with a new api host' do
          let(:api_host) { new_api_host }

          it 'returns an error' do
            expect(result[:message]).to start_with('Token is a required field')
            expect(error_tracking_setting).not_to be_valid
            expect(error_tracking_setting).not_to receive(:list_sentry_projects)
          end

          it 'resets the token' do
            expect { subject.execute }.to change { error_tracking_setting.token }.from(token).to(nil)
          end
        end
      end

      context 'with invalid url' do
        let(:params) do
          ActionController::Parameters.new(
            api_host: 'https://localhost',
            token: new_token
          )
        end

        before do
          error_tracking_setting.enabled = false
        end

        it 'returns error' do
          expect(result[:message]).to start_with('Api url is blocked')
          expect(error_tracking_setting).not_to be_valid
        end
      end

      context 'when list_sentry_projects returns projects' do
        let(:projects) { [:list, :of, :projects] }

        before do
          expect(error_tracking_setting)
            .to receive(:list_sentry_projects).and_return(projects: projects)
        end

        it 'returns the projects' do
          expect(result).to eq(status: :success, projects: projects)
        end
      end
    end

    context 'with unauthorized user' do
      before do
        project.add_guest(user)
      end

      it 'returns error' do
        expect(result).to include(status: :error, message: 'Access denied', http_status: :unauthorized)
      end
    end

    context 'with user with insufficient permissions' do
      before do
        project.add_developer(user)
      end

      it 'returns error' do
        expect(result).to include(status: :error, message: 'Access denied', http_status: :unauthorized)
      end
    end

    context 'with error tracking disabled' do
      before do
        expect(project).to receive(:error_tracking_setting).at_least(:once)
          .and_return(error_tracking_setting)
        expect(error_tracking_setting)
          .to receive(:list_sentry_projects).and_return(projects: [])

        error_tracking_setting.enabled = false
      end

      it 'ignores enabled flag' do
        expect(result).to include(status: :success, projects: [])
      end
    end

    context 'error_tracking_setting is nil' do
      let(:error_tracking_setting) { build(:project_error_tracking_setting, project: project) }
      let(:new_api_url) { new_api_host + 'api/0/projects/org/proj/' }

      before do
        expect(project).to receive(:build_error_tracking_setting).once
          .and_return(error_tracking_setting)

        expect(error_tracking_setting).to receive(:list_sentry_projects)
          .and_return(projects: [:project1, :project2])
      end

      it 'builds a new error_tracking_setting' do
        expect(project.error_tracking_setting).to be_nil

        expect(result[:projects]).to eq([:project1, :project2])

        expect(error_tracking_setting.api_url).to eq(new_api_url)
        expect(error_tracking_setting.token).to eq(new_token)
        expect(error_tracking_setting.enabled).to be true
        expect(error_tracking_setting.persisted?).to be false
        expect(error_tracking_setting.project_id).not_to be_nil

        expect(project.error_tracking_setting).to be_nil
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ErrorTracking
  class BaseService < ::BaseProjectService
    include Gitlab::Utils::UsageData

    def initialize(project, user = nil, params = {})
      super(project: project, current_user: user, params: params.dup)
    end

    def execute
      return unauthorized if unauthorized

      perform
    end

    private

    def perform
      raise NotImplementedError, ""#{self.class} does not implement #{__method__}""
    end

    def compose_response(response, &block)
      errors = parse_errors(response)
      return errors if errors

      yield if block

      track_usage_event(params[:tracking_event], current_user.id) if params[:tracking_event]

      success(parse_response(response))
    end

    def parse_response(response)
      raise NotImplementedError, ""#{self.class} does not implement #{__method__}""
    end

    def unauthorized
      return error('Error Tracking is not enabled') unless enabled?
      return error('Access denied', :unauthorized) unless can_read?
    end

    def parse_errors(response)
      return error('Not ready. Try again later', :no_content) unless response
      return error(response[:error], http_status_for(response[:error_type])) if response[:error].present?
    end

    def http_status_for(error_type)
      case error_type
      when ErrorTracking::ProjectErrorTrackingSetting::SENTRY_API_ERROR_TYPE_MISSING_KEYS
        :internal_server_error
      else
        :bad_request
      end
    end

    def project_error_tracking_setting
      project.error_tracking_setting
    end

    def enabled?
      project_error_tracking_setting&.enabled?
    end

    def can_read?
      can?(current_user, :read_sentry_issue, project)
    end

    def can_update?
      can?(current_user, :update_sentry_issue, project)
    end

    def error_repository
      Gitlab::ErrorTracking::ErrorRepository.build(project)
    end

    def handle_error_repository_exceptions
      yield
    rescue Gitlab::ErrorTracking::ErrorRepository::DatabaseError => e
      { error: e.message }
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ErrorTracking::BaseService, feature_category: :error_tracking do
  describe '#compose_response' do
    let(:project) { build_stubbed(:project) }
    let(:user) { build_stubbed(:user, id: non_existing_record_id) }
    let(:service) { described_class.new(project, user) }

    it 'returns bad_request error when response has an error key' do
      data = { error: 'Unexpected Error' }

      result = service.send(:compose_response, data)

      expect(result[:status]).to be(:error)
      expect(result[:message]).to be('Unexpected Error')
      expect(result[:http_status]).to be(:bad_request)
    end

    it 'returns server error when response has missing key error_type' do
      data = {
        error: 'Unexpected Error',
        error_type: ErrorTracking::ProjectErrorTrackingSetting::SENTRY_API_ERROR_TYPE_MISSING_KEYS
      }

      result = service.send(:compose_response, data)

      expect(result[:status]).to be(:error)
      expect(result[:message]).to be('Unexpected Error')
      expect(result[:http_status]).to be(:internal_server_error)
    end

    it 'returns no content when response is nil' do
      data = nil

      result = service.send(:compose_response, data)

      expect(result[:status]).to be(:error)
      expect(result[:message]).to be('Not ready. Try again later')
      expect(result[:http_status]).to be(:no_content)
    end

    context 'when result has no errors key' do
      let(:data) { { thing: :cat } }

      it 'raises NotImplementedError' do
        expect { service.send(:compose_response, data) }
          .to raise_error(NotImplementedError)
      end

      context 'when parse_response is implemented' do
        before do
          allow(service).to receive(:parse_response) do |response|
            { animal: response[:thing] }
          end
        end

        it 'returns successful response' do
          result = service.send(:compose_response, data)

          expect(result[:animal]).to eq(:cat)
          expect(result[:status]).to eq(:success)
        end

        it 'returns successful response with changes from passed block' do
          result = service.send(:compose_response, data) do
            data[:thing] = :fish
          end

          expect(result[:animal]).to eq(:fish)
          expect(result[:status]).to eq(:success)
        end

        context 'when tracking_event is provided' do
          let(:service) { described_class.new(project, user, tracking_event: :error_tracking_view_list) }

          it_behaves_like 'tracking unique hll events' do
            let(:target_event) { 'error_tracking_view_list' }
            let(:expected_value) { non_existing_record_id }
            let(:request) { service.send(:compose_response, data) }
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ErrorTracking
  class IssueLatestEventService < ErrorTracking::BaseService
    private

    def perform
      response = find_issue_latest_event(params[:issue_id])

      compose_response(response)
    end

    def parse_response(response)
      { latest_event: response[:latest_event] }
    end

    def find_issue_latest_event(issue_id)
      # There are 2 types of the data source for the error tracking feature:
      #
      # * When integrated error tracking is enabled, we use the application database
      #   to read and save error tracking data.
      #
      # * When integrated error tracking is disabled we call
      #   project_error_tracking_setting method which works with Sentry API.
      #
      # Issue https://gitlab.com/gitlab-org/gitlab/-/issues/329596
      #
      if project_error_tracking_setting.integrated_client?
        handle_error_repository_exceptions do
          event = error_repository.last_event_for(issue_id)

          # We use the same response format as project_error_tracking_setting
          # method below for compatibility with existing code.
          { latest_event: event }
        end
      else
        project_error_tracking_setting.issue_latest_event(issue_id: issue_id)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ErrorTracking::IssueLatestEventService, feature_category: :error_tracking do
  include_context 'sentry error tracking context'

  let(:params) { {} }

  subject(:service) { described_class.new(project, user, params) }

  describe '#execute' do
    context 'with authorized user' do
      context 'when issue_latest_event returns an error event' do
        let(:error_event) { build(:error_tracking_sentry_error_event) }

        before do
          allow(error_tracking_setting)
            .to receive(:issue_latest_event).and_return(latest_event: error_event)
        end

        it 'returns the error event' do
          expect(result).to eq(status: :success, latest_event: error_event)
        end
      end

      include_examples 'error tracking service data not ready', :issue_latest_event
      include_examples 'error tracking service sentry error handling', :issue_latest_event
      include_examples 'error tracking service http status handling', :issue_latest_event

      context 'with integrated error tracking' do
        let(:error_repository) { instance_double(Gitlab::ErrorTracking::ErrorRepository) }
        let(:params) { { issue_id: issue_id } }

        before do
          error_tracking_setting.update!(integrated: true)

          allow(service).to receive(:error_repository).and_return(error_repository)
        end

        context 'when error is found' do
          let(:error) { build_stubbed(:error_tracking_open_api_error, project_id: project.id) }
          let(:event) { build_stubbed(:error_tracking_open_api_error_event, fingerprint: error.fingerprint) }
          let(:issue_id) { error.fingerprint }

          before do
            allow(error_repository).to receive(:last_event_for).with(issue_id).and_return(event)
          end

          it 'returns the latest event in expected format' do
            expect(result[:status]).to eq(:success)
            expect(result[:latest_event]).to eq(event)
          end
        end

        context 'when error does not exist' do
          let(:issue_id) { non_existing_record_id }

          before do
            allow(error_repository).to receive(:last_event_for).with(issue_id)
              .and_raise(Gitlab::ErrorTracking::ErrorRepository::DatabaseError.new('Error not found'))
          end

          it 'returns the error in detailed format' do
            expect(result).to match(
              status: :error,
              message: /Error not found/,
              http_status: :bad_request
            )
          end
        end
      end
    end

    include_examples 'error tracking service unauthorized user'
    include_examples 'error tracking service disabled'
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ErrorTracking
  class IssueUpdateService < ErrorTracking::BaseService
    private

    def perform
      update_opts = {
        issue_id: params[:issue_id],
        params: update_params
      }

      response = update_issue(update_opts)

      compose_response(response) do
        project_error_tracking_setting.expire_issues_cache
        response[:closed_issue_iid] = update_related_issue&.iid
      end
    end

    def update_related_issue
      issue = related_issue
      return unless issue

      close_and_create_note(issue)
    end

    def close_and_create_note(issue)
      return unless resolving? && issue.opened?

      processed_issue = close_issue(issue)
      return unless processed_issue.reset.closed?

      create_system_note(processed_issue)
      processed_issue
    end

    def close_issue(issue)
      Issues::CloseService
        .new(container: project, current_user: current_user)
        .execute(issue, system_note: false)
    end

    def create_system_note(issue)
      SystemNoteService.close_after_error_tracking_resolve(issue, project, current_user)
    end

    def related_issue
      SentryIssueFinder
        .new(project, current_user: current_user)
        .execute(params[:issue_id])
        &.issue
    end

    def resolving?
      update_params[:status] == 'resolved'
    end

    def update_params
      params.except(:issue_id)
    end

    def parse_response(response)
      {
        updated: response[:updated].present?,
        closed_issue_iid: response[:closed_issue_iid]
      }
    end

    def unauthorized
      return error('Error Tracking is not enabled') unless enabled?
      return error('Access denied', :unauthorized) unless can_update?
    end

    def update_issue(opts)
      # There are 2 types of the data source for the error tracking feature:
      #
      # * When integrated error tracking is enabled, we use the application database
      #   to read and save error tracking data.
      #
      # * When integrated error tracking is disabled we call
      #   project_error_tracking_setting method which works with Sentry API.
      #
      # Issue https://gitlab.com/gitlab-org/gitlab/-/issues/329596
      #
      if project_error_tracking_setting.integrated_client?
        updated = error_repository.update_error(opts[:issue_id], status: opts[:params][:status])

        # We use the same response format as project_error_tracking_setting
        # method below for compatibility with existing code.
        {
          updated: updated
        }
      else
        project_error_tracking_setting.update_issue(**opts)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ErrorTracking::IssueUpdateService, feature_category: :error_tracking do
  include_context 'sentry error tracking context'

  let(:arguments) { { issue_id: non_existing_record_id, status: 'resolved' } }

  subject(:update_service) { described_class.new(project, user, arguments) }

  shared_examples 'does not perform close issue flow' do
    it 'does not call the close issue service' do
      update_service.execute

      expect(issue_close_service).not_to have_received(:execute)
    end

    it 'does not create system note' do
      expect(SystemNoteService).not_to receive(:close_after_error_tracking_resolve)
      update_service.execute
    end
  end

  describe '#execute' do
    context 'with authorized user' do
      context 'when update_issue returns success' do
        let(:update_issue_response) { { updated: true } }

        before do
          allow(error_tracking_setting).to receive(:update_issue).and_return(update_issue_response)
        end

        it 'returns the response' do
          expect(update_service.execute).to eq(update_issue_response.merge(status: :success, closed_issue_iid: nil))
        end

        it 'updates any related issue' do
          expect(update_service).to receive(:update_related_issue)

          update_service.execute
        end

        it 'clears the reactive cache' do
          expect(error_tracking_setting).to receive(:expire_issues_cache)

          result
        end

        context 'with related issue and resolving' do
          let(:issue) { create(:issue, project: project) }
          let(:sentry_issue) { create(:sentry_issue, issue: issue) }
          let(:arguments) { { issue_id: sentry_issue.sentry_issue_identifier, status: 'resolved' } }
          let(:issue_close_service) { instance_double('Issues::CloseService') }

          before do
            allow_next_instance_of(SentryIssueFinder) do |finder|
              allow(finder).to receive(:execute).and_return(sentry_issue)
            end

            allow(Issues::CloseService)
              .to receive(:new)
              .and_return(issue_close_service)

            allow(issue_close_service)
              .to receive(:execute)
              .and_return(issue)
          end

          it 'closes the issue' do
            update_service.execute

            expect(issue_close_service)
              .to have_received(:execute)
              .with(issue, system_note: false)
          end

          context 'when issue gets closed' do
            let(:closed_issue) { create(:issue, :closed, project: project) }

            before do
              allow(issue_close_service)
                .to receive(:execute)
                .with(issue, system_note: false)
                .and_return(closed_issue)
            end

            it 'creates a system note' do
              expect(SystemNoteService).to receive(:close_after_error_tracking_resolve)

              update_service.execute
            end

            it 'returns a response with closed issue' do
              expect(update_service.execute).to eq(status: :success, updated: true, closed_issue_iid: closed_issue.iid)
            end
          end

          context 'when issue is already closed' do
            let(:issue) { create(:issue, :closed, project: project) }

            include_examples 'does not perform close issue flow'
          end

          context 'when status is not resolving' do
            let(:arguments) { { issue_id: sentry_issue.sentry_issue_identifier, status: 'ignored' } }

            include_examples 'does not perform close issue flow'
          end
        end
      end

      include_examples 'error tracking service sentry error handling', :update_issue

      context 'with integrated error tracking' do
        let(:error_repository) { instance_double(Gitlab::ErrorTracking::ErrorRepository) }
        let(:error) { build_stubbed(:error_tracking_open_api_error, project_id: project.id) }
        let(:issue_id) { error.fingerprint }
        let(:arguments) { { issue_id: issue_id, status: 'resolved' } }

        before do
          error_tracking_setting.update!(integrated: true)

          allow(update_service).to receive(:error_repository).and_return(error_repository)
          allow(error_repository).to receive(:update_error)
            .with(issue_id, status: 'resolved').and_return(updated)
        end

        context 'when update succeeded' do
          let(:updated) { true }

          it 'returns success with updated true' do
            expect(project.error_tracking_setting).to receive(:expire_issues_cache)

            expect(update_service.execute).to eq(
              status: :success,
              updated: true,
              closed_issue_iid: nil
            )
          end
        end

        context 'when update failed' do
          let(:updated) { false }

          it 'returns success with updated false' do
            expect(project.error_tracking_setting).to receive(:expire_issues_cache)

            expect(update_service.execute).to eq(
              status: :success,
              updated: false,
              closed_issue_iid: nil
            )
          end
        end
      end
    end

    include_examples 'error tracking service unauthorized user'
    include_examples 'error tracking service disabled'
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ErrorTracking
  class ListIssuesService < ErrorTracking::BaseService
    DEFAULT_ISSUE_STATUS = 'unresolved'
    DEFAULT_LIMIT = 20
    DEFAULT_SORT = 'last_seen'

    # Sentry client supports 'muted' and 'assigned' but GitLab does not
    ISSUE_STATUS_VALUES = %w[
      resolved
      unresolved
      ignored
    ].freeze

    def external_url
      project_error_tracking_setting&.sentry_external_url
    end

    private

    def perform
      return invalid_status_error unless valid_status?

      sentry_opts = {
        issue_status: issue_status,
        limit: limit,
        search_term: params[:search_term].presence,
        sort: sort,
        cursor: params[:cursor].presence
      }

      response = list_issues(sentry_opts)

      compose_response(response)
    end

    def parse_response(response)
      response.slice(:issues, :pagination)
    end

    def invalid_status_error
      error('Bad Request: Invalid issue_status', http_status_for(:bad_Request))
    end

    def valid_status?
      ISSUE_STATUS_VALUES.include?(issue_status)
    end

    def issue_status
      params[:issue_status] || DEFAULT_ISSUE_STATUS
    end

    def limit
      params[:limit] || DEFAULT_LIMIT
    end

    def sort
      params[:sort] || DEFAULT_SORT
    end

    def list_issues(opts)
      # There are 2 types of the data source for the error tracking feature:
      #
      # * When integrated error tracking is enabled, we use the application database
      #   to read and save error tracking data.
      #
      # * When integrated error tracking is disabled we call
      #   project_error_tracking_setting method which works with Sentry API.
      #
      # Issue https://gitlab.com/gitlab-org/gitlab/-/issues/329596
      #
      if project_error_tracking_setting.integrated_client?
        # We are going to support more options in the future.
        # For now we implement the bare minimum for rendering the list in UI.
        list_opts = {
          filters: { status: opts[:issue_status] },
          query: opts[:search_term],
          sort: opts[:sort],
          limit: opts[:limit],
          cursor: opts[:cursor]
        }

        errors, pagination = error_repository.list_errors(**list_opts)

        pagination_hash = {}
        pagination_hash[:next] = { cursor: pagination.next } if pagination.next
        pagination_hash[:previous] = { cursor: pagination.prev } if pagination.prev

        # We use the same response format as project_error_tracking_setting
        # method below for compatibility with existing code.
        {
          issues: errors,
          pagination: pagination_hash
        }
      else
        project_error_tracking_setting.list_sentry_issues(**opts)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ErrorTracking::ListIssuesService, feature_category: :error_tracking do
  include_context 'sentry error tracking context'

  let(:params) { {} }

  subject(:service) { described_class.new(project, user, params) }

  describe '#execute' do
    context 'with Sentry backend' do
      let(:params) { { search_term: 'something', sort: 'last_seen', cursor: 'some-cursor' } }

      let(:list_sentry_issues_args) do
        {
          issue_status: 'unresolved',
          limit: 20,
          search_term: 'something',
          sort: 'last_seen',
          cursor: 'some-cursor'
        }
      end

      context 'with authorized user' do
        let(:issues) { [] }

        described_class::ISSUE_STATUS_VALUES.each do |status|
          it ""returns the issues with #{status} issue_status"" do
            params[:issue_status] = status
            list_sentry_issues_args[:issue_status] = status
            expect_list_sentry_issues_with(list_sentry_issues_args)

            expect(result).to eq(status: :success, pagination: {}, issues: issues)
          end
        end

        it 'returns the issues with no issue_status' do
          expect_list_sentry_issues_with(list_sentry_issues_args)

          expect(result).to eq(status: :success, pagination: {}, issues: issues)
        end

        it 'returns bad request with invalid issue_status' do
          params[:issue_status] = 'assigned'

          expect(error_tracking_setting).not_to receive(:list_sentry_issues)
          expect(result).to eq(message: ""Bad Request: Invalid issue_status"", status: :error, http_status: :bad_request)
        end

        include_examples 'error tracking service data not ready', :list_sentry_issues
        include_examples 'error tracking service sentry error handling', :list_sentry_issues
        include_examples 'error tracking service http status handling', :list_sentry_issues
      end

      include_examples 'error tracking service unauthorized user'
      include_examples 'error tracking service disabled'

      def expect_list_sentry_issues_with(list_sentry_issues_args)
        expect(error_tracking_setting)
          .to receive(:list_sentry_issues)
          .with(list_sentry_issues_args)
          .and_return(issues: [], pagination: {})
      end
    end

    context 'with integrated error tracking' do
      let(:error_repository) { instance_double(Gitlab::ErrorTracking::ErrorRepository) }
      let(:errors) { [] }
      let(:pagination) { Gitlab::ErrorTracking::ErrorRepository::Pagination.new(nil, nil) }
      let(:opts) { default_opts }

      let(:default_opts) do
        {
          filters: { status: described_class::DEFAULT_ISSUE_STATUS },
          query: nil,
          sort: described_class::DEFAULT_SORT,
          limit: described_class::DEFAULT_LIMIT,
          cursor: nil
        }
      end

      let(:params) { {} }

      before do
        error_tracking_setting.update!(integrated: true)

        allow(service).to receive(:error_repository).and_return(error_repository)
      end

      context 'when errors are found' do
        let(:error) { build_stubbed(:error_tracking_open_api_error, project_id: project.id) }
        let(:errors) { [error] }

        before do
          allow(error_repository).to receive(:list_errors)
            .with(**opts)
            .and_return([errors, pagination])
        end

        context 'without params' do
          it 'returns the errors without pagination' do
            expect(result[:status]).to eq(:success)
            expect(result[:issues]).to eq(errors)
            expect(result[:pagination]).to eq({})
            expect(error_repository).to have_received(:list_errors).with(**opts)
          end
        end

        context 'with pagination' do
          context 'with next page' do
            before do
              pagination.next = 'next cursor'
            end

            it 'has next cursor' do
              expect(result[:pagination]).to eq(next: { cursor: 'next cursor' })
            end
          end

          context 'with prev page' do
            before do
              pagination.prev = 'prev cursor'
            end

            it 'has prev cursor' do
              expect(result[:pagination]).to eq(previous: { cursor: 'prev cursor' })
            end
          end

          context 'with next and prev page' do
            before do
              pagination.next = 'next cursor'
              pagination.prev = 'prev cursor'
            end

            it 'has both cursors' do
              expect(result[:pagination]).to eq(
                next: { cursor: 'next cursor' },
                previous: { cursor: 'prev cursor' }
              )
            end
          end
        end
      end
    end
  end

  describe '#external_url' do
    it 'calls the project setting sentry_external_url' do
      expect(error_tracking_setting).to receive(:sentry_external_url).and_return(sentry_url)

      expect(subject.external_url).to eql sentry_url
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WebHooks
  class LogExecutionService
    include ::Gitlab::ExclusiveLeaseHelpers

    LOCK_TTL = 15.seconds.freeze
    LOCK_SLEEP = 0.25.seconds.freeze
    LOCK_RETRY = 65

    attr_reader :hook, :log_data, :response_category

    def initialize(hook:, log_data:, response_category:)
      @hook = hook
      @log_data = log_data.transform_keys(&:to_sym)
      @response_category = response_category
    end

    def execute
      update_hook_failure_state
      log_execution
    end

    private

    def log_execution
      mask_response_headers

      log_data[:request_headers]['X-Gitlab-Token'] = _('[REDACTED]') if hook.token?

      WebHookLog.create!(web_hook: hook, **log_data)
    end

    def mask_response_headers
      return unless hook.url_variables?
      return unless log_data.key?(:response_headers)

      variables_map = hook.url_variables.invert.transform_values { ""{#{_1}}"" }
      regex = Regexp.union(variables_map.keys)

      log_data[:response_headers].transform_values! do |value|
        regex === value ? value.gsub(regex, variables_map) : value
      end
    end

    # Perform this operation within an `Gitlab::ExclusiveLease` lock to make it
    # safe to be called concurrently from different workers.
    def update_hook_failure_state
      in_lock(lock_name, ttl: LOCK_TTL, sleep_sec: LOCK_SLEEP, retries: LOCK_RETRY) do |retried|
        hook.reset # Reload within the lock so properties are guaranteed to be current.

        case response_category
        when :ok
          hook.enable!
        when :error
          hook.backoff!
        when :failed
          hook.failed!
        end

        hook.update_last_failure
      end
    rescue Gitlab::ExclusiveLeaseHelpers::FailedToObtainLockError
      raise if raise_lock_error?
    end

    def lock_name
      ""web_hooks:update_hook_failure_state:#{hook.id}""
    end

    # Allow an error to be raised after failing to obtain a lease only if the hook
    # is not already in the correct failure state.
    def raise_lock_error?
      hook.reset # Reload so properties are guaranteed to be current.

      hook.executable? != (response_category == :ok)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WebHooks::LogExecutionService, feature_category: :webhooks do
  include ExclusiveLeaseHelpers
  using RSpec::Parameterized::TableSyntax

  describe '#execute' do
    around do |example|
      travel_to(Time.current) { example.run }
    end

    let_it_be_with_reload(:project_hook) { create(:project_hook, :token) }

    let(:response_category) { :ok }
    let(:request_headers) { { 'Header' => 'header value' } }
    let(:data) do
      {
        trigger: 'trigger_name',
        url: 'https://example.com',
        request_headers: request_headers,
        request_data: { 'Request Data' => 'request data value' },
        response_body: 'Response body',
        response_status: '200',
        execution_duration: 1.2,
        internal_error_message: 'error message'
      }
    end

    subject(:service) { described_class.new(hook: project_hook, log_data: data, response_category: response_category) }

    it 'logs the data' do
      expect { service.execute }.to change(::WebHookLog, :count).by(1)

      expect(WebHookLog.recent.first).to have_attributes(data)
    end

    it 'updates the last failure' do
      expect(project_hook).to receive(:update_last_failure)

      service.execute
    end

    context 'obtaining an exclusive lease' do
      let(:lease_key) { ""web_hooks:update_hook_failure_state:#{project_hook.id}"" }

      it 'updates failure state using a lease that ensures fresh state is written' do
        service = described_class.new(hook: project_hook, log_data: data, response_category: :error)
        # Write state somewhere else, so that the hook is out-of-date
        WebHook.find(project_hook.id).update!(recent_failures: 5, disabled_until: 10.minutes.from_now, backoff_count: 1)

        lease = stub_exclusive_lease(lease_key, timeout: described_class::LOCK_TTL)

        expect(lease).to receive(:try_obtain)
        expect(lease).to receive(:cancel)
        expect { service.execute }.to change { WebHook.find(project_hook.id).backoff_count }.to(2)
      end

      context 'when a lease cannot be obtained' do
        where(:response_category, :executable, :needs_updating) do
          :ok     | true  | false
          :ok     | false | true
          :failed | true  | true
          :failed | false | false
          :error  | true  | true
          :error  | false | false
        end

        with_them do
          subject(:service) { described_class.new(hook: project_hook, log_data: data, response_category: response_category) }

          before do
            # stub LOCK_RETRY to be 0 in order for tests to run quicker
            stub_const(""#{described_class.name}::LOCK_RETRY"", 0)
            stub_exclusive_lease_taken(lease_key, timeout: described_class::LOCK_TTL)
            allow(project_hook).to receive(:executable?).and_return(executable)
          end

          it 'raises an error if the hook needs to be updated' do
            if needs_updating
              expect { service.execute }.to raise_error(Gitlab::ExclusiveLeaseHelpers::FailedToObtainLockError)
            else
              expect { service.execute }.not_to raise_error
            end
          end
        end
      end
    end

    context 'when response_category is :ok' do
      it 'does not increment the failure count' do
        expect { service.execute }.not_to change(project_hook, :recent_failures)
      end

      it 'does not change the disabled_until attribute' do
        expect { service.execute }.not_to change(project_hook, :disabled_until)
      end

      context 'when the hook had previously failed' do
        before do
          project_hook.update!(recent_failures: 2)
        end

        it 'resets the failure count' do
          expect { service.execute }.to change(project_hook, :recent_failures).to(0)
        end
      end
    end

    context 'when response_category is :failed' do
      let(:response_category) { :failed }

      before do
        data[:response_status] = '400'
      end

      it 'increments the failure count' do
        expect { service.execute }.to change(project_hook, :recent_failures).by(1)
      end

      it 'does not change the disabled_until attribute' do
        expect { service.execute }.not_to change(project_hook, :disabled_until)
      end

      it 'does not allow the failure count to overflow' do
        project_hook.update!(recent_failures: 32767)

        expect { service.execute }.not_to change(project_hook, :recent_failures)
      end
    end

    context 'when response_category is :error' do
      let(:response_category) { :error }

      before do
        data[:response_status] = '500'
      end

      it 'backs off' do
        expect(project_hook).to receive(:backoff!)

        service.execute
      end
    end

    context 'with url_variables' do
      before do
        project_hook.update!(
          url: 'http://example1.test/{foo}-{bar}',
          url_variables: { 'foo' => 'supers3cret', 'bar' => 'token' }
        )
      end

      let(:data) { super().merge(response_headers: { 'X-Token-Id' => 'supers3cret-token', 'X-Request' => 'PUBLIC-token' }) }
      let(:expected_headers) { { 'X-Token-Id' => '{foo}-{bar}', 'X-Request' => 'PUBLIC-{bar}' } }

      it 'logs the data and masks response headers' do
        expect { service.execute }.to change(::WebHookLog, :count).by(1)

        expect(WebHookLog.recent.first.response_headers).to eq(expected_headers)
      end
    end

    context 'with X-Gitlab-Token' do
      let(:request_headers) { { 'X-Gitlab-Token' => project_hook.token } }

      it 'redacts the token' do
        service.execute

        expect(WebHookLog.recent.first.request_headers).to include('X-Gitlab-Token' => '[REDACTED]')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WebHooks
  class LogDestroyService
    BATCH_SIZE = 1000

    def initialize(web_hook_id)
      @web_hook_id = web_hook_id
    end

    def execute
      next while WebHookLog.delete_batch_for(@web_hook_id, batch_size: BATCH_SIZE)

      ServiceResponse.success
    rescue StandardError => ex
      ServiceResponse.error(message: ex.message)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WebHooks::LogDestroyService, feature_category: :webhooks do
  subject(:service) { described_class.new(hook.id) }

  describe '#execute' do
    shared_examples 'deletes web hook logs for hook' do
      before do
        create_list(:web_hook_log, 3, web_hook: hook)
        hook.destroy! # The LogDestroyService is expected to be called _after_ hook destruction
      end

      it 'deletes the logs' do
        expect { service.execute }
          .to change(WebHookLog, :count).from(3).to(0)
      end

      context 'when the data-set exceeds the batch size' do
        before do
          stub_const(""#{described_class}::BATCH_SIZE"", 2)
        end

        it 'deletes the logs' do
          expect { service.execute }
            .to change(WebHookLog, :count).from(3).to(0)
        end
      end

      context 'when it encounters an error' do
        before do
          allow(WebHookLog).to receive(:delete_batch_for).and_raise(StandardError.new('bang'))
        end

        it 'reports the error' do
          expect(service.execute)
            .to be_error
            .and have_attributes(message: 'bang')
        end
      end
    end

    context 'with system hook' do
      let!(:hook) { create(:system_hook, url: ""http://example.com"") }

      it_behaves_like 'deletes web hook logs for hook'
    end

    context 'with project hook' do
      let!(:hook) { create(:project_hook) }

      it_behaves_like 'deletes web hook logs for hook'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WebHooks
  # Destroy a hook, and schedule the logs for deletion.
  class DestroyService
    include Services::ReturnServiceResponses

    attr_accessor :current_user

    DENIED = 'Insufficient permissions'

    def initialize(current_user)
      @current_user = current_user
    end

    def execute(web_hook)
      return error(DENIED, 401) unless authorized?(web_hook)

      hook_id = web_hook.id

      if web_hook.destroy
        WebHooks::LogDestroyWorker.perform_async({ 'hook_id' => hook_id })
        Gitlab::AppLogger.info(log_message(web_hook))

        success({ async: false })
      else
        error(""Unable to destroy #{web_hook.model_name.human}"", 500)
      end
    end

    private

    def log_message(hook)
      ""User #{current_user&.id} scheduled a deletion of logs for hook ID #{hook.id}""
    end

    def authorized?(web_hook)
      Ability.allowed?(current_user, :destroy_web_hook, web_hook)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WebHooks::DestroyService, feature_category: :webhooks do
  let_it_be(:user) { create(:user) }

  subject { described_class.new(user) }

  describe '#execute' do
    # Testing with a project hook only - for permission tests, see policy specs.
    let!(:hook) { create(:project_hook) }
    let!(:log) { create_list(:web_hook_log, 3, web_hook: hook) }

    context 'when the user does not have permission' do
      it 'is an error' do
        expect(subject.execute(hook))
          .to be_error
          .and have_attributes(message: described_class::DENIED)
      end
    end

    context 'when the user does have permission' do
      before do
        hook.project.add_maintainer(user)
      end

      it 'is successful' do
        expect(subject.execute(hook)).to be_success
      end

      it 'destroys the hook' do
        expect { subject.execute(hook) }.to change(WebHook, :count).from(1).to(0)
      end

      it 'does not destroy logs' do
        expect { subject.execute(hook) }.not_to change(WebHookLog, :count)
      end

      it 'schedules the destruction of logs' do
        expect(WebHooks::LogDestroyWorker).to receive(:perform_async).with({ 'hook_id' => hook.id })
        expect(Gitlab::AppLogger).to receive(:info).with(match(/scheduled a deletion of logs/))

        subject.execute(hook)
      end

      context 'when the hook fails to destroy' do
        before do
          allow(hook).to receive(:destroy).and_return(false)
        end

        it 'is not a success' do
          expect(WebHooks::LogDestroyWorker).not_to receive(:perform_async)

          r = subject.execute(hook)

          expect(r).to be_error
          expect(r[:message]).to match %r{Unable to destroy}
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ContainerRegistry
  module Protection
    class CreateRuleService < BaseService
      ALLOWED_ATTRIBUTES = %i[
        container_path_pattern
        push_protected_up_to_access_level
        delete_protected_up_to_access_level
      ].freeze

      def execute
        unless can?(current_user, :admin_container_image, project)
          error_message = _('Unauthorized to create a container registry protection rule')
          return service_response_error(message: error_message)
        end

        container_registry_protection_rule =
          project.container_registry_protection_rules.create(params.slice(*ALLOWED_ATTRIBUTES))

        unless container_registry_protection_rule.persisted?
          return service_response_error(message: container_registry_protection_rule.errors.full_messages.to_sentence)
        end

        ServiceResponse.success(payload: { container_registry_protection_rule: container_registry_protection_rule })
      rescue StandardError => e
        service_response_error(message: e.message)
      end

      private

      def service_response_error(message:)
        ServiceResponse.error(
          message: message,
          payload: { container_registry_protection_rule: nil }
        )
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ContainerRegistry::Protection::CreateRuleService, '#execute', feature_category: :container_registry do
  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:current_user) { create(:user, maintainer_projects: [project]) }

  let(:service) { described_class.new(project, current_user, params) }
  let(:params) { attributes_for(:container_registry_protection_rule) }

  subject { service.execute }

  shared_examples 'a successful service response' do
    it { is_expected.to be_success }

    it { is_expected.to have_attributes(errors: be_blank) }

    it do
      is_expected.to have_attributes(
        payload: {
          container_registry_protection_rule:
            be_a(ContainerRegistry::Protection::Rule)
              .and(have_attributes(
                container_path_pattern: params[:container_path_pattern],
                push_protected_up_to_access_level: params[:push_protected_up_to_access_level].to_s,
                delete_protected_up_to_access_level: params[:delete_protected_up_to_access_level].to_s
              ))
        }
      )
    end

    it 'creates a new container registry protection rule in the database' do
      expect { subject }.to change { ContainerRegistry::Protection::Rule.count }.by(1)

      expect(
        ContainerRegistry::Protection::Rule.where(
          project: project,
          container_path_pattern: params[:container_path_pattern],
          push_protected_up_to_access_level: params[:push_protected_up_to_access_level]
        )
      ).to exist
    end
  end

  shared_examples 'an erroneous service response' do
    it { is_expected.to be_error }
    it { is_expected.to have_attributes(errors: be_present, payload: include(container_registry_protection_rule: nil)) }

    it 'does not create a new container registry protection rule in the database' do
      expect { subject }.not_to change { ContainerRegistry::Protection::Rule.count }
    end

    it 'does not create a container registry protection rule with the given params' do
      subject

      expect(
        ContainerRegistry::Protection::Rule.where(
          project: project,
          container_path_pattern: params[:container_path_pattern],
          push_protected_up_to_access_level: params[:push_protected_up_to_access_level]
        )
      ).not_to exist
    end
  end

  it_behaves_like 'a successful service response'

  context 'when fields are invalid' do
    context 'when container_path_pattern is invalid' do
      let(:params) { super().merge(container_path_pattern: '') }

      it_behaves_like 'an erroneous service response'

      it { is_expected.to have_attributes(message: match(/Container path pattern can't be blank/)) }
    end

    context 'when delete_protected_up_to_access_level is invalid' do
      let(:params) { super().merge(delete_protected_up_to_access_level: 1000) }

      it_behaves_like 'an erroneous service response'

      it { is_expected.to have_attributes(message: match(/is not a valid delete_protected_up_to_access_level/)) }
    end

    context 'when push_protected_up_to_access_level is invalid' do
      let(:params) { super().merge(push_protected_up_to_access_level: 1000) }

      it_behaves_like 'an erroneous service response'

      it { is_expected.to have_attributes(message: match(/is not a valid push_protected_up_to_access_level/)) }
    end
  end

  context 'with existing container registry protection rule in the database' do
    let_it_be_with_reload(:existing_container_registry_protection_rule) do
      create(:container_registry_protection_rule, project: project)
    end

    context 'when container registry name pattern is slightly different' do
      let(:params) do
        super().merge(
          # The field `container_path_pattern` is unique; this is why we change the value in a minimum way
          container_path_pattern: ""#{existing_container_registry_protection_rule.container_path_pattern}-unique"",
          push_protected_up_to_access_level:
            existing_container_registry_protection_rule.push_protected_up_to_access_level
        )
      end

      it_behaves_like 'a successful service response'
    end

    context 'when field `container_path_pattern` is taken' do
      let(:params) do
        super().merge(
          container_path_pattern: existing_container_registry_protection_rule.container_path_pattern,
          push_protected_up_to_access_level: :maintainer
        )
      end

      it_behaves_like 'an erroneous service response'

      it { is_expected.to have_attributes(errors: ['Container path pattern has already been taken']) }

      it { expect { subject }.not_to change { existing_container_registry_protection_rule.updated_at } }
    end
  end

  context 'with disallowed params' do
    let(:params) { super().merge(project_id: 1, unsupported_param: 'unsupported_param_value') }

    it_behaves_like 'a successful service response'
  end

  context 'with forbidden user access level (project developer role)' do
    # Because of the access level hierarchy, we can assume that
    # other access levels below developer role will also not be able to
    # create container registry protection rules.
    let_it_be(:current_user) { create(:user).tap { |u| project.add_developer(u) } }

    it_behaves_like 'an erroneous service response'

    it { is_expected.to have_attributes(message: match(/Unauthorized/)) }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module LooseForeignKeys
  class ProcessDeletedRecordsService
    BATCH_SIZE = 1000

    def initialize(connection:, modification_tracker: LooseForeignKeys::ModificationTracker.new)
      @connection = connection
      @modification_tracker = modification_tracker
    end

    def execute
      raised_error = false
      tracked_tables.cycle do |table|
        records = load_batch_for_table(table)

        if records.empty?
          tracked_tables.delete(table)
          next
        end

        break if modification_tracker.over_limit?

        loose_foreign_key_definitions = Gitlab::Database::LooseForeignKeys.definitions_by_table[table]

        next if loose_foreign_key_definitions.empty?

        LooseForeignKeys::BatchCleanerService
          .new(
            parent_table: table,
            loose_foreign_key_definitions: loose_foreign_key_definitions,
            deleted_parent_records: records,
            modification_tracker: modification_tracker)
          .execute

        break if modification_tracker.over_limit?
      end

      ::Gitlab::Metrics::LooseForeignKeysSlis.record_apdex(
        success: !modification_tracker.over_limit?,
        db_config_name: db_config_name
      )

      modification_tracker.stats
    rescue StandardError
      raised_error = true
      raise
    ensure
      ::Gitlab::Metrics::LooseForeignKeysSlis.record_error_rate(
        error: raised_error,
        db_config_name: db_config_name
      )
    end

    private

    attr_reader :connection, :modification_tracker

    def db_config_name
      ::Gitlab::Database.db_config_name(connection)
    end

    def load_batch_for_table(table)
      fully_qualified_table_name = ""#{current_schema}.#{table}""
      LooseForeignKeys::DeletedRecord.load_batch_for_table(fully_qualified_table_name, BATCH_SIZE)
    end

    def current_schema
      @current_schema = connection.current_schema
    end

    def tracked_tables
      @tracked_tables ||= Gitlab::Database::LooseForeignKeys.definitions_by_table.keys.shuffle
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe LooseForeignKeys::ProcessDeletedRecordsService, feature_category: :database do
  include MigrationsHelpers

  def create_table_structure
    migration = ActiveRecord::Migration.new.extend(Gitlab::Database::MigrationHelpers::LooseForeignKeyHelpers)

    migration.create_table :_test_loose_fk_parent_table_1
    migration.create_table :_test_loose_fk_parent_table_2

    migration.create_table :_test_loose_fk_child_table_1_1 do |t|
      t.bigint :parent_id
    end

    migration.create_table :_test_loose_fk_child_table_1_2 do |t|
      t.bigint :parent_id_with_different_column
    end

    migration.create_table :_test_loose_fk_child_table_2_1 do |t|
      t.bigint :parent_id
    end

    migration.track_record_deletions(:_test_loose_fk_parent_table_1)
    migration.track_record_deletions(:_test_loose_fk_parent_table_2)
  end

  let(:all_loose_foreign_key_definitions) do
    {
      '_test_loose_fk_parent_table_1' => [
        ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(
          '_test_loose_fk_child_table_1_1',
          '_test_loose_fk_parent_table_1',
          {
            column: 'parent_id',
            on_delete: :async_delete,
            gitlab_schema: :gitlab_main
          }
        ),
        ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(
          '_test_loose_fk_child_table_1_2',
          '_test_loose_fk_parent_table_1',
          {
            column: 'parent_id_with_different_column',
            on_delete: :async_nullify,
            gitlab_schema: :gitlab_main
          }
        )
      ],
      '_test_loose_fk_parent_table_2' => [
        ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(
          '_test_loose_fk_child_table_2_1',
          '_test_loose_fk_parent_table_2',
          {
            column: 'parent_id',
            on_delete: :async_delete,
            gitlab_schema: :gitlab_main
          }
        )
      ]
    }
  end

  let(:connection) { ::ApplicationRecord.connection }

  let(:loose_fk_parent_table_1) { table(:_test_loose_fk_parent_table_1) }
  let(:loose_fk_parent_table_2) { table(:_test_loose_fk_parent_table_2) }
  let(:loose_fk_child_table_1_1) { table(:_test_loose_fk_child_table_1_1) }
  let(:loose_fk_child_table_1_2) { table(:_test_loose_fk_child_table_1_2) }
  let(:loose_fk_child_table_2_1) { table(:_test_loose_fk_child_table_2_1) }

  before_all do
    create_table_structure
  end

  after(:all) do
    migration = ActiveRecord::Migration.new

    migration.drop_table :_test_loose_fk_parent_table_1
    migration.drop_table :_test_loose_fk_parent_table_2
    migration.drop_table :_test_loose_fk_child_table_1_1
    migration.drop_table :_test_loose_fk_child_table_1_2
    migration.drop_table :_test_loose_fk_child_table_2_1
  end

  before do
    allow(Gitlab::Database::LooseForeignKeys).to receive(:definitions_by_table)
      .and_return(all_loose_foreign_key_definitions)

    parent_record_1 = loose_fk_parent_table_1.create!
    loose_fk_child_table_1_1.create!(parent_id: parent_record_1.id)
    loose_fk_child_table_1_2.create!(parent_id_with_different_column: parent_record_1.id)

    parent_record_2 = loose_fk_parent_table_1.create!
    2.times { loose_fk_child_table_1_1.create!(parent_id: parent_record_2.id) }
    3.times { loose_fk_child_table_1_2.create!(parent_id_with_different_column: parent_record_2.id) }

    parent_record_3 = loose_fk_parent_table_2.create!
    5.times { loose_fk_child_table_2_1.create!(parent_id: parent_record_3.id) }

    loose_fk_parent_table_1.delete_all
    loose_fk_parent_table_2.delete_all
  end

  describe '#execute' do
    def execute
      ::Gitlab::Database::SharedModel.using_connection(connection) do
        described_class.new(connection: connection).execute
      end
    end

    it 'cleans up all rows' do
      execute

      expect(loose_fk_child_table_1_1.count).to eq(0)
      expect(loose_fk_child_table_1_2.where(parent_id_with_different_column: nil).count).to eq(4)
      expect(loose_fk_child_table_2_1.count).to eq(0)
    end

    it 'returns stats for records cleaned up' do
      stats = execute

      expect(stats[:delete_count]).to eq(8)
      expect(stats[:update_count]).to eq(4)
    end

    it 'records the Apdex as success: true' do
      expect(::Gitlab::Metrics::LooseForeignKeysSlis).to receive(:record_apdex)
        .with(success: true, db_config_name: 'main')

      execute
    end

    it 'records the error rate as error: false' do
      expect(::Gitlab::Metrics::LooseForeignKeysSlis).to receive(:record_error_rate)
        .with(error: false, db_config_name: 'main')

      execute
    end

    context 'when the amount of records to clean up exceeds BATCH_SIZE' do
      before do
        stub_const('LooseForeignKeys::CleanupWorker::BATCH_SIZE', 2)
      end

      it 'cleans up everything over multiple batches' do
        expect(LooseForeignKeys::BatchCleanerService).to receive(:new).exactly(:twice).and_call_original

        execute

        expect(loose_fk_child_table_1_1.count).to eq(0)
        expect(loose_fk_child_table_1_2.where(parent_id_with_different_column: nil).count).to eq(4)
        expect(loose_fk_child_table_2_1.count).to eq(0)
      end
    end

    context 'when the amount of records to clean up exceeds the total MAX_DELETES' do
      def count_deletable_rows
        loose_fk_child_table_1_1.count + loose_fk_child_table_2_1.count
      end

      before do
        allow_next_instance_of(LooseForeignKeys::ModificationTracker) do |instance|
          allow(instance).to receive(:max_deletes).and_return(2)
        end
        stub_const('LooseForeignKeys::CleanerService::DELETE_LIMIT', 1)
      end

      it 'cleans up MAX_DELETES and leaves the rest for the next run' do
        expect { execute }.to change { count_deletable_rows }.by(-2)
        expect(count_deletable_rows).to be > 0
      end

      it 'records the Apdex as success: false' do
        expect(::Gitlab::Metrics::LooseForeignKeysSlis).to receive(:record_apdex)
          .with(success: false, db_config_name: 'main')

        execute
      end
    end

    context 'when cleanup raises an error' do
      before do
        expect_next_instance_of(::LooseForeignKeys::BatchCleanerService) do |service|
          allow(service).to receive(:execute).and_raise(""Something broke"")
        end
      end

      it 'records the error rate as error: true and does not increment apdex' do
        expect(::Gitlab::Metrics::LooseForeignKeysSlis).to receive(:record_error_rate)
          .with(error: true, db_config_name: 'main')
        expect(::Gitlab::Metrics::LooseForeignKeysSlis).not_to receive(:record_apdex)

        expect { execute }.to raise_error(""Something broke"")
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module LooseForeignKeys
  # rubocop: disable CodeReuse/ActiveRecord
  class CleanerService
    DELETE_LIMIT = 1000
    UPDATE_LIMIT = 500

    def initialize(loose_foreign_key_definition:, connection:, deleted_parent_records:, with_skip_locked: false)
      @loose_foreign_key_definition = loose_foreign_key_definition
      @connection = connection
      @deleted_parent_records = deleted_parent_records
      @with_skip_locked = with_skip_locked
    end

    def execute
      result = connection.execute(build_query)

      { affected_rows: result.cmd_tuples, table: loose_foreign_key_definition.from_table }
    end

    def async_delete?
      loose_foreign_key_definition.on_delete == :async_delete
    end

    def async_nullify?
      loose_foreign_key_definition.on_delete == :async_nullify
    end

    private

    attr_reader :loose_foreign_key_definition, :connection, :deleted_parent_records, :with_skip_locked

    def build_query
      query = if async_delete?
                delete_query
              elsif async_nullify?
                update_query
              else
                raise ""Invalid on_delete argument: #{loose_foreign_key_definition.on_delete}""
              end

      unless query.include?(%{""#{loose_foreign_key_definition.column}"" IN (})
        raise(""FATAL: foreign key condition is missing from the generated query: #{query}"")
      end

      query
    end

    def arel_table
      @arel_table ||= Arel::Table.new(loose_foreign_key_definition.from_table)
    end

    def primary_keys
      @primary_keys ||= connection.primary_keys(loose_foreign_key_definition.from_table).map { |key| arel_table[key] }
    end

    def quoted_table_name
      @quoted_table_name ||= Arel.sql(connection.quote_table_name(loose_foreign_key_definition.from_table))
    end

    def delete_query
      query = Arel::DeleteManager.new
      query.from(quoted_table_name)

      add_in_query_with_limit(query, DELETE_LIMIT)
    end

    def update_query
      query = Arel::UpdateManager.new
      query.table(quoted_table_name)
      query.set([[arel_table[loose_foreign_key_definition.column], nil]])

      add_in_query_with_limit(query, UPDATE_LIMIT)
    end

    # IN query with one or composite primary key
    # WHERE (primary_key1, primary_key2) IN (subselect)
    def add_in_query_with_limit(query, limit)
      columns = Arel::Nodes::Grouping.new(primary_keys)
      query.where(columns.in(in_query_with_limit(limit))).to_sql
    end

    # Builds the following sub-query
    # SELECT primary_keys FROM table WHERE foreign_key IN (1, 2, 3) LIMIT N
    def in_query_with_limit(limit)
      in_query = Arel::SelectManager.new
      in_query.from(quoted_table_name)
      in_query.where(arel_table[loose_foreign_key_definition.column].in(deleted_parent_records.map(&:primary_key_value)))
      in_query.projections = primary_keys
      in_query.take(limit)
      in_query.lock(Arel.sql('FOR UPDATE SKIP LOCKED')) if with_skip_locked
      in_query
    end
  end
  # rubocop: enable CodeReuse/ActiveRecord
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe LooseForeignKeys::CleanerService, feature_category: :database do
  let(:schema) { ApplicationRecord.connection.current_schema }
  let(:deleted_records) do
    [
      LooseForeignKeys::DeletedRecord.new(fully_qualified_table_name: ""#{schema}.projects"", primary_key_value: non_existing_record_id),
      LooseForeignKeys::DeletedRecord.new(fully_qualified_table_name: ""#{schema}.projects"", primary_key_value: non_existing_record_id)
    ]
  end

  let(:loose_fk_definition) do
    ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(
      'issues',
      'projects',
      {
        column: 'project_id',
        on_delete: :async_nullify,
        gitlab_schema: :gitlab_main
      }
    )
  end

  subject(:cleaner_service) do
    described_class.new(
      loose_foreign_key_definition: loose_fk_definition,
      connection: ApplicationRecord.connection,
      deleted_parent_records: deleted_records)
  end

  context 'when invalid foreign key definition is passed' do
    context 'when invalid on_delete argument was given' do
      before do
        loose_fk_definition.options[:on_delete] = :invalid
      end

      it 'raises KeyError' do
        expect { cleaner_service.execute }.to raise_error(StandardError, /Invalid on_delete argument/)
      end
    end
  end

  describe 'query generation' do
    context 'when single primary key is used' do
      let(:issue) { create(:issue) }

      let(:deleted_records) do
        [
          LooseForeignKeys::DeletedRecord.new(fully_qualified_table_name: ""#{schema}.projects"", primary_key_value: issue.project_id)
        ]
      end

      it 'generates an IN query for nullifying the rows' do
        expected_query = %{UPDATE ""issues"" SET ""project_id"" = NULL WHERE (""issues"".""id"") IN (SELECT ""issues"".""id"" FROM ""issues"" WHERE ""issues"".""project_id"" IN (#{issue.project_id}) LIMIT 500)}
        expect(ApplicationRecord.connection).to receive(:execute).with(expected_query).and_call_original

        cleaner_service.execute

        issue.reload
        expect(issue.project_id).to be_nil
      end

      it 'generates an IN query for deleting the rows' do
        loose_fk_definition.options[:on_delete] = :async_delete

        expected_query = %{DELETE FROM ""issues"" WHERE (""issues"".""id"") IN (SELECT ""issues"".""id"" FROM ""issues"" WHERE ""issues"".""project_id"" IN (#{issue.project_id}) LIMIT 1000)}
        expect(ApplicationRecord.connection).to receive(:execute).with(expected_query).and_call_original

        cleaner_service.execute

        expect(Issue.exists?(id: issue.id)).to eq(false)
      end
    end

    context 'when composite primary key is used' do
      let!(:user) { create(:user) }
      let!(:project) { create(:project) }

      let(:loose_fk_definition) do
        ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(
          'project_authorizations',
          'users',
          {
            column: 'user_id',
            on_delete: :async_delete,
            gitlab_schema: :gitlab_main
          }
        )
      end

      let(:deleted_records) do
        [
          LooseForeignKeys::DeletedRecord.new(fully_qualified_table_name: ""#{schema}.users"", primary_key_value: user.id)
        ]
      end

      subject(:cleaner_service) do
        described_class.new(
          loose_foreign_key_definition: loose_fk_definition,
          connection: ApplicationRecord.connection,
          deleted_parent_records: deleted_records
        )
      end

      before do
        project.add_developer(user)
      end

      it 'generates an IN query for deleting the rows' do
        expected_query = %{DELETE FROM ""project_authorizations"" WHERE (""project_authorizations"".""user_id"", ""project_authorizations"".""project_id"", ""project_authorizations"".""access_level"") IN (SELECT ""project_authorizations"".""user_id"", ""project_authorizations"".""project_id"", ""project_authorizations"".""access_level"" FROM ""project_authorizations"" WHERE ""project_authorizations"".""user_id"" IN (#{user.id}) LIMIT 1000)}
        expect(ApplicationRecord.connection).to receive(:execute).with(expected_query).and_call_original

        cleaner_service.execute

        expect(ProjectAuthorization.exists?(user_id: user.id)).to eq(false)
      end

      context 'when the query generation is incorrect (paranoid check)' do
        it 'raises error if the foreign key condition is missing' do
          expect_next_instance_of(LooseForeignKeys::CleanerService) do |instance|
            expect(instance).to receive(:delete_query).and_return('wrong query')
          end

          expect { cleaner_service.execute }.to raise_error /FATAL: foreign key condition is missing from the generated query/
        end
      end
    end

    context 'when with_skip_locked parameter is true' do
      subject(:cleaner_service) do
        described_class.new(
          loose_foreign_key_definition: loose_fk_definition,
          connection: ApplicationRecord.connection,
          deleted_parent_records: deleted_records,
          with_skip_locked: true
        )
      end

      it 'generates a query with the SKIP LOCKED clause' do
        expect(ApplicationRecord.connection).to receive(:execute).with(/FOR UPDATE SKIP LOCKED/).and_call_original

        cleaner_service.execute
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module LooseForeignKeys
  class BatchCleanerService
    CLEANUP_ATTEMPTS_BEFORE_RESCHEDULE = 3
    CONSUME_AFTER_RESCHEDULE = 5.minutes

    def initialize(parent_table:, loose_foreign_key_definitions:, deleted_parent_records:, modification_tracker: LooseForeignKeys::ModificationTracker.new)
      @parent_table = parent_table
      @loose_foreign_key_definitions = loose_foreign_key_definitions
      @deleted_parent_records = deleted_parent_records
      @modification_tracker = modification_tracker
      @deleted_records_counter = Gitlab::Metrics.counter(
        :loose_foreign_key_processed_deleted_records,
        'The number of processed loose foreign key deleted records'
      )
      @deleted_records_rescheduled_count = Gitlab::Metrics.counter(
        :loose_foreign_key_rescheduled_deleted_records,
        'The number of rescheduled loose foreign key deleted records'
      )
      @deleted_records_incremented_count = Gitlab::Metrics.counter(
        :loose_foreign_key_incremented_deleted_records,
        'The number of loose foreign key deleted records with incremented cleanup_attempts'
      )
    end

    def execute
      loose_foreign_key_definitions.each do |loose_foreign_key_definition|
        run_cleaner_service(loose_foreign_key_definition, with_skip_locked: true)

        if modification_tracker.over_limit?
          handle_over_limit
          break
        end

        run_cleaner_service(loose_foreign_key_definition, with_skip_locked: false)

        if modification_tracker.over_limit?
          handle_over_limit
          break
        end
      end

      return if modification_tracker.over_limit?

      # At this point, all associations are cleaned up, we can update the status of the parent records
      update_count = LooseForeignKeys::DeletedRecord.mark_records_processed(deleted_parent_records)

      deleted_records_counter.increment({ table: parent_table, db_config_name: db_config_name }, update_count)
    end

    private

    attr_reader :parent_table, :loose_foreign_key_definitions, :deleted_parent_records, :modification_tracker, :deleted_records_counter, :deleted_records_rescheduled_count, :deleted_records_incremented_count

    def handle_over_limit
      records_to_reschedule = []
      records_to_increment = []

      deleted_parent_records.each do |deleted_record|
        if deleted_record.cleanup_attempts >= CLEANUP_ATTEMPTS_BEFORE_RESCHEDULE
          records_to_reschedule << deleted_record
        else
          records_to_increment << deleted_record
        end
      end

      reschedule_count = LooseForeignKeys::DeletedRecord.reschedule(records_to_reschedule, CONSUME_AFTER_RESCHEDULE.from_now)
      deleted_records_rescheduled_count.increment({ table: parent_table, db_config_name: db_config_name }, reschedule_count)

      increment_count = LooseForeignKeys::DeletedRecord.increment_attempts(records_to_increment)
      deleted_records_incremented_count.increment({ table: parent_table, db_config_name: db_config_name }, increment_count)
    end

    def record_result(cleaner, result)
      if cleaner.async_delete?
        modification_tracker.add_deletions(result[:table], result[:affected_rows])
      elsif cleaner.async_nullify?
        modification_tracker.add_updates(result[:table], result[:affected_rows])
      end
    end

    def run_cleaner_service(loose_foreign_key_definition, with_skip_locked:)
      base_models_for_gitlab_schema = Gitlab::Database.schemas_to_base_models.fetch(loose_foreign_key_definition.options[:gitlab_schema])
      base_models_for_gitlab_schema.each do |base_model|
        cleaner = CleanerService.new(
          loose_foreign_key_definition: loose_foreign_key_definition,
          connection: base_model.connection,
          deleted_parent_records: deleted_parent_records,
          with_skip_locked: with_skip_locked
        )

        loop do
          result = cleaner.execute
          record_result(cleaner, result)

          break if modification_tracker.over_limit? || result[:affected_rows] == 0
        end
      end
    end

    def db_config_name
      LooseForeignKeys::DeletedRecord.connection.pool.db_config.name
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe LooseForeignKeys::BatchCleanerService, feature_category: :database do
  include MigrationsHelpers

  def create_table_structure
    migration = ActiveRecord::Migration.new.extend(Gitlab::Database::MigrationHelpers::LooseForeignKeyHelpers)

    migration.create_table :_test_loose_fk_parent_table

    migration.create_table :_test_loose_fk_child_table_1 do |t|
      t.bigint :parent_id
    end

    migration.create_table :_test_loose_fk_child_table_2 do |t|
      t.bigint :parent_id_with_different_column
    end

    migration.track_record_deletions(:_test_loose_fk_parent_table)
  end

  let(:loose_foreign_key_definitions) do
    [
      ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(
        '_test_loose_fk_child_table_1',
        '_test_loose_fk_parent_table',
        {
          column: 'parent_id',
          on_delete: :async_delete,
          gitlab_schema: :gitlab_main
        }
      ),
      ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(
        '_test_loose_fk_child_table_2',
        '_test_loose_fk_parent_table',
        {
          column: 'parent_id_with_different_column',
          on_delete: :async_nullify,
          gitlab_schema: :gitlab_main
        }
      )
    ]
  end

  let(:loose_fk_parent_table) { table(:_test_loose_fk_parent_table) }
  let(:loose_fk_child_table_1) { table(:_test_loose_fk_child_table_1) }
  let(:loose_fk_child_table_2) { table(:_test_loose_fk_child_table_2) }
  let(:parent_record_1) { loose_fk_parent_table.create! }
  let(:other_parent_record) { loose_fk_parent_table.create! }

  before_all do
    create_table_structure
  end

  before do
    parent_record_1

    loose_fk_child_table_1.create!(parent_id: parent_record_1.id)
    loose_fk_child_table_1.create!(parent_id: parent_record_1.id)

    # these will not be deleted
    loose_fk_child_table_1.create!(parent_id: other_parent_record.id)
    loose_fk_child_table_1.create!(parent_id: other_parent_record.id)

    loose_fk_child_table_2.create!(parent_id_with_different_column: parent_record_1.id)
    loose_fk_child_table_2.create!(parent_id_with_different_column: parent_record_1.id)

    # these will not be deleted
    loose_fk_child_table_2.create!(parent_id_with_different_column: other_parent_record.id)
    loose_fk_child_table_2.create!(parent_id_with_different_column: other_parent_record.id)
  end

  after(:all) do
    migration = ActiveRecord::Migration.new
    migration.drop_table :_test_loose_fk_parent_table
    migration.drop_table :_test_loose_fk_child_table_1
    migration.drop_table :_test_loose_fk_child_table_2
  end

  context 'when parent records are deleted' do
    let(:deleted_records_counter) { Gitlab::Metrics.registry.get(:loose_foreign_key_processed_deleted_records) }

    before do
      parent_record_1.delete

      expect(loose_fk_child_table_1.count).to eq(4)
      expect(loose_fk_child_table_2.count).to eq(4)

      described_class.new(
        parent_table: '_test_loose_fk_parent_table',
        loose_foreign_key_definitions: loose_foreign_key_definitions,
        deleted_parent_records: LooseForeignKeys::DeletedRecord.load_batch_for_table('public._test_loose_fk_parent_table', 100)
      ).execute
    end

    it 'cleans up the child records' do
      expect(loose_fk_child_table_1.where(parent_id: parent_record_1.id)).to be_empty
      expect(loose_fk_child_table_2.where(parent_id_with_different_column: nil).count).to eq(2)
    end

    it 'cleans up the pending parent DeletedRecord' do
      expect(LooseForeignKeys::DeletedRecord.status_pending.count).to eq(0)
      expect(LooseForeignKeys::DeletedRecord.status_processed.count).to eq(1)
    end

    it 'records the DeletedRecord status updates', :prometheus do
      counter = Gitlab::Metrics.registry.get(:loose_foreign_key_processed_deleted_records)

      expect(counter.get(table: loose_fk_parent_table.table_name, db_config_name: 'main')).to eq(1)
    end

    it 'does not delete unrelated records' do
      expect(loose_fk_child_table_1.where(parent_id: other_parent_record.id).count).to eq(2)
      expect(loose_fk_child_table_2.where(parent_id_with_different_column: other_parent_record.id).count).to eq(2)
    end
  end

  describe 'fair queueing' do
    context 'when the execution is over the limit' do
      let(:modification_tracker) { instance_double(LooseForeignKeys::ModificationTracker) }
      let(:over_limit_return_values) { [true] }
      let(:deleted_record) { LooseForeignKeys::DeletedRecord.load_batch_for_table('public._test_loose_fk_parent_table', 1).first }
      let(:deleted_records_rescheduled_counter) { Gitlab::Metrics.registry.get(:loose_foreign_key_rescheduled_deleted_records) }
      let(:deleted_records_incremented_counter) { Gitlab::Metrics.registry.get(:loose_foreign_key_incremented_deleted_records) }

      let(:cleaner) do
        described_class.new(
          parent_table: '_test_loose_fk_parent_table',
          loose_foreign_key_definitions: loose_foreign_key_definitions,
          deleted_parent_records: LooseForeignKeys::DeletedRecord.load_batch_for_table('public._test_loose_fk_parent_table', 100),
          modification_tracker: modification_tracker
        )
      end

      before do
        parent_record_1.delete
        allow(modification_tracker).to receive(:over_limit?).and_return(*over_limit_return_values)
        allow(modification_tracker).to receive(:add_deletions)
      end

      context 'when the deleted record is under the maximum allowed cleanup attempts' do
        it 'updates the cleanup_attempts column', :aggregate_failures do
          deleted_record.update!(cleanup_attempts: 1)

          cleaner.execute

          expect(deleted_record.reload.cleanup_attempts).to eq(2)
          expect(deleted_records_incremented_counter.get(table: loose_fk_parent_table.table_name, db_config_name: 'main')).to eq(1)
        end

        context 'when the deleted record is above the maximum allowed cleanup attempts' do
          it 'reschedules the record', :aggregate_failures do
            deleted_record.update!(cleanup_attempts: LooseForeignKeys::BatchCleanerService::CLEANUP_ATTEMPTS_BEFORE_RESCHEDULE + 1)

            freeze_time do
              cleaner.execute

              expect(deleted_record.reload).to have_attributes(
                cleanup_attempts: 0,
                consume_after: 5.minutes.from_now
              )
              expect(deleted_records_rescheduled_counter.get(table: loose_fk_parent_table.table_name, db_config_name: 'main')).to eq(1)
            end
          end
        end

        describe 'when over limit happens on the second cleanup call without skip locked' do
          # over_limit? is called twice, we test here the 2nd call
          # - When invoking cleanup with SKIP LOCKED
          # - When invoking cleanup (no SKIP LOCKED)
          let(:over_limit_return_values) { [false, true] }

          it 'updates the cleanup_attempts column' do
            expect(cleaner).to receive(:run_cleaner_service).twice

            deleted_record.update!(cleanup_attempts: 1)

            cleaner.execute

            expect(deleted_record.reload.cleanup_attempts).to eq(2)
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

#
# Used by NotificationService to determine who should receive notification
#
module NotificationRecipients
  module BuildService
    def self.notifiable_users(users, *args)
      users.compact.map { |u| NotificationRecipient.new(u, *args) }.select(&:notifiable?).map(&:user)
    end

    def self.notifiable?(user, *args)
      NotificationRecipient.new(user, *args).notifiable?
    end

    def self.build_recipients(target, current_user, **args)
      ::NotificationRecipients::Builder::Default.new(target, current_user, **args).notification_recipients
    end

    def self.build_new_note_recipients(...)
      ::NotificationRecipients::Builder::NewNote.new(...).notification_recipients
    end

    def self.build_merge_request_unmergeable_recipients(...)
      ::NotificationRecipients::Builder::MergeRequestUnmergeable.new(...).notification_recipients
    end

    def self.build_project_maintainers_recipients(target, **args)
      ::NotificationRecipients::Builder::ProjectMaintainers.new(target, **args).notification_recipients
    end

    def self.build_new_review_recipients(...)
      ::NotificationRecipients::Builder::NewReview.new(...).notification_recipients
    end

    def self.build_requested_review_recipients(...)
      ::NotificationRecipients::Builder::RequestReview.new(...).notification_recipients
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe NotificationRecipients::BuildService, feature_category: :team_planning do
  let(:service) { described_class }
  let(:assignee) { create(:user) }
  let(:project) { create(:project, :public) }
  let(:other_projects) { create_list(:project, 5, :public) }

  describe '#build_new_note_recipients' do
    let(:issue) { create(:issue, project: project, assignees: [assignee]) }
    let(:note) { create(:note_on_issue, noteable: issue, project_id: issue.project_id) }

    shared_examples 'no N+1 queries' do
      it 'avoids N+1 queries', :request_store do
        # existing N+1 due to multiple users having to be looked up in the project_authorizations table
        threshold = project.private? ? 1 : 0

        create_user

        service.build_new_note_recipients(note)

        control_count = ActiveRecord::QueryRecorder.new do
          service.build_new_note_recipients(note)
        end

        create_user

        expect { service.build_new_note_recipients(note) }.not_to exceed_query_limit(control_count).with_threshold(threshold)
      end
    end

    context 'when there are multiple watchers' do
      def create_user
        watcher = create(:user)
        create(:notification_setting, source: project, user: watcher, level: :watch)

        other_projects.each do |other_project|
          create(:notification_setting, source: other_project, user: watcher, level: :watch)
        end
      end

      include_examples 'no N+1 queries'
    end

    context 'when there are multiple subscribers' do
      def create_user
        subscriber = create(:user)
        issue.subscriptions.create!(user: subscriber, project: project, subscribed: true)
      end

      include_examples 'no N+1 queries'

      context 'when the project is private' do
        before do
          project.update!(visibility_level: Gitlab::VisibilityLevel::PRIVATE)
        end

        include_examples 'no N+1 queries'
      end
    end
  end

  describe '#build_new_review_recipients' do
    let(:merge_request) { create(:merge_request, source_project: project, target_project: project) }
    let(:review) { create(:review, merge_request: merge_request, project: project, author: merge_request.author) }
    let(:notes) { create_list(:note_on_merge_request, 3, review: review, noteable: review.merge_request, project: review.project) }

    shared_examples 'no N+1 queries' do
      it 'avoids N+1 queries', :request_store do
        # existing N+1 due to multiple users having to be looked up in the project_authorizations table
        threshold = project.private? ? 1 : 0

        create_user

        service.build_new_review_recipients(review)

        control_count = ActiveRecord::QueryRecorder.new do
          service.build_new_review_recipients(review)
        end

        create_user

        expect { service.build_new_review_recipients(review) }.not_to exceed_query_limit(control_count).with_threshold(threshold)
      end
    end

    context 'when there are multiple watchers' do
      def create_user
        watcher = create(:user)
        create(:notification_setting, source: project, user: watcher, level: :watch)

        other_projects.each do |other_project|
          create(:notification_setting, source: other_project, user: watcher, level: :watch)
        end
      end

      include_examples 'no N+1 queries'
    end

    context 'when there are multiple subscribers' do
      def create_user
        subscriber = create(:user)
        merge_request.subscriptions.create!(user: subscriber, project: project, subscribed: true)
      end

      include_examples 'no N+1 queries'

      context 'when the project is private' do
        before do
          project.update!(visibility_level: Gitlab::VisibilityLevel::PRIVATE)
        end

        include_examples 'no N+1 queries'
      end
    end
  end

  describe '#build_requested_review_recipients' do
    let(:merge_request) { create(:merge_request, source_project: project, target_project: project) }

    before do
      merge_request.reviewers.push(assignee)
    end

    shared_examples 'no N+1 queries' do
      it 'avoids N+1 queries', :request_store do
        create_user

        service.build_requested_review_recipients(note)

        control_count = ActiveRecord::QueryRecorder.new do
          service.build_requested_review_recipients(note)
        end

        create_user

        expect { service.build_requested_review_recipients(note) }.not_to exceed_query_limit(control_count)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module NotificationRecipients
  module Builder
    class NewNote < Base
      attr_reader :note

      def initialize(note)
        @note = note
      end

      def target
        note.noteable
      end

      def recipients_target
        note
      end

      # NOTE: may be nil, in the case of a PersonalSnippet
      #
      # (this is okay because NotificationRecipient is written
      # to handle nil projects)
      def project
        note.project
      end

      def group
        if note.for_project_noteable?
          project.group
        else
          target.try(:group)
        end
      end

      def build!
        # Add all users participating in the thread (author, assignee, comment authors)
        add_participants(note.author)
        add_mentions(note.author, target: note)

        if note.for_project_noteable?
          # Merge project watchers
          add_project_watchers
        else
          add_group_watchers
        end

        add_custom_notifications
        add_subscribed_users
      end

      def custom_action
        :new_note
      end

      def acting_user
        note.author
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe NotificationRecipients::Builder::NewNote, feature_category: :team_planning do
  describe '#notification_recipients' do
    let_it_be(:group)   { create(:group, :public) }
    let_it_be(:project) { create(:project, :public, group: group) }
    let_it_be(:issue) { create(:issue, project: project) }

    let_it_be(:other_user)              { create(:user) }
    let_it_be(:participant)             { create(:user) }
    let_it_be(:non_member_participant)  { create(:user) }
    let_it_be(:group_watcher)           { create(:user) }
    let_it_be(:project_watcher)         { create(:user) }
    let_it_be(:guest_project_watcher)   { create(:user) }
    let_it_be(:subscriber)              { create(:user) }
    let_it_be(:unsubscribed_user)       { create(:user) }
    let_it_be(:non_member_subscriber)   { create(:user) }

    let_it_be(:notification_setting_project_w) { create(:notification_setting, source: project, user: project_watcher, level: 2) }
    let_it_be(:notification_setting_guest_w) { create(:notification_setting, source: project, user: guest_project_watcher, level: 2) }
    let_it_be(:notification_setting_group_w) { create(:notification_setting, source: group, user: group_watcher, level: 2) }
    let_it_be(:subscriptions) do
      [
        create(:subscription, project: project, user: subscriber, subscribable: issue, subscribed: true),
        create(:subscription, project: project, user: unsubscribed_user, subscribable: issue, subscribed: false),
        create(:subscription, project: project, user: non_member_subscriber, subscribable: issue, subscribed: true)
      ]
    end

    subject { described_class.new(note) }

    before do
      project.add_developer(participant)
      project.add_developer(project_watcher)
      project.add_guest(guest_project_watcher)
      project.add_developer(subscriber)
      group.add_developer(group_watcher)

      expect(issue).to receive(:participants).and_return([participant, non_member_participant])
    end

    context 'for public notes' do
      let_it_be(:note) { create(:note, noteable: issue, project: project) }

      it 'adds all participants, watchers and subscribers' do
        expect(subject.notification_recipients.map(&:user)).to contain_exactly(
          participant, non_member_participant, project_watcher, group_watcher, guest_project_watcher, subscriber, non_member_subscriber
        )
      end
    end

    context 'for confidential notes' do
      let_it_be(:note) { create(:note, :confidential, noteable: issue, project: project) }

      it 'adds all participants, watchers and subscribers that are project memebrs' do
        expect(subject.notification_recipients.map(&:user)).to contain_exactly(
          participant, project_watcher, group_watcher, subscriber
        )
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module NotificationRecipients
  module Builder
    class Default < Base
      MENTION_TYPE_ACTIONS = [:new_issue, :new_merge_request].freeze

      attr_reader :target
      attr_reader :current_user
      attr_reader :action
      attr_reader :previous_assignees
      attr_reader :skip_current_user

      def initialize(target, current_user, action:, custom_action: nil, previous_assignees: nil, skip_current_user: true)
        @target = target
        @current_user = current_user
        @action = action
        @custom_action = custom_action
        @previous_assignees = previous_assignees
        @skip_current_user = skip_current_user
      end

      def add_watchers
        add_project_watchers
      end

      def build!
        add_participants(current_user)
        add_watchers
        add_custom_notifications

        # Re-assign is considered as a mention of the new assignee
        case custom_action
        when :reassign_merge_request, :reassign_issue
          add_recipients(previous_assignees, :mention, nil)
          add_recipients(target.assignees, :mention, NotificationReason::ASSIGNED)
        when :change_reviewer_merge_request
          add_recipients(previous_assignees, :mention, nil)
          add_recipients(target.reviewers, :mention, NotificationReason::REVIEW_REQUESTED)
        end

        add_subscribed_users

        if self.class.mention_type_actions.include?(custom_action)
          # These will all be participants as well, but adding with the :mention
          # type ensures that users with the mention notification level will
          # receive them, too.
          add_mentions(current_user, target: target)

          # We use the `:participating` notification level in order to match existing legacy behavior as captured
          # in existing specs (notification_service_spec.rb ~ line 507)
          if target.is_a?(Issuable)
            add_recipients(target.assignees, :participating, NotificationReason::ASSIGNED)
          end

          add_labels_subscribers
        end
      end

      def acting_user
        current_user if skip_current_user
      end

      # Build event key to search on custom notification level
      # Check NotificationSetting.email_events
      def custom_action
        @custom_action ||= ""#{action}_#{target.class.model_name.name.underscore}"".to_sym
      end

      def self.mention_type_actions
        MENTION_TYPE_ACTIONS.dup
      end
    end
  end
end

NotificationRecipients::Builder::Default.prepend_mod_with('NotificationRecipients::Builder::Default')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe NotificationRecipients::Builder::Default, feature_category: :team_planning do
  describe '#build!' do
    let_it_be(:group)   { create(:group, :public) }
    let_it_be(:project) { create(:project, :public, group: group).tap { |p| p.add_developer(project_watcher) if project_watcher } }
    let_it_be(:target)  { create(:issue, project: project) }

    let_it_be(:current_user)    { create(:user) }
    let_it_be(:other_user)      { create(:user) }
    let_it_be(:participant)     { create(:user) }
    let_it_be(:group_watcher)   { create(:user) }
    let_it_be(:project_watcher) { create(:user) }

    let_it_be(:notification_setting_project_w) { create(:notification_setting, source: project, user: project_watcher, level: 2) }
    let_it_be(:notification_setting_group_w) { create(:notification_setting, source: group, user: group_watcher, level: 2) }

    subject { described_class.new(target, current_user, action: :new).tap { |s| s.build! } }

    context 'participants and project watchers' do
      before do
        expect(target).to receive(:participants).and_return([participant, current_user])
      end

      it 'adds all participants and watchers' do
        expect(subject.recipients.map(&:user)).to include(participant, project_watcher, group_watcher)
        expect(subject.recipients.map(&:user)).not_to include(other_user)
      end
    end

    context 'subscribers' do
      it 'adds all subscribers' do
        subscriber = create(:user)
        non_subscriber = create(:user)
        create(:subscription, project: project, user: subscriber, subscribable: target, subscribed: true)
        create(:subscription, project: project, user: non_subscriber, subscribable: target, subscribed: false)

        expect(subject.recipients.map(&:user)).to include(subscriber)
      end
    end

    context 'custom notifications' do
      shared_examples 'custom notification recipients' do
        let_it_be(:custom_notification_user) { create(:user) }
        let_it_be(:another_group)   { create(:group) }
        let_it_be(:another_project) { create(:project, namespace: another_group) }

        context 'with project custom notification setting' do
          before do
            create(:notification_setting, source: project, user: custom_notification_user, level: :custom)
          end

          it 'adds the user to the recipients' do
            expect(subject.recipients.map(&:user)).to include(custom_notification_user)
          end
        end

        context 'with the project custom notification setting in another project' do
          before do
            create(:notification_setting, source: another_project, user: custom_notification_user, level: :custom)
          end

          it 'does not add the user to the recipients' do
            expect(subject.recipients.map(&:user)).not_to include(custom_notification_user)
          end
        end

        context 'with group custom notification setting' do
          before do
            create(:notification_setting, source: group, user: custom_notification_user, level: :custom)
          end

          it 'adds the user to the recipients' do
            expect(subject.recipients.map(&:user)).to include(custom_notification_user)
          end
        end

        context 'with the group custom notification setting in another group' do
          before do
            create(:notification_setting, source: another_group, user: custom_notification_user, level: :custom)
          end

          it 'does not add the user to the recipients' do
            expect(subject.recipients.map(&:user)).not_to include(custom_notification_user)
          end
        end

        context 'with project global custom notification setting' do
          before do
            create(:notification_setting, source: project, user: custom_notification_user, level: :global)
          end

          context 'with global custom notification setting' do
            before do
              create(:notification_setting, source: nil, user: custom_notification_user, level: :custom)
            end

            it 'adds the user to the recipients' do
              expect(subject.recipients.map(&:user)).to include(custom_notification_user)
            end
          end

          context 'without global custom notification setting' do
            it 'does not add the user to the recipients' do
              expect(subject.recipients.map(&:user)).not_to include(custom_notification_user)
            end
          end
        end

        context 'with group global custom notification setting' do
          before do
            create(:notification_setting, source: group, user: custom_notification_user, level: :global)
          end

          context 'with global custom notification setting' do
            before do
              create(:notification_setting, source: nil, user: custom_notification_user, level: :custom)
            end

            it 'adds the user to the recipients' do
              expect(subject.recipients.map(&:user)).to include(custom_notification_user)
            end
          end

          context 'without global custom notification setting' do
            it 'does not add the user to the recipients' do
              expect(subject.recipients.map(&:user)).not_to include(custom_notification_user)
            end
          end
        end

        context 'with group custom notification setting in deeply nested parent group' do
          let(:grand_parent_group) { create(:group, :public) }
          let(:parent_group) { create(:group, :public, parent: grand_parent_group) }
          let(:group) { create(:group, :public, parent: parent_group) }
          let(:project) { create(:project, :public, group: group).tap { |p| p.add_developer(project_watcher) } }
          let(:target) { create(:issue, project: project) }

          before do
            create(:notification_setting, source: grand_parent_group, user: custom_notification_user, level: :custom)
          end

          it 'adds the user to the recipients' do
            expect(subject.recipients.map(&:user)).to include(custom_notification_user)
          end
        end

        context 'without a project or group' do
          let(:target) { create(:snippet) }

          before do
            create(:notification_setting, source: nil, user: custom_notification_user, level: :custom)
          end

          it 'does not add the user to the recipients' do
            expect(subject.recipients.map(&:user)).not_to include(custom_notification_user)
          end
        end
      end

      it_behaves_like 'custom notification recipients'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module JiraConnectInstallations
  class ProxyLifecycleEventService
    SUPPOERTED_EVENTS = %i[installed uninstalled].freeze

    def self.execute(installation, event, instance_url)
      new(installation, event, instance_url).execute
    end

    def initialize(installation, event, instance_url)
      # To ensure the event is sent to the right instance, this makes
      # a copy of the installation and assigns the instance_url
      #
      # The installation might be modified already with a new instance_url.
      # This can be the case for an uninstalled event.
      # The installation is updated first, and the uninstalled event has to be sent to
      # the old instance_url.
      @installation = installation.dup
      @installation.instance_url = instance_url

      @event = event.to_sym

      raise(ArgumentError, ""Unknown event '#{@event}'"") unless SUPPOERTED_EVENTS.include?(@event)
    end

    def execute
      result = send_hook

      return ServiceResponse.new(status: :success) if result.code == 200

      log_unsuccessful_response(result.code, result.body)

      ServiceResponse.error(message: { type: :response_error, code: result.code })
    rescue *Gitlab::HTTP::HTTP_ERRORS => error
      ServiceResponse.error(message: { type: :network_error, message: error.message })
    end

    private

    attr_reader :installation, :event

    def send_hook
      Gitlab::HTTP.post(hook_uri, body: body)
    end

    def hook_uri
      case event
      when :installed
        installation.audience_installed_event_url
      when :uninstalled
        installation.audience_uninstalled_event_url
      end
    end

    def body
      return base_body unless event == :installed

      base_body.merge(installed_body)
    end

    def base_body
      {
        clientKey: installation.client_key,
        jwt: jwt_token,
        eventType: event
      }
    end

    def installed_body
      {
        sharedSecret: installation.shared_secret,
        baseUrl: installation.base_url
      }
    end

    def jwt_token
      @jwt_token ||= JiraConnect::CreateAsymmetricJwtService.new(@installation, event: event).execute
    end

    def log_unsuccessful_response(status_code, body)
      Gitlab::IntegrationsLogger.info(
        integration: 'JiraConnect',
        message: 'Proxy lifecycle event received error response',
        jira_event_type: event,
        jira_status_code: status_code,
        jira_body: body
      )
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe JiraConnectInstallations::ProxyLifecycleEventService, feature_category: :integrations do
  describe '.execute' do
    let(:installation) { create(:jira_connect_installation) }

    it 'creates an instance and calls execute' do
      expect_next_instance_of(described_class, installation, 'installed', 'https://test.gitlab.com') do |update_service|
        expect(update_service).to receive(:execute)
      end

      described_class.execute(installation, 'installed', 'https://test.gitlab.com')
    end
  end

  describe '.new' do
    let_it_be(:installation) { create(:jira_connect_installation, instance_url: nil) }

    let(:event) { :installed }

    subject(:service) { described_class.new(installation, event, 'https://test.gitlab.com') }

    it 'creates an internal duplicate of the installation and sets the instance_url' do
      expect(service.instance_variable_get(:@installation).instance_url).to eq('https://test.gitlab.com')
    end

    context 'with unknown event' do
      let(:event) { 'test' }

      it 'raises an error' do
        expect { service }.to raise_error(ArgumentError, 'Unknown event \'test\'')
      end
    end
  end

  describe '#execute' do
    let_it_be(:installation) { create(:jira_connect_installation, instance_url: 'https://old_instance_url.example.com') }

    let(:service) { described_class.new(installation, evnet_type, 'https://gitlab.example.com') }
    let(:service_instance_installation) { service.instance_variable_get(:@installation) }

    before do
      allow_next_instance_of(JiraConnect::CreateAsymmetricJwtService) do |create_asymmetric_jwt_service|
        allow(create_asymmetric_jwt_service).to receive(:execute).and_return('123456')
      end

      stub_request(:post, hook_url)
    end

    subject(:execute_service) { service.execute }

    shared_examples 'sends the event hook' do
      it 'returns a ServiceResponse' do
        expect(execute_service).to be_kind_of(ServiceResponse)
        expect(execute_service[:status]).to eq(:success)
      end

      it 'sends an installed event to the instance' do
        execute_service

        expect(WebMock).to have_requested(:post, hook_url).with(body: expected_request_body)
      end

      it 'creates the JWT token with the event and installation' do
        expect_next_instance_of(
          JiraConnect::CreateAsymmetricJwtService,
          service_instance_installation,
          event: evnet_type
        ) do |create_asymmetric_jwt_service|
          expect(create_asymmetric_jwt_service).to receive(:execute).and_return('123456')
        end

        expect(execute_service[:status]).to eq(:success)
      end

      context 'and the instance responds with an error' do
        before do
          stub_request(:post, hook_url).to_return(
            status: 422,
            body: 'Error message',
            headers: {}
          )
        end

        it 'returns an error ServiceResponse', :aggregate_failures do
          expect(execute_service).to be_kind_of(ServiceResponse)
          expect(execute_service[:status]).to eq(:error)
          expect(execute_service[:message]).to eq( { type: :response_error, code: 422 } )
        end

        it 'logs the error response' do
          expect(Gitlab::IntegrationsLogger).to receive(:info).with(
            integration: 'JiraConnect',
            message: 'Proxy lifecycle event received error response',
            jira_event_type: evnet_type,
            jira_status_code: 422,
            jira_body: 'Error message'
          )

          execute_service
        end
      end

      context 'and the request raises an error' do
        before do
          allow(Gitlab::HTTP).to receive(:post).and_raise(Errno::ECONNREFUSED, 'error message')
        end

        it 'returns an error ServiceResponse', :aggregate_failures do
          expect(execute_service).to be_kind_of(ServiceResponse)
          expect(execute_service[:status]).to eq(:error)
          expect(execute_service[:message]).to eq(
            {
              type: :network_error,
              message: 'Connection refused - error message'
            }
          )
        end
      end
    end

    context 'when installed event' do
      let(:evnet_type) { :installed }
      let(:hook_url) { 'https://gitlab.example.com/-/jira_connect/events/installed' }
      let(:expected_request_body) do
        {
          clientKey: installation.client_key,
          sharedSecret: installation.shared_secret,
          baseUrl: installation.base_url,
          jwt: '123456',
          eventType: 'installed'
        }
      end

      it_behaves_like 'sends the event hook'
    end

    context 'when uninstalled event' do
      let(:evnet_type) { :uninstalled }
      let(:hook_url) { 'https://gitlab.example.com/-/jira_connect/events/uninstalled' }
      let(:expected_request_body) do
        {
          clientKey: installation.client_key,
          jwt: '123456',
          eventType: 'uninstalled'
        }
      end

      it_behaves_like 'sends the event hook'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module JiraConnectInstallations
  class DestroyService
    def self.execute(installation, jira_connect_base_path, jira_connect_uninstalled_event_path)
      new(installation, jira_connect_base_path, jira_connect_uninstalled_event_path).execute
    end

    def initialize(installation, jira_connect_base_path, jira_connect_uninstalled_event_path)
      @installation = installation
      @jira_connect_base_path = jira_connect_base_path
      @jira_connect_uninstalled_event_path = jira_connect_uninstalled_event_path
    end

    def execute
      if @installation.instance_url.present?
        JiraConnect::ForwardEventWorker.perform_async(@installation.id, @jira_connect_base_path, @jira_connect_uninstalled_event_path)
        return true
      end

      @installation.destroy
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe JiraConnectInstallations::DestroyService, feature_category: :integrations do
  describe '.execute' do
    it 'creates an instance and calls execute' do
      expect_next_instance_of(described_class, 'param1', 'param2', 'param3') do |destroy_service|
        expect(destroy_service).to receive(:execute)
      end

      described_class.execute('param1', 'param2', 'param3')
    end
  end

  describe '#execute' do
    let!(:installation) { create(:jira_connect_installation) }
    let(:jira_base_path) { '/-/jira_connect' }
    let(:jira_event_path) { '/-/jira_connect/events/uninstalled' }

    subject { described_class.new(installation, jira_base_path, jira_event_path).execute }

    it { is_expected.to be_truthy }

    it 'deletes the installation' do
      expect { subject }.to change(JiraConnectInstallation, :count).by(-1)
    end

    context 'and the installation has an instance_url set' do
      let!(:installation) { create(:jira_connect_installation, instance_url: 'http://example.com') }

      it { is_expected.to be_truthy }

      it 'schedules a ForwardEventWorker background job and keeps the installation' do
        expect(JiraConnect::ForwardEventWorker).to receive(:perform_async).with(installation.id, jira_base_path, jira_event_path)

        expect { subject }.not_to change(JiraConnectInstallation, :count)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module JiraConnectInstallations
  class UpdateService
    def self.execute(installation, update_params)
      new(installation, update_params).execute
    end

    def initialize(installation, update_params)
      @installation = installation
      @update_params = update_params
    end

    def execute
      return update_error unless @installation.update(@update_params)

      if @installation.instance_url?
        hook_result = ProxyLifecycleEventService.execute(@installation, :installed, @installation.instance_url)

        if instance_url_changed? && hook_result.error?
          @installation.update!(instance_url: @installation.instance_url_before_last_save)

          return instance_installation_creation_error(hook_result.message)
        end
      end

      send_uninstalled_hook if instance_url_changed? && @installation.instance_url.blank?

      ServiceResponse.new(status: :success)
    end

    private

    def instance_url_changed?
      @installation.instance_url_before_last_save != @installation.instance_url
    end

    def send_uninstalled_hook
      return if @installation.instance_url_before_last_save.blank?

      JiraConnect::SendUninstalledHookWorker.perform_async(
        @installation.id,
        @installation.instance_url_before_last_save
      )
    end

    def instance_installation_creation_error(error_message)
      message = if error_message[:type] == :response_error
                  ""Could not be installed on the instance. Error response code #{error_message[:code]}""
                else
                  'Could not be installed on the instance. Network error'
                end

      ServiceResponse.error(message: message)
    end

    def update_error
      ServiceResponse.error(message: @installation.errors)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe JiraConnectInstallations::UpdateService, feature_category: :integrations do
  describe '.execute' do
    it 'creates an instance and calls execute' do
      expect_next_instance_of(described_class, 'param1', 'param2') do |update_service|
        expect(update_service).to receive(:execute)
      end

      described_class.execute('param1', 'param2')
    end
  end

  describe '#execute' do
    let_it_be_with_reload(:installation) { create(:jira_connect_installation) }
    let(:update_params) { { client_key: 'new_client_key' } }

    subject(:execute_service) { described_class.new(installation, update_params).execute }

    it 'returns a ServiceResponse' do
      expect(execute_service).to be_kind_of(ServiceResponse)
      expect(execute_service[:status]).to eq(:success)
    end

    it 'updates the installation' do
      expect { execute_service }.to change { installation.client_key }.to('new_client_key')
    end

    it 'returns a successful result' do
      expect(execute_service.success?).to eq(true)
    end

    context 'and model validation fails' do
      let(:update_params) { { instance_url: 'invalid' } }

      it 'returns an error result' do
        expect(execute_service.error?).to eq(true)
        expect(execute_service.message).to eq(installation.errors)
      end
    end

    context 'and the installation has an instance_url' do
      let_it_be_with_reload(:installation) { create(:jira_connect_installation, instance_url: 'https://other_gitlab.example.com') }

      it 'sends an installed event to the instance', :aggregate_failures do
        expect_next_instance_of(
          JiraConnectInstallations::ProxyLifecycleEventService, installation, :installed, 'https://other_gitlab.example.com'
        ) do |proxy_lifecycle_events_service|
          expect(proxy_lifecycle_events_service).to receive(:execute).and_return(ServiceResponse.new(status: :success))
        end

        expect(JiraConnect::SendUninstalledHookWorker).not_to receive(:perform_async)

        expect { execute_service }.not_to change { installation.instance_url }
      end

      context 'and instance_url gets updated' do
        let(:update_params) { { instance_url: 'https://gitlab.example.com' } }

        before do
          stub_request(:post, 'https://other_gitlab.example.com/-/jira_connect/events/uninstalled')
        end

        it 'sends an installed event to the instance and updates instance_url' do
          expect(JiraConnectInstallations::ProxyLifecycleEventService)
            .to receive(:execute).with(installation, :installed, 'https://gitlab.example.com')
            .and_return(ServiceResponse.new(status: :success))

          expect(JiraConnect::SendUninstalledHookWorker).not_to receive(:perform_async)

          execute_service

          expect(installation.instance_url).to eq(update_params[:instance_url])
        end

        context 'and the new instance_url is nil' do
          let(:update_params) { { instance_url: nil } }

          it 'starts an async worker to send an uninstalled event to the previous instance' do
            expect(JiraConnect::SendUninstalledHookWorker).to receive(:perform_async).with(installation.id, 'https://other_gitlab.example.com')

            execute_service

            expect(installation.instance_url).to eq(nil)
          end

          it 'does not send an installed event' do
            expect(JiraConnectInstallations::ProxyLifecycleEventService).not_to receive(:new)

            execute_service
          end
        end
      end
    end

    context 'and instance_url is updated' do
      let(:update_params) { { instance_url: 'https://gitlab.example.com' } }

      it 'sends an installed event to the instance and updates instance_url' do
        expect_next_instance_of(
          JiraConnectInstallations::ProxyLifecycleEventService, installation, :installed, 'https://gitlab.example.com'
        ) do |proxy_lifecycle_events_service|
          expect(proxy_lifecycle_events_service).to receive(:execute).and_return(ServiceResponse.new(status: :success))
        end

        expect(JiraConnect::SendUninstalledHookWorker).not_to receive(:perform_async)

        execute_service

        expect(installation.instance_url).to eq(update_params[:instance_url])
      end

      context 'and the instance installation cannot be created' do
        before do
          allow_next_instance_of(
            JiraConnectInstallations::ProxyLifecycleEventService,
            installation,
            :installed,
            'https://gitlab.example.com'
          ) do |proxy_lifecycle_events_service|
            allow(proxy_lifecycle_events_service).to receive(:execute).and_return(
              ServiceResponse.error(
                message: {
                  type: :response_error,
                  code: '422'
                }
              )
            )
          end
        end

        it 'does not change instance_url' do
          expect { execute_service }.not_to change { installation.instance_url }
        end

        it 'returns an error message' do
          expect(execute_service[:status]).to eq(:error)
          expect(execute_service[:message]).to eq(""Could not be installed on the instance. Error response code 422"")
        end

        context 'and the installation had a previous instance_url' do
          let(:installation) { build(:jira_connect_installation, instance_url: 'https://other_gitlab.example.com') }

          it 'does not send the uninstalled hook to the previous instance_url' do
            expect(JiraConnect::SendUninstalledHookWorker).not_to receive(:perform_async)

            execute_service
          end
        end

        context 'when failure because of a network error' do
          before do
            allow_next_instance_of(
              JiraConnectInstallations::ProxyLifecycleEventService,
              installation,
              :installed,
              'https://gitlab.example.com'
            ) do |proxy_lifecycle_events_service|
              allow(proxy_lifecycle_events_service).to receive(:execute).and_return(
                ServiceResponse.error(
                  message: {
                    type: :network_error,
                    message: 'Connection refused - error message'
                  }
                )
              )
            end
          end

          it 'returns an error message' do
            expect(execute_service[:status]).to eq(:error)
            expect(execute_service[:message]).to eq(""Could not be installed on the instance. Network error"")
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module JiraConnectSubscriptions
  class CreateService < ::JiraConnectSubscriptions::BaseService
    include Gitlab::Utils::StrongMemoize
    MERGE_REQUEST_SYNC_BATCH_SIZE = 20
    MERGE_REQUEST_SYNC_BATCH_DELAY = 1.minute.freeze

    def execute
      if !params[:jira_user]
        return error(s_('JiraConnect|Could not fetch user information from Jira. ' \
                        'Check the permissions in Jira and try again.'), 403)
      elsif !can_administer_jira?
        return error(s_('JiraConnect|The Jira user is not a site or organization administrator. ' \
                        'Check the permissions in Jira and try again.'), 403)
      end

      unless namespace && can?(current_user, :create_jira_connect_subscription, namespace)
        return error(s_('JiraConnect|Cannot find namespace. Make sure you have sufficient permissions.'), 401)
      end

      create_subscription
    end

    private

    def can_administer_jira?
      params[:jira_user]&.jira_admin?
    end

    def create_subscription
      subscription = JiraConnectSubscription.new(installation: jira_connect_installation, namespace: namespace)

      if subscription.save
        schedule_sync_project_jobs

        success
      else
        error(subscription.errors.full_messages.join(', '), 422)
      end
    end

    def namespace
      strong_memoize(:namespace) do
        Namespace.find_by_full_path(params[:namespace_path])
      end
    end

    def schedule_sync_project_jobs
      namespace.all_projects.each_batch(of: MERGE_REQUEST_SYNC_BATCH_SIZE) do |projects, index|
        JiraConnect::SyncProjectWorker.bulk_perform_in_with_contexts(
          index * MERGE_REQUEST_SYNC_BATCH_DELAY,
          projects,
          arguments_proc: -> (project) { [project.id, Atlassian::JiraConnect::Client.generate_update_sequence_id] },
          context_proc: -> (project) { { project: project } }
        )
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe JiraConnectSubscriptions::CreateService, feature_category: :integrations do
  let_it_be(:installation) { create(:jira_connect_installation) }
  let_it_be(:current_user) { create(:user) }
  let_it_be(:group) { create(:group) }

  let(:path) { group.full_path }
  let(:params) { { namespace_path: path, jira_user: jira_user } }
  let(:jira_user) { double(:JiraUser, jira_admin?: true) }

  subject { described_class.new(installation, current_user, params).execute }

  before do
    group.add_maintainer(current_user)
  end

  shared_examples 'a failed execution' do |**status_attributes|
    it 'does not create a subscription' do
      expect { subject }.not_to change { installation.subscriptions.count }
    end

    it 'returns an error status' do
      expect(subject[:status]).to eq(:error)
      expect(subject).to include(status_attributes)
    end
  end

  context 'remote user does not have access' do
    let(:jira_user) { double(jira_admin?: false) }

    it_behaves_like 'a failed execution',
      http_status: 403,
      message: 'The Jira user is not a site or organization administrator. Check the permissions in Jira and try again.'
  end

  context 'remote user cannot be retrieved' do
    let(:jira_user) { nil }

    it_behaves_like 'a failed execution',
      http_status: 403,
      message: 'Could not fetch user information from Jira. Check the permissions in Jira and try again.'
  end

  context 'when user does have access' do
    it 'creates a subscription' do
      expect { subject }.to change { installation.subscriptions.count }.from(0).to(1)
    end

    it 'returns success' do
      expect(subject[:status]).to eq(:success)
    end

    context 'namespace has projects' do
      let_it_be(:project_1) { create(:project, group: group) }
      let_it_be(:project_2) { create(:project, group: group) }

      before do
        stub_const(""#{described_class}::MERGE_REQUEST_SYNC_BATCH_SIZE"", 1)
      end

      it 'starts workers to sync projects in batches with delay' do
        allow(Atlassian::JiraConnect::Client).to receive(:generate_update_sequence_id).and_return(123)

        expect(JiraConnect::SyncProjectWorker).to receive(:bulk_perform_in).with(1.minute, [[project_1.id, 123]])
        expect(JiraConnect::SyncProjectWorker).to receive(:bulk_perform_in).with(2.minutes, [[project_2.id, 123]])

        subject
      end
    end
  end

  context 'when path is invalid' do
    let(:path) { 'some_invalid_namespace_path' }

    it_behaves_like 'a failed execution',
      http_status: 401,
      message: 'Cannot find namespace. Make sure you have sufficient permissions.'
  end

  context 'when user does not have access' do
    let_it_be(:other_group) { create(:group) }

    let(:path) { other_group.full_path }

    it_behaves_like 'a failed execution',
      http_status: 401,
      message: 'Cannot find namespace. Make sure you have sufficient permissions.'
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Discussions
  class ResolveService < Discussions::BaseService
    include Gitlab::Utils::StrongMemoize

    def initialize(project, user = nil, params = {})
      @discussions = Array.wrap(params.fetch(:one_or_more_discussions))
      @follow_up_issue = params[:follow_up_issue]
      @resolved_count = 0

      raise ArgumentError, 'Discussions must be all for the same noteable' \
        unless noteable_is_same?

      super
    end

    def execute
      discussions.each { |discussion| resolve_discussion(discussion) }

      after_resolve_cleanup
    end

    private

    attr_accessor :discussions, :follow_up_issue

    def noteable_is_same?
      return true unless discussions.size > 1

      # Perform this check without fetching extra records
      discussions.all? do |discussion|
        discussion.noteable_type == first_discussion.noteable_type &&
          discussion.noteable_id == first_discussion.noteable_id
      end
    end

    def resolve_discussion(discussion)
      return unless discussion.can_resolve?(current_user)

      discussion.resolve!(current_user)
      @resolved_count += 1

      if merge_request
        Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter
          .track_resolve_thread_action(user: current_user)

        MergeRequests::ResolvedDiscussionNotificationService.new(project: project, current_user: current_user).execute(merge_request)
      end

      resolve_user_todos_for(discussion)
      SystemNoteService.discussion_continued_in_issue(discussion, project, current_user, follow_up_issue) if follow_up_issue
    end

    def resolve_user_todos_for(discussion)
      return unless discussion.for_design?

      TodoService.new.resolve_todos_for_target(discussion, current_user)
    end

    def first_discussion
      @first_discussion ||= discussions.first
    end

    def merge_request
      strong_memoize(:merge_request) do
        first_discussion.noteable if first_discussion.for_merge_request?
      end
    end

    def after_resolve_cleanup
      return unless merge_request
      return unless @resolved_count > 0

      send_graphql_triggers
      process_auto_merge
    end

    def send_graphql_triggers
      GraphqlTriggers.merge_request_merge_status_updated(merge_request)
    end

    def process_auto_merge
      return unless discussions_ready_to_merge?

      AutoMergeProcessWorker.perform_async(merge_request.id)
    end

    def discussions_ready_to_merge?
      merge_request.auto_merge_enabled? && merge_request.mergeable_discussions_state?
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Discussions::ResolveService, feature_category: :code_review_workflow do
  describe '#execute' do
    let_it_be(:project) { create(:project, :repository) }
    let_it_be(:user) { create(:user, developer_projects: [project]) }
    let_it_be(:merge_request) { create(:merge_request, :merge_when_pipeline_succeeds, source_project: project) }

    let(:discussion) { create(:diff_note_on_merge_request, noteable: merge_request, project: project).to_discussion }
    let(:service) { described_class.new(project, user, one_or_more_discussions: discussion) }

    it ""doesn't resolve discussions the user can't resolve"" do
      expect(discussion).to receive(:can_resolve?).with(user).and_return(false)

      service.execute

      expect(discussion).not_to be_resolved
    end

    it 'resolves the discussion' do
      service.execute

      expect(discussion).to be_resolved
    end

    it 'tracks thread resolve usage data' do
      expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
        .to receive(:track_resolve_thread_action).with(user: user)

      service.execute
    end

    it 'executes the notification service' do
      expect_next_instance_of(MergeRequests::ResolvedDiscussionNotificationService) do |instance|
        expect(instance).to receive(:execute).with(discussion.noteable)
      end

      service.execute
    end

    it 'schedules an auto-merge' do
      expect(AutoMergeProcessWorker).to receive(:perform_async).with(discussion.noteable.id)

      service.execute
    end

    it 'sends GraphQL triggers' do
      expect(GraphqlTriggers).to receive(:merge_request_merge_status_updated).with(discussion.noteable)

      service.execute
    end

    context 'with a project that requires all discussion to be resolved' do
      before do
        project.update!(only_allow_merge_if_all_discussions_are_resolved: true)
      end

      after do
        project.update!(only_allow_merge_if_all_discussions_are_resolved: false)
      end

      let_it_be(:other_discussion) { create(:diff_note_on_merge_request, noteable: merge_request, project: project).to_discussion }

      it 'does not schedule an auto-merge' do
        expect(AutoMergeProcessWorker).not_to receive(:perform_async)

        service.execute
      end

      it 'schedules an auto-merge' do
        expect(AutoMergeProcessWorker).to receive(:perform_async)

        described_class.new(project, user, one_or_more_discussions: [discussion, other_discussion]).execute
      end
    end

    it 'adds a system note to the discussion' do
      issue = create(:issue, project: project)

      expect(SystemNoteService).to receive(:discussion_continued_in_issue).with(discussion, project, user, issue)
      service = described_class.new(project, user, one_or_more_discussions: discussion, follow_up_issue: issue)
      service.execute
    end

    it 'can resolve multiple discussions at once' do
      other_discussion = create(:diff_note_on_merge_request, noteable: merge_request, project: project).to_discussion
      service = described_class.new(project, user, one_or_more_discussions: [discussion, other_discussion])
      service.execute

      expect([discussion, other_discussion]).to all(be_resolved)
    end

    it 'raises an argument error if discussions do not belong to the same noteable' do
      other_merge_request = create(:merge_request)
      other_discussion = create(
        :diff_note_on_merge_request,
        noteable: other_merge_request,
        project: other_merge_request.source_project
      ).to_discussion
      expect do
        described_class.new(project, user, one_or_more_discussions: [discussion, other_discussion])
      end.to raise_error(
        ArgumentError,
        'Discussions must be all for the same noteable'
      )
    end

    context 'when discussion is not for a merge request' do
      let_it_be(:design) { create(:design, :with_file, issue: create(:issue, project: project)) }

      let(:discussion) { create(:diff_note_on_design, noteable: design, project: project).to_discussion }

      it 'does not execute the notification service' do
        expect(MergeRequests::ResolvedDiscussionNotificationService).not_to receive(:new)

        service.execute
      end

      it 'does not track thread resolve usage data' do
        expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
          .not_to receive(:track_resolve_thread_action).with(user: user)

        service.execute
      end

      it 'does not schedule an auto-merge' do
        expect(AutoMergeProcessWorker).not_to receive(:perform_async)

        service.execute
      end

      it 'does not send GraphQL triggers' do
        expect(GraphqlTriggers).not_to receive(:merge_request_merge_status_updated).with(discussion.noteable)

        service.execute
      end
    end

    context 'when resolving a discussion' do
      def resolve_discussion(discussion, user)
        described_class.new(project, user, one_or_more_discussions: discussion).execute
      end

      context 'in a design' do
        let_it_be(:design) { create(:design, :with_file, issue: create(:issue, project: project)) }
        let_it_be(:user_1) { create(:user) }
        let_it_be(:user_2) { create(:user) }
        let_it_be(:discussion_1) { create(:diff_note_on_design, noteable: design, project: project, author: user_1).to_discussion }
        let_it_be(:discussion_2) { create(:diff_note_on_design, noteable: design, project: project, author: user_2).to_discussion }

        before do
          project.add_developer(user_1)
          project.add_developer(user_2)
        end

        context 'when user resolving discussion has open todos' do
          let!(:user_1_todo_for_discussion_1) { create(:todo, :pending, user: user_1, target: design, note: discussion_1.notes.first, project: project) }
          let!(:user_1_todo_2_for_discussion_1) { create(:todo, :pending, user: user_1, target: design, note: discussion_1.notes.first, project: project) }
          let!(:user_1_todo_for_discussion_2) { create(:todo, :pending, user: user_1, target: design, note: discussion_2.notes.first, project: project) }
          let!(:user_2_todo_for_discussion_1) { create(:todo, :pending, user: user_2, target: design, note: discussion_1.notes.first, project: project) }

          it 'marks user todos for given discussion as done' do
            resolve_discussion(discussion_1, user_1)

            expect(user_1_todo_for_discussion_1.reload).to be_done
            expect(user_1_todo_2_for_discussion_1.reload).to be_done
            expect(user_1_todo_for_discussion_2.reload).to be_pending
            expect(user_2_todo_for_discussion_1.reload).to be_pending
          end
        end
      end

      context 'in a merge request' do
        let!(:user_todo_for_discussion) { create(:todo, :pending, user: user, target: merge_request, note: discussion.notes.first, project: project) }

        it 'does not mark user todo as done' do
          resolve_discussion(discussion, user)

          expect(user_todo_for_discussion).to be_pending
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Discussions
  class UnresolveService < Discussions::BaseService
    include Gitlab::Utils::StrongMemoize

    def initialize(discussion, user)
      @discussion = discussion
      @user = user

      super
    end

    def execute
      @all_discussions_resolved_before = merge_request ? @discussion.noteable.discussions_resolved? : false

      @discussion.unresolve!

      send_graphql_triggers

      Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter
        .track_unresolve_thread_action(user: @user)
    end

    private

    def merge_request
      @discussion.noteable if @discussion.for_merge_request?
    end
    strong_memoize_attr :merge_request

    def send_graphql_triggers
      return unless merge_request && @all_discussions_resolved_before

      GraphqlTriggers.merge_request_merge_status_updated(merge_request)
    end
  end
end

```","# frozen_string_literal: true

require ""spec_helper""

RSpec.describe Discussions::UnresolveService, feature_category: :code_review_workflow do
  describe ""#execute"" do
    let_it_be(:project) { create(:project, :repository) }
    let_it_be(:user) { create(:user, developer_projects: [project]) }
    let_it_be(:merge_request) { create(:merge_request, :merge_when_pipeline_succeeds, source_project: project) }

    let(:discussion) { create(:diff_note_on_merge_request, noteable: merge_request, project: project).to_discussion }

    let(:service) { described_class.new(discussion, user) }

    before do
      project.add_developer(user)
      discussion.resolve!(user)
    end

    it ""unresolves the discussion"" do
      service.execute

      expect(discussion).not_to be_resolved
    end

    it ""counts the unresolve event"" do
      expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
        .to receive(:track_unresolve_thread_action).with(user: user)

      service.execute
    end

    it ""sends GraphQL triggers"" do
      expect(GraphqlTriggers).to receive(:merge_request_merge_status_updated).with(discussion.noteable)

      service.execute
    end

    context ""when there are existing unresolved discussions"" do
      before do
        create(:diff_note_on_merge_request, noteable: merge_request, project: project).to_discussion
      end

      it ""does not send a GraphQL triggers"" do
        expect(GraphqlTriggers).not_to receive(:merge_request_merge_status_updated)

        service.execute
      end
    end

    context ""when the noteable is not a merge request"" do
      it ""does not send a GraphQL triggers"" do
        expect(discussion).to receive(:for_merge_request?).and_return(false)
        expect(GraphqlTriggers).not_to receive(:merge_request_merge_status_updated)

        service.execute
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Discussions
  class UpdateDiffPositionService < BaseService
    def execute(discussion)
      old_position = discussion.position
      result = tracer.trace(old_position)
      return unless result

      position = result[:position]
      outdated = result[:outdated]

      discussion.notes.each do |note|
        if outdated
          note.change_position = position

          if project.resolve_outdated_diff_discussions?
            note.resolve_without_save(current_user, resolved_by_push: true)
          end
        else
          note.position = position
          note.change_position = nil
        end
      end

      Note.transaction do
        discussion.notes.each do |note|
          note.save(touch: false)
        end

        if outdated && current_user
          SystemNoteService.diff_discussion_outdated(discussion, project, current_user, position)
        end
      end
    end

    private

    def tracer
      @tracer ||= Gitlab::Diff::PositionTracer.new(
        project: project,
        old_diff_refs: params[:old_diff_refs],
        new_diff_refs: params[:new_diff_refs],
        paths: params[:paths]
      )
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Discussions::UpdateDiffPositionService, feature_category: :code_review_workflow do
  let(:project) { create(:project, :repository) }
  let(:current_user) { project.first_owner }
  let(:create_commit) { project.commit(""913c66a37b4a45b9769037c55c2d238bd0942d2e"") }
  let(:modify_commit) { project.commit(""874797c3a73b60d2187ed6e2fcabd289ff75171e"") }
  let(:edit_commit) { project.commit(""570e7b2abdd848b95f2f578043fc23bd6f6fd24d"") }

  let(:path) { ""files/ruby/popen.rb"" }

  let(:old_diff_refs) do
    Gitlab::Diff::DiffRefs.new(
      base_sha: create_commit.parent_id,
      head_sha: modify_commit.sha
    )
  end

  let(:new_diff_refs) do
    Gitlab::Diff::DiffRefs.new(
      base_sha: create_commit.parent_id,
      head_sha: edit_commit.sha
    )
  end

  subject do
    described_class.new(
      project,
      current_user,
      old_diff_refs: old_diff_refs,
      new_diff_refs: new_diff_refs,
      paths: [path]
    )
  end

  # old diff:
  #     1 + require 'fileutils'
  #     2 + require 'open3'
  #     3 +
  #     4 + module Popen
  #     5 +   extend self
  #     6 +
  #     7 +   def popen(cmd, path=nil)
  #     8 +     unless cmd.is_a?(Array)
  #     9 +       raise ""System commands must be given as an array of strings""
  #    10 +     end
  #    11 +
  #    12 +     path ||= Dir.pwd
  #    13 +     vars = { ""PWD"" => path }
  #    14 +     options = { chdir: path }
  #    15 +
  #    16 +     unless File.directory?(path)
  #    17 +       FileUtils.mkdir_p(path)
  #    18 +     end
  #    19 +
  #    20 +     @cmd_output = """"
  #    21 +     @cmd_status = 0
  #    22 +     Open3.popen3(vars, *cmd, options) do |stdin, stdout, stderr, wait_thr|
  #    23 +       @cmd_output << stdout.read
  #    24 +       @cmd_output << stderr.read
  #    25 +       @cmd_status = wait_thr.value.exitstatus
  #    26 +     end
  #    27 +
  #    28 +     return @cmd_output, @cmd_status
  #    29 +   end
  #    30 + end
  #
  # new diff:
  #     1 + require 'fileutils'
  #     2 + require 'open3'
  #     3 +
  #     4 + module Popen
  #     5 +   extend self
  #     6 +
  #     7 +   def popen(cmd, path=nil)
  #     8 +     unless cmd.is_a?(Array)
  #     9 +       raise RuntimeError, ""System commands must be given as an array of strings""
  #    10 +     end
  #    11 +
  #    12 +     path ||= Dir.pwd
  #    13 +
  #    14 +     vars = {
  #    15 +       ""PWD"" => path
  #    16 +     }
  #    17 +
  #    18 +     options = {
  #    19 +       chdir: path
  #    20 +     }
  #    21 +
  #    22 +     unless File.directory?(path)
  #    23 +       FileUtils.mkdir_p(path)
  #    24 +     end
  #    25 +
  #    26 +     @cmd_output = """"
  #    27 +     @cmd_status = 0
  #    28 +
  #    29 +     Open3.popen3(vars, *cmd, options) do |stdin, stdout, stderr, wait_thr|
  #    30 +       @cmd_output << stdout.read
  #    31 +       @cmd_output << stderr.read
  #    32 +       @cmd_status = wait_thr.value.exitstatus
  #    33 +     end
  #    34 +
  #    35 +     return @cmd_output, @cmd_status
  #    36 +   end
  #    37 + end
  #
  # old->new diff:
  # .. .. @@ -6,12 +6,18 @@ module Popen
  #  6  6
  #  7  7    def popen(cmd, path=nil)
  #  8  8      unless cmd.is_a?(Array)
  #  9    -      raise ""System commands must be given as an array of strings""
  #     9 +      raise RuntimeError, ""System commands must be given as an array of strings""
  # 10 10      end
  # 11 11
  # 12 12      path ||= Dir.pwd
  # 13    -    vars = { ""PWD"" => path }
  # 14    -    options = { chdir: path }
  #    13 +
  #    14 +    vars = {
  #    15 +      ""PWD"" => path
  #    16 +    }
  #    17 +
  #    18 +    options = {
  #    19 +      chdir: path
  #    20 +    }
  # 15 21
  # 16 22      unless File.directory?(path)
  # 17 23        FileUtils.mkdir_p(path)
  # 18 24      end
  # 19 25
  # 20 26      @cmd_output = """"
  # 21 27      @cmd_status = 0
  #    28 +
  # 22 29      Open3.popen3(vars, *cmd, options) do |stdin, stdout, stderr, wait_thr|
  # 23 30        @cmd_output << stdout.read
  # 24 31        @cmd_output << stderr.read
  # .. ..

  describe ""#execute"" do
    let(:discussion) { create(:diff_note_on_merge_request, project: project, position: old_position).to_discussion }

    let(:old_position) do
      Gitlab::Diff::Position.new(
        old_path: path,
        new_path: path,
        old_line: nil,
        new_line: line,
        diff_refs: old_diff_refs
      )
    end

    shared_examples 'outdated diff note' do
      it ""doesn't update the position"" do
        subject.execute(discussion)

        expect(discussion.original_position).to eq(old_position)
        expect(discussion.position).to eq(old_position)
      end

      it 'sets the change position' do
        subject.execute(discussion)

        change_position = discussion.change_position
        expect(change_position.start_sha).to eq(old_diff_refs.head_sha)
        expect(change_position.head_sha).to eq(new_diff_refs.head_sha)
        expect(change_position.formatter.old_line).to eq(9)
        expect(change_position.formatter.new_line).to be_nil
      end

      it 'creates a system discussion' do
        expect(SystemNoteService).to receive(:diff_discussion_outdated).with(
          discussion, project, current_user, instance_of(Gitlab::Diff::Position))

        subject.execute(discussion)
      end
    end

    context ""when the diff line is the same"" do
      let(:line) { 16 }

      it ""updates the position"" do
        subject.execute(discussion)

        expect(discussion.original_position).to eq(old_position)
        expect(discussion.position).not_to eq(old_position)
        expect(discussion.position.formatter.new_line).to eq(22)
      end

      context 'when the resolve_outdated_diff_discussions setting is set' do
        before do
          project.update!(resolve_outdated_diff_discussions: true)
        end

        it 'does not resolve the discussion' do
          subject.execute(discussion)

          expect(discussion).not_to be_resolved
          expect(discussion).not_to be_resolved_by_push
        end
      end
    end

    context ""when the diff line has changed"" do
      let(:line) { 9 }

      include_examples 'outdated diff note'

      context 'when the resolve_outdated_diff_discussions setting is set' do
        before do
          project.update!(resolve_outdated_diff_discussions: true)
        end

        it 'sets resolves the discussion and sets resolved_by_push' do
          subject.execute(discussion)

          expect(discussion).to be_resolved
          expect(discussion).to be_resolved_by_push
        end

        include_examples 'outdated diff note'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Discussions
  class CaptureDiffNotePositionsService
    def initialize(merge_request)
      @merge_request = merge_request
    end

    def execute
      return unless merge_request.has_complete_diff_refs?

      discussions, paths = build_discussions

      service = Discussions::CaptureDiffNotePositionService.new(merge_request, paths)

      discussions.each do |discussion|
        service.execute(discussion)
      end
    end

    private

    attr_reader :merge_request

    def build_discussions
      active_diff_discussions = merge_request.notes.new_diff_notes.discussions.select do |discussion|
        discussion.active?(merge_request.diff_refs)
      end
      paths = active_diff_discussions.flat_map { |n| n.diff_file&.paths }

      [active_diff_discussions, paths]
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Discussions::CaptureDiffNotePositionsService, feature_category: :code_review_workflow do
  context 'when merge request has a discussion' do
    let(:source_branch) { 'compare-with-merge-head-source' }
    let(:target_branch) { 'compare-with-merge-head-target' }
    let(:merge_request) { create(:merge_request, source_branch: source_branch, target_branch: target_branch) }
    let(:project) { merge_request.project }

    let(:offset) { 30 }
    let(:first_new_line) { 508 }
    let(:second_new_line) { 521 }
    let(:third_removed_line) { 1240 }

    let(:service) { described_class.new(merge_request) }

    def build_position(diff_refs, new_line: nil, old_line: nil)
      path = 'files/markdown/ruby-style-guide.md'
      Gitlab::Diff::Position.new(
        old_path: path, new_path: path, new_line: new_line, old_line: old_line, diff_refs: diff_refs)
    end

    def note_for(new_line: nil, old_line: nil)
      position = build_position(merge_request.diff_refs, new_line: new_line, old_line: old_line)
      create(:diff_note_on_merge_request, project: project, position: position, noteable: merge_request)
    end

    def verify_diff_note_position!(note, new_line: nil, old_line: nil)
      id, removed_line, added_line = note.line_code.split('_')

      expect(note.diff_note_positions.size).to eq(1)

      diff_position = note.diff_note_positions.last
      diff_refs = Gitlab::Diff::DiffRefs.new(
        base_sha: merge_request.target_branch_sha,
        start_sha: merge_request.target_branch_sha,
        head_sha: merge_request.merge_ref_head.sha)

      expect(diff_position.line_code).to eq(""#{id}_#{removed_line.to_i - offset}_#{added_line}"")
      expect(diff_position.position).to eq(build_position(diff_refs, new_line: new_line, old_line: old_line))
    end

    let!(:first_discussion_note) { note_for(new_line: first_new_line) }
    let!(:second_discussion_note) { note_for(new_line: second_new_line) }
    let!(:third_discussion_note) { note_for(old_line: third_removed_line) }
    let!(:second_discussion_another_note) do
      create(:diff_note_on_merge_request,
        project: project,
        position: second_discussion_note.position,
        discussion_id: second_discussion_note.discussion_id,
        noteable: merge_request)
    end

    context 'and position of the discussion changed on target branch head' do
      it 'diff positions are created for the first notes of the discussions' do
        MergeRequests::MergeToRefService.new(project: project, current_user: merge_request.author).execute(merge_request)
        service.execute

        verify_diff_note_position!(first_discussion_note, new_line: first_new_line)
        verify_diff_note_position!(second_discussion_note, new_line: second_new_line)
        verify_diff_note_position!(third_discussion_note, old_line: third_removed_line - offset)

        expect(second_discussion_another_note.diff_note_positions).to be_empty
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Discussions
  class CaptureDiffNotePositionService
    def initialize(merge_request, paths)
      @project = merge_request.project
      @tracer = build_tracer(merge_request, paths)
    end

    def execute(discussion)
      # The service has been implemented for text only
      # We don't need to capture positions for images
      return unless discussion.on_text?

      result = tracer&.trace(discussion.position)
      return unless result

      position = result[:position]
      return unless position

      line_code = position.line_code(project.repository)
      return unless line_code

      # Currently position data is copied across all notes of a discussion
      # It makes sense to store a position only for the first note instead
      # Within the newly introduced table we can start doing just that
      DiffNotePosition.create_or_update_for(discussion.notes.first,
        diff_type: :head,
        position: position,
        line_code: line_code)
    end

    private

    attr_reader :tracer, :project

    def build_tracer(merge_request, paths)
      return if paths.blank?

      old_diff_refs, new_diff_refs = build_diff_refs(merge_request)

      return unless old_diff_refs && new_diff_refs

      Gitlab::Diff::PositionTracer.new(
        project: project,
        old_diff_refs: old_diff_refs,
        new_diff_refs: new_diff_refs,
        paths: paths.uniq)
    end

    def build_diff_refs(merge_request)
      merge_ref_head = merge_request.merge_ref_head
      return unless merge_ref_head

      start_sha, _ = merge_ref_head.parent_ids
      new_diff_refs = Gitlab::Diff::DiffRefs.new(
        base_sha: start_sha,
        start_sha: start_sha,
        head_sha: merge_ref_head.id)

      old_diff_refs = merge_request.diff_refs

      return if new_diff_refs == old_diff_refs

      [old_diff_refs, new_diff_refs]
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Discussions::CaptureDiffNotePositionService, feature_category: :code_review_workflow do
  subject { described_class.new(note.noteable, paths) }

  context 'image note on diff' do
    let!(:note) { create(:image_diff_note_on_merge_request) }
    let(:paths) { ['files/images/any_image.png'] }

    it 'is note affected by the service' do
      expect(Gitlab::Diff::PositionTracer).not_to receive(:new)

      expect(subject.execute(note.discussion)).to eq(nil)
      expect(note.diff_note_positions).to be_empty
    end
  end

  context 'when empty paths are passed as a param' do
    let!(:note) { create(:diff_note_on_merge_request) }
    let(:paths) { [] }

    it 'does not calculate positons' do
      expect(Gitlab::Diff::PositionTracer).not_to receive(:new)

      expect(subject.execute(note.discussion)).to eq(nil)
      expect(note.diff_note_positions).to be_empty
    end
  end

  context 'when position tracer returned position' do
    let!(:note) { create(:diff_note_on_merge_request) }
    let(:paths) { ['files/any_file.txt'] }

    before do
      expect(note.noteable).to receive(:merge_ref_head).and_return(double.as_null_object)
      expect_next_instance_of(Gitlab::Diff::PositionTracer) do |tracer|
        expect(tracer).to receive(:trace).and_return({ position: position })
      end
    end

    context 'which is nil' do
      let(:position) { nil }

      it 'does not create diff note position' do
        expect(subject.execute(note.discussion)).to eq(nil)
        expect(note.diff_note_positions).to be_empty
      end
    end

    context 'which does not have a corresponding line' do
      let(:position) { double(line_code: nil) }

      it 'does not create diff note position' do
        expect(subject.execute(note.discussion)).to eq(nil)
        expect(note.diff_note_positions).to be_empty
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Achievements
  class AwardService
    attr_reader :current_user, :achievement_id, :recipient_id

    def initialize(current_user, achievement_id, recipient_id)
      @current_user = current_user
      @achievement_id = achievement_id
      @recipient_id = recipient_id
    end

    def execute
      achievement = Achievements::Achievement.find(achievement_id)
      return error_no_permissions unless allowed?(achievement)

      recipient = User.find(recipient_id)

      user_achievement = Achievements::UserAchievement.create(
        achievement: achievement,
        user: recipient,
        awarded_by_user: current_user)
      return error_awarding(user_achievement) unless user_achievement.persisted?

      NotificationService.new.new_achievement_email(recipient, achievement).deliver_later
      ServiceResponse.success(payload: user_achievement)
    rescue ActiveRecord::RecordNotFound => e
      error(e.message)
    end

    private

    def allowed?(achievement)
      current_user&.can?(:award_achievement, achievement)
    end

    def error_no_permissions
      error('You have insufficient permissions to award this achievement')
    end

    def error_awarding(user_achievement)
      error(user_achievement&.errors&.full_messages || 'Failed to award achievement')
    end

    def error(message)
      ServiceResponse.error(message: Array(message))
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Achievements::AwardService, feature_category: :user_profile do
  describe '#execute' do
    let_it_be(:developer) { create(:user) }
    let_it_be(:maintainer) { create(:user) }
    let_it_be(:group) { create(:group) }
    let_it_be(:achievement) { create(:achievement, namespace: group) }
    let_it_be(:recipient) { create(:user) }

    let(:achievement_id) { achievement.id }
    let(:recipient_id) { recipient.id }

    subject(:response) { described_class.new(current_user, achievement_id, recipient_id).execute }

    before_all do
      group.add_developer(developer)
      group.add_maintainer(maintainer)
    end

    context 'when user does not have permission' do
      let(:current_user) { developer }

      it 'returns an error' do
        expect(response).to be_error
        expect(response.message).to match_array(
          ['You have insufficient permissions to award this achievement'])
      end
    end

    context 'when user has permission' do
      let(:current_user) { maintainer }
      let(:notification_service) { instance_double(NotificationService) }
      let(:mail_message) { instance_double(ActionMailer::MessageDelivery) }

      it 'creates an achievement and sends an e-mail' do
        allow(NotificationService).to receive(:new).and_return(notification_service)
        expect(notification_service).to receive(:new_achievement_email).with(recipient, achievement)
          .and_return(mail_message)
        expect(mail_message).to receive(:deliver_later)

        expect(response).to be_success
      end

      context 'when the achievement is not persisted' do
        let(:user_achievement) { instance_double('Achievements::UserAchievement') }

        it 'returns the correct error' do
          allow(user_achievement).to receive(:persisted?).and_return(false)
          allow(user_achievement).to receive(:errors).and_return(nil)
          allow(Achievements::UserAchievement).to receive(:create).and_return(user_achievement)

          expect(response).to be_error
          expect(response.message).to match_array([""Failed to award achievement""])
        end
      end

      context 'when the achievement does not exist' do
        let(:achievement_id) { non_existing_record_id }

        it 'returns the correct error' do
          expect(response).to be_error
          expect(response.message)
            .to contain_exactly(""Couldn't find Achievements::Achievement with 'id'=#{non_existing_record_id}"")
        end
      end

      context 'when the recipient does not exist' do
        let(:recipient_id) { non_existing_record_id }

        it 'returns the correct error' do
          expect(response).to be_error
          expect(response.message).to contain_exactly(""Couldn't find User with 'id'=#{non_existing_record_id}"")
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Achievements
  class UpdateUserAchievementPrioritiesService
    attr_reader :current_user, :user_achievements

    def initialize(current_user, user_achievements)
      @current_user = current_user
      @user_achievements = user_achievements
    end

    def execute
      return error_no_permissions unless allowed?

      prioritized_user_achievements_map = Hash[user_achievements.map.with_index { |ua, idx| [ua.id, idx] }]

      user_achievements_priorities_mapping = current_user.user_achievements.each_with_object({}) do |ua, result|
        next if ua.priority.nil? && !prioritized_user_achievements_map.key?(ua.id)

        result[ua] = { priority: prioritized_user_achievements_map.fetch(ua.id, nil) }
      end

      return ServiceResponse.success(payload: []) if user_achievements_priorities_mapping.empty?

      ::Gitlab::Database::BulkUpdate.execute(%i[priority], user_achievements_priorities_mapping)

      ServiceResponse.success(payload: user_achievements_priorities_mapping.keys.map(&:reload))
    end

    private

    def allowed?
      user_achievements.all? { |user_achievement| current_user&.can?(:update_owned_user_achievement, user_achievement) }
    end

    def error(message)
      ServiceResponse.error(payload: user_achievements, message: Array(message))
    end

    def error_no_permissions
      error(""You can't update at least one of the given user achievements."")
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Achievements::UpdateUserAchievementPrioritiesService, feature_category: :user_profile do
  describe '#execute' do
    let_it_be(:achievement_owner) { create(:user) }
    let_it_be(:group) { create(:group) }

    let_it_be(:achievement) { create(:achievement, namespace: group) }

    let!(:user_achievement1) do
      create(:user_achievement, achievement: achievement, user: achievement_owner, priority: 0)
    end

    let_it_be(:user_achievement2) { create(:user_achievement, achievement: achievement, user: achievement_owner) }
    let_it_be(:user_achievement3) { create(:user_achievement, achievement: achievement, user: achievement_owner) }

    subject(:response) { described_class.new(current_user, user_achievements).execute }

    context 'when user does not have permission' do
      let(:current_user) { create(:user) }
      let(:user_achievements) { [user_achievement1] }

      it 'returns an error', :aggregate_failures do
        expect(response).to be_error
        expect(response.message).to match_array([""You can't update at least one of the given user achievements.""])
      end
    end

    context 'when user has permission' do
      let_it_be_with_reload(:current_user) { achievement_owner }

      context 'with empty input' do
        let(:user_achievements) { [] }

        it 'removes all priorities', :aggregate_failures do
          expect(response).to be_success

          [user_achievement1, user_achievement2, user_achievement3].each do |ua|
            expect(ua.reload.priority).to be_nil
          end
        end
      end

      context 'with prioritised achievements' do
        let(:user_achievements) { [user_achievement3, user_achievement1] }

        it 're-orders the achievements correctly', :aggregate_failures do
          expect(response).to be_success

          expect(user_achievement1.reload.priority).to eq(1)
          expect(user_achievement2.reload.priority).to be_nil
          expect(user_achievement3.reload.priority).to be_zero
        end
      end

      context 'when no achievement is prioritized and no prioritizations are made' do
        let!(:user_achievement1) { create(:user_achievement, achievement: achievement, user: achievement_owner) }

        let(:user_achievements) { [] }

        it 'works without errors', :aggregate_failures do
          expect(response).to be_success

          [user_achievement1, user_achievement2, user_achievement3].each do |ua|
            expect(ua.reload.priority).to be_nil
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Achievements
  class DestroyUserAchievementService
    attr_reader :current_user, :user_achievement

    def initialize(current_user, user_achievement)
      @current_user = current_user
      @user_achievement = user_achievement
    end

    def execute
      return error_no_permissions unless allowed?

      user_achievement.delete
      ServiceResponse.success(payload: user_achievement)
    end

    private

    def allowed?
      current_user&.can?(:destroy_user_achievement, user_achievement)
    end

    def error_no_permissions
      error('You have insufficient permissions to delete this user achievement')
    end

    def error(message)
      ServiceResponse.error(message: Array(message))
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Achievements::DestroyUserAchievementService, feature_category: :user_profile do
  describe '#execute' do
    let_it_be(:maintainer) { create(:user) }
    let_it_be(:owner) { create(:user) }
    let_it_be(:group) { create(:group) }

    let_it_be(:achievement) { create(:achievement, namespace: group) }
    let_it_be(:user_achievement) { create(:user_achievement, achievement: achievement) }

    subject(:response) { described_class.new(current_user, user_achievement).execute }

    before_all do
      group.add_maintainer(maintainer)
      group.add_owner(owner)
    end

    context 'when user does not have permission' do
      let(:current_user) { maintainer }

      it 'returns an error' do
        expect(response).to be_error
        expect(response.message).to match_array(
          ['You have insufficient permissions to delete this user achievement'])
      end
    end

    context 'when user has permission' do
      let(:current_user) { owner }

      it 'deletes the achievement' do
        expect(response).to be_success
        expect(Achievements::UserAchievement.find_by(id: user_achievement.id)).to be_nil
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Achievements
  class RevokeService
    attr_reader :current_user, :user_achievement

    def initialize(current_user, user_achievement)
      @current_user = current_user
      @user_achievement = user_achievement
    end

    def execute
      return error_no_permissions unless allowed?(user_achievement.achievement)
      return error_already_revoked if user_achievement.revoked?

      user_achievement.assign_attributes({
        revoked_by_user_id: current_user.id,
        revoked_at: Time.zone.now
      })
      return error_awarding unless user_achievement.save

      ServiceResponse.success(payload: user_achievement)
    end

    private

    def allowed?(achievement)
      current_user&.can?(:award_achievement, achievement)
    end

    def error_no_permissions
      error('You have insufficient permissions to revoke this achievement')
    end

    def error_already_revoked
      error('This achievement has already been revoked')
    end

    def error_awarding
      error(user_achievement&.errors&.full_messages || 'Failed to revoke achievement')
    end

    def error(message)
      ServiceResponse.error(message: Array(message))
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Achievements::RevokeService, feature_category: :user_profile do
  describe '#execute' do
    let_it_be(:developer) { create(:user) }
    let_it_be(:maintainer) { create(:user) }
    let_it_be(:group) { create(:group) }
    let_it_be(:achievement) { create(:achievement, namespace: group) }
    let_it_be(:user_achievement) { create(:user_achievement, achievement: achievement) }

    let(:user_achievement_param) { user_achievement }

    subject(:response) { described_class.new(current_user, user_achievement_param).execute }

    before_all do
      group.add_developer(developer)
      group.add_maintainer(maintainer)
    end

    context 'when user does not have permission' do
      let(:current_user) { developer }

      it 'returns an error' do
        expect(response).to be_error
        expect(response.message).to match_array(
          ['You have insufficient permissions to revoke this achievement'])
      end
    end

    context 'when user has permission' do
      let(:current_user) { maintainer }

      it 'revokes an achievement' do
        expect(response).to be_success
      end

      context 'when the achievement has already been revoked' do
        let_it_be(:revoked_achievement) { create(:user_achievement, :revoked, achievement: achievement) }
        let(:user_achievement_param) { revoked_achievement }

        it 'returns the correct error' do
          expect(response).to be_error
          expect(response.message)
            .to contain_exactly('This achievement has already been revoked')
        end
      end

      context 'when the user achievement fails to save' do
        let(:user_achievement_param) { instance_double('Achievements::UserAchievement') }

        it 'returns the correct error' do
          allow(user_achievement_param).to receive(:save).and_return(false)
          allow(user_achievement_param).to receive(:achievement).and_return(achievement)
          allow(user_achievement_param).to receive(:revoked?).and_return(false)
          allow(user_achievement_param).to receive(:errors).and_return(nil)
          expect(user_achievement_param).to receive(:assign_attributes)

          expect(response).to be_error
          expect(response.message).to match_array([""Failed to revoke achievement""])
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Achievements
  class DestroyService
    attr_reader :current_user, :achievement

    def initialize(current_user, achievement)
      @current_user = current_user
      @achievement = achievement
    end

    def execute
      return error_no_permissions unless allowed?

      achievement.delete
      ServiceResponse.success(payload: achievement)
    end

    private

    def allowed?
      current_user&.can?(:admin_achievement, achievement)
    end

    def error_no_permissions
      error('You have insufficient permissions to delete this achievement')
    end

    def error(message)
      ServiceResponse.error(message: Array(message))
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Achievements::DestroyService, feature_category: :user_profile do
  describe '#execute' do
    let_it_be(:developer) { create(:user) }
    let_it_be(:maintainer) { create(:user) }
    let_it_be(:group) { create(:group) }

    let(:achievement) { create(:achievement, namespace: group) }

    subject(:response) { described_class.new(current_user, achievement).execute }

    before_all do
      group.add_developer(developer)
      group.add_maintainer(maintainer)
    end

    context 'when user does not have permission' do
      let(:current_user) { developer }

      it 'returns an error' do
        expect(response).to be_error
        expect(response.message).to match_array(
          ['You have insufficient permissions to delete this achievement'])
      end
    end

    context 'when user has permission' do
      let(:current_user) { maintainer }

      it 'deletes the achievement' do
        expect(response).to be_success
        expect(Achievements::Achievement.find_by(id: achievement.id)).to be_nil
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Achievements
  class UpdateService
    attr_reader :current_user, :achievement, :params

    def initialize(current_user, achievement, params)
      @current_user = current_user
      @achievement = achievement
      @params = params
    end

    def execute
      return error_no_permissions unless allowed?

      if achievement.update(params)
        ServiceResponse.success(payload: achievement)
      else
        error_updating
      end
    end

    private

    def allowed?
      current_user&.can?(:admin_achievement, achievement)
    end

    def error_no_permissions
      error('You have insufficient permission to update this achievement')
    end

    def error(message)
      ServiceResponse.error(payload: achievement, message: Array(message))
    end

    def error_updating
      error(achievement&.errors&.full_messages || 'Failed to update achievement')
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Achievements::UpdateService, feature_category: :user_profile do
  describe '#execute' do
    let_it_be(:user) { create(:user) }

    let(:params) { attributes_for(:achievement, namespace: group) }

    subject(:response) { described_class.new(user, group, params).execute }

    context 'when user does not have permission' do
      let_it_be(:group) { create(:group) }
      let_it_be(:achievement) { create(:achievement, namespace: group) }

      before_all do
        group.add_developer(user)
      end

      it 'returns an error' do
        expect(response).to be_error
        expect(response.message).to match_array(
          ['You have insufficient permission to update this achievement'])
      end
    end

    context 'when user has permission' do
      let_it_be(:group) { create(:group) }
      let_it_be(:achievement) { create(:achievement, namespace: group) }

      before_all do
        group.add_maintainer(user)
      end

      it 'updates an achievement' do
        expect(response).to be_success
      end

      it 'returns an error when the achievement cannot be updated' do
        params[:name] = nil

        expect(response).to be_error
        expect(response.message).to include(""Name can't be blank"")
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Achievements
  class CreateService < BaseService
    def execute
      return error_no_permissions unless allowed?

      achievement = Achievements::Achievement.create(params.merge(namespace_id: @namespace.id))

      return error_creating(achievement) unless achievement.persisted?

      ServiceResponse.success(payload: achievement)
    end

    private

    def error_no_permissions
      error('You have insufficient permissions to create achievements for this namespace')
    end

    def error_creating(achievement)
      error(achievement&.errors&.full_messages || 'Failed to create achievement')
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Achievements::CreateService, feature_category: :user_profile do
  describe '#execute' do
    let_it_be(:user) { create(:user) }

    let(:params) { attributes_for(:achievement, namespace: group) }

    subject(:response) { described_class.new(namespace: group, current_user: user, params: params).execute }

    context 'when user does not have permission' do
      let_it_be(:group) { create(:group) }

      before_all do
        group.add_developer(user)
      end

      it 'returns an error' do
        expect(response).to be_error
        expect(response.message).to match_array(
          ['You have insufficient permissions to create achievements for this namespace'])
      end
    end

    context 'when user has permission' do
      let_it_be(:group) { create(:group) }

      before_all do
        group.add_maintainer(user)
      end

      it 'creates an achievement' do
        expect(response).to be_success
      end

      it 'returns an error when the achievement is not persisted' do
        params[:name] = nil

        expect(response).to be_error
        expect(response.message).to match_array([""Name can't be blank""])
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Security
  class MergeReportsService
    attr_reader :source_reports

    def initialize(*source_reports)
      @source_reports = source_reports
    end

    def execute
      copy_resources_to_target_report
      copy_findings_to_target
      target_report
    end

    private

    def target_report
      @target_report ||= ::Gitlab::Ci::Reports::Security::Report.new(
        source_reports.first.type,
        source_reports.first.pipeline,
        source_reports.first.created_at
      ).tap do |report|
        report.errors = source_reports.flat_map(&:errors)
        report.warnings = source_reports.flat_map(&:warnings)
      end
    end

    def copy_resources_to_target_report
      sorted_source_reports.each do |source_report|
        copy_scanners_to_target(source_report)
        copy_identifiers_to_target(source_report)
        copy_scanned_resources_to_target(source_report)
      end
    end

    def sorted_source_reports
      source_reports.sort { |a, b| a.primary_scanner_order_to(b) }
    end

    def copy_scanners_to_target(source_report)
      # no need for de-duping: it's done by Report internally
      source_report.scanners.values.each { |scanner| target_report.add_scanner(scanner) }
    end

    def copy_identifiers_to_target(source_report)
      # no need for de-duping: it's done by Report internally
      source_report.identifiers.values.each { |identifier| target_report.add_identifier(identifier) }
    end

    def copy_scanned_resources_to_target(source_report)
      target_report.scanned_resources.concat(source_report.scanned_resources).uniq!
    end

    def copy_findings_to_target
      deduplicated_findings.sort.each { |finding| target_report.add_finding(finding) }
    end

    def deduplicated_findings
      prioritized_findings.each_with_object([[], Set.new]) do |finding, (deduplicated, seen_identifiers)|
        next if seen_identifiers.intersect?(finding.keys.to_set)

        seen_identifiers.merge(finding.keys)
        deduplicated << finding
      end.first
    end

    def prioritized_findings
      source_reports.flat_map(&:findings).sort { |a, b| a.scanner_order_to(b) }
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

# rubocop: disable RSpec/MultipleMemoizedHelpers
RSpec.describe Security::MergeReportsService, '#execute', feature_category: :code_review_workflow do
  let(:scanner_1) { build(:ci_reports_security_scanner, external_id: 'scanner-1', name: 'Scanner 1') }
  let(:scanner_2) { build(:ci_reports_security_scanner, external_id: 'scanner-2', name: 'Scanner 2') }
  let(:scanner_3) { build(:ci_reports_security_scanner, external_id: 'scanner-3', name: 'Scanner 3') }

  let(:identifier_1_primary) { build(:ci_reports_security_identifier, external_id: 'VULN-1', external_type: 'scanner-1') }
  let(:identifier_1_cve) { build(:ci_reports_security_identifier, external_id: 'CVE-2019-123', external_type: 'cve') }
  let(:identifier_2_primary) { build(:ci_reports_security_identifier, external_id: 'VULN-2', external_type: 'scanner-2') }
  let(:identifier_2_cve) { build(:ci_reports_security_identifier, external_id: 'CVE-2019-456', external_type: 'cve') }
  let(:identifier_cwe) { build(:ci_reports_security_identifier, external_id: '789', external_type: 'cwe') }
  let(:identifier_wasc) { build(:ci_reports_security_identifier, external_id: '13', external_type: 'wasc') }

  let(:finding_id_1) do
    build(
      :ci_reports_security_finding,
      identifiers: [identifier_1_primary, identifier_1_cve],
      scanner: scanner_1,
      severity: :low
    )
  end

  let(:finding_id_1_extra) do
    build(
      :ci_reports_security_finding,
      identifiers: [identifier_1_primary, identifier_1_cve],
      scanner: scanner_1,
      severity: :low
    )
  end

  let(:finding_id_2_loc_1) do
    build(
      :ci_reports_security_finding,
      identifiers: [identifier_2_primary, identifier_2_cve],
      location: build(:ci_reports_security_locations_sast, start_line: 32, end_line: 34),
      scanner: scanner_2,
      severity: :medium
    )
  end

  let(:finding_id_2_loc_1_extra) do
    build(
      :ci_reports_security_finding,
      identifiers: [identifier_2_primary, identifier_2_cve],
      location: build(:ci_reports_security_locations_sast, start_line: 32, end_line: 34),
      scanner: scanner_2,
      severity: :medium
    )
  end

  let(:finding_id_2_loc_2) do
    build(
      :ci_reports_security_finding,
      identifiers: [identifier_2_primary, identifier_2_cve],
      location: build(:ci_reports_security_locations_sast, start_line: 42, end_line: 44),
      scanner: scanner_2,
      severity: :medium
    )
  end

  let(:finding_cwe_1) do
    build(
      :ci_reports_security_finding,
      identifiers: [identifier_cwe],
      scanner: scanner_3,
      severity: :high
    )
  end

  let(:finding_cwe_2) do
    build(
      :ci_reports_security_finding,
      identifiers: [identifier_cwe],
      scanner: scanner_1,
      severity: :critical
    )
  end

  let(:finding_wasc_1) do
    build(
      :ci_reports_security_finding,
      identifiers: [identifier_wasc],
      scanner: scanner_1,
      severity: :medium
    )
  end

  let(:finding_wasc_2) do
    build(
      :ci_reports_security_finding,
      identifiers: [identifier_wasc],
      scanner: scanner_2,
      severity: :critical
    )
  end

  let(:report_1_findings) { [finding_id_1, finding_id_2_loc_1, finding_id_2_loc_1_extra, finding_cwe_2, finding_wasc_1] }

  let(:scanned_resource) do
    ::Gitlab::Ci::Reports::Security::ScannedResource.new(URI.parse('example.com'), 'GET')
  end

  let(:scanned_resource_1) do
    ::Gitlab::Ci::Reports::Security::ScannedResource.new(URI.parse('example.com'), 'POST')
  end

  let(:scanned_resource_2) do
    ::Gitlab::Ci::Reports::Security::ScannedResource.new(URI.parse('example.com/2'), 'GET')
  end

  let(:scanned_resource_3) do
    ::Gitlab::Ci::Reports::Security::ScannedResource.new(URI.parse('example.com/3'), 'GET')
  end

  let(:report_1) do
    build(
      :ci_reports_security_report,
      scanners: [scanner_1, scanner_2],
      findings: report_1_findings,
      identifiers: report_1_findings.flat_map(&:identifiers),
      scanned_resources: [scanned_resource, scanned_resource_1, scanned_resource_2]
    )
  end

  let(:report_2_findings) { [finding_id_2_loc_2, finding_wasc_2] }

  let(:report_2) do
    build(
      :ci_reports_security_report,
      scanners: [scanner_2],
      findings: report_2_findings,
      identifiers: finding_id_2_loc_2.identifiers,
      scanned_resources: [scanned_resource, scanned_resource_1, scanned_resource_3]
    )
  end

  let(:report_3_findings) { [finding_id_1_extra, finding_cwe_1] }

  let(:report_3) do
    build(
      :ci_reports_security_report,
      scanners: [scanner_1, scanner_3],
      findings: report_3_findings,
      identifiers: report_3_findings.flat_map(&:identifiers)
    )
  end

  let(:merge_service) { described_class.new(report_1, report_2, report_3) }

  subject(:merged_report) { merge_service.execute }

  describe 'errors on target report' do
    subject { merged_report.errors }

    before do
      report_1.add_error('foo', 'bar')
      report_2.add_error('zoo', 'baz')
    end

    it { is_expected.to match_array([{ type: 'foo', message: 'bar' }, { type: 'zoo', message: 'baz' }]) }
  end

  describe 'warnings on target report' do
    subject { merged_report.warnings }

    before do
      report_1.add_warning('foo', 'bar')
      report_2.add_warning('zoo', 'baz')
    end

    it { is_expected.to match_array([{ type: 'foo', message: 'bar' }, { type: 'zoo', message: 'baz' }]) }
  end

  it 'copies scanners into target report and eliminates duplicates' do
    expect(merged_report.scanners.values).to contain_exactly(scanner_1, scanner_2, scanner_3)
  end

  it 'copies identifiers into target report and eliminates duplicates' do
    expect(merged_report.identifiers.values).to(
      contain_exactly(
        identifier_1_primary,
        identifier_1_cve,
        identifier_2_primary,
        identifier_2_cve,
        identifier_cwe,
        identifier_wasc
      )
    )
  end

  it 'deduplicates (except cwe and wasc) and sorts the vulnerabilities by severity (desc) then by compare key' do
    expect(merged_report.findings).to(
      eq([
           finding_cwe_2,
           finding_wasc_2,
           finding_cwe_1,
           finding_id_2_loc_2,
           finding_id_2_loc_1,
           finding_wasc_1,
           finding_id_1
         ])
    )
  end

  it 'deduplicates scanned resources' do
    expect(merged_report.scanned_resources).to(
      eq([
           scanned_resource,
           scanned_resource_1,
           scanned_resource_2,
           scanned_resource_3
         ])
    )
  end

  context 'ordering reports for sast analyzers' do
    let(:bandit_scanner) { build(:ci_reports_security_scanner, external_id: 'bandit', name: 'Bandit') }
    let(:semgrep_scanner) { build(:ci_reports_security_scanner, external_id: 'semgrep', name: 'Semgrep') }

    let(:identifier_bandit) { build(:ci_reports_security_identifier, external_id: 'B403', external_type: 'bandit_test_id') }
    let(:identifier_cve) { build(:ci_reports_security_identifier, external_id: 'CVE-2019-123', external_type: 'cve') }
    let(:identifier_semgrep) { build(:ci_reports_security_identifier, external_id: 'rules.bandit.B105', external_type: 'semgrep_id') }

    let(:finding_id_1) { build(:ci_reports_security_finding, identifiers: [identifier_bandit, identifier_cve], scanner: bandit_scanner, report_type: :sast) }
    let(:finding_id_2) { build(:ci_reports_security_finding, identifiers: [identifier_cve], scanner: semgrep_scanner, report_type: :sast) }
    let(:finding_id_3) { build(:ci_reports_security_finding, identifiers: [identifier_semgrep], scanner: semgrep_scanner, report_type: :sast) }

    let(:bandit_report) do
      build(:ci_reports_security_report,
        type: :sast,
        scanners: [bandit_scanner],
        findings: [finding_id_1],
        identifiers: finding_id_1.identifiers
      )
    end

    let(:semgrep_report) do
      build(
        :ci_reports_security_report,
        type: :sast,
        scanners: [semgrep_scanner],
        findings: [finding_id_2, finding_id_3],
        identifiers: finding_id_2.identifiers + finding_id_3.identifiers
      )
    end

    let(:custom_analyzer_report) do
      build(
        :ci_reports_security_report,
        type: :sast,
        scanners: [scanner_2],
        findings: [finding_id_2_loc_1],
        identifiers: finding_id_2_loc_1.identifiers
      )
    end

    context 'when reports are gathered in an unprioritized order' do
      subject(:sast_merged_report) { described_class.new(semgrep_report, bandit_report).execute }

      specify { expect(sast_merged_report.scanners.values).to eql([bandit_scanner, semgrep_scanner]) }
      specify { expect(sast_merged_report.findings.count).to eq(2) }
      specify { expect(sast_merged_report.findings.first.identifiers).to eql([identifier_bandit, identifier_cve]) }
      specify { expect(sast_merged_report.findings.last.identifiers).to contain_exactly(identifier_semgrep) }
    end

    context 'when a custom analyzer is completed before the known analyzers' do
      subject(:sast_merged_report) { described_class.new(custom_analyzer_report, semgrep_report, bandit_report).execute }

      specify { expect(sast_merged_report.scanners.values).to eql([bandit_scanner, semgrep_scanner, scanner_2]) }
      specify { expect(sast_merged_report.findings.count).to eq(3) }
      specify { expect(sast_merged_report.findings.last.identifiers).to match_array(finding_id_2_loc_1.identifiers) }
    end
  end
end
# rubocop: enable RSpec/MultipleMemoizedHelpers
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Security
  module CiConfiguration
    class DependencyScanningCreateService < ::Security::CiConfiguration::BaseCreateService
      private

      def action
        Security::CiConfiguration::DependencyScanningBuildAction.new(project.auto_devops_enabled?, existing_gitlab_ci_content,
                                                                     project.ci_config_path).generate
      end

      def next_branch
        'set-dependency-scanning-config'
      end

      def message
        _('Configure Dependency Scanning in `.gitlab-ci.yml`, creating this file if it does not already exist')
      end

      def description
        _('Configure Dependency Scanning in `.gitlab-ci.yml` using the GitLab managed template. You can [add variable overrides](https://docs.gitlab.com/ee/user/application_security/dependency_scanning/#customizing-the-dependency-scanning-settings) to customize Dependency Scanning settings.')
      end

      def name
        'Dependency Scanning'
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Security::CiConfiguration::DependencyScanningCreateService, :snowplow,
  feature_category: :software_composition_analysis do
  subject(:result) { described_class.new(project, user).execute }

  let(:branch_name) { 'set-dependency-scanning-config-1' }

  let(:snowplow_event) do
    {
      category: 'Security::CiConfiguration::DependencyScanningCreateService',
      action: 'create',
      label: ''
    }
  end

  include_examples 'services security ci configuration create service', true
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Security
  module CiConfiguration
    class SastCreateService < ::Security::CiConfiguration::BaseCreateService
      attr_reader :params

      def initialize(project, current_user, params, commit_on_default: false)
        super(project, current_user)
        @params = params

        @commit_on_default = commit_on_default
        @branch_name = project.default_branch if @commit_on_default
      end

      private

      def remove_branch_on_exception
        super unless @commit_on_default
      end

      def action
        Security::CiConfiguration::SastBuildAction.new(project.auto_devops_enabled?, params, existing_gitlab_ci_content, project.ci_config_path).generate
      end

      def next_branch
        'set-sast-config'
      end

      def message
        _('Configure SAST in `.gitlab-ci.yml`, creating this file if it does not already exist')
      end

      def description
        _('Configure SAST in `.gitlab-ci.yml` using the GitLab managed template. You can [add variable overrides](https://docs.gitlab.com/ee/user/application_security/sast/#customizing-the-sast-settings) to customize SAST settings.')
      end

      def name
        'SAST'
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Security::CiConfiguration::SastCreateService, :snowplow,
  feature_category: :static_application_security_testing do
  subject(:result) { described_class.new(project, user, params).execute }

  let(:branch_name) { 'set-sast-config-1' }

  let(:non_empty_params) do
    { 'stage' => 'security',
      'SEARCH_MAX_DEPTH' => 1,
      'SECURE_ANALYZERS_PREFIX' => 'new_registry',
      'SAST_EXCLUDED_PATHS' => 'spec,docs' }
  end

  let(:snowplow_event) do
    {
      category: 'Security::CiConfiguration::SastCreateService',
      action: 'create',
      label: 'false'
    }
  end

  include_examples 'services security ci configuration create service'

  RSpec.shared_examples_for 'commits directly to the default branch' do
    it 'commits directly to the default branch' do
      expect(project).to receive(:default_branch).twice.and_return('master')

      expect(result.status).to eq(:success)
      expect(result.payload[:success_path]).to match(/#{Gitlab::Routing.url_helpers.project_new_merge_request_url(project, {})}(.*)description(.*)source_branch/)
      expect(result.payload[:branch]).to eq('master')
    end
  end

  context 'when the repository is empty' do
    let_it_be(:project) { create(:project_empty_repo) }

    context 'when initialize_with_sast is false' do
      before do
        project.add_developer(user)
      end

      let(:params) { { initialize_with_sast: false } }

      it 'returns a ServiceResponse error' do
        expect(result).to be_kind_of(ServiceResponse)
        expect(result.status).to eq(:error)
        expect(result.message).to eq('You must <a target=""_blank"" rel=""noopener noreferrer"" ' \
                                     'href=""http://localhost/help/user/project/repository/index.md#' \
                                     'add-files-to-a-repository"">add at least one file to the ' \
                                     'repository</a> before using Security features.')
      end
    end

    context 'when initialize_with_sast is true' do
      let(:params) { { initialize_with_sast: true } }

      subject(:result) { described_class.new(project, user, params, commit_on_default: true).execute }

      before do
        project.add_maintainer(user)
      end

      it_behaves_like 'commits directly to the default branch'
    end
  end

  context 'when committing to the default branch', :aggregate_failures do
    subject(:result) { described_class.new(project, user, params, commit_on_default: true).execute }

    let(:params) { {} }

    before do
      project.add_developer(user)
    end

    it 'does not try to remove that branch on raised exceptions' do
      expect(Files::MultiService).to receive(:new).and_raise(StandardError, '_exception_')
      expect(project.repository).not_to receive(:rm_branch)

      expect { result }.to raise_error(StandardError, '_exception_')
    end

    it_behaves_like 'commits directly to the default branch'
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Security
  module CiConfiguration
    # This class parses SAST template file and .gitlab-ci.yml to populate default and current values into the JSON
    # read from app/validators/json_schemas/security_ci_configuration_schemas/sast_ui_schema.json
    class SastParserService < ::BaseService
      include Gitlab::Utils::StrongMemoize

      SAST_UI_SCHEMA_PATH = 'app/validators/json_schemas/security_ci_configuration_schemas/sast_ui_schema.json'

      def initialize(project)
        @project = project
      end

      def configuration
        result = Gitlab::Json.parse(File.read(Rails.root.join(SAST_UI_SCHEMA_PATH))).with_indifferent_access
        populate_default_value_for(result, :global)
        populate_default_value_for(result, :pipeline)
        fill_current_value_with_default_for(result, :global)
        fill_current_value_with_default_for(result, :pipeline)
        populate_current_value_for(result, :global)
        populate_current_value_for(result, :pipeline)

        fill_current_value_with_default_for_analyzers(result)
        populate_current_value_for_analyzers(result)

        result
      end

      private

      def sast_template_content
        Gitlab::Template::GitlabCiYmlTemplate.find('SAST').content
      end

      def populate_default_value_for(config, level)
        set_each(config[level], key: :default_value, with: sast_template_attributes)
      end

      def populate_current_value_for(config, level)
        set_each(config[level], key: :value, with: gitlab_ci_yml_attributes)
      end

      def fill_current_value_with_default_for(config, level)
        set_each(config[level], key: :value, with: sast_template_attributes)
      end

      def set_each(config_attributes, key:, with:)
        config_attributes.each do |entity|
          entity[key] = with[entity[:field]] if with[entity[:field]]
        end
      end

      def fill_current_value_with_default_for_analyzers(result)
        result[:analyzers].each do |analyzer|
          analyzer[:variables].each do |entity|
            entity[:value] = entity[:default_value] if entity[:default_value]
          end
        end
      end

      def populate_current_value_for_analyzers(result)
        result[:analyzers].each do |analyzer|
          analyzer[:enabled] = analyzer_enabled?(analyzer[:name])
          populate_current_value_for(analyzer, :variables)
        end
      end

      def analyzer_enabled?(analyzer_name)
        # Unless explicitly listed in the excluded analyzers, consider it enabled
        sast_excluded_analyzers.exclude?(analyzer_name)
      end

      def sast_excluded_analyzers
        strong_memoize(:sast_excluded_analyzers) do
          excluded_analyzers = gitlab_ci_yml_attributes[""SAST_EXCLUDED_ANALYZERS""] || sast_template_attributes[""SAST_EXCLUDED_ANALYZERS""]
          begin
            excluded_analyzers.split(',').map(&:strip)
          rescue StandardError
            []
          end
        end
      end

      def sast_template_attributes
        @sast_template_attributes ||= build_sast_attributes(sast_template_content)
      end

      def gitlab_ci_yml_attributes
        @gitlab_ci_yml_attributes ||= begin
          config_content = @project.repository.blob_data_at(
            @project.repository.root_ref_sha, @project.ci_config_path_or_default
          )
          return {} unless config_content

          build_sast_attributes(config_content)
        end
      end

      def build_sast_attributes(content)
        options = { project: @project, user: current_user, sha: @project.repository.commit.sha }
        yaml_result = Gitlab::Ci::YamlProcessor.new(content, options).execute
        return {} unless yaml_result.valid?

        extract_required_attributes(yaml_result)
      end

      def extract_required_attributes(yaml_result)
        result = {}

        yaml_result.yaml_variables_for(:sast).each do |variable|
          result[variable[:key]] = variable[:value]
        end

        result[:stage] = yaml_result.stage_for(:sast)
        result.with_indifferent_access
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Security::CiConfiguration::SastParserService, feature_category: :static_application_security_testing do
  describe '#configuration' do
    include_context 'read ci configuration for sast enabled project'

    let(:configuration) { described_class.new(project).configuration }
    let(:secure_analyzers) { configuration['global'][0] }
    let(:sast_excluded_paths) { configuration['global'][1] }
    let(:sast_pipeline_stage) { configuration['pipeline'][0] }
    let(:sast_search_max_depth) { configuration['pipeline'][1] }
    let(:brakeman) { configuration['analyzers'][0] }
    let(:sast_brakeman_level) { brakeman['variables'][0] }
    let(:semgrep) { configuration['analyzers'][1] }
    let(:secure_analyzers_prefix) { '$CI_TEMPLATE_REGISTRY_HOST/security-products' }

    it 'parses the configuration for SAST' do
      expect(secure_analyzers['default_value']).to eql(secure_analyzers_prefix)
      expect(sast_excluded_paths['default_value']).to eql('spec, test, tests, tmp')
      expect(sast_pipeline_stage['default_value']).to eql('test')
      expect(sast_search_max_depth['default_value']).to eql('4')
      expect(brakeman['enabled']).to be(true)
      expect(sast_brakeman_level['default_value']).to eql('1')
    end

    context 'while populating current values of the entities' do
      context 'when .gitlab-ci.yml is present' do
        it 'populates the current values from the file' do
          allow(project.repository).to receive(:blob_data_at).and_return(gitlab_ci_yml_content)
          expect(secure_analyzers['value']).to eql(""registry.gitlab.com/gitlab-org/security-products/analyzers2"")
          expect(sast_excluded_paths['value']).to eql('spec, executables')
          expect(sast_pipeline_stage['value']).to eql('our_custom_security_stage')
          expect(sast_search_max_depth['value']).to eql('8')
          expect(brakeman['enabled']).to be(false)
          expect(semgrep['enabled']).to be(true)
          expect(sast_brakeman_level['value']).to eql('2')
        end

        context 'SAST_EXCLUDED_ANALYZERS is set' do
          it 'enables analyzers correctly' do
            allow(project.repository).to receive(:blob_data_at).and_return(gitlab_ci_yml_excluded_analyzers_content)

            expect(brakeman['enabled']).to be(false)
            expect(semgrep['enabled']).to be(true)
          end
        end
      end

      context 'when .gitlab-ci.yml is absent' do
        it 'populates the current values with the default values' do
          allow(project.repository).to receive(:blob_data_at).and_return(nil)
          expect(secure_analyzers['value']).to eql(secure_analyzers_prefix)
          expect(sast_excluded_paths['value']).to eql('spec, test, tests, tmp')
          expect(sast_pipeline_stage['value']).to eql('test')
          expect(sast_search_max_depth['value']).to eql('4')
          expect(brakeman['enabled']).to be(true)
          expect(sast_brakeman_level['value']).to eql('1')
        end
      end

      context 'when .gitlab-ci.yml does not include the sast job' do
        before do
          allow(project.repository).to receive(:blob_data_at).and_return(
            File.read(Rails.root.join('spec/support/gitlab_stubs/gitlab_ci.yml'))
          )
        end

        it 'populates the current values with the default values' do
          expect(secure_analyzers['value']).to eql(secure_analyzers_prefix)
          expect(sast_excluded_paths['value']).to eql('spec, test, tests, tmp')
          expect(sast_pipeline_stage['value']).to eql('test')
          expect(sast_search_max_depth['value']).to eql('4')
          expect(brakeman['enabled']).to be(true)
          expect(sast_brakeman_level['value']).to eql('1')
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Security
  module CiConfiguration
    class SecretDetectionCreateService < ::Security::CiConfiguration::BaseCreateService
      private

      def action
        Security::CiConfiguration::SecretDetectionBuildAction.new(project.auto_devops_enabled?, existing_gitlab_ci_content,
                                                                  project.ci_config_path).generate
      end

      def next_branch
        'set-secret-detection-config'
      end

      def message
        _('Configure Secret Detection in `.gitlab-ci.yml`, creating this file if it does not already exist')
      end

      def description
        _('Configure Secret Detection in `.gitlab-ci.yml` using the GitLab managed template. You can [add variable overrides](https://docs.gitlab.com/ee/user/application_security/secret_detection/#customizing-settings) to customize Secret Detection settings.')
      end

      def name
        'Secret Detection'
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Security::CiConfiguration::SecretDetectionCreateService, :snowplow, feature_category: :container_scanning do
  subject(:result) { described_class.new(project, user).execute }

  let(:branch_name) { 'set-secret-detection-config-1' }

  let(:snowplow_event) do
    {
      category: 'Security::CiConfiguration::SecretDetectionCreateService',
      action: 'create',
      label: ''
    }
  end

  include_examples 'services security ci configuration create service', true
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Security
  module CiConfiguration
    class ContainerScanningCreateService < ::Security::CiConfiguration::BaseCreateService
      private

      def action
        Security::CiConfiguration::ContainerScanningBuildAction.new(project.auto_devops_enabled?, existing_gitlab_ci_content,
                                                                    project.ci_config_path).generate
      end

      def next_branch
        'set-container-scanning-config'
      end

      def message
        _('Configure Container Scanning in `.gitlab-ci.yml`, creating this file if it does not already exist')
      end

      def description
        _('Configure Container Scanning in `.gitlab-ci.yml` using the GitLab managed template. You can [add variable overrides](https://docs.gitlab.com/ee/user/application_security/container_scanning/#customizing-the-container-scanning-settings) to customize Container Scanning settings.')
      end

      def name
        'Container Scanning'
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Security::CiConfiguration::ContainerScanningCreateService, :snowplow, feature_category: :container_scanning do
  subject(:result) { described_class.new(project, user).execute }

  let(:branch_name) { 'set-container-scanning-config-1' }

  let(:snowplow_event) do
    {
      category: 'Security::CiConfiguration::ContainerScanningCreateService',
      action: 'create',
      label: ''
    }
  end

  include_examples 'services security ci configuration create service', true
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Security
  module CiConfiguration
    class SastIacCreateService < ::Security::CiConfiguration::BaseCreateService
      private

      def action
        Security::CiConfiguration::SastIacBuildAction.new(project.auto_devops_enabled?, existing_gitlab_ci_content,
                                                          project.ci_config_path).generate
      end

      def next_branch
        'set-sast-iac-config'
      end

      def message
        _('Configure SAST IaC in `.gitlab-ci.yml`, creating this file if it does not already exist')
      end

      def description
        _('Configure SAST IaC in `.gitlab-ci.yml` using the GitLab managed template. You can [add variable overrides](https://docs.gitlab.com/ee/user/application_security/sast/#customizing-the-sast-settings) to customize SAST IaC settings.')
      end

      def name
        'SAST IaC'
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Security::CiConfiguration::SastIacCreateService, :snowplow, feature_category: :static_application_security_testing do
  subject(:result) { described_class.new(project, user).execute }

  let(:branch_name) { 'set-sast-iac-config-1' }

  let(:snowplow_event) do
    {
      category: 'Security::CiConfiguration::SastIacCreateService',
      action: 'create',
      label: ''
    }
  end

  include_examples 'services security ci configuration create service', true
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Auth
  class DependencyProxyAuthenticationService < BaseService
    AUDIENCE = 'dependency_proxy'
    HMAC_KEY = 'gitlab-dependency-proxy'
    DEFAULT_EXPIRE_TIME = 1.minute

    def execute(authentication_abilities:)
      return error('dependency proxy not enabled', 404) unless ::Gitlab.config.dependency_proxy.enabled
      return error('access forbidden', 403) unless valid_user_actor?

      { token: authorized_token.encoded }
    end

    class << self
      include ::Gitlab::Utils::StrongMemoize

      def secret
        strong_memoize(:secret) do
          OpenSSL::HMAC.hexdigest(
            'sha256',
            ::Settings.attr_encrypted_db_key_base,
            HMAC_KEY
          )
        end
      end

      def token_expire_at
        Time.current + Gitlab::CurrentSettings.container_registry_token_expire_delay.minutes
      end
    end

    private

    def valid_user_actor?
      current_user || valid_deploy_token?
    end

    def valid_deploy_token?
      deploy_token && deploy_token.valid_for_dependency_proxy?
    end

    def authorized_token
      JSONWebToken::HMACToken.new(self.class.secret).tap do |token|
        token['user_id'] = current_user.id if current_user
        token['deploy_token'] = deploy_token.token if deploy_token
        token.expire_time = self.class.token_expire_at
      end
    end

    def deploy_token
      params[:deploy_token]
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Auth::DependencyProxyAuthenticationService, feature_category: :dependency_proxy do
  let_it_be(:user) { create(:user) }
  let_it_be(:params) { {} }

  let(:service) { described_class.new(nil, user, params) }

  before do
    stub_config(dependency_proxy: { enabled: true }, registry: { enabled: true })
  end

  describe '#execute' do
    subject { service.execute(authentication_abilities: nil) }

    shared_examples 'returning' do |status:, message:|
      it ""returns #{message}"", :aggregate_failures do
        expect(subject[:http_status]).to eq(status)
        expect(subject[:message]).to eq(message)
      end
    end

    shared_examples 'returning a token with an encoded field' do |field|
      it 'returns a token with encoded field' do
        token = subject[:token]
        expect(token).not_to be_nil

        decoded_token = decode(token)
        expect(decoded_token[field]).not_to be_nil
      end
    end

    context 'dependency proxy is not enabled' do
      before do
        stub_config(dependency_proxy: { enabled: false })
      end

      it_behaves_like 'returning', status: 404, message: 'dependency proxy not enabled'
    end

    context 'without a user' do
      let(:user) { nil }

      it_behaves_like 'returning', status: 403, message: 'access forbidden'
    end

    context 'with a deploy token' do
      let_it_be(:deploy_token) { create(:deploy_token, :group, :dependency_proxy_scopes) }
      let_it_be(:params) { { deploy_token: deploy_token } }

      it_behaves_like 'returning a token with an encoded field', 'deploy_token'
    end

    context 'with a human user' do
      it_behaves_like 'returning a token with an encoded field', 'user_id'
    end

    context 'all other user types' do
      User::USER_TYPES.except(:human, :project_bot).each_value do |user_type|
        context ""with user_type #{user_type}"" do
          before do
            user.update!(user_type: user_type)
          end

          it_behaves_like 'returning a token with an encoded field', 'user_id'
        end
      end
    end

    def decode(token)
      DependencyProxy::AuthTokenService.new(token).execute
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Auth
  class ContainerRegistryAuthenticationService < BaseService
    AUDIENCE = 'container_registry'
    REGISTRY_LOGIN_ABILITIES = [
      :read_container_image,
      :create_container_image,
      :destroy_container_image,
      :update_container_image,
      :admin_container_image,
      :build_read_container_image,
      :build_create_container_image,
      :build_destroy_container_image
    ].freeze

    FORBIDDEN_IMPORTING_SCOPES = %w[push delete *].freeze

    ActiveImportError = Class.new(StandardError)

    def execute(authentication_abilities:)
      @authentication_abilities = authentication_abilities

      return error('UNAVAILABLE', status: 404, message: 'registry not enabled') unless registry.enabled

      return error('DENIED', status: 403, message: 'access forbidden') unless has_registry_ability?

      unless scopes.any? || current_user || deploy_token || project
        return error('DENIED', status: 403, message: 'access forbidden')
      end

      { token: authorized_token(*scopes).encoded }
    rescue ActiveImportError
      error(
        'DENIED',
        status: 403,
        message: 'Your repository is currently being migrated to a new platform and writes are temporarily disabled. Go to https://gitlab.com/groups/gitlab-org/-/epics/5523 to learn more.'
      )
    end

    def self.full_access_token(*names)
      names_and_actions = names.index_with { %w[*] }
      access_token(names_and_actions)
    end

    def self.import_access_token
      access_token({ 'import' => %w[*] }, 'registry')
    end

    def self.pull_access_token(*names)
      names_and_actions = names.index_with { %w[pull] }
      access_token(names_and_actions)
    end

    def self.pull_nested_repositories_access_token(name)
      name = name.chomp('/')

      access_token({
        name => %w[pull],
        ""#{name}/*"" => %w[pull]
      })
    end

    def self.push_pull_nested_repositories_access_token(name)
      name = name.chomp('/')

      access_token(
        {
          name => %w[pull push],
          ""#{name}/*"" => %w[pull]
        },
        override_project_path: name
      )
    end

    def self.access_token(names_and_actions, type = 'repository', override_project_path: nil)
      registry = Gitlab.config.registry
      token = JSONWebToken::RSAToken.new(registry.key)
      token.issuer = registry.issuer
      token.audience = AUDIENCE
      token.expire_time = token_expire_at

      token[:access] = names_and_actions.map do |name, actions|
        {
          type: type,
          name: name,
          actions: actions,
          meta: access_metadata(path: name, override_project_path: override_project_path)
        }.compact
      end

      token.encoded
    end

    def self.token_expire_at
      Time.current + Gitlab::CurrentSettings.container_registry_token_expire_delay.minutes
    end

    def self.access_metadata(project: nil, path: nil, override_project_path: nil)
      return { project_path: override_project_path.downcase } if override_project_path

      # If the project is not given, try to infer it from the provided path
      if project.nil?
        return if path.nil? # If no path is given, return early
        return if path == 'import' # Ignore the special 'import' path

        # If the path ends with '/*', remove it so we can parse the actual repository path
        path = path.chomp('/*')

        # Parse the repository project from the path
        begin
          project = ContainerRegistry::Path.new(path).repository_project
        rescue ContainerRegistry::Path::InvalidRegistryPathError
          # If the path is invalid, gracefully handle the error
          return
        end
      end

      # Return the project path (lowercase) as metadata
      { project_path: project&.full_path&.downcase }
    end

    private

    def authorized_token(*accesses)
      JSONWebToken::RSAToken.new(registry.key).tap do |token|
        token.issuer = registry.issuer
        token.audience = params[:service]
        token.subject = current_user.try(:username)
        token.expire_time = self.class.token_expire_at
        token[:auth_type] = params[:auth_type]
        token[:access] = accesses.compact
        token[:user] = user_info_token.encoded
      end
    end

    def user_info_token
      info =
        if current_user
          {
            token_type: params[:auth_type],
            username: current_user.username,
            user_id: current_user.id
          }
        elsif deploy_token
          {
            token_type: params[:auth_type],
            username: deploy_token.username,
            deploy_token_id: deploy_token.id
          }
        end

      JSONWebToken::RSAToken.new(registry.key).tap do |token|
        token[:user_info] = info
      end
    end

    def scopes
      return [] unless params[:scopes]

      @scopes ||= params[:scopes].map do |scope|
        process_scope(scope)
      end.compact
    end

    def process_scope(scope)
      type, name, actions = scope.split(':', 3)
      actions = actions.split(',')

      case type
      when 'registry'
        process_registry_access(type, name, actions)
      when 'repository'
        path = ContainerRegistry::Path.new(name)
        process_repository_access(type, path, actions)
      end
    end

    def process_registry_access(type, name, actions)
      return unless current_user&.admin?
      return unless name == 'catalog'
      return unless actions == ['*']

      { type: type, name: name, actions: ['*'] }
    end

    def process_repository_access(type, path, actions)
      return unless path.valid?

      raise ActiveImportError if actively_importing?(actions, path)

      requested_project = path.repository_project

      return unless requested_project

      authorized_actions = actions.select do |action|
        can_access?(requested_project, action)
      end

      log_if_actions_denied(type, requested_project, actions, authorized_actions)

      return unless authorized_actions.present?

      # At this point user/build is already authenticated.
      #
      ensure_container_repository!(path, authorized_actions)

      {
        type: type,
        name: path.to_s,
        actions: authorized_actions,
        meta: self.class.access_metadata(project: requested_project)
      }
    end

    def actively_importing?(actions, path)
      return false if FORBIDDEN_IMPORTING_SCOPES.intersection(actions).empty?

      container_repository = ContainerRepository.find_by_path(path)
      return false unless container_repository

      container_repository.migration_importing?
    end

    ##
    # Because we do not have two way communication with registry yet,
    # we create a container repository image resource when push to the
    # registry is successfully authorized.
    #
    def ensure_container_repository!(path, actions)
      return if path.has_repository?
      return unless actions.include?('push')

      ContainerRepository.find_or_create_from_path(path)
    end

    # Overridden in EE
    def can_access?(requested_project, requested_action)
      return false unless requested_project.container_registry_enabled?

      case requested_action
      when 'pull'
        build_can_pull?(requested_project) || user_can_pull?(requested_project) || deploy_token_can_pull?(requested_project)
      when 'push'
        build_can_push?(requested_project) || user_can_push?(requested_project) || deploy_token_can_push?(requested_project)
      when 'delete'
        build_can_delete?(requested_project) || user_can_admin?(requested_project)
      when '*'
        user_can_admin?(requested_project)
      else
        false
      end
    end

    def build_can_delete?(requested_project)
      # Build can delete only from the project from which it originates
      has_authentication_ability?(:build_destroy_container_image) &&
        requested_project == project
    end

    def registry
      Gitlab.config.registry
    end

    def can_user?(ability, project)
      can?(current_user, ability, project)
    end

    def build_can_pull?(requested_project)
      # Build can:
      # 1. pull from its own project (for ex. a build)
      # 2. read images from dependent projects if creator of build is a team member
      has_authentication_ability?(:build_read_container_image) &&
        (requested_project == project || can_user?(:build_read_container_image, requested_project))
    end

    def user_can_admin?(requested_project)
      has_authentication_ability?(:admin_container_image) &&
        can_user?(:admin_container_image, requested_project)
    end

    def user_can_pull?(requested_project)
      has_authentication_ability?(:read_container_image) &&
        can_user?(:read_container_image, requested_project)
    end

    def deploy_token_can_pull?(requested_project)
      has_authentication_ability?(:read_container_image) &&
        deploy_token.present? &&
        can?(deploy_token, :read_container_image, requested_project)
    end

    def deploy_token_can_push?(requested_project)
      has_authentication_ability?(:create_container_image) &&
        deploy_token.present? &&
        can?(deploy_token, :create_container_image, requested_project)
    end

    ##
    # We still support legacy pipeline triggers which do not have associated
    # actor. New permissions model and new triggers are always associated with
    # an actor. So this should be improved once
    # https://gitlab.com/gitlab-org/gitlab-foss/issues/37452 is resolved.
    #
    def build_can_push?(requested_project)
      # Build can push only to the project from which it originates
      has_authentication_ability?(:build_create_container_image) &&
        requested_project == project
    end

    def user_can_push?(requested_project)
      has_authentication_ability?(:create_container_image) &&
        can_user?(:create_container_image, requested_project)
    end

    def error(code, status:, message: '')
      { errors: [{ code: code, message: message }], http_status: status }
    end

    def has_authentication_ability?(capability)
      @authentication_abilities.to_a.include?(capability)
    end

    def has_registry_ability?
      @authentication_abilities.any? do |ability|
        REGISTRY_LOGIN_ABILITIES.include?(ability)
      end
    end

    # Overridden in EE
    def extra_info
      {}
    end

    def deploy_token
      params[:deploy_token]
    end

    def log_if_actions_denied(type, requested_project, requested_actions, authorized_actions)
      return if requested_actions == authorized_actions

      log_info = {
        message: 'Denied container registry permissions',
        scope_type: type,
        requested_project_path: requested_project.full_path,
        requested_actions: requested_actions,
        authorized_actions: authorized_actions,
        username: current_user&.username,
        user_id: current_user&.id,
        project_path: project&.full_path
      }.merge!(extra_info).compact

      Gitlab::AuthLogger.warn(log_info)
    end
  end
end

Auth::ContainerRegistryAuthenticationService.prepend_mod_with('Auth::ContainerRegistryAuthenticationService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Auth::ContainerRegistryAuthenticationService, feature_category: :container_registry do
  include AdminModeHelper

  it_behaves_like 'a container registry auth service'
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ApplicationSettings
  class UpdateService < ApplicationSettings::BaseService
    include ValidatesClassificationLabel

    attr_reader :params, :application_setting

    MARKDOWN_CACHE_INVALIDATING_PARAMS = %w[asset_proxy_enabled asset_proxy_url asset_proxy_secret_key asset_proxy_whitelist].freeze

    def execute
      result = update_settings

      auto_approve_blocked_users if result

      result
    end

    private

    def update_settings
      validate_classification_label(application_setting, :external_authorization_service_default_label) unless bypass_external_auth?

      if application_setting.errors.any?
        return false
      end

      update_terms(@params.delete(:terms))
      update_default_branch_protection_defaults(@params[:default_branch_protection])

      add_to_outbound_local_requests_whitelist(@params.delete(:add_to_outbound_local_requests_whitelist))

      if params.key?(:performance_bar_allowed_group_path)
        group_id = process_performance_bar_allowed_group_id

        return false if application_setting.errors.any?

        params[:performance_bar_allowed_group_id] = group_id
      end

      if usage_stats_updated? && !params.delete(:skip_usage_stats_user)
        params[:usage_stats_set_by_user_id] = current_user.id
      end

      @application_setting.assign_attributes(params)

      if invalidate_markdown_cache?
        @application_setting[:local_markdown_version] = @application_setting.local_markdown_version + 1
      end

      @application_setting.save
    end

    def usage_stats_updated?
      params.key?(:usage_ping_enabled) || params.key?(:version_check_enabled)
    end

    def add_to_outbound_local_requests_whitelist(values)
      values_array = Array(values).reject(&:empty?)
      return if values_array.empty?

      @application_setting.add_to_outbound_local_requests_whitelist(values_array)
    end

    def invalidate_markdown_cache?
      !params.key?(:local_markdown_version) &&
        (@application_setting.changes.keys & MARKDOWN_CACHE_INVALIDATING_PARAMS).any?
    end

    def update_terms(terms)
      return unless terms.present?

      # Avoid creating a new terms record if the text is exactly the same.
      terms = terms.strip
      return if terms == @application_setting.terms

      ApplicationSetting::Term.create(terms: terms)
      @application_setting.reset_memoized_terms
    end

    def update_default_branch_protection_defaults(default_branch_protection)
      return unless default_branch_protection.present?

      # We are migrating default_branch_protection from an integer
      # column to a jsonb column. While completing the rest of the
      # work, we want to start translating the updates sent to the
      # existing column into the json. Eventually, we will be updating
      # the jsonb column directly and deprecating the original update
      # path. Until then, we want to sync up both columns.
      protection = Gitlab::Access::BranchProtection.new(default_branch_protection.to_i)
      @application_setting.default_branch_protection_defaults = protection.to_hash
    end

    def process_performance_bar_allowed_group_id
      group_full_path = params.delete(:performance_bar_allowed_group_path)
      enable_param_on = Gitlab::Utils.to_boolean(params.delete(:performance_bar_enabled))
      performance_bar_enabled = enable_param_on.nil? || enable_param_on # Default to true

      return if group_full_path.blank?
      return if enable_param_on == false # Explicitly disabling

      unless performance_bar_enabled
        application_setting.errors.add(:performance_bar_allowed_group_id, 'not allowed when performance bar is disabled')
        return
      end

      group = Group.find_by_full_path(group_full_path.chomp('/'))

      unless group
        application_setting.errors.add(:performance_bar_allowed_group_id, 'not found')
        return
      end

      group.id
    end

    def bypass_external_auth?
      params.key?(:external_authorization_service_enabled) && !Gitlab::Utils.to_boolean(params[:external_authorization_service_enabled])
    end

    def auto_approve_blocked_users
      return unless should_auto_approve_blocked_users?

      ApproveBlockedPendingApprovalUsersWorker.perform_async(current_user.id)
    end

    def should_auto_approve_blocked_users?
      return false unless application_setting.previous_changes.key?(:require_admin_approval_after_user_signup)

      enabled_previous, enabled_current = application_setting.previous_changes[:require_admin_approval_after_user_signup]

      enabled_previous && !enabled_current
    end
  end
end

ApplicationSettings::UpdateService.prepend_mod_with('ApplicationSettings::UpdateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ApplicationSettings::UpdateService, feature_category: :shared do
  include ExternalAuthorizationServiceHelpers

  let(:application_settings) { ::Gitlab::CurrentSettings.current_application_settings }
  let(:admin) { create(:user, :admin) }
  let(:params) { {} }

  subject { described_class.new(application_settings, admin, params) }

  before do
    # So the caching behaves like it would in production
    stub_env('IN_MEMORY_APPLICATION_SETTINGS', 'false')

    # Creating these settings first ensures they're used by other factories
    application_settings
  end

  describe 'updating terms' do
    context 'when the passed terms are blank' do
      let(:params) { { terms: '' } }

      it 'does not create terms' do
        expect { subject.execute }.not_to change { ApplicationSetting::Term.count }
      end
    end

    context 'when passing terms' do
      let(:params) { { terms: 'Be nice!  ' } }

      it 'creates the terms' do
        expect { subject.execute }.to change { ApplicationSetting::Term.count }.by(1)
      end

      it 'does not create terms if they are the same as the existing ones' do
        create(:term, terms: 'Be nice!')

        expect { subject.execute }.not_to change { ApplicationSetting::Term.count }
      end

      it 'updates terms if they already existed' do
        create(:term, terms: 'Other terms')

        subject.execute

        expect(application_settings.terms).to eq('Be nice!')
      end

      it 'only queries once when the terms are changed' do
        create(:term, terms: 'Other terms')
        expect(application_settings.terms).to eq('Other terms')

        subject.execute

        expect(application_settings.terms).to eq('Be nice!')
        expect { 2.times { application_settings.terms } }
          .not_to exceed_query_limit(0)
      end
    end
  end

  describe 'updating outbound_local_requests_whitelist' do
    context 'when params is blank' do
      let(:params) { {} }

      it 'does not add to allowlist' do
        expect { subject.execute }.not_to change {
          application_settings.outbound_local_requests_whitelist
        }
      end
    end

    context 'when param add_to_outbound_local_requests_whitelist contains values' do
      before do
        application_settings.outbound_local_requests_whitelist = ['127.0.0.1']
      end

      let(:params) { { add_to_outbound_local_requests_whitelist: ['example.com', ''] } }

      it 'adds to allowlist' do
        expect { subject.execute }.to change {
          application_settings.outbound_local_requests_whitelist
        }

        expect(application_settings.outbound_local_requests_whitelist).to contain_exactly(
          '127.0.0.1', 'example.com'
        )
      end
    end

    context 'when param outbound_local_requests_allowlist_raw is passed' do
      before do
        application_settings.outbound_local_requests_whitelist = ['127.0.0.1']
      end

      let(:params) { { outbound_local_requests_allowlist_raw: 'example.com;gitlab.com' } }

      it 'overwrites the existing allowlist' do
        expect { subject.execute }.to change {
          application_settings.outbound_local_requests_whitelist
        }

        expect(application_settings.outbound_local_requests_whitelist).to contain_exactly(
          'example.com', 'gitlab.com'
        )
      end
    end
  end

  describe 'markdown cache invalidators', feature_category: :team_planning do
    shared_examples 'invalidates markdown cache' do |attribute|
      let(:params) { attribute }

      it 'increments cache' do
        expect { subject.execute }.to change(application_settings, :local_markdown_version).by(1)
      end
    end

    it_behaves_like 'invalidates markdown cache', { asset_proxy_enabled: true }
    it_behaves_like 'invalidates markdown cache', { asset_proxy_url: 'http://test.com' }
    it_behaves_like 'invalidates markdown cache', { asset_proxy_secret_key: 'another secret' }
    it_behaves_like 'invalidates markdown cache', { asset_proxy_allowlist: ['domain.com'] }
    it_behaves_like 'invalidates markdown cache', { asset_proxy_whitelist: ['domain.com'] }

    context 'when also setting the local_markdown_version' do
      let(:params) { { asset_proxy_enabled: true, local_markdown_version: 12 } }

      it 'does not increment' do
        expect { subject.execute }.to change(application_settings, :local_markdown_version).to(12)
      end
    end

    context 'do not invalidate if value does not change' do
      let(:params) { { asset_proxy_enabled: true, asset_proxy_secret_key: 'secret', asset_proxy_url: 'http://test.com' } }

      it 'does not increment' do
        described_class.new(application_settings, admin, params).execute

        expect { described_class.new(application_settings, admin, params).execute }.not_to change(application_settings, :local_markdown_version)
      end
    end
  end

  describe 'performance bar settings', feature_category: :cloud_connector do
    using RSpec::Parameterized::TableSyntax

    where(
      :params_performance_bar_enabled,
      :params_performance_bar_allowed_group_path,
      :previous_performance_bar_allowed_group_id,
      :expected_performance_bar_allowed_group_id,
      :expected_valid
    ) do
      true | '' | nil | nil | true
      true | '' | 42_000_000 | nil | true
      true | nil | nil | nil | true
      true | nil | 42_000_000 | nil | true
      true | 'foo' | nil | nil | false
      true | 'foo' | 42_000_000 | 42_000_000 | false
      true | 'group_a' | nil | 42_000_000 | true
      true | 'group_b' | 42_000_000 | 43_000_000 | true
      true | 'group_b/' | 42_000_000 | 43_000_000 | true
      true | 'group_a' | 42_000_000 | 42_000_000 | true
      false | '' | nil | nil | true
      false | '' | 42_000_000 | nil | true
      false | nil | nil | nil | true
      false | nil | 42_000_000 | nil | true
      false | 'foo' | nil | nil | true
      false | 'foo' | 42_000_000 | nil | true
      false | 'group_a' | nil | nil | true
      false | 'group_b' | 42_000_000 | nil | true
      false | 'group_a' | 42_000_000 | nil | true
      nil | '' | nil | nil | true
      nil | 'foo' | nil | nil | false
      nil | 'group_a' | nil | 42_000_000 | true
    end

    with_them do
      let(:params) do
        {
          performance_bar_allowed_group_path: params_performance_bar_allowed_group_path
        }.tap do |params_hash|
          # Treat nil in the table as missing
          unless params_performance_bar_enabled.nil?
            params_hash[:performance_bar_enabled] = params_performance_bar_enabled
          end
        end
      end

      before do
        if previous_performance_bar_allowed_group_id == 42_000_000 || params_performance_bar_allowed_group_path == 'group_a'
          create(:group, id: 42_000_000, path: 'group_a')
        end

        if expected_performance_bar_allowed_group_id == 43_000_000 || params_performance_bar_allowed_group_path == 'group_b'
          create(:group, id: 43_000_000, path: 'group_b')
        end

        application_settings.update!(performance_bar_allowed_group_id: previous_performance_bar_allowed_group_id)
      end

      it 'sets performance_bar_allowed_group_id when present and performance_bar_enabled == true' do
        expect(application_settings.performance_bar_allowed_group_id).to eq(previous_performance_bar_allowed_group_id)

        if previous_performance_bar_allowed_group_id != expected_performance_bar_allowed_group_id
          expect { subject.execute }
            .to change(application_settings, :performance_bar_allowed_group_id)
            .from(previous_performance_bar_allowed_group_id).to(expected_performance_bar_allowed_group_id)
        else
          expect { subject.execute }
            .not_to change(application_settings, :performance_bar_allowed_group_id)
        end
      end

      it 'adds errors to the model for invalid params' do
        expect(subject.execute).to eq(expected_valid)

        unless expected_valid
          expect(application_settings.errors[:performance_bar_allowed_group_id]).to be_present
        end
      end
    end

    context 'when :performance_bar_allowed_group_path is not present' do
      let(:group) { create(:group) }

      before do
        application_settings.update!(performance_bar_allowed_group_id: group.id)
      end

      it 'does not change the performance bar settings' do
        expect { subject.execute }
          .not_to change(application_settings, :performance_bar_allowed_group_id)
      end
    end

    context 'when :performance_bar_enabled is not present' do
      let(:group) { create(:group) }
      let(:params) { { performance_bar_allowed_group_path: group.full_path } }

      it 'implicitly defaults to true' do
        expect { subject.execute }
          .to change(application_settings, :performance_bar_allowed_group_id)
          .from(nil).to(group.id)
      end
    end
  end

  context 'when external authorization is enabled', feature_category: :system_access do
    before do
      enable_external_authorization_service_check
    end

    it 'does not validate labels if external authorization gets disabled' do
      expect_any_instance_of(described_class).not_to receive(:validate_classification_label)

      described_class.new(application_settings, admin, { external_authorization_service_enabled: false }).execute
    end

    it 'does validate labels if external authorization gets enabled' do
      expect_any_instance_of(described_class).to receive(:validate_classification_label)

      described_class.new(application_settings, admin, { external_authorization_service_enabled: true }).execute
    end

    it 'does validate labels if external authorization is left unchanged' do
      expect_any_instance_of(described_class).to receive(:validate_classification_label)

      described_class.new(application_settings, admin, { external_authorization_service_default_label: 'new-label' }).execute
    end

    it 'does not save the settings with an error if the service denies access' do
      expect(::Gitlab::ExternalAuthorization)
        .to receive(:access_allowed?).with(admin, 'new-label') { false }

      described_class.new(application_settings, admin, { external_authorization_service_default_label: 'new-label' }).execute

      expect(application_settings.errors[:external_authorization_service_default_label]).to be_present
    end

    it 'saves the setting when the user has access to the label' do
      expect(::Gitlab::ExternalAuthorization)
        .to receive(:access_allowed?).with(admin, 'new-label') { true }

      described_class.new(application_settings, admin, { external_authorization_service_default_label: 'new-label' }).execute

      # Read the attribute directly to avoid the stub from
      # `enable_external_authorization_service_check`
      expect(application_settings[:external_authorization_service_default_label]).to eq('new-label')
    end

    it 'does not validate the label if it was not passed' do
      expect(::Gitlab::ExternalAuthorization)
        .not_to receive(:access_allowed?)

      described_class.new(application_settings, admin, { home_page_url: 'http://foo.bar' }).execute
    end
  end

  context 'when raw_blob_request_limit is passsed' do
    let(:params) do
      {
        raw_blob_request_limit: 600
      }
    end

    it 'updates raw_blob_request_limit value' do
      subject.execute

      application_settings.reload

      expect(application_settings.raw_blob_request_limit).to eq(600)
    end
  end

  context 'when default_branch_protection is updated' do
    let(:expected) { ::Gitlab::Access::BranchProtection.protected_against_developer_pushes.stringify_keys }
    let(:params) { { default_branch_protection: ::Gitlab::Access::PROTECTION_DEV_CAN_MERGE } }

    it ""updates default_branch_protection_defaults from the default_branch_protection param"" do
      default_value = ::Gitlab::Access::BranchProtection.protected_fully.deep_stringify_keys

      expect { subject.execute }.to change { application_settings.default_branch_protection_defaults }.from(default_value).to(expected)
    end
  end

  context 'when protected path settings are passed' do
    let(:params) do
      {
        throttle_protected_paths_enabled: 1,
        throttle_protected_paths_period_in_seconds: 600,
        throttle_protected_paths_requests_per_period: 100,
        protected_paths_raw: ""/users/password\r\n/users/sign_in\r\n"",
        protected_paths_for_get_request_raw: ""/users/password\r\n/users/sign_up\r\n""
      }
    end

    it 'updates protected path settings' do
      subject.execute

      application_settings.reload

      expect(application_settings.throttle_protected_paths_enabled).to be_truthy
      expect(application_settings.throttle_protected_paths_period_in_seconds).to eq(600)
      expect(application_settings.throttle_protected_paths_requests_per_period).to eq(100)
      expect(application_settings.protected_paths).to eq(['/users/password', '/users/sign_in'])
      expect(application_settings.protected_paths_for_get_request).to match_array(['/users/password', '/users/sign_up'])
    end
  end

  context 'when general rate limits are passed' do
    let(:params) do
      {
        throttle_authenticated_api_enabled: true,
        throttle_authenticated_api_period_in_seconds: 10,
        throttle_authenticated_api_requests_per_period: 20,
        throttle_authenticated_web_enabled: true,
        throttle_authenticated_web_period_in_seconds: 30,
        throttle_authenticated_web_requests_per_period: 40,
        throttle_unauthenticated_api_enabled: true,
        throttle_unauthenticated_api_period_in_seconds: 50,
        throttle_unauthenticated_api_requests_per_period: 60,
        throttle_unauthenticated_enabled: true,
        throttle_unauthenticated_period_in_seconds: 50,
        throttle_unauthenticated_requests_per_period: 60
      }
    end

    it 'updates general throttle settings' do
      subject.execute

      expect(application_settings.reload).to have_attributes(params)
    end
  end

  context 'when package registry rate limits are passed' do
    let(:params) do
      {
        throttle_unauthenticated_packages_api_enabled: 1,
        throttle_unauthenticated_packages_api_period_in_seconds: 500,
        throttle_unauthenticated_packages_api_requests_per_period: 20,
        throttle_authenticated_packages_api_enabled: 1,
        throttle_authenticated_packages_api_period_in_seconds: 600,
        throttle_authenticated_packages_api_requests_per_period: 10
      }
    end

    it 'updates package registry throttle settings' do
      subject.execute

      application_settings.reload

      expect(application_settings.throttle_unauthenticated_packages_api_enabled).to be_truthy
      expect(application_settings.throttle_unauthenticated_packages_api_period_in_seconds).to eq(500)
      expect(application_settings.throttle_unauthenticated_packages_api_requests_per_period).to eq(20)
      expect(application_settings.throttle_authenticated_packages_api_enabled).to be_truthy
      expect(application_settings.throttle_authenticated_packages_api_period_in_seconds).to eq(600)
      expect(application_settings.throttle_authenticated_packages_api_requests_per_period).to eq(10)
    end
  end

  context 'when files API rate limits are passed' do
    let(:params) do
      {
        throttle_unauthenticated_files_api_enabled: 1,
        throttle_unauthenticated_files_api_period_in_seconds: 500,
        throttle_unauthenticated_files_api_requests_per_period: 20,
        throttle_authenticated_files_api_enabled: 1,
        throttle_authenticated_files_api_period_in_seconds: 600,
        throttle_authenticated_files_api_requests_per_period: 10
      }
    end

    it 'updates files API throttle settings' do
      subject.execute

      application_settings.reload

      expect(application_settings.throttle_unauthenticated_files_api_enabled).to be_truthy
      expect(application_settings.throttle_unauthenticated_files_api_period_in_seconds).to eq(500)
      expect(application_settings.throttle_unauthenticated_files_api_requests_per_period).to eq(20)
      expect(application_settings.throttle_authenticated_files_api_enabled).to be_truthy
      expect(application_settings.throttle_authenticated_files_api_period_in_seconds).to eq(600)
      expect(application_settings.throttle_authenticated_files_api_requests_per_period).to eq(10)
    end
  end

  context 'when deprecated API rate limits are passed' do
    let(:params) do
      {
        throttle_unauthenticated_deprecated_api_enabled: 1,
        throttle_unauthenticated_deprecated_api_period_in_seconds: 500,
        throttle_unauthenticated_deprecated_api_requests_per_period: 20,
        throttle_authenticated_deprecated_api_enabled: 1,
        throttle_authenticated_deprecated_api_period_in_seconds: 600,
        throttle_authenticated_deprecated_api_requests_per_period: 10
      }
    end

    it 'updates deprecated API throttle settings' do
      subject.execute

      application_settings.reload

      expect(application_settings.throttle_unauthenticated_deprecated_api_enabled).to be_truthy
      expect(application_settings.throttle_unauthenticated_deprecated_api_period_in_seconds).to eq(500)
      expect(application_settings.throttle_unauthenticated_deprecated_api_requests_per_period).to eq(20)
      expect(application_settings.throttle_authenticated_deprecated_api_enabled).to be_truthy
      expect(application_settings.throttle_authenticated_deprecated_api_period_in_seconds).to eq(600)
      expect(application_settings.throttle_authenticated_deprecated_api_requests_per_period).to eq(10)
    end
  end

  context 'when git lfs rate limits are passed' do
    let(:params) do
      {
        throttle_authenticated_git_lfs_enabled: 1,
        throttle_authenticated_git_lfs_period_in_seconds: 600,
        throttle_authenticated_git_lfs_requests_per_period: 10
      }
    end

    it 'updates git lfs throttle settings' do
      subject.execute

      application_settings.reload

      expect(application_settings.throttle_authenticated_git_lfs_enabled).to be_truthy
      expect(application_settings.throttle_authenticated_git_lfs_period_in_seconds).to eq(600)
      expect(application_settings.throttle_authenticated_git_lfs_requests_per_period).to eq(10)
    end
  end

  context 'when issues_create_limit is passed' do
    let(:params) do
      {
        issues_create_limit: 600
      }
    end

    it 'updates issues_create_limit value' do
      subject.execute

      application_settings.reload

      expect(application_settings.issues_create_limit).to eq(600)
    end
  end

  context 'when users_get_by_id_limit and users_get_by_id_limit_allowlist_raw are passed' do
    let(:params) do
      {
        users_get_by_id_limit: 456,
        users_get_by_id_limit_allowlist_raw: 'someone, someone_else'
      }
    end

    it 'updates users_get_by_id_limit and users_get_by_id_limit_allowlist value' do
      subject.execute

      application_settings.reload

      expect(application_settings.users_get_by_id_limit).to eq(456)
      expect(application_settings.users_get_by_id_limit_allowlist).to eq(%w[someone someone_else])
    end
  end

  context 'when require_admin_approval_after_user_signup changes' do
    context 'when it goes from enabled to disabled' do
      let(:params) { { require_admin_approval_after_user_signup: false } }

      it 'calls ApproveBlockedPendingApprovalUsersWorker' do
        expect(ApproveBlockedPendingApprovalUsersWorker).to receive(:perform_async)

        subject.execute
      end
    end

    context 'when it goes from disabled to enabled' do
      let(:params) { { require_admin_approval_after_user_signup: true } }

      it 'does not call ApproveBlockedPendingApprovalUsersWorker' do
        application_settings.update!(require_admin_approval_after_user_signup: false)

        expect(ApproveBlockedPendingApprovalUsersWorker).not_to receive(:perform_async)

        subject.execute
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module BatchedGitRefUpdates
  class CleanupSchedulerService
    include Gitlab::ExclusiveLeaseHelpers
    MAX_PROJECTS = 10_000
    BATCH_SIZE = 100
    LOCK_TIMEOUT = 10.minutes

    def execute
      total_projects = 0

      in_lock(self.class.name, retries: 0, ttl: LOCK_TIMEOUT) do
        Deletion.status_pending.distinct_each_batch(column: :project_id, of: BATCH_SIZE) do |deletions|
          ProjectCleanupWorker.bulk_perform_async_with_contexts(
            deletions,
            arguments_proc: ->(deletion) { deletion.project_id },
            context_proc: ->(_) { {} } # No project context because loading the project is wasteful
          )

          total_projects += deletions.count
          break if total_projects >= MAX_PROJECTS
        end
      end

      { total_projects: total_projects }
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe BatchedGitRefUpdates::CleanupSchedulerService, feature_category: :gitaly do
  let(:service) { described_class.new }

  describe '#execute' do
    before do
      BatchedGitRefUpdates::Deletion.create!(project_id: 123, ref: 'ref1')
      BatchedGitRefUpdates::Deletion.create!(project_id: 123, ref: 'ref2')
      BatchedGitRefUpdates::Deletion.create!(project_id: 456, ref: 'ref3')
      BatchedGitRefUpdates::Deletion.create!(project_id: 789, ref: 'ref4', status: :processed)
    end

    it 'schedules ProjectCleanupWorker for each project in pending BatchedGitRefUpdates::Deletion' do
      project_ids = []
      expect(BatchedGitRefUpdates::ProjectCleanupWorker)
        .to receive(:bulk_perform_async_with_contexts) do |deletions, arguments_proc:, context_proc:| # rubocop:disable Lint/UnusedBlockArgument
        project_ids += deletions.map(&arguments_proc)
      end

      service.execute

      expect(project_ids).to contain_exactly(123, 456)
    end

    it 'returns stats' do
      stats = service.execute

      expect(stats).to eq({
        total_projects: 2
      })
    end

    it 'acquires a lock to avoid running duplicate instances' do
      expect(service).to receive(:in_lock) # Mock and don't yield
        .with(described_class.name, retries: 0, ttl: described_class::LOCK_TIMEOUT)
      expect(BatchedGitRefUpdates::ProjectCleanupWorker).not_to receive(:bulk_perform_async_with_contexts)

      service.execute
    end

    it 'limits to MAX_PROJECTS before it stops' do
      stub_const(""#{described_class}::BATCH_SIZE"", 1)
      stub_const(""#{described_class}::MAX_PROJECTS"", 1)

      stats = service.execute

      expect(stats).to eq({
        total_projects: 1
      })
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module BatchedGitRefUpdates
  class ProjectCleanupService
    include ::Gitlab::ExclusiveLeaseHelpers

    LOCK_TIMEOUT = 10.minutes
    GITALY_BATCH_SIZE = 100
    QUERY_BATCH_SIZE = 1000
    MAX_DELETES = 10_000

    def initialize(project_id)
      @project_id = project_id
    end

    def execute
      total_deletes = 0

      in_lock(""#{self.class}/#{@project_id}"", retries: 0, ttl: LOCK_TIMEOUT) do
        project = Project.find_by_id(@project_id)
        break unless project

        Deletion
          .status_pending
          .for_project(@project_id)
          .select_ref_and_identity
          .each_batch(of: QUERY_BATCH_SIZE) do |batch|
          refs = batch.map(&:ref)

          refs.each_slice(GITALY_BATCH_SIZE) do |refs_to_delete|
            project.repository.delete_refs(*refs_to_delete.uniq)
          end

          total_deletes += refs.count
          Deletion.mark_records_processed(batch)

          break if total_deletes >= MAX_DELETES
        end
      end

      { total_deletes: total_deletes }
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe BatchedGitRefUpdates::ProjectCleanupService, feature_category: :gitaly do
  let(:service) { described_class.new(project1.id) }
  let_it_be(:project1) { create(:project, :repository) }
  let_it_be(:project2) { create(:project, :repository) }
  let!(:project1_ref1) do
    BatchedGitRefUpdates::Deletion.create!(project_id: project1.id, ref: 'refs/test/project1-ref1')
  end

  let!(:project1_ref2) do
    BatchedGitRefUpdates::Deletion.create!(project_id: project1.id, ref: 'refs/test/project1-ref2')
  end

  let!(:project1_ref3) do
    BatchedGitRefUpdates::Deletion.create!(project_id: project1.id, ref: 'refs/test/already-processed',
      status: :processed)
  end

  let!(:project2_ref1) do
    BatchedGitRefUpdates::Deletion.create!(project_id: project2.id, ref: 'refs/test/project2-ref1')
  end

  describe '#execute' do
    before do
      project1.repository.create_ref('HEAD', 'refs/test/ref-to-not-be-deleted')
      project1.repository.create_ref('HEAD', project1_ref1.ref)
      project1.repository.create_ref('HEAD', project1_ref2.ref)
      project1.repository.create_ref('HEAD', 'refs/test/already-processed')
      project2.repository.create_ref('HEAD', project2_ref1.ref)
    end

    it 'deletes the named refs in batches for the given project only' do
      expect(test_refs(project1)).to include(
        'refs/test/ref-to-not-be-deleted',
        'refs/test/already-processed',
        'refs/test/project1-ref1',
        'refs/test/project1-ref1',
        'refs/test/project1-ref2')

      service.execute

      expect(test_refs(project1)).to include(
        'refs/test/already-processed',
        'refs/test/ref-to-not-be-deleted')

      expect(test_refs(project1)).not_to include(
        'refs/test/project1-ref1',
        'refs/test/project1-ref2')

      expect(test_refs(project2)).to include('refs/test/project2-ref1')
    end

    it 'handles duplicates' do
      BatchedGitRefUpdates::Deletion.create!(project_id: project1.id, ref: 'refs/test/some-duplicate')
      BatchedGitRefUpdates::Deletion.create!(project_id: project1.id, ref: 'refs/test/some-duplicate')

      service.execute

      expect(test_refs(project1)).not_to include('refs/test/some-duplicate')
    end

    it 'marks the processed BatchedGitRefUpdates::Deletion as processed' do
      service.execute

      expect(BatchedGitRefUpdates::Deletion.status_pending.map(&:ref)).to contain_exactly('refs/test/project2-ref1')
      expect(BatchedGitRefUpdates::Deletion.status_processed.map(&:ref)).to contain_exactly(
        'refs/test/project1-ref1',
        'refs/test/project1-ref2',
        'refs/test/already-processed')
    end

    it 'returns stats' do
      result = service.execute

      expect(result[:total_deletes]).to eq(2)
    end

    it 'acquires a lock for the given project_id to avoid running duplicate instances' do
      expect(service).to receive(:in_lock) # Mock and don't yield
        .with(""#{described_class}/#{project1.id}"", retries: 0, ttl: described_class::LOCK_TIMEOUT)

      expect { service.execute }.not_to change { BatchedGitRefUpdates::Deletion.status_pending.count }
    end

    it 'does nothing when the project does not exist' do
      result = described_class.new(non_existing_record_id).execute

      expect(result[:total_deletes]).to eq(0)
    end

    it 'stops after it reaches limit of deleted refs' do
      stub_const(""#{described_class}::QUERY_BATCH_SIZE"", 1)
      stub_const(""#{described_class}::MAX_DELETES"", 1)

      result = service.execute

      expect(result[:total_deletes]).to eq(1)
    end

    def test_refs(project)
      project.repository.list_refs(['refs/test/']).map(&:name)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class ProcessSyncEventsService
    include ExclusiveLeaseGuard

    BATCH_SIZE = 1000

    def initialize(sync_event_class, sync_class)
      @sync_event_class = sync_event_class
      @sync_class = sync_class
      @results = {}
    end

    def execute
      # preventing parallel processing over the same event table
      try_obtain_lease { process_events }

      enqueue_worker_if_there_still_event

      @results
    end

    private

    def process_events
      add_result(estimated_total_events: @sync_event_class.upper_bound_count)

      events = @sync_event_class.preload_synced_relation.first(BATCH_SIZE)

      add_result(consumable_events: events.size)

      return if events.empty?

      processed_events = []

      begin
        events.each do |event|
          @sync_class.sync!(event)

          processed_events << event
        end
      ensure
        add_result(processed_events: processed_events.size)
        @sync_event_class.id_in(processed_events).delete_all
      end
    end

    def enqueue_worker_if_there_still_event
      @sync_event_class.enqueue_worker if @sync_event_class.exists?
    end

    def lease_key
      ""#{super}::#{@sync_event_class}""
    end

    def lease_timeout
      1.minute
    end

    def add_result(result)
      @results.merge!(result)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::ProcessSyncEventsService, feature_category: :continuous_integration do
  let!(:group) { create(:group) }
  let!(:project1) { create(:project, group: group) }
  let!(:project2) { create(:project, group: group) }
  let!(:parent_group_1) { create(:group) }
  let!(:parent_group_2) { create(:group) }

  subject(:service) { described_class.new(sync_event_class, hierarchy_class) }

  describe '#perform' do
    subject(:execute) { service.execute }

    context 'for Projects::SyncEvent' do
      let(:sync_event_class) { Projects::SyncEvent }
      let(:hierarchy_class) { ::Ci::ProjectMirror }

      before do
        Projects::SyncEvent.delete_all

        project1.update!(group: parent_group_1)
        project2.update!(group: parent_group_2)
      end

      it { is_expected.to eq(service_results(2, 2, 2)) }

      it 'consumes events' do
        expect { execute }.to change(Projects::SyncEvent, :count).from(2).to(0)

        expect(project1.reload.ci_project_mirror).to have_attributes(
          namespace_id: parent_group_1.id
        )
        expect(project2.reload.ci_project_mirror).to have_attributes(
          namespace_id: parent_group_2.id
        )
      end

      context 'when any event left after processing' do
        before do
          stub_const(""#{described_class}::BATCH_SIZE"", 1)
        end

        it { is_expected.to eq(service_results(2, 1, 1)) }

        it 'enqueues Projects::ProcessSyncEventsWorker' do
          expect(Projects::ProcessSyncEventsWorker).to receive(:perform_async)

          execute
        end
      end

      context 'when no event left after processing' do
        before do
          stub_const(""#{described_class}::BATCH_SIZE"", 2)
        end

        it { is_expected.to eq(service_results(2, 2, 2)) }

        it 'does not enqueue Projects::ProcessSyncEventsWorker' do
          expect(Projects::ProcessSyncEventsWorker).not_to receive(:perform_async)

          execute
        end
      end

      context 'when there is no event' do
        before do
          Projects::SyncEvent.delete_all
        end

        it { is_expected.to eq(service_results(0, 0, nil)) }

        it 'does nothing' do
          expect { execute }.not_to change(Projects::SyncEvent, :count)
        end
      end

      context 'when there is non-executed events' do
        before do
          new_project = create(:project)
          sync_event_class.delete_all

          project1.update!(group: parent_group_2)
          new_project.update!(group: parent_group_1)
          project2.update!(group: parent_group_1)

          @new_project_sync_event = new_project.sync_events.last

          allow(sync_event_class).to receive(:preload_synced_relation).and_return(
            sync_event_class.where.not(id: @new_project_sync_event)
          )
        end

        it { is_expected.to eq(service_results(3, 2, 2)) }

        it 'does not delete non-executed events' do
          expect { execute }.to change(Projects::SyncEvent, :count).from(3).to(1)
          expect(@new_project_sync_event.reload).to be_persisted
        end
      end

      private

      def service_results(total, consumable, processed)
        {
          estimated_total_events: total,
          consumable_events: consumable,
          processed_events: processed
        }.compact
      end
    end

    context 'for Namespaces::SyncEvent' do
      let(:sync_event_class) { Namespaces::SyncEvent }
      let(:hierarchy_class) { ::Ci::NamespaceMirror }

      before do
        Namespaces::SyncEvent.delete_all

        # Creates a sync event for group, and the ProjectNamespace of project1 & project2: 3 in total
        group.update!(parent: parent_group_2)
        # Creates a sync event for parent_group2 and all the children: 4 in total
        parent_group_2.update!(parent: parent_group_1)
      end

      shared_examples 'event consuming' do
        it 'consumes events' do
          expect { execute }.to change(Namespaces::SyncEvent, :count).from(7).to(0)

          expect(group.reload.ci_namespace_mirror).to have_attributes(
            traversal_ids: [parent_group_1.id, parent_group_2.id, group.id]
          )
          expect(parent_group_2.reload.ci_namespace_mirror).to have_attributes(
            traversal_ids: [parent_group_1.id, parent_group_2.id]
          )
          expect(project1.reload.project_namespace).to have_attributes(
            traversal_ids: [parent_group_1.id, parent_group_2.id, group.id, project1.project_namespace.id]
          )
          expect(project2.reload.project_namespace).to have_attributes(
            traversal_ids: [parent_group_1.id, parent_group_2.id, group.id, project2.project_namespace.id]
          )
        end
      end

      it_behaves_like 'event consuming'

      it 'enqueues Namespaces::ProcessSyncEventsWorker if any left' do
        stub_const(""#{described_class}::BATCH_SIZE"", 1)

        expect(Namespaces::ProcessSyncEventsWorker).to receive(:perform_async)

        execute
      end

      it 'does not enqueue Namespaces::ProcessSyncEventsWorker if no left' do
        stub_const(""#{described_class}::BATCH_SIZE"", 7)

        expect(Namespaces::ProcessSyncEventsWorker).not_to receive(:perform_async)

        execute
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class TestFailureHistoryService
    class Async
      attr_reader :service

      def initialize(service)
        @service = service
      end

      def perform_if_needed
        TestFailureHistoryWorker.perform_async(service.pipeline.id) if service.should_track_failures?
      end
    end

    MAX_TRACKABLE_FAILURES = 200

    attr_reader :pipeline

    delegate :project, to: :pipeline

    def initialize(pipeline)
      @pipeline = pipeline
    end

    def execute
      return unless should_track_failures?

      track_failures
    end

    def should_track_failures?
      return false unless project.default_branch_or_main == pipeline.ref

      # We fetch for up to MAX_TRACKABLE_FAILURES + 1 builds. So if ever we get
      # 201 total number of builds with the assumption that each job has at least
      # 1 failed unit test, then we have at least 201 failed unit tests which exceeds
      # the MAX_TRACKABLE_FAILURES of 200. If this is the case, let's early exit so we
      # don't have to parse each JUnit report of each of the 201 builds.
      failed_builds.length <= MAX_TRACKABLE_FAILURES
    end

    def async
      Async.new(self)
    end

    private

    def failed_builds
      @failed_builds ||= pipeline.builds_with_failed_tests(limit: MAX_TRACKABLE_FAILURES + 1)
    end

    def track_failures
      failed_unit_tests = gather_failed_unit_tests_from_reports(failed_builds)

      return if failed_unit_tests.size > MAX_TRACKABLE_FAILURES

      failed_unit_tests.each_slice(100) do |batch|
        Ci::UnitTest.transaction do
          unit_test_attrs = ci_unit_test_attrs(batch)
          ci_unit_tests = Ci::UnitTest.find_or_create_by_batch(project, unit_test_attrs)

          failures = ci_unit_test_failure_attrs(ci_unit_tests, failed_unit_tests)
          Ci::UnitTestFailure.insert_all(failures)
        end
      end
    end

    def gather_failed_unit_tests_from_reports(failed_builds)
      failed_builds.each_with_object({}) do |build, failed_unit_tests|
        test_suite = generate_test_suite!(build)
        test_suite.failed.each do |key, unit_test|
          failed_unit_tests[key] = {
            build: build, # This will be used in ci_unit_test_failure_attrs
            unit_test: unit_test # This will be used in ci_unit_test_attrs
          }
        end
      end
    end

    def generate_test_suite!(build)
      test_report = build.collect_test_reports!(Gitlab::Ci::Reports::TestReport.new)
      test_report.get_suite(build.test_suite_name)
    end

    def ci_unit_test_attrs(batch)
      batch.map do |item|
        unit_test = item.last[:unit_test]

        {
          key_hash: unit_test.key,
          name: unit_test.name,
          suite_name: unit_test.suite_name
        }
      end
    end

    def ci_unit_test_failure_attrs(ci_unit_tests, failed_unit_tests)
      ci_unit_tests.map do |ci_unit_test|
        build = failed_unit_tests[ci_unit_test.key_hash][:build]

        {
          unit_test_id: ci_unit_test.id,
          build_id: build.id,
          failed_at: build.finished_at,
          partition_id: build.partition_id
        }
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::TestFailureHistoryService, :aggregate_failures, feature_category: :continuous_integration do
  let_it_be(:project) { create(:project, :repository) }

  let_it_be_with_reload(:pipeline) do
    create(:ci_pipeline, status: :created, project: project, ref: project.default_branch)
  end

  describe '#execute' do
    subject(:execute_service) { described_class.new(pipeline).execute }

    context 'when pipeline has failed builds with test reports' do
      let_it_be(:job) do
        # The test report has 2 unit test failures
        create(:ci_build, :failed, :test_reports, pipeline: pipeline)
      end

      it 'creates unit test failures records' do
        execute_service

        expect(Ci::UnitTest.count).to eq(2)
        expect(Ci::UnitTestFailure.count).to eq(2)
      end

      it 'assigns partition_id to Ci::UnitTestFailure' do
        execute_service

        unit_test_failure_partition_ids = Ci::UnitTestFailure.distinct.pluck(:partition_id)

        expect(unit_test_failure_partition_ids).to match_array([job.partition_id])
      end

      context 'when pipeline is not for the default branch' do
        before do
          pipeline.update_column(:ref, 'new-feature')
        end

        it 'does not persist data' do
          execute_service

          expect(Ci::UnitTest.count).to eq(0)
          expect(Ci::UnitTestFailure.count).to eq(0)
        end
      end

      context 'when test failure data have already been persisted with the same exact attributes' do
        before do
          execute_service
        end

        it 'does not fail but does not persist new data' do
          expect { described_class.new(pipeline).execute }.not_to raise_error

          expect(Ci::UnitTest.count).to eq(2)
          expect(Ci::UnitTestFailure.count).to eq(2)
        end
      end

      context 'when number of failed unit tests exceed the limit' do
        before do
          stub_const(""#{described_class.name}::MAX_TRACKABLE_FAILURES"", 1)
        end

        it 'does not persist data' do
          execute_service

          expect(Ci::UnitTest.count).to eq(0)
          expect(Ci::UnitTestFailure.count).to eq(0)
        end
      end

      context 'when number of failed unit tests across multiple builds exceed the limit' do
        before do
          stub_const(""#{described_class.name}::MAX_TRACKABLE_FAILURES"", 2)

          # This other test report has 1 unique unit test failure which brings us to 3 total failures across all builds
          # thus exceeding the limit of 2 for MAX_TRACKABLE_FAILURES
          create(:ci_build, :failed, :test_reports_with_duplicate_failed_test_names, pipeline: pipeline)
        end

        it 'does not persist data' do
          execute_service

          expect(Ci::UnitTest.count).to eq(0)
          expect(Ci::UnitTestFailure.count).to eq(0)
        end
      end
    end

    context 'when test failure data have duplicates within the same payload (happens when the JUnit report has duplicate unit test names but have different failures)' do
      before do
        # The test report has 2 unit test failures but with the same unit test keys
        create(:ci_build, :failed, :test_reports_with_duplicate_failed_test_names, pipeline: pipeline)
      end

      it 'does not fail but does not persist duplicate data' do
        expect { execute_service }.not_to raise_error

        expect(Ci::UnitTest.count).to eq(1)
        expect(Ci::UnitTestFailure.count).to eq(1)
      end
    end

    context 'when pipeline has no failed builds with test reports' do
      before do
        create(:ci_build, :test_reports, pipeline: pipeline)
        create(:ci_build, :failed, pipeline: pipeline)
      end

      it 'does not persist data' do
        execute_service

        expect(Ci::UnitTest.count).to eq(0)
        expect(Ci::UnitTestFailure.count).to eq(0)
      end
    end
  end

  describe '#should_track_failures?' do
    subject { described_class.new(pipeline).should_track_failures? }

    let_it_be(:jobs) do
      create_list(:ci_build, 2, :test_reports, :failed, pipeline: pipeline)
    end

    context 'when feature flag is enabled and pipeline ref is the default branch' do
      it { is_expected.to eq(true) }
    end

    context 'when pipeline is not equal to the project default branch' do
      before do
        pipeline.update_column(:ref, 'some-other-branch')
      end

      it { is_expected.to eq(false) }
    end

    context 'when total number of builds with failed tests exceeds the max number of trackable failures' do
      before do
        stub_const(""#{described_class.name}::MAX_TRACKABLE_FAILURES"", 1)
      end

      it { is_expected.to eq(false) }
    end
  end

  describe '#async' do
    let(:pipeline) { double(id: 1) }
    let(:service) { described_class.new(pipeline) }

    context 'when service should track failures' do
      before do
        allow(service).to receive(:should_track_failures?).and_return(true)
      end

      it 'enqueues the worker when #perform_if_needed is called' do
        expect(Ci::TestFailureHistoryWorker).to receive(:perform_async).with(pipeline.id)

        service.async.perform_if_needed
      end
    end

    context 'when service should not track failures' do
      before do
        allow(service).to receive(:should_track_failures?).and_return(false)
      end

      it 'does not enqueue the worker when #perform_if_needed is called' do
        expect(Ci::TestFailureHistoryWorker).not_to receive(:perform_async)

        service.async.perform_if_needed
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class UnlockPipelineService
    include BaseServiceUtility
    include ::Gitlab::ExclusiveLeaseHelpers

    ExecutionTimeoutError = Class.new(StandardError)

    BATCH_SIZE = 100
    MAX_EXEC_DURATION = 10.minutes.freeze
    LOCK_TIMEOUT = (MAX_EXEC_DURATION + 1.minute).freeze

    def initialize(pipeline)
      @pipeline = pipeline
      @already_leased = false
      @already_unlocked = false
      @exec_timeout = false
      @unlocked_job_artifacts_count = 0
      @unlocked_pipeline_artifacts_count = 0
    end

    def execute
      unlock_pipeline_exclusively

      success(
        skipped_already_leased: already_leased,
        skipped_already_unlocked: already_unlocked,
        exec_timeout: exec_timeout,
        unlocked_job_artifacts: unlocked_job_artifacts_count,
        unlocked_pipeline_artifacts: unlocked_pipeline_artifacts_count
      )
    end

    private

    attr_reader :pipeline, :already_leased, :already_unlocked, :exec_timeout,
      :unlocked_job_artifacts_count, :unlocked_pipeline_artifacts_count

    def unlock_pipeline_exclusively
      in_lock(lock_key, ttl: LOCK_TIMEOUT, retries: 0) do
        # Even though we enforce uniqueness when enqueueing pipelines, there is still a rare race condition chance that
        # a pipeline can be re-enqueued right after a worker pops off the same pipeline ID from the queue, and then just
        # after it completing the unlock process and releasing the lock, another worker picks up the re-enqueued
        # pipeline ID. So let's make sure to only unlock artifacts if the pipeline has not been unlocked.
        if pipeline.unlocked?
          @already_unlocked = true
          break
        end

        unlock_job_artifacts
        unlock_pipeline_artifacts

        # Marking the row in `ci_pipelines` to unlocked signifies that all artifacts have
        # already been unlocked. This must always happen last.
        unlock_pipeline
      end
    rescue ExecutionTimeoutError
      @exec_timeout = true
    rescue Gitlab::ExclusiveLeaseHelpers::FailedToObtainLockError
      @already_leased = true
    ensure
      if pipeline.unlocked?
        Ci::UnlockPipelineRequest.log_event(:completed, pipeline.id) unless already_unlocked
      else
        # This is to ensure to re-enqueue the pipeline in 2 occasions:
        # 1. When an unexpected error happens.
        # 2. When the execution timeout has been reached in the case of a pipeline having a lot of
        #    job artifacts. This allows us to continue unlocking the rest of the artifacts from
        #    where we left off. This is why we unlock the pipeline last.
        Ci::UnlockPipelineRequest.enqueue(pipeline.id)
        Ci::UnlockPipelineRequest.log_event(:re_enqueued, pipeline.id)
      end
    end

    def lock_key
      ""ci:unlock_pipeline_service:lock:#{pipeline.id}""
    end

    def unlock_pipeline
      pipeline.update_column(:locked, Ci::Pipeline.lockeds[:unlocked])
    end

    def unlock_job_artifacts
      start = Time.current

      pipeline.builds.each_batch(of: BATCH_SIZE) do |builds|
        # rubocop: disable CodeReuse/ActiveRecord
        Ci::JobArtifact.where(job_id: builds.pluck(:id)).each_batch(of: BATCH_SIZE) do |job_artifacts|
          unlocked_count = Ci::JobArtifact
            .where(id: job_artifacts.pluck(:id))
            .update_all(locked: :unlocked)

          @unlocked_job_artifacts_count ||= 0
          @unlocked_job_artifacts_count += unlocked_count

          raise ExecutionTimeoutError if (Time.current - start) > MAX_EXEC_DURATION
        end
        # rubocop: enable CodeReuse/ActiveRecord
      end
    end

    def unlock_pipeline_artifacts
      @unlocked_pipeline_artifacts_count = pipeline.pipeline_artifacts.update_all(locked: :unlocked)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::UnlockPipelineService, :unlock_pipelines, :clean_gitlab_redis_shared_state, feature_category: :build_artifacts do
  describe '#execute', :aggregate_failures do
    let(:service) { described_class.new(pipeline) }

    let!(:pipeline) do
      create(
        :ci_pipeline,
        :with_coverage_report_artifact,
        :with_codequality_mr_diff_report,
        :with_persisted_artifacts,
        locked: :artifacts_locked
      )
    end

    subject(:execute) { service.execute }

    context 'when pipeline is not yet exclusively leased' do
      before do
        stub_const(""#{described_class}::BATCH_SIZE"", 1)
      end

      it 'unlocks the pipeline and all its artifacts' do
        expect { execute }
          .to change { pipeline.reload.locked }.from('artifacts_locked').to('unlocked')
          .and change { pipeline.reload.job_artifacts.all?(&:artifact_unlocked?) }.to(true)
          .and change { pipeline.reload.pipeline_artifacts.all?(&:artifact_unlocked?) }.to(true)

        expect(execute).to eq(
          status: :success,
          skipped_already_leased: false,
          skipped_already_unlocked: false,
          exec_timeout: false,
          unlocked_job_artifacts: pipeline.job_artifacts.count,
          unlocked_pipeline_artifacts: pipeline.pipeline_artifacts.count
        )
      end

      context 'and pipeline is already unlocked' do
        before do
          described_class.new(pipeline).execute
        end

        it 'skips the pipeline' do
          expect(Ci::JobArtifact).not_to receive(:where)

          expect(execute).to eq(
            status: :success,
            skipped_already_leased: false,
            skipped_already_unlocked: true,
            exec_timeout: false,
            unlocked_job_artifacts: 0,
            unlocked_pipeline_artifacts: 0
          )
        end
      end

      context 'and max execution duration was reached' do
        let!(:first_artifact) { pipeline.job_artifacts.order(:id).first }
        let!(:last_artifact) { pipeline.job_artifacts.order(:id).last }

        before do
          stub_const(""#{described_class}::MAX_EXEC_DURATION"", 0.seconds)
        end

        it 'keeps the unlocked state of job artifacts already processed and re-enqueues the pipeline' do
          expect { execute }
            .to change { first_artifact.reload.artifact_unlocked? }.to(true)
            .and not_change { last_artifact.reload.artifact_unlocked? }
            .and not_change { pipeline.reload.locked }
            .and not_change { pipeline.reload.pipeline_artifacts.all?(&:artifact_unlocked?) }
            .and change { pipeline_ids_waiting_to_be_unlocked }.from([]).to([pipeline.id])

          expect(execute).to eq(
            status: :success,
            skipped_already_leased: false,
            skipped_already_unlocked: false,
            exec_timeout: true,
            unlocked_job_artifacts: 1,
            unlocked_pipeline_artifacts: 0
          )
        end
      end

      context 'and an error happened' do
        context 'and was raised in the middle batches of job artifacts being unlocked' do
          let!(:first_artifact) { pipeline.job_artifacts.order(:id).first }
          let!(:last_artifact) { pipeline.job_artifacts.order(:id).last }

          before do
            mock_relation = instance_double('Ci::JobArtifact::ActiveRecord_Relation')
            allow(Ci::JobArtifact).to receive(:where).and_call_original
            allow(Ci::JobArtifact).to receive(:where).with(id: [last_artifact.id]).and_return(mock_relation)
            allow(mock_relation).to receive(:update_all).and_raise('An error')
          end

          it 'keeps the unlocked state of job artifacts already processed and re-enqueues the pipeline' do
            expect { execute }
              .to raise_error('An error')
              .and change { first_artifact.reload.artifact_unlocked? }.to(true)
              .and not_change { last_artifact.reload.artifact_unlocked? }
              .and not_change { pipeline.reload.locked }
              .and not_change { pipeline.reload.pipeline_artifacts.all?(&:artifact_unlocked?) }
              .and change { pipeline_ids_waiting_to_be_unlocked }.from([]).to([pipeline.id])
          end
        end

        context 'and was raised while unlocking pipeline artifacts' do
          before do
            allow(pipeline).to receive_message_chain(:pipeline_artifacts, :update_all).and_raise('An error')
          end

          it 'keeps the unlocked state of job artifacts and re-enqueues the pipeline' do
            expect { execute }
              .to raise_error('An error')
              .and change { pipeline.reload.job_artifacts.all?(&:artifact_unlocked?) }.to(true)
              .and not_change { Ci::PipelineArtifact.where(pipeline_id: pipeline.id).all?(&:artifact_unlocked?) }
              .and not_change { pipeline.reload.locked }.from('artifacts_locked')
              .and change { pipeline_ids_waiting_to_be_unlocked }.from([]).to([pipeline.id])
          end
        end

        context 'and was raised while unlocking pipeline' do
          before do
            allow(pipeline).to receive(:update_column).and_raise('An error')
          end

          it 'keeps the unlocked state of job artifacts and pipeline artifacts and re-enqueues the pipeline' do
            expect { execute }
              .to raise_error('An error')
              .and change { pipeline.reload.job_artifacts.all?(&:artifact_unlocked?) }.to(true)
              .and change { pipeline.reload.pipeline_artifacts.all?(&:artifact_unlocked?) }.to(true)
              .and not_change { pipeline.reload.locked }.from('artifacts_locked')
              .and change { pipeline_ids_waiting_to_be_unlocked }.from([]).to([pipeline.id])
          end
        end
      end
    end

    context 'when pipeline is already exclusively leased' do
      before do
        allow(service).to receive(:in_lock).and_raise(Gitlab::ExclusiveLeaseHelpers::FailedToObtainLockError)
      end

      it 'does nothing and returns success' do
        expect { execute }.not_to change { pipeline.reload.locked }

        expect(execute).to include(
          status: :success,
          skipped_already_leased: true,
          unlocked_job_artifacts: 0,
          unlocked_pipeline_artifacts: 0
        )
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class ExpirePipelineCacheService
    class UrlHelpers
      include ::Gitlab::Routing
      include ::GitlabRoutingHelper
    end

    def execute(pipeline, delete: false)
      store = Gitlab::EtagCaching::Store.new

      update_etag_cache(pipeline, store)

      if delete
        Gitlab::Cache::Ci::ProjectPipelineStatus.new(pipeline.project).delete_from_cache
      else
        Gitlab::Cache::Ci::ProjectPipelineStatus.update_for_pipeline(pipeline)
      end
    end

    private

    def project_pipelines_path(project)
      url_helpers.project_pipelines_path(project, format: :json)
    end

    def project_pipeline_path(project, pipeline)
      url_helpers.project_pipeline_path(project, pipeline, format: :json)
    end

    def commit_pipelines_path(project, commit)
      url_helpers.pipelines_project_commit_path(project, commit.id, format: :json)
    end

    def new_merge_request_pipelines_path(project)
      url_helpers.project_new_merge_request_path(project, format: :json)
    end

    def pipelines_project_merge_request_path(merge_request)
      url_helpers.pipelines_project_merge_request_path(merge_request.target_project, merge_request, format: :json)
    end

    def merge_request_widget_path(merge_request)
      url_helpers.cached_widget_project_json_merge_request_path(merge_request.project, merge_request, format: :json)
    end

    def each_pipelines_merge_request_path(pipeline)
      pipeline.all_merge_requests.each do |merge_request|
        yield(pipelines_project_merge_request_path(merge_request))
        yield(merge_request_widget_path(merge_request))
      end
    end

    def graphql_pipeline_path(pipeline)
      url_helpers.graphql_etag_pipeline_path(pipeline)
    end

    def graphql_pipeline_sha_path(sha)
      url_helpers.graphql_etag_pipeline_sha_path(sha)
    end

    def graphql_project_on_demand_scan_counts_path(project)
      url_helpers.graphql_etag_project_on_demand_scan_counts_path(project)
    end

    # Updates ETag caches of a pipeline.
    #
    # This logic resides in a separate method so that EE can more easily extend
    # it.
    #
    # @param [Ci::Pipeline] pipeline
    # @param [Gitlab::EtagCaching::Store] store
    def update_etag_cache(pipeline, store)
      project = pipeline.project

      etag_paths = [
        project_pipelines_path(project),
        new_merge_request_pipelines_path(project),
        graphql_project_on_demand_scan_counts_path(project)
      ]

      etag_paths << commit_pipelines_path(project, pipeline.commit) unless pipeline.commit.nil?

      each_pipelines_merge_request_path(pipeline) do |path|
        etag_paths << path
      end

      pipeline.upstream_and_all_downstreams.includes(project: [:route, { namespace: :route }]).each do |relative_pipeline| # rubocop: disable CodeReuse/ActiveRecord
        etag_paths << project_pipeline_path(relative_pipeline.project, relative_pipeline)
        etag_paths << graphql_pipeline_path(relative_pipeline)
        etag_paths << graphql_pipeline_sha_path(relative_pipeline.sha)
      end

      store.touch(*etag_paths)
    end

    def url_helpers
      @url_helpers ||= UrlHelpers.new
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::ExpirePipelineCacheService, feature_category: :continuous_integration do
  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project) }
  let_it_be(:pipeline) { create(:ci_pipeline, project: project) }

  subject { described_class.new }

  describe '#execute' do
    it 'invalidates Etag caching for project pipelines path' do
      pipelines_path = ""/#{project.full_path}/-/pipelines.json""
      new_mr_pipelines_path = ""/#{project.full_path}/-/merge_requests/new.json""
      pipeline_path = ""/#{project.full_path}/-/pipelines/#{pipeline.id}.json""
      graphql_pipeline_path = ""/api/graphql:pipelines/id/#{pipeline.id}""
      graphql_pipeline_sha_path = ""/api/graphql:pipelines/sha/#{pipeline.sha}""
      graphql_project_on_demand_scan_counts_path = ""/api/graphql:on_demand_scan/counts/#{project.full_path}""

      expect_touched_etag_caching_paths(
        pipelines_path,
        new_mr_pipelines_path,
        pipeline_path,
        graphql_pipeline_path,
        graphql_pipeline_sha_path,
        graphql_project_on_demand_scan_counts_path
      )

      subject.execute(pipeline)
    end

    it 'invalidates Etag caching for merge request pipelines if pipeline runs on any commit of that source branch' do
      merge_request = create(:merge_request, :with_detached_merge_request_pipeline)
      project = merge_request.target_project

      merge_request_pipelines_path = ""/#{project.full_path}/-/merge_requests/#{merge_request.iid}/pipelines.json""
      merge_request_widget_path = ""/#{project.full_path}/-/merge_requests/#{merge_request.iid}/cached_widget.json""

      expect_touched_etag_caching_paths(
        merge_request_pipelines_path,
        merge_request_widget_path
      )

      subject.execute(merge_request.all_pipelines.last)
    end

    it 'updates the cached status for a project' do
      expect(Gitlab::Cache::Ci::ProjectPipelineStatus).to receive(:update_for_pipeline).with(pipeline)

      subject.execute(pipeline)
    end

    context 'destroyed pipeline' do
      let(:project_with_repo) { create(:project, :repository) }
      let!(:pipeline_with_commit) { create(:ci_pipeline, :success, project: project_with_repo, sha: project_with_repo.commit.id) }

      it 'clears the cache', :use_clean_rails_redis_caching do
        create(:commit_status, :success, pipeline: pipeline_with_commit, ref: pipeline_with_commit.ref)

        # Sanity check
        expect(project_with_repo.pipeline_status.has_status?).to be_truthy

        subject.execute(pipeline_with_commit, delete: true)

        pipeline_with_commit.destroy!

        # We need to reset lazy_latest_pipeline cache to simulate a new request
        BatchLoader::Executor.clear_current

        # Need to use find to avoid memoization
        expect(Project.find(project_with_repo.id).pipeline_status.has_status?).to be_falsey
      end
    end

    context 'when the pipeline is triggered by another pipeline' do
      let(:source) { create(:ci_sources_pipeline, pipeline: pipeline) }

      it 'updates the cache of dependent pipeline' do
        dependent_pipeline_path = ""/#{source.source_project.full_path}/-/pipelines/#{source.source_pipeline.id}.json""

        expect_touched_etag_caching_paths(dependent_pipeline_path)

        subject.execute(pipeline)
      end
    end

    context 'when the pipeline triggered another pipeline' do
      let(:build) { create(:ci_build, pipeline: pipeline) }
      let(:source) { create(:ci_sources_pipeline, source_job: build) }

      it 'updates the cache of dependent pipeline' do
        dependent_pipeline_path = ""/#{source.project.full_path}/-/pipelines/#{source.pipeline.id}.json""

        expect_touched_etag_caching_paths(dependent_pipeline_path)

        subject.execute(pipeline)
      end
    end

    it 'does not do N+1 queries' do
      subject.execute(pipeline)

      control = ActiveRecord::QueryRecorder.new { subject.execute(pipeline) }

      create(:ci_sources_pipeline, pipeline: pipeline)
      create(:ci_sources_pipeline, source_job: create(:ci_build, pipeline: pipeline))

      expect { subject.execute(pipeline) }.not_to exceed_query_limit(control.count)
    end
  end

  def expect_touched_etag_caching_paths(*paths)
    expect_next_instance_of(Gitlab::EtagCaching::Store) do |store|
      expect(store).to receive(:touch).and_wrap_original do |m, *args|
        expect(args).to include(*paths)

        m.call(*args)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# This service tracks failed CI builds using Snowplow.
#
# @param build [Ci::Build] the build that failed.
# @param exit_code [Int] the resulting exit code.
module Ci
  class TrackFailedBuildService
    SCHEMA_URL = 'iglu:com.gitlab/ci_build_failed/jsonschema/1-0-2'

    def initialize(build:, exit_code:, failure_reason:)
      @build = build
      @exit_code = exit_code
      @failure_reason = failure_reason
    end

    def execute
      # rubocop:disable Style/IfUnlessModifier
      unless @build.failed?
        return ServiceResponse.error(message: 'Attempted to track a non-failed CI build')
      end

      # rubocop:enable Style/IfUnlessModifier

      context = SnowplowTracker::SelfDescribingJson.new(SCHEMA_URL, payload)

      ::Gitlab::Tracking.event(
        'ci::build',
        'failed',
        context: [context],
        user: @build.user,
        project: @build.project_id)

      ServiceResponse.success
    end

    private

    def payload
      {
        build_id: @build.id,
        build_name: @build.name,
        build_artifact_types: @build.job_artifact_types,
        exit_code: @exit_code,
        failure_reason: @failure_reason,
        project: @build.project_id
      }
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::TrackFailedBuildService, feature_category: :continuous_integration do
  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project, :public) }
  let_it_be(:pipeline) { create(:ci_pipeline, project: project, user: user) }

  let_it_be(:exit_code) { 42 }
  let_it_be(:failure_reason) { ""script_failure"" }

  describe '#execute' do
    context 'when a build has failed' do
      let_it_be(:build) { create(:ci_build, :failed, :sast_report, pipeline: pipeline, user: user) }

      subject { described_class.new(build: build, exit_code: exit_code, failure_reason: failure_reason) }

      it 'tracks the build failed event', :snowplow do
        response = subject.execute

        expect(response.success?).to be true

        context = {
          schema: described_class::SCHEMA_URL,
          data: {
            build_id: build.id,
            build_name: build.name,
            build_artifact_types: [""sast""],
            exit_code: exit_code,
            failure_reason: failure_reason,
            project: project.id
          }
        }

        expect_snowplow_event(
          category: 'ci::build',
          action: 'failed',
          context: [context],
          user: user,
          project: project.id)
      end
    end

    context 'when a build has not failed' do
      let_it_be(:build) { create(:ci_build, :success, :sast_report, pipeline: pipeline, user: user) }

      subject { described_class.new(build: build, exit_code: nil, failure_reason: nil) }

      it 'does not track the build failed event', :snowplow do
        response = subject.execute

        expect(response.error?).to be true

        expect_no_snowplow_event
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class ChangeVariablesService < BaseContainerService
    def execute
      container.update(params)
    end
  end
end

::Ci::ChangeVariablesService.prepend_mod_with('Ci::ChangeVariablesService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::ChangeVariablesService, feature_category: :secrets_management do
  let(:service) { described_class.new(container: group, current_user: user, params: params) }

  let_it_be(:user) { create(:user) }

  let(:group) { spy(:group, variables: []) }
  let(:params) { { variables_attributes: [{ key: 'new_variable', value: 'variable_value' }] } }

  describe '#execute' do
    subject(:execute) { service.execute }

    it 'delegates to ActiveRecord update' do
      execute

      expect(group).to have_received(:update).with(params)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class RetryJobService < ::BaseService
    include Gitlab::Utils::StrongMemoize

    def execute(job, variables: [])
      if job.retryable?
        job.ensure_scheduling_type!
        new_job = retry_job(job, variables: variables)

        ServiceResponse.success(payload: { job: new_job })
      else
        ServiceResponse.error(
          message: 'Job cannot be retried',
          payload: { job: job, reason: :not_retryable }
        )
      end
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def clone!(job, variables: [], enqueue_if_actionable: false, start_pipeline: false)
      # Cloning a job requires a strict type check to ensure
      # the attributes being used for the clone are taken straight
      # from the model and not overridden by other abstractions.
      raise TypeError unless job.instance_of?(Ci::Build) || job.instance_of?(Ci::Bridge)

      check_access!(job)

      new_job = job.clone(current_user: current_user, new_job_variables_attributes: variables)
      if enqueue_if_actionable && new_job.action?
        new_job.set_enqueue_immediately!
      end

      start_pipeline_proc = -> { start_pipeline(job, new_job) } if start_pipeline

      new_job.run_after_commit do
        start_pipeline_proc&.call

        ::Ci::CopyCrossDatabaseAssociationsService.new.execute(job, new_job)

        ::MergeRequests::AddTodoWhenBuildFailsService
          .new(project: project)
          .close(new_job)
      end

      ::Ci::Pipelines::AddJobService.new(job.pipeline).execute!(new_job) do |processable|
        BulkInsertableAssociations.with_bulk_insert do
          processable.save!
        end
      end

      job.reset # refresh the data to get new values of `retried` and `processed`.

      new_job
    end
    # rubocop: enable CodeReuse/ActiveRecord

    private

    def check_assignable_runners!(job); end

    def retry_job(job, variables: [])
      clone!(job, variables: variables, enqueue_if_actionable: true, start_pipeline: true).tap do |new_job|
        check_assignable_runners!(new_job) if new_job.is_a?(Ci::Build)

        next if new_job.failed?

        ResetSkippedJobsService.new(project, current_user).execute(job)
      end
    end

    def check_access!(job)
      unless can?(current_user, :update_build, job)
        raise Gitlab::Access::AccessDeniedError, '403 Forbidden'
      end
    end

    def start_pipeline(job, new_job)
      Ci::PipelineCreation::StartPipelineService.new(job.pipeline).execute
      new_job.reset
    end
  end
end

Ci::RetryJobService.prepend_mod_with('Ci::RetryJobService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::RetryJobService, feature_category: :continuous_integration do
  using RSpec::Parameterized::TableSyntax
  let_it_be(:reporter) { create(:user) }
  let_it_be(:developer) { create(:user) }
  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:pipeline) do
    create(:ci_pipeline, project: project, sha: 'b83d6e391c22777fca1ed3012fce84f633d7fed0')
  end

  let_it_be(:stage) do
    create(:ci_stage, pipeline: pipeline, name: 'test')
  end

  let_it_be(:deploy_stage) { create(:ci_stage, pipeline: pipeline, name: 'deploy', position: stage.position + 1) }

  let(:job_variables_attributes) { [{ key: 'MANUAL_VAR', value: 'manual test var' }] }
  let(:user) { developer }

  let(:service) { described_class.new(project, user) }

  before_all do
    project.add_developer(developer)
    project.add_reporter(reporter)
  end

  shared_context 'retryable bridge' do
    let_it_be(:downstream_project) { create(:project, :repository) }

    let_it_be_with_refind(:job) do
      create(:ci_bridge, :success,
        pipeline: pipeline, downstream: downstream_project, description: 'a trigger job', ci_stage: stage
      )
    end

    let_it_be(:job_to_clone) { job }

    before do
      job.update!(retried: false)
    end
  end

  shared_context 'retryable build' do
    let_it_be_with_reload(:job) do
      create(:ci_build, :success, pipeline: pipeline, ci_stage: stage)
    end

    let_it_be(:another_pipeline) { create(:ci_empty_pipeline, project: project) }

    let_it_be(:job_to_clone) do
      create(
        :ci_build, :failed, :picked, :expired, :erased, :queued, :coverage, :tags,
        :allowed_to_fail, :on_tag, :triggered, :teardown_environment, :resource_group,
        description: 'my-job', ci_stage: stage,
        pipeline: pipeline, auto_canceled_by: another_pipeline,
        scheduled_at: 10.seconds.since
      )
    end

    before do
      job.update!(retried: false, status: :success)
      job_to_clone.update!(retried: false, status: :success)
    end
  end

  shared_examples_for 'clones the job' do
    let(:job) { job_to_clone }

    before_all do
      job_to_clone.update!(ci_stage: stage)

      create(:ci_build_need, build: job_to_clone)
    end

    context 'when the user has ability to execute job' do
      before do
        stub_not_protect_default_branch
      end

      context 'when there is a failed job ToDo for the MR' do
        let!(:merge_request) { create(:merge_request, source_project: project, author: user, head_pipeline: pipeline) }
        let!(:todo) { create(:todo, :build_failed, user: user, project: project, author: user, target: merge_request) }

        it 'resolves the ToDo for the failed job' do
          expect do
            service.execute(job)
          end.to change { todo.reload.state }.from('pending').to('done')
        end
      end

      context 'when the job has needs' do
        before do
          create_list(:ci_build_need, 2, build: job)
        end

        it 'bulk inserts all the needs' do
          expect(Ci::BuildNeed).to receive(:bulk_insert!).and_call_original

          new_job
        end
      end

      it 'marks the old job as retried' do
        expect(new_job).to be_latest
        expect(job).to be_retried
        expect(job).to be_processed
      end
    end

    context 'when the user does not have permission to execute the job' do
      let(:user) { reporter }

      it 'raises an error' do
        expect { service.execute(job) }
          .to raise_error Gitlab::Access::AccessDeniedError
      end
    end
  end

  shared_examples_for 'does not retry the job' do
    it 'returns :not_retryable and :unprocessable_entity' do
      expect(subject.message).to be('Job cannot be retried')
      expect(subject.payload[:reason]).to eq(:not_retryable)
      expect(subject.payload[:job]).to eq(job)
    end
  end

  shared_examples_for 'retries the job' do
    it_behaves_like 'clones the job'

    it 'enqueues the new job' do
      expect(new_job).to be_pending
    end

    context 'when there are subsequent processables that are skipped' do
      let!(:subsequent_build) do
        create(:ci_build, :skipped, pipeline: pipeline, ci_stage: deploy_stage)
      end

      let!(:subsequent_bridge) do
        create(:ci_bridge, :skipped, pipeline: pipeline, ci_stage: deploy_stage)
      end

      it 'resumes pipeline processing in the subsequent stage' do
        service.execute(job)

        expect(subsequent_build.reload).to be_created
        expect(subsequent_bridge.reload).to be_created
      end

      it 'updates ownership for subsequent builds' do
        expect { service.execute(job) }.to change { subsequent_build.reload.user }.to(user)
      end

      it 'updates ownership for subsequent bridges' do
        expect { service.execute(job) }.to change { subsequent_bridge.reload.user }.to(user)
      end
    end

    context 'when the pipeline has other jobs' do
      let!(:other_test_build) { create(:ci_build, pipeline: pipeline, ci_stage: stage) }
      let!(:deploy) { create(:ci_build, pipeline: pipeline, ci_stage: deploy_stage) }
      let!(:deploy_needs_build2) { create(:ci_build_need, build: deploy, name: other_test_build.name) }

      context 'when job has a nil scheduling_type' do
        before do
          job.pipeline.processables.update_all(scheduling_type: nil)
          job.reload
        end

        it 'populates scheduling_type of processables' do
          expect(new_job.scheduling_type).to eq('stage')
          expect(job.reload.scheduling_type).to eq('stage')
          expect(other_test_build.reload.scheduling_type).to eq('stage')
          expect(deploy.reload.scheduling_type).to eq('dag')
        end
      end

      context 'when job has scheduling_type' do
        it 'does not call populate_scheduling_type!' do
          expect(job.pipeline).not_to receive(:ensure_scheduling_type!)

          expect(new_job.scheduling_type).to eq('stage')
        end
      end
    end

    context 'when the pipeline is a child pipeline and the bridge uses strategy:depend' do
      let!(:parent_pipeline) { create(:ci_pipeline, project: project) }
      let!(:bridge) { create(:ci_bridge, :strategy_depend, pipeline: parent_pipeline, status: 'success') }
      let!(:source_pipeline) { create(:ci_sources_pipeline, pipeline: pipeline, source_job: bridge) }

      it 'marks the source bridge as pending' do
        service.execute(job)

        expect(bridge.reload).to be_pending
      end
    end
  end

  shared_examples_for 'checks enqueue_immediately?' do
    it ""returns enqueue_immediately"" do
      subject
      expect(new_job.enqueue_immediately?).to eq enqueue_immediately
    end
  end

  shared_examples_for 'creates associations for a deployable job' do |factory_type|
    context 'when a job with a deployment is retried' do
      let!(:job) do
        create(factory_type, :with_deployment, :deploy_to_production, pipeline: pipeline, ci_stage: stage)
      end

      it 'creates a new deployment' do
        expect { new_job }.to change { Deployment.count }.by(1)
      end

      it 'does not create a new environment' do
        expect { new_job }.not_to change { Environment.count }
      end
    end

    context 'when a job with a dynamic environment is retried' do
      let_it_be(:other_developer) { create(:user).tap { |u| project.add_developer(u) } }

      let(:environment_name) { 'review/$CI_COMMIT_REF_SLUG-$GITLAB_USER_ID' }

      let!(:job) do
        create(factory_type, :with_deployment,
          environment: environment_name,
          options: { environment: { name: environment_name } },
          pipeline: pipeline,
          ci_stage: stage,
          user: other_developer)
      end

      it 'creates a new deployment' do
        expect { new_job }.to change { Deployment.count }.by(1)
      end

      it 'does not create a new environment' do
        expect { new_job }.not_to change { Environment.count }
      end
    end
  end

  describe '#clone!' do
    let(:start_pipeline_on_clone) { false }
    let(:new_job) { service.clone!(job, start_pipeline: start_pipeline_on_clone) }

    it 'raises an error when an unexpected class is passed' do
      expect { service.clone!(create(:ci_build).present) }.to raise_error(TypeError)
    end

    context 'when the job to be cloned is a bridge' do
      include_context 'retryable bridge'

      it_behaves_like 'clones the job'

      it 'does not create a new deployment' do
        expect { new_job }.not_to change { Deployment.count }
      end

      context 'when the pipeline is started automatically' do
        let(:start_pipeline_on_clone) { true }

        it_behaves_like 'creates associations for a deployable job', :ci_bridge
      end

      context 'when given variables' do
        let(:new_job) { service.clone!(job, variables: job_variables_attributes) }

        it 'does not give variables to the new bridge' do
          expect { new_job }.not_to raise_error
        end
      end
    end

    context 'when the job to be cloned is a build' do
      include_context 'retryable build'

      it_behaves_like 'clones the job'

      it 'does not create a new deployment' do
        expect { new_job }.not_to change { Deployment.count }
      end

      context 'when the pipeline is started automatically' do
        let(:start_pipeline_on_clone) { true }

        it_behaves_like 'creates associations for a deployable job', :ci_build
      end

      context 'when given variables' do
        let(:new_job) { service.clone!(job, variables: job_variables_attributes) }

        context 'when the build is actionable' do
          let_it_be_with_refind(:job) { create(:ci_build, :actionable, pipeline: pipeline) }

          it 'gives variables to the new build' do
            expect(new_job.job_variables.count).to be(1)
            expect(new_job.job_variables.first.key).to eq('MANUAL_VAR')
            expect(new_job.job_variables.first.value).to eq('manual test var')
          end
        end

        context 'when the build is not actionable' do
          let_it_be_with_refind(:job) { create(:ci_build, pipeline: pipeline) }

          it 'does not give variables to the new build' do
            expect(new_job.job_variables.count).to be_zero
          end
        end
      end
    end

    context 'when enqueue_if_actionable is provided' do
      let!(:job) do
        create(:ci_build, *[trait].compact, :failed, pipeline: pipeline, ci_stage: stage)
      end

      let(:new_job) { subject }

      subject { service.clone!(job, enqueue_if_actionable: enqueue_if_actionable) }

      where(:enqueue_if_actionable, :trait, :enqueue_immediately) do
        true  | nil                | false
        true  | :manual            | true
        true  | :expired_scheduled | true

        false | nil                | false
        false | :manual            | false
        false | :expired_scheduled | false
      end

      with_them do
        it_behaves_like 'checks enqueue_immediately?'
      end
    end
  end

  describe '#execute' do
    let(:new_job) { subject[:job] }

    subject { service.execute(job) }

    context 'when the job to be retried is a bridge' do
      context 'and it is not retryable' do
        let_it_be(:job) { create(:ci_bridge, :failed, :reached_max_descendant_pipelines_depth) }

        it_behaves_like 'does not retry the job'
      end

      include_context 'retryable bridge'

      it_behaves_like 'retries the job'

      context 'when given variables' do
        let(:new_job) { service.clone!(job, variables: job_variables_attributes) }

        it 'does not give variables to the new bridge' do
          expect { new_job }.not_to raise_error
        end
      end
    end

    context 'when the job to be retried is a build' do
      context 'and it is not retryable' do
        let_it_be(:job) { create(:ci_build, :deployment_rejected, pipeline: pipeline) }

        it_behaves_like 'does not retry the job'
      end

      include_context 'retryable build'

      it_behaves_like 'retries the job'

      context 'automatic retryable build' do
        let!(:auto_retryable_build) do
          create(:ci_build, pipeline: pipeline, ci_stage: stage, user: user, options: { retry: 1 })
        end

        def drop_build!
          auto_retryable_build.drop_with_exit_code!('test failure', 1)
        end

        it 'creates a new build and enqueues BuildQueueWorker' do
          expect { drop_build! }.to change { Ci::Build.count }.by(1)
                                .and change { BuildQueueWorker.jobs.count }.by(1)
        end
      end

      context 'when there are subsequent jobs that are skipped' do
        let!(:subsequent_build) do
          create(:ci_build, :skipped, pipeline: pipeline, ci_stage: deploy_stage)
        end

        let!(:subsequent_bridge) do
          create(:ci_bridge, :skipped, pipeline: pipeline, ci_stage: deploy_stage)
        end

        it 'does not cause an N+1 when updating the job ownership' do
          control_count = ActiveRecord::QueryRecorder.new(skip_cached: false) { service.execute(job) }.count

          create_list(:ci_build, 2, :skipped, pipeline: pipeline, ci_stage: deploy_stage)

          expect { service.execute(job) }.not_to exceed_all_query_limit(control_count)
        end
      end

      context 'when given variables' do
        let(:new_job) { service.clone!(job, variables: job_variables_attributes) }

        context 'when the build is actionable' do
          let_it_be_with_refind(:job) { create(:ci_build, :actionable, pipeline: pipeline) }

          it 'gives variables to the new build' do
            expect(new_job.job_variables.count).to be(1)
            expect(new_job.job_variables.first.key).to eq('MANUAL_VAR')
            expect(new_job.job_variables.first.value).to eq('manual test var')
          end
        end

        context 'when the build is not actionable' do
          let_it_be_with_refind(:job) { create(:ci_build, pipeline: pipeline) }

          it 'does not give variables to the new build' do
            expect(new_job.job_variables.count).to be_zero
          end
        end
      end
    end

    context 'when job being retried has jobs in previous stages' do
      let!(:job) do
        create(
          :ci_build,
          :failed,
          name: 'deploy_a',
          pipeline: pipeline,
          ci_stage: deploy_stage
        )
      end

      before do
        create(
          :ci_build,
          previous_stage_job_status,
          name: 'test_a',
          pipeline: pipeline,
          ci_stage: stage
        )
      end

      where(:previous_stage_job_status, :after_status) do
        :created   | 'created'
        :pending   | 'created'
        :running   | 'created'
        :manual    | 'created'
        :scheduled | 'created'
        :success   | 'pending'
        :failed    | 'skipped'
        :skipped   | 'pending'
      end

      with_them do
        it 'updates the new job status to after_status' do
          expect(subject).to be_success
          expect(new_job.status).to eq after_status
        end
      end
    end

    context 'when job being retried has DAG dependencies' do
      let!(:job) do
        create(
          :ci_build,
          :failed,
          :dependent,
          name: 'deploy_a',
          pipeline: pipeline,
          ci_stage: deploy_stage,
          needed: dependency
        )
      end

      let(:dependency) do
        create(
          :ci_build,
          dag_dependency_status,
          name: 'test_a',
          pipeline: pipeline,
          ci_stage: stage
        )
      end

      where(:dag_dependency_status, :after_status) do
        :created   | 'created'
        :pending   | 'created'
        :running   | 'created'
        :manual    | 'created'
        :scheduled | 'created'
        :success   | 'pending'
        :failed    | 'skipped'
        :skipped   | 'skipped'
      end

      with_them do
        it 'updates the new job status to after_status' do
          expect(subject).to be_success
          expect(new_job.status).to eq after_status
        end
      end
    end

    context 'when there are other manual/scheduled jobs' do
      let_it_be(:test_manual_build) do
        create(:ci_build, :manual, pipeline: pipeline, ci_stage: stage)
      end

      let_it_be(:subsequent_manual_build) do
        create(:ci_build, :manual, pipeline: pipeline, ci_stage: deploy_stage)
      end

      let_it_be(:test_scheduled_build) do
        create(:ci_build, :scheduled, pipeline: pipeline, ci_stage: stage)
      end

      let_it_be(:subsequent_scheduled_build) do
        create(:ci_build, :scheduled, pipeline: pipeline, ci_stage: deploy_stage)
      end

      let!(:job) do
        create(:ci_build, *[trait].compact, :failed, pipeline: pipeline, ci_stage: stage)
      end

      where(:trait, :enqueue_immediately) do
        nil                | false
        :manual            | true
        :expired_scheduled | true
      end

      with_them do
        it 'retries the given job but not the other manual/scheduled jobs' do
          expect { subject }
            .to change { Ci::Build.count }.by(1)
            .and not_change { test_manual_build.reload.status }
            .and not_change { subsequent_manual_build.reload.status }
            .and not_change { test_scheduled_build.reload.status }
            .and not_change { subsequent_scheduled_build.reload.status }

          expect(new_job).to be_pending
        end

        it_behaves_like 'checks enqueue_immediately?'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class DeleteUnitTestsService
    include EachBatch

    BATCH_SIZE = 100

    def execute
      purge_data!(Ci::UnitTestFailure)
      purge_data!(Ci::UnitTest)
    end

    private

    def purge_data!(klass)
      loop do
        break unless delete_batch!(klass)
      end
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def delete_batch!(klass)
      deleted = 0

      klass.transaction do
        ids = klass.deletable.lock('FOR UPDATE SKIP LOCKED').limit(BATCH_SIZE).pluck(:id)
        deleted = klass.where(id: ids).delete_all if ids.any?
      end

      deleted > 0
    end
    # rubocop: enable CodeReuse/ActiveRecord
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::DeleteUnitTestsService, feature_category: :continuous_integration do
  describe '#execute' do
    let!(:unit_test_1) { create(:ci_unit_test) }
    let!(:unit_test_2) { create(:ci_unit_test) }
    let!(:unit_test_3) { create(:ci_unit_test) }
    let!(:unit_test_4) { create(:ci_unit_test) }
    let!(:unit_test_1_recent_failure) { create(:ci_unit_test_failure, unit_test: unit_test_1) }
    let!(:unit_test_1_old_failure) { create(:ci_unit_test_failure, unit_test: unit_test_1, failed_at: 15.days.ago) }
    let!(:unit_test_2_old_failure) { create(:ci_unit_test_failure, unit_test: unit_test_2, failed_at: 15.days.ago) }
    let!(:unit_test_3_old_failure) { create(:ci_unit_test_failure, unit_test: unit_test_3, failed_at: 15.days.ago) }
    let!(:unit_test_4_old_failure) { create(:ci_unit_test_failure, unit_test: unit_test_4, failed_at: 15.days.ago) }

    before do
      stub_const(""#{described_class.name}::BATCH_SIZE"", 2)

      described_class.new.execute
    end

    it 'does not delete unit test failures not older than 14 days' do
      expect(unit_test_1_recent_failure.reload).to be_persisted
    end

    it 'deletes unit test failures older than 14 days' do
      ids = [
        unit_test_1_old_failure,
        unit_test_2_old_failure,
        unit_test_3_old_failure,
        unit_test_4_old_failure
      ].map(&:id)

      result = Ci::UnitTestFailure.where(id: ids)

      expect(result).to be_empty
    end

    it 'deletes unit tests that have no more associated unit test failures' do
      ids = [
        unit_test_2,
        unit_test_3,
        unit_test_4
      ].map(&:id)

      result = Ci::UnitTest.where(id: ids)

      expect(result).to be_empty
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# This class is a simplified version of assign_nested_attributes_for_collection_association from ActiveRecord
# https://github.com/rails/rails/blob/v6.0.2.1/activerecord/lib/active_record/nested_attributes.rb#L466

module Ci
  class UpdateInstanceVariablesService
    UNASSIGNABLE_KEYS = %w[id _destroy].freeze

    def initialize(params)
      @params = params[:variables_attributes]
    end

    def execute
      instantiate_records
      persist_records
    end

    def errors
      @records.to_a.flat_map { |r| r.errors.full_messages }
    end

    private

    attr_reader :params

    def existing_records_by_id
      @existing_records_by_id ||= Ci::InstanceVariable
        .all
        .index_by { |var| var.id.to_s }
    end

    def instantiate_records
      @records = params.map do |attributes|
        find_or_initialize_record(attributes).tap do |record|
          record.assign_attributes(attributes.except(*UNASSIGNABLE_KEYS))
          record.mark_for_destruction if has_destroy_flag?(attributes)
        end
      end
    end

    def find_or_initialize_record(attributes)
      id = attributes[:id].to_s

      if id.blank?
        Ci::InstanceVariable.new
      else
        existing_records_by_id.fetch(id) { raise ActiveRecord::RecordNotFound }
      end
    end

    def persist_records
      Ci::InstanceVariable.transaction do
        success = @records.map do |record|
          if record.marked_for_destruction?
            record.destroy
          else
            record.save
          end
        end.all?

        raise ActiveRecord::Rollback unless success

        success
      end
    end

    def has_destroy_flag?(hash)
      Gitlab::Utils.to_boolean(hash['_destroy'])
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::UpdateInstanceVariablesService, feature_category: :secrets_management do
  let(:params) { { variables_attributes: variables_attributes } }

  subject { described_class.new(params) }

  describe '#execute' do
    context 'without variables' do
      let(:variables_attributes) { [] }

      it { expect(subject.execute).to be_truthy }
    end

    context 'with insert only variables' do
      let(:variables_attributes) do
        [
          { key: 'var_a', secret_value: 'dummy_value_for_a', protected: true },
          { key: 'var_b', secret_value: 'dummy_value_for_b', protected: false }
        ]
      end

      it { expect(subject.execute).to be_truthy }

      it 'persists all the records' do
        expect { subject.execute }
          .to change { Ci::InstanceVariable.count }
          .by variables_attributes.size
      end

      it 'persists attributes' do
        subject.execute

        expect(Ci::InstanceVariable.all).to contain_exactly(
          have_attributes(key: 'var_a', secret_value: 'dummy_value_for_a', protected: true),
          have_attributes(key: 'var_b', secret_value: 'dummy_value_for_b', protected: false)
        )
      end
    end

    context 'with update only variables' do
      let!(:var_a) { create(:ci_instance_variable) }
      let!(:var_b) { create(:ci_instance_variable, protected: false) }

      let(:variables_attributes) do
        [
          {
            id: var_a.id,
            key: var_a.key,
            secret_value: 'new_dummy_value_for_a',
            protected: var_a.protected?.to_s
          },
          {
            id: var_b.id,
            key: 'var_b_key',
            secret_value: 'new_dummy_value_for_b',
            protected: 'true'
          }
        ]
      end

      it { expect(subject.execute).to be_truthy }

      it 'does not change the count' do
        expect { subject.execute }
          .not_to change { Ci::InstanceVariable.count }
      end

      it 'updates the records in place', :aggregate_failures do
        subject.execute

        expect(var_a.reload).to have_attributes(secret_value: 'new_dummy_value_for_a')

        expect(var_b.reload).to have_attributes(
          key: 'var_b_key', secret_value: 'new_dummy_value_for_b', protected: true)
      end
    end

    context 'with insert and update variables' do
      let!(:var_a) { create(:ci_instance_variable) }

      let(:variables_attributes) do
        [
          {
            id: var_a.id,
            key: var_a.key,
            secret_value: 'new_dummy_value_for_a',
            protected: var_a.protected?.to_s
          },
          {
            key: 'var_b',
            secret_value: 'dummy_value_for_b',
            protected: true
          }
        ]
      end

      it { expect(subject.execute).to be_truthy }

      it 'inserts only one record' do
        expect { subject.execute }
          .to change { Ci::InstanceVariable.count }.by 1
      end

      it 'persists all the records', :aggregate_failures do
        subject.execute
        var_b = Ci::InstanceVariable.find_by(key: 'var_b')

        expect(var_a.reload.secret_value).to eq('new_dummy_value_for_a')
        expect(var_b.secret_value).to eq('dummy_value_for_b')
      end
    end

    context 'with insert, update, and destroy variables' do
      let!(:var_a) { create(:ci_instance_variable) }
      let!(:var_b) { create(:ci_instance_variable) }

      let(:variables_attributes) do
        [
          {
            id: var_a.id,
            key: var_a.key,
            secret_value: 'new_dummy_value_for_a',
            protected: var_a.protected?.to_s
          },
          {
            id: var_b.id,
            key: var_b.key,
            secret_value: 'dummy_value_for_b',
            protected: var_b.protected?.to_s,
            '_destroy' => 'true'
          },
          {
            key: 'var_c',
            secret_value: 'dummy_value_for_c',
            protected: true
          }
        ]
      end

      it { expect(subject.execute).to be_truthy }

      it 'persists all the records', :aggregate_failures do
        subject.execute
        var_c = Ci::InstanceVariable.find_by(key: 'var_c')

        expect(var_a.reload.secret_value).to eq('new_dummy_value_for_a')
        expect { var_b.reload }.to raise_error(ActiveRecord::RecordNotFound)
        expect(var_c.secret_value).to eq('dummy_value_for_c')
      end
    end

    context 'with invalid variables' do
      let!(:var_a) { create(:ci_instance_variable, secret_value: 'dummy_value_for_a') }

      let(:variables_attributes) do
        [
          {
            key: '...?',
            secret_value: 'nice_value'
          },
          {
            id: var_a.id,
            key: var_a.key,
            secret_value: 'new_dummy_value_for_a',
            protected: var_a.protected?.to_s
          },
          {
            key: var_a.key,
            secret_value: 'other_value'
          }
        ]
      end

      it { expect(subject.execute).to be_falsey }

      it 'does not insert any records' do
        expect { subject.execute }
          .not_to change { Ci::InstanceVariable.count }
      end

      it 'does not update existing records' do
        subject.execute

        expect(var_a.reload.secret_value).to eq('dummy_value_for_a')
      end

      it 'returns errors' do
        subject.execute

        expect(subject.errors).to match_array(
          [
            ""Key (#{var_a.key}) has already been taken"",
            ""Key can contain only letters, digits and '_'.""
          ])
      end
    end

    context 'when deleting non existing variables' do
      let(:variables_attributes) do
        [
          {
            id: 'some-id',
            key: 'some_key',
            secret_value: 'other_value',
            '_destroy' => 'true'
          }
        ]
      end

      it { expect { subject.execute }.to raise_error(ActiveRecord::RecordNotFound) }
    end

    context 'when updating non existing variables' do
      let(:variables_attributes) do
        [
          {
            id: 'some-id',
            key: 'some_key',
            secret_value: 'other_value'
          }
        ]
      end

      it { expect { subject.execute }.to raise_error(ActiveRecord::RecordNotFound) }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  # TODO: a couple of points with this approach:
  # + reuses existing architecture and reactive caching
  # - it's not a report comparison and some comparing features must be turned off.
  # see CompareReportsBaseService for more notes.
  # issue: https://gitlab.com/gitlab-org/gitlab/issues/34224
  class GenerateCoverageReportsService < CompareReportsBaseService
    def execute(base_pipeline, head_pipeline)
      merge_request = MergeRequest.find_by_id(params[:id])
      {
        status: :parsed,
        key: key(base_pipeline, head_pipeline),
        data: head_pipeline.pipeline_artifacts.find_by_file_type(:code_coverage).present.for_files(merge_request.new_paths)
      }
    rescue StandardError => e
      Gitlab::ErrorTracking.track_exception(
        e,
        project_id: project.id,
        base_pipeline_id: base_pipeline&.id,
        head_pipeline_id: head_pipeline&.id
      )

      {
        status: :error,
        key: key(base_pipeline, head_pipeline),
        status_reason: _('An error occurred while fetching coverage reports.')
      }
    end

    def latest?(base_pipeline, head_pipeline, data)
      data&.fetch(:key, nil) == key(base_pipeline, head_pipeline)
    end

    private

    def key(base_pipeline, head_pipeline)
      [
        base_pipeline&.id, last_update_timestamp(base_pipeline),
        head_pipeline&.id, last_update_timestamp(head_pipeline)
      ]
    end

    def last_update_timestamp(pipeline_hierarchy)
      pipeline_hierarchy&.self_and_project_descendants&.maximum(:updated_at)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::GenerateCoverageReportsService, feature_category: :code_testing do
  let_it_be(:project) { create(:project, :repository) }

  let(:service) { described_class.new(project) }

  describe '#execute' do
    subject { service.execute(base_pipeline, head_pipeline) }

    context 'when head pipeline has coverage reports' do
      let!(:merge_request) { create(:merge_request, :with_coverage_reports, source_project: project) }
      let!(:service) { described_class.new(project, nil, id: merge_request.id) }
      let!(:head_pipeline) { merge_request.head_pipeline }
      let!(:base_pipeline) { nil }

      it 'returns status and data', :aggregate_failures do
        expect_any_instance_of(Ci::PipelineArtifact) do |instance|
          expect(instance).to receive(:present)
          expect(instance).to receive(:for_files).with(merge_request.new_paths).and_call_original
        end

        expect(subject[:status]).to eq(:parsed)
        expect(subject[:data]).to eq(files: {})
      end
    end

    context 'when head pipeline does not have a coverage report artifact' do
      let!(:merge_request) { create(:merge_request, :with_coverage_reports, source_project: project) }
      let!(:service) { described_class.new(project, nil, id: merge_request.id) }
      let!(:head_pipeline) { merge_request.head_pipeline }
      let!(:base_pipeline) { nil }

      before do
        head_pipeline.pipeline_artifacts.destroy_all # rubocop: disable Cop/DestroyAll
      end

      it 'returns status and error message' do
        expect(subject[:status]).to eq(:error)
        expect(subject[:status_reason]).to include('An error occurred while fetching coverage reports.')
      end
    end

    context 'when head pipeline has coverage reports and no merge request associated' do
      let!(:head_pipeline) { create(:ci_pipeline, :with_coverage_reports, project: project) }
      let!(:base_pipeline) { nil }

      it 'returns status and error message' do
        expect(subject[:status]).to eq(:error)
        expect(subject[:status_reason]).to include('An error occurred while fetching coverage reports.')
      end
    end
  end

  describe '#latest?' do
    subject { service.latest?(base_pipeline, head_pipeline, data) }

    let!(:base_pipeline) { nil }
    let!(:head_pipeline) { create(:ci_pipeline, :with_coverage_reports, project: project) }
    let!(:child_pipeline) { create(:ci_pipeline, child_of: head_pipeline) }
    let!(:key) { service.send(:key, base_pipeline, head_pipeline) }

    let(:data) { { key: key } }

    context 'when cache key is latest' do
      it { is_expected.to be_truthy }
    end

    context 'when head pipeline has been updated' do
      before do
        head_pipeline.update_column(:updated_at, 1.minute.from_now)
      end

      it { is_expected.to be_falsy }
    end

    context 'when cache key is empty' do
      let(:data) { { key: nil } }

      it { is_expected.to be_falsy }
    end

    context 'when the pipeline has a child that is updated' do
      before do
        child_pipeline.update_column(:updated_at, 1.minute.from_now)
      end

      it { is_expected.to be_falsy }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class ProcessPipelineService
    attr_reader :pipeline

    def initialize(pipeline)
      @pipeline = pipeline
    end

    def execute
      increment_processing_counter

      Ci::PipelineProcessing::AtomicProcessingService
        .new(pipeline)
        .execute
    end

    def metrics
      @metrics ||= ::Gitlab::Ci::Pipeline::Metrics
    end

    private

    def increment_processing_counter
      metrics.pipeline_processing_events_counter.increment
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::ProcessPipelineService, feature_category: :continuous_integration do
  let_it_be(:project) { create(:project) }

  let(:pipeline) do
    create(:ci_empty_pipeline, ref: 'master', project: project)
  end

  let(:pipeline_processing_events_counter) { double(increment: true) }

  let(:metrics) do
    double(pipeline_processing_events_counter: pipeline_processing_events_counter)
  end

  subject { described_class.new(pipeline) }

  before do
    stub_ci_pipeline_to_return_yaml_file
    stub_not_protect_default_branch

    allow(subject).to receive(:metrics).and_return(metrics)
  end

  describe 'processing events counter' do
    it 'increments processing events counter' do
      expect(pipeline_processing_events_counter).to receive(:increment)

      subject.execute
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class CreateWebIdeTerminalService < ::BaseService
    include ::Gitlab::Utils::StrongMemoize

    TerminalCreationError = Class.new(StandardError)

    TERMINAL_NAME = 'terminal'

    attr_reader :terminal

    def execute
      check_access!
      validate_params!
      load_terminal_config!

      pipeline = create_pipeline!
      success(pipeline: pipeline)
    rescue TerminalCreationError => e
      error(e.message)
    rescue ActiveRecord::RecordInvalid => e
      error(""Failed to persist the pipeline: #{e.message}"")
    end

    private

    def create_pipeline!
      build_pipeline.tap do |pipeline|
        pipeline.stages << terminal_stage_seed(pipeline).to_resource

        # Project iid must be called outside a transaction, so we ensure it is set here
        # otherwise it may be set within the save! which it will lock the InternalId row for the whole transaction
        pipeline.ensure_project_iid!

        pipeline.save!

        Ci::ProcessPipelineService
          .new(pipeline)
          .execute

        pipeline_created_counter.increment(source: :webide)
      end
    end

    def build_pipeline
      Ci::Pipeline.new(
        project: project,
        user: current_user,
        source: :webide,
        config_source: :webide_source,
        ref: ref,
        sha: sha,
        tag: false,
        before_sha: Gitlab::Git::BLANK_SHA
      )
    end

    def terminal_stage_seed(pipeline)
      attributes = {
        name: TERMINAL_NAME,
        index: 0,
        builds: [terminal_build_seed]
      }

      seed_context = Gitlab::Ci::Pipeline::Seed::Context.new(pipeline)
      Gitlab::Ci::Pipeline::Seed::Stage.new(seed_context, attributes, [])
    end

    def terminal_build_seed
      terminal.merge(
        name: TERMINAL_NAME,
        stage: TERMINAL_NAME,
        user: current_user,
        scheduling_type: :stage)
    end

    def load_terminal_config!
      result = ::Ide::TerminalConfigService.new(project, current_user, sha: sha).execute
      raise TerminalCreationError, result[:message] if result[:status] != :success

      @terminal = result[:terminal]
      raise TerminalCreationError, 'Terminal is not configured' unless terminal
    end

    def validate_params!
      unless sha
        raise TerminalCreationError, 'Ref does not exist'
      end

      unless branch_exists?
        raise TerminalCreationError, 'Ref needs to be a branch'
      end
    end

    def check_access!
      unless can?(current_user, :create_web_ide_terminal, project)
        raise TerminalCreationError, 'Insufficient permissions to create a terminal'
      end

      if terminal_active?
        raise TerminalCreationError, 'There is already a terminal running'
      end
    end

    def pipeline_created_counter
      @pipeline_created_counter ||= Gitlab::Metrics
        .counter(:pipelines_created_total, ""Counter of pipelines created"")
    end

    def terminal_active?
      project.active_webide_pipelines(user: current_user).exists?
    end

    def ref
      strong_memoize(:ref) do
        Gitlab::Git.ref_name(params[:ref])
      end
    end

    def branch_exists?
      project.repository.branch_exists?(ref)
    end

    def sha
      project.commit(params[:ref]).try(:id)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::CreateWebIdeTerminalService, feature_category: :continuous_integration do
  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:user) { create(:user) }

  let(:ref) { 'master' }

  describe '#execute' do
    subject { described_class.new(project, user, ref: ref).execute }

    context 'for maintainer' do
      shared_examples 'be successful' do
        it 'returns a success with pipeline object' do
          is_expected.to include(status: :success)

          expect(subject[:pipeline]).to be_a(Ci::Pipeline)
          expect(subject[:pipeline]).to be_persisted
          expect(subject[:pipeline].stages.count).to eq(1)
          expect(subject[:pipeline].builds.count).to eq(1)
        end

        it 'calls ensure_project_iid explicitly' do
          expect_next_instance_of(Ci::Pipeline) do |instance|
            expect(instance).to receive(:ensure_project_iid!).twice
          end
          subject
        end
      end

      before do
        project.add_maintainer(user)
      end

      context 'when web-ide has valid configuration' do
        before do
          stub_webide_config_file(config_content)
        end

        context 'for empty configuration' do
          let(:config_content) do
            'terminal: {}'
          end

          it_behaves_like 'be successful'
        end

        context 'for configuration with container image' do
          let(:config_content) do
            'terminal: { image: ruby }'
          end

          it_behaves_like 'be successful'
        end

        context 'for configuration with ports' do
          let(:config_content) do
            <<-EOS
              terminal:
                image:
                  name: image:1.0
                  ports:
                    - 80
                script: rspec
                services:
                  - name: test
                    alias: test
                    ports:
                      - 8080
            EOS
          end

          it_behaves_like 'be successful'
        end

        context 'for configuration with variables' do
          let(:config_content) do
            <<-EOS
              terminal:
                script: rspec
                variables:
                  KEY1: VAL1
            EOS
          end

          it_behaves_like 'be successful'

          it 'saves the variables' do
            expect(subject[:pipeline].builds[0].variables).to include(
              key: 'KEY1', value: 'VAL1', public: true, masked: false
            )
          end
        end
      end
    end

    context 'error handling' do
      shared_examples 'having an error' do |message|
        it 'returns an error' do
          is_expected.to eq(
            status: :error,
            message: message
          )
        end
      end

      shared_examples 'having insufficient permissions' do
        it_behaves_like 'having an error', 'Insufficient permissions to create a terminal'
      end

      context 'when user is developer' do
        before do
          project.add_developer(user)
        end

        it_behaves_like 'having insufficient permissions'
      end

      context 'when user is maintainer' do
        before do
          project.add_maintainer(user)
        end

        context 'when terminal is already running' do
          let!(:webide_pipeline) { create(:ci_pipeline, :webide, :running, project: project, user: user) }

          it_behaves_like 'having an error', 'There is already a terminal running'
        end

        context 'when ref is non-existing' do
          let(:ref) { 'non-existing-ref' }

          it_behaves_like 'having an error', 'Ref does not exist'
        end

        context 'when ref is a tag' do
          let(:ref) { 'v1.0.0' }

          it_behaves_like 'having an error', 'Ref needs to be a branch'
        end

        context 'when terminal config is missing' do
          let(:ref) { 'v1.0.0' }

          it_behaves_like 'having an error', 'Ref needs to be a branch'
        end

        context 'when webide config is present' do
          before do
            stub_webide_config_file(config_content)
          end

          context 'config has invalid content' do
            let(:config_content) { 'invalid' }

            it_behaves_like 'having an error', 'Invalid configuration format'
          end

          context 'config is valid, but does not have terminal' do
            let(:config_content) { '{}' }

            it_behaves_like 'having an error', 'Terminal is not configured'
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  # Takes in input a Ci::Bridge job and creates a downstream pipeline
  # (either multi-project or child pipeline) according to the Ci::Bridge
  # specifications.
  class CreateDownstreamPipelineService < ::BaseService
    include Gitlab::Utils::StrongMemoize
    include Ci::DownstreamPipelineHelpers

    DuplicateDownstreamPipelineError = Class.new(StandardError)

    MAX_NESTED_CHILDREN = 2

    def execute(bridge)
      @bridge = bridge

      if @bridge.has_downstream_pipeline?
        Gitlab::ErrorTracking.track_exception(
          DuplicateDownstreamPipelineError.new,
          bridge_id: @bridge.id, project_id: @bridge.project_id
        )

        return ServiceResponse.error(message: 'Already has a downstream pipeline')
      end

      pipeline_params = @bridge.downstream_pipeline_params
      target_ref = pipeline_params.dig(:target_revision, :ref)

      return ServiceResponse.error(message: 'Pre-conditions not met') unless ensure_preconditions!(target_ref)

      return ServiceResponse.error(message: 'Can not run the bridge') unless @bridge.run

      service = ::Ci::CreatePipelineService.new(
        pipeline_params.fetch(:project),
        current_user,
        pipeline_params.fetch(:target_revision))

      downstream_pipeline = service
        .execute(pipeline_params.fetch(:source), **pipeline_params[:execute_params])
        .payload

      log_downstream_pipeline_creation(downstream_pipeline)
      update_bridge_status!(@bridge, downstream_pipeline)
    rescue StandardError => e
      @bridge.reset.drop!(:data_integrity_failure)
      raise e
    end

    private

    def update_bridge_status!(bridge, pipeline)
      Gitlab::OptimisticLocking.retry_lock(bridge, name: 'create_downstream_pipeline_update_bridge_status') do |subject|
        if pipeline.created_successfully?
          # If bridge uses `strategy:depend` we leave it running
          # and update the status when the downstream pipeline completes.
          subject.success! unless subject.dependent?
          ServiceResponse.success(payload: pipeline)
        else
          message = pipeline.errors.full_messages
          subject.options[:downstream_errors] = message
          subject.drop!(:downstream_pipeline_creation_failed)
          ServiceResponse.error(payload: pipeline, message: message)
        end
      end
    rescue StateMachines::InvalidTransition => e
      Gitlab::ErrorTracking.track_exception(
        Ci::Bridge::InvalidTransitionError.new(e.message),
        bridge_id: bridge.id,
        downstream_pipeline_id: pipeline.id)
      ServiceResponse.error(payload: pipeline, message: e.message)
    end

    def ensure_preconditions!(target_ref)
      unless downstream_project_accessible?
        @bridge.drop!(:downstream_bridge_project_not_found)
        return false
      end

      # TODO: Remove this condition if favour of model validation
      # https://gitlab.com/gitlab-org/gitlab/issues/38338
      if downstream_project == project && !@bridge.triggers_child_pipeline?
        @bridge.drop!(:invalid_bridge_trigger)
        return false
      end

      # TODO: Remove this condition if favour of model validation
      # https://gitlab.com/gitlab-org/gitlab/issues/38338
      # only applies to parent-child pipelines not multi-project
      if has_max_nested_children?
        @bridge.drop!(:reached_max_descendant_pipelines_depth)
        return false
      end

      if pipeline_tree_too_large?
        @bridge.drop!(:reached_max_pipeline_hierarchy_size)
        return false
      end

      unless can_create_downstream_pipeline?(target_ref)
        @bridge.drop!(:insufficient_bridge_permissions)
        return false
      end

      if has_cyclic_dependency?
        @bridge.drop!(:pipeline_loop_detected)

        return false
      end

      true
    end

    def downstream_project_accessible?
      downstream_project.present? &&
        can?(current_user, :read_project, downstream_project)
    end

    def can_create_downstream_pipeline?(target_ref)
      can?(current_user, :update_pipeline, project) &&
        can?(current_user, :create_pipeline, downstream_project) &&
          can_update_branch?(target_ref)
    end

    def can_update_branch?(target_ref)
      ::Gitlab::UserAccess.new(current_user, container: downstream_project).can_update_branch?(target_ref)
    end

    def downstream_project
      strong_memoize(:downstream_project) do
        @bridge.downstream_project
      end
    end

    def has_cyclic_dependency?
      return false if @bridge.triggers_child_pipeline?

      pipeline_checksums = @bridge.pipeline.self_and_upstreams.filter_map do |pipeline|
        config_checksum(pipeline) unless pipeline.child?
      end

      # To avoid false positives we allow 1 cycle in the ancestry and
      # fail when 2 cycles are detected: A -> B -> A -> B -> A
      pipeline_checksums.tally.any? { |_checksum, occurrences| occurrences > 2 }
    end

    def has_max_nested_children?
      return false unless @bridge.triggers_child_pipeline?

      # only applies to parent-child pipelines not multi-project
      ancestors_of_new_child = @bridge.pipeline.self_and_project_ancestors
      ancestors_of_new_child.count > MAX_NESTED_CHILDREN
    end

    def pipeline_tree_too_large?
      return false unless @bridge.triggers_downstream_pipeline?

      # Applies to the entire pipeline tree across all projects
      # A pipeline tree can be shared between multiple namespaces (customers), the limit that is used here
      # is the limit of the namespace that has added a downstream pipeline to a pipeline tree.
      @bridge.project.actual_limits.exceeded?(:pipeline_hierarchy_size, complete_hierarchy_count)
    end

    def complete_hierarchy_count
      @bridge.pipeline.complete_hierarchy_count
    end

    def config_checksum(pipeline)
      [pipeline.project_id, pipeline.ref, pipeline.source].hash
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::CreateDownstreamPipelineService, '#execute', feature_category: :continuous_integration do
  include Ci::SourcePipelineHelpers

  # Using let_it_be on user and projects for these specs can cause
  # spec-ordering failures due to the project-based permissions
  # associating them. They should be recreated every time.
  let(:user) { create(:user) }
  let(:upstream_project) { create(:project, :repository) }
  let(:downstream_project) { create(:project, :repository) }

  let!(:upstream_pipeline) do
    create(:ci_pipeline, :created, project: upstream_project)
  end

  let(:trigger) do
    {
      trigger: {
        project: downstream_project.full_path,
        branch: 'feature'
      }
    }
  end

  let(:bridge) do
    create(
      :ci_bridge,
      status: :pending,
      user: user,
      options: trigger,
      pipeline: upstream_pipeline
    )
  end

  let(:service) { described_class.new(upstream_project, user) }
  let(:pipeline) { subject.payload }

  before do
    upstream_project.add_developer(user)
  end

  subject { service.execute(bridge) }

  context 'when downstream project has not been found' do
    let(:trigger) do
      { trigger: { project: 'unknown/project' } }
    end

    it 'does not create a pipeline' do
      expect { subject }
        .not_to change { Ci::Pipeline.count }
      expect(subject).to be_error
      expect(subject.message).to eq(""Pre-conditions not met"")
    end

    it 'changes pipeline bridge job status to failed' do
      subject

      expect(bridge.reload).to be_failed
      expect(bridge.failure_reason)
        .to eq 'downstream_bridge_project_not_found'
    end
  end

  context 'when user can not access downstream project' do
    it 'does not create a new pipeline' do
      expect { subject }
        .not_to change { Ci::Pipeline.count }
      expect(subject).to be_error
      expect(subject.message).to eq(""Pre-conditions not met"")
    end

    it 'changes status of the bridge build to failed' do
      subject

      expect(bridge.reload).to be_failed
      expect(bridge.failure_reason)
        .to eq 'downstream_bridge_project_not_found'
    end
  end

  context 'when user does not have access to create pipeline' do
    before do
      downstream_project.add_guest(user)
    end

    it 'does not create a new pipeline' do
      expect { subject }
        .not_to change { Ci::Pipeline.count }
      expect(subject).to be_error
      expect(subject.message).to eq(""Pre-conditions not met"")
    end

    it 'changes status of the bridge build to failed' do
      subject

      expect(bridge.reload).to be_failed
      expect(bridge.failure_reason).to eq 'insufficient_bridge_permissions'
    end
  end

  context 'when user can create pipeline in a downstream project' do
    let(:stub_config) { true }

    before do
      downstream_project.add_developer(user)
      stub_ci_pipeline_yaml_file(YAML.dump(rspec: { script: 'rspec' })) if stub_config
    end

    it 'creates only one new pipeline' do
      expect { subject }
        .to change { Ci::Pipeline.count }.by(1)
      expect(subject).to be_success
    end

    it 'creates a new pipeline in a downstream project' do
      expect(pipeline.user).to eq bridge.user
      expect(pipeline.project).to eq downstream_project
      expect(bridge.reload.sourced_pipeline.pipeline).to eq pipeline
      expect(pipeline.triggered_by_pipeline).to eq upstream_pipeline
      expect(pipeline.source_bridge).to eq bridge
      expect(pipeline.source_bridge).to be_a ::Ci::Bridge
    end

    it_behaves_like 'logs downstream pipeline creation' do
      let(:downstream_pipeline) { pipeline }
      let(:expected_root_pipeline) { upstream_pipeline }
      let(:expected_hierarchy_size) { 2 }
      let(:expected_downstream_relationship) { :multi_project }
    end

    it 'updates bridge status when downstream pipeline gets processed' do
      expect(pipeline.reload).to be_created
      expect(bridge.reload).to be_success
    end

    it 'triggers the upstream pipeline duration calculation', :sidekiq_inline do
      expect { subject }
        .to change { upstream_pipeline.reload.duration }.from(nil).to(an_instance_of(Integer))
    end

    context 'when bridge job has already any downstream pipeline' do
      before do
        bridge.create_sourced_pipeline!(
          source_pipeline: bridge.pipeline,
          source_project: bridge.project,
          project: bridge.project,
          pipeline: create(:ci_pipeline, project: bridge.project)
        )
      end

      it 'logs an error and exits' do
        expect(Gitlab::ErrorTracking)
          .to receive(:track_exception)
          .with(
            instance_of(described_class::DuplicateDownstreamPipelineError),
            bridge_id: bridge.id, project_id: bridge.project.id)
          .and_call_original
        expect(Ci::CreatePipelineService).not_to receive(:new)
        expect(subject).to be_error
        expect(subject.message).to eq(""Already has a downstream pipeline"")
      end
    end

    context 'when target ref is not specified' do
      let(:trigger) do
        { trigger: { project: downstream_project.full_path } }
      end

      it 'is using default branch name' do
        expect(pipeline.ref).to eq 'master'
      end
    end

    context 'when downstream pipeline has yaml configuration error' do
      before do
        stub_ci_pipeline_yaml_file(YAML.dump(job: { invalid: 'yaml' }))
      end

      it 'creates only one new pipeline' do
        expect { subject }
          .to change { Ci::Pipeline.count }.by(1)
        expect(subject).to be_error
        expect(subject.message).to match_array([""jobs job config should implement a script: or a trigger: keyword""])
      end

      it 'creates a new pipeline in a downstream project' do
        expect(pipeline.user).to eq bridge.user
        expect(pipeline.project).to eq downstream_project
        expect(bridge.reload.sourced_pipeline.pipeline).to eq pipeline
        expect(pipeline.triggered_by_pipeline).to eq upstream_pipeline
        expect(pipeline.source_bridge).to eq bridge
        expect(pipeline.source_bridge).to be_a ::Ci::Bridge
      end

      it 'updates the bridge status when downstream pipeline gets processed' do
        expect(pipeline.reload).to be_failed
        expect(bridge.reload).to be_failed
      end
    end

    context 'when downstream project is the same as the upstream project' do
      let(:trigger) do
        { trigger: { project: upstream_project.full_path } }
      end

      context 'detects a circular dependency' do
        it 'does not create a new pipeline' do
          expect { subject }
            .not_to change { Ci::Pipeline.count }
          expect(subject).to be_error
          expect(subject.message).to eq(""Pre-conditions not met"")
        end

        it 'changes status of the bridge build' do
          subject

          expect(bridge.reload).to be_failed
          expect(bridge.failure_reason).to eq 'invalid_bridge_trigger'
        end
      end

      context 'when ""include"" is provided' do
        let(:file_content) do
          YAML.dump(
            rspec: { script: 'rspec' },
            echo: { script: 'echo' })
        end

        shared_examples 'creates a child pipeline' do
          it 'creates only one new pipeline' do
            expect { subject }
              .to change { Ci::Pipeline.count }.by(1)
            expect(subject).to be_success
          end

          it 'creates a child pipeline in the same project' do
            expect(pipeline.builds.map(&:name)).to match_array(%w[rspec echo])
            expect(pipeline.user).to eq bridge.user
            expect(pipeline.project).to eq bridge.project
            expect(bridge.reload.sourced_pipeline.pipeline).to eq pipeline
            expect(pipeline.triggered_by_pipeline).to eq upstream_pipeline
            expect(pipeline.source_bridge).to eq bridge
            expect(pipeline.source_bridge).to be_a ::Ci::Bridge
          end

          it 'updates bridge status when downstream pipeline gets processed' do
            expect(pipeline.reload).to be_created
            expect(bridge.reload).to be_success
          end

          it 'propagates parent pipeline settings to the child pipeline' do
            expect(pipeline.ref).to eq(upstream_pipeline.ref)
            expect(pipeline.sha).to eq(upstream_pipeline.sha)
            expect(pipeline.source_sha).to eq(upstream_pipeline.source_sha)
            expect(pipeline.target_sha).to eq(upstream_pipeline.target_sha)
            expect(pipeline.target_sha).to eq(upstream_pipeline.target_sha)

            expect(pipeline.trigger_requests.last).to eq(bridge.trigger_request)
          end
        end

        before do
          upstream_project.repository.create_file(
            user, 'child-pipeline.yml', file_content, message: 'message', branch_name: 'master')

          upstream_pipeline.update!(sha: upstream_project.commit.id)
        end

        let(:stub_config) { false }

        let(:trigger) do
          {
            trigger: { include: 'child-pipeline.yml' }
          }
        end

        it_behaves_like 'creates a child pipeline'

        it_behaves_like 'logs downstream pipeline creation' do
          let(:downstream_pipeline) { pipeline }
          let(:expected_root_pipeline) { upstream_pipeline }
          let(:expected_hierarchy_size) { 2 }
          let(:expected_downstream_relationship) { :parent_child }
        end

        it 'updates the bridge job to success' do
          expect { subject }.to change { bridge.status }.to 'success'
          expect(subject).to be_success
        end

        context 'when bridge uses ""depend"" strategy' do
          let(:trigger) do
            {
              trigger: { include: 'child-pipeline.yml', strategy: 'depend' }
            }
          end

          it 'update the bridge job to running status' do
            expect { subject }.to change { bridge.status }.from('pending').to('running')
            expect(subject).to be_success
          end
        end

        context 'when latest sha for the ref changed in the meantime' do
          before do
            upstream_project.repository.create_file(
              user, 'another-change', 'test', message: 'message', branch_name: 'master')
          end

          # it does not auto-cancel pipelines from the same family
          it_behaves_like 'creates a child pipeline'
        end

        context 'when the parent is a merge request pipeline' do
          let(:merge_request) { create(:merge_request, source_project: bridge.project, target_project: bridge.project) }
          let(:file_content) do
            YAML.dump(
              workflow: { rules: [{ if: '$CI_MERGE_REQUEST_ID' }] },
              rspec: { script: 'rspec' },
              echo: { script: 'echo' })
          end

          before do
            bridge.pipeline.update!(source: :merge_request_event, merge_request: merge_request)
          end

          it_behaves_like 'creates a child pipeline'

          it 'propagates the merge request to the child pipeline' do
            expect(pipeline.merge_request).to eq(merge_request)
            expect(pipeline).to be_merge_request
          end
        end

        context 'when upstream pipeline has a parent pipeline' do
          before do
            create(:ci_sources_pipeline,
              source_pipeline: create(:ci_pipeline, project: upstream_pipeline.project),
              pipeline: upstream_pipeline
            )
          end

          it 'creates the pipeline' do
            expect { subject }
              .to change { Ci::Pipeline.count }.by(1)
            expect(subject).to be_success

            expect(bridge.reload).to be_success
          end

          it_behaves_like 'logs downstream pipeline creation' do
            let(:downstream_pipeline) { pipeline }
            let(:expected_root_pipeline) { upstream_pipeline.parent_pipeline }
            let(:expected_hierarchy_size) { 3 }
            let(:expected_downstream_relationship) { :parent_child }
          end
        end

        context 'when upstream pipeline has a parent pipeline, which has a parent pipeline' do
          before do
            parent_of_upstream_pipeline = create(:ci_pipeline, project: upstream_pipeline.project)

            create(:ci_sources_pipeline,
              source_pipeline: create(:ci_pipeline, project: upstream_pipeline.project),
              pipeline: parent_of_upstream_pipeline
            )

            create(:ci_sources_pipeline,
              source_pipeline: parent_of_upstream_pipeline,
              pipeline: upstream_pipeline
            )
          end

          it 'does not create a second descendant pipeline' do
            expect { subject }
              .not_to change { Ci::Pipeline.count }

            expect(bridge.reload).to be_failed
            expect(bridge.failure_reason).to eq 'reached_max_descendant_pipelines_depth'
          end
        end

        context 'when upstream pipeline has two level upstream pipelines from different projects' do
          before do
            upstream_of_upstream_of_upstream_pipeline = create(:ci_pipeline)
            upstream_of_upstream_pipeline = create(:ci_pipeline)

            create(:ci_sources_pipeline,
              source_pipeline: upstream_of_upstream_of_upstream_pipeline,
              pipeline: upstream_of_upstream_pipeline
            )

            create(:ci_sources_pipeline,
              source_pipeline: upstream_of_upstream_pipeline,
              pipeline: upstream_pipeline
            )
          end

          it 'create the pipeline' do
            expect { subject }.to change { Ci::Pipeline.count }.by(1)
            expect(subject).to be_success
          end
        end

        context 'when downstream project does not allow user-defined variables for child pipelines' do
          before do
            bridge.yaml_variables = [{ key: 'BRIDGE', value: '$PIPELINE_VARIABLE-var', public: true }]

            upstream_pipeline.project.update!(restrict_user_defined_variables: true)
          end

          it 'creates a new pipeline allowing variables to be passed downstream' do
            expect { subject }.to change { Ci::Pipeline.count }.by(1)
            expect(subject).to be_success
          end

          it 'passes variables downstream from the bridge' do
            pipeline.variables.map(&:key).tap do |variables|
              expect(variables).to include 'BRIDGE'
            end
          end
        end

        context 'when multi-project pipeline runs from child pipelines bridge job' do
          before do
            stub_ci_pipeline_yaml_file(YAML.dump(rspec: { script: 'rspec' }))
          end

          # instantiate new service, to clear memoized values from child pipeline run
          subject(:execute_with_trigger_project_bridge) do
            described_class.new(upstream_project, user).execute(trigger_project_bridge)
          end

          let!(:child_pipeline) do
            service.execute(bridge)
            bridge.downstream_pipeline
          end

          let!(:trigger_downstream_project) do
            {
              trigger: {
                project: downstream_project.full_path,
                branch: 'feature'
              }
            }
          end

          let!(:trigger_project_bridge) do
            create(
              :ci_bridge, status: :pending, user: user, options: trigger_downstream_project, pipeline: child_pipeline
            )
          end

          it 'creates a new pipeline' do
            expect { execute_with_trigger_project_bridge }
              .to change { Ci::Pipeline.count }.by(1)

            new_pipeline = trigger_project_bridge.downstream_pipeline

            expect(new_pipeline.child?).to eq(false)
            expect(new_pipeline.triggered_by_pipeline).to eq child_pipeline
            expect(trigger_project_bridge.reload).not_to be_failed
          end
        end
      end
    end

    describe 'cyclical dependency detection' do
      shared_examples 'detects cyclical pipelines' do
        it 'does not create a new pipeline' do
          expect { subject }
            .not_to change { Ci::Pipeline.count }
          expect(subject).to be_error
          expect(subject.message).to eq(""Pre-conditions not met"")
        end

        it 'changes status of the bridge build' do
          subject

          expect(bridge.reload).to be_failed
          expect(bridge.failure_reason).to eq 'pipeline_loop_detected'
        end
      end

      shared_examples 'passes cyclical pipeline precondition' do
        it 'creates a new pipeline' do
          expect { subject }
            .to change { Ci::Pipeline.count }
          expect(subject).to be_success
        end

        it 'expect bridge build not to be failed' do
          subject

          expect(bridge.reload).not_to be_failed
        end
      end

      context 'when pipeline ancestry contains 2 cycles of dependencies' do
        before do
          # A(push on master) -> B(pipeline on master) -> A(push on master) ->
          #   B(pipeline on master) -> A(push on master)
          pipeline_1 = create(:ci_pipeline, project: upstream_project, source: :push)
          pipeline_2 = create(:ci_pipeline, project: downstream_project, source: :pipeline)
          pipeline_3 = create(:ci_pipeline, project: upstream_project, source: :push)
          pipeline_4 = create(:ci_pipeline, project: downstream_project, source: :pipeline)

          create_source_pipeline(pipeline_1, pipeline_2)
          create_source_pipeline(pipeline_2, pipeline_3)
          create_source_pipeline(pipeline_3, pipeline_4)
          create_source_pipeline(pipeline_4, upstream_pipeline)
        end

        it_behaves_like 'detects cyclical pipelines'
      end

      context 'when source in the ancestry differ' do
        before do
          # A(push on master) -> B(pipeline on master) -> A(pipeline on master)
          pipeline_1 = create(:ci_pipeline, project: upstream_project, source: :push)
          pipeline_2 = create(:ci_pipeline, project: downstream_project, source: :pipeline)
          upstream_pipeline.update!(source: :pipeline)

          create_source_pipeline(pipeline_1, pipeline_2)
          create_source_pipeline(pipeline_2, upstream_pipeline)
        end

        it_behaves_like 'passes cyclical pipeline precondition'
      end

      context 'when ref in the ancestry differ' do
        before do
          # A(push on master) -> B(pipeline on master) -> A(push on feature-1)
          pipeline_1 = create(:ci_pipeline, ref: 'master', project: upstream_project, source: :push)
          pipeline_2 = create(:ci_pipeline, ref: 'master', project: downstream_project, source: :pipeline)
          upstream_pipeline.update!(ref: 'feature-1')

          create_source_pipeline(pipeline_1, pipeline_2)
          create_source_pipeline(pipeline_2, upstream_pipeline)
        end

        it_behaves_like 'passes cyclical pipeline precondition'
      end

      context 'when only 1 cycle is detected' do
        before do
          # A(push on master) -> B(pipeline on master) -> A(push on master)
          pipeline_1 = create(:ci_pipeline, ref: 'master', project: upstream_project, source: :push)
          pipeline_2 = create(:ci_pipeline, ref: 'master', project: downstream_project, source: :pipeline)

          create_source_pipeline(pipeline_1, pipeline_2)
          create_source_pipeline(pipeline_2, upstream_pipeline)
        end

        it_behaves_like 'passes cyclical pipeline precondition'
      end
    end

    context 'when downstream pipeline creation errors out' do
      let(:stub_config) { false }

      before do
        stub_ci_pipeline_yaml_file(YAML.dump(invalid: { yaml: 'error' }))
      end

      it 'creates only one new pipeline' do
        expect { subject }
          .to change { Ci::Pipeline.count }.by(1)
        expect(subject).to be_error
        expect(subject.message).to match_array([""jobs invalid config should implement a script: or a trigger: keyword""])
      end

      it 'creates a new pipeline in the downstream project' do
        expect(pipeline.user).to eq bridge.user
        expect(pipeline.project).to eq downstream_project
      end

      it 'drops the bridge' do
        expect(pipeline.reload).to be_failed
        expect(bridge.reload).to be_failed
        expect(bridge.failure_reason).to eq('downstream_pipeline_creation_failed')
      end
    end

    context 'when bridge job status update raises state machine errors' do
      let(:stub_config) { false }

      before do
        stub_ci_pipeline_yaml_file(YAML.dump(invalid: { yaml: 'error' }))
        bridge.drop!
      end

      it 'returns the error' do
        expect { subject }.not_to change(downstream_project.ci_pipelines, :count)
        expect(subject).to be_error
        expect(subject.message).to eq('Can not run the bridge')
      end
    end

    context 'when bridge job has YAML variables defined' do
      before do
        bridge.yaml_variables = [{ key: 'BRIDGE', value: 'var', public: true }]
      end

      it 'passes bridge variables to downstream pipeline' do
        expect(pipeline.variables.first)
          .to have_attributes(key: 'BRIDGE', value: 'var')
      end
    end

    context 'when pipeline variables are defined' do
      before do
        upstream_pipeline.variables.create!(key: 'PIPELINE_VARIABLE', value: 'my-value')
      end

      it 'does not pass pipeline variables directly downstream' do
        pipeline.variables.map(&:key).tap do |variables|
          expect(variables).not_to include 'PIPELINE_VARIABLE'
        end
      end

      context 'when using YAML variables interpolation' do
        before do
          bridge.yaml_variables = [{ key: 'BRIDGE', value: '$PIPELINE_VARIABLE-var', public: true }]
        end

        it 'makes it possible to pass pipeline variable downstream' do
          pipeline.variables.find_by(key: 'BRIDGE').tap do |variable|
            expect(variable.value).to eq 'my-value-var'
          end
        end

        context 'when downstream project does not allow user-defined variables for multi-project pipelines' do
          before do
            downstream_project.update!(restrict_user_defined_variables: true)
          end

          it 'does not create a new pipeline' do
            expect { subject }
              .not_to change { Ci::Pipeline.count }
            expect(subject).to be_error
            expect(subject.message).to match_array([""Insufficient permissions to set pipeline variables""])
          end

          it 'ignores variables passed downstream from the bridge' do
            pipeline.variables.map(&:key).tap do |variables|
              expect(variables).not_to include 'BRIDGE'
            end
          end

          it 'sets errors', :aggregate_failures do
            subject

            expect(bridge.reload).to be_failed
            expect(bridge.failure_reason).to eq('downstream_pipeline_creation_failed')
            expect(bridge.options[:downstream_errors]).to eq(['Insufficient permissions to set pipeline variables'])
          end
        end
      end
    end

    # TODO: Move this context into a feature spec that uses
    # multiple pipeline processing services. Location TBD in:
    # https://gitlab.com/gitlab-org/gitlab/issues/36216
    context 'when configured with bridge job rules', :sidekiq_inline do
      before do
        stub_ci_pipeline_yaml_file(config)
        downstream_project.add_maintainer(upstream_project.first_owner)
      end

      let(:config) do
        <<-EOY
          hello:
            script: echo world

          bridge-job:
            rules:
              - if: $CI_COMMIT_REF_NAME == ""master""
            trigger:
              project: #{downstream_project.full_path}
              branch: master
        EOY
      end

      let(:primary_pipeline) do
        Ci::CreatePipelineService.new(upstream_project, upstream_project.first_owner, { ref: 'master' })
          .execute(:push, save_on_errors: false)
          .payload
      end

      let(:bridge)  { primary_pipeline.processables.find_by(name: 'bridge-job') }
      let(:service) { described_class.new(upstream_project, upstream_project.first_owner) }

      context 'that include the bridge job' do
        it 'creates the downstream pipeline' do
          expect { subject }
            .to change(downstream_project.ci_pipelines, :count).by(1)
          expect(subject).to be_error
          expect(subject.message).to eq(""Already has a downstream pipeline"")
        end
      end
    end

    context 'when user does not have access to push protected branch of downstream project' do
      before do
        create(:protected_branch, :maintainers_can_push, project: downstream_project, name: 'feature')
      end

      it 'changes status of the bridge build' do
        subject

        expect(bridge.reload).to be_failed
        expect(bridge.failure_reason).to eq 'insufficient_bridge_permissions'
      end
    end

    context 'when there is no such branch in downstream project' do
      let(:trigger) do
        {
          trigger: {
            project: downstream_project.full_path,
            branch: 'invalid_branch'
          }
        }
      end

      it 'does not create a pipeline and drops the bridge' do
        expect { subject }.not_to change(downstream_project.ci_pipelines, :count)
        expect(subject).to be_error
        expect(subject.message).to match_array([""Reference not found""])

        expect(bridge.reload).to be_failed
        expect(bridge.failure_reason).to eq('downstream_pipeline_creation_failed')
        expect(bridge.options[:downstream_errors]).to eq(['Reference not found'])
      end
    end

    context 'when downstream pipeline has a branch rule and does not satisfy' do
      before do
        stub_ci_pipeline_yaml_file(config)
      end

      let(:config) do
        <<-EOY
          hello:
            script: echo world
            only:
              - invalid_branch
        EOY
      end

      it 'does not create a pipeline and drops the bridge' do
        expect { subject }.not_to change(downstream_project.ci_pipelines, :count)
        expect(subject).to be_error
        expect(subject.message).to match_array(['Pipeline will not run for the selected trigger. ' \
          'The rules configuration prevented any jobs from being added to the pipeline.'])

        expect(bridge.reload).to be_failed
        expect(bridge.failure_reason).to eq('downstream_pipeline_creation_failed')
        expect(bridge.options[:downstream_errors]).to match_array(['Pipeline will not run for the selected trigger. ' \
          'The rules configuration prevented any jobs from being added to the pipeline.'])
      end
    end

    context 'when downstream pipeline has invalid YAML' do
      before do
        stub_ci_pipeline_yaml_file(config)
      end

      let(:config) do
        <<-EOY
          test:
            stage: testx
            script: echo 1
        EOY
      end

      it 'creates the pipeline but drops the bridge' do
        expect { subject }.to change(downstream_project.ci_pipelines, :count).by(1)
        expect(subject).to be_error
        expect(subject.message).to eq(
          [""test job: chosen stage does not exist; available stages are .pre, build, test, deploy, .post""]
        )

        expect(bridge.reload).to be_failed
        expect(bridge.failure_reason).to eq('downstream_pipeline_creation_failed')
        expect(bridge.options[:downstream_errors]).to eq(
          ['test job: chosen stage does not exist; available stages are .pre, build, test, deploy, .post']
        )
      end
    end

    context 'when downstream pipeline has workflow rule' do
      before do
        stub_ci_pipeline_yaml_file(config)
      end

      let(:config) do
        <<-EOY
          workflow:
            rules:
              - if: $my_var

          regular-job:
            script: 'echo Hello, World!'
        EOY
      end

      context 'when passing the required variable' do
        before do
          bridge.yaml_variables = [{ key: 'my_var', value: 'var', public: true }]
        end

        it 'creates the pipeline' do
          expect { subject }.to change(downstream_project.ci_pipelines, :count).by(1)
          expect(subject).to be_success

          expect(bridge.reload).to be_success
        end
      end

      context 'when not passing the required variable' do
        it 'does not create the pipeline' do
          expect { subject }.not_to change(downstream_project.ci_pipelines, :count)
        end
      end
    end

    context 'when a downstream pipeline has sibling pipelines' do
      it_behaves_like 'logs downstream pipeline creation' do
        let(:downstream_pipeline) { pipeline }
        let(:expected_root_pipeline) { upstream_pipeline }
        let(:expected_downstream_relationship) { :multi_project }

        # New downstream, plus upstream, plus two children of upstream created below
        let(:expected_hierarchy_size) { 4 }

        before do
          create_list(:ci_pipeline, 2, child_of: upstream_pipeline)
        end
      end
    end

    context 'when the pipeline tree is too large' do
      let_it_be(:parent)     { create(:ci_pipeline) }
      let_it_be(:child)      { create(:ci_pipeline, child_of: parent) }
      let_it_be(:sibling)    { create(:ci_pipeline, child_of: parent) }

      let(:project) { build(:project, :repository) }
      let(:bridge) do
        create(:ci_bridge, status: :pending, user: user, options: trigger, pipeline: child, project: project)
      end

      context 'when limit was specified by admin' do
        before do
          project.actual_limits.update!(pipeline_hierarchy_size: 3)
        end

        it 'does not create a new pipeline' do
          expect { subject }.not_to change { Ci::Pipeline.count }
        end

        it 'drops the trigger job with an explanatory reason' do
          subject

          expect(bridge.reload).to be_failed
          expect(bridge.failure_reason).to eq('reached_max_pipeline_hierarchy_size')
        end
      end

      context 'when there was no limit specified by admin' do
        before do
          allow(bridge.pipeline).to receive(:complete_hierarchy_count).and_return(1000)
        end

        context 'when pipeline count reaches the default limit of 1000' do
          it 'does not create a new pipeline' do
            expect { subject }.not_to change { Ci::Pipeline.count }
            expect(subject).to be_error
            expect(subject.message).to eq(""Pre-conditions not met"")
          end

          it 'drops the trigger job with an explanatory reason' do
            subject

            expect(bridge.reload).to be_failed
            expect(bridge.failure_reason).to eq('reached_max_pipeline_hierarchy_size')
          end
        end
      end
    end
  end

  context 'when downstream pipeline creation fails with unexpected errors', :aggregate_failures do
    before do
      downstream_project.add_developer(user)

      allow(::Ci::CreatePipelineService).to receive(:new)
        .and_raise(RuntimeError, 'undefined failure')
    end

    it 'drops the bridge without creating a pipeline' do
      expect { subject }
        .to raise_error(RuntimeError, /undefined failure/)
        .and change { Ci::Pipeline.count }.by(0)

      expect(bridge.reload).to be_failed
      expect(bridge.failure_reason).to eq('data_integrity_failure')
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class ArchiveTraceService
    include ::Gitlab::ExclusiveLeaseHelpers

    EXCLUSIVE_LOCK_KEY = 'archive_trace_service:batch_execute:lock'
    LOCK_TIMEOUT = 56.minutes
    LOOP_TIMEOUT = 55.minutes
    LOOP_LIMIT = 2000
    BATCH_SIZE = 100

    # rubocop: disable CodeReuse/ActiveRecord
    def batch_execute(worker_name:)
      start_time = Time.current
      in_lock(EXCLUSIVE_LOCK_KEY, ttl: LOCK_TIMEOUT, retries: 1) do
        Ci::Build.with_stale_live_trace.find_each(batch_size: BATCH_SIZE).with_index do |build, index|
          break if Time.current - start_time > LOOP_TIMEOUT

          if index > LOOP_LIMIT
            Sidekiq.logger.warn(class: worker_name, message: 'Loop limit reached.', job_id: build.id)
            break
          end

          begin
            execute(build, worker_name: worker_name)
          rescue StandardError
            next
          end
        end
      end
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def execute(job, worker_name:)
      unless job.trace.archival_attempts_available?
        Sidekiq.logger.warn(class: worker_name, message: 'The job is out of archival attempts.', job_id: job.id)

        job.trace.attempt_archive_cleanup!
        return
      end

      unless job.trace.can_attempt_archival_now?
        Sidekiq.logger.warn(class: worker_name, message: 'The job can not be archived right now.', job_id: job.id)
        return
      end

      job.trace.archive!
      job.remove_pending_state!

      if job.job_artifacts_trace.present?
        job.project.execute_integrations(Gitlab::DataBuilder::ArchiveTrace.build(job), :archive_trace_hooks)
      end
    rescue ::Gitlab::Ci::Trace::AlreadyArchivedError
      # It's already archived, thus we can safely ignore this exception.
    rescue StandardError => e
      job.trace.increment_archival_attempts!

      # Tracks this error with application logs, Sentry, and Prometheus.
      # If `archive!` keeps failing for over a week, that could incur data loss.
      # (See more https://docs.gitlab.com/ee/administration/job_logs.html#new-incremental-logging-architecture)
      # In order to avoid interrupting the system, we do not raise an exception here.
      archive_error(e, job, worker_name)
    end

    private

    def failed_archive_counter
      @failed_archive_counter ||=
        Gitlab::Metrics.counter(:job_trace_archive_failed_total, ""Counter of failed attempts of trace archiving"")
    end

    def archive_error(error, job, worker_name)
      failed_archive_counter.increment

      Sidekiq.logger.warn(
        class: worker_name,
        message: ""Failed to archive trace. message: #{error.message}."",
        job_id: job.id
      )

      Gitlab::ErrorTracking.track_and_raise_for_dev_exception(
        error,
        issue_url: 'https://gitlab.com/gitlab-org/gitlab-foss/issues/51502',
        job_id: job.id
      )
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::ArchiveTraceService, '#execute', feature_category: :continuous_integration do
  subject { described_class.new.execute(job, worker_name: Ci::ArchiveTraceWorker.name) }

  context 'when job is finished' do
    let(:job) { create(:ci_build, :success, :trace_live) }

    it 'creates an archived trace' do
      expect { subject }.not_to raise_error

      expect(job.reload.job_artifacts_trace).to be_exist
      expect(job.trace_metadata.trace_artifact).to eq(job.job_artifacts_trace)
    end

    context 'integration hooks' do
      it do
        expect(job.project).to receive(:execute_integrations) do |data, hook_type|
          expect(data).to eq Gitlab::DataBuilder::ArchiveTrace.build(job)
          expect(hook_type).to eq :archive_trace_hooks
        end
        expect { subject }.not_to raise_error
      end
    end

    context 'when trace is already archived' do
      let!(:job) { create(:ci_build, :success, :trace_artifact) }

      it 'ignores an exception' do
        expect { subject }.not_to raise_error
      end

      it 'does not create an archived trace' do
        expect { subject }.not_to change { Ci::JobArtifact.trace.count }
      end

      context 'when live trace chunks still exist' do
        before do
          create(:ci_build_trace_chunk, build: job, chunk_index: 0)
        end

        it 'removes the trace chunks' do
          expect { subject }.to change { job.trace_chunks.count }.to(0)
        end

        context 'when associated data does not exist' do
          before do
            job.job_artifacts_trace.file.remove!
          end

          it 'removes the trace artifact and builds a new one' do
            existing_trace = job.job_artifacts_trace
            expect(existing_trace).to receive(:destroy!).and_call_original

            subject

            expect(job.reload.job_artifacts_trace).to be_present
            expect(job.reload.job_artifacts_trace.file.file).to be_present
          end
        end
      end
    end

    context 'when the job is out of archival attempts' do
      before do
        create(:ci_build_trace_metadata,
          build: job,
          archival_attempts: Ci::BuildTraceMetadata::MAX_ATTEMPTS + 1,
          last_archival_attempt_at: 1.week.ago)
      end

      it 'skips archiving' do
        expect(job.trace).not_to receive(:archive!)

        subject
      end

      it 'leaves a warning message in sidekiq log' do
        expect(Sidekiq.logger).to receive(:warn).with(
          class: Ci::ArchiveTraceWorker.name,
          message: 'The job is out of archival attempts.',
          job_id: job.id)

        subject
      end

      context 'job has archive and chunks' do
        let(:job) { create(:ci_build, :success, :trace_artifact) }

        before do
          create(:ci_build_trace_chunk, build: job, chunk_index: 0)
        end

        context 'archive is not completed' do
          before do
            job.job_artifacts_trace.file.remove!
          end

          it 'cleanups any stale archive data' do
            expect(job.job_artifacts_trace).to be_present

            subject

            expect(job.reload.job_artifacts_trace).to be_nil
          end
        end

        it 'removes trace chunks' do
          expect { subject }.to change { job.trace_chunks.count }.to(0)
        end
      end
    end

    context 'when the archival process is backed off' do
      before do
        create(:ci_build_trace_metadata,
          build: job,
          archival_attempts: Ci::BuildTraceMetadata::MAX_ATTEMPTS - 1,
          last_archival_attempt_at: 1.hour.ago)
      end

      it 'skips archiving' do
        expect(job.trace).not_to receive(:archive!)

        subject
      end

      it 'leaves a warning message in sidekiq log' do
        expect(Sidekiq.logger).to receive(:warn).with(
          class: Ci::ArchiveTraceWorker.name,
          message: 'The job can not be archived right now.',
          job_id: job.id)

        subject
      end
    end
  end

  context 'when job is running' do
    let(:job) { create(:ci_build, :running, :trace_live) }

    it 'increments Prometheus counter, sends crash report to Sentry and ignore an error for continuing to archive' do
      expect(Gitlab::ErrorTracking)
        .to receive(:track_and_raise_for_dev_exception)
        .with(::Gitlab::Ci::Trace::ArchiveError,
          issue_url: 'https://gitlab.com/gitlab-org/gitlab-foss/issues/51502',
          job_id: job.id).once

      expect(Sidekiq.logger).to receive(:warn).with(
        class: Ci::ArchiveTraceWorker.name,
        message: ""Failed to archive trace. message: Job is not finished yet."",
        job_id: job.id).and_call_original

      expect(Gitlab::Metrics)
        .to receive(:counter)
        .with(:job_trace_archive_failed_total, ""Counter of failed attempts of trace archiving"")
        .and_call_original

      expect { subject }.not_to raise_error
      expect(job.trace_metadata.archival_attempts).to eq(1)
    end
  end

  describe '#batch_execute' do
    subject { described_class.new.batch_execute(worker_name: Ci::ArchiveTraceWorker.name) }

    let_it_be_with_reload(:job) { create(:ci_build, :success, :trace_live, finished_at: 1.day.ago) }
    let_it_be_with_reload(:job2) { create(:ci_build, :success, :trace_live, finished_at: 1.day.ago) }

    it 'archives multiple traces' do
      expect { subject }.not_to raise_error

      expect(job.reload.job_artifacts_trace).to be_exist
      expect(job2.reload.job_artifacts_trace).to be_exist
    end

    it 'processes traces independently' do
      allow_next_instance_of(Gitlab::Ci::Trace) do |instance|
        orig_method = instance.method(:archive!)
        allow(instance).to receive(:archive!) do
          raise('Unexpected error') if instance.job.id == job.id

          orig_method.call
        end
      end

      expect { subject }.not_to raise_error

      expect(job.reload.job_artifacts_trace).to be_nil
      expect(job2.reload.job_artifacts_trace).to be_exist
    end

    context 'when timeout is reached' do
      before do
        stub_const(""#{described_class}::LOOP_TIMEOUT"", 0.seconds)
      end

      it 'stops executing traces' do
        expect { subject }.not_to raise_error

        expect(job.reload.job_artifacts_trace).to be_nil
      end
    end

    context 'when loop limit is reached' do
      before do
        stub_const(""#{described_class}::LOOP_LIMIT"", -1)
      end

      it 'skips archiving' do
        expect(job.trace).not_to receive(:archive!)

        subject
      end

      it 'stops executing traces' do
        expect(Sidekiq.logger).to receive(:warn).with(
          class: Ci::ArchiveTraceWorker.name,
          message: ""Loop limit reached."",
          job_id: job.id)

        expect { subject }.not_to raise_error

        expect(job.reload.job_artifacts_trace).to be_nil
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class UnlockArtifactsService < ::BaseService
    BATCH_SIZE = 100

    def execute(ci_ref, before_pipeline = nil)
      results = {
        unlocked_pipelines: 0,
        unlocked_job_artifacts: 0,
        unlocked_pipeline_artifacts: 0
      }

      loop do
        unlocked_pipelines = []
        unlocked_job_artifacts = []

        ::Ci::Pipeline.transaction do
          unlocked_pipelines = unlock_pipelines(ci_ref, before_pipeline)
          unlocked_job_artifacts = unlock_job_artifacts(unlocked_pipelines)

          results[:unlocked_pipeline_artifacts] += unlock_pipeline_artifacts(unlocked_pipelines)
        end

        break if unlocked_pipelines.empty?

        results[:unlocked_pipelines] += unlocked_pipelines.length
        results[:unlocked_job_artifacts] += unlocked_job_artifacts.length
      end

      results
    end

    # rubocop:disable CodeReuse/ActiveRecord
    def unlock_job_artifacts_query(pipeline_ids)
      ci_job_artifacts = ::Ci::JobArtifact.arel_table

      build_ids = ::Ci::Build.select(:id).where(commit_id: pipeline_ids)

      returning = Arel::Nodes::Grouping.new(ci_job_artifacts[:id])

      Arel::UpdateManager.new
        .table(ci_job_artifacts)
        .where(ci_job_artifacts[:job_id].in(Arel.sql(build_ids.to_sql)))
        .set([[ci_job_artifacts[:locked], ::Ci::JobArtifact.lockeds[:unlocked]]])
        .to_sql + "" RETURNING #{returning.to_sql}""
    end
    # rubocop:enable CodeReuse/ActiveRecord

    # rubocop:disable CodeReuse/ActiveRecord
    def unlock_pipelines_query(ci_ref, before_pipeline)
      ci_pipelines = ::Ci::Pipeline.arel_table

      pipelines_scope = ci_ref.pipelines.artifacts_locked
      pipelines_scope = pipelines_scope.before_pipeline(before_pipeline) if before_pipeline
      pipelines_scope = pipelines_scope.select(:id).limit(BATCH_SIZE).lock('FOR UPDATE SKIP LOCKED')

      returning = Arel::Nodes::Grouping.new(ci_pipelines[:id])

      Arel::UpdateManager.new
        .table(ci_pipelines)
        .where(ci_pipelines[:id].in(Arel.sql(pipelines_scope.to_sql)))
        .set([[ci_pipelines[:locked], ::Ci::Pipeline.lockeds[:unlocked]]])
        .to_sql + "" RETURNING #{returning.to_sql}""
    end
    # rubocop:enable CodeReuse/ActiveRecord

    private

    def unlock_job_artifacts(pipelines)
      return if pipelines.empty?

      ::Ci::JobArtifact.connection.exec_query(
        unlock_job_artifacts_query(pipelines.rows.flatten)
      )
    end

    # rubocop:disable CodeReuse/ActiveRecord
    def unlock_pipeline_artifacts(pipelines)
      return 0 if pipelines.empty?

      ::Ci::PipelineArtifact.where(pipeline_id: pipelines.rows.flatten).update_all(locked: :unlocked)
    end
    # rubocop:enable CodeReuse/ActiveRecord

    def unlock_pipelines(ci_ref, before_pipeline)
      ::Ci::Pipeline.connection.exec_query(unlock_pipelines_query(ci_ref, before_pipeline))
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::UnlockArtifactsService, feature_category: :continuous_integration do
  using RSpec::Parameterized::TableSyntax

  where(:tag) do
    [
      [false],
      [true]
    ]
  end

  with_them do
    let(:ref) { 'master' }
    let(:ref_path) { tag ? ""#{::Gitlab::Git::TAG_REF_PREFIX}#{ref}"" : ""#{::Gitlab::Git::BRANCH_REF_PREFIX}#{ref}"" }
    let(:ci_ref) { create(:ci_ref, ref_path: ref_path) }
    let(:project) { ci_ref.project }
    let(:source_job) { create(:ci_build, pipeline: pipeline) }

    let!(:old_unlocked_pipeline) { create(:ci_pipeline, :with_persisted_artifacts, ref: ref, tag: tag, project: project, locked: :unlocked) }
    let!(:older_pipeline) { create(:ci_pipeline, :with_persisted_artifacts, ref: ref, tag: tag, project: project, locked: :artifacts_locked) }
    let!(:older_ambiguous_pipeline) { create(:ci_pipeline, :with_persisted_artifacts, ref: ref, tag: !tag, project: project, locked: :artifacts_locked) }
    let!(:code_coverage_pipeline) { create(:ci_pipeline, :with_coverage_report_artifact, ref: ref, tag: tag, project: project, locked: :artifacts_locked) }
    let!(:pipeline) { create(:ci_pipeline, :with_persisted_artifacts, ref: ref, tag: tag, project: project, locked: :artifacts_locked) }
    let!(:child_pipeline) { create(:ci_pipeline, :with_persisted_artifacts, ref: ref, tag: tag, child_of: pipeline, project: project, locked: :artifacts_locked) }
    let!(:newer_pipeline) { create(:ci_pipeline, :with_persisted_artifacts, ref: ref, tag: tag, project: project, locked: :artifacts_locked) }
    let!(:other_ref_pipeline) { create(:ci_pipeline, :with_persisted_artifacts, ref: 'other_ref', tag: tag, project: project, locked: :artifacts_locked) }
    let!(:sources_pipeline) { create(:ci_sources_pipeline, source_job: source_job, source_project: project, pipeline: child_pipeline, project: project) }

    before do
      stub_const(""#{described_class}::BATCH_SIZE"", 1)
    end

    describe '#execute' do
      subject(:execute) { described_class.new(pipeline.project, pipeline.user).execute(ci_ref, before_pipeline) }

      context 'when running on a ref before a pipeline' do
        let(:before_pipeline) { pipeline }

        it 'unlocks artifacts from older pipelines' do
          expect { execute }.to change { older_pipeline.reload.locked }.from('artifacts_locked').to('unlocked')
        end

        it 'does not unlock artifacts for tag or branch with same name as ref' do
          expect { execute }.not_to change { older_ambiguous_pipeline.reload.locked }.from('artifacts_locked')
        end

        it 'does not unlock artifacts from newer pipelines' do
          expect { execute }.not_to change { newer_pipeline.reload.locked }.from('artifacts_locked')
        end

        it 'does not lock artifacts from old unlocked pipelines' do
          expect { execute }.not_to change { old_unlocked_pipeline.reload.locked }.from('unlocked')
        end

        it 'does not unlock artifacts from the same pipeline' do
          expect { execute }.not_to change { pipeline.reload.locked }.from('artifacts_locked')
        end

        it 'does not unlock artifacts for other refs' do
          expect { execute }.not_to change { other_ref_pipeline.reload.locked }.from('artifacts_locked')
        end

        it 'does not unlock artifacts for child pipeline' do
          expect { execute }.not_to change { child_pipeline.reload.locked }.from('artifacts_locked')
        end

        it 'unlocks job artifact records' do
          expect { execute }.to change { ::Ci::JobArtifact.artifact_unlocked.count }.from(0).to(2)
        end

        it 'unlocks pipeline artifact records' do
          expect { execute }.to change { ::Ci::PipelineArtifact.artifact_unlocked.count }.from(0).to(1)
        end
      end

      context 'when running on just the ref' do
        let(:before_pipeline) { nil }

        it 'unlocks artifacts from older pipelines' do
          expect { execute }.to change { older_pipeline.reload.locked }.from('artifacts_locked').to('unlocked')
        end

        it 'unlocks artifacts from newer pipelines' do
          expect { execute }.to change { newer_pipeline.reload.locked }.from('artifacts_locked').to('unlocked')
        end

        it 'unlocks artifacts from the same pipeline' do
          expect { execute }.to change { pipeline.reload.locked }.from('artifacts_locked').to('unlocked')
        end

        it 'does not unlock artifacts for tag or branch with same name as ref' do
          expect { execute }.not_to change { older_ambiguous_pipeline.reload.locked }.from('artifacts_locked')
        end

        it 'does not lock artifacts from old unlocked pipelines' do
          expect { execute }.not_to change { old_unlocked_pipeline.reload.locked }.from('unlocked')
        end

        it 'does not unlock artifacts for other refs' do
          expect { execute }.not_to change { other_ref_pipeline.reload.locked }.from('artifacts_locked')
        end

        it 'unlocks job artifact records' do
          expect { execute }.to change { ::Ci::JobArtifact.artifact_unlocked.count }.from(0).to(8)
        end

        it 'unlocks pipeline artifact records' do
          expect { execute }.to change { ::Ci::PipelineArtifact.artifact_unlocked.count }.from(0).to(1)
        end
      end
    end

    describe '#unlock_pipelines_query' do
      subject { described_class.new(pipeline.project, pipeline.user).unlock_pipelines_query(ci_ref, before_pipeline) }

      context 'when running on a ref before a pipeline' do
        let(:before_pipeline) { pipeline }

        it 'produces the expected SQL string' do
          # To be removed when the ignored column id_convert_to_bigint for ci_pipelines is removed
          # see https://gitlab.com/gitlab-org/gitlab/-/issues/397000
          selected_columns =
            Ci::Pipeline.column_names.map do |field|
              Ci::Pipeline.connection.quote_table_name(""#{Ci::Pipeline.table_name}.#{field}"")
            end.join(', ')
          expect(subject.squish).to eq <<~SQL.squish
            UPDATE
                ""ci_pipelines""
            SET
                ""locked"" = 0
            WHERE
                ""ci_pipelines"".""id"" IN
                    (SELECT
                        ""ci_pipelines"".""id""
                    FROM
                        ""ci_pipelines""
                    WHERE
                        ""ci_pipelines"".""ci_ref_id"" = #{ci_ref.id}
                        AND ""ci_pipelines"".""locked"" = 1
                        AND ""ci_pipelines"".""id"" < #{before_pipeline.id}
                        AND ""ci_pipelines"".""id"" NOT IN
                            (WITH RECURSIVE
                                ""base_and_descendants""
                            AS
                                ((SELECT
                                    #{selected_columns}
                                FROM
                                    ""ci_pipelines""
                                WHERE
                                    ""ci_pipelines"".""id"" = #{before_pipeline.id})
                            UNION
                                (SELECT
                                    #{selected_columns}
                                FROM
                                    ""ci_pipelines"",
                                    ""base_and_descendants"",
                                    ""ci_sources_pipelines""
                                WHERE
                                    ""ci_sources_pipelines"".""pipeline_id"" = ""ci_pipelines"".""id""
                                    AND ""ci_sources_pipelines"".""source_pipeline_id"" = ""base_and_descendants"".""id""
                                    AND ""ci_sources_pipelines"".""source_project_id"" = ""ci_sources_pipelines"".""project_id""))
                            SELECT
                                ""id""
                            FROM
                                ""base_and_descendants""
                            AS
                                ""ci_pipelines"")
                    LIMIT 1
                    FOR UPDATE
                    SKIP LOCKED)
            RETURNING (""ci_pipelines"".""id"")
          SQL
        end
      end

      context 'when running on just the ref' do
        let(:before_pipeline) { nil }

        it 'produces the expected SQL string' do
          expect(subject.squish).to eq <<~SQL.squish
            UPDATE
                ""ci_pipelines""
            SET
                ""locked"" = 0
            WHERE
                ""ci_pipelines"".""id"" IN
                    (SELECT
                        ""ci_pipelines"".""id""
                    FROM
                        ""ci_pipelines""
                    WHERE
                        ""ci_pipelines"".""ci_ref_id"" = #{ci_ref.id}
                        AND ""ci_pipelines"".""locked"" = 1
                    LIMIT 1
                    FOR UPDATE
                        SKIP LOCKED)
            RETURNING
                (""ci_pipelines"".""id"")
          SQL
        end
      end
    end

    describe '#unlock_job_artifacts_query' do
      subject { described_class.new(pipeline.project, pipeline.user).unlock_job_artifacts_query(pipeline_ids) }

      let(:builds_table) { Ci::Build.quoted_table_name }

      context 'when given a single pipeline ID' do
        let(:pipeline_ids) { [older_pipeline.id] }

        it 'produces the expected SQL string' do
          expect(subject.squish).to eq <<~SQL.squish
            UPDATE
                ""ci_job_artifacts""
            SET
                ""locked"" = 0
            WHERE
                ""ci_job_artifacts"".""job_id"" IN
                    (SELECT
                        #{builds_table}.""id""
                    FROM
                        #{builds_table}
                    WHERE
                        #{builds_table}.""type"" = 'Ci::Build'
                        AND #{builds_table}.""commit_id"" = #{older_pipeline.id})
            RETURNING
                (""ci_job_artifacts"".""id"")
          SQL
        end
      end

      context 'when given multiple pipeline IDs' do
        let(:pipeline_ids) { [older_pipeline.id, newer_pipeline.id, pipeline.id] }

        it 'produces the expected SQL string' do
          expect(subject.squish).to eq <<~SQL.squish
            UPDATE
                ""ci_job_artifacts""
            SET
                ""locked"" = 0
            WHERE
                ""ci_job_artifacts"".""job_id"" IN
                    (SELECT
                        #{builds_table}.""id""
                    FROM
                        #{builds_table}
                    WHERE
                        #{builds_table}.""type"" = 'Ci::Build'
                        AND #{builds_table}.""commit_id"" IN (#{pipeline_ids.join(', ')}))
            RETURNING
                (""ci_job_artifacts"".""id"")
          SQL
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  # Cancel a pipelines cancelable jobs and optionally it's child pipelines cancelable jobs
  class CancelPipelineService
    include Gitlab::OptimisticLocking
    include Gitlab::Allowable

    ##
    # @cascade_to_children - if true cancels all related child pipelines for parent child pipelines
    # @auto_canceled_by_pipeline - store the pipeline_id of the pipeline that triggered cancellation
    # @execute_async - if true cancel the children asyncronously
    def initialize(
      pipeline:,
      current_user:,
      cascade_to_children: true,
      auto_canceled_by_pipeline: nil,
      execute_async: true)
      @pipeline = pipeline
      @current_user = current_user
      @cascade_to_children = cascade_to_children
      @auto_canceled_by_pipeline = auto_canceled_by_pipeline
      @execute_async = execute_async
    end

    def execute
      return permission_error_response unless can?(current_user, :cancel_pipeline, pipeline)

      force_execute
    end

    # This method should be used only when we want to always cancel the pipeline without
    # checking whether the current_user has permissions to do so, or when we don't have
    # a current_user available in the context.
    def force_execute
      return ServiceResponse.error(message: 'No pipeline provided', reason: :no_pipeline) unless pipeline

      unless pipeline.cancelable?
        return ServiceResponse.error(message: 'Pipeline is not cancelable', reason: :pipeline_not_cancelable)
      end

      log_pipeline_being_canceled

      pipeline.update_column(:auto_canceled_by_id, @auto_canceled_by_pipeline.id) if @auto_canceled_by_pipeline
      cancel_jobs(pipeline.cancelable_statuses)

      return ServiceResponse.success unless cascade_to_children?

      # cancel any bridges that could spin up new child pipelines
      cancel_jobs(pipeline.bridges_in_self_and_project_descendants.cancelable)
      cancel_children

      ServiceResponse.success
    end

    private

    attr_reader :pipeline, :current_user

    def log_pipeline_being_canceled
      Gitlab::AppJsonLogger.info(
        event: 'pipeline_cancel_running',
        pipeline_id: pipeline.id,
        auto_canceled_by_pipeline_id: @auto_canceled_by_pipeline&.id,
        cascade_to_children: cascade_to_children?,
        execute_async: execute_async?,
        **Gitlab::ApplicationContext.current
      )
    end

    def cascade_to_children?
      @cascade_to_children
    end

    def execute_async?
      @execute_async
    end

    def cancel_jobs(jobs)
      retries = 3
      retry_lock(jobs, retries, name: 'ci_pipeline_cancel_running') do |jobs_to_cancel|
        preloaded_relations = [:project, :pipeline, :deployment, :taggings]

        jobs_to_cancel.find_in_batches do |batch|
          relation = CommitStatus.id_in(batch)
          Preloaders::CommitStatusPreloader.new(relation).execute(preloaded_relations)

          relation.each { |job| cancel_job(job) }
        end
      end
    end

    def cancel_job(job)
      if @auto_canceled_by_pipeline
        job.auto_canceled_by_id = @auto_canceled_by_pipeline.id
        job.auto_canceled_by_partition_id = @auto_canceled_by_pipeline.partition_id
      end

      job.cancel
    end

    def permission_error_response
      ServiceResponse.error(
        message: 'Insufficient permissions to cancel the pipeline',
        reason: :insufficient_permissions
      )
    end

    # For parent child-pipelines only (not multi-project)
    def cancel_children
      pipeline.all_child_pipelines.each do |child_pipeline|
        if execute_async?
          ::Ci::CancelPipelineWorker.perform_async(
            child_pipeline.id,
            @auto_canceled_by_pipeline&.id
          )
        else
          # cascade_to_children is false because we iterate through children
          # we also cancel bridges prior to prevent more children
          self.class.new(
            pipeline: child_pipeline.reset,
            current_user: nil,
            cascade_to_children: false,
            execute_async: execute_async?,
            auto_canceled_by_pipeline: @auto_canceled_by_pipeline
          ).force_execute
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::CancelPipelineService, :aggregate_failures, feature_category: :continuous_integration do
  let_it_be(:project) { create(:project) }
  let_it_be(:current_user) { project.owner }
  let_it_be(:pipeline) { create(:ci_pipeline, project: project) }

  let(:service) do
    described_class.new(
      pipeline: pipeline,
      current_user: current_user,
      cascade_to_children: cascade_to_children,
      auto_canceled_by_pipeline: auto_canceled_by_pipeline,
      execute_async: execute_async)
  end

  let(:cascade_to_children) { true }
  let(:auto_canceled_by_pipeline) { nil }
  let(:execute_async) { true }

  shared_examples 'force_execute' do
    context 'when pipeline is not cancelable' do
      it 'returns an error' do
        expect(response).to be_error
        expect(response.reason).to eq(:pipeline_not_cancelable)
      end
    end

    context 'when pipeline is cancelable' do
      before do
        create(:ci_build, :running, pipeline: pipeline)
        create(:ci_build, :created, pipeline: pipeline)
        create(:ci_build, :success, pipeline: pipeline)
      end

      it 'logs the event' do
        allow(Gitlab::AppJsonLogger).to receive(:info)

        subject

        expect(Gitlab::AppJsonLogger)
          .to have_received(:info)
          .with(
            a_hash_including(
              event: 'pipeline_cancel_running',
              pipeline_id: pipeline.id,
              auto_canceled_by_pipeline_id: nil,
              cascade_to_children: true,
              execute_async: true
            )
          )
      end

      it 'cancels all cancelable jobs' do
        expect(response).to be_success
        expect(pipeline.all_jobs.pluck(:status)).to match_array(%w[canceled canceled success])
      end

      context 'when auto_canceled_by_pipeline is provided' do
        let(:auto_canceled_by_pipeline) { create(:ci_pipeline) }

        it 'updates the pipeline and jobs with it' do
          subject

          expect(pipeline.auto_canceled_by_id).to eq(auto_canceled_by_pipeline.id)

          expect(pipeline.all_jobs.canceled.pluck(:auto_canceled_by_id).uniq)
            .to eq([auto_canceled_by_pipeline.id])

          expect(pipeline.all_jobs.canceled.pluck(:auto_canceled_by_partition_id).uniq)
            .to eq([auto_canceled_by_pipeline.partition_id])
        end
      end

      context 'when pipeline has child pipelines' do
        let(:child_pipeline) { create(:ci_pipeline, child_of: pipeline) }
        let!(:child_job) { create(:ci_build, :running, pipeline: child_pipeline) }
        let(:grandchild_pipeline) { create(:ci_pipeline, child_of: child_pipeline) }
        let!(:grandchild_job) { create(:ci_build, :running, pipeline: grandchild_pipeline) }

        before do
          child_pipeline.source_bridge.update!(status: :running)
          grandchild_pipeline.source_bridge.update!(status: :running)
        end

        context 'when execute_async: false' do
          let(:execute_async) { false }

          it 'cancels the bridge jobs and child jobs' do
            expect(response).to be_success

            expect(pipeline.bridges.pluck(:status)).to be_all('canceled')
            expect(child_pipeline.bridges.pluck(:status)).to be_all('canceled')
            expect(child_job.reload).to be_canceled
            expect(grandchild_job.reload).to be_canceled
          end
        end

        context 'when execute_async: true' do
          it 'schedules the child pipelines for async cancelation' do
            expect(::Ci::CancelPipelineWorker)
              .to receive(:perform_async)
              .with(child_pipeline.id, nil)

            expect(::Ci::CancelPipelineWorker)
              .to receive(:perform_async)
              .with(grandchild_pipeline.id, nil)

            expect(response).to be_success

            expect(pipeline.bridges.pluck(:status)).to be_all('canceled')
          end
        end

        context 'when cascade_to_children: false' do
          let(:execute_async) { true }
          let(:cascade_to_children) { false }

          it 'does not cancel child pipelines' do
            expect(::Ci::CancelPipelineWorker)
              .not_to receive(:perform_async)

            expect(response).to be_success

            expect(pipeline.bridges.pluck(:status)).to be_all('canceled')
            expect(child_job.reload).to be_running
          end
        end
      end

      context 'when preloading relations' do
        let(:pipeline1) { create(:ci_pipeline, :created) }
        let(:pipeline2) { create(:ci_pipeline, :created) }

        before do
          create(:ci_build, :pending, pipeline: pipeline1)
          create(:generic_commit_status, :pending, pipeline: pipeline1)

          create(:ci_build, :pending, pipeline: pipeline2)
          create(:ci_build, :pending, pipeline: pipeline2)
          create(:generic_commit_status, :pending, pipeline: pipeline2)
          create(:generic_commit_status, :pending, pipeline: pipeline2)
          create(:generic_commit_status, :pending, pipeline: pipeline2)
        end

        it 'preloads relations for each build to avoid N+1 queries' do
          control1 = ActiveRecord::QueryRecorder.new do
            described_class.new(pipeline: pipeline1, current_user: current_user).force_execute
          end

          control2 = ActiveRecord::QueryRecorder.new do
            described_class.new(pipeline: pipeline2, current_user: current_user).force_execute
          end

          extra_update_queries = 4 # transition ... => :canceled, queue pop
          extra_generic_commit_status_validation_queries = 2 # name_uniqueness_across_types

          expect(control2.count)
            .to eq(control1.count + extra_update_queries + extra_generic_commit_status_validation_queries)
        end
      end
    end
  end

  describe '#execute' do
    subject(:response) { service.execute }

    it_behaves_like 'force_execute'

    context 'when user does not have permissions to cancel the pipeline' do
      let(:current_user) { create(:user) }

      it 'returns an error when user does not have permissions to cancel pipeline' do
        expect(response).to be_error
        expect(response.reason).to eq(:insufficient_permissions)
      end
    end
  end

  describe '#force_execute' do
    subject(:response) { service.force_execute }

    it_behaves_like 'force_execute'

    context 'when pipeline is not provided' do
      let(:pipeline) { nil }

      it 'returns an error' do
        expect(response).to be_error
        expect(response.reason).to eq(:no_pipeline)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  # This service resets skipped jobs so they can be processed again.
  # It affects the jobs that depend on the passed in job parameter.
  class ResetSkippedJobsService < ::BaseService
    def execute(processables)
      @processables = Array.wrap(processables)
      @pipeline = @processables.first.pipeline

      process_subsequent_jobs
      reset_source_bridge
    end

    private

    def process_subsequent_jobs
      dependent_jobs.each do |job|
        process(job)
      end
    end

    def reset_source_bridge
      @pipeline.reset_source_bridge!(current_user)
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def dependent_jobs
      ordered_by_dag(
        @pipeline.processables
          .from_union(needs_dependent_jobs, stage_dependent_jobs)
          .skipped
          .ordered_by_stage
          .preload(:needs)
      )
    end

    def process(job)
      Gitlab::OptimisticLocking.retry_lock(job, name: 'ci_requeue_job') do |job|
        job.process(current_user)
      end
    end

    def stage_dependent_jobs
      # Get all jobs after the earliest stage of the inputted jobs
      min_stage_idx = @processables.map(&:stage_idx).min
      @pipeline.processables.after_stage(min_stage_idx)
    end

    def needs_dependent_jobs
      # We must include the hierarchy base here because @processables may include both a parent job
      # and its dependents, and we do not want to exclude those dependents from being processed.
      ::Gitlab::Ci::ProcessableObjectHierarchy.new(
        ::Ci::Processable.where(id: @processables.map(&:id))
      ).base_and_descendants
    end

    def ordered_by_dag(jobs)
      sorted_job_names = sort_jobs(jobs).each_with_index.to_h

      jobs.group_by(&:stage_idx).flat_map do |_, stage_jobs|
        stage_jobs.sort_by { |job| sorted_job_names.fetch(job.name) }
      end
    end

    def sort_jobs(jobs)
      Gitlab::Ci::YamlProcessor::Dag.order(
        jobs.to_h do |job|
          [job.name, job.needs.map(&:name)]
        end
      )
    end
    # rubocop: enable CodeReuse/ActiveRecord
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::ResetSkippedJobsService, :sidekiq_inline, feature_category: :continuous_integration do
  let_it_be(:project) { create(:project, :empty_repo) }
  let_it_be(:user) { project.first_owner }

  let(:pipeline) do
    Ci::CreatePipelineService.new(project, user, { ref: 'master' }).execute(:push).payload
  end

  let(:a1) { find_job('a1') }
  let(:a2) { find_job('a2') }
  let(:b1) { find_job('b1') }
  let(:input_processables) { a1 } # This is the input used when running service.execute()

  before_all do
    project.repository.create_file(user, 'init', 'init', message: 'init', branch_name: 'master')
  end

  subject(:service) { described_class.new(project, user) }

  shared_examples 'with a stage-dag mixed pipeline' do
    let(:config) do
      <<-YAML
      stages: [a, b, c]

      a1:
        stage: a
        script: exit $(($RANDOM % 2))

      a2:
        stage: a
        script: exit 0
        needs: [a1]

      a3:
        stage: a
        script: exit 0
        needs: [a2]

      b1:
        stage: b
        script: exit 0
        needs: []

      b2:
        stage: b
        script: exit 0
        needs: [a2]

      c1:
        stage: c
        script: exit 0
        needs: [b2]

      c2:
        stage: c
        script: exit 0
      YAML
    end

    before do
      stub_ci_pipeline_yaml_file(config)
      check_jobs_statuses(
        a1: 'pending',
        a2: 'created',
        a3: 'created',
        b1: 'pending',
        b2: 'created',
        c1: 'created',
        c2: 'created'
      )

      b1.success!
      check_jobs_statuses(
        a1: 'pending',
        a2: 'created',
        a3: 'created',
        b1: 'success',
        b2: 'created',
        c1: 'created',
        c2: 'created'
      )

      a1.drop!
      check_jobs_statuses(
        a1: 'failed',
        a2: 'skipped',
        a3: 'skipped',
        b1: 'success',
        b2: 'skipped',
        c1: 'skipped',
        c2: 'skipped'
      )

      new_a1 = Ci::RetryJobService.new(project, user).clone!(a1)
      new_a1.enqueue!
      check_jobs_statuses(
        a1: 'pending',
        a2: 'skipped',
        a3: 'skipped',
        b1: 'success',
        b2: 'skipped',
        c1: 'skipped',
        c2: 'skipped'
      )
    end

    it 'marks subsequent skipped jobs as processable' do
      service.execute(input_processables)

      check_jobs_statuses(
        a1: 'pending',
        a2: 'created',
        a3: 'created',
        b1: 'success',
        b2: 'created',
        c1: 'created',
        c2: 'created'
      )
    end

    context 'when executed by a different user than the original owner' do
      let(:retryer) { create(:user).tap { |u| project.add_maintainer(u) } }
      let(:service) { described_class.new(project, retryer) }

      it 'reassigns jobs with updated statuses to the retryer' do
        expect(jobs_name_status_owner_needs).to contain_exactly(
          { 'name' => 'a1', 'status' => 'pending', 'user_id' => user.id, 'needs' => [] },
          { 'name' => 'a2', 'status' => 'skipped', 'user_id' => user.id, 'needs' => ['a1'] },
          { 'name' => 'a3', 'status' => 'skipped', 'user_id' => user.id, 'needs' => ['a2'] },
          { 'name' => 'b1', 'status' => 'success', 'user_id' => user.id, 'needs' => [] },
          { 'name' => 'b2', 'status' => 'skipped', 'user_id' => user.id, 'needs' => ['a2'] },
          { 'name' => 'c1', 'status' => 'skipped', 'user_id' => user.id, 'needs' => ['b2'] },
          { 'name' => 'c2', 'status' => 'skipped', 'user_id' => user.id, 'needs' => [] }
        )

        service.execute(input_processables)

        expect(jobs_name_status_owner_needs).to contain_exactly(
          { 'name' => 'a1', 'status' => 'pending', 'user_id' => user.id,    'needs' => [] },
          { 'name' => 'a2', 'status' => 'created', 'user_id' => retryer.id, 'needs' => ['a1'] },
          { 'name' => 'a3', 'status' => 'created', 'user_id' => retryer.id, 'needs' => ['a2'] },
          { 'name' => 'b1', 'status' => 'success', 'user_id' => user.id,    'needs' => [] },
          { 'name' => 'b2', 'status' => 'created', 'user_id' => retryer.id, 'needs' => ['a2'] },
          { 'name' => 'c1', 'status' => 'created', 'user_id' => retryer.id, 'needs' => ['b2'] },
          { 'name' => 'c2', 'status' => 'created', 'user_id' => retryer.id, 'needs' => [] }
        )
      end
    end
  end

  shared_examples 'with stage-dag mixed pipeline with some same-stage needs' do
    let(:config) do
      <<-YAML
      stages: [a, b, c]

      a1:
        stage: a
        script: exit $(($RANDOM % 2))

      a2:
        stage: a
        script: exit 0
        needs: [a1]

      b1:
        stage: b
        script: exit 0
        needs: [b2]

      b2:
        stage: b
        script: exit 0

      c1:
        stage: c
        script: exit 0
        needs: [b2]

      c2:
        stage: c
        script: exit 0
      YAML
    end

    before do
      stub_ci_pipeline_yaml_file(config)
      check_jobs_statuses(
        a1: 'pending',
        a2: 'created',
        b1: 'created',
        b2: 'created',
        c1: 'created',
        c2: 'created'
      )

      a1.drop!
      check_jobs_statuses(
        a1: 'failed',
        a2: 'skipped',
        b1: 'skipped',
        b2: 'skipped',
        c1: 'skipped',
        c2: 'skipped'
      )

      new_a1 = Ci::RetryJobService.new(project, user).clone!(a1)
      new_a1.enqueue!
      check_jobs_statuses(
        a1: 'pending',
        a2: 'skipped',
        b1: 'skipped',
        b2: 'skipped',
        c1: 'skipped',
        c2: 'skipped'
      )
    end

    it 'marks subsequent skipped jobs as processable' do
      service.execute(input_processables)

      check_jobs_statuses(
        a1: 'pending',
        a2: 'created',
        b1: 'created',
        b2: 'created',
        c1: 'created',
        c2: 'created'
      )
    end
  end

  shared_examples 'with same-stage needs' do
    let(:config) do
      <<-YAML
      a1:
        script: exit $(($RANDOM % 2))

      b1:
        script: exit 0
        needs: [a1]

      c1:
        script: exit 0
        needs: [b1]
      YAML
    end

    before do
      stub_ci_pipeline_yaml_file(config)
      check_jobs_statuses(
        a1: 'pending',
        b1: 'created',
        c1: 'created'
      )

      a1.drop!
      check_jobs_statuses(
        a1: 'failed',
        b1: 'skipped',
        c1: 'skipped'
      )

      new_a1 = Ci::RetryJobService.new(project, user).clone!(a1)
      new_a1.enqueue!
      check_jobs_statuses(
        a1: 'pending',
        b1: 'skipped',
        c1: 'skipped'
      )
    end

    it 'marks subsequent skipped jobs as processable' do
      service.execute(input_processables)

      check_jobs_statuses(
        a1: 'pending',
        b1: 'created',
        c1: 'created'
      )
    end
  end

  context 'with same-stage needs where the parent jobs do not share the same descendants' do
    let(:config) do
      <<-YAML
      a1:
        script: exit $(($RANDOM % 2))

      a2:
        script: exit $(($RANDOM % 2))

      b1:
        script: exit 0
        needs: [a1]

      b2:
        script: exit 0
        needs: [a2]

      c1:
        script: exit 0
        needs: [b1]

      c2:
        script: exit 0
        needs: [b2]
      YAML
    end

    before do
      stub_ci_pipeline_yaml_file(config)
      check_jobs_statuses(
        a1: 'pending',
        a2: 'pending',
        b1: 'created',
        b2: 'created',
        c1: 'created',
        c2: 'created'
      )

      a1.drop!
      a2.drop!

      check_jobs_statuses(
        a1: 'failed',
        a2: 'failed',
        b1: 'skipped',
        b2: 'skipped',
        c1: 'skipped',
        c2: 'skipped'
      )

      new_a1 = Ci::RetryJobService.new(project, user).clone!(a1)
      new_a1.enqueue!

      check_jobs_statuses(
        a1: 'pending',
        a2: 'failed',
        b1: 'skipped',
        b2: 'skipped',
        c1: 'skipped',
        c2: 'skipped'
      )

      new_a2 = Ci::RetryJobService.new(project, user).clone!(a2)
      new_a2.enqueue!

      check_jobs_statuses(
        a1: 'pending',
        a2: 'pending',
        b1: 'skipped',
        b2: 'skipped',
        c1: 'skipped',
        c2: 'skipped'
      )
    end

    # This demonstrates that when only a1 is inputted, only the *1 subsequent jobs are reset.
    # This is in contrast to the following example when both a1 and a2 are inputted.
    it 'marks subsequent skipped jobs as processable' do
      service.execute(input_processables)

      check_jobs_statuses(
        a1: 'pending',
        a2: 'pending',
        b1: 'created',
        b2: 'skipped',
        c1: 'created',
        c2: 'skipped'
      )
    end

    context 'when multiple processables are inputted' do
      # When both a1 and a2 are inputted, all subsequent jobs are reset.
      it 'marks subsequent skipped jobs as processable' do
        input_processables = [a1, a2]
        service.execute(input_processables)

        check_jobs_statuses(
          a1: 'pending',
          a2: 'pending',
          b1: 'created',
          b2: 'created',
          c1: 'created',
          c2: 'created'
        )
      end
    end
  end

  context 'when a single processable is inputted' do
    it_behaves_like 'with a stage-dag mixed pipeline'
    it_behaves_like 'with stage-dag mixed pipeline with some same-stage needs'
    it_behaves_like 'with same-stage needs'
  end

  context 'when multiple processables are inputted' do
    let(:input_processables) { [a1, b1] }

    it_behaves_like 'with a stage-dag mixed pipeline'
    it_behaves_like 'with stage-dag mixed pipeline with some same-stage needs'
    it_behaves_like 'with same-stage needs'
  end

  private

  def find_job(name)
    processables.find_by!(name: name)
  end

  def check_jobs_statuses(statuses)
    expect(processables.order(:name).pluck(:name, :status)).to contain_exactly(*statuses.stringify_keys.to_a)
  end

  def processables
    pipeline.processables.latest
  end

  def jobs_name_status_owner_needs
    processables.reload.map do |job|
      job.attributes.slice('name', 'status', 'user_id').merge('needs' => job.needs.map(&:name))
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class CopyCrossDatabaseAssociationsService
    def execute(old_build, new_build)
      ServiceResponse.success
    end
  end
end

Ci::CopyCrossDatabaseAssociationsService.prepend_mod_with('Ci::CopyCrossDatabaseAssociationsService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::CopyCrossDatabaseAssociationsService, feature_category: :continuous_integration do
  let_it_be(:project) { create(:project) }
  let_it_be(:pipeline) { create(:ci_pipeline, project: project) }
  let_it_be(:old_build) { create(:ci_build, pipeline: pipeline) }
  let_it_be(:new_build) { create(:ci_build, pipeline: pipeline) }

  subject(:execute) { described_class.new.execute(old_build, new_build) }

  describe '#execute' do
    it 'returns a success response' do
      expect(execute).to be_success
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class CompareTestReportsService < CompareReportsBaseService
    def comparer_class
      Gitlab::Ci::Reports::TestReportsComparer
    end

    def serializer_class
      TestReportsComparerSerializer
    end

    def get_report(pipeline)
      pipeline&.test_reports
    end

    def build_comparer(base_report, head_report)
      # We need to load the test failure history on the test comparer because we display
      # this on the MR widget
      super.tap do |test_reports_comparer|
        ::Gitlab::Ci::Reports::TestFailureHistory.new(failed_test_cases(test_reports_comparer), project).load!
      end
    end

    def failed_test_cases(test_reports_comparer)
      test_reports_comparer.suite_comparers.flat_map do |suite_comparer|
        suite_comparer.limited_tests.new_failures + suite_comparer.limited_tests.existing_failures
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::CompareTestReportsService, feature_category: :continuous_integration do
  let(:service) { described_class.new(project) }
  let(:project) { create(:project, :repository) }

  describe '#execute' do
    subject(:comparison) { service.execute(base_pipeline, head_pipeline) }

    context 'when head pipeline has test reports' do
      let!(:base_pipeline) { nil }
      let!(:head_pipeline) { create(:ci_pipeline, :with_test_reports, project: project) }

      it 'returns status and data' do
        expect(comparison[:status]).to eq(:parsed)
        expect(comparison[:data]).to match_schema('entities/test_reports_comparer')
      end
    end

    context 'when base and head pipelines have test reports' do
      let!(:base_pipeline) { create(:ci_pipeline, :with_test_reports, project: project) }
      let!(:head_pipeline) { create(:ci_pipeline, :with_test_reports, project: project) }

      it 'returns status and data' do
        expect(comparison[:status]).to eq(:parsed)
        expect(comparison[:data]).to match_schema('entities/test_reports_comparer')
      end
    end

    context 'when head pipeline has corrupted test reports' do
      let!(:base_pipeline) { nil }
      let!(:head_pipeline) { create(:ci_pipeline, project: project) }

      before do
        build = create(:ci_build, pipeline: head_pipeline, project: head_pipeline.project)
        create(:ci_job_artifact, :junit_with_corrupted_data, job: build, project: project)
      end

      it 'returns a parsed TestReports success status and failure on the individual suite' do
        expect(comparison[:status]).to eq(:parsed)
        expect(comparison.dig(:data, 'status')).to eq('success')
        expect(comparison.dig(:data, 'suites', 0, 'status')).to eq('error')
      end
    end

    context 'test failure history' do
      let!(:base_pipeline) { nil }
      let!(:head_pipeline) { create(:ci_pipeline, :with_test_reports_with_three_failures, project: project) }

      let(:new_failures) do
        comparison.dig(:data, 'suites', 0, 'new_failures')
      end

      let(:recent_failures_per_test_case) do
        new_failures.map { |f| f['recent_failures'] }
      end

      # Create test case failure records based on the head pipeline build
      before do
        stub_const(""Gitlab::Ci::Reports::TestSuiteComparer::DEFAULT_MAX_TESTS"", 2)
        stub_const(""Gitlab::Ci::Reports::TestSuiteComparer::DEFAULT_MIN_TESTS"", 1)

        build = head_pipeline.builds.last
        build.update_column(:finished_at, 1.day.ago) # Just to be sure we are included in the report window

        # The JUnit fixture for the given build has 3 failures.
        # This service will create 1 test case failure record for each.
        Ci::TestFailureHistoryService.new(head_pipeline).execute
      end

      it 'loads recent failures on limited test cases to avoid building up a huge DB query', :aggregate_failures do
        expect(comparison[:data]).to match_schema('entities/test_reports_comparer')
        expect(recent_failures_per_test_case).to eq(
          [
            { 'count' => 1, 'base_branch' => 'master' },
            { 'count' => 1, 'base_branch' => 'master' }
          ])
        expect(new_failures.count).to eq(2)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class PlayBuildService < ::BaseService
    def execute(build, job_variables_attributes = nil)
      check_access!(build, job_variables_attributes)

      Ci::EnqueueJobService.new(build, current_user: current_user, variables: job_variables_attributes || []).execute
    rescue StateMachines::InvalidTransition
      retry_build(build.reset)
    end

    private

    def retry_build(build)
      Ci::RetryJobService.new(project, current_user).execute(build)[:job]
    end

    def check_access!(build, job_variables_attributes)
      raise Gitlab::Access::AccessDeniedError unless can?(current_user, :play_job, build)

      if job_variables_attributes.present? && !can?(current_user, :set_pipeline_variables, project)
        raise Gitlab::Access::AccessDeniedError
      end
    end
  end
end

Ci::PlayBuildService.prepend_mod_with('Ci::PlayBuildService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::PlayBuildService, '#execute', feature_category: :continuous_integration do
  let(:user) { create(:user, developer_projects: [project]) }
  let(:project) { create(:project) }
  let(:pipeline) { create(:ci_pipeline, project: project) }
  let(:build) { create(:ci_build, :manual, pipeline: pipeline) }

  let(:service) do
    described_class.new(project, user)
  end

  context 'when project does not have repository yet' do
    let(:project) { create(:project) }

    it 'allows user to play build if protected branch rules are met' do
      create(:protected_branch, :developers_can_merge, name: build.ref, project: project)

      service.execute(build)

      expect(build.reload).to be_pending
    end

    it 'does not allow user with developer role to play build' do
      expect { service.execute(build) }
        .to raise_error Gitlab::Access::AccessDeniedError
    end
  end

  context 'when project has repository' do
    let(:project) { create(:project, :repository) }

    it 'allows user with developer role to play a build' do
      service.execute(build)

      expect(build.reload).to be_pending
    end

    it 'prevents a blocked developer from playing a build' do
      user.block!

      expect { service.execute(build) }.to raise_error(Gitlab::Access::AccessDeniedError)
    end
  end

  context 'when build is a playable manual action' do
    let(:build) { create(:ci_build, :manual, pipeline: pipeline) }
    let!(:branch) { create(:protected_branch, :developers_can_merge, name: build.ref, project: project) }

    it 'enqueues the build' do
      expect(service.execute(build)).to eq build
      expect(build.reload).to be_pending
    end

    it 'reassignes build user correctly' do
      service.execute(build)

      expect(build.reload.user).to eq user
    end

    context 'when a subsequent job is skipped' do
      let!(:job) { create(:ci_build, :skipped, pipeline: pipeline, stage_idx: build.stage_idx + 1) }

      it 'marks the subsequent job as processable' do
        expect { service.execute(build) }.to change { job.reload.status }.from('skipped').to('created')
      end
    end

    context 'when variables are supplied' do
      let(:job_variables) do
        [{ key: 'first', secret_value: 'first' },
         { key: 'second', secret_value: 'second' }]
      end

      subject { service.execute(build, job_variables) }

      it 'assigns the variables to the build' do
        subject

        expect(build.reload.job_variables.map(&:key)).to contain_exactly('first', 'second')
      end

      context 'and variables are invalid' do
        let(:job_variables) { [{}] }

        it 'resets the attributes of the build' do
          build.update!(job_variables_attributes: [{ key: 'old', value: 'old variable' }])

          subject

          expect(build.job_variables.map(&:key)).to contain_exactly('old')
        end
      end

      context 'when user defined variables are restricted' do
        before do
          project.update!(restrict_user_defined_variables: true)
        end

        context 'when user is maintainer' do
          before do
            project.add_maintainer(user)
          end

          it 'assigns the variables to the build' do
            subject

            expect(build.reload.job_variables.map(&:key)).to contain_exactly('first', 'second')
          end
        end

        context 'when user is developer' do
          it 'raises an error' do
            expect { subject }.to raise_error Gitlab::Access::AccessDeniedError
          end
        end
      end
    end
  end

  context 'when build is not a playable manual action' do
    let(:build) { create(:ci_build, :success, pipeline: pipeline) }
    let!(:branch) { create(:protected_branch, :developers_can_merge, name: build.ref, project: project) }

    it 'duplicates the build' do
      duplicate = service.execute(build)

      expect(duplicate).not_to eq build
      expect(duplicate).to be_pending
    end

    it 'assigns users correctly' do
      duplicate = service.execute(build)

      expect(build.user).not_to eq user
      expect(duplicate.user).to eq user
    end

    context 'and is not retryable' do
      let(:build) { create(:ci_build, :deployment_rejected, pipeline: pipeline) }

      it 'does not duplicate the build' do
        expect { service.execute(build) }.not_to change { Ci::Build.count }
      end

      it 'does not enqueue the build' do
        expect { service.execute(build) }.not_to change { build.status }
      end
    end
  end

  context 'when build is not action' do
    let(:user) { create(:user) }
    let(:build) { create(:ci_build, :success, pipeline: pipeline) }

    it 'raises an error' do
      expect { service.execute(build) }
        .to raise_error Gitlab::Access::AccessDeniedError
    end
  end

  context 'when user does not have ability to trigger action' do
    let(:user) { create(:user) }
    let!(:branch) { create(:protected_branch, :developers_can_merge, name: build.ref, project: project) }

    it 'raises an error' do
      expect { service.execute(build) }
        .to raise_error Gitlab::Access::AccessDeniedError
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class RetryPipelineService < ::BaseService
    include Gitlab::OptimisticLocking

    def execute(pipeline)
      access_response = check_access(pipeline)
      return access_response if access_response.error?

      pipeline.ensure_scheduling_type!

      builds_relation(pipeline).find_each do |build|
        next unless can_be_retried?(build)

        Ci::RetryJobService.new(project, current_user).clone!(build)
      end

      pipeline.processables.latest.skipped.find_each do |skipped|
        retry_optimistic_lock(skipped, name: 'ci_retry_pipeline') { |build| build.process(current_user) }
      end

      pipeline.reset_source_bridge!(current_user)

      ::MergeRequests::AddTodoWhenBuildFailsService
        .new(project: project, current_user: current_user)
        .close_all(pipeline)

      start_pipeline(pipeline)

      ServiceResponse.success
    rescue Gitlab::Access::AccessDeniedError => e
      ServiceResponse.error(message: e.message, http_status: :forbidden)
    end

    def check_access(pipeline)
      if can?(current_user, :update_pipeline, pipeline)
        ServiceResponse.success
      else
        ServiceResponse.error(message: '403 Forbidden', http_status: :forbidden)
      end
    end

    private

    def builds_relation(pipeline)
      pipeline.retryable_builds.preload_needs
    end

    def can_be_retried?(build)
      can?(current_user, :update_build, build)
    end

    def start_pipeline(pipeline)
      Ci::PipelineCreation::StartPipelineService.new(pipeline).execute
    end
  end
end

Ci::RetryPipelineService.prepend_mod_with('Ci::RetryPipelineService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::RetryPipelineService, '#execute', feature_category: :continuous_integration do
  include ProjectForksHelper

  let_it_be_with_refind(:user) { create(:user) }
  let_it_be_with_refind(:project) { create(:project) }

  let(:pipeline) { create(:ci_pipeline, project: project) }
  let(:build_stage) { create(:ci_stage, name: 'build', position: 0, pipeline: pipeline) }
  let(:test_stage) { create(:ci_stage, name: 'test', position: 1, pipeline: pipeline) }
  let(:deploy_stage) { create(:ci_stage, name: 'deploy', position: 2, pipeline: pipeline) }

  subject(:service) { described_class.new(project, user) }

  context 'when user has full ability to modify pipeline' do
    before do
      project.add_developer(user)

      create(:protected_branch, :developers_can_merge, name: pipeline.ref, project: project)
    end

    context 'when there are already retried jobs present' do
      before do
        create_build('rspec', :canceled, build_stage, retried: true)
        create_build('rspec', :failed, build_stage)
      end

      it 'does not retry jobs that has already been retried' do
        expect(statuses.first).to be_retried
        expect { service.execute(pipeline) }
          .to change { CommitStatus.count }.by(1)
      end
    end

    context 'when there are failed builds in the last stage' do
      before do
        create_build('rspec 1', :success, build_stage)
        create_build('rspec 2', :failed, test_stage)
        create_build('rspec 3', :canceled, test_stage)
      end

      it 'enqueues all builds in the last stage' do
        service.execute(pipeline)

        expect(build('rspec 2')).to be_pending
        expect(build('rspec 3')).to be_pending
        expect(pipeline.reload).to be_running
      end
    end

    context 'when there are failed or canceled builds in the first stage' do
      before do
        create_build('rspec 1', :failed, build_stage)
        create_build('rspec 2', :canceled, build_stage)
        create_build('rspec 3', :canceled, test_stage)
        create_build('spinach 1', :canceled, deploy_stage)
      end

      it 'retries builds failed builds and marks subsequent for processing' do
        service.execute(pipeline)

        expect(build('rspec 1')).to be_pending
        expect(build('rspec 2')).to be_pending
        expect(build('rspec 3')).to be_created
        expect(build('spinach 1')).to be_created
        expect(pipeline.reload).to be_running
      end

      it 'changes ownership of subsequent builds' do
        expect(build('rspec 2').user).not_to eq(user)
        expect(build('rspec 3').user).not_to eq(user)
        expect(build('spinach 1').user).not_to eq(user)

        service.execute(pipeline)

        expect(build('rspec 2').user).to eq(user)
        expect(build('rspec 3').user).to eq(user)
        expect(build('spinach 1').user).to eq(user)
      end
    end

    context 'when there is failed build present which was run on failure' do
      before do
        create_build('rspec 1', :failed, build_stage)
        create_build('rspec 2', :canceled, build_stage)
        create_build('rspec 3', :canceled, test_stage)
        create_build('report 1', :failed, deploy_stage)
      end

      it 'retries builds only in the first stage' do
        service.execute(pipeline)

        expect(build('rspec 1')).to be_pending
        expect(build('rspec 2')).to be_pending
        expect(build('rspec 3')).to be_created
        expect(build('report 1')).to be_created
        expect(pipeline.reload).to be_running
      end

      it 'creates a new job for report job in this case' do
        service.execute(pipeline)

        expect(statuses.find_by(name: 'report 1', status: 'failed')).to be_retried
      end
    end

    context 'when there is a failed test in a DAG' do
      before do
        create_build('build', :success, build_stage)
        create_build('build2', :success, build_stage)
        test_build = create_build('test', :failed, test_stage, scheduling_type: :dag)
        create(:ci_build_need, build: test_build, name: 'build')
        create(:ci_build_need, build: test_build, name: 'build2')
      end

      it 'retries the test' do
        service.execute(pipeline)

        expect(build('build')).to be_success
        expect(build('build2')).to be_success
        expect(build('test')).to be_pending
        expect(build('test').needs.map(&:name)).to match_array(%w[build build2])
      end

      context 'when there is a failed DAG test without needs' do
        before do
          create_build('deploy', :failed, deploy_stage, scheduling_type: :dag)
        end

        it 'retries the test' do
          service.execute(pipeline)

          expect(build('build')).to be_success
          expect(build('build2')).to be_success
          expect(build('test')).to be_pending
          expect(build('deploy')).to be_pending
        end
      end
    end

    context 'when the last stage was skipped' do
      before do
        create_build('build 1', :success, build_stage)
        create_build('test 2', :failed, test_stage)
        create_build('report 3', :skipped, deploy_stage)
        create_build('report 4', :skipped, deploy_stage)
      end

      it 'retries builds only in the first stage' do
        service.execute(pipeline)

        expect(build('build 1')).to be_success
        expect(build('test 2')).to be_pending
        expect(build('report 3')).to be_created
        expect(build('report 4')).to be_created
        expect(pipeline.reload).to be_running
      end
    end

    context 'when pipeline contains manual actions' do
      context 'when there are optional manual actions only' do
        context 'when there is a canceled manual action in first stage' do
          before do
            create_build('rspec 1', :failed, build_stage)
            create_build('staging', :canceled, build_stage, when: :manual, allow_failure: true)
            create_build('rspec 2', :canceled, test_stage)
          end

          it 'retries failed builds and marks subsequent for processing' do
            service.execute(pipeline)

            expect(build('rspec 1')).to be_pending
            expect(build('staging')).to be_manual
            expect(build('rspec 2')).to be_created
            expect(pipeline.reload).to be_running
          end

          it 'changes ownership of subsequent builds' do
            expect(build('staging').user).not_to eq(user)
            expect(build('rspec 2').user).not_to eq(user)

            service.execute(pipeline)

            expect(build('staging').user).to eq(user)
            expect(build('rspec 2').user).to eq(user)
          end
        end
      end

      context 'when pipeline has blocking manual actions defined' do
        context 'when pipeline retry should enqueue builds' do
          before do
            create_build('test', :failed, build_stage)
            create_build('deploy', :canceled, build_stage, when: :manual, allow_failure: false)
            create_build('verify', :canceled, test_stage)
          end

          it 'retries failed builds' do
            service.execute(pipeline)

            expect(build('test')).to be_pending
            expect(build('deploy')).to be_manual
            expect(build('verify')).to be_created
            expect(pipeline.reload).to be_running
          end
        end

        context 'when pipeline retry should block pipeline immediately' do
          before do
            create_build('test', :success, build_stage)
            create_build('deploy:1', :success, test_stage, when: :manual, allow_failure: false)
            create_build('deploy:2', :failed, test_stage, when: :manual, allow_failure: false)
            create_build('verify', :canceled, deploy_stage)
          end

          it 'reprocesses blocking manual action and blocks pipeline' do
            service.execute(pipeline)

            expect(build('deploy:1')).to be_success
            expect(build('deploy:2')).to be_manual
            expect(build('verify')).to be_created
            expect(pipeline.reload).to be_blocked
          end
        end
      end

      context 'when there is a skipped manual action in last stage' do
        before do
          create_build('rspec 1', :canceled, build_stage)
          create_build('rspec 2', :skipped, build_stage, when: :manual, allow_failure: true)
          create_build('staging', :skipped, test_stage, when: :manual, allow_failure: true)
        end

        it 'retries canceled job and reprocesses manual actions' do
          service.execute(pipeline)

          expect(build('rspec 1')).to be_pending
          expect(build('rspec 2')).to be_manual
          expect(build('staging')).to be_created
          expect(pipeline.reload).to be_running
        end
      end

      context 'when there is a created manual action in the last stage' do
        before do
          create_build('rspec 1', :canceled, build_stage)
          create_build('staging', :created, test_stage, when: :manual, allow_failure: true)
        end

        it 'retries canceled job and does not update the manual action' do
          service.execute(pipeline)

          expect(build('rspec 1')).to be_pending
          expect(build('staging')).to be_created
          expect(pipeline.reload).to be_running
        end
      end

      context 'when there is a created manual action in the first stage' do
        before do
          create_build('rspec 1', :canceled, build_stage)
          create_build('staging', :created, build_stage, when: :manual, allow_failure: true)
        end

        it 'retries canceled job and processes the manual action' do
          service.execute(pipeline)

          expect(build('rspec 1')).to be_pending
          expect(build('staging')).to be_manual
          expect(pipeline.reload).to be_running
        end
      end

      context 'when there is a failed manual action' do
        before do
          create_build('rspec', :success, build_stage)
          create_build('manual-rspec', :failed, build_stage, when: :manual, allow_failure: true)
        end

        it 'processes the manual action' do
          service.execute(pipeline)

          expect(build('rspec')).to be_success
          expect(build('manual-rspec')).to be_manual
          expect(pipeline.reload).to be_success
        end
      end
    end

    it 'closes all todos about failed jobs for pipeline' do
      expect(::MergeRequests::AddTodoWhenBuildFailsService)
        .to receive_message_chain(:new, :close_all)

      service.execute(pipeline)
    end

    it 'reprocesses the pipeline' do
      expect_any_instance_of(Ci::ProcessPipelineService).to receive(:execute)

      service.execute(pipeline)
    end

    context 'when pipeline has processables with nil scheduling_type' do
      let!(:build1) { create_build('build1', :success, build_stage) }
      let!(:build2) { create_build('build2', :failed, build_stage) }
      let!(:build3) { create_build('build3', :failed, test_stage) }
      let!(:build3_needs_build1) { create(:ci_build_need, build: build3, name: build1.name) }

      before do
        statuses.update_all(scheduling_type: nil)
      end

      it 'populates scheduling_type of processables' do
        service.execute(pipeline)

        expect(build1.reload.scheduling_type).to eq('stage')
        expect(build2.reload.scheduling_type).to eq('stage')
        expect(build3.reload.scheduling_type).to eq('dag')
      end
    end

    context 'when the pipeline is a downstream pipeline and the bridge is depended' do
      let!(:bridge) { create(:ci_bridge, :strategy_depend, status: 'success') }

      before do
        create(:ci_sources_pipeline, pipeline: pipeline, source_job: bridge)
      end

      context 'without permission' do
        it 'does nothing to the bridge' do
          expect { service.execute(pipeline) }.to not_change { bridge.reload.status }
           .and not_change { bridge.reload.user }
        end
      end

      context 'with permission' do
        let!(:bridge_pipeline) { create(:ci_pipeline, project: create(:project)) }
        let!(:bridge) do
          create(:ci_bridge, :strategy_depend, status: 'success', pipeline: bridge_pipeline)
        end

        before do
          bridge_pipeline.project.add_maintainer(user)
        end

        it 'marks source bridge as pending' do
          expect { service.execute(pipeline) }.to change { bridge.reload.status }.to('pending')
        end

        it 'assigns the current user to the source bridge' do
          expect { service.execute(pipeline) }.to change { bridge.reload.user }.to(user)
        end
      end
    end

    context 'when there are skipped jobs in later stages' do
      before do
        create_build('build 1', :success, build_stage)
        create_build('test 2', :failed, test_stage)
        create_build('report 3', :skipped, deploy_stage)
        create_bridge('deploy 4', :skipped, deploy_stage)
      end

      it 'retries failed jobs and processes skipped jobs' do
        service.execute(pipeline)

        expect(build('build 1')).to be_success
        expect(build('test 2')).to be_pending
        expect(build('report 3')).to be_created
        expect(build('deploy 4')).to be_created

        expect(pipeline.reload).to be_running
      end
    end

    context 'when user is not allowed to retry build' do
      before do
        build = create(:ci_build, pipeline: pipeline, status: :failed)
        allow_next_instance_of(Ci::RetryJobService) do |service|
          allow(service).to receive(:can?).with(user, :update_build, build).and_return(false)
        end
      end

      it 'returns an error' do
        response = service.execute(pipeline)

        expect(response.http_status).to eq(:forbidden)
        expect(response.errors).to include('403 Forbidden')
        expect(pipeline.reload).not_to be_running
      end
    end
  end

  context 'when user is not allowed to retry pipeline' do
    it 'returns an error' do
      response = service.execute(pipeline)

      expect(response.http_status).to eq(:forbidden)
      expect(response.errors).to include('403 Forbidden')
      expect(pipeline.reload).not_to be_running
    end
  end

  context 'when user is not allowed to trigger manual action' do
    before do
      project.add_developer(user)
      create(:protected_branch, :maintainers_can_push, name: pipeline.ref, project: project)
    end

    context 'when there is a failed manual action present' do
      before do
        create_build('test', :failed, build_stage)
        create_build('deploy', :failed, build_stage, when: :manual)
        create_build('verify', :canceled, test_stage)
      end

      it 'returns an error' do
        response = service.execute(pipeline)

        expect(response.http_status).to eq(:forbidden)
        expect(response.errors).to include('403 Forbidden')
        expect(pipeline.reload).not_to be_running
      end
    end

    context 'when there is a failed manual action in later stage' do
      before do
        create_build('test', :failed, build_stage)
        create_build('deploy', :failed, test_stage, when: :manual)
        create_build('verify', :canceled, deploy_stage)
      end

      it 'returns an error' do
        response = service.execute(pipeline)

        expect(response.http_status).to eq(:forbidden)
        expect(response.errors).to include('403 Forbidden')
        expect(pipeline.reload).not_to be_running
      end
    end
  end

  context 'when maintainer is allowed to push to forked project' do
    let(:user) { create(:user) }
    let(:project) { create(:project, :public) }
    let(:forked_project) { fork_project(project) }
    let(:pipeline) { create(:ci_pipeline, project: forked_project, ref: 'fixes') }

    before do
      project.add_maintainer(user)

      create_build('rspec 1', :failed, test_stage, project: project, ref: pipeline.ref)

      allow_any_instance_of(Project).to receive(:empty_repo?).and_return(false)
      allow_any_instance_of(Project).to receive(:branch_allows_collaboration?).and_return(true)
    end

    it 'allows to retry failed pipeline' do
      service.execute(pipeline)

      expect(build('rspec 1')).to be_pending
      expect(pipeline).to be_running
    end
  end

  def statuses
    pipeline.reload.statuses
  end

  # The method name can be confusing because this can actually return both Ci::Build and Ci::Bridge
  def build(name)
    statuses.latest.find_by(name: name)
  end

  def create_build(name, status, stage, **opts)
    create_processable(:ci_build, name, status, stage, **opts)
  end

  def create_bridge(name, status, stage, **opts)
    create_processable(:ci_bridge, name, status, stage, **opts)
  end

  def create_processable(type, name, status, stage, **opts)
    create(
      type,
      name: name,
      status: status,
      ci_stage: stage,
      stage_idx: stage.position,
      pipeline: pipeline,
      **opts
    ) do |_job|
      ::Ci::ProcessPipelineService.new(pipeline).execute
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class PipelineScheduleService < BaseService
    def execute(schedule)
      return unless project.persisted?

      # Ensure `next_run_at` is set properly before creating a pipeline.
      # Otherwise, multiple pipelines could be created in a short interval.
      schedule.schedule_next_run!
      RunPipelineScheduleWorker.perform_async(schedule.id, current_user&.id)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::PipelineScheduleService, feature_category: :continuous_integration do
  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project) }

  let(:service) { described_class.new(project, user) }

  describe '#execute' do
    subject { service.execute(schedule) }

    let_it_be(:schedule) { create(:ci_pipeline_schedule, project: project, owner: user) }

    it 'schedules next run' do
      expect(schedule).to receive(:schedule_next_run!)

      subject
    end

    it 'runs RunPipelineScheduleWorker' do
      expect(RunPipelineScheduleWorker)
        .to receive(:perform_async).with(schedule.id, schedule.owner.id)

      subject
    end

    context 'when owner is nil' do
      let(:schedule) { create(:ci_pipeline_schedule, project: project, owner: nil) }

      it 'does not raise an error' do
        expect { subject }.not_to raise_error
      end
    end

    context 'when the project is missing' do
      let(:project) { create(:project).tap(&:delete) }

      it 'does not raise an exception' do
        expect { subject }.not_to raise_error
      end

      it 'does not run RunPipelineScheduleWorker' do
        expect(RunPipelineScheduleWorker)
          .not_to receive(:perform_async).with(schedule.id, schedule.owner.id)

        subject
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  ##
  # We call this service everytime we persist a CI/CD job.
  #
  # In most cases a job should already have a stage assigned,  but in cases it
  # doesn't have we need to either find existing one or create a brand new
  # stage.
  #
  class EnsureStageService < BaseService
    EnsureStageError = Class.new(StandardError)

    def execute(build)
      @build = build

      return if build.stage_id.present?
      return if build.invalid?

      ensure_stage.tap do |stage|
        build.stage_id = stage.id

        yield stage if block_given?
      end
    end

    private

    def ensure_stage(attempts: 2)
      find_stage || create_stage
    rescue ActiveRecord::RecordNotUnique
      retry if (attempts -= 1) > 0

      raise EnsureStageError, <<~EOS
        We failed to find or create a unique pipeline stage after 2 retries.
        This should never happen and is most likely the result of a bug in
        the database load balancing code.
      EOS
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def find_stage
      @build.pipeline.stages.find_by(name: @build.stage)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def create_stage
      Ci::Stage.create!(
        name: @build.stage,
        position: @build.stage_idx,
        pipeline: @build.pipeline,
        project: @build.project
      )
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::EnsureStageService, '#execute', feature_category: :continuous_integration do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }

  let(:stage) { create(:ci_stage) }
  let(:job) { build(:ci_build) }

  let(:service) { described_class.new(project, user) }

  context 'when build has a stage assigned' do
    it 'does not create a new stage' do
      job.assign_attributes(stage_id: stage.id)

      expect { service.execute(job) }.not_to change { Ci::Stage.count }
    end
  end

  context 'when build does not have a stage assigned' do
    it 'creates a new stage' do
      job.assign_attributes(stage_id: nil, stage: 'test')

      expect { service.execute(job) }.to change { Ci::Stage.count }.by(1)
    end
  end

  context 'when build is invalid' do
    it 'does not create a new stage' do
      job.assign_attributes(stage_id: nil, ref: nil)

      expect { service.execute(job) }.not_to change { Ci::Stage.count }
    end
  end

  context 'when new stage can not be created because of an exception' do
    before do
      allow(Ci::Stage).to receive(:create!)
        .and_raise(ActiveRecord::RecordNotUnique.new('Duplicates!'))
    end

    it 'retries up to two times' do
      job.assign_attributes(stage_id: nil)

      expect(service).to receive(:find_stage).twice

      expect { service.execute(job) }
        .to raise_error(Ci::EnsureStageService::EnsureStageError)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class ChangeVariableService < BaseContainerService
    def execute
      case params[:action]
      when :create
        container.variables.create(params[:variable_params])
      when :update
        variable.tap do |target_variable|
          target_variable.update(params[:variable_params].except(:key))
        end
      when :destroy
        variable.tap do |target_variable|
          target_variable.destroy
        end
      end
    end

    private

    def variable
      params[:variable] || find_variable
    end

    def find_variable
      identifier = params[:variable_params].slice(:id).presence || params[:variable_params].slice(:key)
      container.variables.find_by!(identifier) # rubocop:disable CodeReuse/ActiveRecord
    end
  end
end

::Ci::ChangeVariableService.prepend_mod_with('Ci::ChangeVariableService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::ChangeVariableService, feature_category: :secrets_management do
  let(:service) { described_class.new(container: group, current_user: user, params: params) }

  let_it_be(:user) { create(:user) }

  let(:group) { create(:group) }

  describe '#execute' do
    subject(:execute) { service.execute }

    context 'when creating a variable' do
      let(:params) { { variable_params: { key: 'new_variable', value: 'variable_value' }, action: :create } }

      it 'persists a variable' do
        expect { execute }.to change(Ci::GroupVariable, :count).from(0).to(1)
      end
    end

    context 'when updating a variable' do
      let!(:variable) { create(:ci_group_variable, value: 'old_value') }
      let(:params) { { variable_params: { key: variable.key, value: 'new_value' }, action: :update } }

      before do
        group.variables << variable
      end

      it 'updates a variable' do
        expect { execute }.to change { variable.reload.value }.from('old_value').to('new_value')
      end

      context 'when the variable does not exist' do
        before do
          variable.destroy!
        end

        it 'raises a record not found error' do
          expect { execute }.to raise_error(::ActiveRecord::RecordNotFound)
        end
      end
    end

    context 'when destroying a variable' do
      let!(:variable) { create(:ci_group_variable) }
      let(:params) { { variable_params: { key: variable.key }, action: :destroy } }

      before do
        group.variables << variable
      end

      it 'destroys a variable' do
        expect { execute }.to change { Ci::GroupVariable.exists?(variable.id) }.from(true).to(false)
      end

      context 'when the variable does not exist' do
        before do
          variable.destroy!
        end

        it 'raises a record not found error' do
          expect { execute }.to raise_error(::ActiveRecord::RecordNotFound)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class DestroyPipelineService < BaseService
    def execute(pipeline)
      raise Gitlab::Access::AccessDeniedError unless can?(current_user, :destroy_pipeline, pipeline)

      Ci::ExpirePipelineCacheService.new.execute(pipeline, delete: true)

      # ensure cancellation happens sync so we accumulate compute minutes successfully
      # before deleting the pipeline.
      ::Ci::CancelPipelineService.new(
        pipeline: pipeline,
        current_user: current_user,
        cascade_to_children: true,
        execute_async: false).force_execute

      # The pipeline, the builds, job and pipeline artifacts all get destroyed here.
      # Ci::Pipeline#destroy triggers fast destroy on job_artifacts and
      # build_trace_chunks to remove the records and data stored in object storage.
      # ci_builds records are deleted using ON DELETE CASCADE from ci_pipelines
      #
      pipeline.reset.destroy!

      ServiceResponse.success(message: 'Pipeline not found')
    rescue ActiveRecord::RecordNotFound
      ServiceResponse.error(message: 'Pipeline not found')
    end
  end
end

Ci::DestroyPipelineService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ci::DestroyPipelineService, feature_category: :continuous_integration do
  let_it_be(:project) { create(:project, :repository) }

  let!(:pipeline) { create(:ci_pipeline, :success, project: project, sha: project.commit.id) }

  subject { described_class.new(project, user).execute(pipeline) }

  context 'user is owner' do
    let(:user) { project.first_owner }

    it 'destroys the pipeline' do
      subject

      expect { pipeline.reload }.to raise_error(ActiveRecord::RecordNotFound)
    end

    it 'clears the cache', :use_clean_rails_redis_caching do
      create(:commit_status, :success, pipeline: pipeline, ref: pipeline.ref)

      expect(project.pipeline_status.has_status?).to be_truthy

      subject

      # We need to reset lazy_latest_pipeline cache to simulate a new request
      BatchLoader::Executor.clear_current

      # Need to use find to avoid memoization
      expect(Project.find(project.id).pipeline_status.has_status?).to be_falsey
    end

    it 'does not log an audit event' do
      expect { subject }.not_to change { AuditEvent.count }
    end

    context 'when the pipeline has jobs' do
      let!(:build) { create(:ci_build, project: project, pipeline: pipeline) }

      it 'destroys associated jobs' do
        subject

        expect { build.reload }.to raise_error(ActiveRecord::RecordNotFound)
      end

      it 'destroys associated stages' do
        stages = pipeline.stages

        subject

        expect(stages).to all(raise_error(ActiveRecord::RecordNotFound))
      end

      context 'when job has artifacts' do
        let!(:artifact) { create(:ci_job_artifact, :archive, job: build) }

        it 'destroys associated artifacts' do
          subject

          expect { artifact.reload }.to raise_error(ActiveRecord::RecordNotFound)
        end

        it 'inserts deleted objects for object storage files' do
          expect { subject }.to change { Ci::DeletedObject.count }
        end
      end

      context 'when job has trace chunks' do
        let(:connection_params) { Gitlab.config.artifacts.object_store.connection.symbolize_keys }
        let(:connection) { ::Fog::Storage.new(connection_params) }

        before do
          stub_object_storage(connection_params: connection_params, remote_directory: 'artifacts')
          stub_artifacts_object_storage
        end

        let!(:trace_chunk) { create(:ci_build_trace_chunk, :fog_with_data, build: build) }

        it 'destroys associated trace chunks' do
          subject

          expect { trace_chunk.reload }.to raise_error(ActiveRecord::RecordNotFound)
        end

        it 'removes data from object store' do
          expect { subject }.to change { Ci::BuildTraceChunks::Fog.new.data(trace_chunk) }
        end
      end
    end

    context 'when pipeline is in cancelable state', :sidekiq_inline do
      let!(:build) { create(:ci_build, :running, pipeline: pipeline) }
      let!(:child_pipeline) { create(:ci_pipeline, :running, child_of: pipeline) }
      let!(:child_build) { create(:ci_build, :running, pipeline: child_pipeline) }

      it 'cancels the pipelines sync' do
        cancel_pipeline_service = instance_double(::Ci::CancelPipelineService)
        expect(::Ci::CancelPipelineService)
          .to receive(:new)
          .with(pipeline: pipeline, current_user: user, cascade_to_children: true, execute_async: false)
          .and_return(cancel_pipeline_service)

        expect(cancel_pipeline_service).to receive(:force_execute)

        subject
      end
    end
  end

  context 'user is not owner' do
    let(:user) { create(:user) }

    it 'raises an exception' do
      expect { subject }.to raise_error(Gitlab::Access::AccessDeniedError)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class AppendBuildTraceService
    Result = Struct.new(:status, :stream_size, keyword_init: true)
    TraceRangeError = Class.new(StandardError)

    attr_reader :build, :params

    def initialize(build, params)
      @build = build
      @params = params
    end

    def execute(body_data)
      # TODO:
      # it seems that `Content-Range` as formatted by runner is wrong,
      # the `byte_end` should point to final byte, but it points byte+1
      # that means that we have to calculate end of body,
      # as we cannot use `content_length[1]`
      # Issue: https://gitlab.com/gitlab-org/gitlab-runner/issues/3275

      content_range = stream_range.split('-')
      body_start = content_range[0].to_i
      body_end = body_start + body_data.bytesize

      if first_debug_chunk?(body_start)
        # Update the build metadata prior to appending trace content
        build.enable_debug_trace!
      end

      if trace_size_exceeded?(body_end)
        build.drop(:trace_size_exceeded)

        return Result.new(status: 403)
      end

      stream_size = build.trace.append(body_data, body_start)

      unless stream_size == body_end
        log_range_error(stream_size, body_end)

        return Result.new(status: 416, stream_size: stream_size)
      end

      Result.new(status: 202, stream_size: stream_size)
    end

    private

    delegate :project, to: :build

    def first_debug_chunk?(body_start)
      body_start == 0 && debug_trace
    end

    def stream_range
      params.fetch(:content_range)
    end

    def debug_trace
      params.fetch(:debug_trace, false)
    end

    def log_range_error(stream_size, body_end)
      extra = {
        build_id: build.id,
        body_end: body_end,
        stream_size: stream_size,
        stream_class: stream_size.class,
        stream_range: stream_range
      }

      build.trace_chunks.last.try do |chunk|
        extra.merge!(
          chunk_index: chunk.chunk_index,
          chunk_store: chunk.data_store,
          chunks_count: build.trace_chunks.count
        )
      end

      ::Gitlab::ErrorTracking
        .log_exception(TraceRangeError.new, extra)
    end

    def trace_size_exceeded?(size)
      project.actual_limits.exceeded?(:ci_jobs_trace_size_limit, size / 1.megabyte)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::AppendBuildTraceService, feature_category: :continuous_integration do
  let_it_be(:project) { create(:project) }
  let_it_be(:pipeline) { create(:ci_pipeline, project: project) }
  let_it_be_with_reload(:build) { create(:ci_build, :running, pipeline: pipeline) }

  before do
    stub_feature_flags(ci_enable_live_trace: true)
  end

  context 'build trace append is successful' do
    it 'returns a correct stream size and status code' do
      stream_size = 192.kilobytes
      body_data = 'x' * stream_size
      content_range = ""0-#{stream_size}""

      result = described_class
        .new(build, content_range: content_range)
        .execute(body_data)

      expect(result.status).to eq 202
      expect(result.stream_size).to eq stream_size
      expect(build.trace_chunks.count).to eq 2
    end
  end

  context 'when could not correctly append to a trace' do
    it 'responds with content range violation and data stored' do
      allow(build).to receive_message_chain(:trace, :append) { 16 }

      result = described_class
        .new(build, content_range: '0-128')
        .execute('x' * 128)

      expect(result.status).to eq 416
      expect(result.stream_size).to eq 16
    end

    it 'logs exception if build has live trace' do
      build.trace.append('abcd', 0)

      expect(::Gitlab::ErrorTracking)
        .to receive(:log_exception)
        .with(anything, hash_including(chunk_index: 0, chunk_store: 'redis_trace_chunks'))

      result = described_class
        .new(build, content_range: '0-128')
        .execute('x' * 128)

      expect(result.status).to eq 416
      expect(result.stream_size).to eq 4
    end
  end

  context 'when the trace size is exceeded' do
    before do
      project.actual_limits.update!(ci_jobs_trace_size_limit: 1)
    end

    it 'returns 403 status code' do
      stream_size = 1.25.megabytes
      body_data = 'x' * stream_size
      content_range = ""0-#{stream_size}""

      result = described_class
        .new(build, content_range: content_range)
        .execute(body_data)

      expect(result.status).to eq 403
      expect(result.stream_size).to be_nil
      expect(build.trace_chunks.count).to eq 0
      expect(build.reload).to be_failed
      expect(build.failure_reason).to eq 'trace_size_exceeded'
    end
  end

  context 'when debug_trace param is provided' do
    let(:metadata) { Ci::BuildMetadata.find_by(build_id: build) }
    let(:stream_size) { 192.kilobytes }
    let(:body_data) { 'x' * stream_size }
    let(:content_range) { ""#{body_start}-#{stream_size}"" }

    context 'when sending the first trace' do
      let(:body_start) { 0 }

      it 'updates build metadata debug_trace_enabled' do
        described_class
          .new(build, content_range: content_range, debug_trace: true)
          .execute(body_data)

        expect(metadata.debug_trace_enabled).to be(true)
      end
    end

    context 'when sending the second trace' do
      let(:body_start) { 1 }

      it 'does not update build metadata debug_trace_enabled', :aggregate_failures do
        query_recorder = ActiveRecord::QueryRecorder.new do
          described_class.new(build, content_range: content_range, debug_trace: true).execute(body_data)
        end

        expect(metadata.debug_trace_enabled).to be(false)
        expect(query_recorder.log).not_to include(/p_ci_builds_metadata/)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class UpdateBuildQueueService
    InvalidQueueTransition = Class.new(StandardError)

    attr_reader :metrics

    def initialize(metrics = ::Gitlab::Ci::Queue::Metrics)
      @metrics = metrics
    end

    ##
    # Add a build to the pending builds queue
    #
    def push(build, transition)
      raise InvalidQueueTransition unless transition.to == 'pending'

      transition.within_transaction do
        result = build.create_queuing_entry!

        unless result.empty?
          metrics.increment_queue_operation(:build_queue_push)

          result.rows.dig(0, 0)
        end
      end
    end

    ##
    # Remove a build from the pending builds queue
    #
    def pop(build, transition)
      raise InvalidQueueTransition unless transition.from == 'pending'

      transition.within_transaction { remove!(build) }
    end

    ##
    # Force remove build from the queue, without checking a transition state
    #
    def remove!(build)
      removed = build.all_queuing_entries.delete_all

      if removed > 0
        metrics.increment_queue_operation(:build_queue_pop)

        build.id
      end
    end

    ##
    # Add shared runner build tracking entry (used for queuing).
    #
    def track(build, transition)
      return unless build.shared_runner_build?

      raise InvalidQueueTransition unless transition.to == 'running'

      transition.within_transaction do
        result = ::Ci::RunningBuild.upsert_shared_runner_build!(build)

        unless result.empty?
          metrics.increment_queue_operation(:shared_runner_build_new)

          result.rows.dig(0, 0)
        end
      end
    end

    ##
    # Remove a runtime build tracking entry for a shared runner build (used for
    # queuing).
    #
    def untrack(build, transition)
      return unless build.shared_runner_build?

      raise InvalidQueueTransition unless transition.from == 'running'

      transition.within_transaction do
        removed = build.all_runtime_metadata.delete_all

        if removed > 0
          metrics.increment_queue_operation(:shared_runner_build_done)

          build.id
        end
      end
    end

    ##
    # Unblock runner associated with given project / build
    #
    def tick(build)
      tick_for(build, build.project.all_available_runners)
    end

    private

    def tick_for(build, runners)
      runners = runners.with_recent_runner_queue
      runners = runners.with_tags

      metrics.observe_active_runners(-> { runners.to_a.size })

      runners.each do |runner|
        metrics.increment_runner_tick(runner)

        runner.pick_build!(build)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::UpdateBuildQueueService, feature_category: :continuous_integration do
  let(:project) { create(:project, :repository) }
  let(:pipeline) { create(:ci_pipeline, project: project) }
  let(:build) { create(:ci_build, pipeline: pipeline) }

  describe 'pending builds queue push / pop' do
    describe '#push' do
      let(:transition) { double('transition') }

      before do
        allow(transition).to receive(:to).and_return('pending')
        allow(transition).to receive(:within_transaction).and_yield
      end

      context 'when pending build can be created' do
        it 'creates a new pending build in transaction' do
          queued = subject.push(build, transition)

          expect(queued).to eq build.id
        end

        it 'increments queue push metric' do
          metrics = spy('metrics')

          described_class.new(metrics).push(build, transition)

          expect(metrics)
            .to have_received(:increment_queue_operation)
            .with(:build_queue_push)
        end
      end

      context 'when invalid transition is detected' do
        it 'raises an error' do
          allow(transition).to receive(:to).and_return('created')

          expect { subject.push(build, transition) }
            .to raise_error(described_class::InvalidQueueTransition)
        end
      end

      context 'when duplicate entry exists' do
        before do
          create(:ci_pending_build, build: build, project: build.project)
        end

        it 'does nothing and returns build id' do
          queued = subject.push(build, transition)

          expect(queued).to eq build.id
        end
      end
    end

    describe '#pop' do
      let(:transition) { double('transition') }

      before do
        allow(transition).to receive(:from).and_return('pending')
        allow(transition).to receive(:within_transaction).and_yield
      end

      context 'when pending build exists' do
        before do
          create(:ci_pending_build, build: build, project: build.project)
        end

        it 'removes pending build in a transaction' do
          dequeued = subject.pop(build, transition)

          expect(dequeued).to eq build.id
        end

        it 'increments queue pop metric' do
          metrics = spy('metrics')

          described_class.new(metrics).pop(build, transition)

          expect(metrics)
            .to have_received(:increment_queue_operation)
            .with(:build_queue_pop)
        end
      end

      context 'when pending build does not exist' do
        it 'does nothing if there is no pending build to remove' do
          dequeued = subject.pop(build, transition)

          expect(dequeued).to be_nil
        end
      end

      context 'when invalid transition is detected' do
        it 'raises an error' do
          allow(transition).to receive(:from).and_return('created')

          expect { subject.pop(build, transition) }
            .to raise_error(described_class::InvalidQueueTransition)
        end
      end
    end

    describe '#remove!' do
      context 'when pending build exists' do
        before do
          create(:ci_pending_build, build: build, project: build.project)
        end

        it 'removes pending build in a transaction' do
          dequeued = subject.remove!(build)

          expect(dequeued).to eq build.id
        end
      end

      context 'when pending build does not exist' do
        it 'does nothing if there is no pending build to remove' do
          dequeued = subject.remove!(build)

          expect(dequeued).to be_nil
        end
      end
    end
  end

  describe 'shared runner builds tracking' do
    let(:runner) { create(:ci_runner, :instance_type) }
    let(:build) { create(:ci_build, runner: runner, pipeline: pipeline) }

    describe '#track' do
      let(:transition) { double('transition') }

      before do
        allow(transition).to receive(:to).and_return('running')
        allow(transition).to receive(:within_transaction).and_yield
      end

      context 'when a shared runner build can be tracked' do
        it 'creates a new shared runner build tracking entry' do
          build_id = subject.track(build, transition)

          expect(build_id).to eq build.id
        end

        it 'increments new shared runner build metric' do
          metrics = spy('metrics')

          described_class.new(metrics).track(build, transition)

          expect(metrics)
            .to have_received(:increment_queue_operation)
            .with(:shared_runner_build_new)
        end
      end

      context 'when invalid transition is detected' do
        it 'raises an error' do
          allow(transition).to receive(:to).and_return('pending')

          expect { subject.track(build, transition) }
            .to raise_error(described_class::InvalidQueueTransition)
        end
      end

      context 'when duplicate entry exists' do
        before do
          create(:ci_running_build, build: build, project: project, runner: runner)
        end

        it 'does nothing and returns build id' do
          build_id = subject.track(build, transition)

          expect(build_id).to eq build.id
        end
      end
    end

    describe '#untrack' do
      let(:transition) { double('transition') }

      before do
        allow(transition).to receive(:from).and_return('running')
        allow(transition).to receive(:within_transaction).and_yield
      end

      context 'when shared runner build tracking entry exists' do
        before do
          create(:ci_running_build, build: build, project: project, runner: runner)
        end

        it 'removes shared runner build' do
          build_id = subject.untrack(build, transition)

          expect(build_id).to eq build.id
        end

        it 'increments shared runner build done metric' do
          metrics = spy('metrics')

          described_class.new(metrics).untrack(build, transition)

          expect(metrics)
            .to have_received(:increment_queue_operation)
            .with(:shared_runner_build_done)
        end
      end

      context 'when tracking entry does not exist' do
        it 'does nothing if there is no tracking entry to remove' do
          build_id = subject.untrack(build, transition)

          expect(build_id).to be_nil
        end
      end

      context 'when invalid transition is detected' do
        it 'raises an error' do
          allow(transition).to receive(:from).and_return('pending')

          expect { subject.untrack(build, transition) }
            .to raise_error(described_class::InvalidQueueTransition)
        end
      end
    end
  end

  describe '#tick' do
    shared_examples 'refreshes runner' do
      it 'ticks runner queue value' do
        expect { subject.tick(build) }.to change { runner.ensure_runner_queue_value }
      end
    end

    shared_examples 'does not refresh runner' do
      it 'ticks runner queue value' do
        expect { subject.tick(build) }.not_to change { runner.ensure_runner_queue_value }
      end
    end

    shared_examples 'matching build' do
      context 'when there is a online runner that can pick build' do
        before do
          runner.update!(contacted_at: 30.minutes.ago)
        end

        it_behaves_like 'refreshes runner'

        it 'avoids running redundant queries' do
          expect(Ci::Runner).not_to receive(:owned_or_instance_wide)

          subject.tick(build)
        end
      end
    end

    shared_examples 'mismatching tags' do
      context 'when there is no runner that can pick build due to tag mismatch' do
        before do
          build.tag_list = [:docker]
        end

        it_behaves_like 'does not refresh runner'
      end
    end

    shared_examples 'recent runner queue' do
      context 'when there is runner with expired cache' do
        before do
          runner.update!(contacted_at: Ci::Runner.recent_queue_deadline)
        end

        it_behaves_like 'does not refresh runner'
      end
    end

    context 'when updating project runners' do
      let(:runner) { create(:ci_runner, :project, projects: [project]) }

      it_behaves_like 'matching build'
      it_behaves_like 'mismatching tags'
      it_behaves_like 'recent runner queue'

      context 'when the runner is assigned to another project' do
        let(:another_project) { create(:project) }
        let(:runner) { create(:ci_runner, :project, projects: [another_project]) }

        it_behaves_like 'does not refresh runner'
      end
    end

    context 'when updating shared runners' do
      let(:runner) { create(:ci_runner, :instance) }

      it_behaves_like 'matching build'
      it_behaves_like 'mismatching tags'
      it_behaves_like 'recent runner queue'

      context 'when there is no runner that can pick build due to being disabled on project' do
        before do
          build.project.shared_runners_enabled = false
        end

        it_behaves_like 'does not refresh runner'
      end
    end

    context 'when updating group runners' do
      let(:group) { create(:group) }
      let(:project) { create(:project, group: group) }
      let(:runner) { create(:ci_runner, :group, groups: [group]) }

      it_behaves_like 'matching build'
      it_behaves_like 'mismatching tags'
      it_behaves_like 'recent runner queue'

      context 'when there is no runner that can pick build due to being disabled on project' do
        before do
          build.project.group_runners_enabled = false
        end

        it_behaves_like 'does not refresh runner'
      end
    end

    context 'avoids N+1 queries', :request_store do
      let!(:build) { create(:ci_build, pipeline: pipeline, tag_list: %w[a b]) }
      let!(:project_runner) { create(:ci_runner, :project, :online, projects: [project], tag_list: %w[a b c]) }

      it 'does execute the same amount of queries regardless of number of runners' do
        control_count = ActiveRecord::QueryRecorder.new { subject.tick(build) }.count

        create_list(:ci_runner, 10, :project, :online, projects: [project], tag_list: %w[b c d])

        expect { subject.tick(build) }.not_to exceed_all_query_limit(control_count)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  # TODO: when using this class with exposed artifacts we see that there are
  # 2 responsibilities:
  # 1. reactive caching interface (same in all cases)
  # 2. data generator (report comparison in most of the case but not always)
  # issue: https://gitlab.com/gitlab-org/gitlab/issues/34224
  class CompareReportsBaseService < ::BaseService
    def execute(base_pipeline, head_pipeline)
      return parsing_payload(base_pipeline, head_pipeline) if base_pipeline&.running?

      base_report = get_report(base_pipeline)
      head_report = get_report(head_pipeline)
      comparer = build_comparer(base_report, head_report)

      {
        status: :parsed,
        key: key(base_pipeline, head_pipeline),
        data: serializer_class
          .new(**serializer_params)
          .represent(comparer).as_json
      }
    rescue Gitlab::Ci::Parsers::ParserError => e
      {
        status: :error,
        key: key(base_pipeline, head_pipeline),
        status_reason: e.message
      }
    end

    def latest?(base_pipeline, head_pipeline, data)
      data&.fetch(:key, nil) == key(base_pipeline, head_pipeline)
    end

    protected

    def parsing_payload(base_pipeline, head_pipeline)
      {
        status: :parsing,
        key: key(base_pipeline, head_pipeline)
      }
    end

    def build_comparer(base_report, head_report)
      comparer_class.new(base_report, head_report)
    end

    private

    def key(base_pipeline, head_pipeline)
      [
        base_pipeline&.id, base_pipeline&.updated_at,
        head_pipeline&.id, head_pipeline&.updated_at
      ]
    end

    def comparer_class
      raise NotImplementedError
    end

    def serializer_class
      raise NotImplementedError
    end

    def serializer_params
      { project: project, current_user: current_user }
    end

    def get_report(pipeline)
      raise NotImplementedError
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::CompareReportsBaseService, feature_category: :continuous_integration do
  let(:service) { described_class.new(project) }
  let(:project) { create(:project, :repository) }

  let!(:base_pipeline) { nil }
  let!(:head_pipeline) { create(:ci_pipeline, :with_test_reports, project: project) }
  let!(:key) { service.send(:key, base_pipeline, head_pipeline) }

  describe '#latest?' do
    subject { service.latest?(base_pipeline, head_pipeline, data) }

    context 'when cache key is latest' do
      let(:data) { { key: key } }

      it { is_expected.to be_truthy }
    end

    context 'when cache key is outdated' do
      before do
        head_pipeline.update_column(:updated_at, 10.minutes.ago)
      end

      let(:data) { { key: key } }

      it { is_expected.to be_falsy }
    end

    context 'when cache key is empty' do
      let(:data) { { key: nil } }

      it { is_expected.to be_falsy }
    end
  end

  describe '#execute' do
    context 'when base_pipeline is running' do
      let!(:base_pipeline) { create(:ci_pipeline, :running, project: project) }

      subject { service.execute(base_pipeline, head_pipeline) }

      it { is_expected.to eq(status: :parsing, key: key) }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class CreateCommitStatusService < BaseService
    include ::Gitlab::ExclusiveLeaseHelpers
    include ::Gitlab::Utils::StrongMemoize
    include ::Services::ReturnServiceResponses

    delegate :sha, to: :commit

    def execute(optional_commit_status_params:)
      in_lock(pipeline_lock_key, **pipeline_lock_params) do
        @optional_commit_status_params = optional_commit_status_params
        unsafe_execute
      end
    end

    private

    attr_reader :pipeline, :stage, :commit_status, :optional_commit_status_params

    def unsafe_execute
      return not_found('Commit') if commit.blank?
      return bad_request('State is required') if params[:state].blank?
      return not_found('References for commit') if ref.blank?

      @pipeline = first_matching_pipeline || create_pipeline
      return forbidden unless ::Ability.allowed?(current_user, :update_pipeline, pipeline)

      @stage = find_or_create_external_stage
      @commit_status = find_or_build_external_commit_status

      return bad_request(commit_status.errors.messages) if commit_status.invalid?

      response = add_or_update_external_job

      return bad_request(response.message) if response.error?

      update_merge_request_head_pipeline
      response
    end

    def ref
      params[:ref] || first_matching_pipeline&.ref ||
        repository.branch_names_contains(sha).first
    end
    strong_memoize_attr :ref

    def commit
      project.commit(params[:sha])
    end
    strong_memoize_attr :commit

    def first_matching_pipeline
      pipelines = project.ci_pipelines.newest_first(sha: sha)
      pipelines = pipelines.for_ref(params[:ref]) if params[:ref]
      pipelines = pipelines.id_in(params[:pipeline_id]) if params[:pipeline_id]
      pipelines.first
    end
    strong_memoize_attr :first_matching_pipeline

    def name
      params[:name] || params[:context] || 'default'
    end

    def create_pipeline
      project.ci_pipelines.build(
        source: :external,
        sha: sha,
        ref: ref,
        user: current_user,
        protected: project.protected_for?(ref)
      ).tap do |new_pipeline|
        new_pipeline.ensure_project_iid!
        new_pipeline.save!
      end
    end

    def find_or_create_external_stage
      pipeline.stages.safe_find_or_create_by!(name: 'external') do |stage| # rubocop:disable Performance/ActiveRecordSubtransactionMethods
        stage.position = ::GenericCommitStatus::EXTERNAL_STAGE_IDX
        stage.project = project
      end
    end

    def find_or_build_external_commit_status
      ::GenericCommitStatus.running_or_pending.find_or_initialize_by( # rubocop:disable CodeReuse/ActiveRecord
        project: project,
        pipeline: pipeline,
        name: name,
        ref: ref,
        user: current_user,
        protected: project.protected_for?(ref),
        ci_stage: stage,
        stage_idx: stage.position,
        stage: 'external'
      ).tap do |new_commit_status|
        new_commit_status.assign_attributes(optional_commit_status_params)
      end
    end

    def add_or_update_external_job
      ::Ci::Pipelines::AddJobService.new(pipeline).execute!(commit_status) do |job|
        apply_job_state!(job)
      end
    end

    def update_merge_request_head_pipeline
      return unless pipeline.latest?

      ::MergeRequest
        .from_project(project).from_source_branches(ref)
        .update_all(head_pipeline_id: pipeline.id)
    end

    def apply_job_state!(job)
      case params[:state]
      when 'pending'
        job.enqueue!
      when 'running'
        job.enqueue
        job.run!
      when 'success'
        job.success!
      when 'failed'
        job.drop!(:api_failure)
      when 'canceled'
        job.cancel!
      else
        raise('invalid state')
      end
    end

    def pipeline_lock_key
      ""api:commit_statuses:project:#{project.id}:sha:#{params[:sha]}""
    end

    def pipeline_lock_params
      {
        ttl: 5.seconds,
        sleep_sec: 0.1.seconds,
        retries: 20
      }
    end

    def not_found(message)
      error(""404 #{message} Not Found"", :not_found)
    end

    def bad_request(message)
      error(message, :bad_request)
    end

    def forbidden
      error(""403 Forbidden"", :forbidden)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::CreateCommitStatusService, :clean_gitlab_redis_cache, feature_category: :continuous_integration do
  using RSpec::Parameterized::TableSyntax

  subject(:response) { execute_service(params) }

  let_it_be_with_refind(:project) { create(:project, :repository) }
  let_it_be(:commit) { project.repository.commit }
  let_it_be(:guest) { create_user(:guest) }
  let_it_be(:reporter) { create_user(:reporter) }
  let_it_be(:developer) { create_user(:developer) }

  let(:user) { developer }
  let(:sha) { commit.id }
  let(:params) { { state: 'pending' } }
  let(:job) { response.payload[:job] }

  %w[pending running success failed canceled].each do |status|
    context ""for #{status}"" do
      let(:params) { { state: status } }

      context 'when pipeline for sha does not exists' do
        it 'creates commit status and sets pipeline iid' do
          expect(response).to be_success
          expect(job.sha).to eq(commit.id)
          expect(job.status).to eq(status)
          expect(job.name).to eq('default')
          expect(job.ref).not_to be_empty
          expect(job.target_url).to be_nil
          expect(job.description).to be_nil
          expect(job.pipeline_id).not_to be_nil

          expect(CommitStatus.find(job.id)).to be_api_failure if status == 'failed'

          expect(::Ci::Pipeline.last.iid).not_to be_nil
        end
      end
    end
  end

  context 'when status transitions from pending' do
    before do
      execute_service(state: 'pending')
    end

    %w[running success failed canceled].each do |status|
      context ""for #{status}"" do
        let(:params) { { state: status } }

        it ""changes to #{status}"" do
          expect { response }
            .to not_change { ::Ci::Pipeline.count }.from(1)
            .and not_change { ::Ci::Stage.count }.from(1)
            .and not_change { ::CommitStatus.count }.from(1)

          expect(response).to be_success
          expect(job.status).to eq(status)
        end
      end
    end

    context 'for invalid transition' do
      let(:params) { { state: 'pending' } }

      it 'returns bad request and error message' do
        expect { response }
          .to not_change { ::Ci::Pipeline.count }.from(1)
          .and not_change { ::Ci::Stage.count }.from(1)
          .and not_change { ::CommitStatus.count }.from(1)

        expect(response).to be_error
        expect(response.http_status).to eq(:bad_request)
        expect(response.message).to eq(
          ""Cannot transition status via :enqueue from :pending (Reason(s): Status cannot transition via \""enqueue\"")""
        )
      end
    end
  end

  context 'with all optional parameters' do
    context 'when creating a commit status' do
      let(:params) do
        {
          sha: sha,
          state: 'success',
          context: 'coverage',
          ref: 'master',
          description: 'test',
          coverage: 80.0,
          target_url: 'http://gitlab.com/status'
        }
      end

      it 'creates commit status' do
        expect { response }
          .to change { ::Ci::Pipeline.count }.by(1)
          .and change { ::Ci::Stage.count }.by(1)
          .and change { ::CommitStatus.count }.by(1)

        expect(response).to be_success
        expect(job.sha).to eq(commit.id)
        expect(job.status).to eq('success')
        expect(job.name).to eq('coverage')
        expect(job.ref).to eq('master')
        expect(job.coverage).to eq(80.0)
        expect(job.description).to eq('test')
        expect(job.target_url).to eq('http://gitlab.com/status')
      end

      context 'when merge request exists for given branch' do
        let!(:merge_request) do
          create(:merge_request, source_project: project, source_branch: 'master', target_branch: 'develop')
        end

        it 'sets head pipeline' do
          expect { response }
            .to change { ::Ci::Pipeline.count }.by(1)
            .and change { ::Ci::Stage.count }.by(1)
            .and change { ::CommitStatus.count }.by(1)

          expect(response).to be_success
          expect(merge_request.reload.head_pipeline).not_to be_nil
        end
      end
    end

    context 'when updating a commit status' do
      let(:parameters) do
        {
          state: 'success',
          name: 'coverage',
          ref: 'master'
        }
      end

      let(:updatable_optional_attributes) do
        {
          description: 'new description',
          coverage: 90.0
        }
      end

      let(:params) { parameters.merge(updatable_optional_attributes) }

      # creating the initial commit status
      before do
        execute_service(
          sha: sha,
          state: 'running',
          context: 'coverage',
          ref: 'master',
          description: 'coverage test',
          coverage: 10.0,
          target_url: 'http://gitlab.com/status'
        )
      end

      it 'updates a commit status' do
        expect { response }
          .to not_change { ::Ci::Pipeline.count }.from(1)
          .and not_change { ::Ci::Stage.count }.from(1)
          .and not_change { ::CommitStatus.count }.from(1)

        expect(response).to be_success
        expect(job.sha).to eq(commit.id)
        expect(job.status).to eq('success')
        expect(job.name).to eq('coverage')
        expect(job.ref).to eq('master')
        expect(job.coverage).to eq(90.0)
        expect(job.description).to eq('new description')
        expect(job.target_url).to eq('http://gitlab.com/status')
      end

      context 'when the `state` parameter is sent the same' do
        let(:parameters) do
          {
            sha: sha,
            state: 'running',
            name: 'coverage',
            ref: 'master'
          }
        end

        it 'does not update the commit status' do
          expect { response }
            .to not_change { ::Ci::Pipeline.count }.from(1)
            .and not_change { ::Ci::Stage.count }.from(1)
            .and not_change { ::CommitStatus.count }.from(1)

          expect(response).to be_error
          expect(response.http_status).to eq(:bad_request)
          expect(response.message).to eq(
            ""Cannot transition status via :run from :running (Reason(s): Status cannot transition via \""run\"")""
          )

          commit_status = project.commit_statuses.find_by!(name: 'coverage')

          expect(commit_status.description).to eq('coverage test')
          expect(commit_status.coverage).to eq(10.0)
        end
      end
    end

    context 'when a pipeline id is specified' do
      let!(:first_pipeline) do
        project.ci_pipelines.build(source: :push, sha: commit.id, ref: 'master', status: 'created').tap do |p|
          p.ensure_project_iid! # Necessary to avoid cross-database modification error
          p.save!
        end
      end

      let!(:other_pipeline) do
        project.ci_pipelines.build(source: :push, sha: commit.id, ref: 'master', status: 'created').tap do |p|
          p.ensure_project_iid! # Necessary to avoid cross-database modification error
          p.save!
        end
      end

      let(:params) do
        {
          sha: sha,
          pipeline_id: other_pipeline.id,
          state: 'success',
          ref: 'master'
        }
      end

      it 'update the correct pipeline', :sidekiq_might_not_need_inline do
        expect { response }
          .to not_change { ::Ci::Pipeline.count }.from(2)
          .and change { ::Ci::Stage.count }.by(1)
          .and change { ::CommitStatus.count }.by(1)

        expect(first_pipeline.reload.status).to eq('created')
        expect(other_pipeline.reload.status).to eq('success')
      end
    end
  end

  context 'when retrying a commit status' do
    subject(:response) do
      execute_service(state: 'failed', name: 'test', ref: 'master')

      execute_service(state: 'success', name: 'test', ref: 'master')
    end

    it 'correctly posts a new commit status' do
      expect { response }
        .to change { ::Ci::Pipeline.count }.by(1)
        .and change { ::Ci::Stage.count }.by(1)
        .and change { ::CommitStatus.count }.by(2)

      expect(response).to be_success
      expect(job.sha).to eq(commit.id)
      expect(job.status).to eq('success')
    end

    it 'retries the commit status', :sidekiq_might_not_need_inline do
      response

      expect(CommitStatus.count).to eq 2
      expect(CommitStatus.first).to be_retried
      expect(CommitStatus.last.pipeline).to be_success
    end
  end

  context 'when status is invalid' do
    let(:params) { { state: 'invalid' } }

    it 'does not create commit status' do
      expect { response }
        .to change { ::Ci::Pipeline.count }.by(1)
        .and change { ::Ci::Stage.count }.by(1)
        .and not_change { ::CommitStatus.count }.from(0)

      expect(response).to be_error
      expect(response.http_status).to eq(:bad_request)
      expect(response.message).to eq('invalid state')
    end
  end

  context 'when request without a state made' do
    let(:params) { {} }

    it 'does not create commit status' do
      expect { response }
        .to not_change { ::Ci::Pipeline.count }.from(0)
        .and not_change { ::Ci::Stage.count }.from(0)
        .and not_change { ::CommitStatus.count }.from(0)

      expect(response).to be_error
      expect(response.http_status).to eq(:bad_request)
      expect(response.message).to eq('State is required')
    end
  end

  context 'when updating a protected ref' do
    let(:params) { { state: 'running', ref: 'master' } }

    before do
      create(:protected_branch, project: project, name: 'master')
    end

    context 'with user as developer' do
      let(:user) { developer }

      it 'does not create commit status' do
        expect { response }
          .to change { ::Ci::Pipeline.count }.by(1)
          .and not_change { ::Ci::Stage.count }.from(0)
          .and not_change { ::CommitStatus.count }.from(0)

        expect(response).to be_error
        expect(response.http_status).to eq(:forbidden)
        expect(response.message).to eq('403 Forbidden')
      end
    end

    context 'with user as maintainer' do
      let(:user) { create_user(:maintainer) }

      it 'creates commit status' do
        expect { response }
          .to change { ::Ci::Pipeline.count }.by(1)
          .and change { ::Ci::Stage.count }.by(1)
          .and change { ::CommitStatus.count }.by(1)

        expect(response).to be_success
      end
    end
  end

  context 'when commit SHA is invalid' do
    let(:sha) { 'invalid_sha' }
    let(:params) { { state: 'running', sha: sha } }

    it 'returns not found error' do
      expect { response }
        .to not_change { ::Ci::Pipeline.count }.from(0)
        .and not_change { ::Ci::Stage.count }.from(0)
        .and not_change { ::CommitStatus.count }.from(0)

      expect(response).to be_error
      expect(response.http_status).to eq(:not_found)
      expect(response.message).to eq('404 Commit Not Found')
    end
  end

  context 'when target URL is an invalid address' do
    let(:params) { { state: 'pending', target_url: 'invalid url' } }

    it 'responds with bad request status and validation errors' do
      expect { response }
        .to change { ::Ci::Pipeline.count }.by(1)
        .and change { ::Ci::Stage.count }.by(1)
        .and not_change { ::CommitStatus.count }.from(0)

      expect(response).to be_error
      expect(response.http_status).to eq(:bad_request)
      expect(response.message[:target_url])
        .to include 'is blocked: Only allowed schemes are http, https'
    end
  end

  context 'when target URL is an unsupported scheme' do
    let(:params) { { state: 'pending', target_url: 'git://example.com' } }

    it 'responds with bad request status and validation errors' do
      expect { response }
        .to change { ::Ci::Pipeline.count }.by(1)
        .and change { ::Ci::Stage.count }.by(1)
        .and not_change { ::CommitStatus.count }.from(0)

      expect(response).to be_error
      expect(response.http_status).to eq(:bad_request)
      expect(response.message[:target_url])
          .to include 'is blocked: Only allowed schemes are http, https'
    end
  end

  context 'when trying to update a status of a different type' do
    let!(:pipeline) { create(:ci_pipeline, project: project, sha: sha, ref: 'ref') }
    let!(:ci_build) { create(:ci_build, pipeline: pipeline, name: 'test-job') }
    let(:params) { { state: 'pending', name: 'test-job' } }

    before do
      execute_service(params)
    end

    it 'responds with bad request status and validation errors' do
      expect { response }
        .to not_change { ::Ci::Pipeline.count }.from(1)
        .and not_change { ::Ci::Stage.count }.from(2)
        .and not_change { ::CommitStatus.count }.from(1)

      expect(response).to be_error
      expect(response.http_status).to eq(:bad_request)
      expect(response.message[:name])
          .to include 'has already been taken'
    end
  end

  context 'with partitions', :ci_partitionable do
    let(:current_partition_id) { ci_testing_partition_id }
    let(:params) { { state: 'running' } }

    before do
      allow(Ci::Pipeline)
        .to receive(:current_partition_value) { current_partition_id }
    end

    it 'creates records in the current partition' do
      expect { response }
        .to change { ::Ci::Pipeline.count }.by(1)
        .and change { ::Ci::Stage.count }.by(1)
        .and change { ::CommitStatus.count }.by(1)

      expect(response).to be_success

      status = CommitStatus.find(job.id)

      expect(status.partition_id).to eq(current_partition_id)
      expect(status.pipeline.partition_id).to eq(current_partition_id)
    end
  end

  context 'for race condition' do
    let(:licenses_snyk_params) { { state: 'running', name: 'licenses', description: 'testing' } }
    let(:security_snyk_params) { { state: 'running', name: 'security', description: 'testing' } }
    let(:snyk_params_list) { [licenses_snyk_params, security_snyk_params] }

    it 'creates one pipeline and two jobs (one for licenses, one for security)' do
      expect do
        snyk_params_list.map do |snyk_params|
          Thread.new do
            response = execute_service(snyk_params)
            expect(response).to be_success
          end
        end.each(&:join)
      end
        .to change { ::Ci::Pipeline.count }.by(1)
        .and change { ::Ci::Stage.count }.by(1)
        .and change { ::CommitStatus.count }.by(2)
    end
  end

  def create_user(access_level_trait)
    user = create(:user)
    create(:project_member, access_level_trait, user: user, project: project)
    user
  end

  def execute_service(params = self.params)
    described_class
      .new(project, user, params)
      .execute(optional_commit_status_params: params.slice(*%i[target_url description coverage]))
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class CompareCodequalityReportsService < CompareReportsBaseService
    def comparer_class
      Gitlab::Ci::Reports::CodequalityReportsComparer
    end

    def serializer_class
      CodequalityReportsComparerSerializer
    end

    def get_report(pipeline)
      pipeline&.codequality_reports
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::CompareCodequalityReportsService, feature_category: :continuous_integration do
  let(:service) { described_class.new(project) }
  let(:project) { create(:project, :repository) }

  describe '#execute' do
    subject { service.execute(base_pipeline, head_pipeline) }

    context 'when head pipeline has a codequality report' do
      let(:base_pipeline) { nil }
      let(:head_pipeline) { create(:ci_pipeline, :with_codequality_reports, project: project) }

      it 'returns status and data' do
        expect(subject[:status]).to eq(:parsed)
        expect(subject[:data]).to match_schema('entities/codequality_reports_comparer')
      end
    end

    context 'when base and head pipelines have codequality reports' do
      let(:base_pipeline) { create(:ci_pipeline, :with_codequality_reports, project: project) }
      let(:head_pipeline) { create(:ci_pipeline, :with_codequality_reports, project: project) }

      it 'returns status and data' do
        expect(subject[:status]).to eq(:parsed)
        expect(subject[:data]).to match_schema('entities/codequality_reports_comparer')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class DeleteObjectsService
    TransactionInProgressError = Class.new(StandardError)
    TRANSACTION_MESSAGE = ""can't perform network calls inside a database transaction""
    BATCH_SIZE = 100
    RETRY_IN = 10.minutes

    def execute
      objects = load_next_batch
      destroy_everything(objects)
    end

    def remaining_batches_count(max_batch_count:)
      Ci::DeletedObject
        .ready_for_destruction(max_batch_count * BATCH_SIZE)
        .size
        .fdiv(BATCH_SIZE)
        .ceil
    end

    private

    # rubocop: disable CodeReuse/ActiveRecord
    def load_next_batch
      # `find_by_sql` performs a write in this case and we need to wrap it in
      # a transaction to stick to the primary database.
      Ci::DeletedObject.transaction do
        Ci::DeletedObject.find_by_sql([next_batch_sql, new_pick_up_at: RETRY_IN.from_now])
      end
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def next_batch_sql
      <<~SQL.squish
      UPDATE ""ci_deleted_objects""
        SET ""pick_up_at"" = :new_pick_up_at
        WHERE ""ci_deleted_objects"".""id"" IN (#{locked_object_ids_sql})
        RETURNING *
      SQL
    end

    def locked_object_ids_sql
      Ci::DeletedObject.lock_for_destruction(BATCH_SIZE).to_sql
    end

    def destroy_everything(objects)
      raise TransactionInProgressError, TRANSACTION_MESSAGE if transaction_open?
      return unless objects.any?

      deleted = objects.select(&:delete_file_from_storage)
      Ci::DeletedObject.id_in(deleted.map(&:id)).delete_all
    end

    def transaction_open?
      Ci::DeletedObject.connection.transaction_open?
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::DeleteObjectsService, :aggregate_failures, feature_category: :continuous_integration do
  let(:service) { described_class.new }
  let(:artifact) { create(:ci_job_artifact, :archive) }
  let(:data) { [artifact] }

  describe '#execute' do
    before do
      Ci::DeletedObject.bulk_import(data)
      # We disable the check because the specs are wrapped in a transaction
      allow(service).to receive(:transaction_open?).and_return(false)
    end

    subject(:execute) { service.execute }

    it 'deletes records' do
      expect { execute }.to change { Ci::DeletedObject.count }.by(-1)
    end

    it 'deletes files' do
      expect { execute }.to change { artifact.file.exists? }
    end

    context 'when trying to execute without records' do
      let(:data) { [] }

      it 'does not change the number of objects' do
        expect { execute }.not_to change { Ci::DeletedObject.count }
      end
    end

    context 'when trying to remove the same file multiple times' do
      let(:objects) { Ci::DeletedObject.all.to_a }

      before do
        expect(service).to receive(:load_next_batch).twice.and_return(objects)
      end

      it 'executes successfully' do
        2.times { expect(service.execute).to be_truthy }
      end
    end

    context 'with artifacts both ready and not ready for deletion' do
      let(:data) { [] }

      let!(:past_ready) { create(:ci_deleted_object, pick_up_at: 2.days.ago) }
      let!(:ready) { create(:ci_deleted_object, pick_up_at: 1.day.ago) }

      it 'skips records with pick_up_at in the future' do
        not_ready = create(:ci_deleted_object, pick_up_at: 1.day.from_now)

        expect { execute }.to change { Ci::DeletedObject.count }.from(3).to(1)
        expect(not_ready.reload.present?).to be_truthy
      end

      it 'limits the number of records removed' do
        stub_const(""#{described_class}::BATCH_SIZE"", 1)

        expect { execute }.to change { Ci::DeletedObject.count }.by(-1)
      end

      it 'removes records in order' do
        stub_const(""#{described_class}::BATCH_SIZE"", 1)

        execute

        expect { past_ready.reload }.to raise_error(ActiveRecord::RecordNotFound)
        expect(ready.reload.present?).to be_truthy
      end

      it 'updates pick_up_at timestamp' do
        allow(service).to receive(:destroy_everything)

        execute

        expect(past_ready.reload.pick_up_at).to be_like_time(10.minutes.from_now)
      end

      it 'does not delete objects for which file deletion has failed' do
        expect(past_ready)
          .to receive(:delete_file_from_storage)
          .and_return(false)

        expect(service)
          .to receive(:load_next_batch)
          .and_return([past_ready, ready])

        expect { execute }.to change { Ci::DeletedObject.count }.from(2).to(1)
        expect(past_ready.reload.present?).to be_truthy
      end
    end

    context 'with an open database transaction' do
      it 'raises an exception and does not remove records' do
        expect(service).to receive(:transaction_open?).and_return(true)

        expect { execute }
          .to raise_error(Ci::DeleteObjectsService::TransactionInProgressError)
          .and change { Ci::DeletedObject.count }.by(0)
      end
    end
  end

  describe '#remaining_batches_count' do
    subject { service.remaining_batches_count(max_batch_count: 3) }

    context 'when there is less than one batch size' do
      before do
        Ci::DeletedObject.bulk_import(data)
      end

      it { is_expected.to eq(1) }
    end

    context 'when there is more than one batch size' do
      before do
        objects_scope = double

        expect(Ci::DeletedObject)
          .to receive(:ready_for_destruction)
          .and_return(objects_scope)

        expect(objects_scope).to receive(:size).and_return(110)
      end

      it { is_expected.to eq(2) }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class DropPipelineService
    PRELOADED_RELATIONS = [:project, :pipeline, :metadata, :deployment, :taggings].freeze

    # execute service asynchronously for each cancelable pipeline
    def execute_async_for_all(pipelines, failure_reason, context_user)
      pipelines.cancelable.select(:id).find_in_batches do |pipelines_batch|
        Ci::DropPipelineWorker.bulk_perform_async_with_contexts(
          pipelines_batch,
          arguments_proc: -> (pipeline) { [pipeline.id, failure_reason] },
          context_proc: -> (_) { { user: context_user } }
        )
      end
    end

    def execute(pipeline, failure_reason, retries: 3)
      Gitlab::OptimisticLocking.retry_lock(pipeline.cancelable_statuses, retries, name: 'ci_pipeline_drop_running') do |cancelables|
        cancelables.find_in_batches do |batch|
          preload_associations_for_drop(batch)

          batch.each do |job|
            job.drop(failure_reason)
          end
        end
      end
    end

    private

    def preload_associations_for_drop(commit_status_batch)
      Preloaders::CommitStatusPreloader.new(commit_status_batch).execute(PRELOADED_RELATIONS)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::DropPipelineService, feature_category: :continuous_integration do
  let_it_be(:user) { create(:user) }

  let(:failure_reason) { :user_blocked }

  let!(:cancelable_pipeline) { create(:ci_pipeline, :running, user: user) }
  let!(:running_build) { create(:ci_build, :running, pipeline: cancelable_pipeline) }
  let!(:commit_status_running) { create(:commit_status, :running, pipeline: cancelable_pipeline) }
  let!(:success_pipeline) { create(:ci_pipeline, :success, user: user) }
  let!(:success_build) { create(:ci_build, :success, pipeline: success_pipeline) }
  let!(:commit_status_success) { create(:commit_status, :success, pipeline: cancelable_pipeline) }

  describe '#execute_async_for_all' do
    subject { described_class.new.execute_async_for_all(user.pipelines, failure_reason, user) }

    it 'drops only cancelable pipelines asynchronously', :sidekiq_inline do
      subject

      expect(cancelable_pipeline.reload).to be_failed
      expect(running_build.reload).to be_failed

      expect(success_pipeline.reload).to be_success
      expect(success_build.reload).to be_success
    end
  end

  describe '#execute' do
    subject { described_class.new.execute(cancelable_pipeline.id, failure_reason) }

    def drop_pipeline!(pipeline)
      described_class.new.execute(pipeline, failure_reason)
    end

    it 'drops each cancelable build in the pipeline', :aggregate_failures do
      drop_pipeline!(cancelable_pipeline)

      expect(running_build.reload).to be_failed
      expect(running_build.failure_reason).to eq(failure_reason.to_s)

      expect(success_build.reload).to be_success
    end

    it 'avoids N+1 queries when reading data' do
      control_count = ActiveRecord::QueryRecorder.new do
        drop_pipeline!(cancelable_pipeline)
      end.count

      writes_per_build = 2
      load_balancer_queries = 3
      expected_reads_count = control_count - writes_per_build

      create_list(:ci_build, 5, :running, pipeline: cancelable_pipeline)

      expect do
        drop_pipeline!(cancelable_pipeline)
      end.not_to exceed_query_limit(expected_reads_count + (5 * writes_per_build) + load_balancer_queries)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class PipelineTriggerService < BaseService
    include Gitlab::Utils::StrongMemoize
    include Services::ReturnServiceResponses
    include Ci::DownstreamPipelineHelpers

    def execute
      if trigger_from_token
        set_application_context_from_trigger(trigger_from_token)
        create_pipeline_from_trigger(trigger_from_token)
      elsif job_from_token
        set_application_context_from_job(job_from_token)
        create_pipeline_from_job(job_from_token)
      end

    rescue Ci::AuthJobFinder::AuthError => e
      error(e.message, 401)
    end

    private

    PAYLOAD_VARIABLE_KEY = 'TRIGGER_PAYLOAD'
    PAYLOAD_VARIABLE_HIDDEN_PARAMS = %i[token].freeze

    def create_pipeline_from_trigger(trigger)
      # this check is to not leak the presence of the project if user cannot read it
      return unless trigger.project == project
      return unless can?(trigger.owner, :read_project, project)

      response = Ci::CreatePipelineService
        .new(project, trigger.owner, ref: params[:ref], variables_attributes: variables)
        .execute(:trigger, ignore_skip_ci: true) do |pipeline|
          pipeline.trigger_requests.build(trigger: trigger)
        end

      pipeline_service_response(response.payload)
    end

    def pipeline_service_response(pipeline)
      if pipeline.created_successfully?
        success(pipeline: pipeline)
      elsif pipeline.persisted?
        err = pipeline.errors.messages.presence || pipeline.failure_reason.presence || 'Could not create pipeline'
        error(err, :unprocessable_entity)
      else
        error(pipeline.errors.messages, :bad_request)
      end
    end

    def trigger_from_token
      strong_memoize(:trigger) do
        Ci::Trigger.find_by_token(params[:token].to_s)
      end
    end

    def create_pipeline_from_job(job)
      # this check is to not leak the presence of the project if user cannot read it
      return unless can?(job.user, :read_project, project)

      response = Ci::CreatePipelineService
        .new(project, job.user, ref: params[:ref], variables_attributes: variables)
        .execute(:pipeline, ignore_skip_ci: true) do |pipeline|
          source = job.sourced_pipelines.build(
            source_pipeline: job.pipeline,
            source_project: job.project,
            pipeline: pipeline,
            project: project)

          pipeline.source_pipeline = source
        end

      log_downstream_pipeline_creation(response.payload)
      pipeline_service_response(response.payload)
    end

    def job_from_token
      strong_memoize(:job) do
        Ci::AuthJobFinder.new(token: params[:token].to_s).execute!
      end
    end

    def variables
      param_variables + [payload_variable]
    end

    def param_variables
      params[:variables].to_h.map do |key, value|
        { key: key, value: value }
      end
    end

    def payload_variable
      { key: PAYLOAD_VARIABLE_KEY,
        value: Gitlab::Json.dump(params.except(*PAYLOAD_VARIABLE_HIDDEN_PARAMS)),
        variable_type: :file }
    end

    def set_application_context_from_trigger(trigger)
      Gitlab::ApplicationContext.push(
        user: trigger.owner,
        project: trigger.project
      )
    end

    def set_application_context_from_job(job)
      Gitlab::ApplicationContext.push(
        user: job.user,
        project: job.project,
        runner: job.runner
      )
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::PipelineTriggerService, feature_category: :continuous_integration do
  include AfterNextHelpers

  let_it_be(:project) { create(:project, :repository) }

  before do
    stub_ci_pipeline_to_return_yaml_file
  end

  describe '#execute' do
    let_it_be(:user) { create(:user) }

    let(:result) { described_class.new(project, user, params).execute }

    before do
      project.add_developer(user)
    end

    shared_examples 'detecting an unprocessable pipeline trigger' do
      context 'when the pipeline was not created successfully' do
        let(:fail_pipeline) do
          receive(:execute).and_wrap_original do |original, *args, **kwargs|
            response = original.call(*args, **kwargs)
            pipeline = response.payload
            pipeline.update!(failure_reason: 'unknown_failure')

            response
          end
        end

        before do
          allow_next(Ci::CreatePipelineService).to fail_pipeline
        end

        it 'has the correct status code' do
          expect { result }.to change { Ci::Pipeline.count }
          expect(result).to be_error
          expect(result.http_status).to eq(:unprocessable_entity)
        end
      end
    end

    context 'with a trigger token' do
      let(:trigger) { create(:ci_trigger, project: project, owner: user) }

      context 'when trigger belongs to a different project' do
        let(:params) { { token: trigger.token, ref: 'master', variables: nil } }
        let(:trigger) { create(:ci_trigger, project: create(:project), owner: user) }

        it 'does nothing' do
          expect { result }.not_to change { Ci::Pipeline.count }
        end
      end

      context 'when trigger owner does not have a permission to read a project' do
        let(:params) { { token: trigger.token, ref: 'master', variables: nil } }
        let(:trigger) { create(:ci_trigger, project: project, owner: create(:user)) }

        it 'does nothing' do
          expect { result }.not_to change { Ci::Pipeline.count }
        end
      end

      context 'when params have an existing trigger token' do
        context 'when params have an existing ref' do
          let(:params) { { token: trigger.token, ref: 'master', variables: nil } }

          it 'triggers a pipeline' do
            expect { result }.to change { Ci::Pipeline.count }.by(1)
            expect(result[:pipeline].ref).to eq('master')
            expect(result[:pipeline].project).to eq(project)
            expect(result[:pipeline].user).to eq(trigger.owner)
            expect(result[:pipeline].trigger_requests.to_a)
              .to eq(result[:pipeline].builds.map(&:trigger_request).uniq)
            expect(result[:status]).to eq(:success)
          end

          it 'stores the payload as a variable' do
            expect { result }.to change { Ci::PipelineVariable.count }.by(1)

            var = result[:pipeline].variables.first

            expect(var.key).to eq('TRIGGER_PAYLOAD')
            expect(var.value).to eq('{""ref"":""master"",""variables"":null}')
            expect(var.variable_type).to eq('file')
          end

          context 'when commit message has [ci skip]' do
            before do
              allow_next(Ci::Pipeline).to receive(:git_commit_message) { '[ci skip]' }
            end

            it 'ignores [ci skip] and create as general' do
              expect { result }.to change { Ci::Pipeline.count }.by(1)
              expect(result).to be_success
            end
          end

          context 'when params have a variable' do
            let(:params) { { token: trigger.token, ref: 'master', variables: variables } }
            let(:variables) { { 'AAA' => 'AAA123' } }

            it 'has variables' do
              expect { result }.to change { Ci::PipelineVariable.count }.by(2)
                               .and change { Ci::TriggerRequest.count }.by(1)
              expect(result[:pipeline].variables.map { |v| { v.key => v.value } }.first).to eq(variables)
              expect(result[:pipeline].trigger_requests.last.variables).to be_nil
            end
          end

          context 'when params have duplicate variables' do
            let(:params) { { token: trigger.token, ref: 'master', variables: variables } }
            let(:variables) { { 'TRIGGER_PAYLOAD' => 'duplicate value' } }

            it 'creates a failed pipeline without variables' do
              expect { result }.to change { Ci::Pipeline.count }
              expect(result).to be_error
              expect(result.message[:base]).to eq(['Duplicate variable name: TRIGGER_PAYLOAD'])
            end
          end

          it_behaves_like 'detecting an unprocessable pipeline trigger'
        end

        context 'when params have a non-existant ref' do
          let(:params) { { token: trigger.token, ref: 'invalid-ref', variables: nil } }

          it 'does not trigger a pipeline' do
            expect { result }.not_to change { Ci::Pipeline.count }
            expect(result).to be_error
            expect(result.http_status).to eq(:bad_request)
          end
        end
      end

      context 'when params have a non-existant trigger token' do
        let(:params) { { token: 'invalid-token', ref: nil, variables: nil } }

        it 'does not trigger a pipeline' do
          expect { result }.not_to change { Ci::Pipeline.count }
          expect(result).to be_nil
        end
      end
    end

    context 'with a pipeline job token' do
      let!(:pipeline) { create(:ci_empty_pipeline, project: project) }
      let(:job) { create(:ci_build, :running, pipeline: pipeline, user: user) }

      context 'when job user does not have a permission to read a project' do
        let(:params) { { token: job.token, ref: 'master', variables: nil } }
        let(:job) { create(:ci_build, pipeline: pipeline, user: create(:user)) }

        it 'does nothing' do
          expect { result }.not_to change { Ci::Pipeline.count }
        end
      end

      context 'when job is not running' do
        let(:params) { { token: job.token, ref: 'master', variables: nil } }
        let(:job) { create(:ci_build, :success, pipeline: pipeline, user: user) }

        it 'does nothing', :aggregate_failures do
          expect { result }.not_to change { Ci::Pipeline.count }
          expect(result[:message]).to eq('Job is not running')
          expect(result[:http_status]).to eq(401)
        end
      end

      context 'when job does not have a project' do
        let(:params) { { token: job.token, ref: 'master', variables: nil } }
        let(:job) { create(:ci_build, status: :running, pipeline: pipeline, user: user) }

        it 'does nothing', :aggregate_failures do
          job.update!(project: nil)

          expect { result }.not_to change { Ci::Pipeline.count }
          expect(result[:message]).to eq('Project has been deleted!')
          expect(result[:http_status]).to eq(401)
        end
      end

      context 'when params have an existsed job token' do
        context 'when params have an existsed ref' do
          let(:params) { { token: job.token, ref: 'master', variables: nil } }

          it 'triggers a pipeline' do
            expect { result }.to change { Ci::Pipeline.count }.by(1)
            expect(result[:pipeline].ref).to eq('master')
            expect(result[:pipeline].project).to eq(project)
            expect(result[:pipeline].user).to eq(job.user)
            expect(result[:status]).to eq(:success)
          end

          it_behaves_like 'logs downstream pipeline creation' do
            let(:downstream_pipeline) { result[:pipeline] }
            let(:expected_root_pipeline) { pipeline }
            let(:expected_hierarchy_size) { 2 }
            let(:expected_downstream_relationship) { :multi_project }
          end

          context 'when commit message has [ci skip]' do
            before do
              allow_next_instance_of(Ci::Pipeline) do |instance|
                allow(instance).to receive(:git_commit_message) { '[ci skip]' }
              end
            end

            it 'ignores [ci skip] and create as general' do
              expect { result }.to change { Ci::Pipeline.count }.by(1)
              expect(result[:status]).to eq(:success)
            end
          end

          context 'when params have a variable' do
            let(:params) { { token: job.token, ref: 'master', variables: variables } }
            let(:variables) { { 'AAA' => 'AAA123' } }

            it 'has variables' do
              expect { result }.to change { Ci::PipelineVariable.count }.by(2)
                               .and change { Ci::Sources::Pipeline.count }.by(1)
              expect(result[:pipeline].variables.map { |v| { v.key => v.value } }.first).to eq(variables)
              expect(job.sourced_pipelines.last.pipeline_id).to eq(result[:pipeline].id)
            end
          end

          context 'when params have duplicate variables' do
            let(:params) { { token: job.token, ref: 'master', variables: variables } }
            let(:variables) { { 'TRIGGER_PAYLOAD' => 'duplicate value' } }

            it 'creates a failed pipeline without variables' do
              expect { result }.to change { Ci::Pipeline.count }
              expect(result).to be_error
              expect(result.message[:base]).to eq(['Duplicate variable name: TRIGGER_PAYLOAD'])
            end
          end

          it_behaves_like 'detecting an unprocessable pipeline trigger'
        end

        context 'when params have a non-existant ref' do
          let(:params) { { token: job.token, ref: 'invalid-ref', variables: nil } }

          it 'does not trigger a job in the pipeline' do
            expect { result }.not_to change { Ci::Pipeline.count }
            expect(result).to be_error
            expect(result.http_status).to eq(:bad_request)
          end
        end
      end

      context 'when params have a non-existsed trigger token' do
        let(:params) { { token: 'invalid-token', ref: nil, variables: nil } }

        it 'does not trigger a pipeline' do
          expect { result }.not_to change { Ci::Pipeline.count }
          expect(result).to be_nil
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class BuildCancelService
    def initialize(build, user)
      @build = build
      @user = user
    end

    def execute
      return forbidden unless allowed?
      return unprocessable_entity unless build.cancelable?

      build.cancel

      ServiceResponse.success(payload: build)
    end

    private

    attr_reader :build, :user

    def allowed?
      user.can?(:cancel_build, build)
    end

    def forbidden
      ServiceResponse.error(message: 'Forbidden', http_status: :forbidden)
    end

    def unprocessable_entity
      ServiceResponse.error(message: 'Unprocessable entity', http_status: :unprocessable_entity)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::BuildCancelService, feature_category: :continuous_integration do
  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project) }
  let_it_be(:pipeline) { create(:ci_pipeline, project: project) }

  describe '#execute' do
    subject(:execute) { described_class.new(build, user).execute }

    context 'when user is authorized to cancel the build' do
      before do
        project.add_maintainer(user)
      end

      context 'when build is cancelable' do
        let!(:build) { create(:ci_build, :cancelable, pipeline: pipeline) }

        it 'transits build to canceled', :aggregate_failures do
          response = execute

          expect(response).to be_success
          expect(response.payload.reload).to be_canceled
        end
      end

      context 'when build is not cancelable' do
        let!(:build) { create(:ci_build, :canceled, pipeline: pipeline) }

        it 'responds with unprocessable entity', :aggregate_failures do
          response = execute

          expect(response).to be_error
          expect(response.http_status).to eq(:unprocessable_entity)
        end
      end
    end

    context 'when user is not authorized to cancel the build' do
      let!(:build) { create(:ci_build, :cancelable, pipeline: pipeline) }

      it 'responds with forbidden', :aggregate_failures do
        response = execute

        expect(response).to be_error
        expect(response.http_status).to eq(:forbidden)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class RunScheduledBuildService < ::BaseService
    def execute(build)
      unless can?(current_user, :update_build, build)
        raise Gitlab::Access::AccessDeniedError
      end

      build.enqueue_scheduled!
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::RunScheduledBuildService, feature_category: :continuous_integration do
  let(:user) { create(:user) }
  let(:project) { create(:project) }
  let(:pipeline) { create(:ci_pipeline, project: project) }

  subject { described_class.new(project, user).execute(build) }

  context 'when user can update build' do
    before do
      project.add_developer(user)

      create(:protected_branch, :developers_can_merge, name: pipeline.ref, project: project)
    end

    context 'when build is scheduled' do
      context 'when scheduled_at is expired' do
        let(:build) { create(:ci_build, :expired_scheduled, user: user, project: project, pipeline: pipeline) }

        it 'can run the build' do
          expect { subject }.not_to raise_error

          expect(build).to be_pending
        end

        context 'when build requires resource' do
          let(:resource_group) { create(:ci_resource_group, project: project) }

          before do
            build.update!(resource_group: resource_group)
          end

          it 'transits to waiting for resource status' do
            expect { subject }.to change { build.status }.from('scheduled').to('waiting_for_resource')
          end
        end
      end

      context 'when scheduled_at is not expired' do
        let(:build) { create(:ci_build, :scheduled, user: user, project: project, pipeline: pipeline) }

        it 'can not run the build' do
          expect { subject }.to raise_error(StateMachines::InvalidTransition)

          expect(build).to be_scheduled
        end
      end
    end

    context 'when build is not scheduled' do
      let(:build) { create(:ci_build, :created, user: user, project: project, pipeline: pipeline) }

      it 'can not run the build' do
        expect { subject }.to raise_error(StateMachines::InvalidTransition)

        expect(build).to be_created
      end
    end
  end

  context 'when user can not update build' do
    context 'when build is scheduled' do
      let(:build) { create(:ci_build, :scheduled, user: user, project: project, pipeline: pipeline) }

      it 'can not run the build' do
        expect { subject }.to raise_error(Gitlab::Access::AccessDeniedError)

        expect(build).to be_scheduled
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  # TODO: a couple of points with this approach:
  # + reuses existing architecture and reactive caching
  # - it's not a report comparison and some comparing features must be turned off.
  # see CompareReportsBaseService for more notes.
  # issue: https://gitlab.com/gitlab-org/gitlab/issues/34224
  class GenerateCodequalityMrDiffReportService < CompareReportsBaseService
    def execute(base_pipeline, head_pipeline)
      merge_request = MergeRequest.find_by_id(params[:id])
      {
        status: :parsed,
        key: key(base_pipeline, head_pipeline),
        data: head_pipeline.pipeline_artifacts.find_by_file_type(:code_quality_mr_diff).present.for_files(merge_request)
      }
    rescue StandardError => e
      Gitlab::ErrorTracking.track_exception(e, project_id: project.id)
      {
        status: :error,
        key: key(base_pipeline, head_pipeline),
        status_reason: _('An error occurred while fetching codequality mr diff reports.')
      }
    end

    def latest?(base_pipeline, head_pipeline, data)
      data&.fetch(:key, nil) == key(base_pipeline, head_pipeline)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::GenerateCodequalityMrDiffReportService, feature_category: :code_review_workflow do
  let(:service) { described_class.new(project) }
  let(:project) { create(:project, :repository) }

  describe '#execute' do
    subject { service.execute(base_pipeline, head_pipeline) }

    context 'when head pipeline has codequality mr diff report' do
      let!(:merge_request) { create(:merge_request, :with_codequality_mr_diff_reports, source_project: project, id: 123456789) }
      let!(:service) { described_class.new(project, nil, id: merge_request.id) }
      let!(:head_pipeline) { merge_request.head_pipeline }
      let!(:base_pipeline) { nil }

      it 'returns status and data', :aggregate_failures do
        expect_any_instance_of(Ci::PipelineArtifact) do |instance|
          expect(instance).to receive(:present)
          expect(instance).to receive(:for_files).with(merge_request).and_call_original
        end

        expect(subject[:status]).to eq(:parsed)
        expect(subject[:data]).to eq(files: {})
      end
    end

    context 'when head pipeline does not have a codequality mr diff report' do
      let!(:merge_request) { create(:merge_request, source_project: project) }
      let!(:service) { described_class.new(project, nil, id: merge_request.id) }
      let!(:head_pipeline) { merge_request.head_pipeline }
      let!(:base_pipeline) { nil }

      it 'returns status and error message' do
        expect(subject[:status]).to eq(:error)
        expect(subject[:status_reason]).to include('An error occurred while fetching codequality mr diff reports.')
      end
    end

    context 'when head pipeline has codequality mr diff report and no merge request associated' do
      let!(:head_pipeline) { create(:ci_pipeline, :with_codequality_mr_diff_report, project: project) }
      let!(:base_pipeline) { nil }

      it 'returns status and error message' do
        expect(subject[:status]).to eq(:error)
        expect(subject[:status_reason]).to include('An error occurred while fetching codequality mr diff reports.')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class GenerateKubeconfigService
    def initialize(pipeline, token:, environment:)
      @pipeline = pipeline
      @token = token
      @environment = environment

      @template = Gitlab::Kubernetes::Kubeconfig::Template.new
    end

    def execute
      template.add_cluster(
        name: cluster_name,
        url: Gitlab::Kas.tunnel_url
      )

      agent_authorizations.each do |authorization|
        agent = authorization.agent
        user = user_name(agent)

        template.add_user(
          name: user,
          token: agent_token(agent)
        )

        template.add_context(
          name: context_name(agent),
          namespace: context_namespace(authorization),
          cluster: cluster_name,
          user: user
        )
      end

      template
    end

    private

    attr_reader :pipeline, :token, :environment, :template

    def agent_authorizations
      ::Clusters::Agents::Authorizations::CiAccess::FilterService.new(
        pipeline.cluster_agent_authorizations,
        environment: environment
      ).execute
    end

    def cluster_name
      'gitlab'
    end

    def user_name(agent)
      ['agent', agent.id].join(delimiter)
    end

    def context_name(agent)
      [agent.project.full_path, agent.name].join(delimiter)
    end

    def context_namespace(authorization)
      authorization.config['default_namespace']
    end

    def agent_token(agent)
      ['ci', agent.id, token].join(delimiter)
    end

    def delimiter
      ':'
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::GenerateKubeconfigService, feature_category: :deployment_management do
  describe '#execute' do
    let_it_be(:group) { create(:group) }
    let_it_be(:project) { create(:project, group: group) }
    let_it_be(:pipeline) { create(:ci_empty_pipeline, project: project) }
    let_it_be(:build) { create(:ci_build, project: project, pipeline: pipeline) }

    let_it_be(:agent_project) { create(:project, group: group, name: 'project-containing-agent-config') }

    let_it_be(:project_agent_authorization) do
      agent = create(:cluster_agent, project: agent_project)
      create(:agent_ci_access_project_authorization, agent: agent, project: project)
    end

    let_it_be(:group_agent_authorization) do
      agent = create(:cluster_agent, project: agent_project)
      create(:agent_ci_access_group_authorization, agent: agent, group: group)
    end

    let(:template) do
      instance_double(
        Gitlab::Kubernetes::Kubeconfig::Template,
        add_cluster: nil,
        add_user: nil,
        add_context: nil
      )
    end

    let(:agent_authorizations) { [project_agent_authorization, group_agent_authorization] }
    let(:filter_service) do
      instance_double(
        ::Clusters::Agents::Authorizations::CiAccess::FilterService,
        execute: agent_authorizations
      )
    end

    subject(:execute) { described_class.new(pipeline, token: build.token, environment: nil).execute }

    before do
      allow(Gitlab::Kubernetes::Kubeconfig::Template).to receive(:new).and_return(template)
      allow(::Clusters::Agents::Authorizations::CiAccess::FilterService).to receive(:new).and_return(filter_service)
    end

    it 'returns a Kubeconfig Template' do
      expect(execute).to eq(template)
    end

    it 'adds a cluster' do
      expect(template).to receive(:add_cluster).with(
        name: 'gitlab',
        url: Gitlab::Kas.tunnel_url
      ).once

      execute
    end

    it ""filters the pipeline's agents by `nil` environment"" do
      expect(::Clusters::Agents::Authorizations::CiAccess::FilterService).to receive(:new).with(
        pipeline.cluster_agent_authorizations,
        environment: nil
      )

      execute
    end

    it 'adds user and context for all eligible agents', :aggregate_failures do
      agent_authorizations.each do |authorization|
        expect(template).to receive(:add_user).with(
          name: ""agent:#{authorization.agent.id}"",
          token: ""ci:#{authorization.agent.id}:#{build.token}""
        )

        expect(template).to receive(:add_context).with(
          name: ""#{agent_project.full_path}:#{authorization.agent.name}"",
          namespace: 'production',
          cluster: 'gitlab',
          user: ""agent:#{authorization.agent.id}""
        )
      end

      execute
    end

    context 'when environment is specified' do
      subject(:execute) { described_class.new(pipeline, token: build.token, environment: 'production').execute }

      it ""filters the pipeline's agents by the specified environment"" do
        expect(::Clusters::Agents::Authorizations::CiAccess::FilterService).to receive(:new).with(
          pipeline.cluster_agent_authorizations,
          environment: 'production'
        )

        execute
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class UpdateBuildStateService
    include ::Gitlab::Utils::StrongMemoize
    include ::Gitlab::ExclusiveLeaseHelpers

    Result = Struct.new(:status, :backoff, keyword_init: true)
    InvalidTraceError = Class.new(StandardError)

    ACCEPT_TIMEOUT = 5.minutes.freeze

    attr_reader :build, :params, :metrics

    def initialize(build, params, metrics = ::Gitlab::Ci::Trace::Metrics.new)
      @build = build
      @params = params
      @metrics = metrics
    end

    def execute
      unless accept_available?
        return update_build_state!
      end

      ensure_pending_state!

      in_build_trace_lock do
        process_build_state!
      end
    end

    private

    def ensure_pending_state!
      pending_state.created_at
    end

    def process_build_state!
      if live_chunks_pending?
        if pending_state_outdated?
          discard_build_trace!
          update_build_state!
        else
          accept_build_state!
        end
      else
        validate_build_trace!
        update_build_state!
      end
    end

    def accept_build_state!
      build.trace_chunks.live.find_each do |chunk|
        chunk.schedule_to_persist!
      end

      metrics.increment_trace_operation(operation: :accepted)

      ::Gitlab::Ci::Runner::Backoff.new(pending_state.created_at).then do |backoff|
        Result.new(status: 202, backoff: backoff.to_seconds)
      end
    end

    def validate_build_trace!
      return unless has_chunks?

      unless live_chunks_pending?
        metrics.increment_trace_operation(operation: :finalized)
        metrics.observe_migration_duration(pending_state_seconds)
      end

      ::Gitlab::Ci::Trace::Checksum.new(build).then do |checksum|
        unless checksum.valid?
          metrics.increment_trace_operation(operation: :invalid)
          metrics.increment_error_counter(error_reason: :chunks_invalid_checksum)

          if checksum.corrupted?
            metrics.increment_trace_operation(operation: :corrupted)
            metrics.increment_error_counter(error_reason: :chunks_invalid_size)
          end

          next unless log_invalid_chunks?

          ::Gitlab::ErrorTracking.log_exception(InvalidTraceError.new,
            project_path: build.project.full_path,
            build_id: build.id,
            state_crc32: checksum.state_crc32,
            chunks_crc32: checksum.chunks_crc32,
            chunks_count: checksum.chunks_count,
            chunks_corrupted: checksum.corrupted?
          )
        end
      end
    end

    def update_build_state!
      case build_state
      when 'running'
        build.touch if build.needs_touch?

        Result.new(status: 200)
      when 'success'
        build.success!

        Result.new(status: 200)
      when 'failed'
        build.drop_with_exit_code!(params[:failure_reason], params[:exit_code])

        Result.new(status: 200)
      else
        Result.new(status: 400)
      end
    end

    def discard_build_trace!
      metrics.increment_trace_operation(operation: :discarded)
    end

    def accept_available?
      !build_running? && has_checksum? && chunks_migration_enabled?
    end

    def live_chunks_pending?
      build.trace_chunks.live.any?
    end

    def has_chunks?
      build.trace_chunks.any?
    end

    def pending_state_outdated?
      pending_state_duration > ACCEPT_TIMEOUT
    end

    def pending_state_duration
      Time.current - pending_state.created_at
    end

    def pending_state_seconds
      pending_state_duration.seconds
    end

    def build_state
      params.dig(:state).to_s
    end

    def has_checksum?
      trace_checksum.present?
    end

    def build_running?
      build_state == 'running'
    end

    def trace_checksum
      params.dig(:output, :checksum) || params.dig(:checksum)
    end

    def trace_bytesize
      params.dig(:output, :bytesize)
    end

    def pending_state
      strong_memoize(:pending_state) { ensure_pending_state }
    end

    def ensure_pending_state
      build_state = Ci::BuildPendingState.safe_find_or_create_by(
        build_id: build.id,
        partition_id: build.partition_id,
        state: params.fetch(:state),
        trace_checksum: trace_checksum,
        trace_bytesize: trace_bytesize,
        failure_reason: failure_reason
      )

      unless build_state.present?
        metrics.increment_trace_operation(operation: :conflict)
      end

      build_state || build.pending_state
    end

    def failure_reason
      reason = params.dig(:failure_reason)

      return unless reason

      Ci::BuildPendingState.failure_reasons.fetch(reason.to_s, 'unknown_failure')
    end

    ##
    # This method is releasing an exclusive lock on a build trace the moment we
    # conclude that build status has been written and the build state update
    # has been committed to the database.
    #
    # Because a build state machine schedules a bunch of workers to run after
    # build status transition to complete, we do not want to keep the lease
    # until all the workers are scheduled because it opens a possibility of
    # race conditions happening.
    #
    # Instead of keeping the lease until the transition is fully done and
    # workers are scheduled, we immediately release the lock after the database
    # commit happens.
    #
    def in_build_trace_lock(&block)
      build.trace.lock do |_, lease| # rubocop:disable CodeReuse/ActiveRecord
        build.run_on_status_commit { lease.cancel }

        yield
      end
    rescue ::Gitlab::Ci::Trace::LockedError
      metrics.increment_trace_operation(operation: :locked)

      accept_build_state!
    end

    def chunks_migration_enabled?
      ::Feature.enabled?(:ci_enable_live_trace, build.project) &&
        ::Feature.enabled?(:ci_accept_trace, build.project, type: :ops)
    end

    def log_invalid_chunks?
      ::Feature.enabled?(:ci_trace_log_invalid_chunks, build.project, type: :ops)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::UpdateBuildStateService, feature_category: :continuous_integration do
  let_it_be(:project) { create(:project) }
  let_it_be(:pipeline) { create(:ci_pipeline, project: project) }

  let(:build) { create(:ci_build, :running, pipeline: pipeline) }
  let(:metrics) { spy('metrics') }

  subject { described_class.new(build, params) }

  before do
    stub_feature_flags(ci_enable_live_trace: true)
  end

  context 'when build has unknown failure reason' do
    let(:params) do
      {
        output: { checksum: 'crc32:12345678', bytesize: 123 },
        state: 'failed',
        failure_reason: 'no idea here',
        exit_code: 42
      }
    end

    it 'updates a build status' do
      result = subject.execute

      expect(build).to be_failed
      expect(result.status).to eq 200
    end
  end

  context 'when build has failed' do
    let(:params) do
      {
        output: { checksum: 'crc32:12345678', bytesize: 123 },
        state: 'failed',
        failure_reason: 'script_failure',
        exit_code: 7
      }
    end

    it 'sends a build failed event to Snowplow' do
      expect(::Ci::TrackFailedBuildWorker)
        .to receive(:perform_async).with(build.id, params[:exit_code], params[:failure_reason])

      subject.execute
    end
  end

  context 'when build does not have checksum' do
    context 'when state has changed' do
      let(:params) { { state: 'success' } }

      it 'updates a state of a running build' do
        subject.execute

        expect(build).to be_success
      end

      it 'returns 200 OK status' do
        result = subject.execute

        expect(result.status).to eq 200
      end

      it 'does not increment finalized trace metric' do
        execute_with_stubbed_metrics!

        expect(metrics)
          .not_to have_received(:increment_trace_operation)
          .with(operation: :finalized)
      end
    end

    context 'when it is a heartbeat request' do
      let(:params) { { state: 'success' } }

      it 'updates a build timestamp' do
        expect { subject.execute }.to change { build.updated_at }
      end
    end

    context 'when state is unknown' do
      let(:params) { { state: 'unknown' } }

      it 'responds with 400 bad request' do
        result = subject.execute

        expect(result.status).to eq 400
        expect(build).to be_running
      end
    end
  end

  context 'when build has a checksum' do
    let(:params) do
      {
        output: { checksum: 'crc32:12345678', bytesize: 123 },
        state: 'failed',
        failure_reason: 'script_failure',
        exit_code: 42
      }
    end

    context 'when build does not have associated trace chunks' do
      it 'updates a build status' do
        result = subject.execute

        expect(build).to be_failed
        expect(result.status).to eq 200
      end

      it 'updates the allow_failure flag' do
        expect(build)
          .to receive(:drop_with_exit_code!)
          .with('script_failure', 42)
          .and_call_original

        subject.execute
      end

      it 'does not increment invalid trace metric' do
        execute_with_stubbed_metrics!

        expect(metrics)
          .not_to have_received(:increment_trace_operation)
          .with(operation: :invalid)
      end

      it 'does not increment chunks_invalid_checksum trace metric' do
        execute_with_stubbed_metrics!

        expect(metrics)
          .not_to have_received(:increment_error_counter)
          .with(error_reason: :chunks_invalid_checksum)
      end
    end

    context 'when build trace has been migrated' do
      before do
        create(:ci_build_trace_chunk, :persisted, build: build, initial_data: 'abcd')
      end

      it 'updates a build state' do
        subject.execute

        expect(build).to be_failed
      end

      it 'updates the allow_failure flag' do
        expect(build)
          .to receive(:drop_with_exit_code!)
          .with('script_failure', 42)
          .and_call_original

        subject.execute
      end

      it 'responds with 200 OK status' do
        result = subject.execute

        expect(result.status).to eq 200
      end

      it 'does not set a backoff value' do
        result = subject.execute

        expect(result.backoff).to be_nil
      end

      it 'increments trace finalized operation metric' do
        execute_with_stubbed_metrics!

        expect(metrics)
          .to have_received(:increment_trace_operation)
          .with(operation: :finalized)
      end

      it 'records migration duration in a histogram' do
        freeze_time do
          create(:ci_build_pending_state, build: build, created_at: 0.5.seconds.ago)

          execute_with_stubbed_metrics!
        end

        expect(metrics)
          .to have_received(:observe_migration_duration)
          .with(0.5)
      end

      context 'when trace checksum is not valid' do
        it 'increments invalid trace metric' do
          execute_with_stubbed_metrics!

          expect(metrics)
            .to have_received(:increment_trace_operation)
            .with(operation: :invalid)
        end

        it 'increments chunks_invalid_checksum trace metric' do
          execute_with_stubbed_metrics!

          expect(metrics)
            .to have_received(:increment_error_counter)
            .with(error_reason: :chunks_invalid_checksum)
        end
      end

      context 'when trace checksum is valid' do
        let(:params) do
          { output: { checksum: 'crc32:ed82cd11', bytesize: 4 }, state: 'success' }
        end

        it 'does not increment invalid or corrupted trace metric' do
          execute_with_stubbed_metrics!

          expect(metrics)
            .not_to have_received(:increment_trace_operation)
            .with(operation: :invalid)

          expect(metrics)
            .not_to have_received(:increment_trace_operation)
            .with(operation: :corrupted)

          expect(metrics)
            .not_to have_received(:increment_error_counter)
            .with(error_reason: :chunks_invalid_checksum)

          expect(metrics)
            .not_to have_received(:increment_error_counter)
            .with(error_reason: :chunks_invalid_size)
        end

        context 'when using deprecated parameters' do
          let(:params) do
            { checksum: 'crc32:ed82cd11', state: 'success' }
          end

          it 'does not increment invalid or corrupted trace metric' do
            execute_with_stubbed_metrics!

            expect(metrics)
              .not_to have_received(:increment_trace_operation)
              .with(operation: :invalid)

            expect(metrics)
              .not_to have_received(:increment_trace_operation)
              .with(operation: :corrupted)

            expect(metrics)
              .not_to have_received(:increment_error_counter)
              .with(error_reason: :chunks_invalid_checksum)

            expect(metrics)
              .not_to have_received(:increment_error_counter)
              .with(error_reason: :chunks_invalid_size)
          end
        end
      end

      context 'when trace checksum is invalid and the log is corrupted' do
        let(:params) do
          { output: { checksum: 'crc32:12345678', bytesize: 1 }, state: 'success' }
        end

        it 'increments invalid and corrupted trace metrics' do
          execute_with_stubbed_metrics!

          expect(metrics)
            .to have_received(:increment_trace_operation)
            .with(operation: :invalid)

          expect(metrics)
            .to have_received(:increment_trace_operation)
            .with(operation: :corrupted)

          expect(metrics)
            .to have_received(:increment_error_counter)
            .with(error_reason: :chunks_invalid_checksum)

          expect(metrics)
            .to have_received(:increment_error_counter)
            .with(error_reason: :chunks_invalid_size)
        end
      end

      context 'when trace checksum is invalid but the log seems fine' do
        let(:params) do
          { output: { checksum: 'crc32:12345678', bytesize: 4 }, state: 'success' }
        end

        it 'does not increment corrupted trace metric' do
          execute_with_stubbed_metrics!

          expect(metrics)
            .to have_received(:increment_trace_operation)
            .with(operation: :invalid)

          expect(metrics)
            .to have_received(:increment_error_counter)
            .with(error_reason: :chunks_invalid_checksum)

          expect(metrics)
            .not_to have_received(:increment_trace_operation)
            .with(operation: :corrupted)

          expect(metrics)
            .not_to have_received(:increment_error_counter)
            .with(error_reason: :chunks_invalid_size)
        end
      end

      context 'when failed to acquire a build trace lock' do
        it 'accepts a state update request' do
          build.trace.lock do
            result = subject.execute

            expect(result.status).to eq 202
          end
        end

        it 'increment locked trace metric' do
          build.trace.lock do
            execute_with_stubbed_metrics!

            expect(metrics)
              .to have_received(:increment_trace_operation)
              .with(operation: :locked)
          end
        end
      end
    end

    context 'when build trace has not been migrated yet' do
      before do
        create(:ci_build_trace_chunk, :redis_with_data, build: build)
      end

      it 'does not update a build state' do
        subject.execute

        expect(build).to be_running
      end

      it 'responds with 202 accepted' do
        result = subject.execute

        expect(result.status).to eq 202
      end

      it 'sets a request backoff value' do
        result = subject.execute

        expect(result.backoff.to_i).to be > 0
      end

      it 'schedules live chunks for migration' do
        expect(Ci::BuildTraceChunkFlushWorker)
          .to receive(:perform_async)
          .with(build.trace_chunks.first.id)

        subject.execute
      end

      it 'creates a pending state record' do
        subject.execute

        build.pending_state.then do |status|
          expect(status).to be_present
          expect(status.state).to eq 'failed'
          expect(status.trace_checksum).to eq 'crc32:12345678'
          expect(status.failure_reason).to eq 'script_failure'
        end
      end

      it 'increments trace accepted operation metric' do
        execute_with_stubbed_metrics!

        expect(metrics)
          .to have_received(:increment_trace_operation)
          .with(operation: :accepted)
      end

      it 'does not increment invalid trace metric' do
        execute_with_stubbed_metrics!

        expect(metrics)
          .not_to have_received(:increment_trace_operation)
          .with(operation: :invalid)

        expect(metrics)
          .not_to have_received(:increment_error_counter)
          .with(error_reason: :chunks_invalid_checksum)
      end

      context 'when build pending state is outdated' do
        before do
          build.create_pending_state(
            state: 'failed',
            trace_checksum: 'crc32:12345678',
            failure_reason: 'script_failure',
            created_at: 10.minutes.ago
          )
        end

        it 'responds with 200 OK' do
          result = subject.execute

          expect(result.status).to eq 200
        end

        it 'updates build state' do
          subject.execute

          expect(build.reload).to be_failed
          expect(build.failure_reason).to eq 'script_failure'
        end

        it 'increments discarded traces metric' do
          execute_with_stubbed_metrics!

          expect(metrics)
            .to have_received(:increment_trace_operation)
            .with(operation: :discarded)
        end

        it 'does not increment finalized trace metric' do
          execute_with_stubbed_metrics!

          expect(metrics)
            .not_to have_received(:increment_trace_operation)
            .with(operation: :finalized)
        end
      end

      context 'when build pending state has changes' do
        before do
          build.create_pending_state(
            state: 'success',
            created_at: 10.minutes.ago
          )
        end

        it 'uses stored state and responds with 200 OK' do
          result = subject.execute

          expect(result.status).to eq 200
        end

        it 'increments conflict trace metric' do
          execute_with_stubbed_metrics!

          expect(metrics)
            .to have_received(:increment_trace_operation)
            .with(operation: :conflict)
        end
      end

      context 'when live traces are disabled' do
        before do
          stub_feature_flags(ci_enable_live_trace: false)
        end

        it 'responds with 200 OK' do
          result = subject.execute

          expect(result.status).to eq 200
        end
      end
    end
  end

  def execute_with_stubbed_metrics!
    described_class
      .new(build, params, metrics)
      .execute
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class PlayManualStageService < BaseService
    def initialize(project, current_user, params)
      super

      @pipeline = params[:pipeline]
    end

    def execute(stage)
      stage.processables.manual.each do |processable|
        next unless processable.playable?

        processable.play(current_user)
      rescue Gitlab::Access::AccessDeniedError
        logger.error(message: 'Unable to play manual action', processable_id: processable.id)
      end
    end

    private

    attr_reader :pipeline, :current_user

    def logger
      Gitlab::AppLogger
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::PlayManualStageService, '#execute', feature_category: :continuous_integration do
  let(:current_user) { create(:user) }
  let(:pipeline) { create(:ci_pipeline, user: current_user) }
  let(:project) { pipeline.project }
  let(:downstream_project) { create(:project) }
  let(:service) { described_class.new(project, current_user, pipeline: pipeline) }
  let(:stage_status) { 'manual' }

  let(:stage) do
    create(:ci_stage, pipeline: pipeline, project: project, name: 'test')
  end

  before do
    project.add_maintainer(current_user)
    downstream_project.add_maintainer(current_user)
    create_builds_for_stage(status: stage_status)
    create_bridge_for_stage(status: stage_status)
  end

  context 'when pipeline has manual processables' do
    before do
      service.execute(stage)
    end

    it 'starts manual processables from pipeline' do
      expect(pipeline.processables.manual.count).to eq(0)
    end

    it 'updates manual processables' do
      pipeline.processables.each do |processable|
        expect(processable.user).to eq(current_user)
      end
    end
  end

  context 'when pipeline has no manual processables' do
    let(:stage_status) { 'failed' }

    before do
      service.execute(stage)
    end

    it 'does not update the processables' do
      expect(pipeline.processables.failed.count).to eq(4)
    end
  end

  context 'when user does not have permission on a specific processable' do
    before do
      allow_next_instance_of(Ci::Processable) do |instance|
        allow(instance).to receive(:play).and_raise(Gitlab::Access::AccessDeniedError)
      end

      service.execute(stage)
    end

    it 'logs the error' do
      expect(Gitlab::AppLogger).to receive(:error)
        .exactly(stage.processables.manual.count)

      service.execute(stage)
    end
  end

  private

  def create_builds_for_stage(options)
    options.merge!({
      when: 'manual',
      pipeline: pipeline,
      stage_id: stage.id,
      user: pipeline.user
    })

    create_list(:ci_build, 3, options)
  end

  def create_bridge_for_stage(options)
    options.merge!({
      when: 'manual',
      pipeline: pipeline,
      stage_id: stage.id,
      user: pipeline.user,
      downstream: downstream_project
    })

    create(:ci_bridge, options)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class BuildEraseService
    include BaseServiceUtility

    def initialize(build, current_user)
      @build = build
      @current_user = current_user
    end

    def execute
      unless build.erasable?
        return ServiceResponse.error(message: _('Build cannot be erased'), http_status: :unprocessable_entity)
      end

      if build.project.refreshing_build_artifacts_size?
        Gitlab::ProjectStatsRefreshConflictsLogger.warn_artifact_deletion_during_stats_refresh(
          method: 'Ci::BuildEraseService#execute',
          project_id: build.project_id
        )
      end

      destroy_artifacts
      erase_trace!
      update_erased!

      ServiceResponse.success(payload: build)
    end

    private

    attr_reader :build, :current_user

    def destroy_artifacts
      Ci::JobArtifacts::DestroyBatchService.new(build.job_artifacts).execute
    end

    def erase_trace!
      build.trace.erase!
    end

    def update_erased!
      build.update(erased_by: current_user, erased_at: Time.current, artifacts_expire_at: nil)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::BuildEraseService, feature_category: :continuous_integration do
  let_it_be(:user) { user }

  let(:build) { create(:ci_build, :artifacts, :trace_artifact, artifacts_expire_at: 100.days.from_now) }

  subject(:service) { described_class.new(build, user) }

  describe '#execute' do
    context 'when build is erasable' do
      before do
        allow(build).to receive(:erasable?).and_return(true)
      end

      it 'is successful' do
        result = service.execute

        expect(result).to be_success
      end

      it 'erases artifacts' do
        service.execute

        expect(build.artifacts_file).not_to be_present
        expect(build.artifacts_metadata).not_to be_present
      end

      it 'erases trace' do
        service.execute

        expect(build.trace).not_to exist
      end

      it 'records erasure detail' do
        freeze_time do
          service.execute

          expect(build.erased_by).to eq(user)
          expect(build.erased_at).to eq(Time.current)
          expect(build.artifacts_expire_at).to be_nil
        end
      end

      context 'when project is undergoing statistics refresh' do
        before do
          allow(build.project).to receive(:refreshing_build_artifacts_size?).and_return(true)
        end

        it 'logs a warning' do
          expect(Gitlab::ProjectStatsRefreshConflictsLogger)
            .to receive(:warn_artifact_deletion_during_stats_refresh)
            .with(method: 'Ci::BuildEraseService#execute', project_id: build.project_id)

          service.execute
        end
      end
    end

    context 'when build is not erasable' do
      before do
        allow(build).to receive(:erasable?).and_return(false)
      end

      it 'is not successful' do
        result = service.execute

        expect(result).to be_error
        expect(result.http_status).to eq(:unprocessable_entity)
      end

      it 'does not erase artifacts' do
        service.execute

        expect(build.artifacts_file).to be_present
        expect(build.artifacts_metadata).to be_present
      end

      it 'does not erase trace' do
        service.execute

        expect(build.trace).to exist
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class ListConfigVariablesService < ::BaseService
    include ReactiveCaching

    self.reactive_cache_key = ->(service) { [service.class.name, service.id] }
    self.reactive_cache_work_type = :external_dependency
    self.reactive_cache_worker_finder = ->(id, *_args) { from_cache(id) }

    def self.from_cache(id)
      project_id, user_id = id.split('-')

      project = Project.find(project_id)
      user = User.find(user_id)

      new(project, user)
    end

    def execute(ref)
      sha = project.commit(ref).try(:sha)

      with_reactive_cache(sha) { |result| result }
    end

    def calculate_reactive_cache(sha)
      config = ::Gitlab::Ci::ProjectConfig.new(project: project, sha: sha)

      return {} unless config.exists?

      result = Gitlab::Ci::YamlProcessor.new(
        config.content,
        project: project,
        user: current_user,
        sha: sha,
        verify_project_sha: true
      ).execute

      result.valid? ? result.root_variables_with_prefill_data : {}
    end

    # Required for ReactiveCaching, it is also used in `reactive_cache_worker_finder`
    def id
      ""#{project.id}-#{current_user.id}""
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::ListConfigVariablesService,
  :use_clean_rails_memory_store_caching, feature_category: :secrets_management do
  include ReactiveCachingHelpers

  let(:ci_config) { {} }
  let(:files) { { '.gitlab-ci.yml' => YAML.dump(ci_config) } }
  let(:project) { create(:project, :custom_repo, :auto_devops_disabled, files: files) }
  let(:user) { project.creator }
  let(:ref) { project.default_branch }
  let(:sha) { project.commit(ref).sha }
  let(:service) { described_class.new(project, user) }

  subject(:result) { service.execute(ref) }

  context 'when sending a valid ref' do
    let(:ci_config) do
      {
        variables: {
          KEY1: { value: 'val 1', description: 'description 1' },
          KEY2: { value: 'val 2', description: '' },
          KEY3: { value: 'val 3' },
          KEY4: 'val 4'
        },
        test: {
          stage: 'test',
          script: 'echo'
        }
      }
    end

    let(:expected_result) do
      {
        'KEY1' => { value: 'val 1', description: 'description 1' },
        'KEY2' => { value: 'val 2', description: '' },
        'KEY3' => { value: 'val 3' },
        'KEY4' => { value: 'val 4' }
      }
    end

    before do
      synchronous_reactive_cache(service)
    end

    it 'returns variables list' do
      expect(result).to eq(expected_result)
    end

    context 'when the ref is a sha from a fork' do
      include_context 'when a project repository contains a forked commit'

      before do
        allow_next_instance_of(Gitlab::Ci::ProjectConfig) do |instance|
          allow(instance).to receive(:exists?).and_return(true)
          allow(instance).to receive(:content).and_return(YAML.dump(ci_config))
        end
      end

      let(:ref) { forked_commit_sha }

      context 'when a project ref contains the sha' do
        before do
          mock_branch_contains_forked_commit_sha
        end

        it 'returns variables list' do
          expect(result).to eq(expected_result)
        end
      end

      context 'when a project ref does not contain the sha' do
        it 'returns empty response' do
          expect(result).to eq({})
        end
      end
    end
  end

  context 'when config has includes' do
    let(:ci_config) do
      {
        include: [{ local: 'other_file.yml' }],
        variables: {
          KEY1: { value: 'val 1', description: 'description 1' }
        },
        test: {
          stage: 'test',
          script: 'echo'
        }
      }
    end

    let(:other_file) do
      {
        variables: {
          KEY2: { value: 'val 2', description: 'description 2' }
        }
      }
    end

    let(:files) { { '.gitlab-ci.yml' => YAML.dump(ci_config), 'other_file.yml' => YAML.dump(other_file) } }

    before do
      synchronous_reactive_cache(service)
    end

    it 'returns variable list' do
      expect(result['KEY1']).to eq({ value: 'val 1', description: 'description 1' })
      expect(result['KEY2']).to eq({ value: 'val 2', description: 'description 2' })
    end
  end

  context 'when project CI config is external' do
    let(:other_project_ci_config) do
      {
        variables: { KEY1: { value: 'val 1', description: 'description 1' } },
        test: { script: 'echo' }
      }
    end

    let(:other_project_files) { { '.gitlab-ci.yml' => YAML.dump(other_project_ci_config) } }
    let(:other_project) { create(:project, :custom_repo, files: other_project_files) }

    before do
      project.update!(ci_config_path: "".gitlab-ci.yml@#{other_project.full_path}:master"")
      synchronous_reactive_cache(service)
    end

    context 'when the user has access to the external project' do
      before do
        other_project.add_developer(user)
      end

      it 'returns variable list' do
        expect(result['KEY1']).to eq({ value: 'val 1', description: 'description 1' })
      end
    end

    context 'when the user has no access to the external project' do
      it 'returns empty json' do
        expect(result).to eq({})
      end
    end
  end

  context 'when sending an invalid ref' do
    let(:ref) { 'invalid-ref' }
    let(:ci_config) { nil }

    before do
      synchronous_reactive_cache(service)
    end

    it 'returns empty json' do
      expect(result).to eq({})
    end
  end

  context 'when sending an invalid config' do
    let(:ci_config) do
      {
        variables: {
          KEY1: { value: 'val 1', description: 'description 1' }
        },
        test: {
          stage: 'invalid',
          script: 'echo'
        }
      }
    end

    before do
      synchronous_reactive_cache(service)
    end

    it 'returns empty result' do
      expect(result).to eq({})
    end
  end

  context 'when reading from cache' do
    let(:reactive_cache_params) { [sha] }
    let(:return_value) { { 'KEY1' => { value: 'val 1', description: 'description 1' } } }

    before do
      stub_reactive_cache(service, return_value, reactive_cache_params)
    end

    it 'returns variable list' do
      expect(result).to eq(return_value)
    end
  end

  context 'when the cache is empty' do
    let(:reactive_cache_params) { [sha] }

    it 'returns nil and enquques the worker to fill cache' do
      expect(ExternalServiceReactiveCachingWorker)
        .to receive(:perform_async)
        .with(service.class, service.id, *reactive_cache_params)

      expect(result).to be_nil
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class PlayBridgeService < ::BaseService
    def execute(bridge)
      check_access!(bridge)

      Ci::EnqueueJobService.new(bridge, current_user: current_user).execute
    end

    private

    def check_access!(bridge)
      raise Gitlab::Access::AccessDeniedError unless can?(current_user, :play_job, bridge)
    end
  end
end

Ci::PlayBridgeService.prepend_mod_with('Ci::PlayBridgeService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::PlayBridgeService, '#execute', feature_category: :continuous_integration do
  let(:project) { create(:project) }
  let(:user) { create(:user) }
  let(:pipeline) { create(:ci_pipeline, project: project) }
  let(:downstream_project) { create(:project) }
  let(:bridge) { create(:ci_bridge, :playable, pipeline: pipeline, downstream: downstream_project) }
  let(:instance) { described_class.new(project, user) }

  subject(:execute_service) { instance.execute(bridge) }

  context 'when user can run the bridge' do
    before do
      allow(instance).to receive(:can?).with(user, :play_job, bridge).and_return(true)
    end

    it 'marks the bridge pending' do
      execute_service

      expect(bridge.reload).to be_pending
    end

    it ""updates bridge's user"" do
      execute_service

      expect(bridge.reload.user).to eq(user)
    end

    it 'enqueues Ci::CreateDownstreamPipelineWorker' do
      expect(::Ci::CreateDownstreamPipelineWorker).to receive(:perform_async).with(bridge.id)

      execute_service
    end

    context 'when a subsequent job is skipped' do
      let!(:job) { create(:ci_build, :skipped, pipeline: pipeline, stage_idx: bridge.stage_idx + 1) }

      before do
        create(:ci_build_need, build: job, name: bridge.name)
      end

      it 'marks the subsequent job as processable' do
        expect { execute_service }.to change { job.reload.status }.from('skipped').to('created')
      end
    end

    context 'when bridge is not playable' do
      let(:bridge) { create(:ci_bridge, :failed, pipeline: pipeline, downstream: downstream_project) }

      it 'raises StateMachines::InvalidTransition' do
        expect { execute_service }.to raise_error StateMachines::InvalidTransition
      end
    end
  end

  context 'when user can not run the bridge' do
    before do
      allow(instance).to receive(:can?).with(user, :play_job, bridge).and_return(false)
    end

    it 'allows user with developer role to play a bridge' do
      expect { execute_service }.to raise_error Gitlab::Access::AccessDeniedError
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  # This class loops through all builds with exposed artifacts and returns
  # basic information about exposed artifacts for given jobs for the frontend
  # to display them as custom links in the merge request.
  #
  # This service must be used with care.
  # Looking for exposed artifacts is very slow and should be done asynchronously.
  class FindExposedArtifactsService < ::BaseService
    include Gitlab::Routing

    MAX_EXPOSED_ARTIFACTS = 10

    def for_pipeline(pipeline, limit: MAX_EXPOSED_ARTIFACTS)
      results = []

      pipeline.builds.latest.with_exposed_artifacts.find_each do |job|
        if job_exposed_artifacts = for_job(job)
          results << job_exposed_artifacts
        end

        break if results.size >= limit
      end

      results
    end

    def for_job(job)
      return unless job.has_exposed_artifacts?

      metadata_entries = first_2_metadata_entries_for_artifacts_paths(job)
      return if metadata_entries.empty?

      {
        text: job.artifacts_expose_as,
        url: path_for_entries(metadata_entries, job),
        job_path: project_job_path(job.project, job),
        job_name: job.name
      }
    end

    private

    # we don't need to fetch all artifacts entries for a job because
    # it could contain many. We only need to know whether it has 1 or more
    # artifacts, so fetching the first 2 would be sufficient.
    def first_2_metadata_entries_for_artifacts_paths(job)
      return [] unless job.artifacts_metadata

      job.artifacts_paths
        .lazy
        .map { |path| job.artifacts_metadata_entry(path, recursive: true) }
        .select { |entry| entry.exists? }
        .first(2)
    end

    def path_for_entries(entries, job)
      return if entries.empty?

      if single_artifact?(entries)
        file_project_job_artifacts_path(job.project, job, entries.first.path)
      else
        browse_project_job_artifacts_path(job.project, job)
      end
    end

    def single_artifact?(entries)
      entries.size == 1 && entries.first.file?
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::FindExposedArtifactsService, feature_category: :build_artifacts do
  include Gitlab::Routing

  let(:metadata) do
    Gitlab::Ci::Build::Artifacts::Metadata
      .new(metadata_file_stream, path, { recursive: true })
  end

  let(:metadata_file_stream) do
    File.open(Rails.root + 'spec/fixtures/ci_build_artifacts_metadata.gz')
  end

  let_it_be(:project) { create(:project) }

  let(:user) { nil }

  after do
    metadata_file_stream&.close
  end

  def create_job_with_artifacts(options)
    create(:ci_build, pipeline: pipeline, options: options).tap do |job|
      create(:ci_job_artifact, :metadata, job: job)
    end
  end

  describe '#for_pipeline' do
    shared_examples 'finds a single match' do
      it 'returns the artifact with exact location' do
        expect(subject).to eq([{
          text: 'Exposed artifact',
          url: file_project_job_artifacts_path(project, job, 'other_artifacts_0.1.2/doc_sample.txt'),
          job_name: job.name,
          job_path: project_job_path(project, job)
        }])
      end
    end

    shared_examples 'finds multiple matches' do
      it 'returns the path to the artifacts browser' do
        expect(subject).to eq([{
          text: 'Exposed artifact',
          url: browse_project_job_artifacts_path(project, job),
          job_name: job.name,
          job_path: project_job_path(project, job)
        }])
      end
    end

    shared_examples 'does not find any matches' do
      it 'returns empty array' do
        expect(subject).to eq []
      end
    end

    let_it_be(:pipeline) { create(:ci_pipeline, project: project) }

    subject { described_class.new(project, user).for_pipeline(pipeline) }

    context 'with jobs having no exposed artifacts' do
      let!(:job) do
        create_job_with_artifacts(artifacts: {
          paths: ['other_artifacts_0.1.2/doc_sample.txt', 'something-else.html']
        })
      end

      it_behaves_like 'does not find any matches'
    end

    context 'with jobs having no artifacts (metadata)' do
      let!(:job) do
        create(:ci_build, pipeline: pipeline, options: {
          artifacts: {
            expose_as: 'Exposed artifact',
            paths: ['other_artifacts_0.1.2/doc_sample.txt', 'something-else.html']
          }
        })
      end

      it_behaves_like 'does not find any matches'
    end

    context 'with jobs having at most 1 matching exposed artifact' do
      let!(:job) do
        create_job_with_artifacts(artifacts: {
          expose_as: 'Exposed artifact',
          paths: ['other_artifacts_0.1.2/doc_sample.txt', 'something-else.html']
        })
      end

      it_behaves_like 'finds a single match'
    end

    context 'with jobs having more than 1 matching exposed artifacts' do
      let!(:job) do
        create_job_with_artifacts(artifacts: {
          expose_as: 'Exposed artifact',
          paths: [
            'ci_artifacts.txt',
            'other_artifacts_0.1.2/doc_sample.txt',
            'something-else.html'
          ]
        })
      end

      it_behaves_like 'finds multiple matches'
    end

    context 'with jobs having more than 1 matching exposed artifacts inside a directory' do
      let!(:job) do
        create_job_with_artifacts(artifacts: {
          expose_as: 'Exposed artifact',
          paths: ['tests_encoding/']
        })
      end

      it_behaves_like 'finds multiple matches'
    end

    context 'with jobs having paths with glob expression' do
      let!(:job) do
        create_job_with_artifacts(artifacts: {
          expose_as: 'Exposed artifact',
          paths: ['other_artifacts_0.1.2/doc_sample.txt', 'tests_encoding/*.*']
        })
      end

      it_behaves_like 'finds a single match' # because those with * are ignored
    end

    context 'limiting results' do
      let!(:job1) do
        create_job_with_artifacts(artifacts: {
          expose_as: 'artifact 1',
          paths: ['ci_artifacts.txt']
        })
      end

      let!(:job2) do
        create_job_with_artifacts(artifacts: {
          expose_as: 'artifact 2',
          paths: ['tests_encoding/']
        })
      end

      let!(:job3) do
        create_job_with_artifacts(artifacts: {
          expose_as: 'should not be exposed',
          paths: ['other_artifacts_0.1.2/doc_sample.txt']
        })
      end

      subject { described_class.new(project, user).for_pipeline(pipeline, limit: 2) }

      it 'returns first 2 results' do
        expect(subject).to eq(
          [
            {
              text: 'artifact 1',
              url: file_project_job_artifacts_path(project, job1, 'ci_artifacts.txt'),
              job_name: job1.name,
              job_path: project_job_path(project, job1)
            },
            {
              text: 'artifact 2',
              url: browse_project_job_artifacts_path(project, job2),
              job_name: job2.name,
              job_path: project_job_path(project, job2)
            }
          ])
      end
    end

    context 'cross-project MR' do
      let!(:foreign_project) { create(:project) }
      let!(:pipeline) { create(:ci_pipeline, project: foreign_project) }

      let!(:job_show) do
        create_job_with_artifacts({
          artifacts: {
            expose_as: 'file artifact',
            paths: ['ci_artifacts.txt']
          }
        })
      end

      let!(:job_browse) do
        create_job_with_artifacts({
          artifacts: {
            expose_as: 'directory artifact',
            paths: ['tests_encoding/']
          }
        })
      end

      subject { described_class.new(project, user).for_pipeline(pipeline, limit: 2) }

      it 'returns the correct path for cross-project MRs' do
        expect(subject).to eq(
          [
            {
              text: 'file artifact',
              url: file_project_job_artifacts_path(foreign_project, job_show, 'ci_artifacts.txt'),
              job_name: job_show.name,
              job_path: project_job_path(foreign_project, job_show)
            },
            {
              text: 'directory artifact',
              url: browse_project_job_artifacts_path(foreign_project, job_browse),
              job_name: job_browse.name,
              job_path: project_job_path(foreign_project, job_browse)
            }
          ])
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class UpdatePendingBuildService
    VALID_PARAMS = %i[instance_runners_enabled namespace_id namespace_traversal_ids].freeze

    InvalidParamsError = Class.new(StandardError)
    InvalidModelError = Class.new(StandardError)

    def initialize(model, update_params)
      @model = model
      @update_params = update_params.symbolize_keys

      validations!
    end

    def execute
      @model.pending_builds.each_batch do |relation|
        relation.update_all(@update_params)
      end
    end

    private

    def validations!
      validate_model! && validate_params!
    end

    def validate_model!
      raise InvalidModelError unless @model.is_a?(::Project) || @model.is_a?(::Group)

      true
    end

    def validate_params!
      extra_params = @update_params.keys - VALID_PARAMS

      raise InvalidParamsError, ""Unvalid params: #{extra_params.join(', ')}"" unless extra_params.empty?

      true
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::UpdatePendingBuildService, feature_category: :continuous_integration do
  let_it_be(:group) { create(:group) }
  let_it_be(:project) { create(:project, namespace: group) }
  let_it_be_with_reload(:pending_build_1) { create(:ci_pending_build, project: project, instance_runners_enabled: false) }
  let_it_be_with_reload(:pending_build_2) { create(:ci_pending_build, project: project, instance_runners_enabled: true) }
  let_it_be(:update_params) { { instance_runners_enabled: true } }

  let(:service) { described_class.new(model, update_params) }

  describe '#execute' do
    subject(:update_pending_builds) { service.execute }

    context 'validations' do
      context 'when model is invalid' do
        let(:model) { pending_build_1 }

        it 'raises an error' do
          expect { update_pending_builds }.to raise_error(described_class::InvalidModelError)
        end
      end

      context 'when params is invalid' do
        let(:model) { group }
        let(:update_params) { { minutes_exceeded: true } }

        it 'raises an error' do
          expect { update_pending_builds }.to raise_error(described_class::InvalidParamsError)
        end
      end
    end

    context 'when model is a group with pending builds' do
      let(:model) { group }

      it 'updates all pending builds', :aggregate_failures do
        update_pending_builds

        expect(pending_build_1.instance_runners_enabled).to be_truthy
        expect(pending_build_2.instance_runners_enabled).to be_truthy
      end
    end

    context 'when model is a project with pending builds' do
      let(:model) { project }

      it 'updates all pending builds', :aggregate_failures do
        update_pending_builds

        expect(pending_build_1.instance_runners_enabled).to be_truthy
        expect(pending_build_2.instance_runners_enabled).to be_truthy
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class CreatePipelineService < BaseService
    attr_reader :pipeline, :logger

    LOG_MAX_DURATION_THRESHOLD = 3.seconds
    LOG_MAX_PIPELINE_SIZE = 2_000
    LOG_MAX_CREATION_THRESHOLD = 20.seconds
    SEQUENCE = [Gitlab::Ci::Pipeline::Chain::Build,
                Gitlab::Ci::Pipeline::Chain::Build::Associations,
                Gitlab::Ci::Pipeline::Chain::Validate::Abilities,
                Gitlab::Ci::Pipeline::Chain::Validate::Repository,
                Gitlab::Ci::Pipeline::Chain::Limit::RateLimit,
                Gitlab::Ci::Pipeline::Chain::Validate::SecurityOrchestrationPolicy,
                Gitlab::Ci::Pipeline::Chain::Skip,
                Gitlab::Ci::Pipeline::Chain::Config::Content,
                Gitlab::Ci::Pipeline::Chain::Config::Process,
                Gitlab::Ci::Pipeline::Chain::Validate::AfterConfig,
                Gitlab::Ci::Pipeline::Chain::RemoveUnwantedChatJobs,
                Gitlab::Ci::Pipeline::Chain::SeedBlock,
                Gitlab::Ci::Pipeline::Chain::EvaluateWorkflowRules,
                Gitlab::Ci::Pipeline::Chain::AssignPartition,
                Gitlab::Ci::Pipeline::Chain::Seed,
                Gitlab::Ci::Pipeline::Chain::Limit::Size,
                Gitlab::Ci::Pipeline::Chain::Limit::ActiveJobs,
                Gitlab::Ci::Pipeline::Chain::Limit::Deployments,
                Gitlab::Ci::Pipeline::Chain::Validate::External,
                Gitlab::Ci::Pipeline::Chain::Populate,
                Gitlab::Ci::Pipeline::Chain::PopulateMetadata,
                Gitlab::Ci::Pipeline::Chain::StopDryRun,
                Gitlab::Ci::Pipeline::Chain::EnsureEnvironments,
                Gitlab::Ci::Pipeline::Chain::EnsureResourceGroups,
                Gitlab::Ci::Pipeline::Chain::Create,
                Gitlab::Ci::Pipeline::Chain::CreateCrossDatabaseAssociations,
                Gitlab::Ci::Pipeline::Chain::CancelPendingPipelines,
                Gitlab::Ci::Pipeline::Chain::Metrics,
                Gitlab::Ci::Pipeline::Chain::TemplateUsage,
                Gitlab::Ci::Pipeline::Chain::Pipeline::Process].freeze

    # Create a new pipeline in the specified project.
    #
    # @param [Symbol] source                                  What event (Ci::Pipeline.sources) triggers the pipeline
    #                                                         creation.
    # @param [Boolean] ignore_skip_ci                         Whether skipping a pipeline creation when `[skip ci]` comment
    #                                                         is present in the commit body
    # @param [Boolean] save_on_errors                         Whether persisting an invalid pipeline when it encounters an
    #                                                         error during creation (e.g. invalid yaml)
    # @param [Ci::TriggerRequest] trigger_request             The pipeline trigger triggers the pipeline creation.
    # @param [Ci::PipelineSchedule] schedule                  The pipeline schedule triggers the pipeline creation.
    # @param [MergeRequest] merge_request                     The merge request triggers the pipeline creation.
    # @param [Ci::ExternalPullRequest] external_pull_request  The external pull request triggers the pipeline creation.
    # @param [Ci::Bridge] bridge                              The bridge job that triggers the downstream pipeline creation.
    # @param [String] content                                 The content of .gitlab-ci.yml to override the default config
    #                                                         contents (e.g. .gitlab-ci.yml in repostiry). Mainly used for
    #                                                         generating a dangling pipeline.
    #
    # @return [Ci::Pipeline]                                  The created Ci::Pipeline object.
    # rubocop: disable Metrics/ParameterLists
    def execute(source, ignore_skip_ci: false, save_on_errors: true, trigger_request: nil, schedule: nil, merge_request: nil, external_pull_request: nil, bridge: nil, **options, &block)
      @logger = build_logger
      @pipeline = Ci::Pipeline.new

      command = Gitlab::Ci::Pipeline::Chain::Command.new(
        source: source,
        origin_ref: params[:ref],
        checkout_sha: params[:checkout_sha],
        after_sha: params[:after],
        before_sha: params[:before],          # The base SHA of the source branch (i.e merge_request.diff_base_sha).
        source_sha: params[:source_sha],      # The HEAD SHA of the source branch (i.e merge_request.diff_head_sha).
        target_sha: params[:target_sha],      # The HEAD SHA of the target branch.
        trigger_request: trigger_request,
        schedule: schedule,
        merge_request: merge_request,
        external_pull_request: external_pull_request,
        ignore_skip_ci: ignore_skip_ci,
        save_incompleted: save_on_errors,
        seeds_block: block,
        variables_attributes: params[:variables_attributes],
        project: project,
        current_user: current_user,
        push_options: params[:push_options] || {},
        chat_data: params[:chat_data],
        bridge: bridge,
        logger: @logger,
        **extra_options(**options))

      # Ensure we never persist the pipeline when dry_run: true
      @pipeline.readonly! if command.dry_run?

      Gitlab::Ci::Pipeline::Chain::Sequence
        .new(pipeline, command, SEQUENCE)
        .build!

      if pipeline.persisted?
        Gitlab::EventStore.publish(
          Ci::PipelineCreatedEvent.new(data: { pipeline_id: pipeline.id })
        )

        create_namespace_onboarding_action
      else
        # If pipeline is not persisted, try to recover IID
        pipeline.reset_project_iid
      end

      if error_message = pipeline.full_error_messages.presence || pipeline.failure_reason.presence
        ServiceResponse.error(message: error_message, payload: pipeline)
      else
        ServiceResponse.success(payload: pipeline)
      end

    ensure
      @logger.commit(pipeline: pipeline, caller: self.class.name)
    end
    # rubocop: enable Metrics/ParameterLists

    private

    def commit
      @commit ||= project.commit(origin_sha || origin_ref)
    end

    def sha
      commit.try(:id)
    end

    def create_namespace_onboarding_action
      Onboarding::PipelineCreatedWorker.perform_async(project.namespace_id)
    end

    def extra_options(content: nil, dry_run: false)
      { content: content, dry_run: dry_run }
    end

    def build_logger
      Gitlab::Ci::Pipeline::Logger.new(project: project) do |l|
        l.log_when do |observations|
          observations.any? do |name, observation|
            name.to_s.end_with?('duration_s') &&
              Array(observation).max >= LOG_MAX_DURATION_THRESHOLD
          end
        end

        l.log_when do |observations|
          count = observations['pipeline_size_count']
          next false unless count

          count >= LOG_MAX_PIPELINE_SIZE
        end

        l.log_when do |observations|
          duration = observations['pipeline_creation_duration_s']
          next false unless duration

          duration >= LOG_MAX_CREATION_THRESHOLD
        end
      end
    end
  end
end

Ci::CreatePipelineService.prepend_mod_with('Ci::CreatePipelineService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::CreatePipelineService, :yaml_processor_feature_flag_corectness, :clean_gitlab_redis_cache, feature_category: :continuous_integration do
  include ProjectForksHelper

  let_it_be_with_refind(:project) { create(:project, :repository) }
  let_it_be_with_reload(:user) { project.first_owner }

  let(:ref_name) { 'refs/heads/master' }

  before do
    stub_ci_pipeline_to_return_yaml_file
  end

  describe '#execute' do
    # rubocop:disable Metrics/ParameterLists
    def execute_service(
      source: :push,
      before: '00000000',
      after: project.commit.id,
      ref: ref_name,
      trigger_request: nil,
      variables_attributes: nil,
      merge_request: nil,
      external_pull_request: nil,
      push_options: nil,
      source_sha: nil,
      target_sha: nil,
      save_on_errors: true)
      params = { ref: ref,
                 before: before,
                 after: after,
                 variables_attributes: variables_attributes,
                 push_options: push_options,
                 source_sha: source_sha,
                 target_sha: target_sha }

      described_class.new(project, user, params).execute(source,
        save_on_errors: save_on_errors,
        trigger_request: trigger_request,
        merge_request: merge_request,
        external_pull_request: external_pull_request) do |pipeline|
        yield(pipeline) if block_given?
      end
    end
    # rubocop:enable Metrics/ParameterLists

    context 'performance' do
      it_behaves_like 'pipelines are created without N+1 SQL queries' do
        let(:config1) do
          <<~YAML
          job1:
            stage: build
            script: exit 0

          job2:
            stage: test
            script: exit 0
          YAML
        end

        let(:config2) do
          <<~YAML
          job1:
            stage: build
            script: exit 0

          job2:
            stage: test
            script: exit 0

          job3:
            stage: deploy
            script: exit 0
          YAML
        end

        let(:accepted_n_plus_ones) do
          1 + # SELECT ""ci_instance_variables""
            1 + # INSERT INTO ""ci_stages""
            1 + # SELECT ""ci_builds"".* FROM ""ci_builds""
            1 + # INSERT INTO ""ci_builds""
            1 + # INSERT INTO ""ci_builds_metadata""
            1   # SELECT ""taggings"".* FROM ""taggings""
        end
      end
    end

    context 'valid params' do
      let(:pipeline) { execute_service.payload }

      let(:pipeline_on_previous_commit) do
        execute_service(
          after: previous_commit_sha_from_ref('master')
        ).payload
      end

      it 'responds with success' do
        expect(execute_service).to be_success
      end

      it 'creates a pipeline' do
        expect(pipeline).to be_kind_of(Ci::Pipeline)
        expect(pipeline).to be_valid
        expect(pipeline).to be_persisted
        expect(pipeline).to be_push
        expect(pipeline).to eq(project.ci_pipelines.last)
        expect(pipeline).to have_attributes(user: user)
        expect(pipeline).to have_attributes(status: 'created')
        expect(pipeline.iid).not_to be_nil
        expect(pipeline.repository_source?).to be true
        expect(pipeline.builds.first).to be_kind_of(Ci::Build)
        expect(pipeline.yaml_errors).not_to be_present
      end

      it 'increments the prometheus counter' do
        counter = spy('pipeline created counter')

        allow(Gitlab::Ci::Pipeline::Metrics)
          .to receive(:pipelines_created_counter).and_return(counter)

        pipeline

        expect(counter).to have_received(:increment)
      end

      it 'records pipeline size in a prometheus histogram' do
        histogram = spy('pipeline size histogram')

        allow(Gitlab::Ci::Pipeline::Metrics)
          .to receive(:pipeline_size_histogram).and_return(histogram)

        execute_service

        expect(histogram).to have_received(:observe)
          .with({ source: 'push', plan: project.actual_plan_name }, 5)
      end

      it 'tracks included template usage' do
        expect_next_instance_of(Gitlab::Ci::Pipeline::Chain::TemplateUsage) do |instance|
          expect(instance).to receive(:perform!)
        end

        execute_service
      end

      context 'when merge requests already exist for this source branch' do
        let!(:merge_request_1) do
          create(:merge_request, source_branch: 'feature', target_branch: ""master"", source_project: project)
        end

        let!(:merge_request_2) do
          create(:merge_request, source_branch: 'feature', target_branch: ""v1.1.0"", source_project: project)
        end

        context 'when the head pipeline sha equals merge request sha' do
          it 'updates head pipeline of each merge request', :sidekiq_might_not_need_inline do
            head_pipeline = execute_service(ref: 'feature', after: nil).payload

            expect(merge_request_1.reload.head_pipeline).to eq(head_pipeline)
            expect(merge_request_2.reload.head_pipeline).to eq(head_pipeline)
          end
        end
      end

      context 'auto-cancel enabled' do
        before do
          project.update!(auto_cancel_pending_pipelines: 'enabled')
        end

        it 'does not cancel HEAD pipeline' do
          pipeline
          pipeline_on_previous_commit

          expect(pipeline.reload).to have_attributes(status: 'created', auto_canceled_by_id: nil)
        end

        it 'auto cancel pending non-HEAD pipelines', :sidekiq_might_not_need_inline do
          pipeline_on_previous_commit
          pipeline

          expect(pipeline_on_previous_commit.reload).to have_attributes(status: 'canceled', auto_canceled_by_id: pipeline.id)
        end

        it 'cancels running outdated pipelines', :sidekiq_inline do
          pipeline_on_previous_commit.reload.run
          head_pipeline = execute_service.payload

          expect(pipeline_on_previous_commit.reload).to have_attributes(status: 'canceled', auto_canceled_by_id: head_pipeline.id)
        end

        it 'cancel created outdated pipelines', :sidekiq_might_not_need_inline do
          pipeline_on_previous_commit.update!(status: 'created')
          pipeline

          expect(pipeline_on_previous_commit.reload).to have_attributes(status: 'canceled', auto_canceled_by_id: pipeline.id)
        end

        it 'does not cancel pipelines from the other branches' do
          new_pipeline = execute_service(
            ref: 'refs/heads/feature',
            after: previous_commit_sha_from_ref('feature')
          ).payload

          pipeline

          expect(new_pipeline.reload).to have_attributes(status: 'created', auto_canceled_by_id: nil)
        end

        context 'when the interruptible attribute is' do
          context 'not defined' do
            before do
              config = YAML.dump(rspec: { script: 'echo' })
              stub_ci_pipeline_yaml_file(config)
            end

            it 'is cancelable' do
              pipeline = execute_service.payload

              expect(pipeline.builds.find_by(name: 'rspec').interruptible).to be_nil
            end
          end

          context 'set to true' do
            before do
              config = YAML.dump(rspec: { script: 'echo', interruptible: true })
              stub_ci_pipeline_yaml_file(config)
            end

            it 'is cancelable' do
              pipeline = execute_service.payload

              expect(pipeline.builds.find_by(name: 'rspec').interruptible).to be_truthy
            end
          end

          context 'set to false' do
            before do
              config = YAML.dump(rspec: { script: 'echo', interruptible: false })
              stub_ci_pipeline_yaml_file(config)
            end

            it 'is not cancelable' do
              pipeline = execute_service.payload

              expect(pipeline.builds.find_by(name: 'rspec').interruptible).to be_falsy
            end
          end
        end

        context 'interruptible builds' do
          before do
            stub_ci_pipeline_yaml_file(YAML.dump(config))
          end

          let(:config) do
            {
              stages: %w[stage1 stage2 stage3 stage4],

              build_1_1: {
                stage: 'stage1',
                script: 'echo',
                interruptible: true
              },
              build_1_2: {
                stage: 'stage1',
                script: 'echo',
                interruptible: true
              },
              build_2_1: {
                stage: 'stage2',
                script: 'echo',
                when: 'delayed',
                start_in: '10 minutes',
                interruptible: true
              },
              build_3_1: {
                stage: 'stage3',
                script: 'echo',
                interruptible: false
              },
              build_4_1: {
                stage: 'stage4',
                script: 'echo'
              }
            }
          end

          it 'properly configures interruptible status' do
            interruptible_status =
              pipeline_on_previous_commit
                .builds
                .joins(:metadata)
                .pluck(:name, ""#{Ci::BuildMetadata.quoted_table_name}.interruptible"")

            expect(interruptible_status).to contain_exactly(
              ['build_1_1', true],
              ['build_1_2', true],
              ['build_2_1', true],
              ['build_3_1', false],
              ['build_4_1', nil]
            )
          end

          context 'when only interruptible builds are running' do
            context 'when build marked explicitly by interruptible is running' do
              it 'cancels running outdated pipelines', :sidekiq_might_not_need_inline do
                pipeline_on_previous_commit
                  .builds
                  .find_by_name('build_1_2')
                  .run!

                pipeline

                expect(pipeline_on_previous_commit.reload).to have_attributes(
                  status: 'canceled', auto_canceled_by_id: pipeline.id)
              end
            end

            context 'when build that is not marked as interruptible is running' do
              it 'cancels running outdated pipelines', :sidekiq_might_not_need_inline do
                build_2_1 = pipeline_on_previous_commit
                  .builds.find_by_name('build_2_1')

                build_2_1.enqueue!
                build_2_1.reset.run!

                pipeline

                expect(pipeline_on_previous_commit.reload).to have_attributes(
                  status: 'canceled', auto_canceled_by_id: pipeline.id)
              end
            end
          end

          context 'when an uninterruptible build is running' do
            it 'does not cancel running outdated pipelines', :sidekiq_inline do
              build_3_1 = pipeline_on_previous_commit
                .builds.find_by_name('build_3_1')

              build_3_1.enqueue!
              build_3_1.reset.run!

              pipeline

              expect(pipeline_on_previous_commit.reload).to have_attributes(
                status: 'running', auto_canceled_by_id: nil)
            end
          end

          context 'when an build is waiting on an interruptible scheduled task' do
            it 'cancels running outdated pipelines', :sidekiq_might_not_need_inline do
              allow(Ci::BuildScheduleWorker).to receive(:perform_at)

              pipeline_on_previous_commit
                .builds
                .find_by_name('build_2_1')
                .schedule!

              pipeline

              expect(pipeline_on_previous_commit.reload).to have_attributes(
                status: 'canceled', auto_canceled_by_id: pipeline.id)
            end
          end

          context 'when a uninterruptible build has finished' do
            it 'does not cancel running outdated pipelines', :sidekiq_might_not_need_inline do
              pipeline_on_previous_commit
                .builds
                .find_by_name('build_3_1')
                .success!

              pipeline

              expect(pipeline_on_previous_commit.reload).to have_attributes(
                status: 'running', auto_canceled_by_id: nil)
            end
          end
        end
      end

      context 'auto-cancel disabled' do
        before do
          project.update!(auto_cancel_pending_pipelines: 'disabled')
        end

        it 'does not auto cancel created non-HEAD pipelines' do
          pipeline_on_previous_commit
          pipeline

          expect(pipeline_on_previous_commit.reload)
            .to have_attributes(status: 'created', auto_canceled_by_id: nil)
        end
      end

      def previous_commit_sha_from_ref(ref)
        project.commit(ref).parent.sha
      end
    end

    context ""skip tag if there is no build for it"" do
      it ""creates commit if there is appropriate job"" do
        expect(execute_service.payload).to be_persisted
      end

      it ""creates commit if there is no appropriate job but deploy job has right ref setting"" do
        config = YAML.dump({ deploy: { script: ""ls"", only: [""master""] } })
        stub_ci_pipeline_yaml_file(config)

        expect(execute_service.payload).to be_persisted
      end
    end

    it 'skips creating pipeline for refs without .gitlab-ci.yml', :aggregate_failures do
      stub_ci_pipeline_yaml_file(nil)

      response = execute_service

      expect(response).to be_error
      expect(response.message).to eq('Missing CI config file')
      expect(response.payload).not_to be_persisted
      expect(Ci::Pipeline.count).to eq(0)
      expect(Onboarding::PipelineCreatedWorker).not_to receive(:perform_async)
    end

    shared_examples 'a failed pipeline' do
      it 'creates failed pipeline' do
        stub_ci_pipeline_yaml_file(ci_yaml)

        pipeline = execute_service.payload

        expect(pipeline).to be_persisted
        expect(pipeline.builds.any?).to be false
        expect(pipeline.status).to eq('failed')
        expect(pipeline.yaml_errors).not_to be_nil
      end
    end

    context 'config evaluation' do
      context 'when config is in a file in repository' do
        before do
          content = YAML.dump(rspec: { script: 'echo' })
          stub_ci_pipeline_yaml_file(content)
        end

        it 'pull it from the repository' do
          pipeline = execute_service.payload
          expect(pipeline).to be_repository_source
          expect(pipeline.builds.map(&:name)).to eq ['rspec']
        end
      end

      context 'when config is from Auto-DevOps' do
        before do
          stub_ci_pipeline_yaml_file(nil)
          allow_any_instance_of(Project).to receive(:auto_devops_enabled?).and_return(true)
          create(:project_auto_devops, project: project)
        end

        it 'pull it from Auto-DevOps' do
          pipeline = execute_service.payload
          expect(pipeline).to be_auto_devops_source
          expect(pipeline.builds.map(&:name)).to match_array(%w[brakeman-sast build code_quality container_scanning secret_detection semgrep-sast test])
        end
      end

      context 'when config is not found' do
        before do
          stub_ci_pipeline_yaml_file(nil)
        end

        it 'responds with error message', :aggregate_failures do
          response = execute_service

          expect(response).to be_error
          expect(response.message).to eq('Missing CI config file')
          expect(response.payload).not_to be_persisted
        end
      end

      context 'when an unexpected error is raised' do
        before do
          expect(Gitlab::Ci::YamlProcessor).to receive(:new)
            .and_raise(RuntimeError, 'undefined failure')
        end

        it 'saves error in pipeline' do
          pipeline = execute_service.payload

          expect(pipeline.yaml_errors).to include('Undefined error')
        end

        it 'logs error' do
          expect(Gitlab::ErrorTracking).to receive(:track_exception).and_call_original

          execute_service
        end
      end
    end

    context 'when yaml is invalid' do
      let(:ci_yaml) { 'invalid: file: fiile' }
      let(:message) { 'Message' }

      it_behaves_like 'a failed pipeline'

      it 'increments the error metric' do
        stub_ci_pipeline_yaml_file(ci_yaml)

        counter = Gitlab::Metrics.counter(:gitlab_ci_pipeline_failure_reasons, 'desc')
        expect { execute_service }.to change { counter.get(reason: 'config_error') }.by(1)
      end

      context 'when receive git commit' do
        before do
          allow_any_instance_of(Ci::Pipeline).to receive(:git_commit_message) { message }
        end

        it_behaves_like 'a failed pipeline'
      end

      context 'when config has ports' do
        context 'in the main image' do
          let(:ci_yaml) do
            <<-EOS
              image:
                name: image:1.0
                ports:
                  - 80
            EOS
          end

          it_behaves_like 'a failed pipeline'
        end

        context 'in the job image' do
          let(:ci_yaml) do
            <<-EOS
              image: image:1.0

              test:
                script: rspec
                image:
                  name: image:1.0
                  ports:
                    - 80
            EOS
          end

          it_behaves_like 'a failed pipeline'
        end

        context 'in the service' do
          let(:ci_yaml) do
            <<-EOS
              image: image:1.0

              test:
                script: rspec
                image: image:1.0
                services:
                  - name: test
                    ports:
                      - 80
            EOS
          end

          it_behaves_like 'a failed pipeline'
        end
      end
    end

    context 'when an unexpected error is raised' do
      before do
        expect(Gitlab::Ci::YamlProcessor).to receive(:new)
          .and_raise(RuntimeError, 'undefined failure')
      end

      it 'saves error in pipeline' do
        pipeline = execute_service.payload

        expect(pipeline.yaml_errors).to include('Undefined error')
      end

      it 'logs error' do
        expect(Gitlab::ErrorTracking).to receive(:track_exception).and_call_original

        execute_service
      end
    end

    context 'when commit contains a [ci skip] directive' do
      shared_examples 'creating a pipeline' do
        it 'does not skip pipeline creation' do
          pipeline = execute_service.payload

          expect(pipeline).to be_persisted
          expect(pipeline.builds.first.name).to eq(""rspec"")
        end
      end

      shared_examples 'skipping a pipeline' do
        it 'skips pipeline creation' do
          pipeline = execute_service.payload

          expect(pipeline).to be_persisted
          expect(pipeline.builds.any?).to be false
          expect(pipeline.status).to eq(""skipped"")
        end
      end

      before do
        allow_any_instance_of(Ci::Pipeline).to receive(:git_commit_message) { commit_message }
      end

      skip_commit_messages = [
        ""some message[ci skip]"",
        ""some message[skip ci]"",
        ""some message[CI SKIP]"",
        ""some message[SKIP CI]"",
        ""some message[ci_skip]"",
        ""some message[skip_ci]"",
        ""some message[ci-skip]"",
        ""some message[skip-ci]""
      ]

      skip_commit_messages.each do |skip_commit_message|
        context ""when the commit message is #{skip_commit_message}"" do
          let(:commit_message) { skip_commit_message }

          it_behaves_like 'skipping a pipeline'
        end
      end

      context 'when commit message does not contain [ci skip] nor [skip ci]' do
        let(:commit_message) { 'some message' }

        it_behaves_like 'creating a pipeline'
      end

      context 'when commit message is nil' do
        let(:commit_message) { nil }

        it_behaves_like 'creating a pipeline'
      end

      context 'when there is [ci skip] tag in commit message and yaml is invalid' do
        let(:commit_message) { 'some message [ci skip]' }
        let(:ci_yaml) { 'invalid: file: fiile' }

        before do
          stub_ci_pipeline_yaml_file(ci_yaml)
        end

        it_behaves_like 'skipping a pipeline'
      end
    end

    context 'when push options contain ci.skip' do
      let(:push_options) do
        { 'ci' => { 'skip' => true } }
      end

      it 'creates a pipline in the skipped state' do
        pipeline = execute_service(push_options: push_options).payload

        # TODO: DRY these up with ""skips builds creation if the commit message""
        expect(pipeline).to be_persisted
        expect(pipeline.builds.any?).to be false
        expect(pipeline.status).to eq(""skipped"")
      end
    end

    context 'when there are no jobs for this pipeline' do
      before do
        config = YAML.dump({ test: { script: 'ls', only: ['feature'] } })
        stub_ci_pipeline_yaml_file(config)
      end

      it 'does not create a new pipeline', :aggregate_failures do
        result = execute_service

        expect(result).to be_error
        expect(result.message).to eq('Pipeline will not run for the selected trigger. ' \
          'The rules configuration prevented any jobs from being added to the pipeline.')
        expect(result.payload).not_to be_persisted
        expect(Ci::Build.all).to be_empty
        expect(Ci::Pipeline.count).to eq(0)
      end

      describe '#iid' do
        let(:internal_id) do
          InternalId.find_by(project_id: project.id, usage: :ci_pipelines)
        end

        before do
          expect_any_instance_of(Ci::Pipeline).to receive(:ensure_project_iid!)
            .and_call_original
        end

        it 'rewinds iid', :aggregate_failures do
          result = execute_service

          expect(result).to be_error
          expect(result.payload).not_to be_persisted
          expect(internal_id.last_value).to eq(0)
        end
      end
    end

    context 'when the configuration includes ID tokens' do
      it 'creates variables for the ID tokens' do
        config = YAML.dump({
          job_with_id_tokens: {
            script: 'ls',
            id_tokens: {
              'TEST_ID_TOKEN' => {
                aud: 'https://gitlab.com'
              }
            }
          }
        })
        stub_ci_pipeline_yaml_file(config)

        result = execute_service.payload

        expect(result).to be_persisted
        expect(result.builds.first.id_tokens).to eq({
          'TEST_ID_TOKEN' => { 'aud' => 'https://gitlab.com' }
        })
      end
    end

    context 'with manual actions' do
      before do
        config = YAML.dump({ deploy: { script: 'ls', when: 'manual' } })
        stub_ci_pipeline_yaml_file(config)
      end

      it 'does not create a new pipeline', :sidekiq_inline do
        result = execute_service.payload

        expect(result).to be_persisted
        expect(result.manual_actions).not_to be_empty
      end
    end

    context 'when builds with auto-retries are configured' do
      let(:pipeline)  { execute_service.payload }
      let(:rspec_job) { pipeline.builds.find_by(name: 'rspec') }

      before do
        stub_ci_pipeline_yaml_file(YAML.dump({
          rspec: { script: 'rspec', retry: retry_value }
        }))
        rspec_job.update!(options: { retry: retry_value })
      end

      context 'as an integer' do
        let(:retry_value) { 2 }

        it 'correctly creates builds with auto-retry value configured' do
          expect(pipeline).to be_persisted
        end
      end

      context 'as hash' do
        let(:retry_value) { { max: 2, when: 'runner_system_failure' } }

        it 'correctly creates builds with auto-retry value configured' do
          expect(pipeline).to be_persisted
        end
      end
    end

    context 'with resource group' do
      context 'when resource group is defined' do
        before do
          config = YAML.dump(
            test: { stage: 'test', script: 'ls', resource_group: resource_group_key }
          )

          stub_ci_pipeline_yaml_file(config)
        end

        let(:resource_group_key) { 'iOS' }

        it 'persists the association correctly' do
          result = execute_service.payload
          deploy_job = result.builds.find_by_name!(:test)
          resource_group = project.resource_groups.find_by_key!(resource_group_key)

          expect(result).to be_persisted
          expect(deploy_job.resource_group.key).to eq(resource_group_key)
          expect(project.resource_groups.count).to eq(1)
          expect(resource_group.processables.count).to eq(1)
          expect(resource_group.resources.count).to eq(1)
          expect(resource_group.resources.first.processable).to eq(nil)
        end

        context 'when resource group key includes predefined variables' do
          let(:resource_group_key) { '$CI_COMMIT_REF_NAME-$CI_JOB_NAME' }

          it 'interpolates the variables into the key correctly' do
            result = execute_service.payload

            expect(result).to be_persisted
            expect(project.resource_groups.exists?(key: 'master-test')).to eq(true)
          end
        end
      end
    end

    context 'when resource group is defined for review app deployment' do
      before do
        config = YAML.dump(
          review_app: {
            stage: 'test',
            script: 'deploy',
            environment: {
              name: 'review/$CI_COMMIT_REF_SLUG',
              on_stop: 'stop_review_app'
            },
            resource_group: '$CI_ENVIRONMENT_NAME'
          },
          stop_review_app: {
            stage: 'test',
            script: 'stop',
            when: 'manual',
            environment: {
              name: 'review/$CI_COMMIT_REF_SLUG',
              action: 'stop'
            },
            resource_group: '$CI_ENVIRONMENT_NAME'
          }
        )

        stub_ci_pipeline_yaml_file(config)
      end

      it 'persists the association correctly' do
        result = execute_service.payload
        deploy_job = result.builds.find_by_name!(:review_app)
        stop_job = result.builds.find_by_name!(:stop_review_app)

        expect(result).to be_persisted
        expect(deploy_job.resource_group.key).to eq('review/master')
        expect(stop_job.resource_group.key).to eq('review/master')
        expect(project.resource_groups.count).to eq(1)
      end

      it 'initializes scoped variables only once for each build' do
        # Bypassing `stub_build` hack because it distrubs the expectations below.
        allow_next_instances_of(Gitlab::Ci::Build::Context::Build, 2) do |build_context|
          allow(build_context).to receive(:variables) { Gitlab::Ci::Variables::Collection.new }
        end

        expect_next_instances_of(::Ci::Build, 2) do |ci_build|
          expect(ci_build).to receive(:scoped_variables).once.and_call_original
        end

        expect(execute_service.payload).to be_created_successfully
      end
    end

    context 'with timeout' do
      context 'when builds with custom timeouts are configured' do
        before do
          config = YAML.dump(rspec: { script: 'rspec', timeout: '2m 3s' })
          stub_ci_pipeline_yaml_file(config)
        end

        it 'correctly creates builds with custom timeout value configured' do
          pipeline = execute_service.payload

          expect(pipeline).to be_persisted
          expect(pipeline.builds.find_by(name: 'rspec').options[:job_timeout]).to eq 123
        end
      end
    end

    context 'with release' do
      shared_examples_for 'a successful release pipeline' do
        before do
          stub_ci_pipeline_yaml_file(YAML.dump(config))
        end

        it 'is valid config' do
          pipeline = execute_service.payload
          build = pipeline.builds.first
          expect(pipeline).to be_kind_of(Ci::Pipeline)
          expect(pipeline).to be_valid
          expect(pipeline.yaml_errors).not_to be_present
          expect(pipeline).to be_persisted
          expect(build).to be_kind_of(Ci::Build)
          expect(build.options).to eq(config[:release].except(:stage, :only))
          expect(build).to be_persisted
        end
      end

      context 'simple example' do
        it_behaves_like 'a successful release pipeline' do
          let(:config) do
            {
              release: {
                script: [""make changelog | tee release_changelog.txt""],
                release: {
                  tag_name: ""v0.06"",
                  description: ""./release_changelog.txt""
                }
              }
            }
          end
        end
      end

      context 'example with all release metadata' do
        it_behaves_like 'a successful release pipeline' do
          let(:config) do
            {
              release: {
                script: [""make changelog | tee release_changelog.txt""],
                release: {
                  name: ""Release $CI_TAG_NAME"",
                  tag_name: ""v0.06"",
                  description: ""./release_changelog.txt"",
                  assets: {
                    links: [
                      {
                        name: ""cool-app.zip"",
                        url: ""http://my.awesome.download.site/1.0-$CI_COMMIT_SHORT_SHA.zip""
                      },
                      {
                        url: ""http://my.awesome.download.site/1.0-$CI_COMMIT_SHORT_SHA.exe""
                      }
                    ]
                  }
                }
              }
            }
          end
        end
      end
    end

    shared_examples 'when ref is protected' do
      let(:user) { create(:user) }

      context 'when user is developer' do
        before do
          project.add_developer(user)
        end

        it 'does not create a pipeline', :aggregate_failures do
          expect(execute_service.payload).not_to be_persisted
          expect(Ci::Pipeline.count).to eq(0)
        end
      end

      context 'when user is maintainer' do
        let(:pipeline) { execute_service.payload }

        before do
          project.add_maintainer(user)
        end

        it 'creates a protected pipeline' do
          expect(pipeline).to be_persisted
          expect(pipeline).to be_protected
          expect(Ci::Pipeline.count).to eq(1)
        end
      end

      context 'when trigger belongs to no one' do
        let(:user) {}
        let(:trigger_request) { create(:ci_trigger_request) }

        it 'does not create a pipeline', :aggregate_failures do
          response = execute_service(trigger_request: trigger_request)

          expect(response).to be_error
          expect(response.payload).not_to be_persisted
          expect(Ci::Pipeline.count).to eq(0)
        end
      end

      context 'when trigger belongs to a developer' do
        let(:user) { create(:user) }
        let(:trigger) { create(:ci_trigger, owner: user) }
        let(:trigger_request) { create(:ci_trigger_request, trigger: trigger) }

        before do
          project.add_developer(user)
        end

        it 'does not create a pipeline', :aggregate_failures do
          response = execute_service(trigger_request: trigger_request)

          expect(response).to be_error
          expect(response.payload).not_to be_persisted
          expect(Ci::Pipeline.count).to eq(0)
        end
      end

      context 'when trigger belongs to a maintainer' do
        let(:user) { create(:user) }
        let(:trigger) { create(:ci_trigger, owner: user) }
        let(:trigger_request) { create(:ci_trigger_request, trigger: trigger) }

        before do
          project.add_maintainer(user)
        end

        it 'creates a pipeline' do
          expect(execute_service(trigger_request: trigger_request).payload)
            .to be_persisted
          expect(Ci::Pipeline.count).to eq(1)
        end
      end
    end

    context 'when ref is a protected branch' do
      before do
        create(:protected_branch, project: project, name: 'master')
      end

      it_behaves_like 'when ref is protected'
    end

    context 'when ref is a protected tag' do
      let(:ref_name) { 'refs/tags/v1.0.0' }

      before do
        create(:protected_tag, project: project, name: '*')
      end

      it_behaves_like 'when ref is protected'
    end

    context 'when pipeline is running for a tag' do
      before do
        config = YAML.dump(
          test: { script: 'test', only: ['branches'] },
          deploy: { script: 'deploy', only: ['tags'] }
        )

        stub_ci_pipeline_yaml_file(config)
      end

      it 'creates a tagged pipeline' do
        pipeline = execute_service(ref: 'v1.0.0').payload

        expect(pipeline.tag?).to be true
      end
    end

    context 'when pipeline is running for a nonexistant-branch' do
      let(:gitlab_ci_yaml) { YAML.dump(test: { script: 'test' }) }

      let(:ref_name) { 'refs/heads/nonexistant-branch' }

      let(:pipeline) { execute_service.payload }

      it 'does not create the pipeline' do
        expect(pipeline).not_to be_created_successfully
        expect(pipeline.errors[:base]).to eq(['Reference not found'])
      end

      context 'when there is a tag with that nonexistant-branch' do
        # v1.0.0 is on the test repo as a tag
        let(:ref_name) { 'refs/heads/v1.0.0' }

        it 'does not create the pipeline' do
          expect(pipeline).not_to be_created_successfully
          expect(pipeline.errors[:base]).to eq(['Reference not found'])
        end
      end
    end

    context 'when pipeline is running for a branch with the name of both a branch and a tag' do
      let(:gitlab_ci_yaml) { YAML.dump(test: { script: 'test' }) }

      # v1.1.0 is on the test repo as branch and tag
      let(:ref_name) { 'refs/heads/v1.1.0' }

      let(:pipeline) { execute_service.payload }

      it 'creates the pipeline for the branch' do
        expect(pipeline).to be_created_successfully
        expect(pipeline.branch?).to be true
        expect(pipeline.tag?).to be false
      end
    end

    context 'when pipeline is running for a tag with the name of both a branch and a tag' do
      let(:gitlab_ci_yaml) { YAML.dump(test: { script: 'test' }) }

      # v1.1.0 is on the test repo as branch and tag
      let(:ref_name) { 'refs/tags/v1.1.0' }

      let(:pipeline) { execute_service.payload }

      it 'creates the pipeline for the tag' do
        expect(pipeline).to be_created_successfully
        expect(pipeline.branch?).to be false
        expect(pipeline.tag?).to be true
      end
    end

    context 'when pipeline is running for an ambiguous ref' do
      let(:gitlab_ci_yaml) { YAML.dump(test: { script: 'test' }) }

      # v1.1.0 is on the test repo as branch and tag
      let(:ref_name) { 'v1.1.0' }

      let(:pipeline) { execute_service.payload }

      it 'does not create the pipeline' do
        expect(pipeline).not_to be_created_successfully
        expect(pipeline.errors[:base]).to eq(['Ref is ambiguous'])
      end
    end

    context 'when pipeline variables are specified' do
      subject(:pipeline) { execute_service(variables_attributes: variables_attributes).payload }

      context 'with valid pipeline variables' do
        let(:variables_attributes) do
          [{ key: 'first', secret_value: 'world' },
           { key: 'second', secret_value: 'second_world' }]
        end

        it 'creates a pipeline with specified variables' do
          expect(pipeline.variables.map { |var| var.slice(:key, :secret_value) })
            .to eq variables_attributes.map(&:with_indifferent_access)
        end
      end

      context 'with duplicate pipeline variables' do
        let(:variables_attributes) do
          [{ key: 'hello', secret_value: 'world' },
           { key: 'hello', secret_value: 'second_world' }]
        end

        it 'fails to create the pipeline' do
          expect(pipeline).to be_failed
          expect(pipeline.variables).to be_empty
          expect(pipeline.errors[:base]).to eq(['Duplicate variable name: hello'])
        end
      end

      context 'with more than one duplicate pipeline variable' do
        let(:variables_attributes) do
          [{ key: 'hello', secret_value: 'world' },
           { key: 'hello', secret_value: 'second_world' },
           { key: 'single', secret_value: 'variable' },
           { key: 'other', secret_value: 'value' },
           { key: 'other', secret_value: 'other value' }]
        end

        it 'fails to create the pipeline' do
          expect(pipeline).to be_failed
          expect(pipeline.variables).to be_empty
          expect(pipeline.errors[:base]).to eq(['Duplicate variable names: hello, other'])
        end
      end
    end

    describe 'Pipeline for external pull requests' do
      let(:response) do
        execute_service(
          source: source,
          external_pull_request: pull_request,
          ref: ref_name,
          source_sha: source_sha,
          target_sha: target_sha
        )
      end

      let(:pipeline) { response.payload }

      before do
        stub_ci_pipeline_yaml_file(YAML.dump(config))
      end

      let(:ref_name) { 'refs/heads/feature' }
      let(:source_sha) { project.commit(ref_name).id }
      let(:target_sha) { nil }

      context 'when source is external pull request' do
        let(:source) { :external_pull_request_event }

        context 'when config has external_pull_requests keywords' do
          let(:config) do
            {
              build: {
                stage: 'build',
                script: 'echo'
              },
              test: {
                stage: 'test',
                script: 'echo',
                only: ['external_pull_requests']
              },
              pages: {
                stage: 'deploy',
                script: 'echo',
                except: ['external_pull_requests']
              }
            }
          end

          context 'when external pull request is specified' do
            let(:pull_request) { create(:external_pull_request, project: project, source_branch: 'feature', target_branch: 'master') }
            let(:ref_name) { pull_request.source_ref }

            it 'creates an external pull request pipeline' do
              expect(pipeline).to be_persisted
              expect(pipeline).to be_external_pull_request_event
              expect(pipeline.external_pull_request).to eq(pull_request)
              expect(pipeline.source_sha).to eq(source_sha)
              expect(pipeline.builds.order(:stage_id)
                .map(&:name))
                .to eq(%w[build test])
            end

            context 'when ref is tag' do
              let(:ref_name) { 'refs/tags/v1.1.0' }

              it 'does not create an extrnal pull request pipeline', :aggregate_failures do
                expect(response).to be_error
                expect(response.message).to eq('Tag is not included in the list and Failed to build the pipeline!')
                expect(pipeline).not_to be_persisted
                expect(pipeline.errors[:tag]).to eq(['is not included in the list'])
              end
            end

            context 'when pull request is created from fork' do
              it 'does not create an external pull request pipeline'
            end

            context ""when there are no matched jobs"" do
              let(:config) do
                {
                  test: {
                    stage: 'test',
                    script: 'echo',
                    except: ['external_pull_requests']
                  }
                }
              end

              it 'does not create a detached merge request pipeline', :aggregate_failures do
                expect(response).to be_error
                expect(response.message).to eq('Pipeline will not run for the selected trigger. ' \
                  'The rules configuration prevented any jobs from being added to the pipeline.')
                expect(pipeline).not_to be_persisted
                expect(pipeline.errors[:base]).to eq(['Pipeline will not run for the selected trigger. ' \
                  'The rules configuration prevented any jobs from being added to the pipeline.'])
              end
            end
          end

          context 'when external pull request is not specified' do
            let(:pull_request) { nil }

            it 'does not create an external pull request pipeline', :aggregate_failures do
              expect(response).to be_error
              expect(response.message).to eq(""External pull request can't be blank and Failed to build the pipeline!"")
              expect(pipeline).not_to be_persisted
              expect(pipeline.errors[:external_pull_request]).to eq([""can't be blank""])
            end
          end
        end

        context ""when config does not have external_pull_requests keywords"" do
          let(:config) do
            {
              build: {
                stage: 'build',
                script: 'echo'
              },
              test: {
                stage: 'test',
                script: 'echo'
              },
              pages: {
                stage: 'deploy',
                script: 'echo'
              }
            }
          end

          context 'when external pull request is specified' do
            let(:pull_request) do
              create(:external_pull_request,
                project: project,
                source_branch: Gitlab::Git.ref_name(ref_name),
                target_branch: 'master')
            end

            it 'creates an external pull request pipeline' do
              expect(pipeline).to be_persisted
              expect(pipeline).to be_external_pull_request_event
              expect(pipeline.external_pull_request).to eq(pull_request)
              expect(pipeline.source_sha).to eq(source_sha)
              expect(pipeline.builds.order(:stage_id)
                .map(&:name))
                .to eq(%w[build test pages])
            end
          end

          context 'when external pull request is not specified' do
            let(:pull_request) { nil }

            it 'does not create an external pull request pipeline', :aggregate_failures do
              expect(response).to be_error
              expect(response.message).to eq(""External pull request can't be blank and Failed to build the pipeline!"")
              expect(pipeline).not_to be_persisted
              expect(pipeline.errors[:base]).to eq(['Failed to build the pipeline!'])
            end
          end
        end
      end
    end

    describe 'Pipelines for merge requests' do
      let(:response) do
        execute_service(
          source: source,
          merge_request: merge_request,
          ref: ref_name,
          source_sha: source_sha,
          target_sha: target_sha
        )
      end

      let(:pipeline) { response.payload }

      before do
        stub_ci_pipeline_yaml_file(YAML.dump(config))
      end

      let(:ref_name) { 'refs/heads/feature' }
      let(:source_sha) { project.commit(ref_name).id }
      let(:target_sha) { nil }

      context 'when source is merge request' do
        let(:source) { :merge_request_event }

        context ""when config has merge_requests keywords"" do
          let(:config) do
            {
              build: {
                stage: 'build',
                script: 'echo'
              },
              test: {
                stage: 'test',
                script: 'echo',
                only: ['merge_requests']
              },
              pages: {
                stage: 'deploy',
                script: 'echo',
                except: ['merge_requests']
              }
            }
          end

          context 'when merge request is specified' do
            let(:merge_request) do
              create(:merge_request,
                source_project: project,
                source_branch: 'feature',
                target_project: project,
                target_branch: 'master')
            end

            let(:ref_name) { merge_request.ref_path }

            it 'creates a detached merge request pipeline' do
              expect(pipeline).to be_persisted
              expect(pipeline).to be_merge_request_event
              expect(pipeline.merge_request).to eq(merge_request)
              expect(pipeline.builds.order(:stage_id).pluck(:name)).to eq(%w[test])
            end

            it 'persists the specified source sha' do
              expect(pipeline.source_sha).to eq(source_sha)
            end

            it 'does not persist target sha for detached merge request pipeline' do
              expect(pipeline.target_sha).to be_nil
            end

            it 'schedules update for the head pipeline of the merge request' do
              allow(MergeRequests::UpdateHeadPipelineWorker).to receive(:perform_async)

              pipeline

              expect(MergeRequests::UpdateHeadPipelineWorker).to have_received(:perform_async).with('Ci::PipelineCreatedEvent', { 'pipeline_id' => pipeline.id })
            end

            it 'schedules a namespace onboarding create action worker' do
              expect(Onboarding::PipelineCreatedWorker)
                .to receive(:perform_async).with(project.namespace_id)

              pipeline
            end

            context 'when target sha is specified' do
              let(:target_sha) { merge_request.target_branch_sha }

              it 'persists the target sha' do
                expect(pipeline.target_sha).to eq(target_sha)
              end
            end

            context 'when ref is tag' do
              let(:ref_name) { 'refs/tags/v1.1.0' }

              it 'does not create a merge request pipeline', :aggregate_failures do
                expect(response).to be_error
                expect(response.message).to eq('Tag is not included in the list and Failed to build the pipeline!')
                expect(pipeline).not_to be_persisted
                expect(pipeline.errors[:tag]).to eq(['is not included in the list'])
              end
            end

            context 'when merge request is created from a forked project' do
              let(:merge_request) do
                create(:merge_request,
                  source_project: project,
                  source_branch: 'feature',
                  target_project: target_project,
                  target_branch: 'master')
              end

              let(:ref_name) { 'refs/heads/feature' }
              let!(:project) { fork_project(target_project, nil, repository: true) }
              let!(:target_project) { create(:project, :repository) }
              let!(:user) { create(:user) }

              before do
                project.add_developer(user)
              end

              it 'creates a legacy detached merge request pipeline in the forked project', :sidekiq_might_not_need_inline do
                expect(pipeline).to be_persisted
                expect(project.ci_pipelines).to eq([pipeline])
                expect(target_project.ci_pipelines).to be_empty
              end
            end

            context ""when there are no matched jobs"" do
              let(:config) do
                {
                  test: {
                    stage: 'test',
                    script: 'echo',
                    except: ['merge_requests']
                  }
                }
              end

              it 'does not create a detached merge request pipeline', :aggregate_failures do
                expect(response).to be_error
                expect(response.message).to eq('Pipeline will not run for the selected trigger. ' \
                  'The rules configuration prevented any jobs from being added to the pipeline.')
                expect(pipeline).not_to be_persisted
              end
            end
          end
        end

        context ""when config does not have merge_requests keywords"" do
          let(:config) do
            {
              build: {
                stage: 'build',
                script: 'echo'
              },
              test: {
                stage: 'test',
                script: 'echo'
              },
              pages: {
                stage: 'deploy',
                script: 'echo'
              }
            }
          end

          context 'when merge request is specified' do
            let(:merge_request) do
              create(:merge_request,
                source_project: project,
                source_branch: Gitlab::Git.ref_name(ref_name),
                target_project: project,
                target_branch: 'master')
            end

            it 'does not create a detached merge request pipeline', :aggregate_failures do
              expect(response).to be_error
              expect(response.message).to eq('Pipeline will not run for the selected trigger. ' \
                'The rules configuration prevented any jobs from being added to the pipeline.')
              expect(pipeline).not_to be_persisted
            end
          end
        end

        context ""when config uses regular expression for only keyword"" do
          let(:config) do
            {
              build: {
                stage: 'build',
                script: 'echo',
                only: [""/^#{ref_name}$/""]
              }
            }
          end

          context 'when merge request is specified' do
            let(:merge_request) do
              create(:merge_request,
                source_project: project,
                source_branch: Gitlab::Git.ref_name(ref_name),
                target_project: project,
                target_branch: 'master')
            end

            it 'does not create a detached merge request pipeline', :aggregate_failures do
              expect(response).to be_error
              expect(response.message).to eq('Pipeline will not run for the selected trigger. ' \
                'The rules configuration prevented any jobs from being added to the pipeline.')
              expect(pipeline).not_to be_persisted
            end
          end
        end

        context ""when config uses variables for only keyword"" do
          let(:config) do
            {
              build: {
                stage: 'build',
                script: 'echo',
                only: {
                  variables: %w[$CI]
                }
              }
            }
          end

          context 'when merge request is specified' do
            let(:merge_request) do
              create(:merge_request,
                source_project: project,
                source_branch: Gitlab::Git.ref_name(ref_name),
                target_project: project,
                target_branch: 'master')
            end

            it 'does not create a detached merge request pipeline', :aggregate_failures do
              expect(response).to be_error
              expect(response.message).to eq('Pipeline will not run for the selected trigger. ' \
                'The rules configuration prevented any jobs from being added to the pipeline.')
              expect(pipeline).not_to be_persisted
            end
          end
        end

        context ""when config has 'except: [tags]'"" do
          let(:config) do
            {
              build: {
                stage: 'build',
                script: 'echo',
                except: ['tags']
              }
            }
          end

          context 'when merge request is specified' do
            let(:merge_request) do
              create(:merge_request,
                source_project: project,
                source_branch: Gitlab::Git.ref_name(ref_name),
                target_project: project,
                target_branch: 'master')
            end

            it 'does not create a detached merge request pipeline', :aggregate_failures do
              expect(response).to be_error
              expect(response.message).to eq('Pipeline will not run for the selected trigger. ' \
                'The rules configuration prevented any jobs from being added to the pipeline.')
              expect(pipeline).not_to be_persisted
            end
          end
        end
      end

      context 'when source is web' do
        let(:source) { :web }
        let(:merge_request) { nil }

        context ""when config has merge_requests keywords"" do
          let(:config) do
            {
              build: {
                stage: 'build',
                script: 'echo'
              },
              test: {
                stage: 'test',
                script: 'echo',
                only: ['merge_requests']
              },
              pages: {
                stage: 'deploy',
                script: 'echo',
                except: ['merge_requests']
              }
            }
          end

          it 'creates a branch pipeline' do
            expect(pipeline).to be_persisted
            expect(pipeline).to be_web
            expect(pipeline.merge_request).to be_nil
            expect(pipeline.builds.order(:stage_id).pluck(:name)).to eq(%w[build pages])
          end
        end
      end
    end

    context 'when needs is used' do
      let(:response) { execute_service }
      let(:pipeline) { response.payload }

      let(:config) do
        {
          build_a: {
            stage: ""build"",
            script: ""ls"",
            only: %w[master]
          },
          test_a: {
            stage: ""test"",
            script: ""ls"",
            only: %w[master feature],
            needs: %w[build_a]
          },
          deploy: {
            stage: ""deploy"",
            script: ""ls"",
            only: %w[tags]
          }
        }
      end

      before do
        stub_ci_pipeline_yaml_file(YAML.dump(config))
      end

      context 'when pipeline on master is created' do
        let(:ref_name) { 'refs/heads/master' }

        it 'creates a pipeline with build_a and test_a' do
          expect(pipeline).to be_persisted
          expect(pipeline.builds.pluck(:name)).to contain_exactly(""build_a"", ""test_a"")
        end

        it 'bulk inserts all needs' do
          expect(Ci::BuildNeed).to receive(:bulk_insert!).and_call_original

          expect(pipeline).to be_persisted
        end
      end

      context 'when pipeline on feature is created' do
        let(:ref_name) { 'refs/heads/feature' }

        shared_examples 'has errors' do
          it 'contains the expected errors', :aggregate_failures do
            expect(pipeline.builds).to be_empty

            error_message = ""'test_a' job needs 'build_a' job, but 'build_a' is not in any previous stage""
            expect(pipeline.yaml_errors).to eq(error_message)
            expect(pipeline.error_messages.map(&:content)).to contain_exactly(error_message)
            expect(pipeline.errors[:base]).to contain_exactly(error_message)
          end
        end

        context 'when save_on_errors is enabled' do
          let(:response) { execute_service(save_on_errors: true) }
          let(:pipeline) { response.payload }

          it 'does create a pipeline as test_a depends on build_a', :aggregate_failures do
            expect(response).to be_error
            expect(response.message).to eq(""'test_a' job needs 'build_a' job, but 'build_a' is not in any previous stage"")
            expect(pipeline).to be_persisted
          end

          it_behaves_like 'has errors'
        end

        context 'when save_on_errors is disabled' do
          let(:response) { execute_service(save_on_errors: false) }
          let(:pipeline) { response.payload }

          it 'does not create a pipeline as test_a depends on build_a', :aggregate_failures do
            expect(response).to be_error
            expect(pipeline).not_to be_persisted
          end

          it_behaves_like 'has errors'
        end
      end

      context 'when pipeline on v1.0.0 is created' do
        let(:ref_name) { 'refs/tags/v1.0.0' }

        it 'does create a pipeline only with deploy' do
          expect(pipeline).to be_persisted
          expect(pipeline.builds.pluck(:name)).to contain_exactly(""deploy"")
        end
      end
    end

    describe 'pipeline components' do
      let(:components_project) do
        create(:project, :repository, creator: user, namespace: user.namespace)
      end

      let(:component_path) do
        ""#{Gitlab.config.gitlab.host}/#{components_project.full_path}/my-component@v0.1""
      end

      let(:template) do
        <<~YAML
          spec:
            inputs:
              stage:
              suffix:
                default: my-job
          ---
          test-$[[ inputs.suffix ]]:
            stage: $[[ inputs.stage ]]
            script: run tests
        YAML
      end

      let(:sha) do
        components_project.repository.create_file(
          user,
          'my-component/template.yml',
          template,
          message: 'Add my first CI component',
          branch_name: 'master'
        )
      end

      let(:config) do
        <<~YAML
          include:
            - component: #{component_path}
              inputs:
                stage: my-stage

          stages:
            - my-stage

          test-1:
            stage: my-stage
            script: run test-1
        YAML
      end

      before do
        stub_ci_pipeline_yaml_file(config)
      end

      context 'when there is no version with specified tag' do
        before do
          components_project.repository.add_tag(user, 'v0.01', sha)
        end

        it 'does not create a pipeline' do
          response = execute_service(save_on_errors: true)

          pipeline = response.payload

          expect(pipeline).to be_persisted
          expect(pipeline.yaml_errors)
            .to include ""my-component@v0.1' - content not found""
        end
      end

      context 'when there is a proper revision available' do
        before do
          components_project.repository.add_tag(user, 'v0.1', sha)
        end

        context 'when component is valid' do
          it 'creates a pipeline using a pipeline component' do
            response = execute_service(save_on_errors: true)

            pipeline = response.payload

            expect(pipeline).to be_persisted
            expect(pipeline.yaml_errors).to be_blank
            expect(pipeline.statuses.count).to eq 2
            expect(pipeline.statuses.map(&:name)).to match_array %w[test-1 test-my-job]
          end
        end

        context 'when interpolation is invalid' do
          let(:template) do
            <<~YAML
              spec:
                inputs:
                  stage:
              ---
              test:
                stage: $[[ inputs.stage ]]
                script: rspec --suite $[[ inputs.suite ]]
            YAML
          end

          it 'does not create a pipeline' do
            response = execute_service(save_on_errors: true)

            pipeline = response.payload

            expect(pipeline).to be_persisted
            expect(pipeline.yaml_errors)
              .to include 'interpolation interrupted by errors, unknown interpolation key: `suite`'
          end
        end

        context 'when there is a syntax error in the template' do
          let(:template) do
            <<~YAML
              spec:
                inputs:
                  stage:
              ---
              :test
                stage: $[[ inputs.stage ]]
            YAML
          end

          it 'does not create a pipeline' do
            response = execute_service(save_on_errors: true)

            pipeline = response.payload

            expect(pipeline).to be_persisted
            expect(pipeline.yaml_errors)
              .to include 'mapping values are not allowed'
          end
        end
      end
    end

    # TODO: Remove this test section when include:with is removed as part of https://gitlab.com/gitlab-org/gitlab/-/issues/408369
    describe 'pipeline components using include:with instead of include:inputs' do
      let(:components_project) do
        create(:project, :repository, creator: user, namespace: user.namespace)
      end

      let(:component_path) do
        ""#{Gitlab.config.gitlab.host}/#{components_project.full_path}/my-component@v0.1""
      end

      let(:template) do
        <<~YAML
          spec:
            inputs:
              stage:
              suffix:
                default: my-job
          ---
          test-$[[ inputs.suffix ]]:
            stage: $[[ inputs.stage ]]
            script: run tests
        YAML
      end

      let(:sha) do
        components_project.repository.create_file(
          user,
          'my-component/template.yml',
          template,
          message: 'Add my first CI component',
          branch_name: 'master'
        )
      end

      let(:config) do
        <<~YAML
          include:
            - component: #{component_path}
              with:
                stage: my-stage

          stages:
            - my-stage

          test-1:
            stage: my-stage
            script: run test-1
        YAML
      end

      before do
        stub_ci_pipeline_yaml_file(config)
      end

      context 'when there is no version with specified tag' do
        before do
          components_project.repository.add_tag(user, 'v0.01', sha)
        end

        it 'does not create a pipeline' do
          response = execute_service(save_on_errors: true)

          pipeline = response.payload

          expect(pipeline).to be_persisted
          expect(pipeline.yaml_errors)
            .to include ""my-component@v0.1' - content not found""
        end
      end

      context 'when there is a proper revision available' do
        before do
          components_project.repository.add_tag(user, 'v0.1', sha)
        end

        context 'when component is valid' do
          it 'creates a pipeline using a pipeline component' do
            response = execute_service(save_on_errors: true)

            pipeline = response.payload

            expect(pipeline).to be_persisted
            expect(pipeline.yaml_errors).to be_blank
            expect(pipeline.statuses.count).to eq 2
            expect(pipeline.statuses.map(&:name)).to match_array %w[test-1 test-my-job]
          end

          context 'when inputs have a description' do
            let(:template) do
              <<~YAML
                spec:
                  inputs:
                    stage:
                    suffix:
                      default: my-job
                      description: description
                ---
                test-$[[ inputs.suffix ]]:
                  stage: $[[ inputs.stage ]]
                  script: run tests
              YAML
            end

            it 'creates a pipeline' do
              response = execute_service(save_on_errors: true)

              pipeline = response.payload

              expect(pipeline).to be_persisted
              expect(pipeline.yaml_errors).to be_blank
            end
          end
        end

        context 'when interpolation is invalid' do
          let(:template) do
            <<~YAML
              spec:
                inputs:
                  stage:
              ---
              test:
                stage: $[[ inputs.stage ]]
                script: rspec --suite $[[ inputs.suite ]]
            YAML
          end

          it 'does not create a pipeline' do
            response = execute_service(save_on_errors: true)

            pipeline = response.payload

            expect(pipeline).to be_persisted
            expect(pipeline.yaml_errors)
              .to include 'interpolation interrupted by errors, unknown interpolation key: `suite`'
          end
        end

        context 'when there is a syntax error in the template' do
          let(:template) do
            <<~YAML
              spec:
                inputs:
                  stage:
              ---
              :test
                stage: $[[ inputs.stage ]]
            YAML
          end

          it 'does not create a pipeline' do
            response = execute_service(save_on_errors: true)

            pipeline = response.payload

            expect(pipeline).to be_persisted
            expect(pipeline.yaml_errors)
              .to include 'mapping values are not allowed'
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class DailyBuildGroupReportResultService
    def execute(pipeline)
      if DailyBuildGroupReportResult.upsert_reports(coverage_reports(pipeline))
        Projects::CiFeatureUsage.insert_usage(
          project_id: pipeline.project_id,
          feature: :code_coverage,
          default_branch: pipeline.default_branch?
        )
      end
    end

    private

    def coverage_reports(pipeline)
      base_attrs = {
        project_id: pipeline.project_id,
        ref_path: pipeline.source_ref_path,
        date: pipeline.created_at.to_date,
        last_pipeline_id: pipeline.id,
        default_branch: pipeline.default_branch?,
        group_id: pipeline.project&.group&.id
      }

      aggregate(pipeline.builds.with_coverage).map do |group_name, group|
        base_attrs.merge(
          group_name: group_name,
          data: {
            'coverage' => average_coverage(group)
          }
        )
      end
    end

    def aggregate(builds)
      builds.group_by(&:group_name)
    end

    def average_coverage(group)
      total_coverage = group.reduce(0.0) { |sum, build| sum + build.coverage }
      (total_coverage / group.size).round(2)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::DailyBuildGroupReportResultService, '#execute', feature_category: :continuous_integration do
  let_it_be(:group) { create(:group, :private) }
  let_it_be(:pipeline) { create(:ci_pipeline, project: create(:project, group: group), created_at: '2020-02-06 00:01:10') }
  let_it_be(:rspec_job) { create(:ci_build, pipeline: pipeline, name: 'rspec 3/3', coverage: 80) }
  let_it_be(:karma_job) { create(:ci_build, pipeline: pipeline, name: 'karma 2/2', coverage: 90) }
  let_it_be(:extra_job) { create(:ci_build, pipeline: pipeline, name: 'extra', coverage: nil) }

  let(:coverages) { Ci::DailyBuildGroupReportResult.all }

  it 'creates daily code coverage record for each job in the pipeline that has coverage value' do
    described_class.new.execute(pipeline)

    Ci::DailyBuildGroupReportResult.find_by(group_name: 'rspec').tap do |coverage|
      expect(coverage).to have_attributes(
        project_id: pipeline.project.id,
        last_pipeline_id: pipeline.id,
        ref_path: pipeline.source_ref_path,
        group_name: rspec_job.group_name,
        data: { 'coverage' => rspec_job.coverage },
        date: pipeline.created_at.to_date,
        group_id: group.id
      )
    end

    Ci::DailyBuildGroupReportResult.find_by(group_name: 'karma').tap do |coverage|
      expect(coverage).to have_attributes(
        project_id: pipeline.project.id,
        last_pipeline_id: pipeline.id,
        ref_path: pipeline.source_ref_path,
        group_name: karma_job.group_name,
        data: { 'coverage' => karma_job.coverage },
        date: pipeline.created_at.to_date,
        group_id: group.id
      )
    end

    expect(Ci::DailyBuildGroupReportResult.find_by(group_name: 'extra')).to be_nil
  end

  it 'creates a project_ci_feature_usage record for the pipeline project' do
    described_class.new.execute(pipeline)

    expect(Projects::CiFeatureUsage.count).to eq(1)
    expect(Projects::CiFeatureUsage.first).to have_attributes(
      project_id: pipeline.project.id,
      feature: 'code_coverage',
      default_branch: false
    )
  end

  context 'when there are multiple builds with the same group name that report coverage' do
    let!(:test_job_1) { create(:ci_build, pipeline: pipeline, name: 'test 1/2', coverage: 70) }
    let!(:test_job_2) { create(:ci_build, pipeline: pipeline, name: 'test 2/2', coverage: 80) }

    it 'creates daily code coverage record with the average as the value' do
      described_class.new.execute(pipeline)

      Ci::DailyBuildGroupReportResult.find_by(group_name: 'test').tap do |coverage|
        expect(coverage).to have_attributes(
          project_id: pipeline.project.id,
          last_pipeline_id: pipeline.id,
          ref_path: pipeline.source_ref_path,
          group_name: test_job_2.group_name,
          data: { 'coverage' => 75.0 },
          date: pipeline.created_at.to_date
        )
      end
    end
  end

  context 'when there is an existing daily code coverage for the matching date, project, ref_path, and group name' do
    let!(:new_pipeline) do
      create(
        :ci_pipeline,
        project: pipeline.project,
        ref: pipeline.ref,
        created_at: '2020-02-06 00:02:20'
      )
    end

    let!(:new_rspec_job) { create(:ci_build, pipeline: new_pipeline, name: 'rspec 4/4', coverage: 84) }
    let!(:new_karma_job) { create(:ci_build, pipeline: new_pipeline, name: 'karma 3/3', coverage: 92) }

    before do
      # Create the existing daily code coverage records
      described_class.new.execute(pipeline)
    end

    it ""updates the existing record's coverage value and last_pipeline_id"" do
      rspec_coverage = Ci::DailyBuildGroupReportResult.find_by(group_name: 'rspec')
      karma_coverage = Ci::DailyBuildGroupReportResult.find_by(group_name: 'karma')

      # Bump up the coverage values
      described_class.new.execute(new_pipeline)

      rspec_coverage.reload
      karma_coverage.reload

      expect(rspec_coverage).to have_attributes(
        last_pipeline_id: new_pipeline.id,
        data: { 'coverage' => new_rspec_job.coverage }
      )

      expect(karma_coverage).to have_attributes(
        last_pipeline_id: new_pipeline.id,
        data: { 'coverage' => new_karma_job.coverage }
      )
    end

    it 'does not create a new project_ci_feature_usage record for the pipeline project' do
      expect { described_class.new.execute(pipeline) }.not_to change { Projects::CiFeatureUsage.count }

      expect(Projects::CiFeatureUsage.first).to have_attributes(
        project_id: pipeline.project.id,
        feature: 'code_coverage',
        default_branch: false
      )
    end
  end

  context 'when the ID of the pipeline is older than the last_pipeline_id' do
    let!(:new_pipeline) do
      create(
        :ci_pipeline,
        project: pipeline.project,
        ref: pipeline.ref,
        created_at: '2020-02-06 00:02:20'
      )
    end

    let!(:new_rspec_job) { create(:ci_build, pipeline: new_pipeline, name: 'rspec 4/4', coverage: 84) }
    let!(:new_karma_job) { create(:ci_build, pipeline: new_pipeline, name: 'karma 3/3', coverage: 92) }

    before do
      # Create the existing daily code coverage records
      # but in this case, for the newer pipeline first.
      described_class.new.execute(new_pipeline)
    end

    it 'updates the existing daily code coverage records' do
      rspec_coverage = Ci::DailyBuildGroupReportResult.find_by(group_name: 'rspec')
      karma_coverage = Ci::DailyBuildGroupReportResult.find_by(group_name: 'karma')

      # Run another one but for the older pipeline.
      # This simulates the scenario wherein the success worker
      # of an older pipeline, for some network hiccup, was delayed
      # and only got executed right after the newer pipeline's success worker.
      # Ideally, we don't want to bump the coverage value with an older one
      # but given this can be a rare edge case and can be remedied by re-running
      # the pipeline we'll just let it be for now. In return, we are able to use
      # Rails 6 shiny new method, upsert_all, and simplify the code a lot.
      described_class.new.execute(pipeline)

      rspec_coverage.reload
      karma_coverage.reload

      expect(rspec_coverage).to have_attributes(
        last_pipeline_id: pipeline.id,
        data: { 'coverage' => rspec_job.coverage }
      )

      expect(karma_coverage).to have_attributes(
        last_pipeline_id: pipeline.id,
        data: { 'coverage' => karma_job.coverage }
      )
    end
  end

  context 'when pipeline has no builds with coverage' do
    let!(:new_pipeline) do
      create(
        :ci_pipeline,
        created_at: '2020-02-06 00:02:20'
      )
    end

    let!(:some_job) { create(:ci_build, pipeline: new_pipeline, name: 'foo') }

    it 'does nothing' do
      expect { described_class.new.execute(new_pipeline) }.not_to raise_error
      expect(Ci::DailyBuildGroupReportResult.count).to eq(0)
      expect(Projects::CiFeatureUsage.count).to eq(0)
    end
  end

  context 'when pipeline ref_path is the project default branch' do
    let(:default_branch) { 'master' }

    before do
      allow(pipeline.project).to receive(:default_branch).and_return(default_branch)
    end

    it 'sets default branch to true' do
      described_class.new.execute(pipeline)

      coverages.each do |coverage|
        expect(coverage.default_branch).to be_truthy
      end
    end

    it 'creates a project_ci_feature_usage record for the pipeline project for default branch' do
      described_class.new.execute(pipeline)

      expect(Projects::CiFeatureUsage.count).to eq(1)
      expect(Projects::CiFeatureUsage.first).to have_attributes(
        project_id: pipeline.project.id,
        feature: 'code_coverage',
        default_branch: true
      )
    end
  end

  context 'when pipeline ref_path is not the project default branch' do
    it 'sets default branch to false' do
      described_class.new.execute(pipeline)

      coverages.each do |coverage|
        expect(coverage.default_branch).to be_falsey
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class EnqueueJobService
    attr_accessor :job, :current_user, :variables

    def initialize(job, current_user:, variables: nil)
      @job = job
      @current_user = current_user
      @variables = variables
    end

    def execute(&transition)
      transition ||= ->(job) { job.enqueue! }

      Gitlab::OptimisticLocking.retry_lock(job, name: 'ci_enqueue_job') do |job|
        job.user = current_user
        job.job_variables_attributes = variables if variables

        transition.call(job)
      end

      ResetSkippedJobsService.new(job.project, current_user).execute(job)

      job
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::EnqueueJobService, '#execute', feature_category: :continuous_integration do
  let_it_be(:project) { create(:project) }
  let(:user) { create(:user, developer_projects: [project]) }
  let(:pipeline) { create(:ci_pipeline, project: project) }
  let(:build) { create(:ci_build, :manual, pipeline: pipeline) }

  let(:service) do
    described_class.new(build, current_user: user)
  end

  subject(:execute) { service.execute }

  it 'assigns the user to the job' do
    expect { execute }.to change { build.reload.user }.to(user)
  end

  it 'calls enqueue!' do
    expect(build).to receive(:enqueue!)
    execute
  end

  it 'calls Ci::ResetSkippedJobsService' do
    expect_next_instance_of(Ci::ResetSkippedJobsService) do |service|
      expect(service).to receive(:execute).with(build)
    end

    execute
  end

  it 'returns the job' do
    expect(execute).to eq(build)
  end

  context 'when variables are supplied' do
    let(:job_variables) do
      [{ key: 'first', secret_value: 'first' },
       { key: 'second', secret_value: 'second' }]
    end

    let(:service) do
      described_class.new(build, current_user: user, variables: job_variables)
    end

    it 'assigns the variables to the job' do
      execute
      expect(build.reload.job_variables.map(&:key)).to contain_exactly('first', 'second')
    end
  end

  context 'when the job transition is invalid' do
    let(:bridge) { create(:ci_bridge, :failed, pipeline: pipeline, project: project) }

    let(:service) do
      described_class.new(bridge, current_user: user)
    end

    it 'raises StateMachines::InvalidTransition' do
      expect { execute }.to raise_error StateMachines::InvalidTransition
    end
  end

  context 'when a transition block is supplied' do
    let(:bridge) { create(:ci_bridge, :playable, pipeline: pipeline) }

    let(:service) do
      described_class.new(bridge, current_user: user)
    end

    subject(:execute) { service.execute(&:pending!) }

    it 'calls the transition block instead of enqueue!' do
      expect(bridge).to receive(:pending!)
      expect(bridge).not_to receive(:enqueue!)
      execute
    end
  end

  context 'when the job is manually triggered another user' do
    let(:job_variables) do
      [{ key: 'third', secret_value: 'third' },
       { key: 'fourth', secret_value: 'fourth' }]
    end

    let(:service) do
      described_class.new(build, current_user: user, variables: job_variables)
    end

    it 'assigns the user and variables to the job', :aggregate_failures do
      called = false
      service.execute do
        unless called
          called = true
          raise ActiveRecord::StaleObjectError
        end

        build.enqueue!
      end

      build.reload

      expect(called).to be true # ensure we actually entered the failure path
      expect(build.user).to eq(user)
      expect(build.job_variables.map(&:key)).to contain_exactly('third', 'fourth')
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class BuildUnscheduleService
    def initialize(build, user)
      @build = build
      @user = user
    end

    def execute
      return forbidden unless allowed?
      return unprocessable_entity unless build.scheduled?

      build.unschedule!

      ServiceResponse.success(payload: build)
    end

    private

    attr_reader :build, :user

    def allowed?
      user.can?(:update_build, build)
    end

    def forbidden
      ServiceResponse.error(message: 'Forbidden', http_status: :forbidden)
    end

    def unprocessable_entity
      ServiceResponse.error(message: 'Unprocessable entity', http_status: :unprocessable_entity)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::BuildUnscheduleService, feature_category: :continuous_integration do
  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project) }
  let_it_be(:pipeline) { create(:ci_pipeline, project: project) }

  describe '#execute' do
    subject(:execute) { described_class.new(build, user).execute }

    context 'when user is authorized to unschedule the build' do
      before do
        project.add_maintainer(user)
      end

      context 'when build is scheduled' do
        let!(:build) { create(:ci_build, :scheduled, pipeline: pipeline) }

        it 'transits build to manual' do
          response = execute

          expect(response).to be_success
          expect(response.payload.reload).to be_manual
        end
      end

      context 'when build is not scheduled' do
        let!(:build) { create(:ci_build, pipeline: pipeline) }

        it 'responds with unprocessable entity', :aggregate_failures do
          response = execute

          expect(response).to be_error
          expect(response.http_status).to eq(:unprocessable_entity)
        end
      end
    end

    context 'when user is not authorized to unschedule the build' do
      let!(:build) { create(:ci_build, :scheduled, pipeline: pipeline) }

      it 'responds with forbidden', :aggregate_failures do
        response = execute

        expect(response).to be_error
        expect(response.http_status).to eq(:forbidden)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class ProcessBuildService < BaseService
    def execute(processable, current_status)
      if valid_statuses_for_processable(processable).include?(current_status)
        process(processable)
        true
      else
        processable.skip
        false
      end
    end

    private

    def process(processable)
      return enqueue(processable) if processable.enqueue_immediately?

      if processable.schedulable?
        processable.schedule
      elsif processable.action?
        processable.actionize
      else
        enqueue(processable)
      end
    end

    def enqueue(processable)
      return processable.drop!(:failed_outdated_deployment_job) if processable.outdated_deployment?

      processable.enqueue
    end

    def valid_statuses_for_processable(processable)
      case processable.when
      when 'on_success', 'manual', 'delayed'
        processable.scheduling_type_dag? ? %w[success] : %w[success skipped]
      when 'on_failure'
        %w[failed]
      when 'always'
        %w[success failed skipped]
      else
        []
      end
    end
  end
end

Ci::ProcessBuildService.prepend_mod_with('Ci::ProcessBuildService')

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Ci::ProcessBuildService, '#execute', feature_category: :continuous_integration do
  using RSpec::Parameterized::TableSyntax
  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project) }
  let_it_be(:pipeline) { create(:ci_pipeline, ref: 'master', project: project) }

  subject { described_class.new(project, user).execute(build, current_status) }

  before_all do
    project.add_maintainer(user)
  end

  shared_context 'with enqueue_immediately set' do
    before do
      build.set_enqueue_immediately!
    end
  end

  context 'for single build' do
    let!(:build) { create(:ci_build, *[trait].compact, :created, **conditions, pipeline: pipeline) }

    where(:trait, :conditions, :current_status, :after_status, :retry_after_status) do
      nil          | { when: :on_success } | 'success' | 'pending'   | 'pending'
      nil          | { when: :on_success } | 'skipped' | 'pending'   | 'pending'
      nil          | { when: :on_success } | 'failed'  | 'skipped'   | 'skipped'
      nil          | { when: :on_failure } | 'success' | 'skipped'   | 'skipped'
      nil          | { when: :on_failure } | 'skipped' | 'skipped'   | 'skipped'
      nil          | { when: :on_failure } | 'failed'  | 'pending'   | 'pending'
      nil          | { when: :always }     | 'success' | 'pending'   | 'pending'
      nil          | { when: :always }     | 'skipped' | 'pending'   | 'pending'
      nil          | { when: :always }     | 'failed'  | 'pending'   | 'pending'
      :actionable  | { when: :manual }     | 'success' | 'manual'    | 'pending'
      :actionable  | { when: :manual }     | 'skipped' | 'manual'    | 'pending'
      :actionable  | { when: :manual }     | 'failed'  | 'skipped'   | 'skipped'
      :schedulable | { when: :delayed }    | 'success' | 'scheduled' | 'pending'
      :schedulable | { when: :delayed }    | 'skipped' | 'scheduled' | 'pending'
      :schedulable | { when: :delayed }    | 'failed'  | 'skipped'   | 'skipped'
    end

    with_them do
      it 'updates the job status to after_status' do
        expect { subject }.to change { build.status }.to(after_status)
      end

      context 'when build is set to enqueue immediately' do
        include_context 'with enqueue_immediately set'

        it 'updates the job status to retry_after_status' do
          expect { subject }.to change { build.status }.to(retry_after_status)
        end
      end
    end
  end

  context 'when build is scheduled with DAG' do
    let!(:build) do
      create(
        :ci_build,
        *[trait].compact,
        :dependent,
        :created,
        when: build_when,
        pipeline: pipeline,
        needed: other_build
      )
    end

    let!(:other_build) { create(:ci_build, :created, when: :on_success, pipeline: pipeline) }

    where(:trait, :build_when, :current_status, :after_status, :retry_after_status) do
      nil          | :on_success | 'success' | 'pending'   | 'pending'
      nil          | :on_success | 'skipped' | 'skipped'   | 'skipped'
      nil          | :manual     | 'success' | 'manual'    | 'pending'
      nil          | :manual     | 'skipped' | 'skipped'   | 'skipped'
      nil          | :delayed    | 'success' | 'manual'    | 'pending'
      nil          | :delayed    | 'skipped' | 'skipped'   | 'skipped'
      :schedulable | :delayed    | 'success' | 'scheduled' | 'pending'
      :schedulable | :delayed    | 'skipped' | 'skipped'   | 'skipped'
    end

    with_them do
      it 'updates the job status to after_status' do
        expect { subject }.to change { build.status }.to(after_status)
      end

      context 'when build is set to enqueue immediately' do
        include_context 'with enqueue_immediately set'

        it 'updates the job status to retry_after_status' do
          expect { subject }.to change { build.status }.to(retry_after_status)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class DisableUserPipelineSchedulesService
    def execute(user)
      Ci::PipelineSchedule.active.owned_by(user).each_batch do |relation|
        relation.update_all(active: false)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::DisableUserPipelineSchedulesService, feature_category: :continuous_integration do
  describe '#execute' do
    let(:user) { create(:user) }

    subject(:service) { described_class.new.execute(user) }

    context 'when user has active pipeline schedules' do
      let(:owned_pipeline_schedule) { create(:ci_pipeline_schedule, active: true, owner: user) }

      it 'disables all active pipeline schedules', :aggregate_failures do
        expect { service }.to change { owned_pipeline_schedule.reload.active? }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class BuildReportResultService
    include Gitlab::Utils::UsageData

    EVENT_NAME = 'i_testing_test_case_parsed'

    def execute(build)
      return unless build.has_test_reports?

      test_suite = generate_test_suite_report(build)

      track_test_cases(build, test_suite)

      build.report_results.create!(
        project_id: build.project_id,
        data: tests_params(test_suite)
      )
    end

    private

    def generate_test_suite_report(build)
      test_report = build.collect_test_reports!(Gitlab::Ci::Reports::TestReport.new)
      test_report.get_suite(build.test_suite_name)
    end

    def tests_params(test_suite)
      {
        tests: {
          name: test_suite.name,
          duration: test_suite.total_time,
          failed: test_suite.failed_count,
          errored: test_suite.error_count,
          skipped: test_suite.skipped_count,
          success: test_suite.success_count,
          suite_error: test_suite.suite_error
        }
      }
    end

    def track_test_cases(build, test_suite)
      track_usage_event(EVENT_NAME, test_case_hashes(build, test_suite))
    end

    def test_case_hashes(build, test_suite)
      [].tap do |hashes|
        test_suite.each_test_case do |test_case|
          key = ""#{build.project_id}-#{test_case.key}""
          hashes << Digest::SHA256.hexdigest(key)
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::BuildReportResultService, feature_category: :continuous_integration do
  describe '#execute', :clean_gitlab_redis_shared_state do
    subject(:build_report_result) { described_class.new.execute(build) }

    context 'when build is finished' do
      let(:build) { create(:ci_build, :success, :test_reports) }

      it 'creates a build report result entry', :aggregate_failures do
        expect { build_report_result }.to change { Ci::BuildReportResult.count }.by(1)
        expect(build_report_result.tests_name).to eq(""test"")
        expect(build_report_result.tests_success).to eq(2)
        expect(build_report_result.tests_failed).to eq(2)
        expect(build_report_result.tests_errored).to eq(0)
        expect(build_report_result.tests_skipped).to eq(0)
        expect(build_report_result.tests_duration).to eq(0.010284)
      end

      it 'tracks unique test cases parsed' do
        build_report_result

        unique_test_cases_parsed = Gitlab::UsageDataCounters::HLLRedisCounter.unique_events(
          event_names: described_class::EVENT_NAME,
          start_date: 2.weeks.ago,
          end_date: 2.weeks.from_now
        )
        expect(unique_test_cases_parsed).to eq(4)
      end

      context 'and build has test report parsing errors' do
        let(:build) { create(:ci_build, :success, :broken_test_reports) }

        it 'creates a build report result entry with suite error', :aggregate_failures do
          expect { build_report_result }.to change { Ci::BuildReportResult.count }.by(1)
          expect(build_report_result.tests_name).to eq(""test"")
          expect(build_report_result.tests_success).to eq(0)
          expect(build_report_result.tests_failed).to eq(0)
          expect(build_report_result.tests_errored).to eq(0)
          expect(build_report_result.tests_skipped).to eq(0)
          expect(build_report_result.tests_duration).to eq(0)
          expect(build_report_result.suite_error).to be_present
        end

        it 'does not track unique test cases parsed' do
          build_report_result

          unique_test_cases_parsed = Gitlab::UsageDataCounters::HLLRedisCounter.unique_events(
            event_names: described_class::EVENT_NAME,
            start_date: 2.weeks.ago,
            end_date: 2.weeks.from_now
          )
          expect(unique_test_cases_parsed).to eq(0)
        end
      end

      context 'when data has already been persisted' do
        it 'raises an error and do not persist the same data twice' do
          expect { 2.times { described_class.new.execute(build) } }.to raise_error(ActiveRecord::RecordNotUnique)

          expect(Ci::BuildReportResult.count).to eq(1)
        end
      end
    end

    context 'when build is running and test report does not exist' do
      let(:build) { create(:ci_build, :running) }

      it 'does not persist data' do
        subject

        expect(Ci::BuildReportResult.count).to eq(0)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class DestroySecureFileService < BaseService
    def execute(secure_file)
      raise Gitlab::Access::AccessDeniedError unless can?(current_user, :admin_secure_files, secure_file.project)

      secure_file.destroy!
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ci::DestroySecureFileService, feature_category: :continuous_integration do
  let_it_be(:maintainer_user) { create(:user) }
  let_it_be(:developer_user) { create(:user) }
  let_it_be(:project) { create(:project) }
  let_it_be(:secure_file) { create(:ci_secure_file, project: project) }
  let_it_be(:project_member) { create(:project_member, :maintainer, user: maintainer_user, project: project) }
  let_it_be(:project_member2) { create(:project_member, :developer, user: developer_user, project: project) }

  subject { described_class.new(project, user).execute(secure_file) }

  context 'user is a maintainer' do
    let(:user) { maintainer_user }

    it 'destroys the secure file' do
      subject

      expect { secure_file.reload }.to raise_error(ActiveRecord::RecordNotFound)
    end
  end

  context 'user is a developer' do
    let(:user) { developer_user }

    it 'raises an exception' do
      expect { subject }.to raise_error(Gitlab::Access::AccessDeniedError)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class PrepareBuildService
    attr_reader :build

    def initialize(build)
      @build = build
    end

    def execute
      prerequisites.each(&:complete!)

      build.enqueue_preparing!
    rescue StandardError => e
      Gitlab::ErrorTracking.track_exception(e, build_id: build.id)

      build.drop(:unmet_prerequisites)
    end

    private

    def prerequisites
      build.prerequisites
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::PrepareBuildService, feature_category: :continuous_integration do
  describe '#execute' do
    let(:build) { create(:ci_build, :preparing) }

    subject { described_class.new(build).execute }

    before do
      allow(build).to receive(:prerequisites).and_return(prerequisites)
    end

    shared_examples 'build enqueueing' do
      it 'enqueues the build' do
        expect(build).to receive(:enqueue_preparing).once

        subject
      end
    end

    context 'build has unmet prerequisites' do
      let(:prerequisite) { double(complete!: true) }
      let(:prerequisites) { [prerequisite] }

      it 'completes each prerequisite' do
        expect(prerequisites).to all(receive(:complete!))

        subject
      end

      include_examples 'build enqueueing'

      context 'prerequisites fail to complete' do
        before do
          allow(build).to receive(:enqueue_preparing).and_return(false)
        end

        it 'drops the build' do
          expect(build).to receive(:drop).with(:unmet_prerequisites).once

          subject
        end
      end

      context 'prerequisites raise an error' do
        before do
          allow(prerequisite).to receive(:complete!).and_raise Kubeclient::HttpError.new(401, 'unauthorized', nil)
        end

        it 'drops the build and notifies Sentry' do
          expect(build).to receive(:drop).with(:unmet_prerequisites).once
          expect(Gitlab::ErrorTracking).to receive(:track_exception)
            .with(instance_of(Kubeclient::HttpError), hash_including(build_id: build.id))

          subject
        end
      end
    end

    context 'build has no prerequisites' do
      let(:prerequisites) { [] }

      include_examples 'build enqueueing'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class PipelineBridgeStatusService < ::BaseService
    def execute(pipeline)
      return unless pipeline.bridge_triggered?

      begin
        pipeline.source_bridge.inherit_status_from_downstream!(pipeline)
      rescue StateMachines::InvalidTransition => e
        Gitlab::ErrorTracking.track_exception(
          Ci::Bridge::InvalidTransitionError.new(e.message),
          bridge_id: pipeline.source_bridge.id,
          downstream_pipeline_id: pipeline.id)
      end
    end
  end
end

Ci::PipelineBridgeStatusService.prepend_mod_with('Ci::PipelineBridgeStatusService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::PipelineBridgeStatusService, feature_category: :continuous_integration do
  let(:user) { build(:user) }
  let_it_be(:project) { create(:project) }

  let(:pipeline) { build(:ci_pipeline, project: project) }

  describe '#execute' do
    subject { described_class.new(project, user).execute(pipeline) }

    context 'when pipeline has upstream bridge' do
      let(:bridge) { build(:ci_bridge) }

      before do
        pipeline.source_bridge = bridge
      end

      it 'calls inherit_status_from_downstream on upstream bridge' do
        expect(bridge).to receive(:inherit_status_from_downstream!).with(pipeline)

        subject
      end

      context 'when bridge job status raises state machine errors' do
        before do
          pipeline.drop!
          bridge.drop!
        end

        it 'tracks the exception' do
          expect(Gitlab::ErrorTracking)
            .to receive(:track_exception)
            .with(
              instance_of(Ci::Bridge::InvalidTransitionError),
              bridge_id: bridge.id,
              downstream_pipeline_id: pipeline.id)

          subject
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  # This class responsible for assigning
  # proper pending build to runner on runner API request
  class RegisterJobService
    include ::Gitlab::Ci::Artifacts::Logger

    attr_reader :runner, :runner_manager, :metrics

    TEMPORARY_LOCK_TIMEOUT = 3.seconds

    Result = Struct.new(:build, :build_json, :build_presented, :valid?)

    ##
    # The queue depth limit number has been determined by observing 95
    # percentile of effective queue depth on gitlab.com. This is only likely to
    # affect 5% of the worst case scenarios.
    MAX_QUEUE_DEPTH = 45

    def initialize(runner, runner_manager)
      @runner = runner
      @runner_manager = runner_manager
      @metrics = ::Gitlab::Ci::Queue::Metrics.new(runner)
    end

    def execute(params = {})
      replica_caught_up =
        ::Ci::Runner.sticking.find_caught_up_replica(:runner, runner.id, use_primary_on_failure: false)

      @metrics.increment_queue_operation(:queue_attempt)

      result = @metrics.observe_queue_time(:process, @runner.runner_type) do
        process_queue(params)
      end

      # Since we execute this query against replica it might lead to false-positive
      # We might receive the positive response: ""hi, we don't have any more builds for you"".
      # This might not be true. If our DB replica is not up-to date with when runner event was generated
      # we might still have some CI builds to be picked. Instead we should say to runner:
      # ""Hi, we don't have any more builds now,  but not everything is right anyway, so try again"".
      # Runner will retry, but again, against replica, and again will check if replication lag did catch-up.
      if !replica_caught_up && !result.build
        metrics.increment_queue_operation(:queue_replication_lag)

        ::Ci::RegisterJobService::Result.new(nil, nil, nil, false) # rubocop:disable Cop/AvoidReturnFromBlocks
      else
        result
      end
    end

    private

    def process_queue(params)
      valid = true
      depth = 0

      each_build(params) do |build|
        depth += 1
        @metrics.increment_queue_operation(:queue_iteration)

        if depth > max_queue_depth
          @metrics.increment_queue_operation(:queue_depth_limit)

          valid = false

          break
        end

        # We read builds from replicas
        # It is likely that some other concurrent connection is processing
        # a given build at a given moment. To avoid an expensive compute
        # we perform an exclusive lease on Redis to acquire a build temporarily
        unless acquire_temporary_lock(build.id)
          @metrics.increment_queue_operation(:build_temporary_locked)

          # We failed to acquire lock
          # - our queue is not complete as some resources are locked temporarily
          # - we need to re-process it again to ensure that all builds are handled
          valid = false

          next
        end

        result = process_build(build, params)
        next unless result

        if result.valid?
          @metrics.register_success(result.build_presented)
          @metrics.observe_queue_depth(:found, depth)

          return result # rubocop:disable Cop/AvoidReturnFromBlocks
        else
          # The usage of valid: is described in
          # handling of ActiveRecord::StaleObjectError
          valid = false
        end
      end

      @metrics.increment_queue_operation(:queue_conflict) unless valid
      @metrics.observe_queue_depth(:conflict, depth) unless valid
      @metrics.observe_queue_depth(:not_found, depth) if valid
      @metrics.register_failure

      Result.new(nil, nil, nil, valid)
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def each_build(params, &blk)
      queue = ::Ci::Queue::BuildQueueService.new(runner)

      builds = if runner.instance_type?
                 queue.builds_for_shared_runner
               elsif runner.group_type?
                 queue.builds_for_group_runner
               else
                 queue.builds_for_project_runner
               end

      if runner.ref_protected?
        builds = queue.builds_for_protected_runner(builds)
      end

      # pick builds that does not have other tags than runner's one
      builds = queue.builds_matching_tag_ids(builds, runner.tags.ids)

      # pick builds that have at least one tag
      unless runner.run_untagged?
        builds = queue.builds_with_any_tags(builds)
      end

      build_ids = retrieve_queue(-> { queue.execute(builds) })

      @metrics.observe_queue_size(-> { build_ids.size }, @runner.runner_type)

      build_ids.each { |build_id| yield Ci::Build.find(build_id) }
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def retrieve_queue(queue_query_proc)
      ##
      # We want to reset a load balancing session to discard the side
      # effects of writes that could have happened prior to this moment.
      #
      ::Gitlab::Database::LoadBalancing::Session.clear_session

      @metrics.observe_queue_time(:retrieve, @runner.runner_type) do
        queue_query_proc.call
      end
    end

    def process_build(build, params)
      unless build.pending?
        @metrics.increment_queue_operation(:build_not_pending)

        ##
        # If this build can not be picked because we had stale data in
        # `ci_pending_builds` table, we need to respond with 409 to retry
        # this operation.
        #
        if ::Ci::UpdateBuildQueueService.new.remove!(build)
          return Result.new(nil, nil, nil, false)
        end

        return
      end

      if runner.matches_build?(build)
        @metrics.increment_queue_operation(:build_can_pick)
      else
        @metrics.increment_queue_operation(:build_not_pick)

        return
      end

      # In case when 2 runners try to assign the same build, second runner will be declined
      # with StateMachines::InvalidTransition or StaleObjectError when doing run! or save method.
      if assign_runner!(build, params)
        present_build!(build)
      end
    rescue ActiveRecord::StaleObjectError
      # We are looping to find another build that is not conflicting
      # It also indicates that this build can be picked and passed to runner.
      # If we don't do it, basically a bunch of runners would be competing for a build
      # and thus we will generate a lot of 409. This will increase
      # the number of generated requests, also will reduce significantly
      # how many builds can be picked by runner in a unit of time.
      # In case we hit the concurrency-access lock,
      # we still have to return 409 in the end,
      # to make sure that this is properly handled by runner.
      @metrics.increment_queue_operation(:build_conflict_lock)

      Result.new(nil, nil, nil, false)
    rescue StateMachines::InvalidTransition
      @metrics.increment_queue_operation(:build_conflict_transition)

      Result.new(nil, nil, nil, false)
    rescue StandardError => ex
      @metrics.increment_queue_operation(:build_conflict_exception)

      # If an error (e.g. GRPC::DeadlineExceeded) occurred constructing
      # the result, consider this as a failure to be retried.
      scheduler_failure!(build)
      track_exception_for_build(ex, build)

      # skip, and move to next one
      nil
    end

    def max_queue_depth
      MAX_QUEUE_DEPTH
    end

    # Force variables evaluation to occur now
    def present_build!(build)
      # We need to use the presenter here because Gitaly calls in the presenter
      # may fail, and we need to ensure the response has been generated.
      presented_build = ::Ci::BuildRunnerPresenter.new(build) # rubocop:disable CodeReuse/Presenter

      log_artifacts_context(build)
      log_build_dependencies_size(presented_build)

      build_json = Gitlab::Json.dump(::API::Entities::Ci::JobRequest::Response.new(presented_build))
      Result.new(build, build_json, presented_build, true)
    end

    def log_build_dependencies_size(presented_build)
      return unless ::Feature.enabled?(:ci_build_dependencies_artifacts_logger, type: :ops)

      presented_build.all_dependencies.then do |dependencies|
        size = dependencies.sum do |build|
          build.available_artifacts? ? build.artifacts_file.size : 0
        end

        log_build_dependencies(size: size, count: dependencies.size) if size > 0
      end
    end

    def assign_runner!(build, params)
      build.runner_id = runner.id
      build.runner_session_attributes = params[:session] if params[:session].present?

      failure_reason, _ = pre_assign_runner_checks.find { |_, check| check.call(build, params) }

      if failure_reason
        @metrics.increment_queue_operation(:runner_pre_assign_checks_failed)

        build.drop!(failure_reason)
      else
        @metrics.increment_queue_operation(:runner_pre_assign_checks_success)

        build.run!
        build.runner_manager = runner_manager if runner_manager
      end

      !failure_reason
    end

    def acquire_temporary_lock(build_id)
      return true if Feature.disabled?(:ci_register_job_temporary_lock, runner, type: :ops)

      key = ""build/register/#{build_id}""

      Gitlab::ExclusiveLease
        .new(key, timeout: TEMPORARY_LOCK_TIMEOUT.to_i)
        .try_obtain
    end

    def scheduler_failure!(build)
      Gitlab::OptimisticLocking.retry_lock(build, 3, name: 'register_job_scheduler_failure') do |subject|
        subject.drop!(:scheduler_failure)
      end
    rescue StandardError => ex
      build.doom!

      # This requires extra exception, otherwise we would loose information
      # why we cannot perform `scheduler_failure`
      track_exception_for_build(ex, build)
    end

    def track_exception_for_build(ex, build)
      Gitlab::ErrorTracking.track_exception(ex,
        build_id: build.id,
        build_name: build.name,
        build_stage: build.stage_name,
        pipeline_id: build.pipeline_id,
        project_id: build.project_id
      )
    end

    def pre_assign_runner_checks
      {
        missing_dependency_failure: -> (build, _) { !build.has_valid_build_dependencies? },
        runner_unsupported: -> (build, params) { !build.supported_runner?(params.dig(:info, :features)) },
        archived_failure: -> (build, _) { build.archived? },
        project_deleted: -> (build, _) { build.project.pending_delete? },
        builds_disabled: -> (build, _) { !build.project.builds_enabled? },
        user_blocked: -> (build, _) { build.user&.blocked? }
      }
    end
  end
end

Ci::RegisterJobService.prepend_mod_with('Ci::RegisterJobService')

```","# frozen_string_literal: true

require 'spec_helper'

module Ci
  RSpec.describe RegisterJobService, feature_category: :continuous_integration do
    let_it_be(:group) { create(:group) }
    let_it_be_with_reload(:project) { create(:project, group: group, shared_runners_enabled: false, group_runners_enabled: false) }
    let_it_be_with_reload(:pipeline) { create(:ci_pipeline, project: project) }

    let_it_be(:shared_runner) { create(:ci_runner, :instance) }
    let!(:project_runner) { create(:ci_runner, :project, projects: [project]) }
    let!(:group_runner) { create(:ci_runner, :group, groups: [group]) }
    let!(:pending_job) { create(:ci_build, :pending, :queued, pipeline: pipeline) }

    describe '#execute' do
      subject(:execute) { described_class.new(runner, runner_manager).execute }

      let(:runner_manager) { nil }

      context 'checks database loadbalancing stickiness' do
        let(:runner) { shared_runner }

        before do
          project.update!(shared_runners_enabled: false)
        end

        it 'result is valid if replica did caught-up', :aggregate_failures do
          expect(ApplicationRecord.sticking).to receive(:find_caught_up_replica)
            .with(:runner, runner.id, use_primary_on_failure: false)
            .and_return(true)

          expect { execute }.not_to change { Ci::RunnerManagerBuild.count }.from(0)
          expect(execute).to be_valid
          expect(execute.build).to be_nil
          expect(execute.build_json).to be_nil
        end

        it 'result is invalid if replica did not caught-up', :aggregate_failures do
          expect(ApplicationRecord.sticking).to receive(:find_caught_up_replica)
            .with(:runner, shared_runner.id, use_primary_on_failure: false)
            .and_return(false)

          expect(subject).not_to be_valid
          expect(subject.build).to be_nil
          expect(subject.build_json).to be_nil
        end
      end

      shared_examples 'handles runner assignment' do
        context 'runner follows tag list' do
          subject(:build) { build_on(project_runner, runner_manager: project_runner_manager) }

          let(:project_runner_manager) { nil }

          context 'when job has tag' do
            before do
              pending_job.update!(tag_list: [""linux""])
              pending_job.reload
              pending_job.create_queuing_entry!
            end

            context 'and runner has matching tag' do
              before do
                project_runner.update!(tag_list: [""linux""])
              end

              context 'with no runner manager specified' do
                it 'picks build' do
                  expect(build).to eq(pending_job)
                  expect(pending_job.runner_manager).to be_nil
                end
              end

              context 'with runner manager specified' do
                let(:project_runner_manager) { create(:ci_runner_machine, runner: project_runner) }

                it 'picks build and assigns runner manager' do
                  expect(build).to eq(pending_job)
                  expect(pending_job.runner_manager).to eq(project_runner_manager)
                end
              end
            end

            it 'does not pick build with different tag' do
              project_runner.update!(tag_list: [""win32""])
              expect(build).to be_falsey
            end

            it 'does not pick build with tag' do
              pending_job.create_queuing_entry!
              expect(build).to be_falsey
            end
          end

          context 'when job has no tag' do
            it 'picks build' do
              expect(build).to eq(pending_job)
            end

            context 'when runner has tag' do
              before do
                project_runner.update!(tag_list: [""win32""])
              end

              it 'picks build' do
                expect(build).to eq(pending_job)
              end
            end
          end
        end

        context 'deleted projects' do
          before do
            project.update!(pending_delete: true)
          end

          context 'for shared runners' do
            before do
              project.update!(shared_runners_enabled: true)
            end

            it 'does not pick a build' do
              expect(build_on(shared_runner)).to be_nil
            end
          end

          context 'for project runner' do
            subject(:build) { build_on(project_runner, runner_manager: project_runner_manager) }

            let(:project_runner_manager) { nil }

            context 'with no runner manager specified' do
              it 'does not pick a build' do
                expect(build).to be_nil
                expect(pending_job.reload).to be_failed
                expect(pending_job.queuing_entry).to be_nil
                expect(Ci::RunnerManagerBuild.all).to be_empty
              end
            end

            context 'with runner manager specified' do
              let(:project_runner_manager) { create(:ci_runner_machine, runner: project_runner) }

              it 'does not pick a build' do
                expect(build).to be_nil
                expect(pending_job.reload).to be_failed
                expect(pending_job.queuing_entry).to be_nil
                expect(Ci::RunnerManagerBuild.all).to be_empty
              end
            end
          end
        end

        context 'allow shared runners' do
          before do
            project.update!(shared_runners_enabled: true)
            pipeline.reload
            pending_job.reload
            pending_job.create_queuing_entry!
          end

          context 'when build owner has been blocked' do
            let(:user) { create(:user, :blocked) }

            before do
              pending_job.update!(user: user)
            end

            context 'with no runner manager specified' do
              it 'does not pick the build and drops the build' do
                expect(build_on(shared_runner)).to be_falsey

                expect(pending_job.reload).to be_user_blocked
              end
            end

            context 'with runner manager specified' do
              let(:runner_manager) { create(:ci_runner_machine, runner: runner) }

              it 'does not pick the build and does not create join record' do
                expect(build_on(shared_runner, runner_manager: runner_manager)).to be_falsey

                expect(Ci::RunnerManagerBuild.all).to be_empty
              end
            end
          end

          context 'for multiple builds' do
            let!(:project2) { create :project, shared_runners_enabled: true }
            let!(:pipeline2) { create :ci_pipeline, project: project2 }
            let!(:project3) { create :project, shared_runners_enabled: true }
            let!(:pipeline3) { create :ci_pipeline, project: project3 }
            let!(:build1_project1) { pending_job }
            let!(:build2_project1) { create(:ci_build, :pending, :queued, pipeline: pipeline) }
            let!(:build3_project1) { create(:ci_build, :pending, :queued, pipeline: pipeline) }
            let!(:build1_project2) { create(:ci_build, :pending, :queued, pipeline: pipeline2) }
            let!(:build2_project2) { create(:ci_build, :pending, :queued, pipeline: pipeline2) }
            let!(:build1_project3) { create(:ci_build, :pending, :queued, pipeline: pipeline3) }

            it 'picks builds one-by-one' do
              expect(Ci::Build).to receive(:find).with(pending_job.id).and_call_original

              expect(build_on(shared_runner)).to eq(build1_project1)
            end

            context 'when using fair scheduling' do
              context 'when all builds are pending' do
                it 'prefers projects without builds first' do
                  # it gets for one build from each of the projects
                  expect(build_on(shared_runner)).to eq(build1_project1)
                  expect(build_on(shared_runner)).to eq(build1_project2)
                  expect(build_on(shared_runner)).to eq(build1_project3)

                  # then it gets a second build from each of the projects
                  expect(build_on(shared_runner)).to eq(build2_project1)
                  expect(build_on(shared_runner)).to eq(build2_project2)

                  # in the end the third build
                  expect(build_on(shared_runner)).to eq(build3_project1)
                end
              end

              context 'when some builds transition to success' do
                it 'equalises number of running builds' do
                  # after finishing the first build for project 1, get a second build from the same project
                  expect(build_on(shared_runner)).to eq(build1_project1)
                  build1_project1.reload.success
                  expect(build_on(shared_runner)).to eq(build2_project1)

                  expect(build_on(shared_runner)).to eq(build1_project2)
                  build1_project2.reload.success
                  expect(build_on(shared_runner)).to eq(build2_project2)
                  expect(build_on(shared_runner)).to eq(build1_project3)
                  expect(build_on(shared_runner)).to eq(build3_project1)
                end
              end
            end

            context 'when using DEFCON mode that disables fair scheduling' do
              before do
                stub_feature_flags(ci_queueing_disaster_recovery_disable_fair_scheduling: true)
              end

              context 'when all builds are pending' do
                it 'returns builds in order of creation (FIFO)' do
                  # it gets for one build from each of the projects
                  expect(build_on(shared_runner)).to eq(build1_project1)
                  expect(build_on(shared_runner)).to eq(build2_project1)
                  expect(build_on(shared_runner)).to eq(build3_project1)
                  expect(build_on(shared_runner)).to eq(build1_project2)
                  expect(build_on(shared_runner)).to eq(build2_project2)
                  expect(build_on(shared_runner)).to eq(build1_project3)
                end
              end

              context 'when some builds transition to success' do
                it 'returns builds in order of creation (FIFO)' do
                  expect(build_on(shared_runner)).to eq(build1_project1)
                  build1_project1.reload.success
                  expect(build_on(shared_runner)).to eq(build2_project1)

                  expect(build_on(shared_runner)).to eq(build3_project1)
                  build2_project1.reload.success
                  expect(build_on(shared_runner)).to eq(build1_project2)
                  expect(build_on(shared_runner)).to eq(build2_project2)
                  expect(build_on(shared_runner)).to eq(build1_project3)
                end
              end
            end
          end

          context 'shared runner' do
            let(:response) { described_class.new(shared_runner, nil).execute }
            let(:build) { response.build }

            it { expect(build).to be_kind_of(Build) }
            it { expect(build).to be_valid }
            it { expect(build).to be_running }
            it { expect(build.runner).to eq(shared_runner) }
            it { expect(Gitlab::Json.parse(response.build_json)['id']).to eq(build.id) }
          end

          context 'project runner' do
            let(:build) { build_on(project_runner) }

            it { expect(build).to be_kind_of(Build) }
            it { expect(build).to be_valid }
            it { expect(build).to be_running }
            it { expect(build.runner).to eq(project_runner) }
          end
        end

        context 'disallow shared runners' do
          before do
            project.update!(shared_runners_enabled: false)
          end

          context 'shared runner' do
            let(:build) { build_on(shared_runner) }

            it { expect(build).to be_nil }
          end

          context 'project runner' do
            let(:build) { build_on(project_runner) }

            it { expect(build).to be_kind_of(Build) }
            it { expect(build).to be_valid }
            it { expect(build).to be_running }
            it { expect(build.runner).to eq(project_runner) }
          end
        end

        context 'disallow when builds are disabled' do
          before do
            project.update!(shared_runners_enabled: true, group_runners_enabled: true)
            project.project_feature.update_attribute(:builds_access_level, ProjectFeature::DISABLED)

            pending_job.reload.create_queuing_entry!
          end

          context 'and uses shared runner' do
            let(:build) { build_on(shared_runner) }

            it { expect(build).to be_nil }
          end

          context 'and uses group runner' do
            let(:build) { build_on(group_runner) }

            it { expect(build).to be_nil }
          end

          context 'and uses project runner' do
            let(:build) { build_on(project_runner) }

            it 'does not pick a build' do
              expect(build).to be_nil
              expect(pending_job.reload).to be_failed
              expect(pending_job.queuing_entry).to be_nil
            end
          end
        end

        context 'allow group runners' do
          before do
            project.update!(group_runners_enabled: true)
          end

          context 'for multiple builds' do
            let!(:project2) { create(:project, group_runners_enabled: true, group: group) }
            let!(:pipeline2) { create(:ci_pipeline, project: project2) }
            let!(:project3) { create(:project, group_runners_enabled: true, group: group) }
            let!(:pipeline3) { create(:ci_pipeline, project: project3) }

            let!(:build1_project1) { pending_job }
            let!(:build2_project1) { create(:ci_build, :queued, pipeline: pipeline) }
            let!(:build3_project1) { create(:ci_build, :queued, pipeline: pipeline) }
            let!(:build1_project2) { create(:ci_build, :queued, pipeline: pipeline2) }
            let!(:build2_project2) { create(:ci_build, :queued, pipeline: pipeline2) }
            let!(:build1_project3) { create(:ci_build, :queued, pipeline: pipeline3) }

            # these shouldn't influence the scheduling
            let!(:unrelated_group) { create(:group) }
            let!(:unrelated_project) { create(:project, group_runners_enabled: true, group: unrelated_group) }
            let!(:unrelated_pipeline) { create(:ci_pipeline, project: unrelated_project) }
            let!(:build1_unrelated_project) { create(:ci_build, :pending, :queued, pipeline: unrelated_pipeline) }
            let!(:unrelated_group_runner) { create(:ci_runner, :group, groups: [unrelated_group]) }

            it 'does not consider builds from other group runners' do
              queue = ::Ci::Queue::BuildQueueService.new(group_runner)

              expect(queue.builds_for_group_runner.size).to eq 6
              build_on(group_runner)

              expect(queue.builds_for_group_runner.size).to eq 5
              build_on(group_runner)

              expect(queue.builds_for_group_runner.size).to eq 4
              build_on(group_runner)

              expect(queue.builds_for_group_runner.size).to eq 3
              build_on(group_runner)

              expect(queue.builds_for_group_runner.size).to eq 2
              build_on(group_runner)

              expect(queue.builds_for_group_runner.size).to eq 1
              build_on(group_runner)

              expect(queue.builds_for_group_runner.size).to eq 0
              expect(build_on(group_runner)).to be_nil
            end
          end

          context 'group runner' do
            let(:build) { build_on(group_runner) }

            it { expect(build).to be_kind_of(Build) }
            it { expect(build).to be_valid }
            it { expect(build).to be_running }
            it { expect(build.runner).to eq(group_runner) }
          end
        end

        context 'disallow group runners' do
          before do
            project.update!(group_runners_enabled: false)

            pending_job.reload.create_queuing_entry!
          end

          context 'group runner' do
            let(:build) { build_on(group_runner) }

            it { expect(build).to be_nil }
          end
        end

        context 'when first build is stalled' do
          before do
            allow_any_instance_of(described_class).to receive(:assign_runner!).and_call_original
            allow_any_instance_of(described_class).to receive(:assign_runner!)
              .with(pending_job, anything).and_raise(ActiveRecord::StaleObjectError)
          end

          subject { described_class.new(project_runner, nil).execute }

          context 'with multiple builds are in queue' do
            let!(:other_build) { create(:ci_build, :pending, :queued, pipeline: pipeline) }

            before do
              allow_any_instance_of(::Ci::Queue::BuildQueueService)
                .to receive(:execute)
                .and_return(Ci::Build.where(id: [pending_job, other_build]).pluck(:id))
            end

            it ""receives second build from the queue"" do
              expect(subject).to be_valid
              expect(subject.build).to eq(other_build)
            end
          end

          context 'when single build is in queue' do
            before do
              allow_any_instance_of(::Ci::Queue::BuildQueueService)
                .to receive(:execute)
                .and_return(Ci::Build.where(id: pending_job).pluck(:id))
            end

            it ""does not receive any valid result"" do
              expect(subject).not_to be_valid
            end
          end

          context 'when there is no build in queue' do
            before do
              allow_any_instance_of(::Ci::Queue::BuildQueueService)
                .to receive(:execute)
                .and_return([])
            end

            it ""does not receive builds but result is valid"" do
              expect(subject).to be_valid
              expect(subject.build).to be_nil
            end
          end
        end

        context 'when access_level of runner is not_protected' do
          let!(:project_runner) { create(:ci_runner, :project, projects: [project]) }

          context 'when a job is protected' do
            let!(:pending_job) { create(:ci_build, :pending, :queued, :protected, pipeline: pipeline) }

            it 'picks the job' do
              expect(build_on(project_runner)).to eq(pending_job)
            end
          end

          context 'when a job is unprotected' do
            let!(:pending_job) { create(:ci_build, :pending, :queued, pipeline: pipeline) }

            it 'picks the job' do
              expect(build_on(project_runner)).to eq(pending_job)
            end
          end

          context 'when protected attribute of a job is nil' do
            let!(:pending_job) { create(:ci_build, :pending, :queued, pipeline: pipeline) }

            before do
              pending_job.update_attribute(:protected, nil)
            end

            it 'picks the job' do
              expect(build_on(project_runner)).to eq(pending_job)
            end
          end
        end

        context 'when access_level of runner is ref_protected' do
          let!(:project_runner) { create(:ci_runner, :project, :ref_protected, projects: [project]) }

          context 'when a job is protected' do
            let!(:pending_job) { create(:ci_build, :pending, :queued, :protected, pipeline: pipeline) }

            it 'picks the job' do
              expect(build_on(project_runner)).to eq(pending_job)
            end
          end

          context 'when a job is unprotected' do
            let!(:pending_job) { create(:ci_build, :pending, :queued, pipeline: pipeline) }

            it 'does not pick the job' do
              expect(build_on(project_runner)).to be_nil
            end
          end

          context 'when protected attribute of a job is nil' do
            let!(:pending_job) { create(:ci_build, :pending, :queued, pipeline: pipeline) }

            before do
              pending_job.update_attribute(:protected, nil)
            end

            it 'does not pick the job' do
              expect(build_on(project_runner)).to be_nil
            end
          end
        end

        context 'runner feature set is verified' do
          let(:options) { { artifacts: { reports: { junit: ""junit.xml"" } } } }
          let!(:pending_job) { create(:ci_build, :pending, :queued, pipeline: pipeline, options: options) }

          subject { build_on(project_runner, params: params) }

          context 'when feature is missing by runner' do
            let(:params) { {} }

            it 'does not pick the build and drops the build' do
              expect(subject).to be_nil
              expect(pending_job.reload).to be_failed
              expect(pending_job).to be_runner_unsupported
            end
          end

          context 'when feature is supported by runner' do
            let(:params) do
              { info: { features: { upload_multiple_artifacts: true } } }
            end

            it 'does pick job' do
              expect(subject).not_to be_nil
            end
          end
        end

        context 'when ""dependencies"" keyword is specified' do
          let!(:pre_stage_job) do
            create(:ci_build, :success, :artifacts, pipeline: pipeline, name: 'test', stage_idx: 0)
          end

          let!(:pending_job) do
            create(:ci_build, :pending, :queued,
              pipeline: pipeline, stage_idx: 1,
              options: { script: [""bash""], dependencies: dependencies })
          end

          let(:dependencies) { %w[test] }

          subject { build_on(project_runner) }

          it 'picks a build with a dependency' do
            picked_build = build_on(project_runner)

            expect(picked_build).to be_present
          end

          context 'when there are multiple dependencies with artifacts' do
            let!(:pre_stage_job_second) do
              create(:ci_build, :success, :artifacts, pipeline: pipeline, name: 'deploy', stage_idx: 0)
            end

            let(:dependencies) { %w[test deploy] }

            it 'logs build artifacts size' do
              build_on(project_runner)

              artifacts_size = [pre_stage_job, pre_stage_job_second].sum do |job|
                job.job_artifacts_archive.size
              end

              expect(artifacts_size).to eq 107464 * 2
              expect(Gitlab::ApplicationContext.current).to include({
                'meta.artifacts_dependencies_size' => artifacts_size,
                'meta.artifacts_dependencies_count' => 2
              })
            end
          end

          shared_examples 'not pick' do
            it 'does not pick the build and drops the build' do
              expect(subject).to be_nil
              expect(pending_job.reload).to be_failed
              expect(pending_job).to be_missing_dependency_failure
            end
          end

          shared_examples 'validation is active' do
            context 'when depended job has not been completed yet' do
              let!(:pre_stage_job) do
                create(:ci_build, :pending, :queued, :manual, pipeline: pipeline, name: 'test', stage_idx: 0)
              end

              it { is_expected.to eq(pending_job) }
            end

            context 'when artifacts of depended job has been expired' do
              let!(:pre_stage_job) do
                create(:ci_build, :success, :expired, pipeline: pipeline, name: 'test', stage_idx: 0)
              end

              context 'when the pipeline is locked' do
                before do
                  pipeline.artifacts_locked!
                end

                it { is_expected.to eq(pending_job) }
              end

              context 'when the pipeline is unlocked' do
                before do
                  pipeline.unlocked!
                end

                it_behaves_like 'not pick'
              end
            end

            context 'when artifacts of depended job has been erased' do
              let!(:pre_stage_job) do
                create(:ci_build, :success, pipeline: pipeline, name: 'test', stage_idx: 0, erased_at: 1.minute.ago)
              end

              it_behaves_like 'not pick'
            end

            context 'when job object is staled' do
              let!(:pre_stage_job) do
                create(:ci_build, :success, :expired, pipeline: pipeline, name: 'test', stage_idx: 0)
              end

              before do
                pipeline.unlocked!

                allow_next_instance_of(Ci::Build) do |build|
                  expect(build).to receive(:drop!)
                    .and_raise(ActiveRecord::StaleObjectError.new(pending_job, :drop!))
                end
              end

              it 'does not drop nor pick' do
                expect(subject).to be_nil
              end
            end
          end

          shared_examples 'validation is not active' do
            context 'when depended job has not been completed yet' do
              let!(:pre_stage_job) do
                create(:ci_build, :pending, :queued, :manual, pipeline: pipeline, name: 'test', stage_idx: 0)
              end

              it { expect(subject).to eq(pending_job) }
            end

            context 'when artifacts of depended job has been expired' do
              let!(:pre_stage_job) do
                create(:ci_build, :success, :expired, pipeline: pipeline, name: 'test', stage_idx: 0)
              end

              it { expect(subject).to eq(pending_job) }
            end

            context 'when artifacts of depended job has been erased' do
              let!(:pre_stage_job) do
                create(:ci_build, :success, pipeline: pipeline, name: 'test', stage_idx: 0, erased_at: 1.minute.ago)
              end

              it { expect(subject).to eq(pending_job) }
            end
          end

          it_behaves_like 'validation is active'
        end

        context 'when build is degenerated' do
          let!(:pending_job) { create(:ci_build, :pending, :queued, :degenerated, pipeline: pipeline) }

          subject { build_on(project_runner) }

          it 'does not pick the build and drops the build' do
            expect(subject).to be_nil

            pending_job.reload
            expect(pending_job).to be_failed
            expect(pending_job).to be_archived_failure
          end
        end

        context 'when build has data integrity problem' do
          let!(:pending_job) do
            create(:ci_build, :pending, :queued, pipeline: pipeline)
          end

          before do
            pending_job.update_columns(options: ""string"")
          end

          subject { build_on(project_runner) }

          it 'does drop the build and logs both failures' do
            expect(Gitlab::ErrorTracking).to receive(:track_exception)
              .with(anything, a_hash_including(build_id: pending_job.id))
              .twice
              .and_call_original

            expect(subject).to be_nil

            pending_job.reload
            expect(pending_job).to be_failed
            expect(pending_job).to be_data_integrity_failure
          end
        end

        context 'when build fails to be run!' do
          let!(:pending_job) do
            create(:ci_build, :pending, :queued, pipeline: pipeline)
          end

          before do
            expect_any_instance_of(Ci::Build).to receive(:run!)
              .and_raise(RuntimeError, 'scheduler error')
          end

          subject { build_on(project_runner) }

          it 'does drop the build and logs failure' do
            expect(Gitlab::ErrorTracking).to receive(:track_exception)
              .with(anything, a_hash_including(build_id: pending_job.id))
              .once
              .and_call_original

            expect(subject).to be_nil

            pending_job.reload
            expect(pending_job).to be_failed
            expect(pending_job).to be_scheduler_failure
          end
        end

        context 'when an exception is raised during a persistent ref creation' do
          before do
            allow_any_instance_of(Ci::PersistentRef).to receive(:exist?) { false }
            allow_any_instance_of(Ci::PersistentRef).to receive(:create_ref) { raise ArgumentError }
          end

          subject { build_on(project_runner) }

          it 'picks the build' do
            expect(subject).to eq(pending_job)

            pending_job.reload
            expect(pending_job).to be_running
          end
        end

        context 'when only some builds can be matched by runner' do
          let!(:project_runner) { create(:ci_runner, :project, projects: [project], tag_list: %w[matching]) }
          let!(:pending_job) { create(:ci_build, :pending, :queued, pipeline: pipeline, tag_list: %w[matching]) }

          before do
            # create additional matching and non-matching jobs
            create_list(:ci_build, 2, :pending, :queued, pipeline: pipeline, tag_list: %w[matching])
            create(:ci_build, :pending, :queued, pipeline: pipeline, tag_list: %w[non-matching])
          end

          it 'observes queue size of only matching jobs' do
            # pending_job + 2 x matching ones
            expect(Gitlab::Ci::Queue::Metrics.queue_size_total).to receive(:observe)
              .with({ runner_type: project_runner.runner_type }, 3)

            expect(build_on(project_runner)).to eq(pending_job)
          end

          it 'observes queue processing time by the runner type' do
            expect(Gitlab::Ci::Queue::Metrics.queue_iteration_duration_seconds)
              .to receive(:observe)
              .with({ runner_type: project_runner.runner_type }, anything)

            expect(Gitlab::Ci::Queue::Metrics.queue_retrieval_duration_seconds)
              .to receive(:observe)
              .with({ runner_type: project_runner.runner_type }, anything)

            expect(build_on(project_runner)).to eq(pending_job)
          end
        end

        context 'when ci_register_job_temporary_lock is enabled' do
          before do
            stub_feature_flags(ci_register_job_temporary_lock: true)

            allow(Gitlab::Ci::Queue::Metrics.queue_operations_total).to receive(:increment)
          end

          context 'when a build is temporarily locked' do
            let(:service) { described_class.new(project_runner, nil) }

            before do
              service.send(:acquire_temporary_lock, pending_job.id)
            end

            it 'skips this build and marks queue as invalid' do
              expect(Gitlab::Ci::Queue::Metrics.queue_operations_total).to receive(:increment)
                .with(operation: :queue_iteration)
              expect(Gitlab::Ci::Queue::Metrics.queue_operations_total).to receive(:increment)
                .with(operation: :build_temporary_locked)

              expect(service.execute).not_to be_valid
            end

            context 'when there is another build in queue' do
              let!(:next_pending_job) { create(:ci_build, :pending, :queued, pipeline: pipeline) }

              it 'skips this build and picks another build' do
                expect(Gitlab::Ci::Queue::Metrics.queue_operations_total).to receive(:increment)
                  .with(operation: :queue_iteration).twice
                expect(Gitlab::Ci::Queue::Metrics.queue_operations_total).to receive(:increment)
                  .with(operation: :build_temporary_locked)

                result = service.execute

                expect(result.build).to eq(next_pending_job)
                expect(result).to be_valid
              end
            end
          end
        end
      end

      context 'when using pending builds table' do
        let!(:runner) { create(:ci_runner, :project, projects: [project], tag_list: %w[conflict]) }

        include_examples 'handles runner assignment'

        context 'when a conflicting data is stored in denormalized table' do
          let!(:pending_job) { create(:ci_build, :pending, :queued, pipeline: pipeline, tag_list: %w[conflict]) }

          before do
            pending_job.update_column(:status, :running)
          end

          it 'removes queuing entry upon build assignment attempt' do
            expect(pending_job.reload).to be_running
            expect(pending_job.queuing_entry).to be_present

            expect(execute).not_to be_valid
            expect(pending_job.reload.queuing_entry).not_to be_present
          end
        end
      end
    end

    describe '#register_success' do
      let!(:current_time) { Time.zone.local(2018, 4, 5, 14, 0, 0) }
      let!(:attempt_counter) { double('Gitlab::Metrics::NullMetric') }
      let!(:job_queue_duration_seconds) { double('Gitlab::Metrics::NullMetric') }

      before do
        allow(Time).to receive(:now).and_return(current_time)
        # Stub tested metrics
        allow(Gitlab::Ci::Queue::Metrics)
          .to receive(:attempt_counter)
                .and_return(attempt_counter)

        allow(Gitlab::Ci::Queue::Metrics)
          .to receive(:job_queue_duration_seconds)
                .and_return(job_queue_duration_seconds)

        project.update!(shared_runners_enabled: true)
        pending_job.update!(created_at: current_time - 3600, queued_at: current_time - 1800)
      end

      shared_examples 'attempt counter collector' do
        it 'increments attempt counter' do
          allow(job_queue_duration_seconds).to receive(:observe)
          expect(attempt_counter).to receive(:increment)

          build_on(runner)
        end
      end

      shared_examples 'jobs queueing time histogram collector' do
        it 'counts job queuing time histogram with expected labels' do
          allow(attempt_counter).to receive(:increment)
          expect(job_queue_duration_seconds).to receive(:observe)
            .with({ shared_runner: expected_shared_runner,
                    jobs_running_for_project: expected_jobs_running_for_project_first_job,
                    shard: expected_shard }, 1800)

          build_on(runner)
        end

        context 'when project already has running jobs' do
          let(:build2) { create(:ci_build, :running, pipeline: pipeline, runner: shared_runner) }
          let(:build3) { create(:ci_build, :running, pipeline: pipeline, runner: shared_runner) }

          before do
            ::Ci::RunningBuild.upsert_shared_runner_build!(build2)
            ::Ci::RunningBuild.upsert_shared_runner_build!(build3)
          end

          it 'counts job queuing time histogram with expected labels' do
            allow(attempt_counter).to receive(:increment)

            expect(job_queue_duration_seconds).to receive(:observe)
              .with({ shared_runner: expected_shared_runner,
                      jobs_running_for_project: expected_jobs_running_for_project_third_job,
                      shard: expected_shard }, 1800)

            build_on(runner)
          end
        end
      end

      shared_examples 'metrics collector' do
        it_behaves_like 'attempt counter collector'
        it_behaves_like 'jobs queueing time histogram collector'
      end

      context 'when shared runner is used' do
        before do
          pending_job.reload
          pending_job.create_queuing_entry!
        end

        let(:runner) { create(:ci_runner, :instance, tag_list: %w[tag1 tag2]) }
        let(:expected_shared_runner) { true }
        let(:expected_shard) { ::Gitlab::Ci::Queue::Metrics::DEFAULT_METRICS_SHARD }
        let(:expected_jobs_running_for_project_first_job) { '0' }
        let(:expected_jobs_running_for_project_third_job) { '2' }

        it_behaves_like 'metrics collector'

        context 'when metrics_shard tag is defined' do
          let(:runner) { create(:ci_runner, :instance, tag_list: %w[tag1 metrics_shard::shard_tag tag2]) }
          let(:expected_shard) { 'shard_tag' }

          it_behaves_like 'metrics collector'
        end

        context 'when multiple metrics_shard tag is defined' do
          let(:runner) { create(:ci_runner, :instance, tag_list: %w[tag1 metrics_shard::shard_tag metrics_shard::shard_tag_2 tag2]) }
          let(:expected_shard) { 'shard_tag' }

          it_behaves_like 'metrics collector'
        end

        context 'when max running jobs bucket size is exceeded' do
          before do
            stub_const('Project::INSTANCE_RUNNER_RUNNING_JOBS_MAX_BUCKET', 1)
          end

          let(:expected_jobs_running_for_project_third_job) { '1+' }

          it_behaves_like 'metrics collector'
        end

        context 'when pending job with queued_at=nil is used' do
          before do
            pending_job.update!(queued_at: nil)
          end

          it_behaves_like 'attempt counter collector'

          it ""doesn't count job queuing time histogram"" do
            allow(attempt_counter).to receive(:increment)
            expect(job_queue_duration_seconds).not_to receive(:observe)

            build_on(runner)
          end
        end
      end

      context 'when project runner is used' do
        let(:runner) { create(:ci_runner, :project, projects: [project], tag_list: %w[tag1 metrics_shard::shard_tag tag2]) }
        let(:expected_shared_runner) { false }
        let(:expected_shard) { ::Gitlab::Ci::Queue::Metrics::DEFAULT_METRICS_SHARD }
        let(:expected_jobs_running_for_project_first_job) { '+Inf' }
        let(:expected_jobs_running_for_project_third_job) { '+Inf' }

        it_behaves_like 'metrics collector'
      end
    end

    context 'when runner_session params are' do
      it 'present sets runner session configuration in the build' do
        runner_session_params = { session: { 'url' => 'https://example.com' } }

        expect(build_on(project_runner, params: runner_session_params).runner_session.attributes)
          .to include(runner_session_params[:session])
      end

      it 'not present it does not configure the runner session' do
        expect(build_on(project_runner).runner_session).to be_nil
      end
    end

    context 'when max queue depth is reached' do
      let!(:pending_job) { create(:ci_build, :pending, :queued, :degenerated, pipeline: pipeline) }
      let!(:pending_job_2) { create(:ci_build, :pending, :queued, :degenerated, pipeline: pipeline) }
      let!(:pending_job_3) { create(:ci_build, :pending, :queued, pipeline: pipeline) }

      before do
        stub_const(""#{described_class}::MAX_QUEUE_DEPTH"", 2)
      end

      it 'returns 409 conflict' do
        expect(Ci::Build.pending.unstarted.count).to eq 3

        result = described_class.new(project_runner, nil).execute

        expect(result).not_to be_valid
        expect(result.build).to be_nil
        expect(result.build_json).to be_nil
      end
    end

    def build_on(runner, runner_manager: nil, params: {})
      described_class.new(runner, runner_manager).execute(params).build
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class ParseAnnotationsArtifactService < ::BaseService
    include ::Gitlab::Utils::StrongMemoize
    include ::Gitlab::EncodingHelper

    SizeLimitError = Class.new(StandardError)
    ParserError = Class.new(StandardError)

    def execute(artifact)
      return error('Artifact is not annotations file type', :bad_request) unless artifact&.annotations?

      return error(""Annotations Artifact Too Big. Maximum Allowable Size: #{annotations_size_limit}"", :bad_request) if
        artifact.file.size > annotations_size_limit

      annotations = parse!(artifact)
      Ci::JobAnnotation.bulk_upsert!(annotations, unique_by: %i[partition_id job_id name])

      success
    rescue SizeLimitError, ParserError, Gitlab::Json.parser_error, ActiveRecord::RecordInvalid => error
      error(error.message, :bad_request)
    end

    private

    def parse!(artifact)
      annotations = []

      artifact.each_blob do |blob|
        # Windows powershell may output UTF-16LE files, so convert the whole file
        # to UTF-8 before proceeding.
        blob = strip_bom(encode_utf8_with_replacement_character(blob))

        blob_json = Gitlab::Json.parse(blob)
        raise ParserError, 'Annotations files must be a JSON object' unless blob_json.is_a?(Hash)

        blob_json.each do |key, value|
          annotations.push(Ci::JobAnnotation.new(job: artifact.job, name: key, data: value))

          if annotations.size > annotations_num_limit
            raise SizeLimitError,
              ""Annotations files cannot have more than #{annotations_num_limit} annotation lists""
          end
        end
      end

      annotations
    end

    def annotations_num_limit
      project.actual_limits.ci_job_annotations_num
    end
    strong_memoize_attr :annotations_num_limit

    def annotations_size_limit
      project.actual_limits.ci_job_annotations_size
    end
    strong_memoize_attr :annotations_size_limit
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::ParseAnnotationsArtifactService, feature_category: :build_artifacts do
  let_it_be(:project) { create(:project) }

  let_it_be_with_reload(:build) { create(:ci_build, project: project) }
  let(:service) { described_class.new(project, nil) }

  describe '#execute' do
    subject { service.execute(artifact) }

    context 'when build has an annotations artifact' do
      let_it_be(:artifact) { create(:ci_job_artifact, :annotations, job: build) }

      context 'when artifact does not have the specified blob' do
        before do
          allow(artifact).to receive(:each_blob)
        end

        it 'parses nothing' do
          expect(subject[:status]).to eq(:success)

          expect(build.job_annotations).to be_empty
        end
      end

      context 'when artifact has the specified blob' do
        let(:blob) { data.to_json }

        before do
          allow(artifact).to receive(:each_blob).and_yield(blob)
        end

        context 'when valid annotations are given' do
          let(:data) do
            {
              external_links: [
                {
                  external_link: {
                    label: 'URL 1',
                    url: 'https://url1.example.com/'
                  }
                },
                {
                  external_link: {
                    label: 'URL 2',
                    url: 'https://url2.example.com/'
                  }
                }
              ]
            }
          end

          it 'parses the artifact' do
            subject

            expect(build.job_annotations.as_json).to contain_exactly(
              hash_including('name' => 'external_links', 'data' => [
                hash_including('external_link' => hash_including('label' => 'URL 1', 'url' => 'https://url1.example.com/')),
                hash_including('external_link' => hash_including('label' => 'URL 2', 'url' => 'https://url2.example.com/'))
              ])
            )
          end
        end

        context 'when valid annotations are given and annotation list name is the same' do
          before do
            build.job_annotations.create!(name: 'external_links', data: [
              {
                external_link: {
                  label: 'URL 1',
                  url: 'https://url1.example.com/'
                }
              }
            ])
          end

          let(:data) do
            {
              external_links: [
                {
                  external_link: {
                    label: 'URL 2',
                    url: 'https://url2.example.com/'
                  }
                }
              ]
            }
          end

          it 'parses the artifact' do
            subject

            expect(build.job_annotations.as_json).to contain_exactly(
              hash_including('name' => 'external_links', 'data' => [
                hash_including('external_link' => hash_including('label' => 'URL 2', 'url' => 'https://url2.example.com/'))
              ])
            )
          end
        end

        context 'when invalid JSON is given' do
          let(:blob) { 'Invalid JSON!' }

          it 'returns error' do
            expect(subject[:status]).to eq(:error)
            expect(subject[:http_status]).to eq(:bad_request)
          end
        end

        context 'when root is not an object' do
          let(:data) { [] }

          it 'returns error' do
            expect(subject[:status]).to eq(:error)
            expect(subject[:message]).to eq('Annotations files must be a JSON object')
            expect(subject[:http_status]).to eq(:bad_request)
          end
        end

        context 'when item is not a valid annotation list' do
          let(:data) { { external_links: {} } }

          it 'returns error' do
            expect(subject[:status]).to eq(:error)
            expect(subject[:message]).to eq('Validation failed: Data must be a valid json schema')
            expect(subject[:http_status]).to eq(:bad_request)
          end
        end

        context 'when more than limitated annotations are specified in annotations' do
          let(:data) do
            {
              external_links_1: [
                {
                  external_link: {
                    label: 'URL',
                    url: 'https://example.com/'
                  }
                }
              ],
              external_links_2: [
                {
                  external_link: {
                    label: 'URL',
                    url: 'https://example.com/'
                  }
                }
              ]
            }
          end

          before do
            allow(service).to receive(:annotations_num_limit).and_return(1)
          end

          it 'returns error' do
            expect(subject[:status]).to eq(:error)
            expect(subject[:message]).to eq(
              ""Annotations files cannot have more than #{service.send(:annotations_num_limit)} annotation lists"")
            expect(subject[:http_status]).to eq(:bad_request)
          end
        end
      end

      context 'when artifact size is too big' do
        before do
          allow(artifact.file).to receive(:size) { service.send(:annotations_size_limit) + 1.kilobyte }
        end

        it 'returns error' do
          expect(subject[:status]).to eq(:error)
          expect(subject[:message]).to eq(
            ""Annotations Artifact Too Big. Maximum Allowable Size: #{service.send(:annotations_size_limit)}"")
          expect(subject[:http_status]).to eq(:bad_request)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class ParseDotenvArtifactService < ::BaseService
    include ::Gitlab::Utils::StrongMemoize
    include ::Gitlab::EncodingHelper

    SizeLimitError = Class.new(StandardError)
    ParserError = Class.new(StandardError)

    def execute(artifact)
      validate!(artifact)

      variables = parse!(artifact)
      Ci::JobVariable.bulk_insert!(variables)

      success
    rescue SizeLimitError, ParserError, ActiveRecord::RecordInvalid, ActiveRecord::RecordNotUnique => error
      Gitlab::ErrorTracking.track_exception(error, job_id: artifact.job_id)
      error(error.message, :bad_request)
    end

    private

    def validate!(artifact)
      unless artifact&.dotenv?
        raise ArgumentError, 'Artifact is not dotenv file type'
      end

      unless artifact.file.size < dotenv_size_limit
        raise SizeLimitError,
          ""Dotenv Artifact Too Big. Maximum Allowable Size: #{dotenv_size_limit}""
      end
    end

    def parse!(artifact)
      variables = {}

      artifact.each_blob do |blob|
        # Windows powershell may output UTF-16LE files, so convert the whole file
        # to UTF-8 before proceeding.
        blob = strip_bom(encode_utf8_with_replacement_character(blob))

        blob.each_line do |line|
          key, value = scan_line!(line)

          variables[key] = Ci::JobVariable.new(
            job_id: artifact.job_id,
            source: :dotenv,
            key: key,
            value: value,
            raw: false
          )
        end
      end

      if variables.size > dotenv_variable_limit
        raise SizeLimitError,
          ""Dotenv files cannot have more than #{dotenv_variable_limit} variables""
      end

      variables.values
    end

    def scan_line!(line)
      result = line.scan(/^(.*?)=(.*)$/).last

      raise ParserError, 'Invalid Format' if result.nil?

      result.each(&:strip!)
    end

    def dotenv_variable_limit
      strong_memoize(:dotenv_variable_limit) { project.actual_limits.dotenv_variables }
    end

    def dotenv_size_limit
      strong_memoize(:dotenv_size_limit) { project.actual_limits.dotenv_size }
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::ParseDotenvArtifactService, feature_category: :build_artifacts do
  let_it_be(:project) { create(:project) }
  let_it_be(:pipeline) { create(:ci_pipeline, project: project) }

  let(:build) { create(:ci_build, pipeline: pipeline, project: project) }
  let(:service) { described_class.new(project, nil) }

  describe '#execute' do
    subject { service.execute(artifact) }

    context 'when build has a dotenv artifact' do
      let!(:artifact) { create(:ci_job_artifact, :dotenv, job: build) }

      it 'parses the artifact' do
        expect(subject[:status]).to eq(:success)

        expect(build.job_variables.as_json(only: [:key, :value])).to contain_exactly(
          hash_including('key' => 'KEY1', 'value' => 'VAR1'),
          hash_including('key' => 'KEY2', 'value' => 'VAR2'))
      end

      context 'when dotenv variables are conflicting against manual variables' do
        before do
          create(:ci_job_variable, job: build, key: 'KEY1')
        end

        it 'returns an error message that there is a duplicate variable' do
          subject

          expect(subject[:status]).to eq(:error)
          expect(subject[:message]).to include(""Key (key, job_id)=(KEY1, #{build.id}) already exists."")
          expect(subject[:http_status]).to eq(:bad_request)
        end
      end

      context 'when dotenv variables have duplicate variables' do
        let!(:artifact) { create(:ci_job_artifact, :dotenv, job: build) }
        let(:blob) do
          <<~EOS
            KEY1=VAR1
            KEY2=VAR2
            KEY2=VAR3
            KEY1=VAR4
          EOS
        end

        before do
          allow(artifact).to receive(:each_blob).and_yield(blob)
        end

        it 'latest values get used' do
          subject

          expect(subject[:status]).to eq(:success)

          expect(build.job_variables.as_json(only: [:key, :value])).to contain_exactly(
            hash_including('key' => 'KEY1', 'value' => 'VAR4'),
            hash_including('key' => 'KEY2', 'value' => 'VAR3'))
        end
      end

      context 'when parse error happens' do
        before do
          allow(service).to receive(:scan_line!) { raise described_class::ParserError, 'Invalid Format' }
        end

        it 'returns error' do
          expect(Gitlab::ErrorTracking).to receive(:track_exception)
            .with(described_class::ParserError, job_id: build.id)

          expect(subject[:status]).to eq(:error)
          expect(subject[:message]).to eq('Invalid Format')
          expect(subject[:http_status]).to eq(:bad_request)
        end
      end

      context 'when artifact size is too big' do
        before do
          allow(artifact.file).to receive(:size) { 10.kilobytes }
        end

        it 'returns error' do
          expect(subject[:status]).to eq(:error)
          expect(subject[:message]).to eq(""Dotenv Artifact Too Big. Maximum Allowable Size: #{service.send(:dotenv_size_limit)}"")
          expect(subject[:http_status]).to eq(:bad_request)
        end
      end

      context 'when artifact has the specified blob' do
        before do
          allow(artifact).to receive(:each_blob).and_yield(blob)
        end

        context 'when a white space trails the key' do
          let(:blob) { 'KEY1 =VAR1' }

          it 'trims the trailing space' do
            subject

            expect(build.job_variables.as_json(only: [:key, :value])).to contain_exactly(
              hash_including('key' => 'KEY1', 'value' => 'VAR1'))
          end
        end

        context 'when multiple key/value pairs exist in one line' do
          let(:blob) { 'KEY=VARCONTAINING=EQLS' }

          it 'parses the dotenv data' do
            subject

            expect(build.job_variables.as_json(only: [:key, :value])).to contain_exactly(
              hash_including('key' => 'KEY', 'value' => 'VARCONTAINING=EQLS'))
          end
        end

        context 'when key contains UNICODE' do
          let(:blob) { '🛹=skateboard' }

          it 'returns error' do
            expect(subject[:status]).to eq(:error)
            expect(subject[:message]).to eq(""Validation failed: Key can contain only letters, digits and '_'."")
            expect(subject[:http_status]).to eq(:bad_request)
          end
        end

        context 'when value contains UNICODE' do
          let(:blob) { 'skateboard=🛹' }

          it 'parses the dotenv data' do
            subject

            expect(build.job_variables.as_json(only: [:key, :value])).to contain_exactly(
              hash_including('key' => 'skateboard', 'value' => '🛹'))
          end
        end

        context 'when key contains a space' do
          let(:blob) { 'K E Y 1=VAR1' }

          it 'returns error' do
            expect(subject[:status]).to eq(:error)
            expect(subject[:message]).to eq(""Validation failed: Key can contain only letters, digits and '_'."")
            expect(subject[:http_status]).to eq(:bad_request)
          end
        end

        context 'when value contains a space' do
          let(:blob) { 'KEY1=V A R 1' }

          it 'parses the dotenv data' do
            subject

            expect(build.job_variables.as_json(only: [:key, :value])).to contain_exactly(
              hash_including('key' => 'KEY1', 'value' => 'V A R 1'))
          end
        end

        context 'when value is double quoated' do
          let(:blob) { 'KEY1=""VAR1""' }

          it 'parses the value as-is' do
            subject

            expect(build.job_variables.as_json(only: [:key, :value])).to contain_exactly(
              hash_including('key' => 'KEY1', 'value' => '""VAR1""'))
          end
        end

        context 'when value is single quoated' do
          let(:blob) { ""KEY1='VAR1'"" }

          it 'parses the value as-is' do
            subject

            expect(build.job_variables.as_json(only: [:key, :value])).to contain_exactly(
              hash_including('key' => 'KEY1', 'value' => ""'VAR1'""))
          end
        end

        context 'when value has white spaces in double quote' do
          let(:blob) { 'KEY1=""  VAR1  ""' }

          it 'parses the value as-is' do
            subject

            expect(build.job_variables.as_json(only: [:key, :value])).to contain_exactly(
              hash_including('key' => 'KEY1', 'value' => '""  VAR1  ""'))
          end
        end

        context 'when key is missing' do
          let(:blob) { '=VAR1' }

          it 'returns error' do
            expect(subject[:status]).to eq(:error)
            expect(subject[:message]).to match(/Key can't be blank/)
            expect(subject[:http_status]).to eq(:bad_request)
          end
        end

        context 'when value is missing' do
          let(:blob) { 'KEY1=' }

          it 'parses the dotenv data' do
            subject

            expect(build.job_variables.as_json(only: [:key, :value])).to contain_exactly(
              hash_including('key' => 'KEY1', 'value' => ''))
          end
        end

        context 'when it is not dotenv format' do
          let(:blob) { ""{ 'KEY1': 'VAR1' }"" }

          it 'returns error' do
            expect(subject[:status]).to eq(:error)
            expect(subject[:message]).to eq('Invalid Format')
            expect(subject[:http_status]).to eq(:bad_request)
          end
        end

        context 'when blob is encoded in UTF-16 LE' do
          let(:blob) { File.read(Rails.root.join('spec/fixtures/build_artifacts/dotenv_utf16_le.txt')) }

          it 'parses the dotenv data' do
            subject

            expect(build.job_variables.as_json(only: [:key, :value])).to contain_exactly(
              hash_including('key' => 'MY_ENV_VAR', 'value' => 'true'),
              hash_including('key' => 'TEST2', 'value' => 'false'))
          end
        end

        context 'when more than limitated variables are specified in dotenv' do
          let(:blob) do
            StringIO.new.tap do |s|
              (service.send(:dotenv_variable_limit) + 1).times do |i|
                s << ""KEY#{i}=VAR#{i}\n""
              end
            end.string
          end

          it 'returns error' do
            expect(subject[:status]).to eq(:error)
            expect(subject[:message]).to eq(""Dotenv files cannot have more than #{service.send(:dotenv_variable_limit)} variables"")
            expect(subject[:http_status]).to eq(:bad_request)
          end
        end

        context 'when variables are cross-referenced in dotenv' do
          let(:blob) do
            <<~EOS
              KEY1=VAR1
              KEY2=${KEY1}_Test
            EOS
          end

          it 'does not support variable expansion in dotenv parser' do
            subject

            expect(build.job_variables.as_json(only: [:key, :value])).to contain_exactly(
              hash_including('key' => 'KEY1', 'value' => 'VAR1'),
              hash_including('key' => 'KEY2', 'value' => '${KEY1}_Test'))
          end
        end

        context 'when there is an empty line' do
          let(:blob) do
            <<~EOS
              KEY1=VAR1

              KEY2=VAR2
            EOS
          end

          it 'does not support empty line in dotenv parser' do
            subject

            expect(subject[:status]).to eq(:error)
            expect(subject[:message]).to eq('Invalid Format')
            expect(subject[:http_status]).to eq(:bad_request)
          end
        end

        context 'when there is a comment' do
          let(:blob) do
            <<~EOS
              KEY1=VAR1         # This is variable
            EOS
          end

          it 'does not support comment in dotenv parser' do
            subject

            expect(build.job_variables.as_json(only: [:key, :value])).to contain_exactly(
              hash_including('key' => 'KEY1', 'value' => 'VAR1         # This is variable'))
          end
        end
      end
    end

    context 'when build does not have a dotenv artifact' do
      let!(:artifact) {}

      it 'raises an error' do
        expect { subject }.to raise_error(ArgumentError)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  # TODO: a couple of points with this approach:
  # + reuses existing architecture and reactive caching
  # - it's not a report comparison and some comparing features must be turned off.
  # see CompareReportsBaseService for more notes.
  # issue: https://gitlab.com/gitlab-org/gitlab/issues/34224
  class GenerateTerraformReportsService < CompareReportsBaseService
    def execute(base_pipeline, head_pipeline)
      {
        status: :parsed,
        key: key(base_pipeline, head_pipeline),
        data: head_pipeline.terraform_reports.plans
      }
    rescue StandardError => e
      Gitlab::ErrorTracking.track_exception(e, project_id: project.id)
      {
        status: :error,
        key: key(base_pipeline, head_pipeline),
        status_reason: _('An error occurred while fetching terraform reports.')
      }
    end

    def latest?(base_pipeline, head_pipeline, data)
      data&.fetch(:key, nil) == key(base_pipeline, head_pipeline)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::GenerateTerraformReportsService, feature_category: :infrastructure_as_code do
  let_it_be(:project) { create(:project, :repository) }

  describe '#execute' do
    let_it_be(:merge_request) { create(:merge_request, :with_terraform_reports, source_project: project) }

    subject { described_class.new(project, nil, id: merge_request.id) }

    context 'when head pipeline has terraform reports' do
      it 'returns status and data' do
        pipeline = merge_request.head_pipeline
        result = subject.execute(nil, pipeline)

        pipeline.builds.each do |build|
          expect(result).to match(
            status: :parsed,
            data: match(
              a_hash_including(build.id.to_s => hash_including(
                'create' => 0,
                'delete' => 0,
                'update' => 1,
                'job_name' => build.name
              ))
            ),
            key: an_instance_of(Array)
          )
        end
      end
    end

    context 'when head pipeline has corrupted terraform reports' do
      it 'returns a report with error messages' do
        build = create(:ci_build, pipeline: merge_request.head_pipeline, project: project)
        create(:ci_job_artifact, :terraform_with_corrupted_data, job: build, project: project)

        result = subject.execute(nil, merge_request.head_pipeline)

        expect(result).to match(
          status: :parsed,
          data: match(
            a_hash_including(build.id.to_s => hash_including(
              'tf_report_error' => :invalid_json_format
            ))
          ),
          key: an_instance_of(Array)
        )
      end
    end

    context 'when head pipeline is corrupted' do
      it 'returns status and error message' do
        result = subject.execute(nil, nil)

        expect(result).to match(
          a_hash_including(
            status: :error,
            status_reason: 'An error occurred while fetching terraform reports.'
          )
        )
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class AbortPipelinesService
    # NOTE: This call fails pipelines in bulk without running callbacks.
    # Only for pipeline abandonment scenarios (examples: project delete)
    def execute(pipelines, failure_reason)
      pipelines.cancelable.each_batch(of: 100) do |pipeline_batch|
        now = Time.current

        basic_attributes = { status: :failed }
        all_attributes = basic_attributes.merge(failure_reason: failure_reason, finished_at: now)

        bulk_fail_for(Ci::Stage, pipeline_batch, basic_attributes)
        bulk_fail_for(CommitStatus, pipeline_batch, all_attributes)

        pipeline_batch.update_all(all_attributes)
      end

      ServiceResponse.success(message: 'Pipelines stopped')
    end

    private

    def bulk_fail_for(klass, pipelines, attributes)
      klass.in_pipelines(pipelines)
        .cancelable
        .in_batches(of: 150) # rubocop:disable Cop/InBatches
        .update_all(attributes)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::AbortPipelinesService, feature_category: :continuous_integration do
  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project, namespace: user.namespace) }

  let_it_be(:cancelable_pipeline, reload: true) { create(:ci_pipeline, :running, project: project, user: user) }
  let_it_be(:manual_pipeline, reload: true) { create(:ci_pipeline, status: :manual, project: project, user: user) }
  let_it_be(:other_users_pipeline, reload: true) { create(:ci_pipeline, :running, project: project, user: create(:user)) } # not this user's pipeline

  let_it_be(:cancelable_build, reload: true) { create(:ci_build, :running, pipeline: cancelable_pipeline) }
  let_it_be(:non_cancelable_build, reload: true) { create(:ci_build, :success, pipeline: cancelable_pipeline) }
  let_it_be(:cancelable_stage, reload: true) { create(:ci_stage, name: 'stageA', status: :running, pipeline: cancelable_pipeline, project: project) }
  let_it_be(:non_cancelable_stage, reload: true) { create(:ci_stage, name: 'stageB', status: :success, pipeline: cancelable_pipeline, project: project) }

  let_it_be(:manual_pipeline_cancelable_build, reload: true) { create(:ci_build, :created, pipeline: manual_pipeline) }
  let_it_be(:manual_pipeline_non_cancelable_build, reload: true) { create(:ci_build, :manual, pipeline: manual_pipeline) }
  let_it_be(:manual_pipeline_cancelable_stage, reload: true) { create(:ci_stage, name: 'stageA', status: :created, pipeline: manual_pipeline, project: project) }
  let_it_be(:manual_pipeline_non_cancelable_stage, reload: true) { create(:ci_stage, name: 'stageB', status: :success, pipeline: manual_pipeline, project: project) }

  describe '#execute' do
    def expect_correct_pipeline_cancellations
      expect(cancelable_pipeline.finished_at).not_to be_nil
      expect(cancelable_pipeline).to be_failed

      expect(manual_pipeline.finished_at).not_to be_nil
      expect(manual_pipeline).to be_failed
    end

    def expect_correct_stage_cancellations
      expect(cancelable_pipeline.stages - [non_cancelable_stage]).to all(be_failed)
      expect(manual_pipeline.stages - [manual_pipeline_non_cancelable_stage]).to all(be_failed)

      expect(non_cancelable_stage).not_to be_failed
      expect(manual_pipeline_non_cancelable_stage).not_to be_failed
    end

    def expect_correct_build_cancellations
      expect(cancelable_build).to be_failed
      expect(cancelable_build.finished_at).not_to be_nil

      expect(manual_pipeline_cancelable_build).to be_failed
      expect(manual_pipeline_cancelable_build.finished_at).not_to be_nil

      expect(non_cancelable_build).not_to be_failed
      expect(manual_pipeline_non_cancelable_build).not_to be_failed
    end

    def expect_correct_cancellations
      expect_correct_pipeline_cancellations
      expect_correct_stage_cancellations
      expect_correct_build_cancellations
    end

    context 'with project pipelines' do
      def abort_project_pipelines
        described_class.new.execute(project.all_pipelines, :project_deleted)
      end

      it 'fails all running pipelines and related jobs' do
        expect(abort_project_pipelines).to be_success

        expect_correct_cancellations

        expect(other_users_pipeline.status).to eq('failed')
        expect(other_users_pipeline.failure_reason).to eq('project_deleted')
        expect(other_users_pipeline.stages.map(&:status)).to all(eq('failed'))
      end

      it 'avoids N+1 queries' do
        control_count = ActiveRecord::QueryRecorder.new { abort_project_pipelines }.count

        pipelines = create_list(:ci_pipeline, 5, :running, project: project)
        create_list(:ci_build, 5, :running, pipeline: pipelines.first)

        expect { abort_project_pipelines }.not_to exceed_query_limit(control_count)
      end

      context 'with live build logs' do
        before do
          create(:ci_build_trace_chunk, build: cancelable_build)
        end

        it 'makes failed builds with stale trace visible' do
          expect(Ci::Build.with_stale_live_trace.count).to eq 0

          travel_to(2.days.ago) do
            abort_project_pipelines
          end

          expect(Ci::Build.with_stale_live_trace.count).to eq 1
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  class CompareAccessibilityReportsService < CompareReportsBaseService
    def comparer_class
      Gitlab::Ci::Reports::AccessibilityReportsComparer
    end

    def serializer_class
      AccessibilityReportsComparerSerializer
    end

    def get_report(pipeline)
      pipeline&.accessibility_reports
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::CompareAccessibilityReportsService, feature_category: :continuous_integration do
  let(:service) { described_class.new(project) }
  let(:project) { create(:project, :repository) }

  describe '#execute' do
    subject { service.execute(base_pipeline, head_pipeline) }

    context 'when head pipeline has accessibility reports' do
      let(:base_pipeline) { nil }
      let(:head_pipeline) { create(:ci_pipeline, :with_accessibility_reports, project: project) }

      it 'returns status and data' do
        expect(subject[:status]).to eq(:parsed)
        expect(subject[:data]).to match_schema('entities/accessibility_reports_comparer')
      end
    end

    context 'when base and head pipelines have accessibility reports' do
      let(:base_pipeline) { create(:ci_pipeline, :with_accessibility_reports, project: project) }
      let(:head_pipeline) { create(:ci_pipeline, :with_accessibility_reports, project: project) }

      it 'returns status and data' do
        expect(subject[:status]).to eq(:parsed)
        expect(subject[:data]).to match_schema('entities/accessibility_reports_comparer')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module JobTokenScope
    class AddProjectService < ::BaseService
      include EditScopeValidations

      def execute(target_project, direction: :inbound)
        validate_edit!(project, target_project, current_user)

        link = allowlist(direction)
          .add!(target_project, user: current_user)

        ServiceResponse.success(payload: { project_link: link })

      rescue ActiveRecord::RecordNotUnique
        ServiceResponse.error(message: ""Target project is already in the job token scope"")
      rescue ActiveRecord::RecordInvalid => e
        ServiceResponse.error(message: e.message)
      rescue EditScopeValidations::ValidationError => e
        ServiceResponse.error(message: e.message)
      end

      private

      def allowlist(direction)
        Ci::JobToken::Allowlist.new(project, direction: direction)
      end
    end
  end
end

Ci::JobTokenScope::AddProjectService.prepend_mod_with('Ci::JobTokenScope::AddProjectService')

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Ci::JobTokenScope::AddProjectService, feature_category: :continuous_integration do
  let(:service) { described_class.new(project, current_user) }

  let_it_be(:project) { create(:project, ci_outbound_job_token_scope_enabled: true).tap(&:save!) }
  let_it_be(:target_project) { create(:project) }
  let_it_be(:current_user) { create(:user) }

  shared_examples 'adds project' do |context|
    it 'adds the project to the scope' do
      expect do
        expect(result).to be_success
      end.to change { Ci::JobToken::ProjectScopeLink.count }.by(1)
    end
  end

  describe '#execute' do
    subject(:result) { service.execute(target_project) }

    it_behaves_like 'editable job token scope' do
      context 'when user has permissions on source and target projects' do
        let(:resulting_direction) { result.payload.fetch(:project_link)&.direction }

        before do
          project.add_maintainer(current_user)
          target_project.add_developer(current_user)
        end

        it_behaves_like 'adds project'

        context 'when token scope is disabled' do
          before do
            project.ci_cd_settings.update!(job_token_scope_enabled: false)
          end

          it_behaves_like 'adds project'

          it 'creates an inbound link by default' do
            expect(resulting_direction).to eq('inbound')
          end

          context 'when direction is specified' do
            subject(:result) { service.execute(target_project, direction: direction) }

            context 'when the direction is outbound' do
              let(:direction) { :outbound }

              specify { expect(resulting_direction).to eq('outbound') }
            end

            context 'when the direction is inbound' do
              let(:direction) { :inbound }

              specify { expect(resulting_direction).to eq('inbound') }
            end
          end
        end
      end

      context 'when target project is same as the source project' do
        before do
          project.add_maintainer(current_user)
        end

        let(:target_project) { project }

        it_behaves_like 'returns error', ""Validation failed: Target project can't be the same as the source project""
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module JobTokenScope
    class RemoveProjectService < ::BaseService
      include EditScopeValidations

      def execute(target_project, direction)
        validate_edit!(project, target_project, current_user)

        if project == target_project
          return ServiceResponse.error(message: ""Source project cannot be removed from the job token scope"")
        end

        link = ::Ci::JobToken::ProjectScopeLink
          .with_access_direction(direction)
          .for_source_and_target(project, target_project)

        unless link
          return ServiceResponse.error(message: ""Target project is not in the job token scope"")
        end

        if link.destroy
          ServiceResponse.success
        else
          ServiceResponse.error(message: link.errors.full_messages.to_sentence, payload: { project_link: link })
        end
      rescue EditScopeValidations::ValidationError => e
        ServiceResponse.error(message: e.message, reason: :insufficient_permissions)
      end
    end
  end
end

Ci::JobTokenScope::RemoveProjectService.prepend_mod_with('Ci::JobTokenScope::RemoveProjectService')

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Ci::JobTokenScope::RemoveProjectService, feature_category: :continuous_integration do
  let(:service) { described_class.new(project, current_user) }

  let_it_be(:project) { create(:project, ci_outbound_job_token_scope_enabled: true).tap(&:save!) }
  let_it_be(:target_project) { create(:project) }
  let_it_be(:current_user) { create(:user) }

  let_it_be(:link) do
    create(:ci_job_token_project_scope_link,
      source_project: project,
      target_project: target_project)
  end

  shared_examples 'removes project' do |context|
    it 'removes the project from the scope' do
      expect do
        expect(result).to be_success
      end.to change { Ci::JobToken::ProjectScopeLink.count }.by(-1)
    end
  end

  describe '#execute' do
    subject(:result) { service.execute(target_project, :outbound) }

    it_behaves_like 'editable job token scope' do
      context 'when user has permissions on source and target project' do
        before do
          project.add_maintainer(current_user)
          target_project.add_developer(current_user)
        end

        it_behaves_like 'removes project'

        context 'when token scope is disabled' do
          before do
            project.ci_cd_settings.update!(job_token_scope_enabled: false)
          end

          it_behaves_like 'removes project'
        end
      end

      context 'when target project is same as the source project' do
        before do
          project.add_maintainer(current_user)
        end

        let(:target_project) { project }

        it_behaves_like 'returns error', ""Source project cannot be removed from the job token scope""
      end

      context 'when target project is not in the job token scope' do
        let_it_be(:target_project) { create(:project, :public) }

        before do
          project.add_maintainer(current_user)
        end

        it_behaves_like 'returns error', 'Target project is not in the job token scope'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module StuckBuilds
    class DropScheduledService
      include DropHelpers

      BUILD_SCHEDULED_OUTDATED_TIMEOUT = 1.hour

      def execute
        Gitlab::AppLogger.info ""#{self.class}: Cleaning scheduled, timed-out builds""

        drop(scheduled_timed_out_builds, failure_reason: :stale_schedule)
      end

      private

      def scheduled_timed_out_builds
        Ci::Build.scheduled.scheduled_at_before(BUILD_SCHEDULED_OUTDATED_TIMEOUT.ago)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::StuckBuilds::DropScheduledService, feature_category: :runner_fleet do
  let_it_be(:runner) { create :ci_runner }

  let!(:job) { create :ci_build, :scheduled, scheduled_at: scheduled_at, runner: runner }

  subject(:service) { described_class.new }

  context 'when job is scheduled' do
    context 'for more than an hour ago' do
      let(:scheduled_at) { 2.hours.ago }

      it_behaves_like 'job is dropped with failure reason', 'stale_schedule'
    end

    context 'for less than 1 hour ago' do
      let(:scheduled_at) { 30.minutes.ago }

      it_behaves_like 'job is unchanged'
    end
  end

  %w[success skipped failed canceled running pending].each do |status|
    context ""when job is #{status}"" do
      before do
        job.update!(status: status)
      end

      context 'and scheduled for more than an hour ago' do
        let(:scheduled_at) { 2.hours.ago }

        it_behaves_like 'job is unchanged'
      end

      context 'and scheduled for less than 1 hour ago' do
        let(:scheduled_at) { 30.minutes.ago }

        it_behaves_like 'job is unchanged'
      end
    end
  end

  context 'when there are no stale scheduled builds' do
    let(:job) {}

    it 'does not drop the stale scheduled build yet' do
      expect { service.execute }.not_to raise_error
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module StuckBuilds
    class DropPendingService
      include DropHelpers

      BUILD_PENDING_OUTDATED_TIMEOUT = 1.day
      BUILD_PENDING_STUCK_TIMEOUT = 1.hour

      def execute
        Gitlab::AppLogger.info ""#{self.class}: Cleaning pending timed-out builds""

        drop(
          pending_builds(BUILD_PENDING_OUTDATED_TIMEOUT.ago),
          failure_reason: :stuck_or_timeout_failure
        )

        drop_stuck(
          pending_builds(BUILD_PENDING_STUCK_TIMEOUT.ago),
          failure_reason: :stuck_or_timeout_failure
        )
      end

      private

      # rubocop: disable CodeReuse/ActiveRecord
      # We're adding the ordering clause by `created_at` and `project_id`
      # because we want to force the query planner to use the
      # `ci_builds_gitlab_monitor_metrics` index all the time.
      def pending_builds(timeout)
        Ci::Build
          .pending
          .created_at_before(timeout)
          .updated_at_before(timeout)
          .order(created_at: :asc, project_id: :asc)
      end
      # rubocop: enable CodeReuse/ActiveRecord
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::StuckBuilds::DropPendingService, feature_category: :runner_fleet do
  let_it_be(:runner) { create(:ci_runner) }
  let_it_be(:pipeline) { create(:ci_empty_pipeline) }
  let_it_be_with_reload(:job) do
    create(:ci_build, pipeline: pipeline, runner: runner)
  end

  let(:created_at) {}
  let(:updated_at) {}

  subject(:service) { described_class.new }

  before do
    job_attributes = { status: status }
    job_attributes[:created_at] = created_at if created_at
    job_attributes[:updated_at] = updated_at if updated_at
    job_attributes.compact!

    job.update!(job_attributes)
  end

  context 'when job is pending' do
    let(:status) { 'pending' }

    context 'when job is not stuck' do
      before do
        allow_next_found_instance_of(Ci::Build) do |build|
          allow(build).to receive(:stuck?).and_return(false)
        end
      end

      context 'when job was updated_at more than 1 day ago' do
        let(:updated_at) { 1.5.days.ago }

        context 'when created_at is the same as updated_at' do
          let(:created_at) { 1.5.days.ago }

          it_behaves_like 'job is dropped with failure reason', 'stuck_or_timeout_failure'
        end

        context 'when created_at is before updated_at' do
          let(:created_at) { 3.days.ago }

          it_behaves_like 'job is dropped with failure reason', 'stuck_or_timeout_failure'
        end
      end

      context 'when job was updated less than 1 day ago' do
        let(:updated_at) { 6.hours.ago }

        context 'when created_at is the same as updated_at' do
          let(:created_at) { 1.5.days.ago }

          it_behaves_like 'job is unchanged'
        end

        context 'when created_at is before updated_at' do
          let(:created_at) { 3.days.ago }

          it_behaves_like 'job is unchanged'
        end
      end

      context 'when job was updated more than 1 hour ago' do
        let(:updated_at) { 2.hours.ago }

        context 'when created_at is the same as updated_at' do
          let(:created_at) { 2.hours.ago }

          it_behaves_like 'job is unchanged'
        end

        context 'when created_at is before updated_at' do
          let(:created_at) { 3.days.ago }

          it_behaves_like 'job is unchanged'
        end
      end
    end

    context 'when job is stuck' do
      before do
        allow_next_found_instance_of(Ci::Build) do |build|
          allow(build).to receive(:stuck?).and_return(true)
        end
      end

      context 'when job was updated_at more than 1 hour ago' do
        let(:updated_at) { 1.5.hours.ago }

        context 'when created_at is the same as updated_at' do
          let(:created_at) { 1.5.hours.ago }

          it_behaves_like 'job is dropped with failure reason', 'stuck_or_timeout_failure'
        end

        context 'when created_at is before updated_at' do
          let(:created_at) { 3.days.ago }

          it_behaves_like 'job is dropped with failure reason', 'stuck_or_timeout_failure'
        end
      end

      context 'when job was updated in less than 1 hour ago' do
        let(:updated_at) { 30.minutes.ago }

        context 'when created_at is the same as updated_at' do
          let(:created_at) { 30.minutes.ago }

          it_behaves_like 'job is unchanged'
        end

        context 'when created_at is before updated_at' do
          let(:created_at) { 2.days.ago }

          it_behaves_like 'job is unchanged'
        end
      end
    end
  end

  context 'when job is running' do
    let(:status) { 'running' }

    context 'when job was updated_at more than an hour ago' do
      let(:updated_at) { 2.hours.ago }

      it_behaves_like 'job is unchanged'
    end

    context 'when job was updated in less than 1 hour ago' do
      let(:updated_at) { 30.minutes.ago }

      it_behaves_like 'job is unchanged'
    end
  end

  %w[success skipped failed canceled].each do |status|
    context ""when job is #{status}"" do
      let(:status) { status }
      let(:updated_at) { 2.days.ago }

      context 'when created_at is the same as updated_at' do
        let(:created_at) { 2.days.ago }

        it_behaves_like 'job is unchanged'
      end

      context 'when created_at is before updated_at' do
        let(:created_at) { 3.days.ago }

        it_behaves_like 'job is unchanged'
      end
    end
  end

  context 'for deleted project' do
    let(:status) { 'running' }
    let(:updated_at) { 2.days.ago }

    before do
      job.project.update!(pending_delete: true)
    end

    it_behaves_like 'job is unchanged'
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module StuckBuilds
    class DropRunningService
      include DropHelpers

      BUILD_RUNNING_OUTDATED_TIMEOUT = 1.hour

      def execute
        Gitlab::AppLogger.info ""#{self.class}: Cleaning running, timed-out builds""

        drop(running_timed_out_builds, failure_reason: :stuck_or_timeout_failure)
      end

      private

      def running_timed_out_builds
        if Feature.enabled?(:ci_new_query_for_running_stuck_jobs)
          Ci::Build
            .running
            .created_at_before(BUILD_RUNNING_OUTDATED_TIMEOUT.ago)
            .updated_at_before(BUILD_RUNNING_OUTDATED_TIMEOUT.ago)
            .order(created_at: :asc, project_id: :asc) # rubocop:disable CodeReuse/ActiveRecord
        else
          Ci::Build.running.updated_at_before(BUILD_RUNNING_OUTDATED_TIMEOUT.ago)
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::StuckBuilds::DropRunningService, feature_category: :runner_fleet do
  let!(:runner) { create :ci_runner }
  let!(:job) { create(:ci_build, runner: runner, created_at: created_at, updated_at: updated_at, status: status) }

  subject(:service) { described_class.new }

  around do |example|
    freeze_time { example.run }
  end

  shared_examples 'running builds' do
    context 'when job is running' do
      let(:status) { 'running' }
      let(:outdated_time) { described_class::BUILD_RUNNING_OUTDATED_TIMEOUT.ago - 30.minutes }
      let(:fresh_time) { described_class::BUILD_RUNNING_OUTDATED_TIMEOUT.ago + 30.minutes }

      context 'when job is outdated' do
        let(:created_at) { outdated_time }
        let(:updated_at) { outdated_time }

        it_behaves_like 'job is dropped with failure reason', 'stuck_or_timeout_failure'
      end

      context 'when job is fresh' do
        let(:created_at) { fresh_time }
        let(:updated_at) { fresh_time }

        it_behaves_like 'job is unchanged'
      end

      context 'when job freshly updated' do
        let(:created_at) { outdated_time }
        let(:updated_at) { fresh_time }

        it_behaves_like 'job is unchanged'
      end
    end
  end

  include_examples 'running builds'

  context 'when new query flag is disabled' do
    before do
      stub_feature_flags(ci_new_query_for_running_stuck_jobs: false)
    end

    include_examples 'running builds'
  end

  %w[success skipped failed canceled scheduled pending].each do |status|
    context ""when job is #{status}"" do
      let(:status) { status }
      let(:updated_at) { 2.days.ago }

      context 'when created_at is the same as updated_at' do
        let(:created_at) { 2.days.ago }

        it_behaves_like 'job is unchanged'
      end

      context 'when created_at is before updated_at' do
        let(:created_at) { 3.days.ago }

        it_behaves_like 'job is unchanged'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module ResourceGroups
    class AssignResourceFromResourceGroupService < ::BaseService
      # rubocop: disable CodeReuse/ActiveRecord
      def execute(resource_group)
        release_resource_from_stale_jobs(resource_group)

        free_resources = resource_group.resources.free.count

        resource_group.upcoming_processables.take(free_resources).each do |upcoming|
          Gitlab::OptimisticLocking.retry_lock(upcoming, name: 'enqueue_waiting_for_resource') do |processable|
            processable.enqueue_waiting_for_resource
          end
        end
      end
      # rubocop: enable CodeReuse/ActiveRecord

      private

      def release_resource_from_stale_jobs(resource_group)
        resource_group.resources.stale_processables.find_each do |processable|
          resource_group.release_resource_from(processable)
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::ResourceGroups::AssignResourceFromResourceGroupService, feature_category: :continuous_integration do
  include ConcurrentHelpers

  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }

  let(:service) { described_class.new(project, user) }

  describe '#execute' do
    subject { service.execute(resource_group) }

    let(:resource_group) { create(:ci_resource_group, project: project) }
    let!(:build) { create(:ci_build, :waiting_for_resource, project: project, user: user, resource_group: resource_group) }

    context 'when there is an available resource' do
      it 'requests resource' do
        subject

        expect(build.reload).to be_pending
        expect(build.resource).to be_present
      end

      context 'when failed to request resource' do
        before do
          allow_next_instance_of(Ci::Build) do |build|
            allow(build).to receive(:enqueue_waiting_for_resource) { false }
          end
        end

        it 'has a build waiting for resource' do
          subject

          expect(build).to be_waiting_for_resource
        end
      end

      context 'when the build has already retained a resource' do
        before do
          resource_group.assign_resource_to(build)
          build.update_column(:status, :pending)
        end

        it 'has a pending build' do
          subject

          expect(build).to be_pending
        end
      end

      context 'when process mode is oldest_first' do
        let(:resource_group) { create(:ci_resource_group, process_mode: :oldest_first, project: project) }

        it 'requests resource' do
          subject

          expect(build.reload).to be_pending
          expect(build.resource).to be_present
        end

        context 'when the other job exists in the newer pipeline' do
          let!(:build_2) { create(:ci_build, :waiting_for_resource, project: project, user: user, resource_group: resource_group) }

          it 'requests resource for the job in the oldest pipeline' do
            subject

            expect(build.reload).to be_pending
            expect(build.resource).to be_present
            expect(build_2.reload).to be_waiting_for_resource
            expect(build_2.resource).to be_nil
          end
        end

        context 'when build is not `waiting_for_resource` state' do
          let!(:build) { create(:ci_build, :created, project: project, user: user, resource_group: resource_group) }

          it 'attempts to request a resource' do
            expect_next_found_instance_of(Ci::Build) do |job|
              expect(job).to receive(:enqueue_waiting_for_resource).and_call_original
            end

            subject
          end

          it 'does not change the job status' do
            subject

            expect(build.reload).to be_created
            expect(build.resource).to be_nil
          end
        end
      end

      context 'when process mode is newest_first' do
        let(:resource_group) { create(:ci_resource_group, process_mode: :newest_first, project: project) }

        it 'requests resource' do
          subject

          expect(build.reload).to be_pending
          expect(build.resource).to be_present
        end

        context 'when the other job exists in the newer pipeline' do
          let!(:build_2) { create(:ci_build, :waiting_for_resource, project: project, user: user, resource_group: resource_group) }

          it 'requests resource for the job in the newest pipeline' do
            subject

            expect(build.reload).to be_waiting_for_resource
            expect(build.resource).to be_nil
            expect(build_2.reload).to be_pending
            expect(build_2.resource).to be_present
          end
        end

        context 'when build is not `waiting_for_resource` state' do
          let!(:build) { create(:ci_build, :created, project: project, user: user, resource_group: resource_group) }

          it 'attempts to request a resource' do
            expect_next_found_instance_of(Ci::Build) do |job|
              expect(job).to receive(:enqueue_waiting_for_resource).and_call_original
            end

            subject
          end

          it 'does not change the job status' do
            subject

            expect(build.reload).to be_created
            expect(build.resource).to be_nil
          end
        end
      end

      context 'when parallel services are running' do
        it 'can run the same command in parallel' do
          parallel_num = 4

          blocks = Array.new(parallel_num).map do
            -> { subject }
          end

          run_parallel(blocks)
          expect(build.reload).to be_pending
        end
      end
    end

    context 'when there are no available resources' do
      let!(:other_build) { create(:ci_build) }

      before do
        resource_group.assign_resource_to(other_build)
      end

      it 'does not request resource' do
        expect_any_instance_of(Ci::Build).not_to receive(:enqueue_waiting_for_resource)

        subject

        expect(build.reload).to be_waiting_for_resource
      end

      context 'when there is a stale build assigned to a resource' do
        before do
          other_build.doom!
          other_build.update_column(:updated_at, 10.minutes.ago)
        end

        it 'releases the resource from the stale build and assignes to the waiting build' do
          subject

          expect(build.reload).to be_pending
          expect(build.resource).to be_present
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module PipelineProcessing
    class AtomicProcessingService
      include Gitlab::Utils::StrongMemoize
      include ExclusiveLeaseGuard

      attr_reader :pipeline

      DEFAULT_LEASE_TIMEOUT = 1.minute
      BATCH_SIZE = 20

      def initialize(pipeline)
        @pipeline = pipeline
        @collection = AtomicProcessingService::StatusCollection.new(pipeline)
      end

      def execute
        return unless pipeline.needs_processing?

        # Run the process only if we can obtain an exclusive lease; returns nil if lease is unavailable
        success = try_obtain_lease { process! }

        if success
          # If any jobs changed from stopped to alive status during pipeline processing, we must
          # re-reset their dependent jobs; see https://gitlab.com/gitlab-org/gitlab/-/issues/388539.
          new_alive_jobs.group_by(&:user).each do |user, jobs|
            log_running_reset_skipped_jobs_service(jobs)

            ResetSkippedJobsService.new(project, user).execute(jobs)
          end

          # Re-schedule if we need further processing
          PipelineProcessWorker.perform_async(pipeline.id) if pipeline.needs_processing?
        end

        success
      end

      private

      def process!
        update_stages!
        update_pipeline!
        update_jobs_processed!

        Ci::ExpirePipelineCacheService.new.execute(pipeline)

        true
      end

      def update_stages!
        pipeline.stages.ordered.each { |stage| update_stage!(stage) }
      end

      def update_stage!(stage)
        # Update jobs for a given stage in bulk/slices
        @collection
          .created_job_ids_in_stage(stage.position)
          .in_groups_of(BATCH_SIZE, false) { |ids| update_jobs!(ids) }

        status = @collection.status_of_stage(stage.position)
        stage.set_status(status)
      end

      def update_jobs!(ids)
        created_jobs = pipeline
          .current_processable_jobs
          .id_in(ids)
          .with_project_preload
          .created
          .ordered_by_stage
          .select_with_aggregated_needs(project)

        created_jobs.each { |job| update_job!(job) }
      end

      def update_pipeline!
        pipeline.set_status(@collection.status_of_all)
      end

      def update_jobs_processed!
        processing = @collection.processing_jobs
        processing.each_slice(BATCH_SIZE) do |slice|
          pipeline.all_jobs.match_id_and_lock_version(slice)
            .update_as_processed!
        end
      end

      def update_job!(job)
        previous_status = status_of_previous_jobs(job)
        # We do not continue to process the job if the previous status is not completed
        return unless Ci::HasStatus::COMPLETED_STATUSES.include?(previous_status)

        ::Deployments::CreateForJobService.new.execute(job)

        Gitlab::OptimisticLocking.retry_lock(job, name: 'atomic_processing_update_job') do |subject|
          Ci::ProcessBuildService.new(project, subject.user)
            .execute(subject, previous_status)

          # update internal representation of job
          # to make the status change of job to be taken into account during further processing
          @collection.set_job_status(job.id, job.status, job.lock_version)
        end
      end

      def status_of_previous_jobs(job)
        if job.scheduling_type_dag?
          # job uses DAG, get status of all dependent needs
          @collection.status_of_jobs(job.aggregated_needs_names.to_a)
        else
          # job uses Stages, get status of prior stage
          @collection.status_of_jobs_prior_to_stage(job.stage_idx.to_i)
        end
      end

      # Gets the jobs that changed from stopped to alive status since the initial status collection
      # was evaluated. We determine this by checking if their current status is no longer stopped.
      def new_alive_jobs
        initial_stopped_job_names = @collection.stopped_job_names

        return [] if initial_stopped_job_names.empty?

        new_collection = AtomicProcessingService::StatusCollection.new(pipeline)
        new_alive_job_names = initial_stopped_job_names - new_collection.stopped_job_names

        return [] if new_alive_job_names.empty?

        pipeline
          .current_jobs
          .by_name(new_alive_job_names)
          .preload(:user) # rubocop: disable CodeReuse/ActiveRecord
          .to_a
      end

      def project
        pipeline.project
      end

      def lease_key
        ""#{super}::pipeline_id:#{pipeline.id}""
      end

      def lease_timeout
        DEFAULT_LEASE_TIMEOUT
      end

      def lease_taken_log_level
        :info
      end

      def log_running_reset_skipped_jobs_service(jobs)
        Gitlab::AppJsonLogger.info(
          class: self.class.name.to_s,
          message: 'Running ResetSkippedJobsService on new alive jobs',
          project_id: project.id,
          pipeline_id: pipeline.id,
          user_id: jobs.first.user.id,
          jobs_count: jobs.count
        )
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::PipelineProcessing::AtomicProcessingService, feature_category: :continuous_integration do
  include RepoHelpers
  include ExclusiveLeaseHelpers

  describe 'Pipeline Processing Service Tests With Yaml' do
    let_it_be(:project) { create(:project, :repository) }
    let_it_be(:user)    { project.first_owner }

    where(:test_file_path) do
      Dir.glob(Rails.root.join('spec/services/ci/pipeline_processing/test_cases/*.yml'))
    end

    with_them do
      let(:test_file) { YAML.load_file(test_file_path) }
      let(:pipeline) { Ci::CreatePipelineService.new(project, user, ref: 'master').execute(:pipeline).payload }

      before do
        stub_ci_pipeline_yaml_file(YAML.dump(test_file['config']))
      end

      it 'follows transitions' do
        expect(pipeline).to be_persisted
        Sidekiq::Worker.drain_all # ensure that all async jobs are executed
        check_expectation(test_file.dig('init', 'expect'), ""init"")

        test_file['transitions'].each_with_index do |transition, idx|
          process_events(transition)
          Sidekiq::Worker.drain_all # ensure that all async jobs are executed
          check_expectation(transition['expect'], ""transition:#{idx}"")
        end
      end

      private

      def check_expectation(expectation, message)
        expect(current_state.deep_stringify_keys).to eq(expectation), message
      end

      def current_state
        # reload pipeline and all relations
        pipeline.reload

        {
          pipeline: pipeline.status,
          stages: pipeline.stages.pluck(:name, :status).to_h,
          jobs: pipeline.latest_statuses.pluck(:name, :status).to_h
        }
      end

      def process_events(transition)
        if transition['jobs']
          event_on_jobs(transition['event'], transition['jobs'])
        else
          event_on_pipeline(transition['event'])
        end
      end

      def event_on_jobs(event, job_names)
        jobs = pipeline.latest_statuses.by_name(job_names).to_a
        expect(jobs.count).to eq(job_names.count) # ensure that we have the same counts

        jobs.each do |job|
          case event
          when 'play'
            job.play(user)
          when 'retry'
            ::Ci::RetryJobService.new(project, user).execute(job)
          else
            job.public_send(""#{event}!"")
          end
        end
      end

      def event_on_pipeline(event)
        if event == 'retry'
          pipeline.retry_failed(user)
        else
          pipeline.public_send(""#{event}!"")
        end
      end
    end
  end

  describe 'Pipeline Processing Service' do
    let(:project) { create(:project, :repository) }
    let(:user)    { project.first_owner }

    let(:pipeline) do
      create(:ci_empty_pipeline, ref: 'master', project: project)
    end

    context 'when simple pipeline is defined' do
      before do
        create_build('linux', stage_idx: 0)
        create_build('mac', stage_idx: 0)
        create_build('rspec', stage_idx: 1)
        create_build('rubocop', stage_idx: 1)
        create_build('deploy', stage_idx: 2)
      end

      it 'processes a pipeline', :sidekiq_inline do
        expect(process_pipeline).to be_truthy

        succeed_pending

        expect(builds.success.count).to eq(2)

        succeed_pending

        expect(builds.success.count).to eq(4)

        succeed_pending

        expect(builds.success.count).to eq(5)
      end

      it 'does not process pipeline if existing stage is running' do
        expect(process_pipeline).to be_truthy
        expect(builds.pending.count).to eq(2)

        expect(process_pipeline).to be_falsey
        expect(builds.pending.count).to eq(2)
      end
    end

    context 'custom stage with first job allowed to fail' do
      before do
        create_build('clean_job', stage_idx: 0, allow_failure: true)
        create_build('test_job', stage_idx: 1, allow_failure: true)
      end

      it 'automatically triggers a next stage when build finishes', :sidekiq_inline do
        expect(process_pipeline).to be_truthy
        expect(builds_statuses).to eq ['pending']

        fail_running_or_pending

        expect(builds_statuses).to eq %w[failed pending]

        fail_running_or_pending

        expect(pipeline.reload).to be_success
      end
    end

    context 'when optional manual actions are defined', :sidekiq_inline do
      before do
        create_build('build', stage_idx: 0)
        create_build('test', stage_idx: 1)
        create_build('test_failure', stage_idx: 2, when: 'on_failure')
        create_build('deploy', stage_idx: 3)
        create_build('production', stage_idx: 3, when: 'manual', allow_failure: true)
        create_build('cleanup', stage_idx: 4, when: 'always')
        create_build('clear:cache', stage_idx: 4, when: 'manual', allow_failure: true)
      end

      context 'when builds are successful' do
        it 'properly processes the pipeline' do
          expect(process_pipeline).to be_truthy
          expect(builds_names).to eq ['build']
          expect(builds_statuses).to eq ['pending']

          succeed_running_or_pending

          expect(builds_names).to eq %w[build test]
          expect(builds_statuses).to eq %w[success pending]

          succeed_running_or_pending

          expect(builds_names).to eq %w[build test deploy production]
          expect(builds_statuses).to eq %w[success success pending manual]

          succeed_running_or_pending

          expect(builds_names).to eq %w[build test deploy production cleanup clear:cache]
          expect(builds_statuses).to eq %w[success success success manual pending manual]

          succeed_running_or_pending

          expect(builds_statuses).to eq %w[success success success manual success manual]
          expect(pipeline.reload.status).to eq 'success'
        end
      end

      context 'when test job fails' do
        it 'properly processes the pipeline' do
          expect(process_pipeline).to be_truthy
          expect(builds_names).to eq ['build']
          expect(builds_statuses).to eq ['pending']

          succeed_running_or_pending

          expect(builds_names).to eq %w[build test]
          expect(builds_statuses).to eq %w[success pending]

          fail_running_or_pending

          expect(builds_names).to eq %w[build test test_failure]
          expect(builds_statuses).to eq %w[success failed pending]

          succeed_running_or_pending

          expect(builds_names).to eq %w[build test test_failure cleanup]
          expect(builds_statuses).to eq %w[success failed success pending]

          succeed_running_or_pending

          expect(builds_statuses).to eq %w[success failed success success]
          expect(pipeline.reload.status).to eq 'failed'
        end
      end

      context 'when test and test_failure jobs fail' do
        it 'properly processes the pipeline' do
          expect(process_pipeline).to be_truthy
          expect(builds_names).to eq ['build']
          expect(builds_statuses).to eq ['pending']

          succeed_running_or_pending

          expect(builds_names).to eq %w[build test]
          expect(builds_statuses).to eq %w[success pending]

          fail_running_or_pending

          expect(builds_names).to eq %w[build test test_failure]
          expect(builds_statuses).to eq %w[success failed pending]

          fail_running_or_pending

          expect(builds_names).to eq %w[build test test_failure cleanup]
          expect(builds_statuses).to eq %w[success failed failed pending]

          succeed_running_or_pending

          expect(builds_names).to eq %w[build test test_failure cleanup]
          expect(builds_statuses).to eq %w[success failed failed success]
          expect(pipeline.reload.status).to eq('failed')
        end
      end

      context 'when deploy job fails' do
        it 'properly processes the pipeline' do
          expect(process_pipeline).to be_truthy
          expect(builds_names).to eq ['build']
          expect(builds_statuses).to eq ['pending']

          succeed_running_or_pending

          expect(builds_names).to eq %w[build test]
          expect(builds_statuses).to eq %w[success pending]

          succeed_running_or_pending

          expect(builds_names).to eq %w[build test deploy production]
          expect(builds_statuses).to eq %w[success success pending manual]

          fail_running_or_pending

          expect(builds_names).to eq %w[build test deploy production cleanup]
          expect(builds_statuses).to eq %w[success success failed manual pending]

          succeed_running_or_pending

          expect(builds_statuses).to eq %w[success success failed manual success]
          expect(pipeline.reload).to be_failed
        end
      end

      context 'when build is canceled in the second stage' do
        it 'does not schedule builds after build has been canceled' do
          expect(process_pipeline).to be_truthy
          expect(builds_names).to eq ['build']
          expect(builds_statuses).to eq ['pending']

          succeed_running_or_pending

          expect(builds.running_or_pending).not_to be_empty
          expect(builds_names).to eq %w[build test]
          expect(builds_statuses).to eq %w[success pending]

          cancel_running_or_pending

          expect(builds.running_or_pending).to be_empty
          expect(builds_names).to eq %w[build test]
          expect(builds_statuses).to eq %w[success canceled]
          expect(pipeline.reload).to be_canceled
        end
      end

      context 'when listing optional manual actions' do
        it 'returns only for skipped builds' do
          # currently all builds are created
          expect(process_pipeline).to be_truthy
          expect(manual_actions).to be_empty

          # succeed stage build
          succeed_running_or_pending

          expect(manual_actions).to be_empty

          # succeed stage test
          succeed_running_or_pending

          expect(manual_actions).to be_one # production

          # succeed stage deploy
          succeed_running_or_pending

          expect(manual_actions).to be_many # production and clear cache
        end
      end
    end

    context 'when delayed jobs are defined', :sidekiq_inline do
      context 'when the scene is timed incremental rollout' do
        before do
          create_build('build', stage_idx: 0)
          create_build('rollout10%', **delayed_options, stage_idx: 1)
          create_build('rollout100%', **delayed_options, stage_idx: 2)
          create_build('cleanup', stage_idx: 3)

          allow(Ci::BuildScheduleWorker).to receive(:perform_at)
        end

        context 'when builds are successful' do
          it 'properly processes the pipeline' do
            expect(process_pipeline).to be_truthy
            expect(builds_names_and_statuses).to eq({ 'build': 'pending' })

            succeed_pending

            expect(builds_names_and_statuses).to eq({ 'build': 'success', 'rollout10%': 'scheduled' })

            travel_to 2.minutes.from_now do
              enqueue_scheduled('rollout10%')
            end
            succeed_pending

            expect(builds_names_and_statuses).to eq({ 'build': 'success', 'rollout10%': 'success', 'rollout100%': 'scheduled' })

            travel_to 2.minutes.from_now do
              enqueue_scheduled('rollout100%')
            end
            succeed_pending

            expect(builds_names_and_statuses).to eq({ 'build': 'success', 'rollout10%': 'success', 'rollout100%': 'success', 'cleanup': 'pending' })

            succeed_pending

            expect(builds_names_and_statuses).to eq({ 'build': 'success', 'rollout10%': 'success', 'rollout100%': 'success', 'cleanup': 'success' })
            expect(pipeline.reload.status).to eq 'success'
          end
        end

        context 'when build job fails' do
          it 'properly processes the pipeline' do
            expect(process_pipeline).to be_truthy
            expect(builds_names_and_statuses).to eq({ 'build': 'pending' })

            fail_running_or_pending

            expect(builds_names_and_statuses).to eq({ 'build': 'failed' })
            expect(pipeline.reload.status).to eq 'failed'
          end
        end

        context 'when rollout 10% is unscheduled' do
          it 'properly processes the pipeline' do
            expect(process_pipeline).to be_truthy
            expect(builds_names_and_statuses).to eq({ 'build': 'pending' })

            succeed_pending

            expect(builds_names_and_statuses).to eq({ 'build': 'success', 'rollout10%': 'scheduled' })

            unschedule

            expect(builds_names_and_statuses).to eq({ 'build': 'success', 'rollout10%': 'manual' })
            expect(pipeline.reload.status).to eq 'manual'
          end

          context 'when user plays rollout 10%' do
            it 'schedules rollout100%' do
              process_pipeline
              succeed_pending
              unschedule
              play_manual_action('rollout10%')
              succeed_pending

              expect(builds_names_and_statuses).to eq({ 'build': 'success', 'rollout10%': 'success', 'rollout100%': 'scheduled' })
              expect(pipeline.reload.status).to eq 'scheduled'
            end
          end
        end

        context 'when rollout 10% fails' do
          it 'properly processes the pipeline' do
            expect(process_pipeline).to be_truthy
            expect(builds_names_and_statuses).to eq({ 'build': 'pending' })

            succeed_pending

            expect(builds_names_and_statuses).to eq({ 'build': 'success', 'rollout10%': 'scheduled' })

            travel_to 2.minutes.from_now do
              enqueue_scheduled('rollout10%')
            end
            fail_running_or_pending

            expect(builds_names_and_statuses).to eq({ 'build': 'success', 'rollout10%': 'failed' })
            expect(pipeline.reload.status).to eq 'failed'
          end

          context 'when user retries rollout 10%' do
            it 'does not schedule rollout10% again' do
              process_pipeline
              succeed_pending
              enqueue_scheduled('rollout10%')
              fail_running_or_pending
              retry_build('rollout10%')

              expect(builds_names_and_statuses).to eq({ 'build': 'success', 'rollout10%': 'pending' })
              expect(pipeline.reload.status).to eq 'running'
            end
          end
        end

        context 'when rollout 10% is played immidiately' do
          it 'properly processes the pipeline' do
            expect(process_pipeline).to be_truthy
            expect(builds_names_and_statuses).to eq({ 'build': 'pending' })

            succeed_pending

            expect(builds_names_and_statuses).to eq({ 'build': 'success', 'rollout10%': 'scheduled' })

            play_manual_action('rollout10%')

            expect(builds_names_and_statuses).to eq({ 'build': 'success', 'rollout10%': 'pending' })
            expect(pipeline.reload.status).to eq 'running'
          end
        end
      end

      context 'when only one scheduled job exists in a pipeline' do
        before do
          create_build('delayed', **delayed_options, stage_idx: 0)

          allow(Ci::BuildScheduleWorker).to receive(:perform_at)
        end

        it 'properly processes the pipeline' do
          expect(process_pipeline).to be_truthy
          expect(builds_names_and_statuses).to eq({ 'delayed': 'scheduled' })

          expect(pipeline.reload.status).to eq 'scheduled'
        end
      end

      context 'when there are two delayed jobs in a stage' do
        before do
          create_build('delayed1', **delayed_options, stage_idx: 0)
          create_build('delayed2', **delayed_options, stage_idx: 0)
          create_build('job', stage_idx: 1)

          allow(Ci::BuildScheduleWorker).to receive(:perform_at)
        end

        it 'blocks the stage until all scheduled jobs finished' do
          expect(process_pipeline).to be_truthy
          expect(builds_names_and_statuses).to eq({ 'delayed1': 'scheduled', 'delayed2': 'scheduled' })

          travel_to 2.minutes.from_now do
            enqueue_scheduled('delayed1')
          end

          expect(builds_names_and_statuses).to eq({ 'delayed1': 'pending', 'delayed2': 'scheduled' })
          expect(pipeline.reload.status).to eq 'running'
        end
      end

      context 'when a delayed job is allowed to fail' do
        before do
          create_build('delayed', **delayed_options, allow_failure: true, stage_idx: 0)
          create_build('job', stage_idx: 1)

          allow(Ci::BuildScheduleWorker).to receive(:perform_at)
        end

        it 'blocks the stage and continues after it failed' do
          expect(process_pipeline).to be_truthy
          expect(builds_names_and_statuses).to eq({ 'delayed': 'scheduled' })

          travel_to 2.minutes.from_now do
            enqueue_scheduled('delayed')
          end
          fail_running_or_pending

          expect(builds_names_and_statuses).to eq({ 'delayed': 'failed', 'job': 'pending' })
          expect(pipeline.reload.status).to eq 'pending'
        end
      end
    end

    context 'when an exception is raised during a persistent ref creation' do
      before do
        successful_build('test', stage_idx: 0)

        allow_next_instance_of(Ci::PersistentRef) do |instance|
          allow(instance).to receive(:delete_refs) { raise ArgumentError }
        end
      end

      it 'process the pipeline' do
        expect { process_pipeline }.not_to raise_error
      end
    end

    context 'when there are manual action in earlier stages' do
      context 'when first stage has only optional manual actions' do
        before do
          create_build('build', stage_idx: 0, when: 'manual', allow_failure: true)
          create_build('check', stage_idx: 1)
          create_build('test', stage_idx: 2)

          process_pipeline
        end

        it 'starts from the second stage' do
          expect(all_builds_statuses).to eq %w[manual pending created]
        end
      end

      context 'when second stage has only optional manual actions' do
        before do
          create_build('check', stage_idx: 0)
          create_build('build', stage_idx: 1, when: 'manual', allow_failure: true)
          create_build('test', stage_idx: 2)

          process_pipeline
        end

        it 'skips second stage and continues on third stage', :sidekiq_inline do
          expect(all_builds_statuses).to eq(%w[pending created created])

          builds.first.success

          expect(all_builds_statuses).to eq(%w[success manual pending])
        end
      end
    end

    context 'when there are only manual actions in stages' do
      before do
        create_build('image', stage_idx: 0, when: 'manual', allow_failure: true)
        create_build('build', stage_idx: 1, when: 'manual', allow_failure: true)
        create_build('deploy', stage_idx: 2, when: 'manual')
        create_build('check', stage_idx: 3)

        process_pipeline
      end

      it 'processes all jobs until blocking actions encountered' do
        expect(all_builds_statuses).to eq(%w[manual manual manual created])
        expect(all_builds_names).to eq(%w[image build deploy check])

        expect(pipeline.reload).to be_blocked
      end
    end

    context 'when there is only one manual action' do
      before do
        create_build('deploy', stage_idx: 0, when: 'manual', allow_failure: true)

        process_pipeline
      end

      it 'skips the pipeline' do
        expect(pipeline.reload).to be_skipped
      end

      context 'when the action was played' do
        before do
          play_manual_action('deploy')
        end

        it 'queues the action and pipeline', :sidekiq_inline do
          expect(all_builds_statuses).to eq(%w[pending])

          expect(pipeline.reload).to be_pending
        end
      end
    end

    context 'when blocking manual actions are defined', :sidekiq_inline do
      before do
        create_build('code:test', stage_idx: 0)
        create_build('staging:deploy', stage_idx: 1, when: 'manual')
        create_build('staging:test', stage_idx: 2, when: 'on_success')
        create_build('production:deploy', stage_idx: 3, when: 'manual')
        create_build('production:test', stage_idx: 4, when: 'always')
      end

      context 'when first stage succeeds' do
        it 'blocks pipeline on stage with first manual action' do
          process_pipeline

          expect(builds_names).to eq %w[code:test]
          expect(builds_statuses).to eq %w[pending]
          expect(pipeline.reload.status).to eq 'pending'

          succeed_running_or_pending

          expect(builds_names).to eq %w[code:test staging:deploy]
          expect(builds_statuses).to eq %w[success manual]
          expect(pipeline.reload).to be_manual
        end
      end

      context 'when first stage fails' do
        it 'does not take blocking action into account' do
          process_pipeline

          expect(builds_names).to eq %w[code:test]
          expect(builds_statuses).to eq %w[pending]
          expect(pipeline.reload.status).to eq 'pending'

          fail_running_or_pending

          expect(builds_names).to eq %w[code:test production:test]
          expect(builds_statuses).to eq %w[failed pending]

          succeed_running_or_pending

          expect(builds_statuses).to eq %w[failed success]
          expect(pipeline.reload).to be_failed
        end
      end

      context 'when pipeline is promoted sequentially up to the end' do
        before do
          # Users need ability to merge into a branch in order to trigger
          # protected manual actions.
          #
          create(:protected_branch, :developers_can_merge, name: 'master', project: project)
        end

        it 'properly processes entire pipeline' do
          process_pipeline

          expect(builds_names).to eq %w[code:test]
          expect(builds_statuses).to eq %w[pending]

          succeed_running_or_pending

          expect(builds_names).to eq %w[code:test staging:deploy]
          expect(builds_statuses).to eq %w[success manual]
          expect(pipeline.reload).to be_manual

          play_manual_action('staging:deploy')

          expect(builds_statuses).to eq %w[success pending]

          succeed_running_or_pending

          expect(builds_names).to eq %w[code:test staging:deploy staging:test]
          expect(builds_statuses).to eq %w[success success pending]

          succeed_running_or_pending

          expect(builds_names).to eq %w[code:test staging:deploy staging:test
                                        production:deploy]
          expect(builds_statuses).to eq %w[success success success manual]

          expect(pipeline.reload).to be_manual
          expect(pipeline.reload).to be_blocked
          expect(pipeline.reload).not_to be_active
          expect(pipeline.reload).not_to be_complete

          play_manual_action('production:deploy')

          expect(builds_statuses).to eq %w[success success success pending]
          expect(pipeline.reload).to be_running

          succeed_running_or_pending

          expect(builds_names).to eq %w[code:test staging:deploy staging:test
                                        production:deploy production:test]
          expect(builds_statuses).to eq %w[success success success success pending]
          expect(pipeline.reload).to be_running

          succeed_running_or_pending

          expect(builds_names).to eq %w[code:test staging:deploy staging:test
                                        production:deploy production:test]
          expect(builds_statuses).to eq %w[success success success success success]
          expect(pipeline.reload).to be_success
        end
      end
    end

    context 'when second stage has only on_failure jobs', :sidekiq_inline do
      before do
        create_build('check', stage_idx: 0)
        create_build('build', stage_idx: 1, when: 'on_failure')
        create_build('test', stage_idx: 2)

        process_pipeline
      end

      it 'skips second stage and continues on third stage' do
        expect(all_builds_statuses).to eq(%w[pending created created])

        builds.first.success

        expect(all_builds_statuses).to eq(%w[success skipped pending])
      end
    end

    context 'when failed build in the middle stage is retried', :sidekiq_inline do
      context 'when failed build is the only unsuccessful build in the stage' do
        before do
          create_build('build:1', stage_idx: 0)
          create_build('build:2', stage_idx: 0)
          create_build('test:1', stage_idx: 1)
          create_build('test:2', stage_idx: 1)
          create_build('deploy:1', stage_idx: 2)
          create_build('deploy:2', stage_idx: 2)
        end

        it 'does trigger builds in the next stage' do
          expect(process_pipeline).to be_truthy
          expect(builds_names).to eq ['build:1', 'build:2']

          succeed_running_or_pending

          expect(builds_names).to eq ['build:1', 'build:2', 'test:1', 'test:2']

          pipeline.builds.find_by(name: 'test:1').success!
          pipeline.builds.find_by(name: 'test:2').drop!

          expect(builds_names).to eq ['build:1', 'build:2', 'test:1', 'test:2']

          Ci::RetryJobService.new(pipeline.project, user).execute(pipeline.builds.find_by(name: 'test:2'))[:job].reset.success!

          expect(builds_names).to eq ['build:1', 'build:2', 'test:1', 'test:2',
                                      'test:2', 'deploy:1', 'deploy:2']
        end
      end
    end

    context 'when builds with auto-retries are configured', :sidekiq_inline do
      before do
        create_build('build:1', stage_idx: 0, user: user, options: { script: 'aa', retry: 2 })
        create_build('test:1', stage_idx: 1, user: user, when: :on_failure)
        create_build('test:2', stage_idx: 1, user: user, options: { script: 'aa', retry: 1 })
      end

      it 'automatically retries builds in a valid order' do
        expect(process_pipeline).to be_truthy

        fail_running_or_pending

        expect(builds_names).to eq %w[build:1 build:1]
        expect(builds_statuses).to eq %w[failed pending]

        succeed_running_or_pending

        expect(builds_names).to eq %w[build:1 build:1 test:2]
        expect(builds_statuses).to eq %w[failed success pending]

        succeed_running_or_pending

        expect(builds_names).to eq %w[build:1 build:1 test:2]
        expect(builds_statuses).to eq %w[failed success success]

        expect(pipeline.reload).to be_success
      end
    end

    context 'when pipeline with needs is created', :sidekiq_inline do
      let!(:linux_build) { create_build('linux:build', stage: 'build', stage_idx: 0) }
      let!(:mac_build) { create_build('mac:build', stage: 'build', stage_idx: 0) }
      let!(:linux_rspec) { create_build('linux:rspec', stage: 'test', stage_idx: 1, scheduling_type: :dag) }
      let!(:linux_rubocop) { create_build('linux:rubocop', stage: 'test', stage_idx: 1, scheduling_type: :dag) }
      let!(:mac_rspec) { create_build('mac:rspec', stage: 'test', stage_idx: 1, scheduling_type: :dag) }
      let!(:mac_rubocop) { create_build('mac:rubocop', stage: 'test', stage_idx: 1, scheduling_type: :dag) }
      let!(:deploy) { create_build('deploy', stage: 'deploy', stage_idx: 2) }

      let!(:linux_rspec_on_build) { create(:ci_build_need, build: linux_rspec, name: 'linux:build') }
      let!(:linux_rubocop_on_build) { create(:ci_build_need, build: linux_rubocop, name: 'linux:build') }

      let!(:mac_rspec_on_build) { create(:ci_build_need, build: mac_rspec, name: 'mac:build') }
      let!(:mac_rubocop_on_build) { create(:ci_build_need, build: mac_rubocop, name: 'mac:build') }

      it 'when linux:* finishes first it runs it out of order' do
        expect(process_pipeline).to be_truthy

        expect(stages).to eq(%w[pending created created])
        expect(builds.pending).to contain_exactly(linux_build, mac_build)

        # we follow the single path of linux
        linux_build.reset.success!

        expect(stages).to eq(%w[running pending created])
        expect(builds.success).to contain_exactly(linux_build)
        expect(builds.pending).to contain_exactly(mac_build, linux_rspec, linux_rubocop)

        linux_rspec.reset.success!

        expect(stages).to eq(%w[running running created])
        expect(builds.success).to contain_exactly(linux_build, linux_rspec)
        expect(builds.pending).to contain_exactly(mac_build, linux_rubocop)

        linux_rubocop.reset.success!

        expect(stages).to eq(%w[running running created])
        expect(builds.success).to contain_exactly(linux_build, linux_rspec, linux_rubocop)
        expect(builds.pending).to contain_exactly(mac_build)

        mac_build.reset.success!
        mac_rspec.reset.success!
        mac_rubocop.reset.success!

        expect(stages).to eq(%w[success success pending])
        expect(builds.success).to contain_exactly(
          linux_build, linux_rspec, linux_rubocop, mac_build, mac_rspec, mac_rubocop)
        expect(builds.pending).to contain_exactly(deploy)
      end

      context 'when one of the jobs is run on a failure' do
        let!(:linux_notify) { create_build('linux:notify', stage: 'deploy', stage_idx: 2, when: 'on_failure', scheduling_type: :dag) }

        let!(:linux_notify_on_build) { create(:ci_build_need, build: linux_notify, name: 'linux:build') }

        context 'when another job in build phase fails first' do
          it 'does skip linux:notify' do
            expect(process_pipeline).to be_truthy

            mac_build.reset.drop!
            linux_build.reset.success!

            expect(linux_notify.reset).to be_skipped
          end
        end

        context 'when linux:build job fails first' do
          it 'does run linux:notify' do
            expect(process_pipeline).to be_truthy

            linux_build.reset.drop!

            expect(linux_notify.reset).to be_pending
          end
        end
      end

      context 'when there is a job scheduled with dag but no need (needs: [])' do
        let!(:deploy_pages) { create_build('deploy_pages', stage: 'deploy', stage_idx: 2, scheduling_type: :dag) }

        it 'runs deploy_pages without waiting prior stages' do
          expect(process_pipeline).to be_truthy

          expect(stages).to eq(%w[pending created pending])
          expect(builds.pending).to contain_exactly(linux_build, mac_build, deploy_pages)

          linux_build.reset.success!
          deploy_pages.reset.success!

          expect(stages).to eq(%w[running pending running])
          expect(builds.success).to contain_exactly(linux_build, deploy_pages)
          expect(builds.pending).to contain_exactly(mac_build, linux_rspec, linux_rubocop)

          linux_rspec.reset.success!
          linux_rubocop.reset.success!
          mac_build.reset.success!
          mac_rspec.reset.success!
          mac_rubocop.reset.success!

          expect(stages).to eq(%w[success success running])
          expect(builds.pending).to contain_exactly(deploy)
        end
      end
    end

    context 'when a needed job is skipped', :sidekiq_inline do
      let!(:linux_build) { create_build('linux:build', stage: 'build', stage_idx: 0) }
      let!(:linux_rspec) { create_build('linux:rspec', stage: 'test', stage_idx: 1) }
      let!(:deploy) { create_build('deploy', stage: 'deploy', stage_idx: 2, scheduling_type: :dag) }

      before do
        create(:ci_build_need, build: deploy, name: 'linux:build')
      end

      it 'skips the jobs depending on it' do
        expect(process_pipeline).to be_truthy

        expect(stages).to eq(%w[pending created created])
        expect(all_builds.pending).to contain_exactly(linux_build)

        linux_build.reset.drop!

        expect(stages).to eq(%w[failed skipped skipped])
        expect(all_builds.failed).to contain_exactly(linux_build)
        expect(all_builds.skipped).to contain_exactly(linux_rspec, deploy)
      end
    end

    context 'when a needed job is manual', :sidekiq_inline do
      let!(:linux_build) { create_build('linux:build', stage: 'build', stage_idx: 0, when: 'manual', allow_failure: true) }
      let!(:deploy) { create_build('deploy', stage: 'deploy', stage_idx: 1, scheduling_type: :dag) }

      before do
        create(:ci_build_need, build: deploy, name: 'linux:build')
      end

      it 'makes deploy DAG to be skipped' do
        expect(process_pipeline).to be_truthy

        expect(stages).to eq(%w[skipped skipped])
        expect(all_builds.manual).to contain_exactly(linux_build)
        expect(all_builds.skipped).to contain_exactly(deploy)
      end
    end

    context 'when jobs change from stopped to alive status during pipeline processing' do
      around do |example|
        Sidekiq::Testing.fake! { example.run }
      end

      let(:config) do
        <<-YAML
        stages: [test, deploy]

        manual1:
          stage: test
          when: manual
          script: exit 0

        manual2:
          stage: test
          when: manual
          script: exit 0

        test1:
          stage: test
          needs: [manual1]
          script: exit 0

        test2:
          stage: test
          needs: [manual2]
          script: exit 0

        deploy1:
          stage: deploy
          needs: [manual1, manual2]
          script: exit 0

        deploy2:
          stage: deploy
          needs: [test2]
          script: exit 0
        YAML
      end

      let(:pipeline) do
        Ci::CreatePipelineService.new(project, user, { ref: 'master' }).execute(:push).payload
      end

      let(:manual1) { all_builds.find_by(name: 'manual1') }
      let(:manual2) { all_builds.find_by(name: 'manual2') }

      let(:statuses_0) do
        { 'manual1': 'created', 'manual2': 'created', 'test1': 'created', 'test2': 'created', 'deploy1': 'created', 'deploy2': 'created' }
      end

      let(:statuses_1) do
        { 'manual1': 'manual', 'manual2': 'manual', 'test1': 'skipped', 'test2': 'skipped', 'deploy1': 'skipped', 'deploy2': 'skipped' }
      end

      let(:statuses_2) do
        { 'manual1': 'pending', 'manual2': 'pending', 'test1': 'skipped', 'test2': 'skipped', 'deploy1': 'skipped', 'deploy2': 'skipped' }
      end

      let(:statuses_3) do
        { 'manual1': 'pending', 'manual2': 'pending', 'test1': 'created', 'test2': 'created', 'deploy1': 'created', 'deploy2': 'created' }
      end

      let(:log_info) do
        {
          class: described_class.name.to_s,
          message: 'Running ResetSkippedJobsService on new alive jobs',
          project_id: project.id,
          pipeline_id: pipeline.id,
          user_id: user.id,
          jobs_count: 2
        }
      end

      before do
        stub_ci_pipeline_yaml_file(config)
        pipeline # Create the pipeline
      end

      # Since this is a test for a race condition, we are calling internal method `enqueue!`
      # instead of `play` and stubbing `new_alive_jobs` of the service class.
      it 'runs ResetSkippedJobsService on the new alive jobs and logs event' do
        # Initial control without any pipeline processing
        expect(all_builds_names_and_statuses).to eq(statuses_0)

        process_pipeline

        # Initial control after the first pipeline processing
        expect(all_builds_names_and_statuses).to eq(statuses_1)

        # Change the manual jobs from stopped to alive status.
        # We don't use `play` to avoid running `ResetSkippedJobsService`.
        manual1.enqueue!
        manual2.enqueue!

        # Statuses after playing the manual jobs
        expect(all_builds_names_and_statuses).to eq(statuses_2)

        mock_play_jobs_during_processing([manual1, manual2])

        expect(Ci::ResetSkippedJobsService).to receive(:new).once.and_call_original

        process_pipeline

        expect(all_builds_names_and_statuses).to eq(statuses_3)
      end

      it 'logs event' do
        expect(Gitlab::AppJsonLogger).to receive(:info).once.with(log_info)

        mock_play_jobs_during_processing([manual1, manual2])
        process_pipeline
      end

      context 'when the new alive jobs belong to different users' do
        let_it_be(:user2) { create(:user) }

        before do
          process_pipeline # First pipeline processing

          # Change the manual jobs from stopped to alive status
          manual1.enqueue!
          manual2.enqueue!

          manual2.update!(user: user2)

          mock_play_jobs_during_processing([manual1, manual2])
        end

        it 'runs ResetSkippedJobsService on the new alive jobs' do
          # Statuses after playing the manual jobs
          expect(all_builds_names_and_statuses).to eq(statuses_2)

          # Since there are two different users, we expect this service to be called twice.
          expect(Ci::ResetSkippedJobsService).to receive(:new).twice.and_call_original

          process_pipeline

          expect(all_builds_names_and_statuses).to eq(statuses_3)
        end

        # In this scenario, the new alive jobs (manual1 and manual2) have different users.
        # We can only know for certain the assigned user of dependent jobs that are exclusive
        # to either manual1 or manual2. Otherwise, the assigned user will depend on which of
        # the new alive jobs get processed first by ResetSkippedJobsService.
        it 'assigns the correct user to the dependent jobs' do
          test1 = all_builds.find_by(name: 'test1')
          test2 = all_builds.find_by(name: 'test2')

          expect(test1.user).to eq(user)
          expect(test2.user).to eq(user)

          process_pipeline

          expect(test1.reset.user).to eq(user)
          expect(test2.reset.user).to eq(user2)
        end

        it 'logs event' do
          expect(Gitlab::AppJsonLogger).to receive(:info).once.with(log_info.merge(jobs_count: 1))
          expect(Gitlab::AppJsonLogger).to receive(:info).once.with(log_info.merge(user_id: user2.id, jobs_count: 1))

          mock_play_jobs_during_processing([manual1, manual2])
          process_pipeline
        end
      end
    end

    context 'when a bridge job has parallel:matrix config', :sidekiq_inline do
      let(:parent_config) do
        <<-EOY
        test:
          stage: test
          script: echo test

        deploy:
          stage: deploy
          trigger:
            include: .child.yml
          parallel:
            matrix:
              - PROVIDER: ovh
                STACK: [monitoring, app]
        EOY
      end

      let(:child_config) do
        <<-EOY
        test:
          stage: test
          script: echo test
        EOY
      end

      let(:pipeline) do
        Ci::CreatePipelineService.new(project, user, { ref: 'master' }).execute(:push).payload
      end

      let(:project_files) do
        {
          '.gitlab-ci.yml' => parent_config,
          '.child.yml' => child_config
        }
      end

      around do |example|
        create_and_delete_files(project, project_files) do
          example.run
        end
      end

      it 'creates pipeline with bridges, then passes the matrix variables to downstream jobs' do
        expect(all_builds_names).to contain_exactly('test', 'deploy: [ovh, monitoring]', 'deploy: [ovh, app]')
        expect(all_builds_statuses).to contain_exactly('pending', 'created', 'created')

        succeed_pending

        # bridge jobs directly transition to success
        expect(all_builds_statuses).to contain_exactly('success', 'success', 'success')

        bridge1 = all_builds.find_by(name: 'deploy: [ovh, monitoring]')
        bridge2 = all_builds.find_by(name: 'deploy: [ovh, app]')

        downstream_job1 = bridge1.downstream_pipeline.all_jobs.first
        downstream_job2 = bridge2.downstream_pipeline.all_jobs.first

        expect(downstream_job1.scoped_variables.to_hash).to include('PROVIDER' => 'ovh', 'STACK' => 'monitoring')
        expect(downstream_job2.scoped_variables.to_hash).to include('PROVIDER' => 'ovh', 'STACK' => 'app')
      end
    end

    context 'when a bridge job has invalid downstream project', :sidekiq_inline do
      let(:config) do
        <<-EOY
        test:
          stage: test
          script: echo test

        deploy:
          stage: deploy
          trigger:
            project: invalid-project
        EOY
      end

      let(:pipeline) do
        Ci::CreatePipelineService.new(project, user, { ref: 'master' }).execute(:push).payload
      end

      before do
        stub_ci_pipeline_yaml_file(config)
      end

      it 'creates a pipeline, then fails the bridge job' do
        expect(all_builds_names).to contain_exactly('test', 'deploy')
        expect(all_builds_statuses).to contain_exactly('pending', 'created')

        succeed_pending

        expect(all_builds_names).to contain_exactly('test', 'deploy')
        expect(all_builds_statuses).to contain_exactly('success', 'failed')
      end
    end

    context 'when the dependency is stage-independent', :sidekiq_inline do
      let(:config) do
        <<-EOY
        stages: [A, B]

        A1:
          stage: A
          script: exit 0
          when: manual

        A2:
          stage: A
          script: exit 0
          needs: [A1]

        B:
          stage: B
          needs: [A2]
          script: exit 0
        EOY
      end

      let(:pipeline) do
        Ci::CreatePipelineService.new(project, user, { ref: 'master' }).execute(:push).payload
      end

      before do
        stub_ci_pipeline_yaml_file(config)
      end

      it 'processes subsequent jobs in the correct order when playing first job' do
        expect(all_builds_names).to eq(%w[A1 A2 B])
        expect(all_builds_statuses).to eq(%w[manual skipped skipped])

        play_manual_action('A1')

        expect(all_builds_names).to eq(%w[A1 A2 B])
        expect(all_builds_statuses).to eq(%w[pending created created])
      end
    end

    context 'when the exclusive lease is taken' do
      let(:lease_key) { ""ci/pipeline_processing/atomic_processing_service::pipeline_id:#{pipeline.id}"" }

      it 'skips pipeline processing' do
        create_build('linux', stage_idx: 0)

        stub_exclusive_lease_taken(lease_key)

        expect(Gitlab::AppJsonLogger).to receive(:info).with(a_hash_including(message: /^Cannot obtain an exclusive lease/))
        expect(process_pipeline).to be_falsy
      end
    end

    describe 'deployments creation' do
      let(:config) do
        <<-YAML
        stages: [stage-0, stage-1, stage-2, stage-3, stage-4]

        test:
          stage: stage-0
          script: exit 0

        review:
          stage: stage-1
          environment:
            name: review
            action: start
          script: exit 0

        staging:
          stage: stage-2
          environment:
            name: staging
            action: start
          script: exit 0
          when: manual
          allow_failure: false

        canary:
          stage: stage-3
          environment:
            name: canary
            action: start
          script: exit 0
          when: manual

        production-a:
          stage: stage-4
          environment:
            name: production-a
            action: start
          script: exit 0
          when: manual

        production-b:
          stage: stage-4
          environment:
            name: production-b
            action: start
          script: exit 0
          when: manual
          needs: [canary]
        YAML
      end

      let(:pipeline) do
        Ci::CreatePipelineService.new(project, user, { ref: 'master' }).execute(:push).payload
      end

      let(:test_job) { all_builds.find_by(name: 'test') }
      let(:review_deploy_job) { all_builds.find_by(name: 'review') }
      let(:staging_deploy_job) { all_builds.find_by(name: 'staging') }
      let(:canary_deploy_job) { all_builds.find_by(name: 'canary') }
      let(:production_a_deploy_job) { all_builds.find_by(name: 'production-a') }
      let(:production_b_deploy_job) { all_builds.find_by(name: 'production-b') }

      before do
        create(:environment, name: 'review', project: project)
        create(:environment, name: 'staging', project: project)
        create(:environment, name: 'canary', project: project)
        create(:environment, name: 'production-a', project: project)
        create(:environment, name: 'production-b', project: project)

        stub_ci_pipeline_yaml_file(config)
        pipeline # create the pipeline
      end

      it 'creates deployment records for the deploy jobs', :aggregate_failures do
        # processes the 'test' job, not creating a Deployment record
        expect { process_pipeline }.not_to change { Deployment.count }
        succeed_pending
        expect(test_job.status).to eq 'success'

        # processes automatic 'review' deploy job, creating a Deployment record
        expect { process_pipeline }.to change { Deployment.count }.by(1)
        succeed_pending
        expect(review_deploy_job.status).to eq 'success'

        # processes manual 'staging' deploy job, creating a Deployment record
        # the subsequent manual deploy jobs ('canary', 'production-a', 'production-b')
        #   are not yet processed because 'staging' is set as `allow_failure: false`
        expect { process_pipeline }.to change { Deployment.count }.by(1)
        play_manual_action('staging')
        succeed_pending
        expect(staging_deploy_job.reload.status).to eq 'success'

        # processes manual 'canary' deployment job
        # the subsequent manual deploy jobs ('production-a' and 'production-b')
        #   are also processed because 'canary' is set by default as `allow_failure: true`
        #   the 'production-b' is set as `needs: [canary]`, but it is still processed
        # overall, 3 Deployment records are created
        expect { process_pipeline }.to change { Deployment.count }.by(3)
        expect(canary_deploy_job.status).to eq 'manual'
        expect(production_a_deploy_job.status).to eq 'manual'
        expect(production_b_deploy_job.status).to eq 'skipped'

        # play and succeed the manual 'canary' and 'production-a' jobs
        play_manual_action('canary')
        play_manual_action('production-a')
        succeed_pending
        expect(canary_deploy_job.reload.status).to eq 'success'
        expect(production_a_deploy_job.reload.status).to eq 'success'
        expect(production_b_deploy_job.reload.status).to eq 'created'

        # process the manual 'production-b' job again, no Deployment record is created
        #   because it has already been created when 'production-b' was first processed
        expect { process_pipeline }.not_to change { Deployment.count }
        expect(production_b_deploy_job.reload.status).to eq 'manual'
      end
    end

    private

    def all_builds
      pipeline.all_jobs.order(:stage_idx, :id)
    end

    def builds
      all_builds.where.not(status: [:created, :skipped])
    end

    def stages
      pipeline.reset.stages.map(&:status)
    end

    def builds_names
      builds.pluck(:name)
    end

    def builds_names_and_statuses
      builds.each_with_object({}) do |b, h|
        h[b.name.to_sym] = b.status
      end
    end

    def all_builds_names_and_statuses
      all_builds.each_with_object({}) do |b, h|
        h[b.name.to_sym] = b.status
      end
    end

    def all_builds_names
      all_builds.pluck(:name)
    end

    def builds_statuses
      builds.pluck(:status)
    end

    def all_builds_statuses
      all_builds.pluck(:status)
    end

    def succeed_pending
      builds.pending.each do |build|
        build.reset.success
      end
    end

    def succeed_running_or_pending
      pipeline.builds.running_or_pending.each do |build|
        build.reset.success
      end
    end

    def fail_running_or_pending
      pipeline.builds.running_or_pending.each do |build|
        build.reset.drop
      end
    end

    def cancel_running_or_pending
      pipeline.builds.running_or_pending.each do |build|
        build.reset.cancel
      end
    end

    def play_manual_action(name)
      builds.find_by(name: name).play(user)
    end

    def enqueue_scheduled(name)
      builds.scheduled.find_by(name: name).enqueue!
    end

    def retry_build(name)
      Ci::RetryJobService.new(project, user).execute(builds.find_by(name: name))
    end

    def manual_actions
      pipeline.manual_actions.reload
    end

    def create_build(name, **opts)
      create(:ci_build, :created, pipeline: pipeline, name: name, **with_stage_opts(opts))
    end

    def successful_build(name, **opts)
      create(:ci_build, :success, pipeline: pipeline, name: name, **with_stage_opts(opts))
    end

    def with_stage_opts(opts)
      { stage: ""stage-#{opts[:stage_idx].to_i}"" }.merge(opts)
    end

    def delayed_options
      { when: 'delayed', options: { script: %w[echo], start_in: '1 minute' } }
    end

    def unschedule
      pipeline.builds.scheduled.map(&:unschedule)
    end
  end

  private

  def process_pipeline
    described_class.new(pipeline).execute
  end

  # A status collection is initialized at the start of pipeline processing and then again at the
  # end of processing.  Here we simulate ""playing"" the given jobs during pipeline processing by
  # stubbing stopped_job_names so that they appear to have been stopped at the beginning of
  # processing and then later changed to alive status at the end.
  def mock_play_jobs_during_processing(jobs)
    collection = Ci::PipelineProcessing::AtomicProcessingService::StatusCollection.new(pipeline)

    allow(collection).to receive(:stopped_job_names).and_return(jobs.map(&:name), [])

    # Return the same collection object for every instance of StatusCollection
    allow(Ci::PipelineProcessing::AtomicProcessingService::StatusCollection).to receive(:new)
      .and_return(collection)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module PipelineProcessing
    class AtomicProcessingService
      class StatusCollection
        include Gitlab::Utils::StrongMemoize

        attr_reader :pipeline

        def initialize(pipeline)
          @pipeline = pipeline
          @stage_jobs = {}
          @prior_stage_jobs = {}
        end

        # This method updates internal status for given ID
        def set_job_status(id, status, lock_version)
          job = all_jobs_by_id[id]
          return unless job

          job[:status] = status
          job[:lock_version] = lock_version
        end

        # This methods gets composite status of all jobs
        def status_of_all
          status_for_array(all_jobs)
        end

        # This methods gets composite status for jobs at a given stage
        def status_of_stage(stage_position)
          strong_memoize(""status_of_stage_#{stage_position}"") do
            stage_jobs = all_jobs_grouped_by_stage_position[stage_position].to_a

            status_for_array(stage_jobs.flatten)
          end
        end

        # This methods gets composite status for jobs with given names
        def status_of_jobs(names)
          jobs = all_jobs_by_name.slice(*names)

          status_for_array(jobs.values, dag: true)
        end

        # This methods gets composite status for jobs before given stage
        def status_of_jobs_prior_to_stage(stage_position)
          strong_memoize(""status_of_jobs_prior_to_stage_#{stage_position}"") do
            stage_jobs = all_jobs_grouped_by_stage_position
              .select { |position, _| position < stage_position }

            status_for_array(stage_jobs.values.flatten)
          end
        end

        # This methods gets a list of jobs for a given stage
        def created_job_ids_in_stage(stage_position)
          all_jobs_grouped_by_stage_position[stage_position]
            .to_a
            .select { |job| job[:status] == 'created' }
            .map { |job| job[:id] }
        end

        # This method returns a list of all job, that are to be processed
        def processing_jobs
          all_jobs.lazy.reject { |job| job[:processed] }
        end

        # This method returns the names of jobs that have a stopped status
        def stopped_job_names
          all_jobs.select { |job| job[:status].in?(Ci::HasStatus::STOPPED_STATUSES) }.pluck(:name) # rubocop: disable CodeReuse/ActiveRecord
        end

        private

        # We use these columns to perform an efficient calculation of a status
        JOB_ATTRS = [
          :id, :name, :status, :allow_failure,
          :stage_idx, :processed, :lock_version
        ].freeze

        def status_for_array(jobs, dag: false)
          result = Gitlab::Ci::Status::Composite
            .new(jobs, dag: dag, project: pipeline.project)
            .status
          result || 'success'
        end

        def all_jobs_grouped_by_stage_position
          strong_memoize(:all_jobs_by_order) do
            all_jobs.group_by { |job| job[:stage_idx].to_i }
          end
        end

        def all_jobs_by_id
          strong_memoize(:all_jobs_by_id) do
            all_jobs.index_by { |row| row[:id] }
          end
        end

        def all_jobs_by_name
          strong_memoize(:jobs_by_name) do
            all_jobs.index_by { |row| row[:name] }
          end
        end

        # rubocop: disable CodeReuse/ActiveRecord
        def all_jobs
          # We fetch all relevant data in one go.
          #
          # This is more efficient than relying on PostgreSQL to calculate composite status for us
          #
          # Since we need to reprocess everything we can fetch all of them and do processing ourselves.
          strong_memoize(:all_jobs) do
            raw_jobs = pipeline
              .current_jobs
              .ordered_by_stage
              .pluck(*JOB_ATTRS)

            raw_jobs.map do |row|
              JOB_ATTRS.zip(row).to_h
            end
          end
        end
        # rubocop: enable CodeReuse/ActiveRecord
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::PipelineProcessing::AtomicProcessingService::StatusCollection,
  feature_category: :continuous_integration do
  using RSpec::Parameterized::TableSyntax

  let_it_be(:pipeline) { create(:ci_pipeline) }
  let_it_be(:build_stage) { create(:ci_stage, name: 'build', pipeline: pipeline) }
  let_it_be(:test_stage) { create(:ci_stage, name: 'test', pipeline: pipeline) }
  let_it_be(:deploy_stage) { create(:ci_stage, name: 'deploy', pipeline: pipeline) }
  let_it_be(:build_a) do
    create(:ci_build, :success, name: 'build-a', ci_stage: build_stage, stage_idx: 0, pipeline: pipeline)
  end

  let_it_be(:build_b) do
    create(:ci_build, :failed, name: 'build-b', ci_stage: build_stage, stage_idx: 0, pipeline: pipeline)
  end

  let_it_be(:test_a) do
    create(:ci_build, :running, name: 'test-a', ci_stage: test_stage, stage_idx: 1, pipeline: pipeline)
  end

  let_it_be(:test_b) do
    create(:ci_build, :pending, name: 'test-b', ci_stage: test_stage, stage_idx: 1, pipeline: pipeline)
  end

  let_it_be(:deploy) do
    create(:ci_build, :created, name: 'deploy', ci_stage: deploy_stage, stage_idx: 2, pipeline: pipeline)
  end

  let(:collection) { described_class.new(pipeline) }

  describe '#set_job_status' do
    it 'does update existing status of job' do
      collection.set_job_status(test_a.id, 'success', 100)

      expect(collection.status_of_jobs(['test-a'])).to eq('success')
    end

    it 'ignores a missing job' do
      collection.set_job_status(-1, 'failed', 100)
    end
  end

  describe '#status_of_all' do
    it 'returns composite status of the collection' do
      expect(collection.status_of_all).to eq('running')
    end
  end

  describe '#status_of_jobs' do
    where(:names, :status) do
      %w[build-a]         | 'success'
      %w[build-a build-b] | 'failed'
      %w[build-a test-a]  | 'running'
    end

    with_them do
      it 'returns composite status of given names' do
        expect(collection.status_of_jobs(names)).to eq(status)
      end
    end
  end

  describe '#status_of_jobs_prior_to_stage' do
    where(:stage, :status) do
      0 | 'success'
      1 | 'failed'
      2 | 'running'
    end

    with_them do
      it 'returns composite status for jobs in prior stages' do
        expect(collection.status_of_jobs_prior_to_stage(stage)).to eq(status)
      end
    end
  end

  describe '#status_of_stage' do
    where(:stage, :status) do
      0 | 'failed'
      1 | 'running'
      2 | 'created'
    end

    with_them do
      it 'returns composite status for jobs at a given stages' do
        expect(collection.status_of_stage(stage)).to eq(status)
      end
    end
  end

  describe '#created_job_ids_in_stage' do
    it 'returns IDs of jobs at a given stage position' do
      expect(collection.created_job_ids_in_stage(0)).to be_empty
      expect(collection.created_job_ids_in_stage(1)).to be_empty
      expect(collection.created_job_ids_in_stage(2)).to contain_exactly(deploy.id)
    end
  end

  describe '#processing_jobs' do
    it 'returns jobs marked as processing' do
      expect(collection.processing_jobs.map { |job| job[:id] })
        .to contain_exactly(build_a.id, build_b.id, test_a.id, test_b.id, deploy.id)
    end
  end

  describe '#stopped_job_names' do
    it 'returns names of jobs that have a stopped status' do
      expect(collection.stopped_job_names)
        .to contain_exactly(build_a.name, build_b.name)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module Catalog
    module Resources
      class ValidateService
        MINIMUM_AMOUNT_OF_COMPONENTS = 1

        def initialize(project, ref)
          @project = project
          @ref = ref
          @errors = []
        end

        def execute
          verify_presence_project_readme
          verify_presence_project_description
          scan_directory_for_components

          if errors.empty?
            ServiceResponse.success
          else
            ServiceResponse.error(message: errors.join(', '))
          end
        end

        private

        attr_reader :project, :ref, :errors

        def verify_presence_project_readme
          return if project_has_readme?

          errors << 'Project must have a README'
        end

        def verify_presence_project_description
          return if project.description.present?

          errors << 'Project must have a description'
        end

        def scan_directory_for_components
          return if Ci::Catalog::ComponentsProject.new(project).fetch_component_paths(ref,
            limit: MINIMUM_AMOUNT_OF_COMPONENTS).any?

          errors << 'Project must contain components. Ensure you are using the correct directory structure'
        end

        def project_has_readme?
          project.repository.blob_data_at(ref, 'README.md')
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::Catalog::Resources::ValidateService, feature_category: :pipeline_composition do
  describe '#execute' do
    context 'when a project has a README, a description, and at least one component' do
      it 'is valid' do
        project = create(:project, :catalog_resource_with_components)
        response = described_class.new(project, project.default_branch).execute

        expect(response).to be_success
      end
    end

    context 'when a project has neither a description nor a README nor components' do
      it 'is not valid' do
        project = create(:project, :small_repo)
        response = described_class.new(project, project.default_branch).execute

        expect(response.message).to eq(
          'Project must have a README, ' \
          'Project must have a description, ' \
          'Project must contain components. Ensure you are using the correct directory structure')
      end
    end

    context 'when a project has components but has neither a description nor a README' do
      it 'is not valid' do
        project = create(:project, :small_repo, files: { 'templates/dast/template.yml' => 'image: alpine' })
        response = described_class.new(project, project.default_branch).execute

        expect(response.message).to eq('Project must have a README, Project must have a description')
      end
    end

    context 'when a project has a description but has neither a README nor components' do
      it 'is not valid' do
        project = create(:project, :small_repo, description: 'project with no README and no components')
        response = described_class.new(project, project.default_branch).execute

        expect(response.message).to eq(
          'Project must have a README, ' \
          'Project must contain components. Ensure you are using the correct directory structure')
      end
    end

    context 'when a project has a README but has neither a description nor components' do
      it 'is not valid' do
        project = create(:project, :repository)
        response = described_class.new(project, project.default_branch).execute

        expect(response.message).to eq(
          'Project must have a description, ' \
          'Project must contain components. Ensure you are using the correct directory structure')
      end
    end

    context 'when a project has components and a description but no README' do
      it 'is not valid' do
        project = create(:project, :small_repo, description: 'desc', files: { 'templates/dast.yml' => 'image: alpine' })
        response = described_class.new(project, project.default_branch).execute

        expect(response.message).to eq('Project must have a README')
      end
    end

    context 'when a project has components and a README but no description' do
      it 'is not valid' do
        project = create(:project, :custom_repo,
          files: { 'templates/dast.yml' => 'image: alpine', 'README.md' => 'readme' })
        response = described_class.new(project, project.default_branch).execute

        expect(response.message).to eq('Project must have a description')
      end
    end

    context 'when a project has a description and a README but no components' do
      it 'is not valid' do
        project = create(:project, :readme, description: 'project with no README and no components')
        response = described_class.new(project, project.default_branch).execute

        expect(response.message).to eq(
          'Project must contain components. Ensure you are using the correct directory structure')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module Catalog
    module Resources
      class ReleaseService
        def initialize(release)
          @release = release
          @project = release.project
          @errors = []
        end

        def execute
          validate_catalog_resource
          create_version

          if errors.empty?
            ServiceResponse.success
          else
            ServiceResponse.error(message: errors.join(', '))
          end
        end

        private

        attr_reader :project, :errors, :release

        def validate_catalog_resource
          response = Ci::Catalog::Resources::ValidateService.new(project, release.sha).execute
          return if response.success?

          errors << response.message
        end

        def create_version
          return if errors.present?

          response = Ci::Catalog::Resources::Versions::CreateService.new(release).execute
          return if response.success?

          errors << response.message
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::Catalog::Resources::ReleaseService, feature_category: :pipeline_composition do
  describe '#execute' do
    context 'with a valid catalog resource and release' do
      it 'validates the catalog resource and creates a version' do
        project = create(:project, :catalog_resource_with_components)
        catalog_resource = create(:ci_catalog_resource, project: project)
        release = create(:release, project: project, sha: project.repository.root_ref_sha)

        response = described_class.new(release).execute

        version = Ci::Catalog::Resources::Version.last

        expect(response).to be_success
        expect(version.release).to eq(release)
        expect(version.catalog_resource).to eq(catalog_resource)
        expect(version.catalog_resource.project).to eq(project)
      end
    end

    context 'when the validation of the catalog resource fails' do
      it 'returns an error and does not create a version' do
        project = create(:project, :repository)
        create(:ci_catalog_resource, project: project)
        release = create(:release, project: project, sha: project.repository.root_ref_sha)

        response = described_class.new(release).execute

        expect(Ci::Catalog::Resources::Version.count).to be(0)
        expect(response).to be_error
        expect(response.message).to eq(
          'Project must have a description, ' \
          'Project must contain components. Ensure you are using the correct directory structure')
      end
    end

    context 'when the creation of a version fails' do
      it 'returns an error and does not create a version' do
        project =
          create(
            :project, :custom_repo,
            description: 'Component project',
            files: {
              'templates/secret-detection.yml' => 'image: agent: coop',
              'README.md' => 'Read me'
            }
          )
        create(:ci_catalog_resource, project: project)
        release = create(:release, project: project, sha: project.repository.root_ref_sha)

        response = described_class.new(release).execute

        expect(Ci::Catalog::Resources::Version.count).to be(0)
        expect(response).to be_error
        expect(response.message).to include('mapping values are not allowed in this context')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module Catalog
    module Resources
      class DestroyService
        include Gitlab::Allowable

        attr_reader :project, :current_user

        def initialize(project, user)
          @current_user = user
          @project = project
        end

        def execute(catalog_resource)
          raise Gitlab::Access::AccessDeniedError unless can?(current_user, :add_catalog_resource,
            project)

          catalog_resource.destroy!

          ServiceResponse.success(message: 'Catalog Resource destroyed')
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::Catalog::Resources::DestroyService, feature_category: :pipeline_composition do
  let_it_be(:project) { create(:project, :catalog_resource_with_components) }
  let_it_be(:catalog_resource) { create(:ci_catalog_resource, project: project) }
  let_it_be(:user) { create(:user) }

  let(:service) { described_class.new(project, user) }

  before do
    stub_licensed_features(ci_namespace_catalog: true)
  end

  describe '#execute' do
    context 'with an unauthorized user' do
      it 'raises an AccessDeniedError' do
        expect { service.execute(catalog_resource) }.to raise_error(Gitlab::Access::AccessDeniedError)
      end
    end

    context 'with an authorized user' do
      before_all do
        project.add_owner(user)
      end

      it 'destroys a catalog resource' do
        expect(project.catalog_resource).to eq(catalog_resource)

        response = service.execute(catalog_resource)

        expect(project.reload.catalog_resource).to be_nil
        expect(response.status).to be(:success)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module Catalog
    module Resources
      class CreateService
        include Gitlab::Allowable

        attr_reader :project, :current_user

        def initialize(project, user)
          @current_user = user
          @project = project
        end

        def execute
          raise Gitlab::Access::AccessDeniedError unless can?(current_user, :add_catalog_resource, project)

          catalog_resource = Ci::Catalog::Resource.new(project: project)

          if catalog_resource.valid?
            catalog_resource.save!
            ServiceResponse.success(payload: catalog_resource)
          else
            ServiceResponse.error(message: catalog_resource.errors.full_messages.join(', '))
          end
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::Catalog::Resources::CreateService, feature_category: :pipeline_composition do
  let_it_be(:project) { create(:project, :catalog_resource_with_components) }
  let_it_be(:user) { create(:user) }

  let(:service) { described_class.new(project, user) }

  before do
    stub_licensed_features(ci_namespace_catalog: true)
  end

  describe '#execute' do
    context 'with an unauthorized user' do
      it 'raises an AccessDeniedError' do
        expect { service.execute }.to raise_error(Gitlab::Access::AccessDeniedError)
      end
    end

    context 'with an authorized user' do
      before_all do
        project.add_owner(user)
      end

      context 'and a valid project' do
        it 'creates a catalog resource' do
          response = service.execute

          expect(response.payload.project).to eq(project)
        end
      end

      context 'with an invalid catalog resource' do
        it 'does not save the catalog resource' do
          catalog_resource = instance_double(::Ci::Catalog::Resource,
            valid?: false,
            errors: instance_double(ActiveModel::Errors, full_messages: ['not valid']))
          allow(::Ci::Catalog::Resource).to receive(:new).and_return(catalog_resource)

          response = service.execute

          expect(response.message).to eq('not valid')
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module Catalog
    module Resources
      module Versions
        class CreateService
          def initialize(release)
            @project = release.project
            @release = release
            @errors = []
            @version = nil
            @components_project = Ci::Catalog::ComponentsProject.new(project)
          end

          def execute
            build_catalog_resource_version
            fetch_and_build_components if Feature.enabled?(:ci_catalog_create_metadata, project)
            publish_catalog_resource!

            if errors.empty?
              ServiceResponse.success
            else
              ServiceResponse.error(message: errors.flatten.first(10).join(', '))
            end
          end

          private

          attr_reader :project, :errors, :release, :components_project

          def build_catalog_resource_version
            return error('Project is not a catalog resource') unless project.catalog_resource

            @version = Ci::Catalog::Resources::Version.new(
              release: release,
              catalog_resource: project.catalog_resource,
              project: project
            )
          end

          def fetch_and_build_components
            return if errors.present?

            max_components = Ci::Catalog::ComponentsProject::COMPONENTS_LIMIT
            component_paths = components_project.fetch_component_paths(release.sha, limit: max_components + 1)

            if component_paths.size > max_components
              return error(""Release cannot contain more than #{max_components} components"")
            end

            build_components(component_paths)
          end

          def build_components(component_paths)
            paths_with_oids = component_paths.map { |path| [release.sha, path] }
            blobs = project.repository.blobs_at(paths_with_oids)

            blobs.each do |blob|
              metadata = extract_metadata(blob)
              build_catalog_resource_component(metadata)
            end
          rescue ::Gitlab::Config::Loader::FormatError => e
            error(e)
          end

          def extract_metadata(blob)
            {
              name: components_project.extract_component_name(blob.path),
              inputs: components_project.extract_inputs(blob.data),
              path: blob.path
            }
          end

          def build_catalog_resource_component(metadata)
            return if errors.present?

            component = @version.components.build(
              name: metadata[:name],
              project: @version.project,
              inputs: metadata[:inputs],
              catalog_resource: @version.catalog_resource,
              path: metadata[:path],
              created_at: Time.current
            )

            return if component.valid?

            error(""Build component error: #{component.errors.full_messages.join(', ')}"")
          end

          def publish_catalog_resource!
            return if errors.present?

            ::Ci::Catalog::Resources::Version.transaction do
              BulkInsertableAssociations.with_bulk_insert do
                @version.save!
              end

              project.catalog_resource.publish!
            end
          end

          def error(message)
            errors << message
          end
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::Catalog::Resources::Versions::CreateService, feature_category: :pipeline_composition do
  describe '#execute' do
    let(:files) do
      {
        'templates/secret-detection.yml' => ""spec:\n inputs:\n  website:\n---\nimage: alpine_1"",
        'templates/dast/template.yml' => 'image: alpine_2',
        'templates/blank-yaml.yml' => '',
        'templates/dast/sub-folder/template.yml' => 'image: alpine_3',
        'templates/template.yml' => ""spec:\n inputs:\n  environment:\n---\nimage: alpine_6"",
        'tests/test.yml' => 'image: alpine_7',
        'README.md' => 'Read me'
      }
    end

    let(:project) do
      create(
        :project, :custom_repo,
        description: 'Simple and Complex components',
        files: files
      )
    end

    let(:release) { create(:release, project: project, sha: project.repository.root_ref_sha) }
    let!(:catalog_resource) { create(:ci_catalog_resource, project: project) }

    context 'when the project is not a catalog resource' do
      it 'does not create a version' do
        project = create(:project, :repository)
        release =  create(:release, project: project, sha: project.repository.root_ref_sha)

        response = described_class.new(release).execute

        expect(response).to be_error
        expect(response.message).to include('Project is not a catalog resource')
      end
    end

    context 'when the catalog resource has different types of components and a release' do
      it 'creates a version for the release' do
        response = described_class.new(release).execute

        expect(response).to be_success

        version = Ci::Catalog::Resources::Version.last

        expect(version.release).to eq(release)
        expect(version.catalog_resource).to eq(catalog_resource)
        expect(version.catalog_resource.project).to eq(project)
      end

      it 'marks the catalog resource as published' do
        described_class.new(release).execute

        expect(catalog_resource.reload.state).to eq('published')
      end

      context 'when the ci_catalog_create_metadata feature flag is disabled' do
        before do
          stub_feature_flags(ci_catalog_create_metadata: false)
        end

        it 'does not create components' do
          expect(Ci::Catalog::Resources::Component).not_to receive(:bulk_insert!).and_call_original
          expect(project.ci_components.count).to eq(0)

          response = described_class.new(release).execute

          expect(response).to be_success
          expect(project.ci_components.count).to eq(0)
        end
      end

      context 'when the ci_catalog_create_metadata feature flag is enabled' do
        context 'when there are more than 10 components' do
          let(:files) do
            {
              'templates/secret11.yml' => '',
              'templates/secret10.yml' => '',
              'templates/secret8.yml' => '',
              'templates/secret7.yml' => '',
              'templates/secret6.yml' => '',
              'templates/secret5.yml' => '',
              'templates/secret4.yml' => '',
              'templates/secret3.yml' => '',
              'templates/secret2.yml' => '',
              'templates/secret1.yml' => '',
              'templates/secret0.yml' => '',
              'README.md' => 'Read me'
            }
          end

          it 'does not create components' do
            response = described_class.new(release).execute

            expect(response).to be_error
            expect(response.message).to include('Release cannot contain more than 10 components')
            expect(project.ci_components.count).to eq(0)
          end
        end

        it 'bulk inserts all the components' do
          expect(Ci::Catalog::Resources::Component).to receive(:bulk_insert!).and_call_original

          described_class.new(release).execute
        end

        it 'creates components for the catalog resource' do
          expect(project.ci_components.count).to eq(0)
          response = described_class.new(release).execute

          expect(response).to be_success

          version = Ci::Catalog::Resources::Version.last

          expect(project.ci_components.count).to eq(4)
          expect(project.ci_components.first.name).to eq('blank-yaml')
          expect(project.ci_components.first.project).to eq(version.project)
          expect(project.ci_components.first.inputs).to eq({})
          expect(project.ci_components.first.catalog_resource).to eq(version.catalog_resource)
          expect(project.ci_components.first.version).to eq(version)
          expect(project.ci_components.first.path).to eq('templates/blank-yaml.yml')
          expect(project.ci_components.second.name).to eq('dast')
          expect(project.ci_components.second.project).to eq(version.project)
          expect(project.ci_components.second.inputs).to eq({})
          expect(project.ci_components.second.catalog_resource).to eq(version.catalog_resource)
          expect(project.ci_components.second.version).to eq(version)
          expect(project.ci_components.second.path).to eq('templates/dast/template.yml')
          expect(project.ci_components.third.name).to eq('secret-detection')
          expect(project.ci_components.third.project).to eq(version.project)
          expect(project.ci_components.third.inputs).to eq({ ""website"" => nil })
          expect(project.ci_components.third.catalog_resource).to eq(version.catalog_resource)
          expect(project.ci_components.third.version).to eq(version)
          expect(project.ci_components.third.path).to eq('templates/secret-detection.yml')
          expect(project.ci_components.fourth.name).to eq('template')
          expect(project.ci_components.fourth.project).to eq(version.project)
          expect(project.ci_components.fourth.inputs).to eq({ ""environment"" => nil })
          expect(project.ci_components.fourth.catalog_resource).to eq(version.catalog_resource)
          expect(project.ci_components.fourth.version).to eq(version)
          expect(project.ci_components.fourth.path).to eq('templates/template.yml')
        end
      end
    end

    context 'with invalid data' do
      let_it_be(:files) do
        {
          'templates/secret-detection.yml' => 'some: invalid: syntax',
          'README.md' => 'Read me'
        }
      end

      it 'returns an error' do
        response = described_class.new(release).execute

        expect(response).to be_error
        expect(response.message).to include('mapping values are not allowed in this context')
      end
    end

    context 'when one or more components are invalid' do
      let_it_be(:files) do
        {
          'templates/secret-detection.yml' => ""spec:\n inputs:\n  - website\n---\nimage: alpine_1"",
          'README.md' => 'Read me'
        }
      end

      it 'returns an error' do
        response = described_class.new(release).execute

        expect(response).to be_error
        expect(response.message).to include('Inputs must be a valid json schema')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module Pipelines
    class AddJobService
      include ::Gitlab::ExclusiveLeaseHelpers

      attr_reader :pipeline

      def initialize(pipeline)
        @pipeline = pipeline

        raise ArgumentError, ""Pipeline must be persisted for this service to be used"" unless pipeline.persisted?
      end

      def execute!(job, &block)
        assign_pipeline_attributes(job)

        in_lock(""ci:pipelines:#{pipeline.id}:add-job"", ttl: LOCK_TIMEOUT, sleep_sec: LOCK_SLEEP, retries: LOCK_RETRIES) do
          Ci::Pipeline.transaction do
            yield(job)

            job.update_older_statuses_retried!
          end
        end

        ServiceResponse.success(payload: { job: job })
      rescue StandardError => e
        ServiceResponse.error(message: e.message, payload: { job: job })
      end

      private

      LOCK_TIMEOUT = 1.minute
      LOCK_SLEEP = 0.5.seconds
      LOCK_RETRIES = 20

      def assign_pipeline_attributes(job)
        job.pipeline = pipeline
        job.project = pipeline.project
        job.ref = pipeline.ref
        job.partition_id = pipeline.partition_id

        # update metadata since it might have been lazily initialised before this call
        # metadata is present on `Ci::Processable`
        if job.respond_to?(:metadata) && job.metadata
          job.metadata.project = pipeline.project
          job.metadata.partition_id = pipeline.partition_id
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::Pipelines::AddJobService, feature_category: :continuous_integration do
  include ExclusiveLeaseHelpers

  let_it_be_with_reload(:pipeline) { create(:ci_pipeline) }

  let(:job) { build(:ci_build) }

  subject(:service) { described_class.new(pipeline) }

  context 'when the pipeline is not persisted' do
    let(:pipeline) { build(:ci_pipeline) }

    it 'raises error' do
      expect { service }.to raise_error('Pipeline must be persisted for this service to be used')
    end
  end

  describe '#execute!' do
    subject(:execute) do
      service.execute!(job) do |job|
        job.save!
      end
    end

    it 'assigns pipeline attributes to the job' do
      expect do
        execute
      end.to change { job.slice(:pipeline, :project, :ref) }.to(
        pipeline: pipeline, project: pipeline.project, ref: pipeline.ref
      ).and change { job.metadata.project }.to(pipeline.project)
    end

    it 'assigns partition_id to job and metadata' do
      pipeline.partition_id = ci_testing_partition_id

      expect { execute }
        .to change(job, :partition_id).to(pipeline.partition_id)
        .and change { job.metadata.partition_id }.to(pipeline.partition_id)
    end

    it 'returns a service response with the job as payload' do
      expect(execute).to be_success
      expect(execute.payload[:job]).to eq(job)
    end

    it 'calls update_older_statuses_retried!' do
      expect(job).to receive(:update_older_statuses_retried!)

      execute
    end

    context 'when the block raises an error' do
      subject(:execute) do
        service.execute!(job) do |job|
          raise ""this is an error""
        end
      end

      it 'returns a service response with the error and the job as payload' do
        expect(execute).to be_error
        expect(execute.payload[:job]).to eq(job)
        expect(execute.message).to eq('this is an error')
      end
    end

    context 'exclusive lock' do
      let(:lock_uuid) { 'test' }
      let(:lock_key) { ""ci:pipelines:#{pipeline.id}:add-job"" }
      let(:lock_timeout) { 1.minute }

      before do
        # ""Please stub a default value first if message might be received with other args as well.""
        allow(Gitlab::ExclusiveLease).to receive(:new).and_call_original
      end

      it 'uses exclusive lock' do
        lease = stub_exclusive_lease(lock_key, lock_uuid, timeout: lock_timeout)
        expect(lease).to receive(:try_obtain)
        expect(lease).to receive(:cancel)

        expect(execute).to be_success
        expect(execute.payload[:job]).to eq(job)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module Pipelines
    class HookService
      include Gitlab::Utils::StrongMemoize

      HOOK_NAME = :pipeline_hooks

      def initialize(pipeline)
        @pipeline = pipeline
      end

      def execute
        project.execute_hooks(hook_data, HOOK_NAME) if project.has_active_hooks?(HOOK_NAME)
        project.execute_integrations(hook_data, HOOK_NAME) if project.has_active_integrations?(HOOK_NAME)
      end

      private

      attr_reader :pipeline

      def project
        @project ||= pipeline.project
      end

      def hook_data
        strong_memoize(:hook_data) do
          Gitlab::DataBuilder::Pipeline.build(pipeline)
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::Pipelines::HookService, feature_category: :continuous_integration do
  describe '#execute_hooks' do
    let_it_be(:namespace) { create(:namespace) }
    let_it_be(:project) { create(:project, :repository, namespace: namespace) }
    let_it_be(:pipeline, reload: true) { create(:ci_empty_pipeline, :created, project: project) }

    let(:hook_enabled) { true }
    let!(:hook) { create(:project_hook, project: project, pipeline_events: hook_enabled) }
    let(:hook_data) { double }

    subject(:service) { described_class.new(pipeline) }

    describe 'HOOK_NAME' do
      specify { expect(described_class::HOOK_NAME).to eq(:pipeline_hooks) }
    end

    context 'with pipeline hooks enabled' do
      before do
        allow(Gitlab::DataBuilder::Pipeline).to receive(:build).with(pipeline).once.and_return(hook_data)
      end

      it 'calls pipeline.project.execute_hooks and pipeline.project.execute_integrations' do
        create(:pipelines_email_integration, project: project)

        expect(pipeline.project).to receive(:execute_hooks).with(hook_data, described_class::HOOK_NAME)
        expect(pipeline.project).to receive(:execute_integrations).with(hook_data, described_class::HOOK_NAME)

        service.execute
      end
    end

    context 'with pipeline hooks and integrations disabled' do
      let(:hook_enabled) { false }

      it 'does not call pipeline.project.execute_hooks and pipeline.project.execute_integrations' do
        expect(pipeline.project).not_to receive(:execute_hooks)
        expect(pipeline.project).not_to receive(:execute_integrations)

        service.execute
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module Pipelines
    class UpdateMetadataService
      def initialize(pipeline, params)
        @pipeline = pipeline
        @params = params
      end

      def execute
        metadata = pipeline.pipeline_metadata

        metadata = pipeline.build_pipeline_metadata(project: pipeline.project) if metadata.nil?

        params[:name] = params[:name].strip if params.key?(:name)

        if metadata.update(params)
          ServiceResponse.success(message: 'Pipeline metadata was updated', payload: pipeline)
        else
          ServiceResponse.error(message: 'Failed to update pipeline', payload: metadata.errors.full_messages,
            reason: :bad_request)
        end
      end

      private

      attr_reader :pipeline, :params
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::Pipelines::UpdateMetadataService, feature_category: :continuous_integration do
  subject(:execute) { described_class.new(pipeline, { name: name }).execute }

  let(:name) { 'Some random pipeline name' }

  context 'when pipeline has no name' do
    let(:pipeline) { create(:ci_pipeline) }

    it 'updates the name' do
      expect { execute }.to change { pipeline.reload.name }.to(name)
    end
  end

  context 'when pipeline has a name' do
    let(:pipeline) { create(:ci_pipeline, name: 'Some other name') }

    it 'updates the name' do
      expect { execute }.to change { pipeline.reload.name }.to(name)
    end
  end

  context 'when new name is too long' do
    let(:pipeline) { create(:ci_pipeline) }
    let(:name) { 'a' * 256 }

    it 'does not update the name' do
      expect { execute }.not_to change { pipeline.reload.name }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Ci
  module PipelineArtifacts
    class CreateCodeQualityMrDiffReportService
      include Gitlab::Utils::StrongMemoize

      def initialize(pipeline)
        @pipeline = pipeline
      end

      def execute
        return unless pipeline.can_generate_codequality_reports?
        return if pipeline.has_codequality_mr_diff_report?
        return unless new_errors_introduced?

        Ci::PipelineArtifact.create_or_replace_for_pipeline!(**artifact_attributes)
      end

      private

      attr_reader :pipeline

      def artifact_attributes
        file = build_carrierwave_file!

        {
          pipeline: pipeline,
          file_type: :code_quality_mr_diff,
          size: file[""tempfile""].size,
          file: file,
          locked: pipeline.locked
        }
      end

      def merge_requests
        strong_memoize(:merge_requests) do
          pipeline.merge_requests_as_head_pipeline
        end
      end

      def head_report
        strong_memoize(:head_report) do
          pipeline.codequality_reports
        end
      end

      def base_report(merge_request)
        strong_memoize(:base_report) do
          merge_request&.base_pipeline&.codequality_reports
        end
      end

      def mr_diff_report_by_merge_requests
        strong_memoize(:mr_diff_report_by_merge_requests) do
          merge_requests.each_with_object({}) do |merge_request, hash|
            key = ""merge_request_#{merge_request.id}""
            new_errors = Gitlab::Ci::Reports::CodequalityReportsComparer.new(base_report(merge_request), head_report).new_errors
            next if new_errors.empty?

            hash[key] = Gitlab::Ci::Reports::CodequalityMrDiff.new(new_errors)
          end
        end
      end

      def new_errors_introduced?
        mr_diff_report_by_merge_requests.present?
      end

      def build_carrierwave_file!
        CarrierWaveStringFile.new_file(
          file_content: build_quality_mr_diff_report(mr_diff_report_by_merge_requests),
          filename: Ci::PipelineArtifact::DEFAULT_FILE_NAMES.fetch(:code_quality_mr_diff),
          content_type: 'application/json'
        )
      end

      def build_quality_mr_diff_report(mr_diff_report)
        Gitlab::Json.dump(mr_diff_report.each_with_object({}) do |diff_report, hash|
          hash[diff_report.first] = Ci::CodequalityMrDiffReportSerializer.new.represent(diff_report.second) # rubocop: disable CodeReuse/Serializer
        end)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ci::PipelineArtifacts::CreateCodeQualityMrDiffReportService, feature_category: :build_artifacts do
  describe '#execute' do
    let(:merge_request) { create(:merge_request) }
    let(:project) { merge_request.project }
    let(:head_pipeline) { create(:ci_pipeline, :success, :with_codequality_reports, project: project, merge_requests_as_head_pipeline: [merge_request]) }
    let(:base_pipeline) { create(:ci_pipeline, :success, project: project, ref: merge_request.target_branch, sha: merge_request.diff_base_sha) }

    subject { described_class.new(head_pipeline).execute }

    context 'when there are codequality reports' do
      context 'when pipeline passes' do
        context 'when degradations are present' do
          context 'when degradations already present in target branch pipeline' do
            before do
              create(:ci_build, :success, :codequality_reports, name: 'codequality', pipeline: base_pipeline, project: project)
            end

            it ""does not persist a pipeline artifact"" do
              expect { subject }.not_to change { Ci::PipelineArtifact.count }
            end
          end

          context 'when degradation is not present in target branch pipeline' do
            before do
              create(:ci_build, :success, :codequality_reports_without_degradation, name: 'codequality', pipeline: base_pipeline, project: project)
            end

            it 'persists a pipeline artifact' do
              expect { subject }.to change { Ci::PipelineArtifact.count }.by(1)
            end

            it 'persists the default file name' do
              subject

              pipeline_artifact = Ci::PipelineArtifact.first

              expect(pipeline_artifact.file.filename).to eq('code_quality_mr_diff.json')
            end

            it 'sets expire_at to 1 week' do
              freeze_time do
                subject

                pipeline_artifact = Ci::PipelineArtifact.first

                expect(pipeline_artifact.expire_at).to eq(1.week.from_now)
              end
            end

            it ""artifact has pipeline's locked status"" do
              subject

              artifact = Ci::PipelineArtifact.first

              expect(artifact.locked).to eq(head_pipeline.locked)
            end

            it 'does not persist the same artifact twice' do
              2.times { described_class.new(head_pipeline).execute }

              expect { subject }.not_to change { Ci::PipelineArtifact.count }
            end
          end
        end
      end
    end

    context 'when there are no codequality reports for head pipeline' do
      let(:head_pipeline) { create(:ci_pipeline, :success, project: project, merge_requests_as_head_pipeline: [merge_request]) }

      it ""does not persist a pipeline artifact"" do
        expect { subject }.not_to change { Ci::PipelineArtifact.count }
      end
    end

    context 'when there are no codequality reports for base pipeline' do
      let(:head_pipeline) { create(:ci_pipeline, :success, project: project, merge_requests_as_head_pipeline: [merge_request]) }

      it ""does not persist a pipeline artifact"" do
        expect { subject }.not_to change { Ci::PipelineArtifact.count }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Ci
  module PipelineArtifacts
    class CoverageReportService
      include Gitlab::Utils::StrongMemoize

      def initialize(pipeline)
        @pipeline = pipeline
      end

      def execute
        return if report.empty?

        Ci::PipelineArtifact.create_or_replace_for_pipeline!(**pipeline_artifact_params).tap do |pipeline_artifact|
          Gitlab::AppLogger.info(log_params(pipeline_artifact))
        end
      end

      private

      attr_reader :pipeline

      def report
        strong_memoize(:report) do
          Gitlab::Ci::Reports::CoverageReportGenerator.new(pipeline).report
        end
      end

      def pipeline_artifact_params
        {
          pipeline: pipeline,
          file_type: :code_coverage,
          file: carrierwave_file,
          size: carrierwave_file['tempfile'].size,
          locked: pipeline.locked
        }
      end

      def carrierwave_file
        strong_memoize(:carrier_wave_file) do
          CarrierWaveStringFile.new_file(
            file_content: Gitlab::Json.dump(report),
            filename: Ci::PipelineArtifact::DEFAULT_FILE_NAMES.fetch(:code_coverage),
            content_type: 'application/json'
          )
        end
      end

      def log_params(pipeline_artifact)
        {
          project_id: pipeline.project_id,
          pipeline_id: pipeline.id,
          pipeline_artifact_id: pipeline_artifact.id,
          message: ""Created code coverage for pipeline.""
        }
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::PipelineArtifacts::CoverageReportService, feature_category: :build_artifacts do
  describe '#execute' do
    let_it_be(:project) { create(:project, :repository) }

    subject { described_class.new(pipeline).execute }

    shared_examples 'creating or updating a pipeline coverage report' do
      context 'when pipeline is finished' do
        it 'creates or updates a pipeline artifact' do
          subject

          expect(pipeline.reload.pipeline_artifacts.count).to eq(1)
        end

        it 'persists the default file name' do
          subject

          file = Ci::PipelineArtifact.first.file

          expect(file.filename).to eq('code_coverage.json')
        end

        it 'sets expire_at to 1 week from now' do
          freeze_time do
            subject

            pipeline_artifact = Ci::PipelineArtifact.first

            expect(pipeline_artifact.expire_at).to eq(1.week.from_now)
          end
        end

        it 'logs relevant information' do
          allow(Gitlab::AppLogger).to receive(:info).and_call_original
          expect(Gitlab::AppLogger).to receive(:info).with({
                                                             project_id: project.id,
                                                             pipeline_id: pipeline.id,
                                                             pipeline_artifact_id: kind_of(Numeric),
                                                             message: kind_of(String)
                                                           })

          subject
        end
      end
    end

    context 'when pipeline has coverage report' do
      let!(:pipeline) { create(:ci_pipeline, :with_coverage_reports, project: project) }

      it_behaves_like 'creating or updating a pipeline coverage report'

      it ""artifact has pipeline's locked status"" do
        subject

        artifact = Ci::PipelineArtifact.first

        expect(artifact.locked).to eq(pipeline.locked)
      end
    end

    context 'when pipeline has coverage report from child pipeline' do
      let!(:pipeline) { create(:ci_pipeline, :success, project: project) }
      let!(:child_pipeline) { create(:ci_pipeline, :with_coverage_reports, project: project, child_of: pipeline) }

      it_behaves_like 'creating or updating a pipeline coverage report'
    end

    context 'when pipeline has existing pipeline artifact for coverage report' do
      let!(:pipeline) { create(:ci_pipeline, :with_coverage_reports, project: project) }
      let!(:child_pipeline) { create(:ci_pipeline, :with_coverage_reports, project: project, child_of: pipeline) }

      let!(:pipeline_artifact) do
        create(:ci_pipeline_artifact, :with_coverage_report, pipeline: pipeline, expire_at: 1.day.from_now)
      end

      it_behaves_like 'creating or updating a pipeline coverage report'
    end

    context 'when pipeline is running and coverage report does not exist' do
      let(:pipeline) { create(:ci_pipeline, :running) }

      it 'does not persist data' do
        expect { subject }.not_to change { Ci::PipelineArtifact.count }.from(0)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module PipelineArtifacts
    class DestroyAllExpiredService
      include ::Gitlab::ExclusiveLeaseHelpers
      include ::Gitlab::LoopHelpers
      include ::Gitlab::Utils::StrongMemoize

      BATCH_SIZE = 100
      LOOP_LIMIT = 1000
      LOOP_TIMEOUT = 5.minutes
      LOCK_TIMEOUT = 10.minutes
      EXCLUSIVE_LOCK_KEY = 'expired_pipeline_artifacts:destroy:lock'

      def initialize
        @removed_artifacts_count = 0
        @start_at = Time.current
      end

      def execute
        in_lock(EXCLUSIVE_LOCK_KEY, ttl: LOCK_TIMEOUT, retries: 1) do
          destroy_unlocked_pipeline_artifacts

          legacy_destroy_pipeline_artifacts
        end

        @removed_artifacts_count
      end

      private

      def destroy_unlocked_pipeline_artifacts
        loop_until(timeout: LOOP_TIMEOUT, limit: LOOP_LIMIT) do
          artifacts = Ci::PipelineArtifact.expired_before(@start_at).artifact_unlocked.limit(BATCH_SIZE)

          break if artifacts.empty?

          destroy_batch(artifacts)
        end
      end

      def legacy_destroy_pipeline_artifacts
        loop_until(timeout: LOOP_TIMEOUT, limit: LOOP_LIMIT) do
          destroy_artifacts_batch
        end
      end

      def destroy_artifacts_batch
        artifacts = ::Ci::PipelineArtifact.unlocked.expired.limit(BATCH_SIZE).to_a
        return false if artifacts.empty?

        destroy_batch(artifacts)
      end

      def destroy_batch(artifacts)
        artifacts.each(&:destroy!)
        increment_stats(artifacts.size)

        true
      end

      def increment_stats(size)
        destroyed_artifacts_counter.increment({}, size)
        @removed_artifacts_count += size
      end

      def destroyed_artifacts_counter
        strong_memoize(:destroyed_artifacts_counter) do
          name = :destroyed_pipeline_artifacts_count_total
          comment = 'Counter of destroyed expired pipeline artifacts'

          ::Gitlab::Metrics.counter(name, comment)
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::PipelineArtifacts::DestroyAllExpiredService, :clean_gitlab_redis_shared_state,
  feature_category: :build_artifacts do
  let(:service) { described_class.new }

  describe '.execute' do
    subject { service.execute }

    context 'when timeout happens' do
      before do
        stub_const('Ci::PipelineArtifacts::DestroyAllExpiredService::LOOP_TIMEOUT', 0.1.seconds)
        allow(service).to receive(:destroy_artifacts_batch) { true }
      end

      it 'returns 0 and does not continue destroying' do
        is_expected.to eq(0)
      end
    end

    context 'when there are no artifacts' do
      it 'does not raise error' do
        expect { subject }.not_to raise_error
      end
    end

    context 'when the loop limit is reached' do
      before do
        stub_const('::Ci::PipelineArtifacts::DestroyAllExpiredService::LOOP_LIMIT', 1)
        stub_const('::Ci::PipelineArtifacts::DestroyAllExpiredService::BATCH_SIZE', 1)

        create_list(:ci_pipeline_artifact, 2, :unlocked, expire_at: 1.week.ago)
      end

      it 'destroys one artifact' do
        expect { subject }.to change { Ci::PipelineArtifact.count }.by(-1)
      end

      it 'reports the number of destroyed artifacts' do
        is_expected.to eq(1)
      end
    end

    context 'when there are artifacts more than batch sizes' do
      before do
        stub_const('Ci::PipelineArtifacts::DestroyAllExpiredService::BATCH_SIZE', 1)

        create_list(:ci_pipeline_artifact, 2, :unlocked, expire_at: 1.week.ago)
      end

      it 'destroys all expired artifacts' do
        expect { subject }.to change { Ci::PipelineArtifact.count }.by(-2)
      end

      it 'reports the number of destroyed artifacts' do
        is_expected.to eq(2)
      end
    end

    context 'when artifacts are not expired' do
      before do
        create(:ci_pipeline_artifact, :unlocked, expire_at: 2.days.from_now)
      end

      it 'does not destroy pipeline artifacts' do
        expect { subject }.not_to change { Ci::PipelineArtifact.count }
      end

      it 'reports the number of destroyed artifacts' do
        is_expected.to eq(0)
      end
    end

    context 'when pipeline is locked' do
      before do
        create(:ci_pipeline_artifact, expire_at: 2.weeks.ago)
      end

      it 'does not destroy pipeline artifacts' do
        expect { subject }.not_to change { Ci::PipelineArtifact.count }
      end

      it 'reports the number of destroyed artifacts' do
        is_expected.to eq(0)
      end
    end

    context 'with unlocked pipeline artifacts' do
      let_it_be(:not_expired_artifact) { create(:ci_pipeline_artifact, :artifact_unlocked, expire_at: 2.days.from_now) }

      before do
        create_list(:ci_pipeline_artifact, 2, :artifact_unlocked, expire_at: 1.week.ago)
        allow(service).to receive(:legacy_destroy_pipeline_artifacts)
      end

      it 'destroys all expired artifacts' do
        expect { subject }.to change { Ci::PipelineArtifact.count }.by(-2)
        expect(not_expired_artifact.reload).to be_present
      end

      context 'when the loop limit is reached' do
        before do
          stub_const('::Ci::PipelineArtifacts::DestroyAllExpiredService::LOOP_LIMIT', 1)
          stub_const('::Ci::PipelineArtifacts::DestroyAllExpiredService::BATCH_SIZE', 1)
        end

        it 'destroys one artifact' do
          expect { subject }.to change { Ci::PipelineArtifact.count }.by(-1)
          expect(not_expired_artifact.reload).to be_present
        end

        it 'reports the number of destroyed artifacts' do
          is_expected.to eq(1)
        end
      end
    end
  end

  describe '.destroy_artifacts_batch' do
    it 'returns a falsy value without artifacts' do
      expect(service.send(:destroy_artifacts_batch)).to be_falsy
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# This service is responsible for creating a pipeline for a given
# ExternalPullRequest coming from other providers such as GitHub.

module Ci
  module ExternalPullRequests
    class CreatePipelineService < BaseService
      def execute(pull_request)
        return pull_request_not_open_error unless pull_request.open?
        return pull_request_branch_error unless pull_request.actual_branch_head?

        Ci::ExternalPullRequests::CreatePipelineWorker.perform_async(
          project.id, current_user.id, pull_request.id
        )
      end

      private

      def pull_request_not_open_error
        ServiceResponse.error(message: 'The pull request is not opened', payload: nil)
      end

      def pull_request_branch_error
        ServiceResponse.error(message: 'The source sha is not the head of the source branch', payload: nil)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::ExternalPullRequests::CreatePipelineService, feature_category: :continuous_integration do
  describe '#execute' do
    let_it_be(:project) { create(:project, :auto_devops, :repository) }
    let_it_be(:user) { create(:user) }
    let_it_be_with_reload(:pull_request) { create(:external_pull_request, project: project) }

    before do
      project.add_maintainer(user)
    end

    subject(:execute) { described_class.new(project, user).execute(pull_request) }

    context 'when pull request is open' do
      before do
        pull_request.update!(status: :open)
      end

      context 'when source sha is the head of the source branch' do
        let(:source_branch) { project.repository.branches.last }

        before do
          pull_request.update!(source_branch: source_branch.name, source_sha: source_branch.target)
        end

        it 'enqueues Ci::ExternalPullRequests::CreatePipelineWorker' do
          expect { execute }
            .to change { ::Ci::ExternalPullRequests::CreatePipelineWorker.jobs.count }
            .by(1)

          args = ::Ci::ExternalPullRequests::CreatePipelineWorker.jobs.last['args']

          expect(args[0]).to eq(project.id)
          expect(args[1]).to eq(user.id)
          expect(args[2]).to eq(pull_request.id)
        end
      end

      context 'when source sha is not the head of the source branch (force push upon rebase)' do
        let(:source_branch) { project.repository.branches.first }
        let(:commit) { project.repository.commits(source_branch.name, limit: 2).last }

        before do
          pull_request.update!(source_branch: source_branch.name, source_sha: commit.sha)
        end

        it 'does nothing', :aggregate_failures do
          expect { execute }
            .not_to change { ::Ci::ExternalPullRequests::CreatePipelineWorker.jobs.count }

          expect(execute).to be_error
          expect(execute.message).to eq('The source sha is not the head of the source branch')
          expect(execute.payload).to be_nil
        end
      end
    end

    context 'when pull request is not opened' do
      before do
        pull_request.update!(status: :closed)
      end

      it 'does nothing', :aggregate_failures do
        expect { execute }
          .not_to change { ::Ci::ExternalPullRequests::CreatePipelineWorker.jobs.count }

        expect(execute).to be_error
        expect(execute.message).to eq('The pull request is not opened')
        expect(execute.payload).to be_nil
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module Components
    class FetchService
      include Gitlab::Utils::StrongMemoize

      COMPONENT_PATHS = [
        ::Gitlab::Ci::Components::InstancePath
      ].freeze

      def initialize(address:, current_user:)
        @address = address
        @current_user = current_user
      end

      def execute
        unless component_path_class
          return ServiceResponse.error(
            message: ""#{error_prefix} the component path is not supported"",
            reason: :unsupported_path)
        end

        component_path = component_path_class.new(address: address)
        result = component_path.fetch_content!(current_user: current_user)

        if result
          ServiceResponse.success(payload: {
            content: result.content,
            path: result.path,
            project: component_path.project,
            sha: component_path.sha
          })
        else
          ServiceResponse.error(message: ""#{error_prefix} content not found"", reason: :content_not_found)
        end
      rescue Gitlab::Access::AccessDeniedError
        ServiceResponse.error(
          message: ""#{error_prefix} project does not exist or you don't have sufficient permissions"",
          reason: :not_allowed)
      end

      private

      attr_reader :current_user, :address

      def component_path_class
        COMPONENT_PATHS.find { |klass| klass.match?(address) }
      end
      strong_memoize_attr :component_path_class

      def error_prefix
        ""component '#{address}' -""
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::Components::FetchService, feature_category: :pipeline_composition do
  let_it_be(:user) { create(:user) }
  let_it_be(:current_user) { user }
  let_it_be(:current_host) { Gitlab.config.gitlab.host }
  let_it_be(:content) do
    <<~COMPONENT
    job:
      script: echo
    COMPONENT
  end

  let(:service) do
    described_class.new(address: address, current_user: current_user)
  end

  let_it_be(:project) do
    project = create(
      :project, :custom_repo,
      files: {
        'template.yml' => content,
        'my-component/template.yml' => content,
        'my-dir/my-component/template.yml' => content
      }
    )

    project.repository.add_tag(project.creator, 'v0.1', project.repository.commit.sha)

    project
  end

  before do
    project.add_developer(user)
  end

  describe '#execute', :aggregate_failures do
    subject(:result) { service.execute }

    shared_examples 'an external component' do
      shared_examples 'component address' do
        context 'when content exists' do
          it 'returns the content' do
            expect(result).to be_success
            expect(result.payload[:content]).to eq(content)
          end
        end

        context 'when content does not exist' do
          let(:address) { ""#{current_host}/#{component_path}@~version-does-not-exist"" }

          it 'returns an error' do
            expect(result).to be_error
            expect(result.reason).to eq(:content_not_found)
          end
        end
      end

      context 'when user does not have permissions to read the code' do
        let(:version) { 'master' }
        let(:current_user) { create(:user) }

        it 'returns an error' do
          expect(result).to be_error
          expect(result.reason).to eq(:not_allowed)
        end
      end

      context 'when version is a branch name' do
        it_behaves_like 'component address' do
          let(:version) { project.default_branch }
        end
      end

      context 'when version is a tag name' do
        it_behaves_like 'component address' do
          let(:version) { project.repository.tags.first.name }
        end
      end

      context 'when version is a commit sha' do
        it_behaves_like 'component address' do
          let(:version) { project.repository.tags.first.id }
        end
      end

      context 'when version is not provided' do
        let(:version) { nil }

        it 'returns an error' do
          expect(result).to be_error
          expect(result.reason).to eq(:content_not_found)
        end
      end

      context 'when project does not exist' do
        let(:component_path) { 'unknown/component' }
        let(:version) { '1.0' }

        it 'returns an error' do
          expect(result).to be_error
          expect(result.reason).to eq(:content_not_found)
        end
      end

      context 'when host is different than the current instance host' do
        let(:current_host) { 'another-host.com' }
        let(:version) { '1.0' }

        it 'returns an error' do
          expect(result).to be_error
          expect(result.reason).to eq(:unsupported_path)
        end
      end
    end

    context 'when address points to an external component' do
      let(:address) { ""#{current_host}/#{component_path}@#{version}"" }

      context 'when component path is the full path to a project' do
        let(:component_path) { project.full_path }
        let(:component_yaml_path) { 'template.yml' }

        it_behaves_like 'an external component'
      end

      context 'when component path points to a directory in a project' do
        let(:component_path) { ""#{project.full_path}/my-component"" }
        let(:component_yaml_path) { 'my-component/template.yml' }

        it_behaves_like 'an external component'
      end

      context 'when component path points to a nested directory in a project' do
        let(:component_path) { ""#{project.full_path}/my-dir/my-component"" }
        let(:component_yaml_path) { 'my-dir/my-component/template.yml' }

        it_behaves_like 'an external component'
      end
    end
  end

  def stub_project_blob(ref, path, content)
    allow_next_instance_of(Repository) do |instance|
      allow(instance).to receive(:blob_data_at).with(ref, path).and_return(content)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module PrometheusMetrics
    class ObserveHistogramsService
      class << self
        def available_histograms
          @available_histograms ||= [
            histogram(:pipeline_graph_link_calculation_duration_seconds, 'Total time spent calculating links, in seconds', {}, [0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.8, 1, 2]),
            histogram(:pipeline_graph_links_total, 'Number of links per graph', {}, [1, 5, 10, 25, 50, 100, 200]),
            histogram(:pipeline_graph_links_per_job_ratio, 'Ratio of links to job per graph', {}, [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1])
          ].to_h
        end

        private

        def histogram(name, *attrs)
          [name.to_s, proc { Gitlab::Metrics.histogram(name, *attrs) }]
        end
      end

      def initialize(project, params)
        @project = project
        @params = params
      end

      def execute
        params
          .fetch(:histograms, [])
          .each { |data| observe(data) }

        ServiceResponse.success(http_status: :created)
      end

      private

      attr_reader :project, :params

      def observe(data)
        histogram = find_histogram(data[:name])
        histogram.observe({}, data[:value].to_f)
      end

      def find_histogram(name)
        self.class.available_histograms
          .fetch(name) { raise ActiveRecord::RecordNotFound }
          .call
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::PrometheusMetrics::ObserveHistogramsService, feature_category: :continuous_integration do
  let_it_be(:project) { create(:project) }

  let(:params) { {} }

  subject(:execute) { described_class.new(project, params).execute }

  before do
    Gitlab::Metrics.reset_registry!
  end

  context 'with empty data' do
    it 'does not raise errors' do
      is_expected.to be_success
    end
  end

  context 'observes metrics successfully' do
    let(:params) do
      {
        histograms: [
          { name: 'pipeline_graph_link_calculation_duration_seconds', value: '1' },
          { name: 'pipeline_graph_links_per_job_ratio', value: '0.9' }
        ]
      }
    end

    it 'increments the metrics' do
      execute

      expect(histogram_data).to match(a_hash_including({ 0.8 => 0.0, 1 => 1.0, 2 => 1.0 }))

      expect(histogram_data(:pipeline_graph_links_per_job_ratio))
        .to match(a_hash_including({ 0.8 => 0.0, 0.9 => 1.0, 1 => 1.0 }))
    end

    it 'returns an empty body and status code' do
      is_expected.to be_success
      expect(subject.http_status).to eq(:created)
      expect(subject.payload).to eq({})
    end
  end

  context 'with unknown histograms' do
    let(:params) do
      { histograms: [{ name: 'chunky_bacon', value: '4' }] }
    end

    it 'raises ActiveRecord::RecordNotFound error' do
      expect { subject }.to raise_error ActiveRecord::RecordNotFound
    end
  end

  def histogram_data(name = :pipeline_graph_link_calculation_duration_seconds)
    Gitlab::Metrics.registry.get(name)&.get({})
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module Refs
    class EnqueuePipelinesToUnlockService
      include BaseServiceUtility

      BATCH_SIZE = 50
      ENQUEUE_INTERVAL_SECONDS = 0.1
      EXCLUDED_IDS_LIMIT = 1000

      def execute(ci_ref, before_pipeline: nil)
        total_new_entries = 0

        pipelines_scope(ci_ref, before_pipeline).each_batch(of: BATCH_SIZE) do |batch|
          pipeline_ids = batch.pluck(:id) # rubocop: disable CodeReuse/ActiveRecord
          total_added = Ci::UnlockPipelineRequest.enqueue(pipeline_ids)
          total_new_entries += total_added

          # Take a little rest to avoid overloading Redis
          sleep ENQUEUE_INTERVAL_SECONDS
        end

        success(
          total_pending_entries: Ci::UnlockPipelineRequest.total_pending,
          total_new_entries: total_new_entries
        )
      end

      private

      def pipelines_scope(ci_ref, before_pipeline)
        scope = ci_ref.pipelines.artifacts_locked

        if before_pipeline
          # We use `same_family_pipeline_ids.map(&:id)` to force run the query and
          # specifically pass the array of IDs to the NOT IN condition. If not, we would
          # end up running the subquery for same_family_pipeline_ids on each batch instead.
          excluded_ids = before_pipeline.same_family_pipeline_ids.map(&:id)
          scope = scope.created_before_id(before_pipeline.id)

          # When unlocking previous pipelines, we still want to keep the
          # last successful CI source pipeline locked.
          # If before_pipeline is not provided, like in the case of deleting a ref,
          # we want to unlock all pipelines instead.
          ci_ref.last_successful_ci_source_pipeline.try do |pipeline|
            excluded_ids.concat(pipeline.same_family_pipeline_ids.map(&:id))
          end

          # We add a limit to the excluded IDs just to be safe and avoid any
          # arity issues with the NOT IN query.
          scope = scope.where.not(id: excluded_ids.take(EXCLUDED_IDS_LIMIT)) # rubocop: disable CodeReuse/ActiveRecord
        end

        scope
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::Refs::EnqueuePipelinesToUnlockService, :unlock_pipelines, :clean_gitlab_redis_shared_state, feature_category: :build_artifacts do
  describe '#execute' do
    let_it_be(:ref) { 'master' }
    let_it_be(:project) { create(:project) }
    let_it_be(:tag_ref_path) { ""#{::Gitlab::Git::TAG_REF_PREFIX}#{ref}"" }
    let_it_be(:ci_ref_tag) { create(:ci_ref, ref_path: tag_ref_path, project: project) }
    let_it_be(:branch_ref_path) { ""#{::Gitlab::Git::BRANCH_REF_PREFIX}#{ref}"" }
    let_it_be(:ci_ref_branch) { create(:ci_ref, ref_path: branch_ref_path, project: project) }
    let_it_be(:other_ref) { 'other_ref' }
    let_it_be(:other_ref_path) { ""#{::Gitlab::Git::BRANCH_REF_PREFIX}#{other_ref}"" }
    let_it_be(:other_ci_ref) { create(:ci_ref, ref_path: other_ref_path, project: project) }

    let(:service) { described_class.new }

    subject(:execute) { service.execute(target_ref, before_pipeline: before_pipeline) }

    before do
      stub_const(""#{described_class}::BATCH_SIZE"", 2)
      stub_const(""#{described_class}::ENQUEUE_INTERVAL_SECONDS"", 0)
    end

    shared_examples_for 'unlocking pipelines' do
      let(:is_tag) { target_ref.ref_path.include?(::Gitlab::Git::TAG_REF_PREFIX) }

      let!(:other_ref_pipeline) { create_pipeline(:locked, other_ref, :failed, tag: false) }
      let!(:old_unlocked_pipeline) { create_pipeline(:unlocked, ref, :failed) }
      let!(:old_locked_pipeline_1) { create_pipeline(:locked, ref, :failed) }
      let!(:old_locked_pipeline_2) { create_pipeline(:locked, ref, :success) }
      let!(:old_locked_pipeline_3) { create_pipeline(:locked, ref, :success) }
      let!(:old_locked_pipeline_3_child) { create_pipeline(:locked, ref, :success, child_of: old_locked_pipeline_3) }
      let!(:old_locked_pipeline_4) { create_pipeline(:locked, ref, :success) }
      let!(:old_locked_pipeline_4_child) { create_pipeline(:locked, ref, :success, child_of: old_locked_pipeline_4) }
      let!(:old_locked_pipeline_5) { create_pipeline(:locked, ref, :failed) }
      let!(:old_locked_pipeline_5_child) { create_pipeline(:locked, ref, :success, child_of: old_locked_pipeline_5) }
      let!(:pipeline) { create_pipeline(:locked, ref, :failed) }
      let!(:child_pipeline) { create_pipeline(:locked, ref, :failed, child_of: pipeline) }
      let!(:newer_pipeline) { create_pipeline(:locked, ref, :failed) }

      context 'when before_pipeline is given' do
        let(:before_pipeline) { pipeline }

        it 'only enqueues old locked pipelines within the ref, excluding the last successful CI source pipeline' do
          expect { execute }
            .to change { pipeline_ids_waiting_to_be_unlocked }
            .from([])
            .to([
              old_locked_pipeline_1.id,
              old_locked_pipeline_2.id,
              old_locked_pipeline_3.id,
              old_locked_pipeline_3_child.id,
              old_locked_pipeline_5.id,
              old_locked_pipeline_5_child.id
            ])

          expect(execute).to include(
            status: :success,
            total_pending_entries: 6,
            total_new_entries: 6
          )
        end
      end

      context 'when before_pipeline is not given' do
        let(:before_pipeline) { nil }

        it 'enqueues all locked pipelines within the ref' do
          expect { execute }
            .to change { pipeline_ids_waiting_to_be_unlocked }
            .from([])
            .to([
              old_locked_pipeline_1.id,
              old_locked_pipeline_2.id,
              old_locked_pipeline_3.id,
              old_locked_pipeline_3_child.id,
              old_locked_pipeline_4.id,
              old_locked_pipeline_4_child.id,
              old_locked_pipeline_5.id,
              old_locked_pipeline_5_child.id,
              pipeline.id,
              child_pipeline.id,
              newer_pipeline.id
            ])

          expect(execute).to include(
            status: :success,
            total_pending_entries: 11,
            total_new_entries: 11
          )
        end
      end
    end

    context 'when ref is a tag' do
      let(:target_ref) { ci_ref_tag }

      it_behaves_like 'unlocking pipelines'
    end

    context 'when ref is a branch' do
      let(:target_ref) { ci_ref_branch }

      it_behaves_like 'unlocking pipelines'
    end

    def create_pipeline(type, ref, status, tag: is_tag, child_of: nil)
      trait = type == :locked ? :artifacts_locked : :unlocked
      create(:ci_pipeline, trait, status: status, ref: ref, tag: tag, project: project, child_of: child_of).tap do |p|
        if child_of
          build = create(:ci_build, pipeline: child_of)
          create(:ci_sources_pipeline, source_job: build, source_project: project, pipeline: p, project: project)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module Queue
    class PendingBuildsStrategy
      attr_reader :runner

      def initialize(runner)
        @runner = runner
      end

      # rubocop:disable CodeReuse/ActiveRecord
      def builds_for_shared_runner
        shared_builds = builds_available_for_shared_runners

        builds_ordered_for_shared_runners(shared_builds)
      end

      def builds_for_group_runner
        return new_builds.none if runner.namespace_ids.empty?

        new_builds_relation = new_builds.where('ci_pending_builds.namespace_traversal_ids && ARRAY[?]::int[]', runner.namespace_ids)

        return order(new_builds_relation) if ::Feature.enabled?(:order_builds_for_group_runner)

        new_builds_relation
      end

      def builds_matching_tag_ids(relation, ids)
        relation.for_tags(runner.tags_ids)
      end

      def builds_with_any_tags(relation)
        relation.where('cardinality(tag_ids) > 0')
      end

      def order(relation)
        relation.order('build_id ASC')
      end

      def new_builds
        ::Ci::PendingBuild.all
      end

      def build_ids(relation)
        relation.pluck(:build_id)
      end

      private

      def builds_available_for_shared_runners
        new_builds.with_instance_runners
      end

      def builds_ordered_for_shared_runners(relation)
        if Feature.enabled?(:ci_queueing_disaster_recovery_disable_fair_scheduling, runner, type: :ops)
          # if disaster recovery is enabled, we fallback to FIFO scheduling
          relation.order('ci_pending_builds.build_id ASC')
        else
          # Implements Fair Scheduling
          # Builds are ordered by projects that have the fewest running builds.
          # This keeps projects that create many builds at once from hogging capacity but
          # has the downside of penalizing projects with lots of builds created in a short period of time
          relation
            .with(running_builds_for_shared_runners_cte.to_arel)
            .joins(""LEFT JOIN project_builds ON ci_pending_builds.project_id = project_builds.project_id"")
            .order(Arel.sql('COALESCE(project_builds.running_builds, 0) ASC'), 'ci_pending_builds.build_id ASC')
        end
      end

      def running_builds_for_shared_runners_cte
        running_builds = ::Ci::RunningBuild
          .instance_type
          .group(:project_id)
          .select(:project_id, 'COUNT(*) AS running_builds')

        ::Gitlab::SQL::CTE
          .new(:project_builds, running_builds, materialized: true)
      end
      # rubocop:enable CodeReuse/ActiveRecord
    end
  end
end

Ci::Queue::PendingBuildsStrategy.prepend_mod_with('Ci::Queue::PendingBuildsStrategy')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::Queue::PendingBuildsStrategy, feature_category: :continuous_integration do
  let_it_be(:group) { create(:group) }
  let_it_be(:group_runner) { create(:ci_runner, :group, groups: [group]) }
  let_it_be(:project) { create(:project, group: group) }
  let_it_be(:pipeline) { create(:ci_pipeline, project: project) }

  let!(:build_1) { create(:ci_build, :created, pipeline: pipeline) }
  let!(:build_2) { create(:ci_build, :created, pipeline: pipeline) }
  let!(:build_3) { create(:ci_build, :created, pipeline: pipeline) }
  let!(:pending_build_1) { create(:ci_pending_build, build: build_2, project: project) }
  let!(:pending_build_2) { create(:ci_pending_build, build: build_3, project: project) }
  let!(:pending_build_3) { create(:ci_pending_build, build: build_1, project: project) }

  describe 'builds_for_group_runner' do
    it 'returns builds ordered by build ID' do
      strategy = described_class.new(group_runner)
      expect(strategy.builds_for_group_runner).to eq([pending_build_3, pending_build_1, pending_build_2])
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module Runners
    class UpdateRunnerService
      attr_reader :runner

      def initialize(runner)
        @runner = runner
      end

      def execute(params)
        params[:active] = !params.delete(:paused) if params.include?(:paused)

        if runner.update(params)
          runner.tick_runner_queue
          ServiceResponse.success
        else
          ServiceResponse.error(message: runner.errors.full_messages)
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::Runners::UpdateRunnerService, '#execute', feature_category: :runner_fleet do
  subject(:execute) { described_class.new(runner).execute(params) }

  let(:runner) { create(:ci_runner) }

  before do
    allow(runner).to receive(:tick_runner_queue)
  end

  context 'with description params' do
    let(:params) { { description: 'new runner' } }

    it 'updates the runner and ticking the queue' do
      expect(execute).to be_success

      runner.reload

      expect(runner).to have_received(:tick_runner_queue)
      expect(runner.description).to eq('new runner')
    end
  end

  context 'with paused param' do
    let(:params) { { paused: true } }

    it 'updates the runner and ticking the queue' do
      expect(runner.active).to be_truthy
      expect(execute).to be_success

      runner.reload

      expect(runner).to have_received(:tick_runner_queue)
      expect(runner.active).to be_falsey
    end
  end

  context 'with cost factor params' do
    let(:params) { { public_projects_minutes_cost_factor: 1.1, private_projects_minutes_cost_factor: 2.2 } }

    it 'updates the runner cost factors' do
      expect(execute).to be_success

      runner.reload

      expect(runner.public_projects_minutes_cost_factor).to eq(1.1)
      expect(runner.private_projects_minutes_cost_factor).to eq(2.2)
    end
  end

  context 'when params are not valid' do
    let(:params) { { run_untagged: false } }

    it 'does not update and returns error because it is not valid' do
      expect(execute).to be_error

      runner.reload

      expect(runner).not_to have_received(:tick_runner_queue)
      expect(runner.run_untagged).to be_truthy
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module Runners
    class SetRunnerAssociatedProjectsService
      # @param [Ci::Runner] runner: the project runner to assign/unassign projects from
      # @param [User] current_user: the user performing the operation
      # @param [Array<Integer>] project_ids: the IDs of the associated projects to assign the runner to
      def initialize(runner:, current_user:, project_ids:)
        @runner = runner
        @current_user = current_user
        @project_ids = project_ids
      end

      def execute
        unless current_user&.can?(:assign_runner, runner)
          return ServiceResponse.error(message: 'user not allowed to assign runner', http_status: :forbidden)
        end

        return ServiceResponse.success if project_ids.nil?

        set_associated_projects
      end

      private

      def set_associated_projects
        new_project_ids = [runner.owner_project.id] + project_ids

        response = ServiceResponse.success
        runner.transaction do
          # rubocop:disable CodeReuse/ActiveRecord
          current_project_ids = runner.projects.ids
          # rubocop:enable CodeReuse/ActiveRecord

          response = associate_new_projects(new_project_ids, current_project_ids)
          response = disassociate_old_projects(new_project_ids, current_project_ids) if response.success?
          raise ActiveRecord::Rollback, response.errors unless response.success?
        end

        response
      end

      def associate_new_projects(new_project_ids, current_project_ids)
        missing_projects = Project.id_in(new_project_ids - current_project_ids)

        unless missing_projects.all? { |project| current_user.can?(:register_project_runners, project) }
          return ServiceResponse.error(message: 'user is not authorized to add runners to project')
        end

        unless missing_projects.all? { |project| runner.assign_to(project, current_user) }
          return ServiceResponse.error(message: 'failed to assign projects to runner')
        end

        ServiceResponse.success
      end

      def disassociate_old_projects(new_project_ids, current_project_ids)
        projects_to_be_deleted = current_project_ids - new_project_ids
        return ServiceResponse.success if projects_to_be_deleted.empty?

        all_destroyed =
          Ci::RunnerProject
            .destroy_by(project_id: projects_to_be_deleted)
            .all?(&:destroyed?)
        return ServiceResponse.success if all_destroyed

        ServiceResponse.error(message: 'failed to destroy runner project')
      end

      attr_reader :runner, :current_user, :project_ids
    end
  end
end

Ci::Runners::SetRunnerAssociatedProjectsService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ci::Runners::SetRunnerAssociatedProjectsService, '#execute', feature_category: :runner_fleet do
  subject(:execute) do
    described_class.new(runner: runner, current_user: user, project_ids: new_projects.map(&:id)).execute
  end

  let_it_be(:owner_project) { create(:project) }
  let_it_be(:project2) { create(:project) }

  let(:original_projects) { [owner_project, project2] }
  let(:runner) { create(:ci_runner, :project, projects: original_projects) }

  context 'without user' do
    let(:user) { nil }
    let(:new_projects) { [project2] }

    it 'does not call assign_to on runner and returns error response', :aggregate_failures do
      expect(runner).not_to receive(:assign_to)

      expect(execute).to be_error
      expect(execute.message).to eq('user not allowed to assign runner')
    end
  end

  context 'with unauthorized user' do
    let(:user) { create(:user) }
    let(:new_projects) { [project2] }

    it 'does not call assign_to on runner and returns error message' do
      expect(runner).not_to receive(:assign_to)

      expect(execute).to be_error
      expect(execute.message).to eq('user not allowed to assign runner')
    end
  end

  context 'with authorized user' do
    let_it_be(:project3) { create(:project) }
    let_it_be(:project4) { create(:project) }

    let(:projects_with_maintainer_access) { original_projects }

    before do
      projects_with_maintainer_access.each { |project| project.add_maintainer(user) }
    end

    shared_context 'with successful requests' do
      context 'when disassociating a project' do
        let(:new_projects) { [project3, project4] }

        it 'reassigns associated projects and returns success response' do
          expect(execute).to be_success

          runner.reload

          expect(runner.owner_project).to eq(owner_project)
          expect(runner.projects.ids).to match_array([owner_project.id] + new_projects.map(&:id))
        end
      end

      context 'when disassociating no projects' do
        let(:new_projects) { [project2, project3] }

        it 'reassigns associated projects and returns success response' do
          expect(execute).to be_success

          runner.reload

          expect(runner.owner_project).to eq(owner_project)
          expect(runner.projects.ids).to match_array([owner_project.id] + new_projects.map(&:id))
        end
      end

      context 'when disassociating all projects' do
        let(:new_projects) { [] }

        it 'reassigns associated projects and returns success response' do
          expect(execute).to be_success

          runner.reload

          expect(runner.owner_project).to eq(owner_project)
          expect(runner.projects.ids).to contain_exactly(owner_project.id)
        end
      end
    end

    shared_context 'with failing destroy calls' do
      let(:new_projects) { [project3, project4] }

      it 'returns error response and rolls back transaction' do
        allow_next_found_instance_of(Ci::RunnerProject) do |runner_project|
          allow(runner_project).to receive(:destroy).and_return(false)
        end

        expect(execute).to be_error
        expect(runner.reload.projects.order(:id)).to eq(original_projects)
      end
    end

    context 'with maintainer user' do
      let(:user) { create(:user) }
      let(:projects_with_maintainer_access) { original_projects + new_projects }

      it_behaves_like 'with successful requests'
      it_behaves_like 'with failing destroy calls'

      context 'when associating new projects' do
        let(:new_projects) { [project3, project4] }

        context 'with missing permissions on one of the new projects' do
          let(:projects_with_maintainer_access) { original_projects + [project3] }

          it 'returns error response and rolls back transaction' do
            expect(execute).to be_error
            expect(execute.errors).to contain_exactly('user is not authorized to add runners to project')
            expect(runner.reload.projects.order(:id)).to eq(original_projects)
          end
        end
      end
    end

    context 'with admin user', :enable_admin_mode do
      let(:user) { create(:user, :admin) }
      let(:projects_with_maintainer_access) { original_projects + new_projects }

      it_behaves_like 'with successful requests'
      it_behaves_like 'with failing destroy calls'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module Runners
    class BulkDeleteRunnersService
      attr_reader :runners

      RUNNER_LIMIT = 50

      # @param runners [Array<Ci::Runner>] the runners to unregister/destroy
      # @param current_user [User] the user performing the operation
      def initialize(runners:, current_user:)
        @runners = runners
        @current_user = current_user
      end

      def execute
        if @runners
          # Delete a few runners immediately
          return delete_runners
        end

        ServiceResponse.success(payload: { deleted_count: 0, deleted_ids: [], errors: [] })
      end

      private

      def delete_runners
        runner_count = @runners.limit(RUNNER_LIMIT + 1).count
        authorized_runners_ids, unauthorized_runners_ids = compute_authorized_runners
        # rubocop:disable CodeReuse/ActiveRecord
        runners_to_be_deleted =
          Ci::Runner
            .where(id: authorized_runners_ids)
            .preload([:taggings, :runner_namespaces, :runner_projects])
        # rubocop:enable CodeReuse/ActiveRecord
        deleted_ids = runners_to_be_deleted.destroy_all.map(&:id) # rubocop:disable Cop/DestroyAll

        ServiceResponse.success(
          payload: {
            deleted_count: deleted_ids.count,
            deleted_ids: deleted_ids,
            errors: error_messages(runner_count, authorized_runners_ids, unauthorized_runners_ids)
          })
      end

      def compute_authorized_runners
        # rubocop:disable CodeReuse/ActiveRecord
        @current_user.ci_owned_runners.load # preload the owned runners to avoid an N+1
        authorized_runners, unauthorized_runners =
          @runners.limit(RUNNER_LIMIT)
                  .partition { |runner| Ability.allowed?(@current_user, :delete_runner, runner) }
        # rubocop:enable CodeReuse/ActiveRecord

        [authorized_runners.map(&:id), unauthorized_runners.map(&:id)]
      end

      def error_messages(runner_count, authorized_runners_ids, unauthorized_runners_ids)
        errors = []

        if runner_count > RUNNER_LIMIT
          errors << ""Can only delete up to #{RUNNER_LIMIT} runners per call. Ignored the remaining runner(s).""
        end

        if authorized_runners_ids.empty?
          errors << ""User does not have permission to delete any of the runners""
        elsif unauthorized_runners_ids.any?
          failed_ids = unauthorized_runners_ids.map { |runner_id| ""##{runner_id}"" }.join(', ')
          errors << ""User does not have permission to delete runner(s) #{failed_ids}""
        end

        errors
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ci::Runners::BulkDeleteRunnersService, '#execute', feature_category: :runner_fleet do
  subject(:execute) { described_class.new(**service_args).execute }

  let_it_be(:admin_user) { create(:user, :admin) }
  let_it_be_with_refind(:owner_user) { create(:user) } # discard memoized ci_owned_runners
  let_it_be(:group) { create(:group) }
  let_it_be(:project) { create(:project, group: group) }

  let(:user) {}
  let(:service_args) { { runners: runners_arg, current_user: user } }
  let(:runners_arg) {}

  context 'with runners specified' do
    let!(:instance_runner) { create(:ci_runner) }
    let!(:group_runner) { create(:ci_runner, :group, groups: [group]) }
    let!(:project_runner) { create(:ci_runner, :project, projects: [project]) }

    shared_examples 'a service deleting runners in bulk' do
      let!(:expected_deleted_ids) { expected_deleted_runners.map(&:id) }

      it 'destroys runners', :aggregate_failures do
        expect { execute }.to change { Ci::Runner.count }.by(-expected_deleted_ids.count)

        is_expected.to be_success
        expect(execute.payload).to eq(
          {
            deleted_count: expected_deleted_ids.count,
            deleted_ids: expected_deleted_ids,
            errors: []
          })
        expect { project_runner.runner_projects.first.reload }.to raise_error(ActiveRecord::RecordNotFound)
        expected_deleted_runners.each do |deleted_runner|
          expect(deleted_runner[:errors]).to be_nil
          expect { deleted_runner.reload }.to raise_error(ActiveRecord::RecordNotFound)
        end
      end

      context 'with too many runners specified' do
        before do
          stub_const(""#{described_class}::RUNNER_LIMIT"", 1)
        end

        it 'deletes only first RUNNER_LIMIT runners', :aggregate_failures do
          expect { execute }.to change { Ci::Runner.count }.by(-1)

          is_expected.to be_success
          expect(execute.payload).to eq(
            {
              deleted_count: 1,
              deleted_ids: expected_deleted_ids.take(1),
              errors: [""Can only delete up to 1 runners per call. Ignored the remaining runner(s).""]
            })
        end
      end
    end

    context 'when the user cannot delete runners' do
      let(:runners_arg) { Ci::Runner.all }

      context 'when user is not group owner' do
        before do
          group.add_developer(user)
        end

        let(:user) { create(:user) }

        it 'does not delete any runner and returns error', :aggregate_failures do
          expect { execute }.not_to change { Ci::Runner.count }
          expect(execute[:errors]).to match_array(""User does not have permission to delete any of the runners"")
        end
      end

      context 'when user is not part of the group' do
        let(:user) { create(:user) }

        it 'does not delete any runner and returns error', :aggregate_failures do
          expect { execute }.not_to change { Ci::Runner.count }
          expect(execute[:errors]).to match_array(""User does not have permission to delete any of the runners"")
        end
      end
    end

    context 'when the user can delete runners' do
      context 'when user is an admin', :enable_admin_mode do
        include_examples 'a service deleting runners in bulk' do
          let(:runners_arg) { Ci::Runner.all }
          let!(:expected_deleted_runners) { [instance_runner, group_runner, project_runner] }
          let(:user) { admin_user }
        end

        context 'with a runner already deleted' do
          before do
            group_runner.destroy!
          end

          include_examples 'a service deleting runners in bulk' do
            let(:runners_arg) { Ci::Runner.all }
            let!(:expected_deleted_runners) { [instance_runner, project_runner] }
            let(:user) { admin_user }
          end
        end

        context 'when deleting a single runner' do
          let(:runners_arg) { Ci::Runner.all }

          it 'avoids N+1 cached queries', :use_sql_query_cache, :request_store do
            # Run this once to establish a baseline
            control_count = ActiveRecord::QueryRecorder.new(skip_cached: false) do
              execute
            end

            additional_runners = 1

            create_list(:ci_runner, 1 + additional_runners, :instance)
            create_list(:ci_runner, 1 + additional_runners, :group, groups: [group])
            create_list(:ci_runner, 1 + additional_runners, :project, projects: [project])

            service = described_class.new(runners: runners_arg, current_user: user)

            # Base cost per runner is:
            #  - 1 `SELECT * FROM ""taggings""` query
            #  - 1 `SAVEPOINT` query
            #  - 1 `DELETE FROM ""ci_runners""` query
            #  - 1 `RELEASE SAVEPOINT` query
            # Project runners have an additional query:
            #  - 1 `DELETE FROM ""ci_runner_projects""` query, given the call to `destroy_all`
            instance_runner_cost = 4
            group_runner_cost = 4
            project_runner_cost = 5
            expect { service.execute }
              .not_to exceed_all_query_limit(control_count)
              .with_threshold(additional_runners * (instance_runner_cost + group_runner_cost + project_runner_cost))
          end
        end
      end

      context 'when user is group owner' do
        before do
          group.add_owner(user)
        end

        include_examples 'a service deleting runners in bulk' do
          let(:runners_arg) { Ci::Runner.not_instance_type }
          let!(:expected_deleted_runners) { [group_runner, project_runner] }
          let(:user) { owner_user }
        end

        context 'with a runner non-authorised to be deleted' do
          let(:runners_arg) { Ci::Runner.all }
          let!(:expected_deleted_runners) { [project_runner] }
          let(:user) { owner_user }

          it 'destroys only authorised runners', :aggregate_failures do
            allow(Ability).to receive(:allowed?).and_call_original
            expect(Ability).to receive(:allowed?).with(user, :delete_runner, instance_runner).and_return(false)

            expect { execute }.to change { Ci::Runner.count }.by(-2)

            is_expected.to be_success
            expect(execute.payload).to eq(
              {
                deleted_count: 2,
                deleted_ids: [group_runner.id, project_runner.id],
                errors: [""User does not have permission to delete runner(s) ##{instance_runner.id}""]
              })
          end
        end
      end
    end

    context 'with no arguments specified' do
      let(:runners_arg) { nil }
      let(:user) { owner_user }

      it 'returns 0 deleted runners' do
        is_expected.to be_success
        expect(execute.payload).to eq({ deleted_count: 0, deleted_ids: [], errors: [] })
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module Runners
    class UnregisterRunnerManagerService
      attr_reader :runner, :author, :system_id

      # @param [Ci::Runner] runner the runner to unregister/destroy
      # @param [User, authentication token String] author the user or the authentication token authorizing the removal
      # @param [String] system_id ID of the system being unregistered
      def initialize(runner, author, system_id:)
        @runner = runner
        @author = author
        @system_id = system_id
      end

      def execute
        return system_id_missing_error if system_id.blank?

        runner_manager = runner.runner_managers.find_by_system_xid!(system_id)
        runner_manager.destroy!

        ServiceResponse.success
      end

      private

      def system_id_missing_error
        ServiceResponse.error(message: '`system_id` needs to be specified for runners created in the UI.')
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ci::Runners::UnregisterRunnerManagerService, '#execute', feature_category: :runner_fleet do
  subject(:execute) { described_class.new(runner, 'some_token', system_id: system_id).execute }

  context 'with runner registered with registration token' do
    let!(:runner) { create(:ci_runner, registration_type: :registration_token) }
    let(:system_id) { nil }

    it 'does not destroy runner or runner managers' do
      expect do
        expect(execute).to be_error
      end.to not_change { Ci::Runner.count }
         .and not_change { Ci::RunnerManager.count }
      expect(runner[:errors]).to be_nil
    end
  end

  context 'with runner created in UI' do
    let!(:runner_manager1) { create(:ci_runner_machine, runner: runner, system_xid: 'system_id_1') }
    let!(:runner_manager2) { create(:ci_runner_machine, runner: runner, system_xid: 'system_id_2') }
    let!(:runner) { create(:ci_runner, registration_type: :authenticated_user) }

    context 'with system_id specified' do
      let(:system_id) { runner_manager1.system_xid }

      it 'destroys runner_manager1 and leaves runner', :aggregate_failures do
        expect do
          expect(execute).to be_success
        end.to change { Ci::RunnerManager.count }.by(-1)
           .and not_change { Ci::Runner.count }
        expect(runner[:errors]).to be_nil
        expect(runner.runner_managers).to contain_exactly(runner_manager2)
      end
    end

    context 'with unknown system_id' do
      let(:system_id) { 'unknown_system_id' }

      it 'raises RecordNotFound error', :aggregate_failures do
        expect do
          execute
        end.to raise_error(ActiveRecord::RecordNotFound)
           .and not_change { Ci::Runner.count }
           .and not_change { Ci::RunnerManager.count }
      end
    end

    context 'with system_id missing' do
      let(:system_id) { nil }

      it 'returns error and leaves runner_manager1', :aggregate_failures do
        expect do
          expect(execute).to be_error
          expect(execute.message).to eq('`system_id` needs to be specified for runners created in the UI.')
        end.to not_change { Ci::Runner.count }
           .and not_change { Ci::RunnerManager.count }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module Runners
    class UnassignRunnerService
      # @param [Ci::RunnerProject] runner_project the runner/project association to destroy
      # @param [User] user the user performing the operation
      def initialize(runner_project, user)
        @runner_project = runner_project
        @runner = runner_project.runner
        @project = runner_project.project
        @user = user
      end

      def execute
        unless @user.present? && @user.can?(:assign_runner, @runner)
          return ServiceResponse.error(message: 'user not allowed to assign runner')
        end

        if @runner_project.destroy
          ServiceResponse.success
        else
          ServiceResponse.error(message: 'failed to destroy runner project')
        end
      end

      private

      attr_reader :runner, :project, :user
    end
  end
end

Ci::Runners::UnassignRunnerService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ci::Runners::UnassignRunnerService, '#execute', feature_category: :runner_fleet do
  let_it_be(:project) { create(:project) }
  let_it_be(:runner) { create(:ci_runner, :project, projects: [project]) }

  let(:runner_project) { runner.runner_projects.last }

  subject(:execute) { described_class.new(runner_project, user).execute }

  context 'without user' do
    let(:user) { nil }

    it 'does not destroy runner_project', :aggregate_failures do
      expect(runner_project).not_to receive(:destroy)
      expect { execute }.not_to change { runner.runner_projects.count }.from(1)

      is_expected.to be_error
    end
  end

  context 'with unauthorized user' do
    let(:user) { build(:user) }

    it 'does not call destroy on runner_project' do
      expect(runner).not_to receive(:destroy)

      is_expected.to be_error
    end
  end

  context 'with admin user', :enable_admin_mode do
    let(:user) { create_default(:user, :admin) }

    context 'with destroy returning false' do
      it 'returns error response' do
        expect(runner_project).to receive(:destroy).once.and_return(false)

        is_expected.to be_error
      end
    end

    context 'with destroy returning true' do
      it 'returns success response' do
        expect(runner_project).to receive(:destroy).once.and_return(true)

        is_expected.to be_success
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module Runners
    class CreateRunnerService
      RUNNER_CLASS_MAPPING = {
        'instance_type' => Ci::Runners::RunnerCreationStrategies::InstanceRunnerStrategy,
        'group_type' => Ci::Runners::RunnerCreationStrategies::GroupRunnerStrategy,
        'project_type' => Ci::Runners::RunnerCreationStrategies::ProjectRunnerStrategy
      }.freeze

      def initialize(user:, params:)
        @user = user
        @params = params
        @strategy = RUNNER_CLASS_MAPPING[params[:runner_type]].new(user: user, params: params)
      end

      def execute
        normalize_params

        error = strategy.validate_params
        return ServiceResponse.error(message: error, reason: :validation_error) if error

        unless strategy.authorized_user?
          return ServiceResponse.error(message: _('Insufficient permissions'), reason: :forbidden)
        end

        runner = ::Ci::Runner.new(params)

        return ServiceResponse.success(payload: { runner: runner }) if runner.save

        ServiceResponse.error(message: runner.errors.full_messages, reason: :save_error)
      end

      def normalize_params
        params[:registration_type] = :authenticated_user
        params[:active] = !params.delete(:paused) if params.key?(:paused)
        params[:creator] = user

        strategy.normalize_params
      end

      private

      attr_reader :user, :params, :strategy
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ci::Runners::CreateRunnerService, ""#execute"", feature_category: :runner_fleet do
  subject(:execute) { described_class.new(user: current_user, params: params).execute }

  let(:runner) { execute.payload[:runner] }

  let_it_be(:admin) { create(:admin) }
  let_it_be(:non_admin_user) { create(:user) }
  let_it_be(:anonymous) { nil }
  let_it_be(:group_owner) { create(:user) }

  let_it_be(:group) { create(:group) }

  shared_examples 'it can create a runner' do
    it 'creates a runner of the specified type', :aggregate_failures do
      is_expected.to be_success
      expect(runner.runner_type).to eq expected_type
    end

    context 'with default params provided' do
      let(:args) do
        {}
      end

      before do
        params.merge!(args)
      end

      it { is_expected.to be_success }

      it 'uses default values when none are provided' do
        expect(runner).to be_an_instance_of(::Ci::Runner)
        expect(runner.persisted?).to be_truthy
        expect(runner.run_untagged).to be true
        expect(runner.active).to be true
        expect(runner.creator).to be current_user
        expect(runner.authenticated_user_registration_type?).to be_truthy
        expect(runner.runner_type).to eq expected_type
      end
    end

    context 'with non-default params provided' do
      let(:args) do
        {
          description: 'some description',
          maintenance_note: 'a note',
          paused: true,
          tag_list: %w[tag1 tag2],
          access_level: 'ref_protected',
          locked: true,
          maximum_timeout: 600,
          run_untagged: false
        }
      end

      before do
        params.merge!(args)
      end

      it { is_expected.to be_success }

      it 'creates runner with specified values', :aggregate_failures do
        expect(runner).to be_an_instance_of(::Ci::Runner)
        expect(runner.description).to eq 'some description'
        expect(runner.maintenance_note).to eq 'a note'
        expect(runner.active).to eq !args[:paused]
        expect(runner.locked).to eq args[:locked]
        expect(runner.run_untagged).to eq args[:run_untagged]
        expect(runner.tags).to contain_exactly(
          an_object_having_attributes(name: 'tag1'),
          an_object_having_attributes(name: 'tag2')
        )
        expect(runner.access_level).to eq args[:access_level]
        expect(runner.maximum_timeout).to eq args[:maximum_timeout]

        expect(runner.authenticated_user_registration_type?).to be_truthy
        expect(runner.runner_type).to eq expected_type
      end

      context 'with a nil paused value' do
        let(:args) do
          {
            paused: nil,
            description: 'some description',
            maintenance_note: 'a note',
            tag_list: %w[tag1 tag2],
            access_level: 'ref_protected',
            locked: true,
            maximum_timeout: 600,
            run_untagged: false
          }
        end

        it { is_expected.to be_success }

        it 'creates runner with active set to true' do
          expect(runner).to be_an_instance_of(::Ci::Runner)
          expect(runner.active).to eq true
        end
      end

      context 'with no paused value given' do
        let(:args) do
          {
            description: 'some description',
            maintenance_note: 'a note',
            tag_list: %w[tag1 tag2],
            access_level: 'ref_protected',
            locked: true,
            maximum_timeout: 600,
            run_untagged: false
          }
        end

        it { is_expected.to be_success }

        it 'creates runner with active set to true' do
          expect(runner).to be_an_instance_of(::Ci::Runner)
          expect(runner.active).to eq true
        end
      end
    end
  end

  shared_examples 'it cannot create a runner' do
    it 'runner payload is nil' do
      expect(runner).to be nil
    end

    it { is_expected.to be_error }
  end

  shared_examples 'it can return an error' do
    let(:runner_double) { Ci::Runner.new }

    context 'when the runner fails to save' do
      before do
        allow(Ci::Runner).to receive(:new).and_return runner_double
      end

      it_behaves_like 'it cannot create a runner'

      it 'returns error message' do
        expect(execute.errors).not_to be_empty
      end
    end
  end

  context 'with :runner_type param set to instance_type' do
    let(:expected_type) { 'instance_type' }
    let(:params) { { runner_type: 'instance_type' } }

    context 'when anonymous user' do
      let(:current_user) { anonymous }

      it_behaves_like 'it cannot create a runner'
    end

    context 'when non-admin user' do
      let(:current_user) { non_admin_user }

      it_behaves_like 'it cannot create a runner'
    end

    context 'when admin user' do
      let(:current_user) { admin }

      it_behaves_like 'it cannot create a runner'

      context 'when admin mode is enabled', :enable_admin_mode do
        it_behaves_like 'it can create a runner'
        it_behaves_like 'it can return an error'

        context 'with unexpected scope param specified' do
          let(:params) { { runner_type: 'instance_type', scope: group } }

          it_behaves_like 'it cannot create a runner'
        end

        context 'when model validation fails' do
          let(:params) { { runner_type: 'instance_type', run_untagged: false, tag_list: [] } }

          it_behaves_like 'it cannot create a runner'

          it 'returns error message and reason', :aggregate_failures do
            expect(execute.reason).to eq(:save_error)
            expect(execute.message).to contain_exactly(a_string_including('Tags list can not be empty'))
          end
        end
      end
    end
  end

  context 'with :runner_type param set to group_type' do
    let(:expected_type) { 'group_type' }
    let(:params) { { runner_type: 'group_type', scope: group } }

    before do
      group.add_developer(non_admin_user)
      group.add_owner(group_owner)
    end

    context 'when anonymous user' do
      let(:current_user) { anonymous }

      it_behaves_like 'it cannot create a runner'
    end

    context 'when non-admin user' do
      let(:current_user) { non_admin_user }

      it_behaves_like 'it cannot create a runner'
    end

    context 'when group owner' do
      let(:current_user) { group_owner }

      it_behaves_like 'it can create a runner'

      context 'with missing scope param' do
        let(:params) { { runner_type: 'group_type' } }

        it_behaves_like 'it cannot create a runner'
      end
    end

    context 'when admin user' do
      let(:current_user) { admin }

      it_behaves_like 'it cannot create a runner'

      context 'when admin mode is enabled', :enable_admin_mode do
        it_behaves_like 'it can create a runner'
        it_behaves_like 'it can return an error'
      end
    end
  end

  context 'with :runner_type param set to project_type' do
    let_it_be(:project) { create(:project, namespace: group) }

    let(:expected_type) { 'project_type' }
    let(:params) { { runner_type: 'project_type', scope: project } }

    before do
      group.add_developer(non_admin_user)
      group.add_owner(group_owner)
    end

    context 'when anonymous user' do
      let(:current_user) { anonymous }

      it_behaves_like 'it cannot create a runner'
    end

    context 'when group owner' do
      let(:current_user) { group_owner }

      it_behaves_like 'it can create a runner'

      context 'with missing scope param' do
        let(:params) { { runner_type: 'project_type' } }

        it_behaves_like 'it cannot create a runner'
      end
    end

    context 'when non-admin user' do
      let(:current_user) { non_admin_user }

      it_behaves_like 'it cannot create a runner'

      context 'with project permissions to create runner' do
        before do
          project.add_maintainer(current_user)
        end

        it_behaves_like 'it can create a runner'
      end
    end

    context 'when admin user' do
      let(:current_user) { admin }

      it_behaves_like 'it cannot create a runner'

      context 'when admin mode is enabled', :enable_admin_mode do
        it_behaves_like 'it can create a runner'
        it_behaves_like 'it can return an error'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module Runners
    class AssignRunnerService
      # @param [Ci::Runner] runner: the runner to assign to a project
      # @param [Project] project: the new project to assign the runner to
      # @param [User] user: the user performing the operation
      def initialize(runner, project, user)
        @runner = runner
        @project = project
        @user = user
      end

      def execute
        unless @user.present? && @user.can?(:assign_runner, @runner)
          return ServiceResponse.error(message: 'user not allowed to assign runner', http_status: :forbidden)
        end

        unless @user.can?(:register_project_runners, @project)
          return ServiceResponse.error(message: 'user not allowed to add runners to project', http_status: :forbidden)
        end

        if @runner.assign_to(@project, @user)
          ServiceResponse.success
        else
          ServiceResponse.error(message: 'failed to assign runner')
        end
      end

      private

      attr_reader :runner, :project, :user
    end
  end
end

Ci::Runners::AssignRunnerService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ci::Runners::AssignRunnerService, '#execute', feature_category: :runner_fleet do
  subject(:execute) { described_class.new(runner, new_project, user).execute }

  let_it_be(:owner_group) { create(:group) }
  let_it_be(:owner_project) { create(:project, group: owner_group) }
  let_it_be(:new_project) { create(:project) }
  let_it_be(:runner) { create(:ci_runner, :project, projects: [owner_project]) }

  context 'without user' do
    let(:user) { nil }

    it 'does not call assign_to on runner and returns error response', :aggregate_failures do
      expect(runner).not_to receive(:assign_to)

      is_expected.to be_error
      expect(execute.message).to eq('user not allowed to assign runner')
    end
  end

  context 'with unauthorized user' do
    let(:user) { build(:user) }

    it 'does not call assign_to on runner and returns error message' do
      expect(runner).not_to receive(:assign_to)

      is_expected.to be_error
      expect(execute.message).to eq('user not allowed to assign runner')
    end
  end

  context 'with authorized user' do
    let(:user) { create(:user) }

    context 'with user owning runner and being maintainer of new project' do
      before do
        owner_project.group.add_owner(user)
        new_project.add_maintainer(user)
      end

      it 'calls assign_to on runner and returns success response' do
        expect(runner).to receive(:assign_to).with(new_project, user).once.and_call_original

        is_expected.to be_success
      end
    end

    context 'with user owning runner' do
      before do
        owner_project.add_maintainer(user)
      end

      it 'does not call assign_to on runner and returns error message', :aggregate_failures do
        expect(runner).not_to receive(:assign_to)

        is_expected.to be_error
        expect(execute.message).to eq('user not allowed to add runners to project')
      end
    end

    context 'with user being maintainer of new project', :aggregate_failures do
      before do
        new_project.add_maintainer(user)
      end

      it 'does not call assign_to on runner and returns error message' do
        expect(runner).not_to receive(:assign_to)

        is_expected.to be_error
        expect(execute.message).to eq('user not allowed to assign runner')
      end
    end
  end

  context 'with admin user', :enable_admin_mode do
    let(:user) { create(:user, :admin) }

    it 'calls assign_to on runner and returns success response' do
      expect(runner).to receive(:assign_to).with(new_project, user).once.and_call_original

      is_expected.to be_success
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module Runners
    class ReconcileExistingRunnerVersionsService
      VERSION_BATCH_SIZE = 100

      def execute
        insert_result = insert_runner_versions
        total_deleted = cleanup_runner_versions(insert_result[:versions_from_runners])
        total_updated = update_status_on_outdated_runner_versions(insert_result[:versions_from_runners])

        ServiceResponse.success(payload: {
          total_inserted: insert_result[:new_record_count],
          total_updated: total_updated,
          total_deleted: total_deleted
        })
      end

      private

      def upgrade_check
        @runner_upgrade_check ||= Gitlab::Ci::RunnerUpgradeCheck.new(::Gitlab::VERSION)
      end

      # rubocop: disable CodeReuse/ActiveRecord
      def insert_runner_versions
        versions_from_runners = Set[]
        new_record_count = 0
        Ci::Runner.distinct_each_batch(column: :version, of: VERSION_BATCH_SIZE) do |version_batch|
          batch_versions = version_batch.pluck(:version).to_set
          versions_from_runners += batch_versions

          # Avoid hitting primary DB
          already_existing_versions = Ci::RunnerVersion.where(version: batch_versions).pluck(:version)
          new_versions = batch_versions - already_existing_versions

          if new_versions.any?
            new_record_count += Ci::RunnerVersion.insert_all(
              new_versions.map { |v| { version: v } },
              returning: :version,
              unique_by: :version).count
          end
        end

        { versions_from_runners: versions_from_runners, new_record_count: new_record_count }
      end

      def cleanup_runner_versions(versions_from_runners)
        Ci::RunnerVersion.where.not(version: versions_from_runners).delete_all
      end
      # rubocop: enable CodeReuse/ActiveRecord

      def outdated_runner_versions
        Ci::RunnerVersion.potentially_outdated
      end

      def update_status_on_outdated_runner_versions(versions_from_runners)
        total_updated = 0

        outdated_runner_versions.each_batch(of: VERSION_BATCH_SIZE) do |version_batch|
          updated = version_batch
            .select { |runner_version| versions_from_runners.include?(runner_version['version']) }
            .filter_map { |runner_version| runner_version_with_updated_status(runner_version) }

          if updated.any?
            total_updated += Ci::RunnerVersion.upsert_all(updated, unique_by: :version).count
          end
        end

        total_updated
      end

      def runner_version_with_updated_status(runner_version)
        _, new_status = upgrade_check.check_runner_upgrade_suggestion(runner_version.version)

        if new_status != :error && new_status != runner_version.status.to_sym
          {
            version: runner_version.version,
            status: Ci::RunnerVersion.statuses[new_status]
          }
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ci::Runners::ReconcileExistingRunnerVersionsService, '#execute', feature_category: :runner_fleet do
  include RunnerReleasesHelper

  subject(:execute) { described_class.new.execute }

  let_it_be(:runner_14_0_1) { create(:ci_runner, version: '14.0.1') }
  let_it_be(:runner_version_14_0_1) do
    create(:ci_runner_version, version: '14.0.1', status: :unavailable)
  end

  context 'with RunnerUpgradeCheck recommending 14.0.2' do
    let(:upgrade_check) { instance_double(::Gitlab::Ci::RunnerUpgradeCheck) }

    before do
      stub_const('Ci::Runners::ReconcileExistingRunnerVersionsService::VERSION_BATCH_SIZE', 1)

      allow(::Gitlab::Ci::RunnerUpgradeCheck).to receive(:new).and_return(upgrade_check).once
    end

    context 'with runner with new version' do
      let!(:runner_14_0_2) { create(:ci_runner, version: '14.0.2') }
      let!(:runner_14_0_0) { create(:ci_runner, version: '14.0.0') }
      let!(:runner_version_14_0_0) do
        create(:ci_runner_version, version: '14.0.0', status: :unavailable)
      end

      before do
        allow(upgrade_check).to receive(:check_runner_upgrade_suggestion)
          .and_return([::Gitlab::VersionInfo.new(14, 0, 2), :recommended])
        allow(upgrade_check).to receive(:check_runner_upgrade_suggestion)
          .with('14.0.2')
          .and_return([::Gitlab::VersionInfo.new(14, 0, 2), :unavailable])
          .once
      end

      it 'creates and updates expected ci_runner_versions entries', :aggregate_failures do
        expect(Ci::RunnerVersion).to receive(:insert_all)
          .ordered
          .with([{ version: '14.0.2' }], anything)
          .once
          .and_call_original

        expect { execute }
          .to change { runner_version_14_0_0.reload.status }.from('unavailable').to('recommended')
          .and change { runner_version_14_0_1.reload.status }.from('unavailable').to('recommended')
          .and change { ::Ci::RunnerVersion.find_by(version: '14.0.2')&.status }.from(nil).to('unavailable')

        expect(execute).to be_success
        expect(execute.payload).to eq({
          total_inserted: 1, # 14.0.2 is inserted
          total_updated: 3, # 14.0.0, 14.0.1 are updated, and newly inserted 14.0.2's status is calculated
          total_deleted: 0
        })
      end
    end

    context 'with orphan ci_runner_version' do
      let!(:runner_version_14_0_2) do
        create(:ci_runner_version, version: '14.0.2', status: :unavailable)
      end

      before do
        allow(upgrade_check).to receive(:check_runner_upgrade_suggestion)
          .and_return([::Gitlab::VersionInfo.new(14, 0, 2), :unavailable])
      end

      it 'deletes orphan ci_runner_versions entry', :aggregate_failures do
        expect { execute }
          .to change { ::Ci::RunnerVersion.find_by_version('14.0.2')&.status }.from('unavailable').to(nil)
          .and not_change { runner_version_14_0_1.reload.status }.from('unavailable')

        expect(execute).to be_success
        expect(execute.payload).to eq({
          total_inserted: 0,
          total_updated: 0,
          total_deleted: 1 # 14.0.2 is deleted
        })
      end
    end

    context 'with no runner version changes' do
      before do
        allow(upgrade_check).to receive(:check_runner_upgrade_suggestion)
          .and_return([::Gitlab::VersionInfo.new(14, 0, 1), :unavailable])
      end

      it 'does not modify ci_runner_versions entries', :aggregate_failures do
        expect { execute }.not_to change { runner_version_14_0_1.reload.status }.from('unavailable')

        expect(execute).to be_success
        expect(execute.payload).to eq({
          total_inserted: 0,
          total_updated: 0,
          total_deleted: 0
        })
      end
    end

    context 'with failing version check' do
      before do
        allow(upgrade_check).to receive(:check_runner_upgrade_suggestion)
          .and_return([::Gitlab::VersionInfo.new(14, 0, 1), :error])
      end

      it 'makes no changes to ci_runner_versions', :aggregate_failures do
        expect { execute }.not_to change { runner_version_14_0_1.reload.status }.from('unavailable')

        expect(execute).to be_success
        expect(execute.payload).to eq({
          total_inserted: 0,
          total_updated: 0,
          total_deleted: 0
        })
      end
    end
  end

  context 'integration testing with Gitlab::Ci::RunnerUpgradeCheck' do
    before do
      stub_runner_releases(%w[14.0.0 14.0.1])
    end

    it 'does not modify ci_runner_versions entries', :aggregate_failures do
      expect { execute }.not_to change { runner_version_14_0_1.reload.status }.from('unavailable')

      expect(execute).to be_success
      expect(execute.payload).to eq({
        total_inserted: 0,
        total_updated: 0,
        total_deleted: 0
      })
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module Runners
    class ResetRegistrationTokenService
      # @param [ApplicationSetting, Project, Group] scope: the scope of the reset operation
      # @param [User] user: the user performing the operation
      def initialize(scope, user)
        @scope = scope
        @user = user
      end

      def execute
        unless @user.present? && @user.can?(:update_runners_registration_token, scope)
          return ServiceResponse.error(message: 'user not allowed to update runners registration token')
        end

        if scope.respond_to?(:runners_registration_token)
          scope.reset_runners_registration_token!
          runners_token = scope.runners_registration_token
        else
          scope.reset_runners_token!
          runners_token = scope.runners_token
        end

        ServiceResponse.success(payload: { new_registration_token: runners_token })
      end

      private

      attr_reader :scope, :user
    end
  end
end

Ci::Runners::ResetRegistrationTokenService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ci::Runners::ResetRegistrationTokenService, '#execute', feature_category: :runner_fleet do
  subject(:execute) { described_class.new(scope, current_user).execute }

  let_it_be(:user) { build(:user) }
  let_it_be(:admin_user) { create(:user, :admin) }

  shared_examples 'a registration token reset operation' do
    context 'without user' do
      let(:current_user) { nil }

      it 'does not reset registration token and returns error response' do
        expect(scope).not_to receive(token_reset_method_name)

        expect(execute).to be_error
      end
    end

    context 'with unauthorized user' do
      let(:current_user) { user }

      it 'does not reset registration token and returns error response' do
        expect(scope).not_to receive(token_reset_method_name)

        expect(execute).to be_error
      end
    end

    context 'with admin user', :enable_admin_mode do
      let(:current_user) { admin_user }

      it 'resets registration token and returns value unchanged' do
        expect(scope).to receive(token_reset_method_name).once do
          expect(scope).to receive(token_method_name).once.and_return(""#{token_method_name} return value"")
        end

        expect(execute).to be_success
        expect(execute.payload[:new_registration_token]).to eq(""#{token_method_name} return value"")
      end
    end
  end

  context 'with instance scope' do
    let_it_be(:scope) { create(:application_setting) }

    before do
      allow(ApplicationSetting).to receive(:current).and_return(scope)
      allow(ApplicationSetting).to receive(:current_without_cache).and_return(scope)
    end

    it_behaves_like 'a registration token reset operation' do
      let(:token_method_name) { :runners_registration_token }
      let(:token_reset_method_name) { :reset_runners_registration_token! }
    end
  end

  context 'with group scope' do
    let_it_be(:scope) { create(:group) }

    it_behaves_like 'a registration token reset operation' do
      let(:token_method_name) { :runners_token }
      let(:token_reset_method_name) { :reset_runners_token! }
    end
  end

  context 'with project scope' do
    let_it_be(:scope) { create(:project) }

    it_behaves_like 'a registration token reset operation' do
      let(:token_method_name) { :runners_token }
      let(:token_reset_method_name) { :reset_runners_token! }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module Runners
    class UnregisterRunnerService
      attr_reader :runner, :author

      # @param [Ci::Runner] runner the runner to unregister/destroy
      # @param [User, authentication token String] author the user or the authentication token that authorizes the removal
      def initialize(runner, author)
        @runner = runner
        @author = author
      end

      def execute
        runner.destroy!

        ServiceResponse.success
      end
    end
  end
end

Ci::Runners::UnregisterRunnerService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ci::Runners::UnregisterRunnerService, '#execute', feature_category: :runner_fleet do
  subject(:execute) { described_class.new(runner, 'some_token').execute }

  let(:runner) { create(:ci_runner) }

  it 'destroys runner' do
    expect(runner).to receive(:destroy).once.and_call_original

    expect do
      expect(execute).to be_success
    end.to change { Ci::Runner.count }.by(-1)
    expect(runner[:errors]).to be_nil
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module Runners
    class StaleManagersCleanupService
      MAX_DELETIONS = 1000
      SUB_BATCH_LIMIT = 100

      def execute
        ServiceResponse.success(payload: delete_stale_runner_managers)
      end

      private

      def delete_stale_runner_managers
        batch_counts = []
        total_deleted_count = 0
        loop do
          sub_batch_limit = [SUB_BATCH_LIMIT, MAX_DELETIONS].min

          # delete_all discards part of the `stale` scope query, so we explicitly wrap it with a SELECT as a workaround
          deleted_count = Ci::RunnerManager.id_in(Ci::RunnerManager.stale.limit(sub_batch_limit)).delete_all
          batch_counts << deleted_count
          total_deleted_count += deleted_count

          break if deleted_count == 0 || total_deleted_count >= MAX_DELETIONS
        end

        {
          total_deleted: total_deleted_count,
          batch_counts: batch_counts
        }
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::Runners::StaleManagersCleanupService, feature_category: :runner_fleet do
  let(:service) { described_class.new }
  let!(:runner_manager3) { create(:ci_runner_machine, created_at: 6.months.ago, contacted_at: Time.current) }

  subject(:response) { service.execute }

  context 'with no stale runner managers' do
    it 'does not clean any runner managers and returns :success status' do
      expect do
        expect(response).to be_success
        expect(response.payload).to match({ total_deleted: 0, batch_counts: [0] })
      end.not_to change { Ci::RunnerManager.count }.from(1)
    end
  end

  context 'with some stale runner managers' do
    before do
      create(:ci_runner_machine, :stale)
      create(:ci_runner_machine, :stale, contacted_at: nil)
    end

    it 'only leaves non-stale runners' do
      expect(response).to be_success
      expect(response.payload).to match({ total_deleted: 2, batch_counts: [2, 0] })
      expect(Ci::RunnerManager.all).to contain_exactly(runner_manager3)
    end

    context 'with more stale runners than SUB_BATCH_LIMIT' do
      before do
        stub_const(""#{described_class}::SUB_BATCH_LIMIT"", 1)
      end

      it 'only leaves non-stale runners' do
        expect(response).to be_success
        expect(response.payload).to match({ total_deleted: 2, batch_counts: [1, 1, 0] })
        expect(Ci::RunnerManager.all).to contain_exactly(runner_manager3)
      end
    end

    context 'with more stale runners than MAX_DELETIONS' do
      before do
        stub_const(""#{described_class}::MAX_DELETIONS"", 1)
      end

      it 'only leaves non-stale runners' do
        expect do
          expect(response).to be_success
          expect(response.payload).to match({
            total_deleted: Ci::Runners::StaleManagersCleanupService::MAX_DELETIONS,
            batch_counts: [1]
          })
        end.to change { Ci::RunnerManager.count }.by(-Ci::Runners::StaleManagersCleanupService::MAX_DELETIONS)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module Runners
    class RegisterRunnerService
      include Gitlab::Utils::StrongMemoize

      def initialize(registration_token, attributes)
        @registration_token = registration_token
        @attributes = attributes
      end

      def execute
        return ServiceResponse.error(message: 'invalid token supplied', http_status: :forbidden) unless attrs_from_token

        unless registration_token_allowed?(attrs_from_token)
          return ServiceResponse.error(
            message: 'runner registration disallowed',
            reason: :runner_registration_disallowed)
        end

        runner = ::Ci::Runner.new(attributes.merge(attrs_from_token))

        Ci::BulkInsertableTags.with_bulk_insert_tags do
          Ci::Runner.transaction do
            if runner.save
              Gitlab::Ci::Tags::BulkInsert.bulk_insert_tags!([runner])
            else
              raise ActiveRecord::Rollback
            end
          end
        end

        ServiceResponse.success(payload: { runner: runner })
      end

      private

      attr_reader :registration_token, :attributes

      def attrs_from_token
        if runner_registration_token_valid?(registration_token)
          # Create shared runner. Requires admin access
          { runner_type: :instance_type }
        elsif runner_registrar_valid?('project') && project = ::Project.find_by_runners_token(registration_token)
          # Create a project runner
          { runner_type: :project_type, projects: [project] }
        elsif runner_registrar_valid?('group') && group = ::Group.find_by_runners_token(registration_token)
          # Create a group runner
          { runner_type: :group_type, groups: [group] }
        end
      end
      strong_memoize_attr :attrs_from_token

      def registration_token_allowed?(attrs)
        case attrs[:runner_type]
        when :group_type
          token_scope.allow_runner_registration_token?
        when :project_type
          token_scope.namespace.allow_runner_registration_token?
        else
          Gitlab::CurrentSettings.allow_runner_registration_token
        end
      end

      def runner_registration_token_valid?(registration_token)
        ActiveSupport::SecurityUtils.secure_compare(registration_token, Gitlab::CurrentSettings.runners_registration_token)
      end

      def runner_registrar_valid?(type)
        Gitlab::CurrentSettings.valid_runner_registrars.include?(type)
      end

      def token_scope
        case attrs_from_token[:runner_type]
        when :project_type
          attrs_from_token[:projects]&.first
        when :group_type
          attrs_from_token[:groups]&.first
          # No scope for instance type
        end
      end
    end
  end
end

Ci::Runners::RegisterRunnerService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ci::Runners::RegisterRunnerService, '#execute', feature_category: :runner_fleet do
  let(:registration_token) { 'abcdefg123456' }
  let(:token) {}
  let(:args) { {} }
  let(:runner) { execute.payload[:runner] }
  let(:allow_runner_registration_token) { true }

  before do
    stub_application_setting(runners_registration_token: registration_token)
    stub_application_setting(valid_runner_registrars: ApplicationSetting::VALID_RUNNER_REGISTRAR_TYPES)
    stub_application_setting(allow_runner_registration_token: allow_runner_registration_token)
  end

  subject(:execute) { described_class.new(token, args).execute }

  shared_examples 'runner registration is disallowed' do
    it 'returns error response with runner_registration_disallowed reason' do
      expect(execute).to be_error
      expect(execute.message).to eq 'runner registration disallowed'
      expect(execute.reason).to eq :runner_registration_disallowed
    end
  end

  context 'when no token is provided' do
    let(:token) { '' }

    it 'returns error response' do
      expect(execute).to be_error
      expect(execute.message).to eq 'invalid token supplied'
      expect(execute.http_status).to eq :forbidden
    end
  end

  context 'when invalid token is provided' do
    let(:token) { 'invalid' }

    it 'returns error response' do
      expect(execute).to be_error
      expect(execute.message).to eq 'invalid token supplied'
      expect(execute.http_status).to eq :forbidden
    end
  end

  context 'when valid token is provided' do
    context 'when instance registration token is used' do
      let(:token) { registration_token }

      it 'creates runner with default values' do
        expect(execute).to be_success

        expect(runner).to be_an_instance_of(::Ci::Runner)
        expect(runner.persisted?).to be_truthy
        expect(runner.run_untagged).to be true
        expect(runner.active).to be true
        expect(runner.token).not_to eq(registration_token)
        expect(runner.token).not_to start_with(::Ci::Runner::CREATED_RUNNER_TOKEN_PREFIX)
        expect(runner).to be_instance_type
      end

      context 'when registering instance runners is disallowed' do
        let(:allow_runner_registration_token) { false }

        it_behaves_like 'runner registration is disallowed'
      end

      context 'with non-default arguments' do
        let(:args) do
          {
            description: 'some description',
            active: false,
            locked: true,
            run_untagged: false,
            tag_list: %w[tag1 tag2],
            access_level: 'ref_protected',
            maximum_timeout: 600,
            name: 'some name',
            version: 'some version',
            revision: 'some revision',
            platform: 'some platform',
            architecture: 'some architecture',
            ip_address: '10.0.0.1',
            config: {
              gpus: 'some gpu config'
            }
          }
        end

        it 'creates runner with specified values', :aggregate_failures do
          expect(execute).to be_success

          expect(runner).to be_an_instance_of(::Ci::Runner)
          expect(runner.active).to eq args[:active]
          expect(runner.locked).to eq args[:locked]
          expect(runner.run_untagged).to eq args[:run_untagged]
          expect(runner.tags).to contain_exactly(
            an_object_having_attributes(name: 'tag1'),
            an_object_having_attributes(name: 'tag2')
          )
          expect(runner.access_level).to eq args[:access_level]
          expect(runner.maximum_timeout).to eq args[:maximum_timeout]
          expect(runner.name).to eq args[:name]
          expect(runner.version).to eq args[:version]
          expect(runner.revision).to eq args[:revision]
          expect(runner.platform).to eq args[:platform]
          expect(runner.architecture).to eq args[:architecture]
          expect(runner.ip_address).to eq args[:ip_address]

          expect(Ci::Runner.tagged_with('tag1')).to include(runner)
          expect(Ci::Runner.tagged_with('tag2')).to include(runner)
        end
      end

      context 'with runner token expiration interval', :freeze_time do
        before do
          stub_application_setting(runner_token_expiration_interval: 5.days)
        end

        it 'creates runner with token expiration' do
          expect(execute).to be_success

          expect(runner).to be_an_instance_of(::Ci::Runner)
          expect(runner.token_expires_at).to eq(5.days.from_now)
        end
      end
    end

    context 'when project registration token is used' do
      let_it_be(:project) { create(:project, :with_namespace_settings) }

      let(:token) { project.runners_token }
      let(:allow_group_runner_registration_token) { true }

      before do
        project.namespace.update!(allow_runner_registration_token: allow_group_runner_registration_token)
      end

      it 'creates project runner' do
        expect(execute).to be_success

        expect(runner).to be_an_instance_of(::Ci::Runner)
        expect(project.runners.size).to eq(1)
        expect(runner).to eq(project.runners.first)
        expect(runner.token).not_to eq(registration_token)
        expect(runner.token).not_to eq(project.runners_token)
        expect(runner).to be_project_type
      end

      context 'with runner registration disabled at instance level' do
        let(:allow_runner_registration_token) { false }

        it_behaves_like 'runner registration is disallowed'
      end

      context 'with runner registration disabled at group level' do
        let(:allow_group_runner_registration_token) { false }

        it_behaves_like 'runner registration is disallowed'
      end

      context 'when it exceeds the application limits' do
        before do
          create(:ci_runner, runner_type: :project_type, projects: [project], contacted_at: 1.second.ago)
          create(:plan_limits, :default_plan, ci_registered_project_runners: 1)
        end

        it 'does not create runner' do
          expect(execute).to be_success

          expect(runner).to be_an_instance_of(::Ci::Runner)
          expect(runner.persisted?).to be_falsey
          expect(runner.errors.messages).to eq(
            'runner_projects.base': ['Maximum number of ci registered project runners (1) exceeded']
          )
          expect(project.runners.reload.size).to eq(1)
        end
      end

      context 'when abandoned runners cause application limits to not be exceeded' do
        before do
          create(:ci_runner, runner_type: :project_type, projects: [project], created_at: 14.months.ago, contacted_at: 13.months.ago)
          create(:plan_limits, :default_plan, ci_registered_project_runners: 1)
        end

        it 'creates runner' do
          expect(execute).to be_success

          expect(runner).to be_an_instance_of(::Ci::Runner)
          expect(runner.errors).to be_empty
          expect(project.runners.reload.size).to eq(2)
          expect(project.runners.recent.size).to eq(1)
        end
      end

      context 'when valid runner registrars do not include project' do
        before do
          stub_application_setting(valid_runner_registrars: ['group'])
        end

        it 'returns 403 error' do
          expect(execute).to be_error
          expect(execute.http_status).to eq :forbidden
        end
      end
    end

    context 'when group registration token is used' do
      let_it_be_with_refind(:group) { create(:group) }

      let(:token) { group.runners_token }
      let(:allow_group_runner_registration_token) { true }

      before do
        group.update!(allow_runner_registration_token: allow_group_runner_registration_token)
      end

      it 'creates a group runner' do
        expect(execute).to be_success

        expect(runner).to be_an_instance_of(::Ci::Runner)
        expect(runner.errors).to be_empty
        expect(group.runners.reload.size).to eq(1)
        expect(runner.token).not_to eq(registration_token)
        expect(runner.token).not_to eq(group.runners_token)
        expect(runner).to be_group_type
      end

      context 'with runner registration disabled at instance level' do
        let(:allow_runner_registration_token) { false }

        it_behaves_like 'runner registration is disallowed'
      end

      context 'with runner registration disabled at group level' do
        let(:allow_group_runner_registration_token) { false }

        it_behaves_like 'runner registration is disallowed'
      end

      context 'when it exceeds the application limits' do
        before do
          create(:ci_runner, runner_type: :group_type, groups: [group], contacted_at: nil, created_at: 1.month.ago)
          create(:plan_limits, :default_plan, ci_registered_group_runners: 1)
        end

        it 'does not create runner' do
          expect(execute).to be_success

          expect(runner).to be_an_instance_of(::Ci::Runner)
          expect(runner.persisted?).to be_falsey
          expect(runner.errors.messages).to eq(
            'runner_namespaces.base': ['Maximum number of ci registered group runners (1) exceeded']
          )
          expect(group.runners.reload.size).to eq(1)
        end
      end

      context 'when abandoned runners cause application limits to not be exceeded' do
        before do
          create(:ci_runner, runner_type: :group_type, groups: [group], created_at: 4.months.ago, contacted_at: 3.months.ago)
          create(:ci_runner, runner_type: :group_type, groups: [group], contacted_at: nil, created_at: 4.months.ago)
          create(:plan_limits, :default_plan, ci_registered_group_runners: 1)
        end

        it 'creates runner' do
          expect(execute).to be_success

          expect(runner).to be_an_instance_of(::Ci::Runner)
          expect(runner.errors).to be_empty
          expect(group.runners.reload.size).to eq(3)
          expect(group.runners.recent.size).to eq(1)
        end
      end

      context 'when valid runner registrars do not include group' do
        before do
          stub_application_setting(valid_runner_registrars: ['project'])
        end

        it 'returns error response' do
          is_expected.to be_error
        end
      end
    end

    context 'when tags are provided' do
      let(:token) { registration_token }

      let(:args) do
        { tag_list: %w[tag1 tag2] }
      end

      it 'creates runner with tags' do
        expect(runner).to be_persisted

        expect(runner.tags).to contain_exactly(
          an_object_having_attributes(name: 'tag1'),
          an_object_having_attributes(name: 'tag2')
        )
      end

      it 'creates tags in bulk' do
        expect(Gitlab::Ci::Tags::BulkInsert).to receive(:bulk_insert_tags!).and_call_original

        expect(runner).to be_persisted
      end

      context 'and tag list exceeds limit' do
        let(:args) do
          { tag_list: (1..Ci::Runner::TAG_LIST_MAX_LENGTH + 1).map { |i| ""tag#{i}"" } }
        end

        it 'does not create any tags' do
          expect(Gitlab::Ci::Tags::BulkInsert).not_to receive(:bulk_insert_tags!)

          expect(runner).not_to be_persisted
          expect(runner.tags).to be_empty
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module Runners
    class ProcessRunnerVersionUpdateService
      def initialize(version)
        @version = version
      end

      def execute
        return ServiceResponse.error(message: 'version update disabled') unless enabled?
        return ServiceResponse.error(message: 'version not present') unless @version

        _, status = upgrade_check_service.check_runner_upgrade_suggestion(@version)
        return ServiceResponse.error(message: 'upgrade version check failed') if status == :error

        Ci::RunnerVersion.upsert({ version: @version, status: status })
        ServiceResponse.success(payload: { upgrade_status: status.to_s })
      end

      private

      def upgrade_check_service
        @runner_upgrade_check ||= Gitlab::Ci::RunnerUpgradeCheck.new(::Gitlab::VERSION)
      end

      def enabled?
        Gitlab::Ci::RunnerReleases.instance.enabled?
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::Runners::ProcessRunnerVersionUpdateService, feature_category: :runner_fleet do
  subject(:service) { described_class.new(version) }

  let(:version) { '1.0.0' }
  let(:available_runner_releases) { %w[1.0.0 1.0.1] }

  describe '#execute' do
    subject(:execute) { service.execute }

    context 'with upgrade check returning error' do
      let(:service_double) { instance_double(Gitlab::Ci::RunnerUpgradeCheck) }

      before do
        allow(service_double).to receive(:check_runner_upgrade_suggestion).with(version)
          .and_return([version, :error])
        allow(service).to receive(:upgrade_check_service).and_return(service_double)
      end

      it 'does not update ci_runner_versions records', :aggregate_failures do
        expect do
          expect(execute).to be_error
          expect(execute.message).to eq 'upgrade version check failed'
        end.not_to change(Ci::RunnerVersion, :count).from(0)
        expect(service_double).to have_received(:check_runner_upgrade_suggestion).with(version).once
      end
    end

    context 'when fetching runner releases is disabled' do
      before do
        stub_application_setting(update_runner_versions_enabled: false)
      end

      it 'does not update ci_runner_versions records', :aggregate_failures do
        expect do
          expect(execute).to be_error
          expect(execute.message).to eq 'version update disabled'
        end.not_to change(Ci::RunnerVersion, :count).from(0)
      end
    end

    context 'with successful result from upgrade check' do
      before do
        url = ::Gitlab::CurrentSettings.current_application_settings.public_runner_releases_url

        WebMock.stub_request(:get, url).to_return(
          body: available_runner_releases.map { |v| { name: v } }.to_json,
          status: 200,
          headers: { 'Content-Type' => 'application/json' }
        )
      end

      context 'with no existing ci_runner_version record' do
        it 'creates ci_runner_versions record', :aggregate_failures do
          expect do
            expect(execute).to be_success
            expect(execute.http_status).to eq :ok
            expect(execute.payload).to eq({ upgrade_status: 'recommended' })
          end.to change(Ci::RunnerVersion, :all).to contain_exactly(
            an_object_having_attributes(version: version, status: 'recommended')
          )
        end
      end

      context 'with existing ci_runner_version record' do
        let!(:runner_version) { create(:ci_runner_version, version: '1.0.0', status: :unavailable) }

        it 'updates ci_runner_versions record', :aggregate_failures do
          expect do
            expect(execute).to be_success
            expect(execute.http_status).to eq :ok
            expect(execute.payload).to eq({ upgrade_status: 'recommended' })
          end.to change { runner_version.reload.status }.from('unavailable').to('recommended')
        end
      end

      context 'with up-to-date ci_runner_version record' do
        let!(:runner_version) { create(:ci_runner_version, version: '1.0.0', status: :recommended) }

        it 'does not update ci_runner_versions record', :aggregate_failures do
          expect do
            expect(execute).to be_success
            expect(execute.http_status).to eq :ok
            expect(execute.payload).to eq({ upgrade_status: 'recommended' })
          end.not_to change { runner_version.reload.status }
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module JobArtifacts
    class DeleteProjectArtifactsService < BaseProjectService
      def execute
        ExpireProjectBuildArtifactsWorker.perform_async(project.id)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::JobArtifacts::DeleteProjectArtifactsService, feature_category: :build_artifacts do
  let_it_be(:project) { create(:project) }

  subject { described_class.new(project: project) }

  describe '#execute' do
    it 'enqueues a Ci::ExpireProjectBuildArtifactsWorker' do
      expect(Ci::JobArtifacts::ExpireProjectBuildArtifactsWorker).to receive(:perform_async).with(project.id).and_call_original

      subject.execute
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module JobArtifacts
    class TrackArtifactReportService
      include Gitlab::Utils::UsageData

      REPORT_TRACKED = %i[test coverage].freeze

      def execute(pipeline)
        REPORT_TRACKED.each do |report|
          if pipeline.complete_and_has_reports?(Ci::JobArtifact.of_report_type(report))
            track_usage_event(event_name(report), pipeline.user_id)
          end
        end
      end

      def event_name(report)
        ""i_testing_#{report}_report_uploaded""
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::JobArtifacts::TrackArtifactReportService, feature_category: :build_artifacts do
  describe '#execute', :clean_gitlab_redis_shared_state do
    let_it_be(:group) { create(:group, :private) }
    let_it_be(:project) { create(:project, group: group) }
    let_it_be(:user1) { create(:user) }
    let_it_be(:user2) { create(:user) }

    let(:test_event_name_1) { 'i_testing_test_report_uploaded' }
    let(:test_event_name_2) { 'i_testing_coverage_report_uploaded' }

    let(:counter) { Gitlab::UsageDataCounters::HLLRedisCounter }
    let(:start_time) { 1.week.ago }
    let(:end_time) { 1.week.from_now }

    subject(:track_artifact_report) { described_class.new.execute(pipeline) }

    context 'when pipeline has test reports' do
      let_it_be(:pipeline) { create(:ci_pipeline, project: project, user: user1) }

      before do
        2.times do
          pipeline.builds << build(:ci_build, :test_reports, pipeline: pipeline, project: pipeline.project)
        end
      end

      it 'tracks the test event using HLLRedisCounter' do
        expect(Gitlab::UsageDataCounters::HLLRedisCounter)
          .to receive(:track_event)
          .with(test_event_name_1, values: user1.id)
          .and_call_original

        expect { track_artifact_report }.to change {
          counter.unique_events(event_names: test_event_name_1, start_date: start_time, end_date: end_time)
        }.by 1
      end
    end

    context 'when pipeline does not have test reports' do
      let_it_be(:pipeline) { create(:ci_empty_pipeline) }

      it 'does not track the test event' do
        track_artifact_report

        expect(Gitlab::UsageDataCounters::HLLRedisCounter)
          .not_to receive(:track_event)
          .with(anything, test_event_name_1)
      end

      it 'does not track the coverage test event' do
        track_artifact_report

        expect(Gitlab::UsageDataCounters::HLLRedisCounter)
          .not_to receive(:track_event)
          .with(anything, test_event_name_2)
      end
    end

    context 'when a single user started multiple pipelines with test reports' do
      let_it_be(:pipeline1) { create(:ci_pipeline, :with_test_reports, project: project, user: user1) }
      let_it_be(:pipeline2) { create(:ci_pipeline, :with_test_reports, project: project, user: user1) }

      it 'tracks all pipelines using HLLRedisCounter by one user_id for the test event' do
        expect(Gitlab::UsageDataCounters::HLLRedisCounter)
          .to receive(:track_event)
          .with(test_event_name_1, values: user1.id)
          .and_call_original

        expect(Gitlab::UsageDataCounters::HLLRedisCounter)
          .to receive(:track_event)
          .with(test_event_name_1, values: user1.id)
          .and_call_original

        expect do
          described_class.new.execute(pipeline1)
          described_class.new.execute(pipeline2)
        end.to change {
          counter.unique_events(event_names: test_event_name_1, start_date: start_time, end_date: end_time)
        }.by 1
      end
    end

    context 'when multiple users started multiple pipelines with test reports' do
      let_it_be(:pipeline1) { create(:ci_pipeline, :with_test_reports, project: project, user: user1) }
      let_it_be(:pipeline2) { create(:ci_pipeline, :with_test_reports, project: project, user: user2) }

      it 'tracks all pipelines using HLLRedisCounter by multiple users for test reports' do
        expect(Gitlab::UsageDataCounters::HLLRedisCounter)
          .to receive(:track_event)
          .with(test_event_name_1, values: user1.id)
          .and_call_original

        expect(Gitlab::UsageDataCounters::HLLRedisCounter)
          .to receive(:track_event)
          .with(test_event_name_1, values: user2.id)
          .and_call_original

        expect do
          described_class.new.execute(pipeline1)
          described_class.new.execute(pipeline2)
        end.to change {
          counter.unique_events(event_names: test_event_name_1, start_date: start_time, end_date: end_time)
        }.by 2
      end
    end

    context 'when pipeline has coverage test reports' do
      let_it_be(:pipeline) { create(:ci_pipeline, project: project, user: user1) }

      before do
        2.times do
          pipeline.builds << build(:ci_build, :coverage_reports, pipeline: pipeline, project: pipeline.project)
        end
      end

      it 'tracks the coverage test event using HLLRedisCounter' do
        expect(Gitlab::UsageDataCounters::HLLRedisCounter)
          .to receive(:track_event)
          .with(test_event_name_2, values: user1.id)
          .and_call_original

        expect { track_artifact_report }.to change {
          counter.unique_events(event_names: test_event_name_2, start_date: start_time, end_date: end_time)
        }.by 1
      end
    end

    context 'when a single user started multiple pipelines with coverage reports' do
      let_it_be(:pipeline1) { create(:ci_pipeline, :with_coverage_reports, project: project, user: user1) }
      let_it_be(:pipeline2) { create(:ci_pipeline, :with_coverage_reports, project: project, user: user1) }

      it 'tracks all pipelines using HLLRedisCounter by one user_id for the coverage test event' do
        expect(Gitlab::UsageDataCounters::HLLRedisCounter)
          .to receive(:track_event)
          .with(test_event_name_2, values: user1.id)
          .twice
          .and_call_original

        expect do
          described_class.new.execute(pipeline1)
          described_class.new.execute(pipeline2)
        end.to change {
          counter.unique_events(event_names: test_event_name_2, start_date: start_time, end_date: end_time)
        }.by 1
      end
    end

    context 'when multiple users started multiple pipelines with coverage test reports' do
      let_it_be(:pipeline1) { create(:ci_pipeline, :with_coverage_reports, project: project, user: user1) }
      let_it_be(:pipeline2) { create(:ci_pipeline, :with_coverage_reports, project: project, user: user2) }

      it 'tracks all pipelines using HLLRedisCounter by multiple users for coverage test reports' do
        expect(Gitlab::UsageDataCounters::HLLRedisCounter)
          .to receive(:track_event)
          .with(test_event_name_2, values: user1.id)
          .and_call_original

        expect(Gitlab::UsageDataCounters::HLLRedisCounter)
          .to receive(:track_event)
          .with(test_event_name_2, values: user2.id)
          .and_call_original

        expect do
          described_class.new.execute(pipeline1)
          described_class.new.execute(pipeline2)
        end.to change {
          counter.unique_events(event_names: test_event_name_2, start_date: start_time, end_date: end_time)
        }.by 2
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module JobArtifacts
    class DestroyBatchService
      include BaseServiceUtility
      include ::Gitlab::Utils::StrongMemoize

      # Danger: Private - Should only be called in Ci Services that pass a batch of job artifacts
      # Not for use outside of the Ci:: namespace

      # Adds the passed batch of job artifacts to the `ci_deleted_objects` table
      # for asyncronous destruction of the objects in Object Storage via the `Ci::DeleteObjectsService`
      # and then deletes the batch of related `ci_job_artifacts` records.
      # Params:
      # +job_artifacts+:: A relation of job artifacts to destroy (fewer than MAX_JOB_ARTIFACT_BATCH_SIZE)
      # +pick_up_at+:: When to pick up for deletion of files
      # Returns:
      # +Hash+:: A hash with status and destroyed_artifacts_count keys
      def initialize(job_artifacts, pick_up_at: nil, skip_projects_on_refresh: false)
        @job_artifacts = job_artifacts.with_destroy_preloads.to_a
        @pick_up_at = pick_up_at
        @skip_projects_on_refresh = skip_projects_on_refresh
        @destroyed_ids = []
      end

      # rubocop: disable CodeReuse/ActiveRecord
      def execute(update_stats: true)
        if @skip_projects_on_refresh
          exclude_artifacts_undergoing_stats_refresh
        else
          track_artifacts_undergoing_stats_refresh
        end

        if @job_artifacts.empty?
          return success(destroyed_ids: @destroyed_ids, destroyed_artifacts_count: 0, statistics_updates: {})
        end

        destroy_related_records(@job_artifacts)

        destroy_around_hook(@job_artifacts) do
          @destroyed_ids = @job_artifacts.map(&:id)
          Ci::DeletedObject.transaction do
            Ci::DeletedObject.bulk_import(@job_artifacts, @pick_up_at)
            Ci::JobArtifact.id_in(@destroyed_ids).delete_all
          end
        end

        after_batch_destroy_hook(@job_artifacts)

        update_project_statistics! if update_stats

        increment_monitoring_statistics(artifacts_count, artifacts_bytes)

        Gitlab::Ci::Artifacts::Logger.log_deleted(@job_artifacts, 'Ci::JobArtifacts::DestroyBatchService#execute')

        success(
          destroyed_ids: @destroyed_ids,
          destroyed_artifacts_count: artifacts_count,
          statistics_updates: statistics_updates_per_project
        )
      end
      # rubocop: enable CodeReuse/ActiveRecord

      private

      # Overriden in EE
      # :nocov:
      def destroy_around_hook(artifacts)
        yield
      end
      # :nocov:

      # Overriden in EE
      def destroy_related_records(artifacts); end

      # Overriden in EE
      def after_batch_destroy_hook(artifacts); end

      # using ! here since this can't be called inside a transaction
      def update_project_statistics!
        statistics_updates_per_project.each do |project, increments|
          ProjectStatistics.bulk_increment_statistic(project, Ci::JobArtifact.project_statistics_name, increments)
        end
      end

      def statistics_updates_per_project
        strong_memoize(:statistics_updates_per_project) do
          result = Hash.new { |updates, project| updates[project] = [] }

          @job_artifacts.each_with_object(result) do |job_artifact, result|
            increment = Gitlab::Counters::Increment.new(amount: -job_artifact.size.to_i, ref: job_artifact.id)
            result[job_artifact.project] << increment
          end
        end
      end

      def increment_monitoring_statistics(size, bytes)
        metrics.increment_destroyed_artifacts_count(size)
        metrics.increment_destroyed_artifacts_bytes(bytes)
      end

      def metrics
        @metrics ||= ::Gitlab::Ci::Artifacts::Metrics.new
      end

      def artifacts_count
        strong_memoize(:artifacts_count) do
          @job_artifacts.count
        end
      end

      def artifacts_bytes
        strong_memoize(:artifacts_bytes) do
          @job_artifacts.sum { |artifact| artifact.try(:size) || 0 }
        end
      end

      def track_artifacts_undergoing_stats_refresh
        project_ids = @job_artifacts.find_all do |artifact|
          artifact.project.refreshing_build_artifacts_size?
        end.map(&:project_id).uniq

        project_ids.each do |project_id|
          Gitlab::ProjectStatsRefreshConflictsLogger.warn_artifact_deletion_during_stats_refresh(
            method: 'Ci::JobArtifacts::DestroyBatchService#execute',
            project_id: project_id
          )
        end
      end

      def exclude_artifacts_undergoing_stats_refresh
        project_ids = Set.new

        @job_artifacts.reject! do |artifact|
          next unless artifact.project.refreshing_build_artifacts_size?

          project_ids << artifact.project_id
        end

        if project_ids.any?
          Gitlab::ProjectStatsRefreshConflictsLogger.warn_skipped_artifact_deletion_during_stats_refresh(
            method: 'Ci::JobArtifacts::DestroyBatchService#execute',
            project_ids: project_ids
          )
        end
      end
    end
  end
end

Ci::JobArtifacts::DestroyBatchService.prepend_mod_with('Ci::JobArtifacts::DestroyBatchService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::JobArtifacts::DestroyBatchService, feature_category: :build_artifacts do
  let(:artifacts) { Ci::JobArtifact.where(id: [artifact_with_file.id, artifact_without_file.id]) }
  let(:skip_projects_on_refresh) { false }
  let(:service) do
    described_class.new(
      artifacts,
      pick_up_at: Time.current,
      skip_projects_on_refresh: skip_projects_on_refresh
    )
  end

  let_it_be(:artifact_with_file, refind: true) do
    create(:ci_job_artifact, :zip)
  end

  let_it_be(:artifact_without_file, refind: true) do
    create(:ci_job_artifact)
  end

  let_it_be(:undeleted_artifact, refind: true) do
    create(:ci_job_artifact)
  end

  describe '#execute' do
    subject(:execute) { service.execute }

    it 'creates a deleted object for artifact with attached file' do
      expect { subject }.to change { Ci::DeletedObject.count }.by(1)
    end

    it 'does not remove the attached file' do
      expect { execute }.not_to change { artifact_with_file.file.exists? }
    end

    it 'deletes the artifact records and logs them' do
      expect(Gitlab::Ci::Artifacts::Logger)
        .to receive(:log_deleted)
        .with(
          match_array([artifact_with_file, artifact_without_file]),
          'Ci::JobArtifacts::DestroyBatchService#execute'
        )

      expect { subject }.to change { Ci::JobArtifact.count }.by(-2)
    end

    it 'reports metrics for destroyed artifacts' do
      expect_next_instance_of(Gitlab::Ci::Artifacts::Metrics) do |metrics|
        expect(metrics).to receive(:increment_destroyed_artifacts_count).with(2).and_call_original
        expect(metrics).to receive(:increment_destroyed_artifacts_bytes).with(107464).and_call_original
      end

      execute
    end

    context 'when artifact belongs to a project that is undergoing stats refresh' do
      let!(:artifact_under_refresh_1) do
        create(:ci_job_artifact, :zip)
      end

      let!(:artifact_under_refresh_2) do
        create(:ci_job_artifact, :zip)
      end

      let!(:artifact_under_refresh_3) do
        create(:ci_job_artifact, :zip, project: artifact_under_refresh_2.project)
      end

      let(:artifacts) do
        Ci::JobArtifact.where(id: [artifact_with_file.id, artifact_under_refresh_1.id, artifact_under_refresh_2.id,
                                   artifact_under_refresh_3.id])
      end

      before do
        create(:project_build_artifacts_size_refresh, :created, project: artifact_with_file.project)
        create(:project_build_artifacts_size_refresh, :pending, project: artifact_under_refresh_1.project)
        create(:project_build_artifacts_size_refresh, :running, project: artifact_under_refresh_2.project)
      end

      shared_examples 'avoiding N+1 queries' do
        let!(:control_artifact_on_refresh) do
          create(:ci_job_artifact, :zip)
        end

        let!(:control_artifact_non_refresh) do
          create(:ci_job_artifact, :zip)
        end

        let!(:other_artifact_on_refresh) do
          create(:ci_job_artifact, :zip)
        end

        let!(:other_artifact_on_refresh_2) do
          create(:ci_job_artifact, :zip)
        end

        let!(:other_artifact_non_refresh) do
          create(:ci_job_artifact, :zip)
        end

        let!(:control_artifacts) do
          Ci::JobArtifact.where(
            id: [
              control_artifact_on_refresh.id,
              control_artifact_non_refresh.id
            ]
          )
        end

        let!(:artifacts) do
          Ci::JobArtifact.where(
            id: [
              other_artifact_on_refresh.id,
              other_artifact_on_refresh_2.id,
              other_artifact_non_refresh.id
            ]
          )
        end

        let(:control_service) do
          described_class.new(
            control_artifacts,
            pick_up_at: Time.current,
            skip_projects_on_refresh: skip_projects_on_refresh
          )
        end

        before do
          create(:project_build_artifacts_size_refresh, :pending, project: control_artifact_on_refresh.project)
          create(:project_build_artifacts_size_refresh, :pending, project: other_artifact_on_refresh.project)
          create(:project_build_artifacts_size_refresh, :pending, project: other_artifact_on_refresh_2.project)
        end

        it 'does not make multiple queries when fetching multiple project refresh records' do
          control = ActiveRecord::QueryRecorder.new { control_service.execute }

          expect { subject }.not_to exceed_query_limit(control)
        end
      end

      context 'and skip_projects_on_refresh is set to false (default)' do
        it 'logs the projects undergoing refresh and continues with the delete', :aggregate_failures do
          expect(Gitlab::ProjectStatsRefreshConflictsLogger).to receive(:warn_artifact_deletion_during_stats_refresh).with(
            method: 'Ci::JobArtifacts::DestroyBatchService#execute',
            project_id: artifact_under_refresh_1.project.id
          ).once

          expect(Gitlab::ProjectStatsRefreshConflictsLogger).to receive(:warn_artifact_deletion_during_stats_refresh).with(
            method: 'Ci::JobArtifacts::DestroyBatchService#execute',
            project_id: artifact_under_refresh_2.project.id
          ).once

          expect { subject }.to change { Ci::JobArtifact.count }.by(-4)
        end

        it_behaves_like 'avoiding N+1 queries'
      end

      context 'and skip_projects_on_refresh is set to true' do
        let(:skip_projects_on_refresh) { true }

        it 'logs the projects undergoing refresh and excludes the artifacts from deletion', :aggregate_failures do
          expect(Gitlab::ProjectStatsRefreshConflictsLogger).to receive(:warn_skipped_artifact_deletion_during_stats_refresh).with(
            method: 'Ci::JobArtifacts::DestroyBatchService#execute',
            project_ids: match_array([artifact_under_refresh_1.project.id, artifact_under_refresh_2.project.id])
          )

          expect { subject }.to change { Ci::JobArtifact.count }.by(-1)
          expect(Ci::JobArtifact.where(id: artifact_under_refresh_1.id)).to exist
          expect(Ci::JobArtifact.where(id: artifact_under_refresh_2.id)).to exist
          expect(Ci::JobArtifact.where(id: artifact_under_refresh_3.id)).to exist
        end

        it_behaves_like 'avoiding N+1 queries'
      end
    end

    context 'when artifact belongs to a project not undergoing refresh' do
      context 'and skip_projects_on_refresh is set to false (default)' do
        it 'does not log any warnings', :aggregate_failures do
          expect(Gitlab::ProjectStatsRefreshConflictsLogger).not_to receive(:warn_artifact_deletion_during_stats_refresh)

          expect { subject }.to change { Ci::JobArtifact.count }.by(-2)
        end
      end

      context 'and skip_projects_on_refresh is set to true' do
        let(:skip_projects_on_refresh) { true }

        it 'does not log any warnings', :aggregate_failures do
          expect(Gitlab::ProjectStatsRefreshConflictsLogger).not_to receive(:warn_skipped_artifact_deletion_during_stats_refresh)

          expect { subject }.to change { Ci::JobArtifact.count }.by(-2)
        end
      end
    end

    context 'ProjectStatistics', :sidekiq_inline do
      let_it_be(:project_1) { create(:project) }
      let_it_be(:project_2) { create(:project) }

      let(:artifact_with_file) { create(:ci_job_artifact, :zip, project: project_1) }
      let(:artifact_with_file_2) { create(:ci_job_artifact, :zip, project: project_1) }
      let(:artifact_without_file) { create(:ci_job_artifact, project: project_2) }
      let!(:artifacts) { Ci::JobArtifact.where(id: [artifact_with_file.id, artifact_without_file.id, artifact_with_file_2.id]) }

      it 'updates project statistics by the relevant amount' do
        expected_amount = -(artifact_with_file.size + artifact_with_file_2.size)

        expect { execute }
          .to change { project_1.statistics.reload.build_artifacts_size }.by(expected_amount)
          .and change { project_2.statistics.reload.build_artifacts_size }.by(0)
      end

      it 'increments project statistics with artifact size as amount and job artifact id as ref' do
        project_1_increments = [
          have_attributes(amount: -artifact_with_file.size, ref: artifact_with_file.id),
          have_attributes(amount: -artifact_with_file_2.file.size, ref: artifact_with_file_2.id)
        ]
        project_2_increments = [have_attributes(amount: 0, ref: artifact_without_file.id)]

        expect(ProjectStatistics).to receive(:bulk_increment_statistic).with(project_1, :build_artifacts_size, match_array(project_1_increments))
        expect(ProjectStatistics).to receive(:bulk_increment_statistic).with(project_2, :build_artifacts_size, match_array(project_2_increments))

        execute
      end

      context 'with update_stats: false' do
        subject(:execute) { service.execute(update_stats: false) }

        it 'does not update project statistics' do
          expect { execute }.not_to change { [project_1.statistics.reload.build_artifacts_size, project_2.statistics.reload.build_artifacts_size] }
        end

        it 'returns statistic updates per project' do
          project_1_updates = [
            have_attributes(amount: -artifact_with_file.size, ref: artifact_with_file.id),
            have_attributes(amount: -artifact_with_file_2.file.size, ref: artifact_with_file_2.id)
          ]
          project_2_updates = [have_attributes(amount: 0, ref: artifact_without_file.id)]

          expected_updates = {
            statistics_updates: {
              project_1 => match_array(project_1_updates),
              project_2 => project_2_updates
            }
          }

          expect(execute).to match(a_hash_including(expected_updates))
        end
      end
    end

    context 'when failed to destroy artifact' do
      context 'when the import fails' do
        before do
          expect(Ci::DeletedObject)
            .to receive(:bulk_import)
            .once
            .and_raise(ActiveRecord::RecordNotDestroyed)
        end

        it 'raises an exception and stop destroying' do
          expect { execute }.to raise_error(ActiveRecord::RecordNotDestroyed)
                            .and not_change { Ci::JobArtifact.count }
        end
      end
    end

    context 'when there are no artifacts' do
      let(:artifacts) { Ci::JobArtifact.none }

      it 'does not raise error' do
        expect { execute }.not_to raise_error
      end

      it 'reports the number of destroyed artifacts' do
        is_expected.to eq(destroyed_artifacts_count: 0, destroyed_ids: [], statistics_updates: {}, status: :success)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module JobArtifacts
    # This class is used by Ci::JobArtifact's FastDestroyAll implementation.
    # Ci::JobArtifact.begin_fast_destroy instantiates this service and calls #destroy_records.
    # This will set @statistics_updates instance variables.
    # The same instance is passed to Ci::JobArtifact.finalize_fast_destroy, which then calls
    # #update_statistics, using @statistics_updates set by #destroy_records.
    class DestroyAssociationsService
      BATCH_SIZE = 100

      def initialize(job_artifacts_relation)
        @job_artifacts_relation = job_artifacts_relation
        @statistics_updates = {}
      end

      def destroy_records
        @job_artifacts_relation.each_batch(of: BATCH_SIZE) do |relation|
          service = Ci::JobArtifacts::DestroyBatchService.new(relation, pick_up_at: Time.current)
          result  = service.execute(update_stats: false)
          @statistics_updates.merge!(result[:statistics_updates]) do |_project, existing_updates, new_updates|
            existing_updates.concat(new_updates)
          end
        end
      end

      def update_statistics
        @statistics_updates.each do |project, increments|
          ProjectStatistics.bulk_increment_statistic(project, Ci::JobArtifact.project_statistics_name, increments)
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::JobArtifacts::DestroyAssociationsService, feature_category: :build_artifacts do
  let_it_be(:project_1) { create(:project) }
  let_it_be(:project_2) { create(:project) }

  let_it_be(:artifact_1, refind: true) { create(:ci_job_artifact, :zip, project: project_1) }
  let_it_be(:artifact_2, refind: true) { create(:ci_job_artifact, :junit, project: project_2) }
  let_it_be(:artifact_3, refind: true) { create(:ci_job_artifact, :terraform, project: project_1) }
  let_it_be(:artifact_4, refind: true) { create(:ci_job_artifact, :trace, project: project_2) }
  let_it_be(:artifact_5, refind: true) { create(:ci_job_artifact, :metadata, project: project_2) }

  let_it_be(:locked_artifact, refind: true) { create(:ci_job_artifact, :zip, :locked, project: project_1) }

  let(:artifact_ids_to_be_removed) { [artifact_1.id, artifact_2.id, artifact_3.id, artifact_4.id, artifact_5.id] }
  let(:artifacts) { Ci::JobArtifact.where(id: artifact_ids_to_be_removed) }
  let(:service) { described_class.new(artifacts) }

  describe '#destroy_records' do
    it 'removes all types of artifacts without updating statistics' do
      expect_next_instance_of(Ci::JobArtifacts::DestroyBatchService) do |service|
        expect(service).to receive(:execute).with(update_stats: false).and_call_original
      end

      expect { service.destroy_records }.to change { Ci::JobArtifact.count }.by(-artifact_ids_to_be_removed.count)
    end

    context 'with a locked artifact' do
      let(:artifact_ids_to_be_removed) { [artifact_1.id, locked_artifact.id] }

      it 'removes all artifacts' do
        expect { service.destroy_records }.to change { Ci::JobArtifact.count }.by(-artifact_ids_to_be_removed.count)
      end
    end

    context 'when there are no artifacts' do
      let(:artifacts) { Ci::JobArtifact.none }

      it 'does not raise error' do
        expect { service.destroy_records }.not_to raise_error
      end
    end
  end

  describe '#update_statistics' do
    before do
      stub_const(""#{described_class}::BATCH_SIZE"", 2)
      service.destroy_records
    end

    it 'updates project statistics' do
      project1_increments = [
        have_attributes(amount: -artifact_1.size, ref: artifact_1.id),
        have_attributes(amount: -artifact_3.size, ref: artifact_3.id)
      ]
      project2_increments = [
        have_attributes(amount: -artifact_2.size, ref: artifact_2.id),
        have_attributes(amount: -artifact_4.size, ref: artifact_4.id),
        have_attributes(amount: -artifact_5.size, ref: artifact_5.id)
      ]

      expect(ProjectStatistics).to receive(:bulk_increment_statistic).once
        .with(project_1, :build_artifacts_size, match_array(project1_increments))
      expect(ProjectStatistics).to receive(:bulk_increment_statistic).once
        .with(project_2, :build_artifacts_size, match_array(project2_increments))

      service.update_statistics
    end

    context 'when there are no artifacts' do
      let(:artifacts) { Ci::JobArtifact.none }

      it 'does not raise error' do
        expect { service.update_statistics }.not_to raise_error
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module JobArtifacts
    class DestroyAllExpiredService
      include ::Gitlab::ExclusiveLeaseHelpers
      include ::Gitlab::LoopHelpers

      BATCH_SIZE = 100
      LOOP_LIMIT = 500
      LOOP_TIMEOUT = 5.minutes
      LOCK_TIMEOUT = 6.minutes
      EXCLUSIVE_LOCK_KEY = 'expired_job_artifacts:destroy:lock'

      def initialize
        @removed_artifacts_count = 0
        @start_at = Time.current
      end

      ##
      # Destroy expired job artifacts on GitLab instance
      #
      # This destroy process cannot run for more than 6 minutes. This is for
      # preventing multiple `ExpireBuildArtifactsWorker` CRON jobs run concurrently,
      # which is scheduled every 7 minutes.
      def execute
        in_lock(EXCLUSIVE_LOCK_KEY, ttl: LOCK_TIMEOUT, retries: 1) do
          destroy_unlocked_job_artifacts
        end

        @removed_artifacts_count
      end

      private

      def destroy_unlocked_job_artifacts
        loop_until(timeout: LOOP_TIMEOUT, limit: LOOP_LIMIT) do
          artifacts = Ci::JobArtifact.expired_before(@start_at).non_trace.artifact_unlocked.limit(BATCH_SIZE)
          service_response = destroy_batch(artifacts)
          @removed_artifacts_count += service_response[:destroyed_artifacts_count]
        end
      end

      def destroy_batch(artifacts)
        Ci::JobArtifacts::DestroyBatchService.new(artifacts, skip_projects_on_refresh: true).execute
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::JobArtifacts::DestroyAllExpiredService, :clean_gitlab_redis_shared_state,
  feature_category: :build_artifacts do
  include ExclusiveLeaseHelpers

  let(:service) { described_class.new }

  describe '.execute' do
    subject { service.execute }

    let_it_be(:locked_pipeline) { create(:ci_pipeline, :artifacts_locked) }
    let_it_be(:pipeline) { create(:ci_pipeline, :unlocked) }
    let_it_be(:locked_job) { create(:ci_build, :success, pipeline: locked_pipeline) }
    let_it_be(:job) { create(:ci_build, :success, pipeline: pipeline) }

    context 'when artifact is expired' do
      let!(:artifact) { create(:ci_job_artifact, :expired, job: job, locked: job.pipeline.locked) }

      context 'with preloaded relationships' do
        let(:second_artifact) { create(:ci_job_artifact, :expired, :junit, job: job) }

        let(:more_artifacts) do
          [
            create(:ci_job_artifact, :expired, :sast, job: job),
            create(:ci_job_artifact, :expired, :metadata, job: job),
            create(:ci_job_artifact, :expired, :codequality, job: job),
            create(:ci_job_artifact, :expired, :accessibility, job: job)
          ]
        end

        before do
          stub_const(""#{described_class}::LOOP_LIMIT"", 1)

          # This artifact-with-file is created before the control execution to ensure
          # that the DeletedObject operations are accounted for in the query count.
          second_artifact
        end

        it 'performs a consistent number of queries' do
          control = ActiveRecord::QueryRecorder.new { service.execute }

          more_artifacts

          expect { subject }.not_to exceed_query_limit(control.count)
        end
      end

      context 'when artifact is not locked' do
        it 'deletes job artifact record' do
          expect { subject }.to change { Ci::JobArtifact.count }.by(-1)
        end

        context 'when the artifact does not have a file attached to it' do
          it 'does not create deleted objects' do
            expect(artifact.exists?).to be_falsy # sanity check

            expect { subject }.not_to change { Ci::DeletedObject.count }
          end
        end

        context 'when the artifact has a file attached to it' do
          let!(:artifact) { create(:ci_job_artifact, :expired, :zip, job: job, locked: job.pipeline.locked) }

          it 'creates a deleted object' do
            expect { subject }.to change { Ci::DeletedObject.count }.by(1)
          end

          it 'resets project statistics', :sidekiq_inline do
            expect { subject }
              .to change { artifact.project.statistics.reload.build_artifacts_size }.by(-artifact.file.size)
          end

          it 'does not remove the files' do
            expect { subject }.not_to change { artifact.file.exists? }
          end
        end

        context 'when the project in which the artifact belongs to is undergoing stats refresh' do
          before do
            create(:project_build_artifacts_size_refresh, :pending, project: artifact.project)
          end

          it 'does not destroy job artifact' do
            expect { subject }.not_to change { Ci::JobArtifact.count }
          end
        end
      end

      context 'when artifact is locked' do
        let!(:artifact) { create(:ci_job_artifact, :expired, job: locked_job, locked: locked_job.pipeline.locked) }

        it 'does not destroy job artifact' do
          expect { subject }.not_to change { Ci::JobArtifact.count }
        end
      end
    end

    context 'when artifact is not expired' do
      let!(:artifact) { create(:ci_job_artifact, job: job, locked: job.pipeline.locked) }

      it 'does not destroy expired job artifacts' do
        expect { subject }.not_to change { Ci::JobArtifact.count }
      end
    end

    context 'when artifact is permanent' do
      let!(:artifact) { create(:ci_job_artifact, expire_at: nil, job: job, locked: job.pipeline.locked) }

      it 'does not destroy expired job artifacts' do
        expect { subject }.not_to change { Ci::JobArtifact.count }
      end
    end

    context 'when failed to destroy artifact' do
      let!(:artifact) { create(:ci_job_artifact, :expired, job: job, locked: job.pipeline.locked) }

      before do
        stub_const(""#{described_class}::LOOP_LIMIT"", 10)
      end

      context 'when the import fails' do
        before do
          expect(Ci::DeletedObject)
            .to receive(:bulk_import)
            .once
            .and_raise(ActiveRecord::RecordNotDestroyed)
        end

        it 'raises an exception and stop destroying' do
          expect { subject }.to raise_error(ActiveRecord::RecordNotDestroyed)
                            .and not_change { Ci::JobArtifact.count }.from(1)
        end
      end

      context 'when the delete fails' do
        before do
          expect(Ci::JobArtifact)
            .to receive(:id_in)
            .once
            .and_raise(ActiveRecord::RecordNotDestroyed)
        end

        it 'raises an exception rolls back the insert' do
          expect { subject }.to raise_error(ActiveRecord::RecordNotDestroyed)
                            .and not_change { Ci::DeletedObject.count }.from(0)
        end
      end
    end

    context 'when exclusive lease has already been taken by the other instance' do
      let!(:artifact) { create(:ci_job_artifact, :expired, job: job, locked: job.pipeline.locked) }

      before do
        stub_exclusive_lease_taken(described_class::EXCLUSIVE_LOCK_KEY, timeout: described_class::LOCK_TIMEOUT)
      end

      it 'raises an error and does not start destroying' do
        expect { subject }.to raise_error(Gitlab::ExclusiveLeaseHelpers::FailedToObtainLockError)
                          .and not_change { Ci::JobArtifact.count }.from(1)
      end
    end

    context 'with a second artifact and batch size of 1' do
      let(:second_job) { create(:ci_build, :success, pipeline: pipeline) }
      let!(:second_artifact) { create(:ci_job_artifact, :archive, expire_at: 1.day.ago, job: second_job, locked: job.pipeline.locked) }
      let!(:artifact) { create(:ci_job_artifact, :expired, job: job, locked: job.pipeline.locked) }

      before do
        stub_const(""#{described_class}::BATCH_SIZE"", 1)
      end

      context 'when timeout happens' do
        before do
          stub_const(""#{described_class}::LOOP_TIMEOUT"", 0.seconds)
        end

        it 'destroys one artifact' do
          expect { subject }.to change { Ci::JobArtifact.count }.by(-1)
        end

        it 'reports the number of destroyed artifacts' do
          is_expected.to eq(1)
        end
      end

      context 'when loop reached loop limit' do
        before do
          stub_const(""#{described_class}::LOOP_LIMIT"", 1)
        end

        it 'destroys one artifact' do
          expect { subject }.to change { Ci::JobArtifact.count }.by(-1)
        end

        it 'reports the number of destroyed artifacts' do
          is_expected.to eq(1)
        end
      end

      context 'when the number of artifacts is greater than than batch size' do
        it 'destroys all expired artifacts' do
          expect { subject }.to change { Ci::JobArtifact.count }.by(-2)
        end

        it 'reports the number of destroyed artifacts' do
          is_expected.to eq(2)
        end
      end
    end

    context 'when there are no artifacts' do
      it 'does not raise error' do
        expect { subject }.not_to raise_error
      end

      it 'reports the number of destroyed artifacts' do
        is_expected.to eq(0)
      end
    end

    context 'when some artifacts are locked' do
      let!(:artifact) { create(:ci_job_artifact, :expired, job: job, locked: job.pipeline.locked) }
      let!(:locked_artifact) { create(:ci_job_artifact, :expired, job: locked_job, locked: locked_job.pipeline.locked) }

      it 'destroys only unlocked artifacts' do
        expect { subject }.to change { Ci::JobArtifact.count }.by(-1)
        expect(locked_artifact).to be_persisted
      end
    end

    context 'when some artifacts are trace' do
      let!(:artifact) { create(:ci_job_artifact, :expired, job: job, locked: job.pipeline.locked) }
      let!(:trace_artifact) { create(:ci_job_artifact, :trace, :expired, job: job, locked: job.pipeline.locked) }

      it 'destroys only non trace artifacts' do
        expect { subject }.to change { Ci::JobArtifact.count }.by(-1)
        expect(trace_artifact).to be_persisted
      end
    end

    context 'when all artifacts are locked' do
      let!(:artifact) { create(:ci_job_artifact, :expired, job: locked_job, locked: locked_job.pipeline.locked) }

      it 'destroys no artifacts' do
        expect { subject }.to change { Ci::JobArtifact.count }.by(0)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module JobArtifacts
    class UpdateUnknownLockedStatusService
      include ::Gitlab::ExclusiveLeaseHelpers
      include ::Gitlab::LoopHelpers

      BATCH_SIZE = 100
      LOOP_TIMEOUT = 5.minutes
      LOOP_LIMIT = 100
      LARGE_LOOP_LIMIT = 500
      EXCLUSIVE_LOCK_KEY = 'unknown_status_job_artifacts:update:lock'
      LOCK_TIMEOUT = 6.minutes

      def initialize
        @removed_count = 0
        @locked_count = 0
        @start_at = Time.current
        @loop_limit = Feature.enabled?(:ci_job_artifacts_backlog_large_loop_limit) ? LARGE_LOOP_LIMIT : LOOP_LIMIT
      end

      def execute
        in_lock(EXCLUSIVE_LOCK_KEY, ttl: LOCK_TIMEOUT, retries: 1) do
          update_locked_status_on_unknown_artifacts
        end

        { removed: @removed_count, locked: @locked_count }
      end

      private

      def update_locked_status_on_unknown_artifacts
        loop_until(timeout: LOOP_TIMEOUT, limit: @loop_limit) do
          unknown_status_build_ids = safely_ordered_ci_job_artifacts_locked_unknown_relation.pluck_job_id.uniq

          locked_pipe_build_ids = ::Ci::Build
            .with_pipeline_locked_artifacts
            .id_in(unknown_status_build_ids)
            .pluck_primary_key

          @locked_count += update_unknown_artifacts(locked_pipe_build_ids, Ci::JobArtifact.lockeds[:artifacts_locked])

          unlocked_pipe_build_ids = unknown_status_build_ids - locked_pipe_build_ids
          service_response = batch_destroy_artifacts(unlocked_pipe_build_ids)
          @removed_count += service_response[:destroyed_artifacts_count]
        end
      end

      def update_unknown_artifacts(build_ids, locked_value)
        return 0 unless build_ids.any?

        expired_locked_unknown_artifacts.for_job_ids(build_ids).update_all(locked: locked_value)
      end

      def batch_destroy_artifacts(build_ids)
        deleteable_artifacts_relation =
          if build_ids.any?
            expired_locked_unknown_artifacts.for_job_ids(build_ids)
          else
            Ci::JobArtifact.none
          end

        Ci::JobArtifacts::DestroyBatchService.new(deleteable_artifacts_relation).execute
      end

      def expired_locked_unknown_artifacts
        # UPDATE queries perform better without the specific order and limit
        # https://gitlab.com/gitlab-org/gitlab/-/merge_requests/76509#note_891260455
        Ci::JobArtifact.expired_before(@start_at).artifact_unknown
      end

      def safely_ordered_ci_job_artifacts_locked_unknown_relation
        # Adding the ORDER and LIMIT improves performance when we don't have build_id
        expired_locked_unknown_artifacts.limit(BATCH_SIZE).order_expired_asc
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::JobArtifacts::UpdateUnknownLockedStatusService, :clean_gitlab_redis_shared_state,
  feature_category: :build_artifacts do
  include ExclusiveLeaseHelpers

  let(:service) { described_class.new }

  describe '.execute' do
    subject { service.execute }

    let_it_be(:locked_pipeline) { create(:ci_pipeline, :artifacts_locked) }
    let_it_be(:pipeline) { create(:ci_pipeline, :unlocked) }
    let_it_be(:locked_job) { create(:ci_build, :success, pipeline: locked_pipeline) }
    let_it_be(:job) { create(:ci_build, :success, pipeline: pipeline) }

    let!(:unknown_unlocked_artifact) do
      create(:ci_job_artifact, :junit, expire_at: 1.hour.ago, job: job, locked: Ci::JobArtifact.lockeds[:unknown])
    end

    let!(:unknown_locked_artifact) do
      create(:ci_job_artifact, :lsif,
        expire_at: 1.day.ago,
        job: locked_job,
        locked: Ci::JobArtifact.lockeds[:unknown]
      )
    end

    let!(:unlocked_artifact) do
      create(:ci_job_artifact, :archive, expire_at: 1.hour.ago, job: job, locked: Ci::JobArtifact.lockeds[:unlocked])
    end

    let!(:locked_artifact) do
      create(:ci_job_artifact, :sast, :raw,
        expire_at: 1.day.ago,
        job: locked_job,
        locked: Ci::JobArtifact.lockeds[:artifacts_locked]
      )
    end

    context 'when artifacts are expired' do
      it 'sets artifact_locked when the pipeline is locked' do
        expect { service.execute }
          .to change { unknown_locked_artifact.reload.locked }.from('unknown').to('artifacts_locked')
          .and not_change { Ci::JobArtifact.exists?(locked_artifact.id) }
      end

      it 'destroys the artifact when the pipeline is unlocked' do
        expect { subject }.to change { Ci::JobArtifact.exists?(unknown_unlocked_artifact.id) }.from(true).to(false)
      end

      it 'does not update ci_job_artifact rows with known locked values' do
        expect { service.execute }
          .to not_change(locked_artifact, :attributes)
          .and not_change { Ci::JobArtifact.exists?(locked_artifact.id) }
          .and not_change(unlocked_artifact, :attributes)
          .and not_change { Ci::JobArtifact.exists?(unlocked_artifact.id) }
      end

      it 'logs the counts of affected artifacts' do
        expect(subject).to eq({ removed: 1, locked: 1 })
      end
    end

    context 'in a single iteration' do
      before do
        stub_const(""#{described_class}::BATCH_SIZE"", 1)
      end

      context 'due to the LOOP_TIMEOUT' do
        before do
          stub_const(""#{described_class}::LOOP_TIMEOUT"", 0.seconds)
        end

        it 'affects the earliest expired artifact first' do
          subject

          expect(unknown_locked_artifact.reload.locked).to eq('artifacts_locked')
          expect(unknown_unlocked_artifact.reload.locked).to eq('unknown')
        end

        it 'reports the number of destroyed artifacts' do
          is_expected.to eq({ removed: 0, locked: 1 })
        end
      end

      context 'due to @loop_limit' do
        before do
          stub_const(""#{described_class}::LARGE_LOOP_LIMIT"", 1)
        end

        it 'affects the most recently expired artifact first' do
          subject

          expect(unknown_locked_artifact.reload.locked).to eq('artifacts_locked')
          expect(unknown_unlocked_artifact.reload.locked).to eq('unknown')
        end

        it 'reports the number of destroyed artifacts' do
          is_expected.to eq({ removed: 0, locked: 1 })
        end
      end
    end

    context 'when artifact is not expired' do
      let!(:unknown_unlocked_artifact) do
        create(:ci_job_artifact, :junit,
          expire_at: 1.year.from_now,
          job: job,
          locked: Ci::JobArtifact.lockeds[:unknown]
        )
      end

      it 'does not change the locked status' do
        expect { service.execute }.not_to change { unknown_unlocked_artifact.locked }
        expect(Ci::JobArtifact.exists?(unknown_unlocked_artifact.id)).to eq(true)
      end
    end

    context 'when exclusive lease has already been taken by the other instance' do
      before do
        stub_exclusive_lease_taken(described_class::EXCLUSIVE_LOCK_KEY, timeout: described_class::LOCK_TIMEOUT)
      end

      it 'raises an error and' do
        expect { subject }.to raise_error(Gitlab::ExclusiveLeaseHelpers::FailedToObtainLockError)
      end
    end

    context 'when there are no unknown status artifacts' do
      before do
        Ci::JobArtifact.update_all(locked: :unlocked)
      end

      it 'does not raise error' do
        expect { subject }.not_to raise_error
      end

      it 'reports the number of destroyed artifacts' do
        is_expected.to eq({ removed: 0, locked: 0 })
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module JobArtifacts
    class BulkDeleteByProjectService
      include BaseServiceUtility

      JOB_ARTIFACTS_COUNT_LIMIT = 50

      def initialize(job_artifact_ids:, project:, current_user:)
        @job_artifact_ids = job_artifact_ids
        @project = project
        @current_user = current_user
      end

      def execute
        if exceeds_limits?
          return ServiceResponse.error(
            message: ""Can only delete up to #{JOB_ARTIFACTS_COUNT_LIMIT} job artifacts per call""
          )
        end

        find_result = find_artifacts

        return ServiceResponse.error(message: find_result[:error_message]) if find_result[:error_message]

        @job_artifact_scope = find_result[:scope]

        unless all_job_artifacts_belong_to_project?
          return ServiceResponse.error(message: 'Not all artifacts belong to requested project')
        end

        result = Ci::JobArtifacts::DestroyBatchService.new(job_artifact_scope).execute

        destroyed_artifacts_count = result.fetch(:destroyed_artifacts_count)
        destroyed_ids = result.fetch(:destroyed_ids)

        ServiceResponse.success(
          payload: {
            destroyed_count: destroyed_artifacts_count,
            destroyed_ids: destroyed_ids,
            errors: []
          })
      end

      private

      def find_artifacts
        job_artifacts = ::Ci::JobArtifact.id_in(job_artifact_ids)

        error_message = nil
        if job_artifacts.count != job_artifact_ids.count
          not_found_artifacts = job_artifact_ids - job_artifacts.map(&:id)
          error_message = ""Artifacts (#{not_found_artifacts.join(',')}) not found""
        end

        { scope: job_artifacts, error_message: error_message }
      end

      def exceeds_limits?
        job_artifact_ids.count > JOB_ARTIFACTS_COUNT_LIMIT
      end

      def all_job_artifacts_belong_to_project?
        # rubocop:disable CodeReuse/ActiveRecord
        job_artifact_scope.pluck(:project_id).all?(project.id)
        # rubocop:enable CodeReuse/ActiveRecord
      end

      attr_reader :job_artifact_ids, :job_artifact_scope, :current_user, :project
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ci::JobArtifacts::BulkDeleteByProjectService, ""#execute"", feature_category: :build_artifacts do
  subject(:execute) do
    described_class.new(
      job_artifact_ids: job_artifact_ids,
      current_user: current_user,
      project: project).execute
  end

  let_it_be(:current_user) { create(:user) }
  let_it_be(:build, reload: true) do
    create(:ci_build, :artifacts, :trace_artifact, user: current_user)
  end

  let_it_be(:project) { build.project }
  let_it_be(:job_artifact_ids) { build.job_artifacts.map(&:id) }

  describe '#execute' do
    context 'when number of artifacts exceeds limits to delete' do
      let_it_be(:second_build, reload: true) do
        create(:ci_build, :artifacts, :trace_artifact, user: current_user, project: project)
      end

      let_it_be(:job_artifact_ids) { ::Ci::JobArtifact.all.map(&:id) }

      before do
        project.add_maintainer(current_user)
        stub_const(""#{described_class}::JOB_ARTIFACTS_COUNT_LIMIT"", 1)
      end

      it 'fails to destroy' do
        result = execute

        expect(result).to be_error
        expect(result[:message]).to eq('Can only delete up to 1 job artifacts per call')
      end
    end

    context 'when requested not existing artifacts do delete' do
      let_it_be(:deleted_build, reload: true) do
        create(:ci_build, :artifacts, :trace_artifact, user: current_user, project: project)
      end

      let_it_be(:deleted_job_artifacts) { deleted_build.job_artifacts }
      let_it_be(:job_artifact_ids) { ::Ci::JobArtifact.all.map(&:id) }

      before do
        project.add_maintainer(current_user)
        deleted_job_artifacts.each(&:destroy!)
      end

      it 'fails to destroy' do
        result = execute

        expect(result).to be_error
        expect(result[:message]).to eq(""Artifacts (#{deleted_job_artifacts.map(&:id).join(',')}) not found"")
      end
    end

    context 'when maintainer has access to the project' do
      before do
        project.add_maintainer(current_user)
      end

      it 'is successful' do
        result = execute

        expect(result).to be_success
        expect(result.payload).to eq(
          {
            destroyed_count: job_artifact_ids.count,
            destroyed_ids: job_artifact_ids,
            errors: []
          }
        )
        expect(::Ci::JobArtifact.where(id: job_artifact_ids).count).to eq(0)
      end

      context 'and partially owns artifacts' do
        let_it_be(:orphan_artifact) { create(:ci_job_artifact, :archive) }
        let_it_be(:orphan_artifact_id) { orphan_artifact.id }
        let_it_be(:owned_artifacts_ids) { build.job_artifacts.erasable.map(&:id) }
        let_it_be(:job_artifact_ids) { [orphan_artifact_id] + owned_artifacts_ids }

        it 'fails to destroy' do
          result = execute

          expect(result).to be_error
          expect(result[:message]).to be('Not all artifacts belong to requested project')
          expect(::Ci::JobArtifact.where(id: job_artifact_ids).count).to eq(3)
        end
      end

      context 'and request all artifacts from a different project' do
        let_it_be(:different_project_artifact) { create(:ci_job_artifact, :archive) }
        let_it_be(:job_artifact_ids) { [different_project_artifact] }

        let_it_be(:different_build, reload: true) do
          create(:ci_build, :artifacts, :trace_artifact, user: current_user)
        end

        let_it_be(:different_project) { different_build.project }

        before do
          different_project.add_maintainer(current_user)
        end

        it 'returns a error' do
          result = execute

          expect(result).to be_error
          expect(result[:message]).to be('Not all artifacts belong to requested project')
          expect(::Ci::JobArtifact.where(id: job_artifact_ids).count).to eq(job_artifact_ids.count)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module JobArtifacts
    class CreateService < ::BaseService
      include Gitlab::Utils::UsageData

      LSIF_ARTIFACT_TYPE = 'lsif'

      OBJECT_STORAGE_ERRORS = [
        Errno::EIO,
        Google::Apis::ServerError,
        Signet::RemoteServerError
      ].freeze

      def initialize(job)
        @job = job
        @project = job.project
        @pipeline = job.pipeline
      end

      def authorize(artifact_type:, filesize: nil)
        result = validate_requirements(artifact_type: artifact_type, filesize: filesize)
        return result unless result[:status] == :success

        headers = JobArtifactUploader.workhorse_authorize(
          has_length: false,
          maximum_size: max_size(artifact_type),
          use_final_store_path: true,
          final_store_path_root_id: project.id
        )

        if lsif?(artifact_type)
          headers[:ProcessLsif] = true
          track_usage_event('i_source_code_code_intelligence', project.id)
        end

        success(headers: headers)
      end

      def execute(artifacts_file, params, metadata_file: nil)
        result = validate_requirements(artifact_type: params[:artifact_type], filesize: artifacts_file.size)
        return result unless result[:status] == :success

        return success if sha256_matches_existing_artifact?(params[:artifact_type], artifacts_file)

        build_result = build_artifact(artifacts_file, params, metadata_file)
        return build_result unless build_result[:status] == :success

        artifact = build_result[:artifact]
        artifact_metadata = build_result[:artifact_metadata]

        track_artifact_uploader(artifact)

        parse_result = parse_artifact(artifact)
        return parse_result unless parse_result[:status] == :success

        persist_artifact(artifact, artifact_metadata)
      end

      private

      attr_reader :job, :project, :pipeline

      def validate_requirements(artifact_type:, filesize:)
        return too_large_error if too_large?(artifact_type, filesize)

        success
      end

      def too_large?(type, size)
        size > max_size(type) if size
      end

      def lsif?(type)
        type == LSIF_ARTIFACT_TYPE
      end

      def max_size(type)
        Ci::JobArtifact.max_artifact_size(type: type, project: project)
      end

      def too_large_error
        error('file size has reached maximum size limit', :payload_too_large)
      end

      def build_artifact(artifacts_file, params, metadata_file)
        artifact_attributes = {
          job: job,
          project: project,
          expire_in: expire_in(params),
          accessibility: accessibility(params),
          locked: pipeline.locked
        }

        file_attributes = {
          file_type: params[:artifact_type],
          file_format: params[:artifact_format],
          file_sha256: artifacts_file.sha256,
          file: artifacts_file
        }

        artifact = Ci::JobArtifact.new(artifact_attributes.merge(file_attributes))

        artifact_metadata = build_metadata_artifact(artifact, metadata_file) if metadata_file

        success(artifact: artifact, artifact_metadata: artifact_metadata)
      end

      def build_metadata_artifact(job_artifact, metadata_file)
        Ci::JobArtifact.new(
          job: job_artifact.job,
          project: job_artifact.project,
          expire_at: job_artifact.expire_at,
          locked: job_artifact.locked,
          file: metadata_file,
          file_type: :metadata,
          file_format: :gzip,
          file_sha256: metadata_file.sha256,
          accessibility: job_artifact.accessibility
        )
      end

      def expire_in(params)
        params['expire_in'] || Gitlab::CurrentSettings.current_application_settings.default_artifacts_expire_in
      end

      def accessibility(params)
        accessibility = params[:accessibility]

        return :public if Feature.disabled?(:non_public_artifacts, project, type: :development)

        return accessibility if accessibility.present?

        job.artifact_is_public_in_config? ? :public : :private
      end

      def parse_artifact(artifact)
        case artifact.file_type
        when 'dotenv' then parse_dotenv_artifact(artifact)
        when 'annotations' then parse_annotations_artifact(artifact)
        else success
        end
      end

      def persist_artifact(artifact, artifact_metadata)
        job.transaction do
          # NOTE: The `artifacts_expire_at` column is already deprecated and to be removed in the near future.
          # Running it first because in migrations we lock the `ci_builds` table
          # first and then the others. This reduces the chances of deadlocks.
          job.update_column(:artifacts_expire_at, artifact.expire_at)

          artifact.save!
          artifact_metadata&.save!
        end

        success(artifact: artifact)
      rescue ActiveRecord::RecordNotUnique => error
        track_exception(error, artifact.file_type)
        error('another artifact of the same type already exists', :bad_request)
      rescue *OBJECT_STORAGE_ERRORS => error
        track_exception(error, artifact.file_type)
        error(error.message, :service_unavailable)
      rescue StandardError => error
        track_exception(error, artifact.file_type)
        error(error.message, :bad_request)
      end

      def sha256_matches_existing_artifact?(artifact_type, artifacts_file)
        existing_artifact = job.job_artifacts.find_by_file_type(artifact_type)
        return false unless existing_artifact

        existing_artifact.file_sha256 == artifacts_file.sha256
      end

      def track_exception(error, artifact_type)
        Gitlab::ErrorTracking.track_exception(
          error,
          job_id: job.id,
          project_id: job.project_id,
          uploading_type: artifact_type
        )
      end

      def track_artifact_uploader(_artifact)
        # Overridden in EE
      end

      def parse_dotenv_artifact(artifact)
        Ci::ParseDotenvArtifactService.new(project, current_user).execute(artifact)
      end

      def parse_annotations_artifact(artifact)
        Ci::ParseAnnotationsArtifactService.new(project, current_user).execute(artifact)
      end
    end
  end
end

Ci::JobArtifacts::CreateService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::JobArtifacts::CreateService, :clean_gitlab_redis_shared_state, feature_category: :build_artifacts do
  include WorkhorseHelpers
  include Gitlab::Utils::Gzip

  let_it_be(:project) { create(:project) }

  let(:service) { described_class.new(job) }
  let(:job) { create(:ci_build, project: project) }

  describe '#authorize', :aggregate_failures do
    let(:artifact_type) { 'archive' }
    let(:filesize) { nil }

    subject(:authorize) { service.authorize(artifact_type: artifact_type, filesize: filesize) }

    shared_examples_for 'handling lsif artifact' do
      context 'when artifact is lsif' do
        let(:artifact_type) { 'lsif' }

        it 'includes ProcessLsif in the headers' do
          expect(authorize[:headers][:ProcessLsif]).to eq(true)
        end
      end
    end

    shared_examples_for 'validating requirements' do
      context 'when filesize is specified' do
        let(:max_artifact_size) { 10 }

        before do
          allow(Ci::JobArtifact)
            .to receive(:max_artifact_size)
            .with(type: artifact_type, project: project)
            .and_return(max_artifact_size)
        end

        context 'and filesize exceeds the limit' do
          let(:filesize) { max_artifact_size + 1 }

          it 'returns error' do
            expect(authorize[:status]).to eq(:error)
          end
        end

        context 'and filesize does not exceed the limit' do
          let(:filesize) { max_artifact_size - 1 }

          it 'returns success' do
            expect(authorize[:status]).to eq(:success)
          end
        end
      end
    end

    shared_examples_for 'uploading to temp location' do |store_type|
      # We are not testing the entire headers here because this is fully tested
      # in workhorse_authorize's spec. We just want to confirm that it indeed used the temp path
      # by checking some indicators in the headers returned.
      if store_type == :object_storage
        it 'includes the authorize headers' do
          expect(authorize[:status]).to eq(:success)
          expect(authorize[:headers][:RemoteObject][:StoreURL]).to include(ObjectStorage::TMP_UPLOAD_PATH)
        end
      else
        it 'includes the authorize headers' do
          expect(authorize[:status]).to eq(:success)
          expect(authorize[:headers][:TempPath]).to include(ObjectStorage::TMP_UPLOAD_PATH)
        end
      end

      it_behaves_like 'handling lsif artifact'
      it_behaves_like 'validating requirements'
    end

    context 'when object storage is enabled' do
      context 'and direct upload is enabled' do
        let(:final_store_path) { '12/34/abc-123' }

        before do
          stub_artifacts_object_storage(JobArtifactUploader, direct_upload: true)

          allow(JobArtifactUploader)
            .to receive(:generate_final_store_path)
            .with(root_id: project.id)
            .and_return(final_store_path)
        end

        it 'includes the authorize headers' do
          expect(authorize[:status]).to eq(:success)

          expect(authorize[:headers][:RemoteObject][:ID]).to eq(final_store_path)

          # We are not testing the entire headers here because this is fully tested
          # in workhorse_authorize's spec. We just want to confirm that it indeed used the final path
          # by checking some indicators in the headers returned.
          expect(authorize[:headers][:RemoteObject][:StoreURL])
            .to include(final_store_path)

          # We have to ensure to tell Workhorse to skip deleting the file after upload
          # because we are uploading the file to its final location
          expect(authorize[:headers][:RemoteObject][:SkipDelete]).to eq(true)
        end

        it_behaves_like 'handling lsif artifact'
        it_behaves_like 'validating requirements'
      end

      context 'and direct upload is disabled' do
        before do
          stub_artifacts_object_storage(JobArtifactUploader, direct_upload: false)
        end

        it_behaves_like 'uploading to temp location', :local_storage
      end
    end

    context 'when object storage is disabled' do
      it_behaves_like 'uploading to temp location', :local_storage
    end
  end

  describe '#execute' do
    let(:artifacts_sha256) { '0' * 64 }
    let(:metadata_file) { nil }

    let(:params) do
      {
        'artifact_type' => 'archive',
        'artifact_format' => 'zip'
      }.with_indifferent_access
    end

    subject(:execute) { service.execute(artifacts_file, params, metadata_file: metadata_file) }

    shared_examples_for 'handling accessibility' do
      shared_examples 'public accessibility' do
        it 'sets accessibility to public level' do
          subject

          expect(job.job_artifacts).not_to be_empty
          expect(job.job_artifacts).to all be_public_accessibility
        end
      end

      shared_examples 'private accessibility' do
        it 'sets accessibility to private level' do
          subject

          expect(job.job_artifacts).not_to be_empty
          expect(job.job_artifacts).to all be_private_accessibility
        end
      end

      context 'when non_public_artifacts flag is disabled' do
        before do
          stub_feature_flags(non_public_artifacts: false)
        end

        it_behaves_like 'public accessibility'
      end

      context 'when non_public_artifacts flag is enabled' do
        context 'and accessibility is defined in the params' do
          context 'and is passed as private' do
            before do
              params.merge!('accessibility' => 'private')
            end

            it_behaves_like 'private accessibility'
          end

          context 'and is passed as public' do
            before do
              params.merge!('accessibility' => 'public')
            end

            it_behaves_like 'public accessibility'
          end
        end

        context 'and accessibility is not defined in the params' do
          context 'and job has no public artifacts defined in its CI config' do
            it_behaves_like 'public accessibility'
          end

          context 'and job artifacts defined as private in the CI config' do
            let(:job) { create(:ci_build, :with_private_artifacts_config, project: project) }

            it_behaves_like 'private accessibility'
          end

          context 'and job artifacts defined as public in the CI config' do
            let(:job) { create(:ci_build, :with_public_artifacts_config, project: project) }

            it_behaves_like 'public accessibility'
          end
        end
      end

      context 'when accessibility passed as invalid value' do
        before do
          params.merge!('accessibility' => 'foo')
        end

        it 'fails with argument error' do
          expect { execute }.to raise_error(ArgumentError, ""'foo' is not a valid accessibility"")
        end
      end
    end

    shared_examples_for 'handling metadata file' do
      context 'when metadata file is also uploaded' do
        let(:metadata_file) do
          file_to_upload('spec/fixtures/ci_build_artifacts_metadata.gz', sha256: artifacts_sha256)
        end

        before do
          stub_application_setting(default_artifacts_expire_in: '1 day')
        end

        it 'creates a new metadata job artifact' do
          expect { execute }.to change { Ci::JobArtifact.where(file_type: :metadata).count }.by(1)

          new_artifact = job.job_artifacts.last
          expect(new_artifact.project).to eq(job.project)
          expect(new_artifact.file).to be_present
          expect(new_artifact.file_type).to eq('metadata')
          expect(new_artifact.file_format).to eq('gzip')
          expect(new_artifact.file_sha256).to eq(artifacts_sha256)
          expect(new_artifact.locked).to eq(job.pipeline.locked)
        end

        it 'logs the created artifact and metadata' do
          expect(Gitlab::Ci::Artifacts::Logger)
            .to receive(:log_created)
            .with(an_instance_of(Ci::JobArtifact)).twice

          subject
        end

        it_behaves_like 'handling accessibility'

        it 'sets expiration date according to application settings' do
          expected_expire_at = 1.day.from_now

          expect(execute).to match(a_hash_including(status: :success, artifact: anything))
          archive_artifact, metadata_artifact = job.job_artifacts.last(2)

          expect(job.artifacts_expire_at).to be_within(1.minute).of(expected_expire_at)
          expect(archive_artifact.expire_at).to be_within(1.minute).of(expected_expire_at)
          expect(metadata_artifact.expire_at).to be_within(1.minute).of(expected_expire_at)
        end

        context 'when expire_in params is set to a specific value' do
          before do
            params.merge!('expire_in' => '2 hours')
          end

          it 'sets expiration date according to the parameter' do
            expected_expire_at = 2.hours.from_now

            expect(execute).to match(a_hash_including(status: :success, artifact: anything))
            archive_artifact, metadata_artifact = job.job_artifacts.last(2)

            expect(job.artifacts_expire_at).to be_within(1.minute).of(expected_expire_at)
            expect(archive_artifact.expire_at).to be_within(1.minute).of(expected_expire_at)
            expect(metadata_artifact.expire_at).to be_within(1.minute).of(expected_expire_at)
          end
        end

        context 'when expire_in params is set to `never`' do
          before do
            params.merge!('expire_in' => 'never')
          end

          it 'sets expiration date according to the parameter' do
            expected_expire_at = nil

            expect(execute).to be_truthy
            archive_artifact, metadata_artifact = job.job_artifacts.last(2)

            expect(job.artifacts_expire_at).to eq(expected_expire_at)
            expect(archive_artifact.expire_at).to eq(expected_expire_at)
            expect(metadata_artifact.expire_at).to eq(expected_expire_at)
          end
        end
      end
    end

    shared_examples_for 'handling dotenv' do |storage_type|
      context 'when artifact type is dotenv' do
        let(:params) do
          {
            'artifact_type' => 'dotenv',
            'artifact_format' => 'gzip'
          }.with_indifferent_access
        end

        if storage_type == :object_storage
          let(:object_body) { File.read('spec/fixtures/build.env.gz') }
          let(:upload_filename) { 'build.env.gz' }

          before do
            stub_request(:get, %r{s3.amazonaws.com/#{remote_path}})
              .to_return(status: 200, body: File.read('spec/fixtures/build.env.gz'))
          end
        else
          let(:artifacts_file) do
            file_to_upload('spec/fixtures/build.env.gz', sha256: artifacts_sha256)
          end
        end

        it 'calls parse service' do
          expect_any_instance_of(Ci::ParseDotenvArtifactService) do |service|
            expect(service).to receive(:execute).once.and_call_original
          end

          expect(execute[:status]).to eq(:success)
          expect(job.job_variables.as_json(only: [:key, :value, :source])).to contain_exactly(
            hash_including('key' => 'KEY1', 'value' => 'VAR1', 'source' => 'dotenv'),
            hash_including('key' => 'KEY2', 'value' => 'VAR2', 'source' => 'dotenv'))
        end
      end
    end

    shared_examples_for 'handling annotations' do |storage_type|
      context 'when artifact type is annotations' do
        let(:params) do
          {
            'artifact_type' => 'annotations',
            'artifact_format' => 'gzip'
          }.with_indifferent_access
        end

        if storage_type == :object_storage
          let(:object_body) { File.read('spec/fixtures/gl-annotations.json.gz') }
          let(:upload_filename) { 'gl-annotations.json.gz' }

          before do
            stub_request(:get, %r{s3.amazonaws.com/#{remote_path}})
              .to_return(status: 200, body: File.read('spec/fixtures/gl-annotations.json.gz'))
          end
        else
          let(:artifacts_file) do
            file_to_upload('spec/fixtures/gl-annotations.json.gz', sha256: artifacts_sha256)
          end
        end

        it 'calls parse service' do
          expect_any_instance_of(Ci::ParseAnnotationsArtifactService) do |service|
            expect(service).to receive(:execute).once.and_call_original
          end

          expect(execute[:status]).to eq(:success)
          expect(job.job_annotations.as_json).to contain_exactly(
            hash_including('name' => 'external_links', 'data' => [
              hash_including('external_link' => hash_including('label' => 'URL 1', 'url' => 'https://url1.example.com/')),
              hash_including('external_link' => hash_including('label' => 'URL 2', 'url' => 'https://url2.example.com/'))
            ])
          )
        end
      end
    end

    shared_examples_for 'handling object storage errors' do
      shared_examples 'rescues object storage error' do |klass, message, expected_message|
        it ""handles #{klass}"" do
          allow_next_instance_of(JobArtifactUploader) do |uploader|
            allow(uploader).to receive(:store!).and_raise(klass, message)
          end

          expect(Gitlab::ErrorTracking)
            .to receive(:track_exception)
            .and_call_original

          expect(execute).to match(
            a_hash_including(
              http_status: :service_unavailable,
              message: expected_message || message,
              status: :error))
        end
      end

      it_behaves_like 'rescues object storage error',
        Errno::EIO, 'some/path', 'Input/output error - some/path'

      it_behaves_like 'rescues object storage error',
        Google::Apis::ServerError, 'Server error'

      it_behaves_like 'rescues object storage error',
        Signet::RemoteServerError, 'The service is currently unavailable'
    end

    shared_examples_for 'validating requirements' do
      context 'when filesize is specified' do
        let(:max_artifact_size) { 10 }

        before do
          allow(Ci::JobArtifact)
            .to receive(:max_artifact_size)
            .with(type: 'archive', project: project)
            .and_return(max_artifact_size)

          allow(artifacts_file).to receive(:size).and_return(filesize)
        end

        context 'and filesize exceeds the limit' do
          let(:filesize) { max_artifact_size + 1 }

          it 'returns error' do
            expect(execute[:status]).to eq(:error)
          end
        end

        context 'and filesize does not exceed the limit' do
          let(:filesize) { max_artifact_size - 1 }

          it 'returns success' do
            expect(execute[:status]).to eq(:success)
          end
        end
      end
    end

    shared_examples_for 'handling existing artifact' do
      context 'when job already has an artifact of the same file type' do
        let!(:existing_artifact) do
          create(:ci_job_artifact, params[:artifact_type], file_sha256: existing_sha256, job: job)
        end

        context 'when sha256 of uploading artifact is the same of the existing one' do
          let(:existing_sha256) { artifacts_sha256 }

          it 'ignores the changes' do
            expect { execute }.not_to change { Ci::JobArtifact.count }
            expect(execute).to match(a_hash_including(status: :success))
          end
        end

        context 'when sha256 of uploading artifact is different than the existing one' do
          let(:existing_sha256) { '1' * 64 }

          it 'returns error status' do
            expect(Gitlab::ErrorTracking).to receive(:track_exception).and_call_original

            expect { execute }.not_to change { Ci::JobArtifact.count }
            expect(execute).to match(
              a_hash_including(
                http_status: :bad_request,
                message: 'another artifact of the same type already exists',
                status: :error
              )
            )
          end
        end
      end
    end

    shared_examples_for 'logging artifact' do
      it 'logs the created artifact' do
        expect(Gitlab::Ci::Artifacts::Logger)
          .to receive(:log_created)
          .with(an_instance_of(Ci::JobArtifact))

        execute
      end
    end

    shared_examples_for 'handling uploads' do
      context 'when artifacts file is uploaded' do
        it 'creates a new job artifact' do
          expect { execute }.to change { Ci::JobArtifact.count }.by(1)

          new_artifact = execute[:artifact]
          expect(new_artifact).to eq(job.job_artifacts.last)
          expect(new_artifact.project).to eq(job.project)
          expect(new_artifact.file.filename).to eq(artifacts_file.original_filename)
          expect(new_artifact.file_identifier).to eq(artifacts_file.original_filename)
          expect(new_artifact.file_type).to eq(params['artifact_type'])
          expect(new_artifact.file_format).to eq(params['artifact_format'])
          expect(new_artifact.file_sha256).to eq(artifacts_sha256)
          expect(new_artifact.locked).to eq(job.pipeline.locked)
          expect(new_artifact.size).to eq(artifacts_file.size)

          expect(execute[:status]).to eq(:success)
        end

        it_behaves_like 'handling accessibility'
        it_behaves_like 'handling metadata file'
        it_behaves_like 'handling partitioning'
        it_behaves_like 'logging artifact'
      end
    end

    shared_examples_for 'handling partitioning' do
      context 'with job partitioned', :ci_partitionable do
        let(:pipeline) { create(:ci_pipeline, project: project, partition_id: ci_testing_partition_id) }
        let(:job) { create(:ci_build, pipeline: pipeline) }

        it 'sets partition_id on artifacts' do
          expect { execute }.to change { Ci::JobArtifact.count }

          artifacts_partitions = job.job_artifacts.map(&:partition_id).uniq

          expect(artifacts_partitions).to eq([ci_testing_partition_id])
        end
      end
    end

    context 'when object storage and direct upload is enabled' do
      let(:fog_connection) { stub_artifacts_object_storage(JobArtifactUploader, direct_upload: true) }
      let(:remote_path) { File.join(remote_store_path, remote_id) }
      let(:object_body) { File.open('spec/fixtures/ci_build_artifacts.zip') }
      let(:upload_filename) { 'artifacts.zip' }
      let(:object) do
        fog_connection.directories
          .new(key: 'artifacts')
          .files
          .create( # rubocop:disable Rails/SaveBang
            key: remote_path,
            body: object_body
          )
      end

      let(:artifacts_file) do
        fog_to_uploaded_file(
          object,
          filename: upload_filename,
          sha256: artifacts_sha256,
          remote_id: remote_id
        )
      end

      let(:remote_id) { 'generated-remote-id-12345' }
      let(:remote_store_path) { ObjectStorage::TMP_UPLOAD_PATH }

      it_behaves_like 'handling uploads'
      it_behaves_like 'handling dotenv', :object_storage
      it_behaves_like 'handling annotations', :object_storage
      it_behaves_like 'handling object storage errors'
      it_behaves_like 'validating requirements'
    end

    context 'when using local storage' do
      let(:artifacts_file) do
        file_to_upload('spec/fixtures/ci_build_artifacts.zip', sha256: artifacts_sha256)
      end

      it_behaves_like 'handling uploads'
      it_behaves_like 'handling dotenv', :local_storage
      it_behaves_like 'handling annotations', :local_storage
      it_behaves_like 'validating requirements'
    end
  end

  def file_to_upload(path, params = {})
    upload = Tempfile.new('upload')
    FileUtils.copy(path, upload.path)
    # This is a workaround for https://github.com/docker/for-linux/issues/1015
    FileUtils.touch(upload.path)

    UploadedFile.new(upload.path, **params)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module JobArtifacts
    class DeleteService
      include BaseServiceUtility

      def initialize(build)
        @build = build
      end

      def execute
        if build.project.refreshing_build_artifacts_size?
          Gitlab::ProjectStatsRefreshConflictsLogger.warn_artifact_deletion_during_stats_refresh(
            method: 'Ci::JobArtifacts::DeleteService#execute',
            project_id: build.project_id
          )
          return ServiceResponse.error(
            message: 'Action temporarily disabled. The project this job belongs to is undergoing stats refresh.',
            reason: :project_stats_refresh
          )
        end

        result = Ci::JobArtifacts::DestroyBatchService.new(build.job_artifacts.erasable).execute

        if result.fetch(:status) == :success
          ServiceResponse.success(payload:
          {
            destroyed_artifacts_count: result.fetch(:destroyed_artifacts_count)
          })
        else
          ServiceResponse.error(message: result.fetch(:message))
        end
      end

      private

      attr_reader :build
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::JobArtifacts::DeleteService, feature_category: :build_artifacts do
  let_it_be(:build, reload: true) do
    create(:ci_build, :artifacts, :trace_artifact, artifacts_expire_at: 100.days.from_now)
  end

  subject(:service) { described_class.new(build) }

  describe '#execute' do
    it 'is successful' do
      result = service.execute

      expect(result).to be_success
      expect(result[:destroyed_artifacts_count]).to be(2)
    end

    it 'deletes erasable artifacts' do
      expect { service.execute }.to change { build.job_artifacts.erasable.count }.from(2).to(0)
    end

    it 'does not delete trace' do
      expect { service.execute }.not_to change { build.has_trace? }.from(true)
    end

    context 'when project is undergoing stats refresh' do
      before do
        allow(build.project).to receive(:refreshing_build_artifacts_size?).and_return(true)
      end

      it 'logs a warning' do
        expect(Gitlab::ProjectStatsRefreshConflictsLogger)
          .to receive(:warn_artifact_deletion_during_stats_refresh)
                .with(method: 'Ci::JobArtifacts::DeleteService#execute', project_id: build.project_id)

        service.execute
      end

      it 'returns an error response with the correct message and reason' do
        result = service.execute

        expect(result).to be_error
        expect(result[:message]).to be('Action temporarily disabled. ' \
          'The project this job belongs to is undergoing stats refresh.')
        expect(result[:reason]).to be(:project_stats_refresh)
      end
    end

    context 'when an error response is received from DestroyBatchService' do
      before do
        allow_next_instance_of(Ci::JobArtifacts::DestroyBatchService) do |service|
          allow(service).to receive(:execute).and_return({ status: :error, message: 'something went wrong' })
        end
      end

      it 'returns an error response with the correct message' do
        result = service.execute

        expect(result).to be_error
        expect(result[:message]).to be('something went wrong')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module JobArtifacts
    class ExpireProjectBuildArtifactsService
      BATCH_SIZE = 1000

      def initialize(project_id, expiry_time)
        @project_id = project_id
        @expiry_time = expiry_time
      end

      # rubocop:disable CodeReuse/ActiveRecord
      def execute
        scope = Ci::JobArtifact.for_project(project_id).order(:id)
        file_type_values = Ci::JobArtifact.erasable_file_types.map { |file_type| [Ci::JobArtifact.file_types[file_type]] }
        from_sql = Arel::Nodes::Grouping.new(Arel::Nodes::ValuesList.new(file_type_values)).as('file_types (file_type)').to_sql
        array_scope = Ci::JobArtifact.from(from_sql).select(:file_type)
        array_mapping_scope = -> (file_type_expression) { Ci::JobArtifact.where(Ci::JobArtifact.arel_table[:file_type].eq(file_type_expression)) }

        Gitlab::Pagination::Keyset::Iterator
          .new(scope: scope, in_operator_optimization_options: { array_scope: array_scope, array_mapping_scope: array_mapping_scope })
          .each_batch(of: BATCH_SIZE) do |batch|
          ids = batch.reselect!(:id).to_a.map(&:id)
          Ci::JobArtifact.unlocked.where(id: ids).update_all(locked: Ci::JobArtifact.lockeds[:unlocked], expire_at: expiry_time)
        end
      end
      # rubocop:enable CodeReuse/ActiveRecord

      private

      attr_reader :project_id, :expiry_time
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::JobArtifacts::ExpireProjectBuildArtifactsService, feature_category: :build_artifacts do
  let_it_be(:project) { create(:project) }
  let_it_be(:pipeline, reload: true) { create(:ci_pipeline, :unlocked, project: project) }

  let(:expiry_time) { Time.current }

  RSpec::Matchers.define :have_locked_status do |expected_status|
    match do |job_artifacts|
      predicate = ""#{expected_status}?"".to_sym
      job_artifacts.all? { |artifact| artifact.__send__(predicate) }
    end
  end

  RSpec::Matchers.define :expire_at do |expected_expiry|
    match do |job_artifacts|
      job_artifacts.all? { |artifact| artifact.expire_at.to_i == expected_expiry.to_i }
    end
  end

  RSpec::Matchers.define :have_no_expiry do
    match do |job_artifacts|
      job_artifacts.all? { |artifact| artifact.expire_at.nil? }
    end
  end

  describe '#execute' do
    subject(:execute) { described_class.new(project.id, expiry_time).execute }

    context 'with job containing erasable artifacts' do
      let_it_be(:job, reload: true) { create(:ci_build, :erasable, pipeline: pipeline) }

      it 'unlocks erasable job artifacts' do
        execute

        expect(job.job_artifacts).to have_locked_status(:artifact_unlocked)
      end

      it 'expires erasable job artifacts' do
        execute

        expect(job.job_artifacts).to expire_at(expiry_time)
      end
    end

    context 'with job containing trace artifacts' do
      let_it_be(:job, reload: true) { create(:ci_build, :trace_artifact, pipeline: pipeline) }

      it 'does not unlock trace artifacts' do
        execute

        expect(job.job_artifacts).to have_locked_status(:artifact_unknown)
      end

      it 'does not expire trace artifacts' do
        execute

        expect(job.job_artifacts).to have_no_expiry
      end
    end

    context 'with job from artifact locked pipeline' do
      let_it_be(:job, reload: true) { create(:ci_build, pipeline: pipeline) }
      let_it_be(:locked_artifact, reload: true) { create(:ci_job_artifact, :locked, job: job) }

      before do
        pipeline.artifacts_locked!
      end

      it 'does not unlock locked artifacts' do
        execute

        expect(job.job_artifacts).to have_locked_status(:artifact_artifacts_locked)
      end

      it 'does not expire locked artifacts' do
        execute

        expect(job.job_artifacts).to have_no_expiry
      end
    end

    context 'with job containing both erasable and trace artifacts' do
      let_it_be(:job, reload: true) { create(:ci_build, pipeline: pipeline) }
      let_it_be(:erasable_artifact, reload: true) { create(:ci_job_artifact, :archive, job: job) }
      let_it_be(:trace_artifact, reload: true) { create(:ci_job_artifact, :trace, job: job) }

      it 'unlocks erasable artifacts' do
        execute

        expect(erasable_artifact.artifact_unlocked?).to be_truthy
      end

      it 'expires erasable artifacts' do
        execute

        expect(erasable_artifact.expire_at.to_i).to eq(expiry_time.to_i)
      end

      it 'does not unlock trace artifacts' do
        execute

        expect(trace_artifact.artifact_unlocked?).to be_falsey
      end

      it 'does not expire trace artifacts' do
        execute

        expect(trace_artifact.expire_at).to be_nil
      end
    end

    context 'with multiple pipelines' do
      let_it_be(:job, reload: true) { create(:ci_build, :erasable, pipeline: pipeline) }

      let_it_be(:pipeline2, reload: true) { create(:ci_pipeline, :unlocked, project: project) }
      let_it_be(:job2, reload: true) { create(:ci_build, :erasable, pipeline: pipeline) }

      it 'unlocks artifacts across pipelines' do
        execute

        expect(job.job_artifacts).to have_locked_status(:artifact_unlocked)
        expect(job2.job_artifacts).to have_locked_status(:artifact_unlocked)
      end

      it 'expires artifacts across pipelines' do
        execute

        expect(job.job_artifacts).to expire_at(expiry_time)
        expect(job2.job_artifacts).to expire_at(expiry_time)
      end
    end

    context 'with artifacts belonging to another project' do
      let_it_be(:job, reload: true) { create(:ci_build, :erasable, pipeline: pipeline) }

      let_it_be(:another_project, reload: true) { create(:project) }
      let_it_be(:another_pipeline, reload: true) { create(:ci_pipeline, project: another_project) }
      let_it_be(:another_job, reload: true) { create(:ci_build, :erasable, pipeline: another_pipeline) }

      it 'does not unlock erasable artifacts in other projects' do
        execute

        expect(another_job.job_artifacts).to have_locked_status(:artifact_unknown)
      end

      it 'does not expire erasable artifacts in other projects' do
        execute

        expect(another_job.job_artifacts).to have_no_expiry
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module PipelineSchedules
    class CalculateNextRunService < BaseService
      include Gitlab::Utils::StrongMemoize

      def execute(schedule, fallback_method:)
        @schedule = schedule

        return fallback_method.call unless plan_cron&.cron_valid?

        now = Time.zone.now
        plan_min_run = plan_cron.next_time_from(now)

        schedule_next_run = schedule_cron.next_time_from(now)
        return schedule_next_run if worker_cron.match?(schedule_next_run) && plan_min_run <= schedule_next_run

        plan_next_run = plan_cron.next_time_from(schedule_next_run)
        return plan_next_run if worker_cron.match?(plan_next_run)

        worker_next_run = worker_cron.next_time_from(schedule_next_run)
        return worker_next_run if plan_min_run <= worker_next_run

        worker_cron.next_time_from(plan_next_run)
      end

      private

      def schedule_cron
        strong_memoize(:schedule_cron) do
          Gitlab::Ci::CronParser.new(@schedule.cron, @schedule.cron_timezone)
        end
      end

      def worker_cron
        strong_memoize(:worker_cron) do
          Gitlab::Ci::CronParser.new(@schedule.worker_cron_expression, Time.zone.name)
        end
      end

      def plan_cron
        strong_memoize(:plan_cron) do
          daily_limit = @schedule.daily_limit

          next unless daily_limit

          every_x_minutes = (1.day.in_minutes / daily_limit).to_i

          Gitlab::Ci::CronParser.parse_natural(""every #{every_x_minutes} minutes"", Time.zone.name)
        end
      end
    end
  end
end

```","# frozen_string_literal: true
# rubocop:disable Layout/LineLength
require 'spec_helper'

RSpec.describe Ci::PipelineSchedules::CalculateNextRunService, feature_category: :continuous_integration do
  let_it_be(:project) { create(:project, :public, :repository) }

  describe '#execute' do
    using RSpec::Parameterized::TableSyntax

    let(:run_service) do
      described_class.new(project).execute(pipeline_schedule,
        fallback_method: pipeline_schedule.method(:calculate_next_run_at))
    end

    let(:pipeline_schedule) { create(:ci_pipeline_schedule, cron: schedule_cron) }
    let(:daily_limit_of_144_runs) { 1.day / 10.minutes }
    let(:daily_limit_of_24_runs) { 1.day / 1.hour }

    before do
      allow(Settings).to receive(:cron_jobs) { { 'pipeline_schedule_worker' => { 'cron' => worker_cron } } }
      create(:plan_limits, :default_plan, ci_daily_pipeline_schedule_triggers: plan_limit) if plan_limit
    end

    context ""when there is invalid or no plan limits"" do
      where(:worker_cron, :schedule_cron, :plan_limit, :now, :expected_result) do
        '0 1 2 3 *'   | '0 1 * * *'   | nil             | Time.zone.local(2021, 3, 2, 1, 0)   | Time.zone.local(2022, 3, 2, 1, 0)
        '*/5 * * * *' | '*/1 * * * *' | nil             | Time.zone.local(2021, 5, 27, 11, 0) | Time.zone.local(2021, 5, 27, 11, 5)
        '*/5 * * * *' | '0 * * * *'   | nil             | Time.zone.local(2021, 5, 27, 11, 0) | Time.zone.local(2021, 5, 27, 12, 5)
        # 1.day / 2.hours => 12 times a day and it is invalid because there is a minimum for plan limits.
        # See: https://docs.gitlab.com/ee/administration/instance_limits.html#limit-the-number-of-pipelines-created-by-a-pipeline-schedule-per-day
        '*/5 * * * *' | '0 * * * *'   | 1.day / 2.hours | Time.zone.local(2021, 5, 27, 11, 0) | Time.zone.local(2021, 5, 27, 12, 5)
      end

      with_them do
        it 'calls fallback method to get next_run_at' do
          travel_to(now) do
            expect(pipeline_schedule).to receive(:calculate_next_run_at).and_call_original

            result = run_service

            expect(result).to eq(expected_result)
          end
        end
      end
    end

    context ""when the workers next run matches schedule's earliest run"" do
      where(:worker_cron, :schedule_cron, :plan_limit, :now, :expected_result) do
        '*/5 * * * *' | '0 * * * *'   | daily_limit_of_144_runs  | Time.zone.local(2021, 5, 27, 11, 0)  | Time.zone.local(2021, 5, 27, 12, 0)
        '*/5 * * * *' | '*/5 * * * *' | daily_limit_of_144_runs  | Time.zone.local(2021, 5, 27, 11, 0)  | Time.zone.local(2021, 5, 27, 11, 10)
        '*/5 * * * *' | '0 1 * * *'   | daily_limit_of_144_runs  | Time.zone.local(2021, 5, 27, 1, 0)   | Time.zone.local(2021, 5, 28, 1, 0)
        '*/5 * * * *' | '0 2 * * *'   | daily_limit_of_144_runs  | Time.zone.local(2021, 5, 27, 1, 0)   | Time.zone.local(2021, 5, 27, 2, 0)
        '*/5 * * * *' | '0 3 * * *'   | daily_limit_of_144_runs  | Time.zone.local(2021, 5, 27, 1, 0)   | Time.zone.local(2021, 5, 27, 3, 0)
        '*/5 * * * *' | '0 1 1 * *'   | daily_limit_of_144_runs  | Time.zone.local(2021, 5, 1, 1, 0)    | Time.zone.local(2021, 6, 1, 1, 0)
        '*/9 * * * *' | '0 1 1 * *'   | daily_limit_of_144_runs  | Time.zone.local(2021, 5, 1, 1, 9)    | Time.zone.local(2021, 6, 1, 1, 0)
        '*/5 * * * *' | '45 21 1 2 *' | daily_limit_of_144_runs  | Time.zone.local(2021, 2, 1, 21, 45)  | Time.zone.local(2022, 2, 1, 21, 45)
      end

      with_them do
        it 'calculates the next_run_at to be earliest point of match' do
          travel_to(now) do
            result = run_service

            expect(result).to eq(expected_result)
          end
        end
      end
    end

    context ""when next_run_at is restricted by plan limit"" do
      where(:worker_cron, :schedule_cron, :plan_limit, :now, :expected_result) do
        '*/5 * * * *' | '59 14 * * *' | daily_limit_of_24_runs   | Time.zone.local(2021, 5, 1, 15, 0)  | Time.zone.local(2021, 5, 2, 15, 0)
        '*/5 * * * *' | '*/1 * * * *' | daily_limit_of_24_runs   | Time.zone.local(2021, 5, 27, 11, 0) | Time.zone.local(2021, 5, 27, 12, 0)
        '*/5 * * * *' | '*/1 * * * *' | daily_limit_of_144_runs  | Time.zone.local(2021, 5, 27, 11, 0) | Time.zone.local(2021, 5, 27, 11, 10)
        '*/5 * * * *' | '*/1 * * * *' | (1.day / 7.minutes).to_i | Time.zone.local(2021, 5, 27, 11, 0) | Time.zone.local(2021, 5, 27, 11, 10)
      end

      with_them do
        it 'calculates the next_run_at based on next available limit' do
          travel_to(now) do
            result = run_service

            expect(result).to eq(expected_result)
          end
        end
      end
    end

    context ""when next_run_at is restricted by worker's availability"" do
      where(:worker_cron, :schedule_cron, :plan_limit, :now, :expected_result) do
        '0 1 2 3 *' | '0 1 * * *' | daily_limit_of_144_runs | Time.zone.local(2021, 3, 2, 1, 0) | Time.zone.local(2022, 3, 2, 1, 0)
      end

      with_them do
        it 'calculates the next_run_at using worker_cron' do
          travel_to(now) do
            result = run_service

            expect(result).to eq(expected_result)
          end
        end
      end
    end
  end
end
# rubocop:enable Layout/LineLength
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module PipelineSchedules
    class TakeOwnershipService
      def initialize(schedule, user)
        @schedule = schedule
        @user = user
      end

      def execute
        return forbidden unless allowed?

        if schedule.update(owner: user)
          ServiceResponse.success(payload: schedule)
        else
          ServiceResponse.error(message: schedule.errors.full_messages)
        end
      end

      private

      attr_reader :schedule, :user

      def allowed?
        user.can?(:admin_pipeline_schedule, schedule)
      end

      def forbidden
        ServiceResponse.error(message: _('Failed to change the owner'), reason: :access_denied)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::PipelineSchedules::TakeOwnershipService, feature_category: :continuous_integration do
  let_it_be(:user) { create(:user) }
  let_it_be(:owner) { create(:user) }
  let_it_be(:reporter) { create(:user) }
  let_it_be(:project) { create(:project, :public, :repository) }
  let_it_be(:pipeline_schedule) { create(:ci_pipeline_schedule, project: project, owner: owner) }

  before_all do
    project.add_maintainer(user)
    project.add_maintainer(owner)
    project.add_reporter(reporter)
  end

  describe '#execute' do
    context 'when user does not have permission' do
      subject(:service) { described_class.new(pipeline_schedule, reporter) }

      it 'returns ServiceResponse.error' do
        result = service.execute

        expect(result).to be_a(ServiceResponse)
        expect(result.error?).to be(true)
        expect(result.message).to eq(_('Failed to change the owner'))
      end
    end

    context 'when user has permission' do
      subject(:service) { described_class.new(pipeline_schedule, user) }

      it 'returns ServiceResponse.success' do
        result = service.execute

        expect(result).to be_a(ServiceResponse)
        expect(result.success?).to be(true)
        expect(result.payload).to eq(pipeline_schedule)
      end

      context 'when schedule update fails' do
        subject(:service) { described_class.new(pipeline_schedule, owner) }

        before do
          allow(pipeline_schedule).to receive(:update).and_return(false)

          errors = ActiveModel::Errors.new(pipeline_schedule)
          errors.add(:base, 'An error occurred')
          allow(pipeline_schedule).to receive(:errors).and_return(errors)
        end

        it 'returns ServiceResponse.error' do
          result = service.execute

          expect(result).to be_a(ServiceResponse)
          expect(result.error?).to be(true)
          expect(result.message).to eq(['An error occurred'])
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module PipelineSchedules
    class UpdateService < BaseSaveService
      AUTHORIZE = :update_pipeline_schedule

      def initialize(schedule, user, params)
        @schedule = schedule
        @user = user
        @project = schedule.project
        @params = params
      end

      def execute
        return forbidden_to_save unless allowed_to_save?

        super
      end

      private

      def authorize_message
        _('The current user is not authorized to update the pipeline schedule')
      end
      strong_memoize_attr :authorize_message
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::PipelineSchedules::UpdateService, feature_category: :continuous_integration do
  let_it_be_with_reload(:user) { create(:user) }
  let_it_be_with_reload(:project) { create(:project, :public, :repository) }
  let_it_be_with_reload(:pipeline_schedule) { create(:ci_pipeline_schedule, project: project, owner: user) }
  let_it_be(:reporter) { create(:user) }
  let_it_be(:project_owner) { create(:user) }

  let_it_be(:pipeline_schedule_variable) do
    create(:ci_pipeline_schedule_variable,
      key: 'foo', value: 'foovalue', pipeline_schedule: pipeline_schedule)
  end

  before_all do
    project.add_maintainer(user)
    project.add_owner(project_owner)
    project.add_reporter(reporter)

    pipeline_schedule.reload
  end

  describe ""execute"" do
    context 'when user does not have permission' do
      subject(:service) { described_class.new(pipeline_schedule, reporter, {}) }

      it 'returns ServiceResponse.error' do
        result = service.execute

        expect(result).to be_a(ServiceResponse)
        expect(result.error?).to be(true)

        error_message = _('The current user is not authorized to update the pipeline schedule')
        expect(result.message).to match_array([error_message])
        expect(pipeline_schedule.errors).to match_array([error_message])
      end
    end

    context 'when user has permission' do
      let(:params) do
        {
          description: 'updated_desc',
          ref: 'patch-x',
          active: false,
          cron: '*/1 * * * *',
          variables_attributes: [
            { id: pipeline_schedule_variable.id, key: 'bar', secret_value: 'barvalue' }
          ]
        }
      end

      subject(:service) { described_class.new(pipeline_schedule, user, params) }

      it 'updates database values with passed params' do
        expect do
          service.execute
          pipeline_schedule.reload
        end.to change { pipeline_schedule.description }.from('pipeline schedule').to('updated_desc')
          .and change { pipeline_schedule.ref }.from('master').to('patch-x')
          .and change { pipeline_schedule.active }.from(true).to(false)
          .and change { pipeline_schedule.cron }.from('0 1 * * *').to('*/1 * * * *')
          .and change { pipeline_schedule.variables.last.key }.from('foo').to('bar')
          .and change { pipeline_schedule.variables.last.value }.from('foovalue').to('barvalue')
      end

      context 'when the new branch is protected', :request_store do
        let(:maintainer_access) { :no_one_can_merge }

        before do
          create(:protected_branch, :no_one_can_push, maintainer_access, name: 'patch-x', project: project)
        end

        after do
          ProtectedBranches::CacheService.new(project).refresh
        end

        context 'when called by someone other than the schedule owner who can update the ref' do
          let(:maintainer_access) { :maintainers_can_merge }

          subject(:service) { described_class.new(pipeline_schedule, project_owner, params) }

          it 'does not update the schedule' do
            expect do
              service.execute
              pipeline_schedule.reload
            end.not_to change { pipeline_schedule.description }
          end
        end

        context 'when called by the schedule owner' do
          it 'does not update the schedule' do
            expect do
              service.execute
              pipeline_schedule.reload
            end.not_to change { pipeline_schedule.description }
          end

          context 'when the owner can update the ref' do
            let(:maintainer_access) { :maintainers_can_merge }

            it 'updates the schedule' do
              expect { service.execute }.to change { pipeline_schedule.description }
            end
          end
        end
      end

      context 'when creating a variable' do
        let(:params) do
          {
            variables_attributes: [
              { key: 'ABC', secret_value: 'ABC123' }
            ]
          }
        end

        it 'creates the new variable' do
          expect { service.execute }.to change { Ci::PipelineScheduleVariable.count }.by(1)

          expect(pipeline_schedule.variables.last.key).to eq('ABC')
          expect(pipeline_schedule.variables.last.value).to eq('ABC123')
        end
      end

      context 'when deleting a variable' do
        let(:params) do
          {
            variables_attributes: [
              {
                id: pipeline_schedule_variable.id,
                _destroy: true
              }
            ]
          }
        end

        it 'deletes the existing variable' do
          expect { service.execute }.to change { Ci::PipelineScheduleVariable.count }.by(-1)
        end
      end

      it 'returns ServiceResponse.success' do
        result = service.execute

        expect(result).to be_a(ServiceResponse)
        expect(result.success?).to be(true)
        expect(result.payload.description).to eq('updated_desc')
      end

      context 'when schedule update fails' do
        subject(:service) { described_class.new(pipeline_schedule, user, {}) }

        before do
          allow(pipeline_schedule).to receive(:save).and_return(false)

          errors = ActiveModel::Errors.new(pipeline_schedule)
          errors.add(:base, 'An error occurred')
          allow(pipeline_schedule).to receive(:errors).and_return(errors)
        end

        it 'returns ServiceResponse.error' do
          result = service.execute

          expect(result).to be_a(ServiceResponse)
          expect(result.error?).to be(true)
          expect(result.message).to match_array(['An error occurred'])
        end
      end
    end

    it_behaves_like 'pipeline schedules checking variables permission' do
      subject(:service) { described_class.new(pipeline_schedule, user, params) }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module PipelineSchedules
    class CreateService < BaseSaveService
      AUTHORIZE = :create_pipeline_schedule

      def initialize(project, user, params)
        @schedule = project.pipeline_schedules.new
        @user = user
        @project = project
        @params = params.merge(owner: user)
      end

      private

      def authorize_message
        _('The current user is not authorized to create the pipeline schedule')
      end
      strong_memoize_attr :authorize_message
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::PipelineSchedules::CreateService, feature_category: :continuous_integration do
  let_it_be(:reporter) { create(:user) }
  let_it_be_with_reload(:user) { create(:user) }
  let_it_be_with_reload(:project) { create(:project, :public, :repository) }

  subject(:service) { described_class.new(project, user, params) }

  before_all do
    project.add_maintainer(user)
    project.add_reporter(reporter)
  end

  describe ""execute"" do
    context 'when user does not have permission' do
      subject(:service) { described_class.new(project, reporter, {}) }

      it 'returns ServiceResponse.error' do
        result = service.execute

        expect(result).to be_a(ServiceResponse)
        expect(result.error?).to be(true)

        error_message = _('The current user is not authorized to create the pipeline schedule')
        expect(result.message).to match_array([error_message])
        expect(result.payload.errors).to match_array([error_message])
      end
    end

    context 'when user has permission' do
      let(:params) do
        {
          description: 'desc',
          ref: 'patch-x',
          active: false,
          cron: '*/1 * * * *',
          cron_timezone: 'UTC'
        }
      end

      subject(:service) { described_class.new(project, user, params) }

      it 'saves values with passed params' do
        result = service.execute

        expect(result.payload).to have_attributes(
          description: 'desc',
          ref: 'patch-x',
          active: false,
          cron: '*/1 * * * *',
          cron_timezone: 'UTC'
        )
      end

      it 'returns ServiceResponse.success' do
        result = service.execute

        expect(result).to be_a(ServiceResponse)
        expect(result.success?).to be(true)
      end

      context 'when schedule save fails' do
        subject(:service) { described_class.new(project, user, {}) }

        before do
          errors = ActiveModel::Errors.new(project)
          errors.add(:base, 'An error occurred')

          allow_next_instance_of(Ci::PipelineSchedule) do |instance|
            allow(instance).to receive(:save).and_return(false)
            allow(instance).to receive(:errors).and_return(errors)
          end
        end

        it 'returns ServiceResponse.error' do
          result = service.execute

          expect(result).to be_a(ServiceResponse)
          expect(result.error?).to be(true)
          expect(result.message).to match_array(['An error occurred'])
        end
      end
    end

    it_behaves_like 'pipeline schedules checking variables permission'
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module PipelineCreation
    class CancelRedundantPipelinesService
      include Gitlab::Utils::StrongMemoize

      BATCH_SIZE = 25
      PAGE_SIZE = 500

      def initialize(pipeline)
        @pipeline = pipeline
        @project = @pipeline.project
      end

      # rubocop: disable CodeReuse/ActiveRecord
      def execute
        return if service_disabled?
        return if pipeline.parent_pipeline? # skip if child pipeline
        return unless project.auto_cancel_pending_pipelines?

        paginator.each do |ids|
          pipelines = parent_and_child_pipelines(ids)

          Gitlab::OptimisticLocking.retry_lock(pipelines, name: 'cancel_pending_pipelines') do |cancelables|
            auto_cancel_interruptible_pipelines(cancelables.ids)
          end
        end
      end

      private

      attr_reader :pipeline, :project

      def paginator
        page = 1
        Enumerator.new do |yielder|
          loop do
            # leverage the index_ci_pipelines_on_project_id_and_status_and_created_at index
            records = project.all_pipelines
              .created_after(pipelines_created_after)
              .order(:status, :created_at)
              .page(page) # use offset pagination because there is no other way to loop over the data
              .per(PAGE_SIZE)
              .pluck(:id)

            raise StopIteration if records.empty?

            yielder << records
            page += 1
          end
        end
      end

      def parent_auto_cancelable_pipelines(ids)
        scope = project.all_pipelines
          .created_after(pipelines_created_after)
          .for_ref(pipeline.ref)
          .where_not_sha(project.commit(pipeline.ref).try(:id))
          .where(""created_at < ?"", pipeline.created_at)
          .for_status(CommitStatus::AVAILABLE_STATUSES) # Force usage of project_id_and_status_and_created_at_index
          .ci_sources

        scope.id_in(ids)
      end

      def parent_and_child_pipelines(ids)
        Ci::Pipeline.object_hierarchy(parent_auto_cancelable_pipelines(ids), project_condition: :same)
          .base_and_descendants
          .alive_or_scheduled
      end
      # rubocop: enable CodeReuse/ActiveRecord

      def auto_cancel_interruptible_pipelines(pipeline_ids)
        ::Ci::Pipeline
          .id_in(pipeline_ids)
          .with_only_interruptible_builds
          .each do |cancelable_pipeline|
            Gitlab::AppLogger.info(
              class: self.class.name,
              message: ""Pipeline #{pipeline.id} auto-canceling pipeline #{cancelable_pipeline.id}"",
              canceled_pipeline_id: cancelable_pipeline.id,
              canceled_by_pipeline_id: pipeline.id,
              canceled_by_pipeline_source: pipeline.source
            )

            # cascade_to_children not needed because we iterate through descendants here
            ::Ci::CancelPipelineService.new(
              pipeline: cancelable_pipeline,
              current_user: nil,
              auto_canceled_by_pipeline: pipeline,
              cascade_to_children: false
            ).force_execute
          end
      end

      def pipelines_created_after
        3.days.ago
      end

      # Finding the pipelines to cancel is an expensive task that is not well
      # covered by indexes for all project use-cases and sometimes it might
      # harm other services. See https://gitlab.com/gitlab-com/gl-infra/production/-/issues/14758
      # This feature flag is in place to disable this feature for rogue projects.
      #
      def service_disabled?
        Feature.enabled?(:disable_cancel_redundant_pipelines_service, project, type: :ops)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::PipelineCreation::CancelRedundantPipelinesService, feature_category: :continuous_integration do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }

  let(:prev_pipeline) { create(:ci_pipeline, project: project) }
  let!(:new_commit) { create(:commit, project: project) }
  let(:pipeline) { create(:ci_pipeline, project: project, sha: new_commit.sha) }

  let(:service) { described_class.new(pipeline) }

  before do
    create(:ci_build, :interruptible, :running, pipeline: prev_pipeline)
    create(:ci_build, :interruptible, :success, pipeline: prev_pipeline)
    create(:ci_build, :created, pipeline: prev_pipeline)

    create(:ci_build, :interruptible, pipeline: pipeline)
  end

  shared_examples 'time limits pipeline cancellation' do
    context 'with old pipelines' do
      let(:old_pipeline) { create(:ci_pipeline, project: project, created_at: 5.days.ago) }

      before do
        create(:ci_build, :interruptible, :pending, pipeline: old_pipeline)
      end

      it 'ignores old pipelines' do
        execute

        expect(build_statuses(prev_pipeline)).to contain_exactly('canceled', 'success', 'canceled')
        expect(build_statuses(pipeline)).to contain_exactly('pending')
        expect(build_statuses(old_pipeline)).to contain_exactly('pending')
      end
    end
  end

  describe '#execute!' do
    subject(:execute) { service.execute }

    context 'when build statuses are set up correctly' do
      it 'has builds of all statuses' do
        expect(build_statuses(prev_pipeline)).to contain_exactly('running', 'success', 'created')
        expect(build_statuses(pipeline)).to contain_exactly('pending')
      end
    end

    context 'when auto-cancel is enabled' do
      before do
        project.update!(auto_cancel_pending_pipelines: 'enabled')
      end

      it 'cancels only previous interruptible builds' do
        execute

        expect(build_statuses(prev_pipeline)).to contain_exactly('canceled', 'success', 'canceled')
        expect(build_statuses(pipeline)).to contain_exactly('pending')
      end

      it 'logs canceled pipelines' do
        allow(Gitlab::AppLogger).to receive(:info)

        execute

        expect(Gitlab::AppLogger).to have_received(:info).with(
          class: described_class.name,
          message: ""Pipeline #{pipeline.id} auto-canceling pipeline #{prev_pipeline.id}"",
          canceled_pipeline_id: prev_pipeline.id,
          canceled_by_pipeline_id: pipeline.id,
          canceled_by_pipeline_source: pipeline.source
        )
      end

      context 'when the previous pipeline has a child pipeline' do
        let(:child_pipeline) { create(:ci_pipeline, child_of: prev_pipeline) }

        context 'with another nested child pipeline' do
          let(:another_child_pipeline) { create(:ci_pipeline, child_of: child_pipeline) }

          before do
            create(:ci_build, :interruptible, :running, pipeline: another_child_pipeline)
            create(:ci_build, :interruptible, :running, pipeline: another_child_pipeline)
          end

          it 'cancels all nested child pipeline builds' do
            expect(build_statuses(another_child_pipeline)).to contain_exactly('running', 'running')

            execute

            expect(build_statuses(another_child_pipeline)).to contain_exactly('canceled', 'canceled')
          end
        end

        context 'when started after pipeline was finished' do
          before do
            create(:ci_build, :interruptible, :running, pipeline: child_pipeline)
            prev_pipeline.update!(status: ""success"")
          end

          it 'cancels child pipeline builds' do
            expect(build_statuses(child_pipeline)).to contain_exactly('running')

            execute

            expect(build_statuses(child_pipeline)).to contain_exactly('canceled')
          end
        end

        context 'when the child pipeline has interruptible running jobs' do
          before do
            create(:ci_build, :interruptible, :running, pipeline: child_pipeline)
            create(:ci_build, :interruptible, :running, pipeline: child_pipeline)
          end

          it 'cancels all child pipeline builds' do
            expect(build_statuses(child_pipeline)).to contain_exactly('running', 'running')

            execute

            expect(build_statuses(child_pipeline)).to contain_exactly('canceled', 'canceled')
          end

          context 'when the child pipeline includes completed interruptible jobs' do
            before do
              create(:ci_build, :interruptible, :failed, pipeline: child_pipeline)
              create(:ci_build, :interruptible, :success, pipeline: child_pipeline)
            end

            it 'cancels all child pipeline builds with a cancelable_status' do
              expect(build_statuses(child_pipeline)).to contain_exactly('running', 'running', 'failed', 'success')

              execute

              expect(build_statuses(child_pipeline)).to contain_exactly('canceled', 'canceled', 'failed', 'success')
            end
          end
        end

        context 'when the child pipeline has started non-interruptible job' do
          before do
            create(:ci_build, :interruptible, :running, pipeline: child_pipeline)
            # non-interruptible started
            create(:ci_build, :success, pipeline: child_pipeline)
          end

          it 'does not cancel any child pipeline builds' do
            expect(build_statuses(child_pipeline)).to contain_exactly('running', 'success')

            execute

            expect(build_statuses(child_pipeline)).to contain_exactly('running', 'success')
          end
        end

        context 'when the child pipeline has non-interruptible non-started job' do
          before do
            create(:ci_build, :interruptible, :running, pipeline: child_pipeline)
          end

          not_started_statuses = Ci::HasStatus::AVAILABLE_STATUSES - Ci::HasStatus::STARTED_STATUSES
          context 'when the jobs are cancelable' do
            cancelable_not_started_statuses =
              Set.new(not_started_statuses).intersection(Ci::HasStatus::CANCELABLE_STATUSES)
            cancelable_not_started_statuses.each do |status|
              it ""cancels all child pipeline builds when build status #{status} included"" do
                # non-interruptible but non-started
                create(:ci_build, status.to_sym, pipeline: child_pipeline)

                expect(build_statuses(child_pipeline)).to contain_exactly('running', status)

                execute

                expect(build_statuses(child_pipeline)).to contain_exactly('canceled', 'canceled')
              end
            end
          end

          context 'when the jobs are not cancelable' do
            not_cancelable_not_started_statuses = not_started_statuses - Ci::HasStatus::CANCELABLE_STATUSES
            not_cancelable_not_started_statuses.each do |status|
              it ""does not cancel child pipeline builds when build status #{status} included"" do
                # non-interruptible but non-started
                create(:ci_build, status.to_sym, pipeline: child_pipeline)

                expect(build_statuses(child_pipeline)).to contain_exactly('running', status)

                execute

                expect(build_statuses(child_pipeline)).to contain_exactly('canceled', status)
              end
            end
          end
        end
      end

      context 'when the pipeline is a child pipeline' do
        let!(:parent_pipeline) { create(:ci_pipeline, project: project, sha: new_commit.sha) }
        let(:pipeline) { create(:ci_pipeline, child_of: parent_pipeline) }

        before do
          create(:ci_build, :interruptible, :running, pipeline: parent_pipeline)
          create(:ci_build, :interruptible, :running, pipeline: parent_pipeline)
        end

        it 'does not cancel any builds' do
          expect(build_statuses(prev_pipeline)).to contain_exactly('running', 'success', 'created')
          expect(build_statuses(parent_pipeline)).to contain_exactly('running', 'running')

          execute

          expect(build_statuses(prev_pipeline)).to contain_exactly('running', 'success', 'created')
          expect(build_statuses(parent_pipeline)).to contain_exactly('running', 'running')
        end
      end

      context 'when the previous pipeline source is webide' do
        let(:prev_pipeline) { create(:ci_pipeline, :webide, project: project) }

        it 'does not cancel builds of the previous pipeline' do
          execute

          expect(build_statuses(prev_pipeline)).to contain_exactly('created', 'running', 'success')
          expect(build_statuses(pipeline)).to contain_exactly('pending')
        end
      end

      it 'does not cancel future pipelines' do
        expect(prev_pipeline.id).to be < pipeline.id
        expect(build_statuses(pipeline)).to contain_exactly('pending')
        expect(build_statuses(prev_pipeline)).to contain_exactly('running', 'success', 'created')

        described_class.new(prev_pipeline).execute

        expect(build_statuses(pipeline.reload)).to contain_exactly('pending')
      end

      it_behaves_like 'time limits pipeline cancellation'
    end

    context 'when auto-cancel is disabled' do
      before do
        project.update!(auto_cancel_pending_pipelines: 'disabled')
      end

      it 'does not cancel any build' do
        subject

        expect(build_statuses(prev_pipeline)).to contain_exactly('running', 'success', 'created')
        expect(build_statuses(pipeline)).to contain_exactly('pending')
      end
    end

    context 'when enable_cancel_redundant_pipelines_service FF is enabled' do
      before do
        stub_feature_flags(disable_cancel_redundant_pipelines_service: true)
      end

      it 'does not cancel any build' do
        subject

        expect(build_statuses(prev_pipeline)).to contain_exactly('running', 'success', 'created')
        expect(build_statuses(pipeline)).to contain_exactly('pending')
      end
    end
  end

  private

  def build_statuses(pipeline)
    pipeline.builds.pluck(:status)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module PipelineCreation
    class StartPipelineService
      attr_reader :pipeline

      def initialize(pipeline)
        @pipeline = pipeline
      end

      def execute
        ##
        # Create a persistent ref for the pipeline.
        # The pipeline ref is fetched in the jobs and deleted when the pipeline transitions to a finished state.
        pipeline.ensure_persistent_ref

        Ci::ProcessPipelineService.new(pipeline).execute
      end
    end
  end
end

::Ci::PipelineCreation::StartPipelineService.prepend_mod_with('Ci::PipelineCreation::StartPipelineService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ci::PipelineCreation::StartPipelineService, feature_category: :continuous_integration do
  let(:pipeline) { build(:ci_pipeline) }

  subject(:service) { described_class.new(pipeline) }

  describe '#execute' do
    it 'calls the pipeline process service' do
      expect(Ci::ProcessPipelineService)
        .to receive(:new)
        .with(pipeline)
        .and_return(double('service', execute: true))

      service.execute
    end

    it 'creates pipeline ref' do
      expect(pipeline.persistent_ref).to receive(:create).once

      service.execute
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ci
  module Deployments
    class DestroyService < BaseService
      def execute(deployment)
        raise Gitlab::Access::AccessDeniedError unless can?(current_user, :destroy_deployment, deployment)

        return ServiceResponse.error(message: 'Cannot destroy running deployment') if deployment&.running?
        return ServiceResponse.error(message: 'Deployment currently deployed to environment') if deployment&.last?

        project.destroy_deployment_by_id(deployment)

        ServiceResponse.success(message: 'Deployment destroyed')
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ci::Deployments::DestroyService, feature_category: :continuous_integration do
  let_it_be(:project) { create(:project, :repository) }

  let(:environment) { create(:environment, project: project) }
  let(:commits) { project.repository.commits(nil, { limit: 3 }) }
  let!(:deploy) do
    create(
      :deployment,
      :success,
      project: project,
      environment: environment,
      deployable: nil,
      sha: commits[2].sha
    )
  end

  let!(:running_deploy) do
    create(
      :deployment,
      :running,
      project: project,
      environment: environment,
      deployable: nil,
      sha: commits[1].sha
    )
  end

  let!(:old_deploy) do
    create(
      :deployment,
      :success,
      project: project,
      environment: environment,
      deployable: nil,
      sha: commits[0].sha,
      finished_at: 1.year.ago
    )
  end

  let(:user) { project.first_owner }

  subject { described_class.new(project, user) }

  context 'when deleting a deployment' do
    it 'delete is accepted for old deployment' do
      expect(subject.execute(old_deploy)).to be_success
    end

    it 'does not delete a running deployment' do
      response = subject.execute(running_deploy)
      expect(response).to be_an_error
      expect(response.message).to eq(""Cannot destroy running deployment"")
    end

    it 'does not delete the last deployment' do
      response = subject.execute(deploy)
      expect(response).to be_an_error
      expect(response.message).to eq(""Deployment currently deployed to environment"")
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Environments
  class ResetAutoStopService < ::BaseService
    def execute(environment)
      return error(_('Failed to cancel auto stop because you do not have permission to update the environment.')) unless can_update_environment?(environment)
      return error(_('Failed to cancel auto stop because the environment is not set as auto stop.')) unless environment.auto_stop_at?

      if environment.reset_auto_stop
        success
      else
        error(_('Failed to cancel auto stop because failed to update the environment.'))
      end
    end

    private

    def can_update_environment?(environment)
      can?(current_user, :update_environment, environment)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Environments::ResetAutoStopService, feature_category: :continuous_delivery do
  let_it_be(:project) { create(:project) }
  let_it_be(:developer) { create(:user).tap { |user| project.add_developer(user) } }
  let_it_be(:reporter) { create(:user).tap { |user| project.add_reporter(user) } }

  let(:user) { developer }
  let(:service) { described_class.new(project, user) }

  describe '#execute' do
    subject { service.execute(environment) }

    context 'when environment will be stopped automatically' do
      let(:environment) { create(:environment, :will_auto_stop, project: project) }

      it 'resets auto stop' do
        expect(environment).to receive(:reset_auto_stop).and_call_original

        expect(subject[:status]).to eq(:success)
      end

      context 'when failed to reset auto stop' do
        before do
          expect(environment).to receive(:reset_auto_stop) { false }
        end

        it 'returns error' do
          expect(subject[:status]).to eq(:error)
          expect(subject[:message]).to eq('Failed to cancel auto stop because failed to update the environment.')
        end
      end

      context 'when user is reporter' do
        let(:user) { reporter }

        it 'returns error' do
          expect(subject[:status]).to eq(:error)
          expect(subject[:message]).to eq('Failed to cancel auto stop because you do not have permission to update the environment.')
        end
      end
    end

    context 'when environment will not be stopped automatically' do
      let(:environment) { create(:environment, project: project) }

      it 'returns error' do
        expect(subject[:status]).to eq(:error)
        expect(subject[:message]).to eq('Failed to cancel auto stop because the environment is not set as auto stop.')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Environments
  class ScheduleToDeleteReviewAppsService < ::BaseService
    include ::Gitlab::ExclusiveLeaseHelpers

    EXCLUSIVE_LOCK_KEY_BASE = 'environments:delete_review_apps:lock'
    LOCK_TIMEOUT = 2.minutes

    def execute
      if validation_error = validate
        return validation_error
      end

      mark_deletable_environments
    end

    private

    def key
      ""#{EXCLUSIVE_LOCK_KEY_BASE}:#{project.id}""
    end

    def dry_run?
      return true if params[:dry_run].nil?

      params[:dry_run]
    end

    def validate
      return if can?(current_user, :destroy_environment, project)

      Result.new(error_message: ""You do not have permission to destroy environments in this project"", status: :unauthorized)
    end

    def mark_deletable_environments
      in_lock(key, ttl: LOCK_TIMEOUT, retries: 1) do
        unsafe_mark_deletable_environments
      end

    rescue FailedToObtainLockError
      Result.new(error_message: ""Another process is already processing a delete request. Please retry later."", status: :conflict)
    end

    def unsafe_mark_deletable_environments
      result = Result.new
      environments = project.environments
                            .not_scheduled_for_deletion
                            .stopped_review_apps(params[:before], params[:limit])

      # Check if the actor has write permission to a potentially-protected environment.
      deletable, failed = *environments.partition { |env| current_user.can?(:destroy_environment, env) }

      if deletable.any? && failed.empty?
        mark_for_deletion(deletable) unless dry_run?
        result.set_status(:ok)
        result.set_scheduled_entries(deletable)
      else
        result.set_status(
          :bad_request,
          error_message: ""No environments found for scheduled deletion. Either your query did not match any environments (default parameters match environments that are 30 days or older), or you have insufficient permissions to delete matching environments.""
        )

        result.set_unprocessable_entries(failed)
      end

      result
    end

    def mark_for_deletion(deletable_environments)
      Environment.id_in(deletable_environments).schedule_to_delete
    end

    class Result
      attr_accessor :scheduled_entries, :unprocessable_entries, :error_message, :status

      def initialize(scheduled_entries: [], unprocessable_entries: [], error_message: nil, status: nil)
        self.scheduled_entries = scheduled_entries
        self.unprocessable_entries = unprocessable_entries
        self.error_message = error_message
        self.status = status
      end

      def success?
        status == :ok
      end

      def set_status(status, error_message: nil)
        self.status = status
        self.error_message = error_message
      end

      def set_scheduled_entries(entries)
        self.scheduled_entries = entries
      end

      def set_unprocessable_entries(entries)
        self.unprocessable_entries = entries
      end
    end
  end
end

```","# frozen_string_literal: true

require ""spec_helper""

RSpec.describe Environments::ScheduleToDeleteReviewAppsService, feature_category: :continuous_delivery do
  include ExclusiveLeaseHelpers

  let_it_be(:maintainer) { create(:user) }
  let_it_be(:developer)  { create(:user) }
  let_it_be(:reporter)   { create(:user) }
  let_it_be(:project)    { create(:project, :private, :repository, namespace: maintainer.namespace) }

  let(:service)      { described_class.new(project, current_user, before: 30.days.ago, dry_run: dry_run) }
  let(:dry_run)      { false }
  let(:current_user) { maintainer }

  before do
    project.add_maintainer(maintainer)
    project.add_developer(developer)
    project.add_reporter(reporter)
  end

  describe ""#execute"" do
    subject { service.execute }

    shared_examples ""can schedule for deletion"" do
      let!(:old_stopped_review_env) { create(:environment, :with_review_app, :stopped, created_at: 31.days.ago, project: project) }
      let!(:new_stopped_review_env) { create(:environment, :with_review_app, :stopped, project: project) }
      let!(:old_active_review_env)  { create(:environment, :with_review_app, :available, created_at: 31.days.ago, project: project) }
      let!(:old_stopped_other_env)  { create(:environment, :stopped, created_at: 31.days.ago, project: project) }
      let!(:new_stopped_other_env)  { create(:environment, :stopped, project: project) }
      let!(:old_active_other_env)   { create(:environment, :available, created_at: 31.days.ago, project: project) }
      let!(:already_deleting_env)   { create(:environment, :with_review_app, :stopped, created_at: 31.days.ago, project: project, auto_delete_at: 1.day.from_now) }
      let(:already_deleting_time)   { already_deleting_env.reload.auto_delete_at }

      context ""live run"" do
        let(:dry_run) { false }

        around do |example|
          freeze_time { example.run }
        end

        it ""marks the correct environment as scheduled_entries"" do
          expect(subject.success?).to be_truthy
          expect(subject.scheduled_entries).to contain_exactly(old_stopped_review_env)
          expect(subject.unprocessable_entries).to be_empty

          old_stopped_review_env.reload
          new_stopped_review_env.reload
          old_active_review_env.reload
          old_stopped_other_env.reload
          new_stopped_other_env.reload
          old_active_other_env.reload
          already_deleting_env.reload

          expect(old_stopped_review_env.auto_delete_at).to eq(1.week.from_now)
          expect(new_stopped_review_env.auto_delete_at).to be_nil
          expect(old_active_review_env.auto_delete_at).to be_nil
          expect(old_stopped_other_env.auto_delete_at).to be_nil
          expect(new_stopped_other_env.auto_delete_at).to be_nil
          expect(old_active_other_env.auto_delete_at).to be_nil
          expect(already_deleting_env.auto_delete_at).to eq(already_deleting_time)
        end
      end

      context ""dry run"" do
        let(:dry_run) { true }

        it ""returns the same but doesn't update the record"" do
          expect(subject.success?).to be_truthy
          expect(subject.scheduled_entries).to contain_exactly(old_stopped_review_env)
          expect(subject.unprocessable_entries).to be_empty

          old_stopped_review_env.reload
          new_stopped_review_env.reload
          old_active_review_env.reload
          old_stopped_other_env.reload
          new_stopped_other_env.reload
          old_active_other_env.reload
          already_deleting_env.reload

          expect(old_stopped_review_env.auto_delete_at).to be_nil
          expect(new_stopped_review_env.auto_delete_at).to be_nil
          expect(old_active_review_env.auto_delete_at).to be_nil
          expect(old_stopped_other_env.auto_delete_at).to be_nil
          expect(new_stopped_other_env.auto_delete_at).to be_nil
          expect(old_active_other_env.auto_delete_at).to be_nil
          expect(already_deleting_env.auto_delete_at).to eq(already_deleting_time)
        end
      end

      describe ""execution in parallel"" do
        before do
          stub_exclusive_lease_taken(service.send(:key))
        end

        it ""does not execute unsafe_mark_scheduled_entries_environments"" do
          expect(service).not_to receive(:unsafe_mark_scheduled_entries_environments)

          expect(subject.success?).to be_falsey
          expect(subject.status).to eq(:conflict)
        end
      end
    end

    context ""as a maintainer"" do
      let(:current_user) { maintainer }

      it_behaves_like ""can schedule for deletion""
    end

    context ""as a developer"" do
      let(:current_user) { developer }

      it_behaves_like ""can schedule for deletion""
    end

    context ""as a reporter"" do
      let(:current_user) { reporter }

      it ""fails to delete environments"" do
        old_stopped_review_env = create(:environment, :with_review_app, :stopped, created_at: 31.days.ago, project: project)

        expect(subject.success?).to be_falsey

        # Both of these should be empty as we fail before testing them
        expect(subject.scheduled_entries).to be_empty
        expect(subject.unprocessable_entries).to be_empty

        old_stopped_review_env.reload

        expect(old_stopped_review_env.auto_delete_at).to be_nil
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Environments
  # This class creates an environment record for a pipeline job.
  class CreateForJobService
    def execute(job)
      return unless job.is_a?(::Ci::Processable) && job.has_environment_keyword?

      environment = to_resource(job)

      if environment.persisted?
        job.persisted_environment = environment
        job.assign_attributes(metadata_attributes: { expanded_environment_name: environment.name })
      else
        job.assign_attributes(status: :failed, failure_reason: :environment_creation_failure)
      end

      environment
    end

    private

    # rubocop: disable Performance/ActiveRecordSubtransactionMethods
    def to_resource(job)
      job.project.environments.safe_find_or_create_by(name: job.expanded_environment_name) do |environment|
        # Initialize the attributes at creation
        environment.auto_stop_in = expanded_auto_stop_in(job)
        environment.tier = job.environment_tier_from_options
        environment.merge_request = job.pipeline.merge_request
      end
    end
    # rubocop: enable Performance/ActiveRecordSubtransactionMethods

    def expanded_auto_stop_in(job)
      return unless job.environment_auto_stop_in

      ExpandVariables.expand(job.environment_auto_stop_in, -> { job.simple_variables.sort_and_expand_all })
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Environments::CreateForJobService, feature_category: :continuous_delivery do
  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:user) { create(:user) }
  let_it_be(:pipeline) { create(:ci_pipeline, project: project) }

  let(:service) { described_class.new }

  it_behaves_like 'create environment for job' do
    let(:factory_type) { :ci_build }
  end

  it_behaves_like 'create environment for job' do
    let(:factory_type) { :ci_bridge }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Environments
  class AutoStopService
    include ::Gitlab::ExclusiveLeaseHelpers
    include ::Gitlab::LoopHelpers

    BATCH_SIZE = 100
    LOOP_TIMEOUT = 45.minutes
    LOOP_LIMIT = 1000
    EXCLUSIVE_LOCK_KEY = 'environments:auto_stop:lock'
    LOCK_TIMEOUT = 50.minutes

    ##
    # Stop expired environments on GitLab instance
    #
    # This auto stop process cannot run for more than 45 minutes. This is for
    # preventing multiple `AutoStopCronWorker` CRON jobs run concurrently,
    # which is scheduled at every hour.
    def execute
      in_lock(EXCLUSIVE_LOCK_KEY, ttl: LOCK_TIMEOUT, retries: 1) do
        loop_until(timeout: LOOP_TIMEOUT, limit: LOOP_LIMIT) do
          stop_in_batch
        end
      end
    end

    private

    def stop_in_batch
      environments = Environment.preload_project.select(:id, :project_id).auto_stoppable(BATCH_SIZE)

      return false if environments.empty?

      Environments::AutoStopWorker.bulk_perform_async_with_contexts(
        environments,
        arguments_proc: -> (environment) { environment.id },
        context_proc: -> (environment) { { project: environment.project } }
      )

      true
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Environments::AutoStopService, :clean_gitlab_redis_shared_state, :sidekiq_inline,
  feature_category: :continuous_delivery do
  include CreateEnvironmentsHelpers
  include ExclusiveLeaseHelpers

  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:user) { create(:user) }

  let(:service) { described_class.new }

  before_all do
    project.add_developer(user)
  end

  describe '#execute' do
    subject { service.execute }

    let_it_be(:project) { create(:project, :repository) }
    let_it_be(:user) { create(:user) }

    let(:environments) { Environment.all }

    before_all do
      project.add_developer(user)
      project.repository.add_branch(user, 'review/feature-1', 'master')
      project.repository.add_branch(user, 'review/feature-2', 'master')
    end

    before do
      create_review_app(user, project, 'review/feature-1')
      create_review_app(user, project, 'review/feature-2')
    end

    it 'stops environments and play stop jobs' do
      expect { subject }
        .to change { Environment.all.map(&:state).uniq }
        .from(['available']).to(['stopping'])

      expect(Ci::Build.where(name: 'stop_review_app').map(&:status).uniq).to eq(['pending'])
    end

    it 'schedules stop processes in bulk' do
      args = [[Environment.find_by_name('review/feature-1').id], [Environment.find_by_name('review/feature-2').id]]

      expect(Environments::AutoStopWorker)
        .to receive(:bulk_perform_async).with(args).once.and_call_original

      subject
    end

    context 'when the other sidekiq worker has already been running' do
      before do
        stub_exclusive_lease_taken(described_class::EXCLUSIVE_LOCK_KEY)
      end

      it 'does not execute stop_in_batch' do
        expect_next_instance_of(described_class) do |service|
          expect(service).not_to receive(:stop_in_batch)
        end

        expect { subject }.to raise_error(Gitlab::ExclusiveLeaseHelpers::FailedToObtainLockError)
      end
    end

    context 'when loop reached timeout' do
      before do
        stub_const(""#{described_class}::LOOP_TIMEOUT"", 0.seconds)
        stub_const(""#{described_class}::LOOP_LIMIT"", 100_000)
        allow_next_instance_of(described_class) do |service|
          allow(service).to receive(:stop_in_batch) { true }
        end
      end

      it 'returns false and does not continue the process' do
        is_expected.to eq(false)
      end
    end

    context 'when loop reached loop limit' do
      before do
        stub_const(""#{described_class}::LOOP_LIMIT"", 1)
        stub_const(""#{described_class}::BATCH_SIZE"", 1)
      end

      it 'stops only one available environment' do
        expect { subject }.to change { Environment.available.count }.by(-1)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Environments
  class StopService < BaseService
    attr_reader :ref

    def execute(environment)
      unless can?(current_user, :stop_environment, environment)
        return ServiceResponse.error(
          message: 'Unauthorized to stop the environment',
          payload: { environment: environment }
        )
      end

      if params[:force]
        environment.stop_complete!
      else
        environment.stop_with_actions!(current_user)
      end

      unless environment.saved_change_to_attribute?(:state)
        return ServiceResponse.error(
          message: 'Attemped to stop the environment but failed to change the status',
          payload: { environment: environment }
        )
      end

      ServiceResponse.success(payload: { environment: environment })
    end

    def execute_for_branch(branch_name)
      @ref = branch_name

      return unless @ref.present?

      environments.each { |environment| execute(environment) }
    end

    def execute_for_merge_request_pipeline(merge_request)
      return unless merge_request.actual_head_pipeline&.merge_request?

      created_environments = merge_request.created_environments

      if created_environments.any?
        # This log message can be removed with https://gitlab.com/gitlab-org/gitlab/-/issues/372965
        Gitlab::AppJsonLogger.info(message: 'Running new dynamic environment stop logic', project_id: project.id)
        created_environments.each { |env| execute(env) }
      else
        environments_in_head_pipeline = merge_request.environments_in_head_pipeline(deployment_status: :success)
        environments_in_head_pipeline.each { |env| execute(env) }

        if environments_in_head_pipeline.any?
          # If we don't see a message often, we'd be able to remove this path. (or likely in GitLab 16.0)
          # See https://gitlab.com/gitlab-org/gitlab/-/issues/372965
          Gitlab::AppJsonLogger.info(message: 'Running legacy dynamic environment stop logic', project_id: project.id)
        end
      end
    end

    private

    def environments
      @environments ||= Environments::EnvironmentsByDeploymentsFinder
        .new(project, current_user, ref: @ref, recently_updated: true)
        .execute
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Environments::StopService, feature_category: :continuous_delivery do
  include CreateEnvironmentsHelpers

  let(:project) { create(:project, :private, :repository) }
  let(:user) { create(:user) }

  let(:service) { described_class.new(project, user) }

  describe '#execute' do
    subject { service.execute(environment) }

    let_it_be(:project) { create(:project, :private, :repository) }
    let_it_be(:developer) { create(:user).tap { |u| project.add_developer(u) } }
    let_it_be(:reporter) { create(:user).tap { |u| project.add_reporter(u) } }

    let(:user) { developer }

    context 'with a deployment' do
      let!(:environment) { review_job.persisted_environment }
      let!(:pipeline) { create(:ci_pipeline, project: project) }
      let!(:review_job) { create(:ci_build, :with_deployment, :start_review_app, pipeline: pipeline, project: project) }
      let!(:stop_review_job) { create(:ci_build, :with_deployment, :stop_review_app, :manual, pipeline: pipeline, project: project) }

      before do
        review_job.success!
      end

      context 'without stop action' do
        let!(:environment) { create(:environment, :available, project: project) }

        it 'stops the environment' do
          expect { subject }.to change { environment.reload.state }.from('available').to('stopped')
        end
      end

      it 'plays the stop action' do
        expect { subject }.to change { stop_review_job.reload.status }.from('manual').to('pending')
      end

      context 'force option' do
        let(:service) { described_class.new(project, user, { force: true }) }

        it 'does not play the stop action when forced' do
          expect { subject }.to change { environment.reload.state }.from('available').to('stopped')
          expect(stop_review_job.reload.status).to eq('manual')
        end
      end

      context 'when an environment has already been stopped' do
        let!(:environment) { create(:environment, :stopped, project: project) }

        it 'does not play the stop action' do
          expect { subject }.not_to change { stop_review_job.reload.status }
        end
      end
    end

    context 'without a deployment' do
      let!(:environment) { create(:environment, project: project) }

      it 'stops the environment' do
        expect { subject }.to change { environment.reload.state }.from('available').to('stopped')
      end

      context 'when the actor is a reporter' do
        let(:user) { reporter }

        it 'does not stop the environment' do
          expect { subject }.not_to change { environment.reload.state }
        end
      end
    end
  end

  describe '#execute_for_branch' do
    context 'when environment with review app exists' do
      context 'when user has permission to stop environment' do
        before do
          project.add_developer(user)
        end

        context 'when environment is associated with removed branch' do
          it 'stops environment' do
            expect_environment_stopping_on('feature', feature_environment)
          end
        end

        context 'when environment is associated with different branch' do
          it 'does not stop environment' do
            expect_environment_not_stopped_on('master', feature_environment)
          end
        end

        context 'when specified branch does not exist' do
          it 'does not stop environment' do
            expect_environment_not_stopped_on('non/existent/branch', feature_environment)
          end
        end

        context 'when no branch not specified' do
          it 'does not stop environment' do
            expect_environment_not_stopped_on(nil, feature_environment)
          end
        end

        context 'when environment is not stopped' do
          before do
            allow_next_found_instance_of(Environment) do |environment|
              allow(environment).to receive(:state).and_return(:stopped)
            end
          end

          it 'does not stop environment' do
            expect_environment_not_stopped_on('feature', feature_environment)
          end
        end
      end

      context 'when user does not have permission to stop environment' do
        context 'when user has no access to manage deployments' do
          before do
            project.add_guest(user)
          end

          it 'does not stop environment' do
            expect_environment_not_stopped_on('master', feature_environment)
          end
        end
      end

      context 'when branch for stop action is protected' do
        before do
          project.add_developer(user)
          create(:protected_branch, :no_one_can_push, name: 'master', project: project)
        end

        it 'does not stop environment' do
          expect_environment_not_stopped_on('master', feature_environment)
        end
      end
    end

    context 'when there is no environment associated with review app' do
      before do
        create(:environment, project: project)
      end

      context 'when user has permission to stop environments' do
        before do
          project.add_maintainer(user)
        end

        it 'does not stop environment' do
          expect_environment_not_stopped_on('master', feature_environment)
        end
      end
    end

    context 'when environment does not exist' do
      it 'does not raise error' do
        expect { service.execute_for_branch('master') }
          .not_to raise_error
      end
    end
  end

  describe '#execute_for_merge_request_pipeline' do
    subject { service.execute_for_merge_request_pipeline(merge_request) }

    let(:merge_request) { create(:merge_request, source_branch: 'feature', target_branch: 'master') }
    let(:project) { merge_request.project }
    let(:user) { create(:user) }

    let(:pipeline) do
      create(:ci_pipeline,
        source: :merge_request_event,
        merge_request: merge_request,
        project: project,
        sha: merge_request.diff_head_sha,
        merge_requests_as_head_pipeline: [merge_request])
    end

    let!(:review_job) { create(:ci_build, :with_deployment, :start_review_app, :success, pipeline: pipeline, project: project) }
    let!(:stop_review_job) { create(:ci_build, :with_deployment, :stop_review_app, :manual, pipeline: pipeline, project: project) }

    before do
      review_job.deployment.success!
    end

    it 'has active environment at first' do
      expect(pipeline.environments_in_self_and_project_descendants.first).to be_available
    end

    context 'when user is a developer' do
      before do
        project.add_developer(user)
      end

      context 'and merge request has associated created_environments' do
        let!(:environment1) { create(:environment, project: project, merge_request: merge_request) }
        let!(:environment2) { create(:environment, project: project, merge_request: merge_request) }
        let!(:environment3) { create(:environment, project: project) }
        let!(:environment3_deployment) { create(:deployment, environment: environment3, sha: pipeline.sha) }

        before do
          subject
        end

        it 'stops the associated created_environments' do
          expect(environment1.reload).to be_stopped
          expect(environment2.reload).to be_stopped
        end

        it 'does not affect environments that are not associated to the merge request' do
          expect(environment3.reload).to be_available
        end
      end

      it 'stops the active environment' do
        subject
        expect(pipeline.environments_in_self_and_project_descendants.first).to be_stopping
      end

      context 'when pipeline is a branch pipeline for merge request' do
        let(:pipeline) do
          create(:ci_pipeline,
            source: :push,
            project: project,
            sha: merge_request.diff_head_sha,
            merge_requests_as_head_pipeline: [merge_request])
        end

        it 'does not stop the active environment' do
          subject

          expect(pipeline.environments_in_self_and_project_descendants.first).to be_available
        end
      end

      context 'with environment related jobs ' do
        let!(:environment) { create(:environment, :available, name: 'staging', project: project) }
        let!(:prepare_staging_job) { create(:ci_build, :prepare_staging, pipeline: pipeline, project: project) }
        let!(:start_staging_job) { create(:ci_build, :start_staging, :with_deployment, :manual, pipeline: pipeline, project: project) }
        let!(:stop_staging_job) { create(:ci_build, :stop_staging, :manual, pipeline: pipeline, project: project) }

        it 'does not stop environments that was not started by the merge request' do
          subject

          expect(prepare_staging_job.persisted_environment.state).to eq('available')
        end
      end
    end

    context 'when user is a reporter' do
      before do
        project.add_reporter(user)
      end

      it 'does not stop the active environment' do
        subject

        expect(pipeline.environments_in_self_and_project_descendants.first).to be_available
      end
    end

    context 'when pipeline is not associated with environments' do
      let!(:job) { create(:ci_build, pipeline: pipeline, project: project) }

      it 'does not raise exception' do
        expect { subject }.not_to raise_exception
      end
    end

    context 'when pipeline is not a pipeline for merge request' do
      let(:pipeline) do
        create(:ci_pipeline,
          project: project,
          ref: 'feature',
          sha: merge_request.diff_head_sha,
          merge_requests_as_head_pipeline: [merge_request])
      end

      it 'does not stop the active environment' do
        subject

        expect(pipeline.environments_in_self_and_project_descendants.first).to be_available
      end
    end
  end

  def expect_environment_stopped_on(branch, environment)
    expect { service.execute_for_branch(branch) }
      .to change { environment.reload.state }.from('available').to('stopped')
  end

  def expect_environment_stopping_on(branch, environment)
    expect { service.execute_for_branch(branch) }
      .to change { environment.reload.state }.from('available').to('stopping')
  end

  def expect_environment_not_stopped_on(branch, environment)
    expect { service.execute_for_branch(branch) }
      .not_to change { environment.reload.state }.from('available')
  end

  def feature_environment
    create(:environment, :with_review_app, project: project, ref: 'feature')
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Environments
  class AutoRecoverService
    include ::Gitlab::ExclusiveLeaseHelpers
    include ::Gitlab::LoopHelpers

    BATCH_SIZE = 100
    LOOP_TIMEOUT = 45.minutes
    LOOP_LIMIT = 1000
    EXCLUSIVE_LOCK_KEY = 'environments:auto_recover:lock'
    LOCK_TIMEOUT = 50.minutes

    ##
    # Recover environments that are stuck stopping on a GitLab instance
    #
    # This auto stop process cannot run for more than 45 minutes. This is for
    # preventing multiple `AutoStopCronWorker` CRON jobs run concurrently,
    # which is scheduled at every hour.
    def execute
      in_lock(EXCLUSIVE_LOCK_KEY, ttl: LOCK_TIMEOUT, retries: 1) do
        loop_until(timeout: LOOP_TIMEOUT, limit: LOOP_LIMIT) do
          recover_in_batch
        end
      end
    end

    private

    def recover_in_batch
      environments = Environment.preload_project.select(:id, :project_id).long_stopping.limit(BATCH_SIZE)

      return false if environments.empty?

      Environments::AutoRecoverWorker.bulk_perform_async_with_contexts(
        environments,
        arguments_proc: ->(environment) { environment.id },
        context_proc: ->(environment) { { project: environment.project } }
      )

      true
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Environments::AutoRecoverService, :clean_gitlab_redis_shared_state, :sidekiq_inline,
  feature_category: :continuous_delivery do
  include CreateEnvironmentsHelpers
  include ExclusiveLeaseHelpers

  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:user) { create(:user) }

  let(:service) { described_class.new }

  before_all do
    project.add_developer(user)
  end

  describe '#execute' do
    subject { service.execute }

    let_it_be(:project) { create(:project, :repository) }
    let_it_be(:user) { create(:user) }

    let(:environments) { Environment.all }

    before_all do
      project.add_developer(user)
      project.repository.add_branch(user, 'review/feature-1', 'master')
      project.repository.add_branch(user, 'review/feature-2', 'master')
    end

    before do
      create_review_app(user, project, 'review/feature-1')
      create_review_app(user, project, 'review/feature-2')

      Environment.all.map do |e|
        e.stop_actions.map(&:drop)
        e.stop!
        e.update!(updated_at: (Environment::LONG_STOP + 1.day).ago)
        e.reload
      end
    end

    it 'stops environments that have been stuck stopping too long' do
      expect { subject }
        .to change { Environment.all.map(&:state).uniq }
        .from(['stopping']).to(['available'])
    end

    it 'schedules stop processes in bulk' do
      args = [[Environment.find_by_name('review/feature-1').id], [Environment.find_by_name('review/feature-2').id]]

      expect(Environments::AutoRecoverWorker)
        .to receive(:bulk_perform_async).with(args).once.and_call_original

      subject
    end

    context 'when the other sidekiq worker has already been running' do
      before do
        stub_exclusive_lease_taken(described_class::EXCLUSIVE_LOCK_KEY)
      end

      it 'does not execute recover_in_batch' do
        expect_next_instance_of(described_class) do |service|
          expect(service).not_to receive(:recover_in_batch)
        end

        expect { subject }.to raise_error(Gitlab::ExclusiveLeaseHelpers::FailedToObtainLockError)
      end
    end

    context 'when loop reached timeout' do
      before do
        stub_const(""#{described_class}::LOOP_TIMEOUT"", 0.seconds)
        stub_const(""#{described_class}::LOOP_LIMIT"", 100_000)
        allow_next_instance_of(described_class) do |service|
          allow(service).to receive(:recover_in_batch).and_return(true)
        end
      end

      it 'returns false and does not continue the process' do
        is_expected.to eq(false)
      end
    end

    context 'when loop reached loop limit' do
      before do
        stub_const(""#{described_class}::LOOP_LIMIT"", 1)
        stub_const(""#{described_class}::BATCH_SIZE"", 1)
      end

      it 'stops only one available environment' do
        expect { subject }.to change { Environment.long_stopping.count }.by(-1)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Environments
  class DestroyService < BaseService
    def execute(environment)
      unless can?(current_user, :destroy_environment, environment)
        return ServiceResponse.error(
          message: 'Unauthorized to delete the environment'
        )
      end

      environment.destroy

      unless environment.destroyed?
        return ServiceResponse.error(
          message: 'Attemped to destroy the environment but failed'
        )
      end

      ServiceResponse.success
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Environments::DestroyService, feature_category: :continuous_delivery do
  include CreateEnvironmentsHelpers

  let_it_be(:project) { create(:project, :private, :repository) }
  let_it_be(:user) { create(:user) }

  let(:service) { described_class.new(project, user) }

  describe '#execute' do
    subject { service.execute(environment) }

    let_it_be(:project) { create(:project, :private, :repository) }
    let_it_be(:developer) { create(:user).tap { |u| project.add_developer(u) } }
    let_it_be(:reporter) { create(:user).tap { |u| project.add_reporter(u) } }

    let(:user) { developer }

    let!(:environment) { create(:environment, project: project, state: :stopped) }

    context ""when destroy is authorized"" do
      it 'destroys the environment' do
        expect { subject }.to change { environment.destroyed? }.from(false).to(true)
      end
    end

    context ""when destroy is not authorized"" do
      let(:user) { reporter }

      it 'does not destroy the environment' do
        expect { subject }.not_to change { environment.destroyed? }
      end
    end

    context ""when destroy fails"" do
      before do
        allow(environment)
          .to receive(:destroy)
          .and_return(false)
      end

      it 'returns errors' do
        expect(subject.message).to include(""Attemped to destroy the environment but failed"")
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Environments
  class UpdateService < BaseService
    ALLOWED_ATTRIBUTES = %i[external_url tier cluster_agent kubernetes_namespace flux_resource_path].freeze

    def execute(environment)
      unless can?(current_user, :update_environment, environment)
        return ServiceResponse.error(
          message: _('Unauthorized to update the environment'),
          payload: { environment: environment }
        )
      end

      if unauthorized_cluster_agent?
        return ServiceResponse.error(
          message: _('Unauthorized to access the cluster agent in this project'),
          payload: { environment: environment })
      end

      if environment.update(**params.slice(*ALLOWED_ATTRIBUTES))
        ServiceResponse.success(payload: { environment: environment })
      else
        ServiceResponse.error(
          message: environment.errors.full_messages,
          payload: { environment: environment }
        )
      end
    end

    private

    def unauthorized_cluster_agent?
      return false unless params[:cluster_agent]

      ::Clusters::Agents::Authorizations::UserAccess::Finder
        .new(current_user, agent: params[:cluster_agent], project: project)
        .execute
        .empty?
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Environments::UpdateService, feature_category: :environment_management do
  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:developer) { create(:user).tap { |u| project.add_developer(u) } }
  let_it_be(:reporter) { create(:user).tap { |u| project.add_reporter(u) } }
  let_it_be(:environment) { create(:environment, project: project) }

  let(:service) { described_class.new(project, current_user, params) }
  let(:current_user) { developer }
  let(:params) { {} }

  describe '#execute' do
    subject { service.execute(environment) }

    let(:params) { { external_url: 'https://gitlab.com/' } }

    it 'updates the external URL' do
      expect { subject }.to change { environment.reload.external_url }.to('https://gitlab.com/')
    end

    it 'returns successful response' do
      response = subject

      expect(response).to be_success
      expect(response.payload[:environment]).to eq(environment)
    end

    context 'when setting a kubernetes namespace to the environment' do
      let(:params) { { kubernetes_namespace: 'default' } }

      it 'updates the kubernetes namespace' do
        expect { subject }.to change { environment.reload.kubernetes_namespace }.to('default')
      end

      it 'returns successful response' do
        response = subject

        expect(response).to be_success
        expect(response.payload[:environment]).to eq(environment)
      end
    end

    context 'when setting a flux resource path to the environment' do
      let(:params) { { flux_resource_path: 'path/to/flux/resource' } }

      it 'updates the flux resource path' do
        expect { subject }.to change { environment.reload.flux_resource_path }.to('path/to/flux/resource')
      end

      it 'returns successful response' do
        response = subject

        expect(response).to be_success
        expect(response.payload[:environment]).to eq(environment)
      end
    end

    context 'when setting a cluster agent to the environment' do
      let_it_be(:agent_management_project) { create(:project) }
      let_it_be(:cluster_agent) { create(:cluster_agent, project: agent_management_project) }

      let!(:authorization) { create(:agent_user_access_project_authorization, project: project, agent: cluster_agent) }
      let(:params) { { cluster_agent: cluster_agent } }

      it 'returns successful response' do
        response = subject

        expect(response).to be_success
        expect(response.payload[:environment].cluster_agent).to eq(cluster_agent)
      end

      context 'when user does not have permission to read the agent' do
        let!(:authorization) { nil }

        it 'returns an error' do
          response = subject

          expect(response).to be_error
          expect(response.message).to eq('Unauthorized to access the cluster agent in this project')
          expect(response.payload[:environment]).to eq(environment)
        end
      end
    end

    context 'when unsetting a cluster agent of the environment' do
      let_it_be(:cluster_agent) { create(:cluster_agent, project: project) }

      let(:params) { { cluster_agent: nil } }

      before do
        environment.update!(cluster_agent: cluster_agent)
      end

      it 'returns successful response' do
        response = subject

        expect(response).to be_success
        expect(response.payload[:environment].cluster_agent).to be_nil
      end
    end

    context 'when params contain invalid value' do
      let(:params) { { external_url: 'http://${URL}' } }

      it 'returns an error' do
        response = subject

        expect(response).to be_error
        expect(response.message).to match_array(""External url URI is invalid"")
        expect(response.payload[:environment]).to eq(environment)
      end
    end

    context 'when disallowed parameter is passed' do
      let(:params) { { external_url: 'https://gitlab.com/', slug: 'prod' } }

      it 'ignores the parameter' do
        response = subject

        expect(response).to be_success
        expect(response.payload[:environment].external_url).to eq('https://gitlab.com/')
        expect(response.payload[:environment].slug).not_to eq('prod')
      end
    end

    context 'when user is reporter' do
      let(:current_user) { reporter }

      it 'returns an error' do
        response = subject

        expect(response).to be_error
        expect(response.message).to eq('Unauthorized to update the environment')
        expect(response.payload[:environment]).to eq(environment)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Environments
  class CreateService < BaseService
    ALLOWED_ATTRIBUTES = %i[name external_url tier cluster_agent kubernetes_namespace flux_resource_path].freeze

    def execute
      unless can?(current_user, :create_environment, project)
        return ServiceResponse.error(
          message: _('Unauthorized to create an environment'),
          payload: { environment: nil }
        )
      end

      if unauthorized_cluster_agent?
        return ServiceResponse.error(
          message: _('Unauthorized to access the cluster agent in this project'),
          payload: { environment: nil })
      end

      environment = project.environments.create(**params.slice(*ALLOWED_ATTRIBUTES))

      if environment.persisted?
        ServiceResponse.success(payload: { environment: environment })
      else
        ServiceResponse.error(
          message: environment.errors.full_messages,
          payload: { environment: nil }
        )
      end
    end

    private

    def unauthorized_cluster_agent?
      return false unless params[:cluster_agent]

      ::Clusters::Agents::Authorizations::UserAccess::Finder
        .new(current_user, agent: params[:cluster_agent], project: project)
        .execute
        .empty?
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Environments::CreateService, feature_category: :environment_management do
  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:developer) { create(:user).tap { |u| project.add_developer(u) } }
  let_it_be(:reporter) { create(:user).tap { |u| project.add_reporter(u) } }

  let(:service) { described_class.new(project, current_user, params) }
  let(:current_user) { developer }
  let(:params) { {} }

  describe '#execute' do
    subject { service.execute }

    let(:params) { { name: 'production', external_url: 'https://gitlab.com', tier: :production, kubernetes_namespace: 'default', flux_resource_path: 'path/to/flux/resource' } }

    it 'creates an environment' do
      expect { subject }.to change { ::Environment.count }.by(1)
    end

    it 'returns successful response' do
      response = subject

      expect(response).to be_success
      expect(response.payload[:environment].name).to eq('production')
      expect(response.payload[:environment].external_url).to eq('https://gitlab.com')
      expect(response.payload[:environment].tier).to eq('production')
      expect(response.payload[:environment].kubernetes_namespace).to eq('default')
      expect(response.payload[:environment].flux_resource_path).to eq('path/to/flux/resource')
    end

    context 'with a cluster agent' do
      let_it_be(:agent_management_project) { create(:project) }
      let_it_be(:cluster_agent) { create(:cluster_agent, project: agent_management_project) }

      let!(:authorization) { create(:agent_user_access_project_authorization, project: project, agent: cluster_agent) }
      let(:params) { { name: 'production', cluster_agent: cluster_agent } }

      it 'returns successful response' do
        response = subject

        expect(response).to be_success
        expect(response.payload[:environment].cluster_agent).to eq(cluster_agent)
      end

      context 'when user does not have permission to read the agent' do
        let!(:authorization) { nil }

        it 'returns an error' do
          response = subject

          expect(response).to be_error
          expect(response.message).to eq('Unauthorized to access the cluster agent in this project')
          expect(response.payload[:environment]).to be_nil
        end
      end
    end

    context 'when params contain invalid value' do
      let(:params) { { name: 'production', external_url: 'http://${URL}' } }

      it 'does not create an environment' do
        expect { subject }.not_to change { ::Environment.count }
      end

      it 'returns an error' do
        response = subject

        expect(response).to be_error
        expect(response.message).to match_array(""External url URI is invalid"")
        expect(response.payload[:environment]).to be_nil
      end
    end

    context 'when disallowed parameter is passed' do
      let(:params) { { name: 'production', slug: 'prod' } }

      it 'ignores the parameter' do
        response = subject

        expect(response).to be_success
        expect(response.payload[:environment].name).to eq('production')
        expect(response.payload[:environment].slug).not_to eq('prod')
      end
    end

    context 'when user is reporter' do
      let(:current_user) { reporter }

      it 'does not create an environment' do
        expect { subject }.not_to change { ::Environment.count }
      end

      it 'returns an error' do
        response = subject

        expect(response).to be_error
        expect(response.message).to eq('Unauthorized to create an environment')
        expect(response.payload[:environment]).to be_nil
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Environments
  class StopStaleService < BaseService
    def execute
      return ServiceResponse.error(message: 'Before date must be provided') unless params[:before].present?

      return ServiceResponse.error(message: 'Unauthorized') unless can?(current_user, :stop_environment, project)

      Environment.available
      .deployed_and_updated_before(project.id, params[:before])
      .without_protected(project)
      .in_batches(of: 100) do |env_batch| # rubocop:disable Cop/InBatches
        Environments::AutoStopWorker.bulk_perform_async_with_contexts(
          env_batch,
          arguments_proc: ->(environment) { environment.id },
          context_proc: ->(environment) { { project: project } }
        )
      end

      ServiceResponse.success(message: 'Successfully requested stop for all stale environments')
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Environments::StopStaleService,
  :clean_gitlab_redis_shared_state,
  :sidekiq_inline,
  feature_category: :continuous_delivery do
  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:user) { create(:user) }

  let(:params) { { after: nil } }
  let(:service) { described_class.new(project, user, params) }

  describe '#execute' do
    subject { service.execute }

    let_it_be(:project) { create(:project, :repository) }
    let_it_be(:user) { create(:user) }
    let_it_be(:stale_environment) { create(:environment, project: project, updated_at: 2.weeks.ago) }
    let_it_be(:stale_environment2) { create(:environment, project: project, updated_at: 2.weeks.ago) }
    let_it_be(:recent_environment) { create(:environment, project: project, updated_at: Date.today) }

    let_it_be(:params) { { before: 1.week.ago } }

    before do
      allow(service).to receive(:can?).with(user, :stop_environment, project).and_return(true)
    end

    it 'only stops stale environments' do
      spy_service = Environments::AutoStopWorker.new

      allow(Environments::AutoStopWorker).to receive(:new) { spy_service }

      expect(spy_service).to receive(:perform).with(stale_environment.id).and_call_original
      expect(spy_service).to receive(:perform).with(stale_environment2.id).and_call_original
      expect(spy_service).not_to receive(:perform).with(recent_environment.id)

      expect(Environment).to receive(:deployed_and_updated_before).with(project.id, params[:before]).and_call_original
      expect(Environment).to receive(:without_protected).with(project).and_call_original

      expect(subject.success?).to be_truthy

      expect(stale_environment.reload).to be_stopped
      expect(stale_environment2.reload).to be_stopped
      expect(recent_environment.reload).to be_available
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Environments
  module CanaryIngress
    class UpdateService < ::BaseService
      def execute_async(environment)
        result = validate(environment)

        return result unless result[:status] == :success

        Environments::CanaryIngress::UpdateWorker.perform_async(environment.id, params)

        success
      end

      # This method actually executes the PATCH request to Kubernetes,
      # that is used by internal processes i.e. sidekiq worker.
      # You should always use `execute_async` to properly validate user's requests.
      def execute(environment)
        canary_ingress = environment.ingresses&.find(&:canary?)

        unless canary_ingress.present?
          return error(_('Canary Ingress does not exist in the environment.'))
        end

        if environment.patch_ingress(canary_ingress, patch_data)
          environment.clear_all_caches
          success
        else
          error(_('Failed to update the Canary Ingress.'), :bad_request)
        end
      end

      private

      def validate(environment)
        unless can?(current_user, :update_environment, environment)
          return error(_('You do not have permission to update the environment.'))
        end

        unless params[:weight].is_a?(Integer) && (0..100).cover?(params[:weight])
          return error(_('Canary weight must be specified and valid range (0..100).'))
        end

        if environment.has_running_deployments?
          return error(_('There are running deployments on the environment. Please retry later.'))
        end

        if ::Gitlab::ApplicationRateLimiter.throttled?(:update_environment_canary_ingress, scope: [environment])
          return error(_(""This environment's canary ingress has been updated recently. Please retry later.""))
        end

        success
      end

      def patch_data
        {
          metadata: {
            annotations: {
              Gitlab::Kubernetes::Ingress::ANNOTATION_KEY_CANARY_WEIGHT => params[:weight].to_s
            }
          }
        }
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Environments::CanaryIngress::UpdateService, :clean_gitlab_redis_cache,
  feature_category: :continuous_delivery do
  include KubernetesHelpers

  let_it_be(:project, refind: true) { create(:project) }
  let_it_be(:maintainer) { create(:user) }
  let_it_be(:reporter) { create(:user) }

  let(:user) { maintainer }
  let(:params) { {} }
  let(:service) { described_class.new(project, user, params) }

  before_all do
    project.add_maintainer(maintainer)
    project.add_reporter(reporter)
  end

  shared_examples_for 'failed request' do
    it 'returns an error' do
      expect(subject[:status]).to eq(:error)
      expect(subject[:message]).to eq(message)
    end
  end

  describe '#execute_async' do
    subject { service.execute_async(environment) }

    let(:environment) { create(:environment, project: project) }
    let(:params) { { weight: 50 } }
    let(:canary_ingress) { ::Gitlab::Kubernetes::Ingress.new(kube_ingress(track: :canary)) }

    context 'when the actor does not have permission to update environment' do
      let(:user) { reporter }

      it_behaves_like 'failed request' do
        let(:message) { ""You do not have permission to update the environment."" }
      end
    end

    context 'when weight parameter is invalid' do
      let(:params) { { weight: 'unknown' } }

      it_behaves_like 'failed request' do
        let(:message) { 'Canary weight must be specified and valid range (0..100).' }
      end
    end

    context 'when no parameters exist' do
      let(:params) { {} }

      it_behaves_like 'failed request' do
        let(:message) { 'Canary weight must be specified and valid range (0..100).' }
      end
    end

    context 'when environment has a running deployment' do
      before do
        allow(environment).to receive(:has_running_deployments?) { true }
      end

      it_behaves_like 'failed request' do
        let(:message) { 'There are running deployments on the environment. Please retry later.' }
      end
    end

    context 'when canary ingress was updated recently' do
      before do
        allow(::Gitlab::ApplicationRateLimiter).to receive(:throttled?) { true }
      end

      it_behaves_like 'failed request' do
        let(:message) { ""This environment's canary ingress has been updated recently. Please retry later."" }
      end
    end
  end

  describe '#execute' do
    subject { service.execute(environment) }

    let(:environment) { create(:environment, project: project) }
    let(:params) { { weight: 50 } }
    let(:canary_ingress) { ::Gitlab::Kubernetes::Ingress.new(kube_ingress(track: :canary)) }

    context 'when canary ingress is present in the environment' do
      before do
        allow(environment).to receive(:ingresses) { [canary_ingress] }
      end

      context 'when patch request succeeds' do
        let(:patch_data) do
          {
            metadata: {
              annotations: {
                Gitlab::Kubernetes::Ingress::ANNOTATION_KEY_CANARY_WEIGHT => params[:weight].to_s
              }
            }
          }
        end

        before do
          allow(environment).to receive(:patch_ingress).with(canary_ingress, patch_data) { true }
        end

        it 'returns success' do
          expect(subject[:status]).to eq(:success)
          expect(subject[:message]).to be_nil
        end

        it 'clears all caches' do
          expect(environment).to receive(:clear_all_caches)

          subject
        end
      end

      context 'when patch request does not succeed' do
        before do
          allow(environment).to receive(:patch_ingress) { false }
        end

        it_behaves_like 'failed request' do
          let(:message) { 'Failed to update the Canary Ingress.' }
        end
      end
    end

    context 'when canary ingress is not present in the environment' do
      it_behaves_like 'failed request' do
        let(:message) { 'Canary Ingress does not exist in the environment.' }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class ImportService < BaseService
    Error = Class.new(StandardError)
    PermissionError = Class.new(StandardError)

    # Returns true if this importer is supposed to perform its work in the
    # background.
    #
    # This method will only return `true` if async importing is explicitly
    # supported by an importer class (`Gitlab::GithubImport::ParallelImporter`
    # for example).
    def async?
      has_importer? && !!importer_class.try(:async?)
    end

    def execute
      track_start_import

      add_repository_to_project

      validate_repository_size!

      download_lfs_objects

      import_data

      after_execute_hook

      success
    rescue Gitlab::HTTP_V2::UrlBlocker::BlockedUrlError, StandardError => e
      Gitlab::Import::ImportFailureService.track(
        project_id: project.id,
        error_source: self.class.name,
        exception: e,
        metrics: true
      )

      message = Projects::ImportErrorFilter.filter_message(e.message)
      error(
        s_(
          ""ImportProjects|Error importing repository %{project_safe_import_url} into %{project_full_path} - %{message}""
        ) % { project_safe_import_url: project.safe_import_url, project_full_path: project.full_path, message: message }
      )
    end

    protected

    def extra_attributes_for_measurement
      {
        current_user: current_user&.name,
        project_full_path: project&.full_path,
        import_type: project&.import_type,
        file_path: project&.import_source
      }
    end

    private

    attr_reader :resolved_address

    def validate_repository_size!
      # Defined in EE::Projects::ImportService
    end

    def after_execute_hook
      # Defined in EE::Projects::ImportService
    end

    def track_start_import
      has_importer? && importer_class.try(:track_start_import, project)
    end

    def add_repository_to_project
      if project.external_import? && !unknown_url?
        begin
          @resolved_address = get_resolved_address
        rescue Gitlab::HTTP_V2::UrlBlocker::BlockedUrlError => e
          raise e, s_(""ImportProjects|Blocked import URL: %{message}"") % { message: e.message }
        end
      end

      # We should skip the repository for a GitHub import or GitLab project import,
      # because these importers fetch the project repositories for us.
      return if importer_imports_repository?

      if unknown_url?
        # In this case, we only want to import issues, not a repository.
        create_repository
      elsif !project.repository_exists?
        import_repository
      end
    end

    def create_repository
      unless project.create_repository
        raise Error, s_('ImportProjects|The repository could not be created.')
      end
    end

    def import_repository
      refmap = importer_class.try(:refmap) if has_importer?

      if refmap
        project.ensure_repository
        project.repository.fetch_as_mirror(project.import_url, refmap: refmap, resolved_address: resolved_address)
      else
        project.repository.import_repository(project.import_url, resolved_address: resolved_address)
      end
    rescue ::Gitlab::Git::CommandError => e
      # Expire cache to prevent scenarios such as:
      # 1. First import failed, but the repo was imported successfully, so +exists?+ returns true
      # 2. Retried import, repo is broken or not imported but +exists?+ still returns true
      project.repository.expire_content_cache if project.repository_exists?

      raise Error, e.message
    end

    def download_lfs_objects
      # In this case, we only want to import issues
      return if unknown_url?

      # If it has its own repository importer, it has to implements its own lfs import download
      return if importer_imports_repository?

      return unless project.lfs_enabled?

      result = Projects::LfsPointers::LfsImportService.new(project).execute

      if result[:status] == :error
        # To avoid aborting the importing process, we silently fail
        # if any exception raises.
        Gitlab::AppLogger.error(""The Lfs import process failed. #{result[:message]}"")
      end
    end

    def import_data
      return unless has_importer?

      project.repository.expire_content_cache unless project.gitlab_project_import?

      unless importer.execute
        raise Error, s_('ImportProjects|The remote data could not be imported.')
      end
    end

    def importer_class
      @importer_class ||= Gitlab::ImportSources.importer(project.import_type)
    end

    def has_importer?
      Gitlab::ImportSources.importer_names.include?(project.import_type)
    end

    def importer
      importer_class.new(project)
    end

    def unknown_url?
      project.import_url == Project::UNKNOWN_IMPORT_URL
    end

    def importer_imports_repository?
      has_importer? && importer_class.try(:imports_repository?)
    end

    def get_resolved_address
      Gitlab::UrlBlocker
        .validate!(
          project.import_url,
          schemes: Project::VALID_IMPORT_PROTOCOLS,
          ports: Project::VALID_IMPORT_PORTS,
          allow_localhost: allow_local_requests?,
          allow_local_network: allow_local_requests?,
          dns_rebind_protection: dns_rebind_protection?)
        .then do |(import_url, resolved_host)|
          next '' if resolved_host.nil? || !import_url.scheme.in?(%w[http https])

          import_url.hostname.to_s
        end
    end

    def allow_local_requests?
      Rails.env.development? && # There is no known usecase for this in non-development environments
        Gitlab::CurrentSettings.allow_local_requests_from_web_hooks_and_services?
    end

    def dns_rebind_protection?
      return false if Gitlab.http_proxy_env?

      Gitlab::CurrentSettings.dns_rebinding_protection_enabled?
    end
  end
end

Projects::ImportService.prepend_mod_with('Projects::ImportService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::ImportService, feature_category: :importers do
  let!(:project) { create(:project) }
  let(:user) { project.creator }

  subject { described_class.new(project, user) }

  before do
    allow(project).to receive(:lfs_enabled?).and_return(true)
  end

  describe '#async?' do
    it 'returns true for an asynchronous importer' do
      importer_class = double(:importer, async?: true)

      allow(subject).to receive(:has_importer?).and_return(true)
      allow(subject).to receive(:importer_class).and_return(importer_class)

      expect(subject).to be_async
    end

    it 'returns false for a regular importer' do
      importer_class = double(:importer, async?: false)

      allow(subject).to receive(:has_importer?).and_return(true)
      allow(subject).to receive(:importer_class).and_return(importer_class)

      expect(subject).not_to be_async
    end

    it 'returns false when the importer does not define #async?' do
      importer_class = double(:importer)

      allow(subject).to receive(:has_importer?).and_return(true)
      allow(subject).to receive(:importer_class).and_return(importer_class)

      expect(subject).not_to be_async
    end

    it 'returns false when the importer does not exist' do
      allow(subject).to receive(:has_importer?).and_return(false)

      expect(subject).not_to be_async
    end
  end

  describe '#execute' do
    context 'with unknown url' do
      before do
        project.import_url = Project::UNKNOWN_IMPORT_URL
      end

      it 'succeeds if repository is created successfully' do
        expect(project).to receive(:create_repository).and_return(true)

        result = subject.execute

        expect(result[:status]).to eq :success
      end

      it 'fails if repository creation fails' do
        expect(project).to receive(:create_repository).and_return(false)

        result = subject.execute

        expect(result[:status]).to eq :error
        expect(result[:message]).to eq ""Error importing repository #{project.safe_import_url} into #{project.full_path} - The repository could not be created.""
      end

      context 'when repository creation succeeds' do
        it 'does not download lfs files' do
          expect_any_instance_of(Projects::LfsPointers::LfsImportService).not_to receive(:execute)

          subject.execute
        end
      end
    end

    context 'with known url' do
      before do
        project.import_url = 'https://github.com/vim/vim.git'
        project.import_type = 'github'
      end

      context 'with a Github repository' do
        it 'tracks the start of import' do
          expect(Gitlab::GithubImport::ParallelImporter).to receive(:track_start_import)

          subject.execute
        end

        it 'succeeds if repository import was scheduled' do
          expect_any_instance_of(Gitlab::GithubImport::ParallelImporter)
            .to receive(:execute)
            .and_return(true)

          result = subject.execute

          expect(result[:status]).to eq :success
        end

        it 'fails if repository import was not scheduled' do
          expect_any_instance_of(Gitlab::GithubImport::ParallelImporter)
            .to receive(:execute)
            .and_return(false)

          result = subject.execute

          expect(result[:status]).to eq :error
        end

        context 'when repository import scheduled' do
          it 'does not download lfs objects' do
            expect_any_instance_of(Projects::LfsPointers::LfsImportService).not_to receive(:execute)

            subject.execute
          end
        end
      end

      context 'with a non Github repository' do
        before do
          project.import_url = 'https://bitbucket.org/vim/vim.git'
          project.import_type = 'bitbucket'
        end

        context 'when importer supports refmap' do
          before do
            project.import_type = 'gitea'
          end

          it 'succeeds if repository fetch as mirror is successful' do
            expect(project).to receive(:ensure_repository)
            expect(project.repository).to receive(:fetch_as_mirror).with('https://bitbucket.org/vim/vim.git', refmap: Gitlab::LegacyGithubImport::Importer.refmap, resolved_address: '').and_return(true)
            expect_next_instance_of(Gitlab::LegacyGithubImport::Importer) do |importer|
              expect(importer).to receive(:execute).and_return(true)
            end

            expect_next_instance_of(Projects::LfsPointers::LfsImportService) do |service|
              expect(service).to receive(:execute).and_return(status: :success)
            end

            result = subject.execute

            expect(result[:status]).to eq :success
          end

          it 'fails if repository fetch as mirror fails' do
            expect(project).to receive(:ensure_repository)
            expect(project.repository)
              .to receive(:fetch_as_mirror)
              .and_raise(Gitlab::Git::CommandError, 'Failed to import the repository /a/b/c')

            result = subject.execute

            expect(result[:status]).to eq :error
            expect(result[:message]).to eq ""Error importing repository #{project.safe_import_url} into #{project.full_path} - Failed to import the repository [FILTERED]""
          end
        end

        context 'when importer does not support refmap' do
          it 'succeeds if repository import is successful' do
            expect_next_instance_of(Gitlab::BitbucketImport::ParallelImporter) do |importer|
              expect(importer).to receive(:execute).and_return(true)
            end

            result = subject.execute

            expect(result[:status]).to eq :success
          end

          it 'fails if repository import fails' do
            expect_next_instance_of(Gitlab::BitbucketImport::ParallelImporter) do |importer|
              expect(importer).to receive(:execute)
                .and_raise(Gitlab::Git::CommandError, 'Failed to import the repository /a/b/c')
            end

            result = subject.execute

            expect(result[:status]).to eq :error
            expect(result[:message]).to eq ""Error importing repository #{project.safe_import_url} into #{project.full_path} - Failed to import the repository [FILTERED]""
          end

          context 'when bitbucket_parallel_importer feature flag is disabled' do
            before do
              stub_feature_flags(bitbucket_parallel_importer: false)
            end

            it 'succeeds if repository import is successful' do
              expect(project.repository).to receive(:import_repository).and_return(true)
              expect_next_instance_of(Gitlab::BitbucketImport::Importer) do |importer|
                expect(importer).to receive(:execute).and_return(true)
              end

              expect_next_instance_of(Projects::LfsPointers::LfsImportService) do |service|
                expect(service).to receive(:execute).and_return(status: :success)
              end

              result = subject.execute

              expect(result[:status]).to eq :success
            end

            it 'fails if repository import fails' do
              expect(project.repository)
                .to receive(:import_repository)
                .with('https://bitbucket.org/vim/vim.git', resolved_address: '')
                .and_raise(Gitlab::Git::CommandError, 'Failed to import the repository /a/b/c')

              result = subject.execute

              expect(result[:status]).to eq :error
              expect(result[:message]).to eq ""Error importing repository #{project.safe_import_url} into #{project.full_path} - Failed to import the repository [FILTERED]""
            end

            context 'when lfs import fails' do
              it 'logs the error' do
                error_message = 'error message'

                expect(project.repository).to receive(:import_repository).and_return(true)

                expect_next_instance_of(Gitlab::BitbucketImport::Importer) do |importer|
                  expect(importer).to receive(:execute).and_return(true)
                end

                expect_next_instance_of(Projects::LfsPointers::LfsImportService) do |service|
                  expect(service).to receive(:execute).and_return(status: :error, message: error_message)
                end

                expect(Gitlab::AppLogger).to receive(:error).with(""The Lfs import process failed. #{error_message}"")

                subject.execute
              end
            end

            context 'when repository import scheduled' do
              before do
                expect(project.repository).to receive(:import_repository).and_return(true)
                allow(subject).to receive(:import_data)
              end

              it 'downloads lfs objects if lfs_enabled is enabled for project' do
                allow(project).to receive(:lfs_enabled?).and_return(true)

                expect_any_instance_of(Projects::LfsPointers::LfsImportService).to receive(:execute)

                subject.execute
              end

              it 'does not download lfs objects if lfs_enabled is not enabled for project' do
                allow(project).to receive(:lfs_enabled?).and_return(false)
                expect_any_instance_of(Projects::LfsPointers::LfsImportService).not_to receive(:execute)

                subject.execute
              end
            end
          end
        end
      end
    end

    context 'with valid importer' do
      before do
        provider = double(:provider).as_null_object
        stub_omniauth_setting(providers: [provider])

        project.import_url = 'https://github.com/vim/vim.git'
        project.import_type = 'github'

        allow(project).to receive(:import_data).and_return(double(:import_data).as_null_object)
      end

      it 'succeeds if importer succeeds' do
        allow_any_instance_of(Gitlab::GithubImport::ParallelImporter)
          .to receive(:execute).and_return(true)

        result = subject.execute

        expect(result[:status]).to eq :success
      end

      it 'fails if importer fails' do
        allow_any_instance_of(Gitlab::GithubImport::ParallelImporter)
          .to receive(:execute)
          .and_return(false)

        result = subject.execute

        expect(result[:status]).to eq :error
      end

      context 'when importer' do
        it 'has a custom repository importer it does not download lfs objects' do
          allow(Gitlab::GithubImport::ParallelImporter).to receive(:imports_repository?).and_return(true)

          expect_any_instance_of(Projects::LfsPointers::LfsImportService).not_to receive(:execute)

          subject.execute
        end

        it 'does not have a custom repository importer downloads lfs objects' do
          allow(Gitlab::GithubImport::ParallelImporter).to receive(:imports_repository?).and_return(false)

          expect_any_instance_of(Projects::LfsPointers::LfsImportService).to receive(:execute)

          subject.execute
        end

        context 'when lfs import fails' do
          it 'logs the error' do
            error_message = 'error message'

            allow(Gitlab::GithubImport::ParallelImporter).to receive(:imports_repository?).and_return(false)
            expect_any_instance_of(Projects::LfsPointers::LfsImportService).to receive(:execute).and_return(status: :error, message: error_message)
            expect(Gitlab::AppLogger).to receive(:error).with(""The Lfs import process failed. #{error_message}"")

            subject.execute
          end
        end
      end
    end

    context 'with blocked import_URL' do
      it 'fails with localhost' do
        project.import_url = 'https://localhost:9000/vim/vim.git'

        result = described_class.new(project, user).execute

        expect(result[:status]).to eq :error
        expect(result[:message]).to include('Requests to localhost are not allowed')
      end

      it 'fails with port 25' do
        project.import_url = ""https://github.com:25/vim/vim.git""

        result = subject.execute

        expect(result[:status]).to eq :error
        expect(result[:message]).to include('Only allowed ports are 80, 443')
      end

      it 'fails with file scheme' do
        project.import_url = ""file:///tmp/dir.git""

        result = subject.execute

        expect(result[:status]).to eq :error
        expect(result[:message]).to include('Only allowed schemes are http, https')
      end
    end

    context 'when import is a local request' do
      before do
        project.import_url = ""http://127.0.0.1/group/project""
      end

      context 'when local network requests are enabled' do
        before do
          stub_application_setting(allow_local_requests_from_web_hooks_and_services: true)
        end

        it 'returns an error' do
          expect(project.repository).not_to receive(:import_repository)
          expect(subject.execute).to include(
            status: :error,
            message: end_with('Requests to localhost are not allowed')
          )
        end

        context 'when environment is development' do
          before do
            stub_rails_env('development')
          end

          it 'imports successfully' do
            expect(project.repository)
              .to receive(:import_repository)
              .and_return(true)
            expect(subject.execute[:status]).to eq(:success)
          end
        end
      end
    end

    context 'when DNS rebind protection is disabled' do
      before do
        allow(Gitlab::CurrentSettings).to receive(:dns_rebinding_protection_enabled?).and_return(false)
        project.import_url = ""https://example.com/group/project""

        allow(Gitlab::UrlBlocker).to receive(:validate!)
          .with(
            project.import_url,
            ports: Project::VALID_IMPORT_PORTS,
            schemes: Project::VALID_IMPORT_PROTOCOLS,
            allow_local_network: false,
            allow_localhost: false,
            dns_rebind_protection: false
          )
          .and_return([Addressable::URI.parse(""https://example.com/group/project""), nil])
      end

      it 'imports repository with url without additional resolved address' do
        expect(project.repository).to receive(:import_repository).with('https://example.com/group/project', resolved_address: '').and_return(true)

        expect_next_instance_of(Projects::LfsPointers::LfsImportService) do |service|
          expect(service).to receive(:execute).and_return(status: :success)
        end

        result = subject.execute

        expect(result[:status]).to eq(:success)
      end
    end

    context 'when DNS rebind protection is enabled' do
      before do
        allow(Gitlab::CurrentSettings).to receive(:http_proxy_env?).and_return(false)
        allow(Gitlab::CurrentSettings).to receive(:dns_rebinding_protection_enabled?).and_return(true)
      end

      context 'when https url is provided' do
        before do
          project.import_url = ""https://example.com/group/project""

          allow(Gitlab::UrlBlocker).to receive(:validate!)
            .with(
              project.import_url,
              ports: Project::VALID_IMPORT_PORTS,
              schemes: Project::VALID_IMPORT_PROTOCOLS,
              allow_local_network: false,
              allow_localhost: false,
              dns_rebind_protection: true
            )
            .and_return([Addressable::URI.parse(""https://172.16.123.1/group/project""), 'example.com'])
        end

        it 'imports repository with url and additional resolved address' do
          expect(project.repository).to receive(:import_repository).with('https://example.com/group/project', resolved_address: '172.16.123.1').and_return(true)

          expect_next_instance_of(Projects::LfsPointers::LfsImportService) do |service|
            expect(service).to receive(:execute).and_return(status: :success)
          end

          result = subject.execute

          expect(result[:status]).to eq(:success)
        end

        context 'when host resolves to an IPv6 address' do
          before do
            project.import_url = 'https://gitlab.com/gitlab-org/gitlab-development-kit'

            allow(Gitlab::UrlBlocker).to receive(:validate!)
              .with(
                project.import_url,
                ports: Project::VALID_IMPORT_PORTS,
                schemes: Project::VALID_IMPORT_PROTOCOLS,
                allow_local_network: false,
                allow_localhost: false,
                dns_rebind_protection: true
              )
             .and_return([Addressable::URI.parse('https://[2606:4700:90:0:f22e:fbec:5bed:a9b9]/gitlab-org/gitlab-development-kit'), 'gitlab.com'])
          end

          it 'imports repository with url and additional resolved bare IPv6 address' do
            expect(project.repository).to receive(:import_repository).with('https://gitlab.com/gitlab-org/gitlab-development-kit', resolved_address: '2606:4700:90:0:f22e:fbec:5bed:a9b9').and_return(true)

            expect_next_instance_of(Projects::LfsPointers::LfsImportService) do |service|
              expect(service).to receive(:execute).and_return(status: :success)
            end

            result = subject.execute

            expect(result[:status]).to eq(:success)
          end
        end
      end

      context 'when http url is provided' do
        before do
          project.import_url = ""http://example.com/group/project""

          allow(Gitlab::UrlBlocker).to receive(:validate!)
            .with(
              project.import_url,
              ports: Project::VALID_IMPORT_PORTS,
              schemes: Project::VALID_IMPORT_PROTOCOLS,
              allow_local_network: false,
              allow_localhost: false,
              dns_rebind_protection: true
            )
            .and_return([Addressable::URI.parse(""http://172.16.123.1/group/project""), 'example.com'])
        end

        it 'imports repository with url and additional resolved address' do
          expect(project.repository).to receive(:import_repository).with('http://example.com/group/project', resolved_address: '172.16.123.1').and_return(true)

          expect_next_instance_of(Projects::LfsPointers::LfsImportService) do |service|
            expect(service).to receive(:execute).and_return(status: :success)
          end

          result = subject.execute

          expect(result[:status]).to eq(:success)
        end
      end

      context 'when git address is provided' do
        before do
          project.import_url = ""git://example.com/group/project.git""

          allow(Gitlab::UrlBlocker).to receive(:validate!)
            .with(
              project.import_url,
              ports: Project::VALID_IMPORT_PORTS,
              schemes: Project::VALID_IMPORT_PROTOCOLS,
              allow_local_network: false,
              allow_localhost: false,
              dns_rebind_protection: true
            )
            .and_return([Addressable::URI.parse(""git://172.16.123.1/group/project""), 'example.com'])
        end

        it 'imports repository with url and without resolved address' do
          expect(project.repository).to receive(:import_repository).with('git://example.com/group/project.git', resolved_address: '').and_return(true)

          expect_next_instance_of(Projects::LfsPointers::LfsImportService) do |service|
            expect(service).to receive(:execute).and_return(status: :success)
          end

          result = subject.execute

          expect(result[:status]).to eq(:success)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  # Service class for counting and caching the number of open merge requests of
  # a project.
  class OpenMergeRequestsCountService < Projects::CountService
    def cache_key_name
      'open_merge_requests_count'
    end

    def self.query(project_ids)
      MergeRequest.opened.of_projects(project_ids)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::OpenMergeRequestsCountService, :use_clean_rails_memory_store_caching, feature_category: :code_review_workflow do
  let_it_be(:project) { create(:project) }

  subject { described_class.new(project) }

  it_behaves_like 'a counter caching service'

  describe '#count' do
    it 'returns the number of open merge requests' do
      create(:merge_request, :opened, source_project: project, target_project: project)

      expect(subject.count).to eq(1)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  # Service class that can be used to execute actions necessary after creating a
  # default branch.
  class ProtectDefaultBranchService
    attr_reader :project, :default_branch_protection

    # @param [Project] project
    def initialize(project)
      @project = project

      @default_branch_protection = Gitlab::Access::BranchProtection
        .new(project.namespace.default_branch_protection)
    end

    def execute
      protect_default_branch if default_branch
    end

    def protect_default_branch
      # Ensure HEAD points to the default branch in case it is not master
      project.change_head(default_branch)

      create_protected_branch if protect_branch? && !protected_branch_exists?
    end

    def create_protected_branch
      params = {
        name: default_branch,
        push_access_levels_attributes: [{ access_level: push_access_level }],
        merge_access_levels_attributes: [{ access_level: merge_access_level }]
      }

      # The creator of the project is always allowed to create protected
      # branches, so we skip the authorization check in this service class.
      ProtectedBranches::CreateService
        .new(project, project.creator, params)
        .execute(skip_authorization: true)
    end

    def protect_branch?
      default_branch_protection.any? &&
        !ProtectedBranch.protected?(project, default_branch)
    end

    def protected_branch_exists?
      project.all_protected_branches.find_by_name(default_branch).present?
    end

    def default_branch
      project.default_branch
    end

    def push_access_level
      if default_branch_protection.developer_can_push?
        Gitlab::Access::DEVELOPER
      else
        Gitlab::Access::MAINTAINER
      end
    end

    def merge_access_level
      if default_branch_protection.developer_can_merge?
        Gitlab::Access::DEVELOPER
      else
        Gitlab::Access::MAINTAINER
      end
    end
  end
end

Projects::ProtectDefaultBranchService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::ProtectDefaultBranchService, feature_category: :source_code_management do
  let(:service) { described_class.new(project) }
  let(:project) { create(:project) }

  describe '#execute' do
    before do
      allow(service)
        .to receive(:protect_default_branch)
    end

    context 'without a default branch' do
      it 'does nothing' do
        allow(service)
          .to receive(:default_branch)
          .and_return(nil)

        service.execute

        expect(service)
          .not_to have_received(:protect_default_branch)
      end
    end

    context 'with a default branch' do
      it 'protects the default branch' do
        allow(service)
          .to receive(:default_branch)
          .and_return('master')

        service.execute

        expect(service)
          .to have_received(:protect_default_branch)
      end
    end
  end

  describe '#protect_default_branch' do
    before do
      allow(service)
        .to receive(:default_branch)
        .and_return('master')

      allow(project)
        .to receive(:change_head)
        .with('master')

      allow(service)
        .to receive(:create_protected_branch)
    end

    context 'when branch protection is needed' do
      before do
        allow(service)
          .to receive(:protect_branch?)
          .and_return(true)

        allow(service)
          .to receive(:create_protected_branch)
      end

      it 'changes the HEAD of the project' do
        service.protect_default_branch

        expect(project)
          .to have_received(:change_head)
      end

      it 'protects the default branch' do
        service.protect_default_branch

        expect(service)
          .to have_received(:create_protected_branch)
      end
    end

    context 'when branch protection is not needed' do
      before do
        allow(service)
          .to receive(:protect_branch?)
          .and_return(false)
      end

      it 'changes the HEAD of the project' do
        service.protect_default_branch

        expect(project)
          .to have_received(:change_head)
      end

      it 'does not protect the default branch' do
        service.protect_default_branch

        expect(service)
          .not_to have_received(:create_protected_branch)
      end
    end

    context 'when protected branch does not exist' do
      before do
        allow(service)
          .to receive(:protected_branch_exists?)
                .and_return(false)
        allow(service)
          .to receive(:protect_branch?)
                .and_return(true)
      end

      it 'changes the HEAD of the project' do
        service.protect_default_branch

        expect(project)
          .to have_received(:change_head)
      end

      it 'protects the default branch' do
        service.protect_default_branch

        expect(service)
          .to have_received(:create_protected_branch)
      end
    end

    context 'when protected branch already exists' do
      before do
        allow(service)
          .to receive(:protected_branch_exists?)
                .and_return(true)
      end

      it 'changes the HEAD of the project' do
        service.protect_default_branch

        expect(project)
          .to have_received(:change_head)
      end

      it 'does not protect the default branch' do
        service.protect_default_branch

        expect(service)
          .not_to have_received(:create_protected_branch)
      end
    end
  end

  describe '#create_protected_branch' do
    it 'creates the protected branch' do
      creator = instance_spy(User)
      create_service = instance_spy(ProtectedBranches::CreateService)
      access_level = Gitlab::Access::DEVELOPER
      params = {
        name: 'master',
        push_access_levels_attributes: [{ access_level: access_level }],
        merge_access_levels_attributes: [{ access_level: access_level }]
      }

      allow(project)
        .to receive(:creator)
        .and_return(creator)

      allow(ProtectedBranches::CreateService)
        .to receive(:new)
        .with(project, creator, params)
        .and_return(create_service)

      allow(service)
        .to receive(:push_access_level)
        .and_return(access_level)

      allow(service)
        .to receive(:merge_access_level)
        .and_return(access_level)

      allow(service)
        .to receive(:default_branch)
        .and_return('master')

      allow(create_service)
        .to receive(:execute)
        .with(skip_authorization: true)

      service.create_protected_branch

      expect(create_service)
        .to have_received(:execute)
    end
  end

  describe '#protect_branch?' do
    context 'when default branch protection is disabled' do
      it 'returns false' do
        allow(project.namespace)
          .to receive(:default_branch_protection)
          .and_return(Gitlab::Access::PROTECTION_NONE)

        expect(service.protect_branch?).to eq(false)
      end
    end

    context 'when default branch protection is enabled' do
      before do
        allow(project.namespace)
          .to receive(:default_branch_protection)
          .and_return(Gitlab::Access::PROTECTION_DEV_CAN_MERGE)

        allow(service)
          .to receive(:default_branch)
          .and_return('master')
      end

      it 'returns false if the branch is already protected' do
        allow(ProtectedBranch)
          .to receive(:protected?)
          .with(project, 'master')
          .and_return(true)

        expect(service.protect_branch?).to eq(false)
      end

      it 'returns true if the branch is not yet protected' do
        allow(ProtectedBranch)
          .to receive(:protected?)
          .with(project, 'master')
          .and_return(false)

        expect(service.protect_branch?).to eq(true)
      end
    end
  end

  describe '#protected_branch_exists?' do
    let_it_be(:group) { create(:group) }
    let_it_be(:project) { create(:project, group: group) }

    let(:default_branch) { ""default-branch"" }

    before do
      allow(project).to receive(:default_branch).and_return(default_branch)
      create(:protected_branch, project: nil, group: group, name: default_branch)
    end

    context 'when feature flag `group_protected_branches` disabled' do
      before do
        stub_feature_flags(group_protected_branches: false)
        stub_feature_flags(allow_protected_branches_for_group: false)
      end

      it 'return false' do
        expect(service.protected_branch_exists?).to eq(false)
      end
    end

    context 'when feature flag `group_protected_branches` enabled' do
      before do
        stub_feature_flags(group_protected_branches: true)
        stub_feature_flags(allow_protected_branches_for_group: true)
      end

      it 'return true' do
        expect(service.protected_branch_exists?).to eq(true)
      end
    end
  end

  describe '#default_branch' do
    it 'returns the default branch of the project' do
      allow(project)
        .to receive(:default_branch)
        .and_return('master')

      expect(service.default_branch).to eq('master')
    end
  end

  describe '#push_access_level' do
    context 'when developers can push' do
      it 'returns the DEVELOPER access level' do
        allow(project.namespace)
          .to receive(:default_branch_protection)
          .and_return(Gitlab::Access::PROTECTION_DEV_CAN_PUSH)

        expect(service.push_access_level).to eq(Gitlab::Access::DEVELOPER)
      end
    end

    context 'when developers can not push' do
      it 'returns the MAINTAINER access level' do
        allow(project.namespace)
          .to receive(:default_branch_protection)
          .and_return(Gitlab::Access::PROTECTION_DEV_CAN_MERGE)

        expect(service.push_access_level).to eq(Gitlab::Access::MAINTAINER)
      end
    end
  end

  describe '#merge_access_level' do
    context 'when developers can merge' do
      it 'returns the DEVELOPER access level' do
        allow(project.namespace)
          .to receive(:default_branch_protection)
          .and_return(Gitlab::Access::PROTECTION_DEV_CAN_MERGE)

        expect(service.merge_access_level).to eq(Gitlab::Access::DEVELOPER)
      end
    end

    context 'when developers can not merge' do
      it 'returns the MAINTAINER access level' do
        allow(project.namespace)
          .to receive(:default_branch_protection)
          .and_return(Gitlab::Access::PROTECTION_DEV_CAN_PUSH)

        expect(service.merge_access_level).to eq(Gitlab::Access::MAINTAINER)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class UpdateRepositoryStorageService
    include UpdateRepositoryStorageMethods

    delegate :project, to: :repository_storage_move

    private

    def track_repository(destination_storage_name)
      project.update_column(:repository_storage, destination_storage_name)

      # Connect project to pool repository from the new shard
      project.swap_pool_repository!

      # Connect project to the repository from the new shard
      project.track_project_repository

      # Link repository from the new shard to pool repository from the new shard
      project.link_pool_repository if replicate_object_pool_on_move_ff_enabled?
    end

    def mirror_repositories
      if project.repository_exists?
        mirror_repository(type: Gitlab::GlRepository::PROJECT)
      end

      if project.wiki.repository_exists?
        mirror_repository(type: Gitlab::GlRepository::WIKI)
      end

      if project.design_repository.exists?
        mirror_repository(type: ::Gitlab::GlRepository::DESIGN)
      end
    end

    def mirror_object_pool(destination_storage_name)
      return unless replicate_object_pool_on_move_ff_enabled?
      return unless project.repository_exists?

      pool_repository = project.pool_repository
      return unless pool_repository

      # If pool repository already exists, then we will link the moved project repository to it
      return if pool_repository_exists_for?(shard_name: destination_storage_name, pool_repository: pool_repository)

      target_pool_repository = create_pool_repository_for!(
        shard_name: destination_storage_name,
        pool_repository: pool_repository
      )

      Repositories::ReplicateService.new(pool_repository.object_pool.repository)
        .execute(target_pool_repository.object_pool.repository, :object_pool)
    end

    def remove_old_paths
      super

      if project.wiki.repository_exists?
        Gitlab::Git::Repository.new(
          source_storage_name,
          ""#{project.wiki.disk_path}.git"",
          nil,
          nil
        ).remove
      end

      if project.design_repository.exists?
        Gitlab::Git::Repository.new(
          source_storage_name,
          ""#{project.design_repository.disk_path}.git"",
          nil,
          nil
        ).remove
      end
    end

    def pool_repository_exists_for?(shard_name:, pool_repository:)
      PoolRepository.by_disk_path_and_shard_name(
        pool_repository.disk_path,
        shard_name
      ).exists?
    end

    def create_pool_repository_for!(shard_name:, pool_repository:)
      # Set state `ready` because we manually replicate object pool
      PoolRepository.create!(
        shard: Shard.by_name(shard_name),
        source_project: pool_repository.source_project,
        disk_path: pool_repository.disk_path,
        state: 'ready'
      )
    end

    def replicate_object_pool_on_move_ff_enabled?
      Feature.enabled?(:replicate_object_pool_on_move, project)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::UpdateRepositoryStorageService, feature_category: :source_code_management do
  include Gitlab::ShellAdapter

  subject { described_class.new(repository_storage_move) }

  describe ""#execute"" do
    let(:time) { Time.current }

    before do
      allow(Time).to receive(:now).and_return(time)

      stub_storage_settings('test_second_storage' => {})
    end

    context 'without wiki and design repository' do
      let!(:shard_default) { create(:shard, name: 'default') }
      let!(:shard_second_storage) { create(:shard, name: 'test_second_storage') }

      let(:project) { create(:project, :repository, wiki_enabled: false) }
      let(:destination) { 'test_second_storage' }
      let(:repository_storage_move) { create(:project_repository_storage_move, :scheduled, container: project, destination_storage_name: destination) }
      let!(:checksum) { project.repository.checksum }
      let(:project_repository_double) { double(:repository) }
      let(:original_project_repository_double) { double(:repository) }

      let(:object_pool_double) { double(:object_pool, repository: object_pool_repository_double) }
      let(:object_pool_repository_double) { double(:repository) }

      let(:original_object_pool_double) { double(:object_pool, repository: original_object_pool_repository_double) }
      let(:original_object_pool_repository_double) { double(:repository) }

      before do
        allow(Gitlab::GitalyClient).to receive(:filesystem_id).with('default').and_call_original
        allow(Gitlab::GitalyClient).to receive(:filesystem_id).with('test_second_storage').and_return(SecureRandom.uuid)
        allow(Gitlab::Git::Repository).to receive(:new).and_call_original
        allow(Gitlab::Git::Repository).to receive(:new)
          .with('test_second_storage', project.repository.raw.relative_path, project.repository.gl_repository, project.repository.full_path)
          .and_return(project_repository_double)
        allow(Gitlab::Git::Repository).to receive(:new)
          .with('default', project.repository.raw.relative_path, nil, nil)
          .and_return(original_project_repository_double)

        allow(Gitlab::Git::ObjectPool).to receive(:new).and_call_original
        allow(Gitlab::Git::ObjectPool).to receive(:new)
          .with('test_second_storage', anything, anything, anything)
          .and_return(object_pool_double)
        allow(Gitlab::Git::ObjectPool).to receive(:new)
          .with('default', anything, anything, anything)
          .and_return(original_object_pool_double)

        allow(original_object_pool_double).to receive(:create)
        allow(object_pool_double).to receive(:create)
      end

      context 'when the move succeeds' do
        it 'moves the repository to the new storage and unmarks the repository as read-only' do
          expect(project_repository_double).to receive(:replicate)
            .with(project.repository.raw)
          expect(project_repository_double).to receive(:checksum)
            .and_return(checksum)
          expect(original_project_repository_double).to receive(:remove)

          result = subject.execute
          project.reload

          expect(result).to be_success
          expect(project).not_to be_repository_read_only
          expect(project.repository_storage).to eq('test_second_storage')
          expect(project.project_repository.shard_name).to eq('test_second_storage')
          expect(repository_storage_move.reload).to be_finished
          expect(repository_storage_move.error_message).to be_nil
        end
      end

      context 'when touch raises an exception' do
        let(:exception) { RuntimeError.new('Boom') }

        it 'marks the storage move as failed and restores read-write access' do
          allow(repository_storage_move).to receive(:container).and_return(project)

          allow(project).to receive(:touch).and_wrap_original do
            project.assign_attributes(updated_at: 1.second.ago)
            raise exception
          end

          expect(project_repository_double).to receive(:replicate)
            .with(project.repository.raw)
          expect(project_repository_double).to receive(:checksum)
            .and_return(checksum)

          expect { subject.execute }.to raise_error(exception)
          project.reload

          expect(project).not_to be_repository_read_only
          expect(repository_storage_move.reload).to be_failed
          expect(repository_storage_move.error_message).to eq('Boom')
        end
      end

      context 'when the filesystems are the same' do
        before do
          expect(Gitlab::GitalyClient).to receive(:filesystem_id).twice.and_return(SecureRandom.uuid)
        end

        it 'updates the database without trying to move the repostory', :aggregate_failures do
          result = subject.execute
          project.reload

          expect(result).to be_success
          expect(project).not_to be_repository_read_only
          expect(project.repository_storage).to eq('test_second_storage')
          expect(project.project_repository.shard_name).to eq('test_second_storage')
        end
      end

      context 'when the move fails' do
        it 'unmarks the repository as read-only without updating the repository storage' do
          allow(Gitlab::GitalyClient).to receive(:filesystem_id).with('default').and_call_original
          allow(Gitlab::GitalyClient).to receive(:filesystem_id).with('test_second_storage').and_return(SecureRandom.uuid)

          expect(project_repository_double).to receive(:replicate)
            .with(project.repository.raw)
            .and_raise(Gitlab::Git::CommandError, 'Boom')
          expect(project_repository_double).to receive(:remove)

          expect do
            subject.execute
          end.to raise_error(Gitlab::Git::CommandError)

          expect(project).not_to be_repository_read_only
          expect(project.repository_storage).to eq('default')
          expect(repository_storage_move).to be_failed
          expect(repository_storage_move.error_message).to eq('Boom')
        end
      end

      context 'when the cleanup fails' do
        it 'sets the correct state' do
          expect(project_repository_double).to receive(:replicate)
            .with(project.repository.raw)
          expect(project_repository_double).to receive(:checksum)
            .and_return(checksum)
          expect(original_project_repository_double).to receive(:remove)
            .and_raise(Gitlab::Git::CommandError)

          expect do
            subject.execute
          end.to raise_error(Gitlab::Git::CommandError)

          expect(repository_storage_move).to be_cleanup_failed
        end
      end

      context 'when the checksum does not match' do
        it 'unmarks the repository as read-only without updating the repository storage' do
          allow(Gitlab::GitalyClient).to receive(:filesystem_id).with('default').and_call_original
          allow(Gitlab::GitalyClient).to receive(:filesystem_id).with('test_second_storage').and_return(SecureRandom.uuid)

          expect(project_repository_double).to receive(:replicate)
            .with(project.repository.raw)
          expect(project_repository_double).to receive(:checksum)
            .and_return('not matching checksum')
          expect(project_repository_double).to receive(:remove)

          expect do
            subject.execute
          end.to raise_error(Repositories::ReplicateService::Error, /Failed to verify project repository checksum/)

          expect(project).not_to be_repository_read_only
          expect(project.repository_storage).to eq('default')
        end
      end

      context 'with repository pool' do
        let(:shard_from) { shard_default }
        let(:shard_to) { shard_second_storage }
        let(:old_object_pool_checksum) { 'abcd' }
        let(:new_object_pool_checksum) { old_object_pool_checksum }

        before do
          allow(project_repository_double).to receive(:replicate).with(project.repository.raw)
          allow(project_repository_double).to receive(:checksum).and_return(checksum)
          allow(original_project_repository_double).to receive(:remove)

          allow(object_pool_repository_double).to receive(:replicate).with(original_object_pool_repository_double)
          allow(object_pool_repository_double).to receive(:checksum).and_return(new_object_pool_checksum)
          allow(original_object_pool_repository_double).to receive(:checksum).and_return(old_object_pool_checksum)

          allow(object_pool_double).to receive(:link) do |repository|
            expect(repository.storage).to eq 'test_second_storage'
          end
        end

        context 'when project had a repository pool' do
          let!(:pool_repository) { create(:pool_repository, :ready, shard: shard_from, source_project: project) }

          it 'creates a new repository pool and connects project to it' do
            result = subject.execute
            expect(result).to be_success

            project.reload.cleanup

            new_pool_repository = project.pool_repository

            expect(new_pool_repository).not_to eq(pool_repository)
            expect(new_pool_repository.shard).to eq(shard_second_storage)
            expect(new_pool_repository.state).to eq('ready')
            expect(new_pool_repository.disk_path).to eq(pool_repository.disk_path)
            expect(new_pool_repository.source_project).to eq(project)

            expect(object_pool_double).to have_received(:link).with(project.repository.raw)
          end

          context 'when feature flag replicate_object_pool_on_move is disabled' do
            before do
              stub_feature_flags(replicate_object_pool_on_move: false)
            end

            it 'just moves the repository without the object pool' do
              result = subject.execute
              expect(result).to be_success

              project.reload.cleanup

              new_pool_repository = project.pool_repository

              expect(new_pool_repository).to eq(pool_repository)
              expect(new_pool_repository.shard).to eq(shard_default)
              expect(new_pool_repository.state).to eq('ready')
              expect(new_pool_repository.source_project).to eq(project)

              expect(object_pool_repository_double).not_to have_received(:replicate)
              expect(object_pool_double).not_to have_received(:link)
            end
          end

          context 'when new shard has a repository pool' do
            let!(:new_pool_repository) { create(:pool_repository, :ready, shard: shard_to, source_project: project) }

            it 'connects project to it' do
              result = subject.execute
              expect(result).to be_success

              project.reload.cleanup

              project_pool_repository = project.pool_repository

              expect(project_pool_repository).to eq(new_pool_repository)
              expect(object_pool_double).to have_received(:link).with(project.repository.raw)
            end
          end

          context 'when new shard has a repository pool without the root project' do
            let!(:new_pool_repository) { create(:pool_repository, :ready, shard: shard_to, disk_path: pool_repository.disk_path) }

            before do
              pool_repository.update!(source_project: nil)
              new_pool_repository.update!(source_project: nil)
            end

            it 'connects project to it' do
              result = subject.execute
              expect(result).to be_success

              project.reload.cleanup

              project_pool_repository = project.pool_repository

              expect(project_pool_repository).to eq(new_pool_repository)
              expect(object_pool_double).to have_received(:link).with(project.repository.raw)
            end
          end

          context 'when repository does not exist' do
            let(:project) { create(:project) }
            let(:checksum) { nil }

            it 'does not mirror object pool' do
              result = subject.execute
              expect(result).to be_success

              expect(object_pool_repository_double).not_to have_received(:replicate)
            end
          end

          context 'when project belongs to repository pool, but not as a root project' do
            let!(:another_project) { create(:project, :repository) }
            let!(:pool_repository) { create(:pool_repository, :ready, shard: shard_from, source_project: another_project) }

            before do
              project.update!(pool_repository: pool_repository)
            end

            it 'creates a new repository pool and connects project to it' do
              result = subject.execute
              expect(result).to be_success

              project.reload.cleanup

              new_pool_repository = project.pool_repository

              expect(new_pool_repository).not_to eq(pool_repository)
              expect(new_pool_repository.shard).to eq(shard_second_storage)
              expect(new_pool_repository.state).to eq('ready')
              expect(new_pool_repository.source_project).to eq(another_project)

              expect(object_pool_double).to have_received(:link).with(project.repository.raw)
            end
          end

          context 'when project belongs to the repository pool without a root project' do
            let!(:pool_repository) { create(:pool_repository, :ready, shard: shard_from) }

            before do
              pool_repository.update!(source_project: nil)
              project.update!(pool_repository: pool_repository)
            end

            it 'creates a new repository pool without a root project and connects project to it' do
              result = subject.execute
              expect(result).to be_success

              project.reload.cleanup

              new_pool_repository = project.pool_repository

              expect(new_pool_repository).not_to eq(pool_repository)
              expect(new_pool_repository.shard).to eq(shard_second_storage)
              expect(new_pool_repository.state).to eq('ready')
              expect(new_pool_repository.source_project).to eq(nil)
              expect(new_pool_repository.disk_path).to eq(pool_repository.disk_path)

              expect(object_pool_double).to have_received(:link).with(project.repository.raw)
            end
          end

          context 'when object pool checksum does not match' do
            let(:new_object_pool_checksum) { 'not_match' }

            it 'raises an error and removes the new object pool repository' do
              expect(object_pool_repository_double).to receive(:remove)

              original_count = PoolRepository.count

              expect do
                subject.execute
              end.to raise_error(Repositories::ReplicateService::Error, /Failed to verify object_pool repository/)

              project.reload

              expect(PoolRepository.count).to eq(original_count)

              expect(project.pool_repository).to eq(pool_repository)
              expect(project.repository.shard).to eq('default')
            end
          end
        end
      end

      context 'when the repository move is finished' do
        let(:repository_storage_move) { create(:project_repository_storage_move, :finished, container: project, destination_storage_name: destination) }

        it 'is idempotent' do
          expect do
            result = subject.execute

            expect(result).to be_success
          end.not_to change(repository_storage_move, :state)
        end
      end

      context 'when the repository move is failed' do
        let(:repository_storage_move) { create(:project_repository_storage_move, :failed, container: project, destination_storage_name: destination) }

        it 'is idempotent' do
          expect do
            result = subject.execute

            expect(result).to be_success
          end.not_to change(repository_storage_move, :state)
        end
      end
    end

    context 'project with no repositories' do
      let(:project) { create(:project) }
      let(:repository_storage_move) { create(:project_repository_storage_move, :scheduled, container: project, destination_storage_name: 'test_second_storage') }

      it 'updates the database' do
        allow(Gitlab::GitalyClient).to receive(:filesystem_id).with('default').and_call_original
        allow(Gitlab::GitalyClient).to receive(:filesystem_id).with('test_second_storage').and_return(SecureRandom.uuid)

        result = subject.execute
        project.reload

        expect(result).to be_success
        expect(project).not_to be_repository_read_only
        expect(project.repository_storage).to eq('test_second_storage')
        expect(project.project_repository.shard_name).to eq('test_second_storage')
      end
    end

    context 'with wiki repository' do
      include_examples 'moves repository to another storage', 'wiki' do
        let(:project) { create(:project, :repository, wiki_enabled: true) }
        let(:repository) { project.wiki.repository }
        let(:destination) { 'test_second_storage' }
        let(:repository_storage_move) { create(:project_repository_storage_move, :scheduled, container: project, destination_storage_name: destination) }

        before do
          project.create_wiki
        end
      end
    end

    context 'with design repository' do
      include_examples 'moves repository to another storage', 'design' do
        let(:project) { create(:project, :repository) }
        let(:repository) { project.design_repository }
        let(:destination) { 'test_second_storage' }
        let(:repository_storage_move) { create(:project_repository_storage_move, :scheduled, container: project, destination_storage_name: destination) }

        before do
          project.design_repository.create_if_not_exists
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class FetchStatisticsIncrementService
    attr_reader :project

    def initialize(project)
      @project = project
    end

    def execute
      increment_fetch_count_sql = <<~SQL
        INSERT INTO #{table_name} (project_id, date, fetch_count)
        VALUES (#{project.id}, '#{Date.today}', 1)
        ON CONFLICT (project_id, date) DO UPDATE SET fetch_count = #{table_name}.fetch_count + 1
      SQL

      ProjectDailyStatistic.connection.execute(increment_fetch_count_sql)
    end

    private

    def table_name
      ProjectDailyStatistic.table_name
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

module Projects
  RSpec.describe FetchStatisticsIncrementService, feature_category: :groups_and_projects do
    let(:project) { create(:project) }

    describe '#execute' do
      subject { described_class.new(project).execute }

      it 'creates a new record for today with count == 1' do
        expect { subject }.to change { ProjectDailyStatistic.count }.by(1)
        created_stat = ProjectDailyStatistic.last

        expect(created_stat.fetch_count).to eq(1)
        expect(created_stat.project).to eq(project)
        expect(created_stat.date).to eq(Date.today)
      end

      it ""doesn't increment previous days statistics"" do
        yesterday_stat = create(:project_daily_statistic, fetch_count: 5, project: project, date: 1.day.ago)

        expect { subject }.not_to change { yesterday_stat.reload.fetch_count }
      end

      context 'when the record already exists for today' do
        let!(:project_daily_stat) { create(:project_daily_statistic, fetch_count: 5, project: project, date: Date.today) }

        it 'increments the today record count by 1' do
          expect { subject }.to change { project_daily_stat.reload.fetch_count }.to(6)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class UpdatePagesService < BaseService
    include Gitlab::Utils::StrongMemoize

    # old deployment can be cached by pages daemon
    # so we need to give pages daemon some time update cache
    # 10 minutes is enough, but 30 feels safer
    OLD_DEPLOYMENTS_DESTRUCTION_DELAY = 30.minutes

    attr_reader :build, :deployment_update

    def initialize(project, build)
      @project = project
      @build = build
      @deployment_update = ::Gitlab::Pages::DeploymentUpdate.new(project, build)
    end

    def execute
      register_attempt

      ::Ci::Pipelines::AddJobService.new(@build.pipeline).execute!(commit_status) do |job|
        job.enqueue!
        job.run!
      end

      return error(deployment_update.errors.first.full_message) unless deployment_update.valid?

      build.artifacts_file.use_file do |artifacts_path|
        deployment = create_pages_deployment(artifacts_path, build)

        break error('The uploaded artifact size does not match the expected value') unless deployment
        break error(deployment_update.errors.first.full_message) unless deployment_update.valid?

        deactive_old_deployments(deployment)
        success
      end
    rescue StandardError => e
      error(e.message)
      raise e
    end

    private

    def success
      commit_status.success
      publish_deployed_event
      super
    end

    def error(message)
      register_failure
      log_error(""Projects::UpdatePagesService: #{message}"")
      commit_status.allow_failure = !deployment_update.latest?
      commit_status.description = message
      commit_status.drop(:script_failure)
      super
    end

    # Create status notifying the deployment of pages
    def commit_status
      GenericCommitStatus.new(
        user: build.user,
        ci_stage: stage,
        name: 'pages:deploy',
        stage: 'deploy',
        stage_idx: stage.position
      )
    end
    strong_memoize_attr :commit_status

    # rubocop: disable Performance/ActiveRecordSubtransactionMethods
    def stage
      build.pipeline.stages.safe_find_or_create_by(name: 'deploy', pipeline_id: build.pipeline.id) do |stage|
        stage.position = GenericCommitStatus::EXTERNAL_STAGE_IDX
        stage.project = build.project
      end
    end
    strong_memoize_attr :commit_status
    # rubocop: enable Performance/ActiveRecordSubtransactionMethods

    def create_pages_deployment(artifacts_path, build)
      File.open(artifacts_path) do |file|
        attributes = pages_deployment_attributes(file, build)
        deployment = project.pages_deployments.build(**attributes)

        break if deployment.file.size != file.size

        deployment.tap(&:save!)
      end
    end

    # overridden on EE
    def pages_deployment_attributes(file, build)
      {
        file: file,
        file_count: deployment_update.entries_count,
        file_sha256: build.job_artifacts_archive.file_sha256,
        ci_build_id: build.id,
        root_directory: build.options[:publish],
        upload_ready: false
      }
    end

    def deactive_old_deployments(deployment)
      PagesDeployment.deactivate_deployments_older_than(
        deployment,
        time: OLD_DEPLOYMENTS_DESTRUCTION_DELAY.from_now)
    end

    def register_attempt
      pages_deployments_total_counter.increment
    end

    def register_failure
      pages_deployments_failed_total_counter.increment
    end

    def pages_deployments_total_counter
      Gitlab::Metrics.counter(:pages_deployments_total, ""Counter of GitLab Pages deployments triggered"")
    end
    strong_memoize_attr :pages_deployments_total_counter

    def pages_deployments_failed_total_counter
      Gitlab::Metrics.counter(:pages_deployments_failed_total, ""Counter of GitLab Pages deployments which failed"")
    end
    strong_memoize_attr :pages_deployments_failed_total_counter

    def publish_deployed_event
      event = ::Pages::PageDeployedEvent.new(data: {
        project_id: project.id,
        namespace_id: project.namespace_id,
        root_namespace_id: project.root_namespace.id
      })

      Gitlab::EventStore.publish(event)
    end
  end
end

::Projects::UpdatePagesService.prepend_mod

```","# frozen_string_literal: true

require ""spec_helper""

RSpec.describe Projects::UpdatePagesService, feature_category: :pages do
  let_it_be(:project, refind: true) { create(:project, :repository) }

  let_it_be(:old_pipeline) { create(:ci_pipeline, project: project, sha: project.commit('HEAD').sha) }
  let_it_be(:pipeline) { create(:ci_pipeline, project: project, sha: project.commit('HEAD').sha) }

  let(:options) { {} }
  let(:build) { create(:ci_build, pipeline: pipeline, ref: 'HEAD', options: options) }
  let(:invalid_file) { fixture_file_upload('spec/fixtures/dk.png') }

  let(:file) { fixture_file_upload(""spec/fixtures/pages.zip"") }
  let(:custom_root_file) { fixture_file_upload(""spec/fixtures/pages_with_custom_root.zip"") }
  let(:empty_file) { fixture_file_upload(""spec/fixtures/pages_empty.zip"") }
  let(:empty_metadata_filename) { ""spec/fixtures/pages_empty.zip.meta"" }
  let(:metadata_filename) { ""spec/fixtures/pages.zip.meta"" }
  let(:custom_root_file_metadata) { ""spec/fixtures/pages_with_custom_root.zip.meta"" }
  let(:metadata) { fixture_file_upload(metadata_filename) if File.exist?(metadata_filename) }

  subject(:service) { described_class.new(project, build) }

  RSpec.shared_examples 'old deployments' do
    it 'deactivates old deployments from the same project with the same path prefix', :freeze_time do
      other_project = create(:pages_deployment)
      same_project_other_path_prefix = create(:pages_deployment, project: project, path_prefix: 'other')
      same_project = create(:pages_deployment, project: project)

      expect { expect(service.execute[:status]).to eq(:success) }
        .to not_change { other_project.reload.deleted_at }
        .and not_change { same_project_other_path_prefix.reload.deleted_at }
        .and change { same_project.reload.deleted_at }
        .from(nil).to(described_class::OLD_DEPLOYMENTS_DESTRUCTION_DELAY.from_now)
    end
  end

  RSpec.shared_examples 'pages size limit is' do |size_limit|
    context ""when size is below the limit"" do
      before do
        allow(metadata).to receive(:total_size).and_return(size_limit - 1.megabyte)
        allow(metadata).to receive(:entries).and_return([])
      end

      it 'updates pages correctly' do
        subject.execute

        deploy_status = GenericCommitStatus.last
        expect(deploy_status.description).not_to be_present
        expect(project.pages_deployed?).to eq(true)
      end

      it_behaves_like 'old deployments'
    end

    context ""when size is above the limit"" do
      before do
        allow(metadata).to receive(:total_size).and_return(size_limit + 1.megabyte)
        allow(metadata).to receive(:entries).and_return([])
      end

      it 'limits the maximum size of gitlab pages' do
        subject.execute

        deploy_status = GenericCommitStatus.last
        expect(deploy_status.description).to match(/artifacts for pages are too large/)
        expect(deploy_status).to be_script_failure
      end
    end
  end

  context 'when a deploy stage already exists', :aggregate_failures do
    let!(:stage) { create(:ci_stage, name: 'deploy', pipeline: pipeline) }

    it 'assigns the deploy stage' do
      expect { service.execute }
        .to change(GenericCommitStatus, :count).by(1)
        .and change(Ci::Stage.where(name: 'deploy'), :count).by(0)

      status = GenericCommitStatus.last

      expect(status.ci_stage).to eq(stage)
      expect(status.ci_stage.name).to eq('deploy')
      expect(status.stage_name).to eq('deploy')
      expect(status.stage).to eq('deploy')
    end
  end

  context 'when a deploy stage does not exists' do
    it 'assigns the deploy stage' do
      expect { service.execute }
        .to change(GenericCommitStatus, :count).by(1)
        .and change(Ci::Stage.where(name: 'deploy'), :count).by(1)

      status = GenericCommitStatus.last

      expect(status.ci_stage.name).to eq('deploy')
      expect(status.stage_name).to eq('deploy')
      expect(status.stage).to eq('deploy')
    end
  end

  context 'for new artifacts' do
    context ""for a valid job"" do
      let!(:artifacts_archive) { create(:ci_job_artifact, :correct_checksum, file: file, job: build) }

      before do
        create(:ci_job_artifact, file_type: :metadata, file_format: :gzip, file: metadata, job: build)

        build.reload
      end

      it_behaves_like 'old deployments'

      it ""doesn't delete artifacts after deploying"" do
        expect(service.execute[:status]).to eq(:success)

        expect(project.pages_deployed?).to eq(true)
        expect(build.artifacts?).to eq(true)
      end

      it 'succeeds' do
        expect { expect(service.execute[:status]).to eq(:success) }
          .to change { project.pages_deployed? }
          .from(false).to(true)
      end

      it 'publishes a PageDeployedEvent event with project id and namespace id' do
        expected_data = {
          project_id: project.id,
          namespace_id: project.namespace_id,
          root_namespace_id: project.root_namespace.id
        }

        expect { service.execute }.to publish_event(Pages::PageDeployedEvent).with(expected_data)
      end

      it 'creates pages_deployment' do
        expect { expect(service.execute[:status]).to eq(:success) }
          .to change { project.pages_deployments.count }
          .by(1)

        deployment = project.pages_deployments.last

        expect(deployment.size).to eq(file.size)
        expect(deployment.file).to be_present
        expect(deployment.file_count).to eq(3)
        expect(deployment.file_sha256).to eq(artifacts_archive.file_sha256)
        expect(deployment.ci_build_id).to eq(build.id)
        expect(deployment.root_directory).to be_nil
      end

      it 'does not fail if pages_metadata is absent' do
        project.pages_metadatum.destroy!
        project.reload

        expect { expect(service.execute[:status]).to eq(:success) }
          .to change { project.pages_deployments.count }
          .by(1)
      end

      context 'when archive does not have pages directory' do
        let(:file) { empty_file }
        let(:metadata_filename) { empty_metadata_filename }

        it 'returns an error' do
          expect(service.execute[:status]).not_to eq(:success)

          expect(GenericCommitStatus.last.description)
            .to eq(
              ""Error: You need to either include a `public/` folder in your artifacts, "" \
              ""or specify which one to use for Pages using `publish` in `.gitlab-ci.yml`"")
        end
      end

      context 'when there is a custom root config' do
        let(:file) { custom_root_file }
        let(:metadata_filename) { custom_root_file_metadata }

        context 'when the directory specified with `publish` is included in the artifacts' do
          let(:options) { { publish: 'foo' } }

          it 'creates pages_deployment and saves it in the metadata' do
            expect(service.execute[:status]).to eq(:success)

            deployment = project.pages_deployments.last
            expect(deployment.root_directory).to eq(options[:publish])
          end
        end

        context 'when the directory specified with `publish` is not included in the artifacts' do
          let(:options) { { publish: 'bar' } }

          it 'returns an error' do
            expect(service.execute[:status]).not_to eq(:success)

            expect(GenericCommitStatus.last.description)
              .to eq(
                ""Error: You need to either include a `public/` folder in your artifacts, "" \
                ""or specify which one to use for Pages using `publish` in `.gitlab-ci.yml`"")
          end
        end

        context 'when there is a folder named `public`, but `publish` specifies a different one' do
          let(:options) { { publish: 'foo' } }
          let(:file) { fixture_file_upload(""spec/fixtures/pages.zip"") }
          let(:metadata_filename) { ""spec/fixtures/pages.zip.meta"" }

          it 'returns an error' do
            expect(service.execute[:status]).not_to eq(:success)

            expect(GenericCommitStatus.last.description)
              .to eq(
                ""Error: You need to either include a `public/` folder in your artifacts, "" \
                ""or specify which one to use for Pages using `publish` in `.gitlab-ci.yml`"")
          end
        end
      end

      it 'limits pages size' do
        stub_application_setting(max_pages_size: 1)
        expect(service.execute[:status]).not_to eq(:success)
      end

      it 'limits pages file count' do
        create(:plan_limits, :default_plan, pages_file_entries: 2)

        expect(service.execute[:status]).not_to eq(:success)

        expect(GenericCommitStatus.last.description)
          .to eq(""pages site contains 3 file entries, while limit is set to 2"")
      end

      context 'when timeout happens by DNS error' do
        before do
          allow_next_instance_of(described_class) do |instance|
            allow(instance).to receive(:create_pages_deployment).and_raise(SocketError)
          end
        end

        it 'raises an error' do
          expect { service.execute }.to raise_error(SocketError)

          build.reload

          deploy_status = GenericCommitStatus.last
          expect(deploy_status).to be_failed
          expect(project.pages_deployed?).to eq(false)
        end
      end

      context 'when missing artifacts metadata' do
        before do
          allow(build).to receive(:artifacts_metadata?).and_return(false)
        end

        it 'does not raise an error as failed job' do
          service.execute

          build.reload

          deploy_status = GenericCommitStatus.last
          expect(deploy_status).to be_failed
          expect(project.pages_deployed?).to eq(false)
        end
      end

      context 'with background jobs running', :sidekiq_inline do
        it 'succeeds' do
          expect(project.pages_deployed?).to be_falsey
          expect(service.execute[:status]).to eq(:success)
        end
      end

      context ""when sha on branch was updated before deployment was uploaded"" do
        before do
          expect(subject).to receive(:create_pages_deployment).and_wrap_original do |m, *args|
            build.update!(ref: 'feature')
            m.call(*args)
          end
        end

        it 'creates a new pages deployment' do
          expect { expect(service.execute[:status]).to eq(:success) }
            .to change { project.pages_deployments.count }.by(1)

          deployment = project.pages_deployments.last
          expect(deployment.ci_build_id).to eq(build.id)
        end

        it_behaves_like 'old deployments'

        context 'when newer deployment present' do
          it 'fails with outdated reference message' do
            new_pipeline = create(:ci_pipeline, project: project, sha: project.commit('HEAD').sha)
            new_build = create(:ci_build, name: 'pages', pipeline: new_pipeline, ref: 'HEAD')
            create(:pages_deployment, project: project, ci_build: new_build)

            expect(service.execute[:status]).to eq(:error)

            deploy_status = GenericCommitStatus.last
            expect(deploy_status).to be_failed
            expect(deploy_status.description).to eq('build SHA is outdated for this ref')
          end
        end
      end

      it 'fails when uploaded deployment size is wrong' do
        allow_next_instance_of(PagesDeployment) do |deployment|
          allow(deployment)
            .to receive(:file)
            .and_return(instance_double(Pages::DeploymentUploader, size: file.size + 1))
        end

        expect(service.execute[:status]).not_to eq(:success)

        expect(GenericCommitStatus.last.description)
          .to eq('The uploaded artifact size does not match the expected value')
      end
    end
  end

  # this situation should never happen in real life because all new archives have sha256
  # and we only use new archives
  # this test is here just to clarify that this behavior is intentional
  context 'when artifacts archive does not have sha256' do
    let!(:artifacts_archive) { create(:ci_job_artifact, file: file, job: build) }

    before do
      create(:ci_job_artifact, file_type: :metadata, file_format: :gzip, file: metadata, job: build)

      build.reload
    end

    it 'fails with exception raised' do
      expect { service.execute }
        .to raise_error(""Validation failed: File sha256 can't be blank"")
    end
  end

  it 'fails if no artifacts' do
    expect(service.execute[:status]).not_to eq(:success)
  end

  it 'fails for invalid archive' do
    create(:ci_job_artifact, :archive, file: invalid_file, job: build)
    expect(service.execute[:status]).not_to eq(:success)
  end

  describe 'maximum pages artifacts size' do
    let(:metadata) { spy('metadata') }

    before do
      file = fixture_file_upload('spec/fixtures/pages.zip')
      metafile = fixture_file_upload('spec/fixtures/pages.zip.meta')

      create(:ci_job_artifact, :archive, :correct_checksum, file: file, job: build)
      create(:ci_job_artifact, :metadata, file: metafile, job: build)

      allow(build).to receive(:artifacts_metadata_entry)
        .and_return(metadata)
    end

    context 'when maximum pages size is set to zero' do
      before do
        stub_application_setting(max_pages_size: 0)
      end

      it_behaves_like 'pages size limit is', ::Gitlab::Pages::MAX_SIZE
    end

    context 'when size is limited on the instance level' do
      before do
        stub_application_setting(max_pages_size: 100)
      end

      it_behaves_like 'pages size limit is', 100.megabytes
    end
  end

  context 'when retrying the job' do
    let(:stage) { create(:ci_stage, position: 1_000_000, name: 'deploy', pipeline: pipeline) }
    let!(:older_deploy_job) do
      create(
        :generic_commit_status,
        :failed,
        pipeline: pipeline,
        ref: build.ref,
        ci_stage: stage,
        name: 'pages:deploy'
      )
    end

    before do
      create(:ci_job_artifact, :correct_checksum, file: file, job: build)
      create(:ci_job_artifact, file_type: :metadata, file_format: :gzip, file: metadata, job: build)
      build.reload
    end

    it 'marks older pages:deploy jobs retried' do
      expect(service.execute[:status]).to eq(:success)

      expect(older_deploy_job.reload).to be_retried

      deploy_status = GenericCommitStatus.last
      expect(deploy_status.ci_stage).to eq(stage)
      expect(deploy_status.stage_idx).to eq(stage.position)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# NOTE: This service cannot be used directly because it is part of a
# a bigger process. Instead, use the service MoveAccessService which moves
# project memberships, project group links, authorizations and refreshes
# the authorizations if necessary
module Projects
  class MoveProjectMembersService < BaseMoveRelationsService
    def execute(source_project, remove_remaining_elements: true)
      return unless super

      Project.transaction do
        move_project_members
        remove_remaining_members if remove_remaining_elements

        success
      end
    end

    private

    def move_project_members
      non_existent_members.update_all(source_id: @project.id)
    end

    def remove_remaining_members
      # Remove remaining members and authorizations from source_project
      source_project.project_members.destroy_all # rubocop: disable Cop/DestroyAll
    end

    def project_members_in_target_project
      @project.project_members.select(:user_id)
    end

    # Look for members in source_project that are not in the target project
    # rubocop: disable CodeReuse/ActiveRecord
    def non_existent_members
      source_project.members
                    .select(:id)
                    .where.not(user_id: @project.project_members.select(:user_id))
    end
    # rubocop: enable CodeReuse/ActiveRecord
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::MoveProjectMembersService, feature_category: :groups_and_projects do
  let!(:user) { create(:user) }
  let(:project_with_users) { create(:project, namespace: user.namespace) }
  let(:target_project) { create(:project, namespace: user.namespace) }
  let(:maintainer_user) { create(:user) }
  let(:reporter_user) { create(:user) }
  let(:developer_user) { create(:user) }

  subject { described_class.new(target_project, user) }

  describe '#execute' do
    before do
      project_with_users.add_maintainer(maintainer_user)
      project_with_users.add_developer(developer_user)
      project_with_users.add_reporter(reporter_user)
    end

    it 'moves the members from one project to another' do
      expect(project_with_users.project_members.count).to eq 4
      expect(target_project.project_members.count).to eq 1

      subject.execute(project_with_users)

      expect(project_with_users.project_members.count).to eq 0
      expect(target_project.project_members.count).to eq 4
    end

    it 'does not move existent members to the current project' do
      target_project.add_maintainer(developer_user)
      target_project.add_developer(reporter_user)

      expect(project_with_users.project_members.count).to eq 4
      expect(target_project.project_members.count).to eq 3

      subject.execute(project_with_users)

      expect(project_with_users.project_members.count).to eq 0
      expect(target_project.project_members.count).to eq 4
    end

    it 'rollbacks changes if transaction fails' do
      allow(subject).to receive(:success).and_raise(StandardError)

      expect { subject.execute(project_with_users) }.to raise_error(StandardError)

      expect(project_with_users.project_members.count).to eq 4
      expect(target_project.project_members.count).to eq 1
    end

    context 'when remove_remaining_elements is false' do
      let(:options) { { remove_remaining_elements: false } }

      it 'does not remove remaining project members' do
        target_project.add_maintainer(developer_user)
        target_project.add_developer(reporter_user)

        subject.execute(project_with_users, **options)

        expect(project_with_users.project_members.count).not_to eq 0
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Service class for getting and caching the number of merge requests of several projects
# Warning: do not user this service with a really large set of projects
# because the service use maps to retrieve the project ids
module Projects
  class BatchOpenMergeRequestsCountService < Projects::BatchCountService
    # rubocop: disable CodeReuse/ActiveRecord
    def global_count
      @global_count ||= count_service.query(project_ids).group(:project_id).count
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def count_service
      ::Projects::OpenMergeRequestsCountService
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::BatchOpenMergeRequestsCountService, feature_category: :code_review_workflow do
  subject { described_class.new([project_1, project_2]) }

  let_it_be(:project_1) { create(:project) }
  let_it_be(:project_2) { create(:project) }

  describe '#refresh_cache_and_retrieve_data', :use_clean_rails_memory_store_caching do
    before do
      create(:merge_request, source_project: project_1, target_project: project_1)
      create(:merge_request, source_project: project_2, target_project: project_2)
    end

    it 'refreshes cache keys correctly when cache is clean', :aggregate_failures do
      subject.refresh_cache_and_retrieve_data

      expect(Rails.cache.read(get_cache_key(subject, project_1))).to eq(1)
      expect(Rails.cache.read(get_cache_key(subject, project_2))).to eq(1)

      expect { subject.refresh_cache_and_retrieve_data }.not_to exceed_query_limit(0)
    end
  end

  def get_cache_key(subject, project)
    subject.count_service
      .new(project)
      .cache_key
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class SlackApplicationInstallService < BaseService
    include Gitlab::Routing

    # Endpoint to initiate the OAuth flow, redirects to Slack's authorization screen
    # https://api.slack.com/authentication/oauth-v2#asking
    SLACK_AUTHORIZE_URL = 'https://slack.com/oauth/v2/authorize'

    # Endpoint to exchange the temporary authorization code for an access token
    # https://api.slack.com/authentication/oauth-v2#exchanging
    SLACK_EXCHANGE_TOKEN_URL = 'https://slack.com/api/oauth.v2.access'

    def execute
      slack_data = exchange_slack_token

      return error(""Slack: #{slack_data['error']}"") unless slack_data['ok']

      integration = project.gitlab_slack_application_integration \
        || project.create_gitlab_slack_application_integration!

      installation = integration.slack_integration || integration.build_slack_integration

      installation.update!(
        bot_user_id: slack_data['bot_user_id'],
        bot_access_token: slack_data['access_token'],
        team_id: slack_data.dig('team', 'id'),
        team_name: slack_data.dig('team', 'name'),
        alias: project.full_path,
        user_id: slack_data.dig('authed_user', 'id'),
        authorized_scope_names: slack_data['scope']
      )

      update_legacy_installations!(installation)

      success
    end

    private

    def exchange_slack_token
      query = {
        client_id: Gitlab::CurrentSettings.slack_app_id,
        client_secret: Gitlab::CurrentSettings.slack_app_secret,
        code: params[:code],
        # NOTE: Needs to match the `redirect_uri` passed to the authorization endpoint,
        # otherwise we get a `bad_redirect_uri` error.
        redirect_uri: slack_auth_project_settings_slack_url(project)
      }

      Gitlab::HTTP.get(SLACK_EXCHANGE_TOKEN_URL, query: query).to_hash
    end

    # Update any legacy SlackIntegration records for the Slack Workspace. Legacy SlackIntegration records
    # are any created before our Slack App was upgraded to use Granular Bot Permissions and issue a
    # bot_access_token. Any SlackIntegration records for the Slack Workspace will already have the same
    # bot_access_token.
    def update_legacy_installations!(installation)
      updatable_attributes = installation.attributes.slice(
        'user_id',
        'bot_user_id',
        'encrypted_bot_access_token',
        'encrypted_bot_access_token_iv',
        'updated_at'
      )

      SlackIntegration.by_team(installation.team_id).id_not_in(installation.id).each_batch do |batch|
        batch_ids = batch.pluck(:id) # rubocop: disable CodeReuse/ActiveRecord
        batch.update_all(updatable_attributes)

        ::Integrations::SlackWorkspace::IntegrationApiScope.update_scopes(batch_ids, installation.slack_api_scopes)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::SlackApplicationInstallService, feature_category: :integrations do
  let_it_be(:user) { create(:user) }
  let_it_be_with_refind(:project) { create(:project) }

  let(:integration) { project.gitlab_slack_application_integration }
  let(:installation) { integration.slack_integration }

  let(:slack_app_id) { 'A12345' }
  let(:slack_app_secret) { 'secret' }
  let(:oauth_code) { 'code' }
  let(:params) { { code: oauth_code } }
  let(:exchange_url) { described_class::SLACK_EXCHANGE_TOKEN_URL }
  let(:redirect_url) { Gitlab::Routing.url_helpers.slack_auth_project_settings_slack_url(project) }

  subject(:service) { described_class.new(project, user, params) }

  before do
    stub_application_setting(slack_app_id: slack_app_id, slack_app_secret: slack_app_secret)

    query = {
      client_id: slack_app_id,
      client_secret: slack_app_secret,
      code: oauth_code,
      redirect_uri: redirect_url
    }

    stub_request(:get, exchange_url)
      .with(query: query)
      .to_return(body: response.to_json, headers: { 'Content-Type' => 'application/json' })
  end

  context 'when Slack responds with an error' do
    let(:response) do
      {
        ok: false,
        error: 'something is wrong'
      }
    end

    it 'returns error result' do
      result = service.execute

      expect(result).to eq(message: 'Slack: something is wrong', status: :error)
    end
  end

  context 'when Slack responds with an access token' do
    let_it_be(:team_id) { 'T11111' }
    let_it_be(:team_name) { 'Team name' }
    let_it_be(:user_id) { 'U11111' }
    let_it_be(:bot_user_id) { 'U99999' }
    let_it_be(:bot_access_token) { 'token-XXXXX' }

    let(:response) do
      {
        ok: true,
        app_id: 'A12345',
        authed_user: { id: user_id },
        token_type: 'bot',
        access_token: bot_access_token,
        bot_user_id: bot_user_id,
        team: { id: team_id, name: 'Team name' },
        enterprise: { is_enterprise_install: false },
        scope: 'chat:a,chat:b,chat:c'
      }
    end

    shared_examples 'success response' do
      it 'returns success result and creates all needed records' do
        result = service.execute

        expect(result).to eq(status: :success)
        expect(integration).to be_present
        expect(installation).to be_present
        expect(installation).to have_attributes(
          integration_id: integration.id,
          team_id: team_id,
          team_name: team_name,
          alias: project.full_path,
          user_id: user_id,
          bot_user_id: bot_user_id,
          bot_access_token: bot_access_token,
          authorized_scope_names: contain_exactly('chat:a', 'chat:b', 'chat:c')
        )
      end
    end

    it_behaves_like 'success response'

    context 'when integration record already exists' do
      before do
        project.create_gitlab_slack_application_integration!
      end

      it_behaves_like 'success response'

      context 'when installation record already exists' do
        before do
          integration.create_slack_integration!(
            team_id: 'old value',
            team_name: 'old value',
            alias: 'old value',
            user_id: 'old value',
            bot_user_id: 'old value',
            bot_access_token: 'old value'
          )
        end

        it_behaves_like 'success response'
      end
    end

    context 'when the team has other Slack installation records' do
      let_it_be_with_reload(:other_installation) { create(:slack_integration, team_id: team_id) }
      let_it_be_with_reload(:other_legacy_installation) { create(:slack_integration, :legacy, team_id: team_id) }
      let_it_be_with_reload(:legacy_installation_for_other_team) { create(:slack_integration, :legacy) }

      it_behaves_like 'success response'

      it 'updates related legacy records' do
        travel_to(1.minute.from_now) do
          expected_attributes = {
            'user_id' => user_id,
            'bot_user_id' => bot_user_id,
            'bot_access_token' => bot_access_token,
            'updated_at' => Time.current,
            'authorized_scope_names' => %w[chat:a chat:b chat:c]
          }

          service.execute

          expect(other_installation).to have_attributes(expected_attributes)
          expect(other_legacy_installation).to have_attributes(expected_attributes)
          expect(legacy_installation_for_other_team).not_to have_attributes(expected_attributes)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  # Service class for performing operations that should take place after a
  # project has been renamed.
  #
  # Example usage:
  #
  #     project = Project.find(42)
  #
  #     project.update(...)
  #
  #     Projects::AfterRenameService.new(project).execute
  class AfterRenameService
    include BaseServiceUtility

    # @return [String] The Project being renamed.
    attr_reader :project

    # @return [String] The path slug the project was using, before the rename took place.
    attr_reader :path_before

    # @return [String] The full path of the namespace + project, before the rename took place.
    attr_reader :full_path_before

    # @return [String] The full path of the namespace + project, after the rename took place.
    attr_reader :full_path_after

    RenameFailedError = Class.new(StandardError)

    # @param [Project] project The Project being renamed.
    # @param [String] path_before The path slug the project was using, before the rename took place.
    def initialize(project, path_before:, full_path_before:)
      @project = project
      @path_before = path_before
      @full_path_before = full_path_before
      @full_path_after = project.full_path
    end

    def execute
      rename_base_repository_in_registry!
      expire_caches_before_rename
      rename_or_migrate_repository!
      send_move_instructions
      execute_system_hooks
      update_repository_configuration
      rename_transferred_documents
      log_completion
      publish_event
    end

    def rename_base_repository_in_registry!
      return unless project.has_container_registry_tags?

      ensure_registry_tags_can_be_handled

      result = ContainerRegistry::GitlabApiClient.rename_base_repository_path(
        full_path_before, name: project_path)

      return if result == :ok

      rename_failed!(""Renaming the base repository in the registry failed with error #{result}."")
    end

    def ensure_registry_tags_can_be_handled
      return if Feature.enabled?(:renaming_project_with_tags, project) &&
        ContainerRegistry::GitlabApiClient.supports_gitlab_api?

      rename_failed!(""Project #{full_path_before} cannot be renamed because images are "" \
      ""present in its container registry"")
    end

    def expire_caches_before_rename
      project.expire_caches_before_rename(full_path_before)
    end

    def rename_or_migrate_repository!
      success =
        ::Projects::HashedStorage::MigrationService
          .new(project, full_path_before)
          .execute

      return if success

      rename_failed!(""Repository #{full_path_before} could not be renamed to #{full_path_after}"")
    end

    def send_move_instructions
      return unless send_move_instructions?

      project.send_move_instructions(full_path_before)
    end

    def execute_system_hooks
      project.old_path_with_namespace = full_path_before
      system_hook_service.execute_hooks_for(project, :rename)
    end

    def update_repository_configuration
      project.reload_repository!
      project.set_full_path
      project.track_project_repository
    end

    def rename_transferred_documents
      if rename_uploads?
        Gitlab::UploadsTransfer
          .new
          .rename_project(path_before, project_path, namespace_full_path)
      end
    end

    def log_completion
      log_info(
        ""Project #{project.id} has been renamed from "" \
          ""#{full_path_before} to #{full_path_after}""
      )
    end

    def send_move_instructions?
      !project.import_started?
    end

    def rename_uploads?
      !project.hashed_storage?(:attachments)
    end

    def project_path
      project.path
    end

    def namespace_full_path
      project.namespace.full_path
    end

    def rename_failed!(error)
      log_error(error)

      raise RenameFailedError, error
    end

    def publish_event
      event = Projects::ProjectPathChangedEvent.new(data: {
        project_id: project.id,
        namespace_id: project.namespace_id,
        root_namespace_id: project.root_namespace.id,
        old_path: full_path_before,
        new_path: full_path_after
      })

      Gitlab::EventStore.publish(event)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::AfterRenameService, feature_category: :groups_and_projects do
  let(:legacy_storage) { Storage::LegacyProject.new(project) }
  let(:hashed_storage) { Storage::Hashed.new(project) }
  let!(:path_before_rename) { project.path }
  let!(:full_path_before_rename) { project.full_path }
  let!(:path_after_rename) { ""#{project.path}-renamed"" }
  let!(:full_path_after_rename) { ""#{project.full_path}-renamed"" }
  let!(:repo_before_rename) { project.repository.raw }
  let!(:wiki_repo_before_rename) { project.wiki.repository.raw }

  let(:repo_after_rename) do
    Gitlab::Git::Repository.new(project.repository_storage, ""#{full_path_after_rename}.git"", nil, nil)
  end

  let(:wiki_repo_after_rename) do
    Gitlab::Git::Repository.new(project.repository_storage, ""#{full_path_after_rename}.wiki.git"", nil, nil)
  end

  describe '#execute' do
    let(:project) { create(:project, :repository, skip_disk_validation: true) }
    let(:gitlab_shell) { Gitlab::Shell.new }
    let(:hash) { Digest::SHA2.hexdigest(project.id.to_s) }
    let(:hashed_prefix) { File.join('@hashed', hash[0..1], hash[2..3]) }
    let(:hashed_path) { File.join(hashed_prefix, hash) }
    let(:message) { ""Repository #{full_path_before_rename} could not be renamed to #{full_path_after_rename}"" }

    before do
      # Project#gitlab_shell returns a new instance of Gitlab::Shell on every
      # call. This makes testing a bit easier.
      allow(project).to receive(:gitlab_shell).and_return(gitlab_shell)

      stub_application_setting(hashed_storage_enabled: true)
    end

    shared_examples 'logging and raising a RenameFailedError' do
      it 'logs raises a RenameFailedError' do
        expect_any_instance_of(described_class).to receive(:log_error).with(message)

        expect { service_execute }
          .to raise_error(described_class::RenameFailedError)
      end
    end

    it 'renames a repository' do
      stub_container_registry_config(enabled: false)

      expect_any_instance_of(SystemHooksService)
        .to receive(:execute_hooks_for)
        .with(project, :rename)

      expect(project).to receive(:expire_caches_before_rename)

      service_execute
    end

    context 'when renaming or migrating fails' do
      before do
        allow_any_instance_of(::Projects::HashedStorage::MigrationService)
          .to receive(:execute).and_return(false)
      end

      it_behaves_like 'logging and raising a RenameFailedError'
    end

    context 'container registry with images' do
      let(:container_repository) { create(:container_repository) }
      let(:message) do
        ""Project #{full_path_before_rename} cannot be renamed because images are "" \
          ""present in its container registry""
      end

      before do
        stub_container_registry_config(enabled: true)
        stub_container_registry_tags(repository: :any, tags: ['tag'])
        project.container_repositories << container_repository
      end

      context 'when feature renaming_project_with_tags is disabled' do
        before do
          stub_feature_flags(renaming_project_with_tags: false)
        end

        it_behaves_like 'logging and raising a RenameFailedError'
      end

      context 'when Gitlab API is not supported' do
        before do
          allow(ContainerRegistry::GitlabApiClient).to receive(:supports_gitlab_api?).and_return(false)
        end

        it_behaves_like 'logging and raising a RenameFailedError'
      end

      context 'when Gitlab API Client is supported' do
        before do
          allow(ContainerRegistry::GitlabApiClient).to receive(:supports_gitlab_api?).and_return(true)
        end

        it 'renames the base repository in the registry' do
          expect(ContainerRegistry::GitlabApiClient).to receive(:rename_base_repository_path)
            .with(full_path_before_rename, name: path_after_rename).and_return(:ok)

          service_execute
        end

        context 'when the base repository rename in the registry fails' do
          before do
            allow(ContainerRegistry::GitlabApiClient)
              .to receive(:rename_base_repository_path).and_return(:bad_request)
          end

          let(:message) { 'Renaming the base repository in the registry failed with error bad_request.' }

          it_behaves_like 'logging and raising a RenameFailedError'
        end
      end
    end

    context 'attachments' do
      let(:uploader) { create(:upload, :issuable_upload, :with_file, model: project) }
      let(:file_uploader) { build(:file_uploader, project: project) }
      let(:legacy_storage_path) { File.join(file_uploader.root, legacy_storage.disk_path) }
      let(:hashed_storage_path) { File.join(file_uploader.root, hashed_storage.disk_path) }

      it 'keeps uploads folder location unchanged' do
        expect_any_instance_of(Gitlab::UploadsTransfer).not_to receive(:rename_project)

        service_execute
      end

      context 'when not rolled out' do
        let(:project) { create(:project, :repository, storage_version: 1, skip_disk_validation: true) }

        it 'moves attachments folder to hashed storage' do
          expect(File.directory?(legacy_storage_path)).to be_truthy
          expect(File.directory?(hashed_storage_path)).to be_falsey

          service_execute
          expect(project.reload.hashed_storage?(:attachments)).to be_truthy

          expect(File.directory?(legacy_storage_path)).to be_falsey
          expect(File.directory?(hashed_storage_path)).to be_truthy
        end
      end
    end

    it 'updates project full path in gitaly' do
      service_execute

      expect(project.repository.full_path).to eq(project.full_path)
    end

    it 'updates storage location' do
      service_execute

      expect(project.project_repository).to have_attributes(
        disk_path: project.disk_path,
        shard_name: project.repository_storage
      )
    end

    context 'EventStore' do
      let(:project) { create(:project, :repository, skip_disk_validation: true) }

      it 'publishes a ProjectPathChangedEvent' do
        expect { service_execute }
          .to publish_event(Projects::ProjectPathChangedEvent)
          .with(
            project_id: project.id,
            namespace_id: project.namespace_id,
            root_namespace_id: project.root_namespace.id,
            old_path: full_path_before_rename,
            new_path: full_path_after_rename
          )
      end
    end
  end

  def service_execute
    # AfterRenameService is called by UpdateService after a successful model.update
    # the initialization will include before and after paths values
    project.update!(path: path_after_rename)

    described_class.new(project, path_before: path_before_rename, full_path_before: full_path_before_rename).execute
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class MoveForksService < BaseMoveRelationsService
    def execute(source_project, remove_remaining_elements: true)
      return unless super && source_project.fork_network

      Project.transaction do
        move_fork_network_members
        update_root_project
        refresh_forks_count

        success
      end
    end

    private

    # rubocop: disable CodeReuse/ActiveRecord
    def move_fork_network_members
      ForkNetworkMember.where(project: source_project).update_all(project_id: @project.id)
      ForkNetworkMember.where(forked_from_project: source_project).update_all(forked_from_project_id: @project.id)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    # rubocop: disable CodeReuse/ActiveRecord
    def update_root_project
      # Update root network project
      ForkNetwork.where(root_project: source_project).update_all(root_project_id: @project.id)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def refresh_forks_count
      Projects::ForksCountService.new(@project).refresh_cache
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::MoveForksService, feature_category: :source_code_management do
  include ProjectForksHelper

  let!(:user) { create(:user) }
  let!(:project_with_forks) { create(:project, namespace: user.namespace) }
  let!(:target_project) { create(:project, namespace: user.namespace) }
  let!(:lvl1_forked_project_1) { fork_project(project_with_forks, user) }
  let!(:lvl1_forked_project_2) { fork_project(project_with_forks, user) }
  let!(:lvl2_forked_project_1_1) { fork_project(lvl1_forked_project_1, user) }
  let!(:lvl2_forked_project_1_2) { fork_project(lvl1_forked_project_1, user) }

  subject { described_class.new(target_project, user) }

  describe '#execute' do
    context 'when moving a root forked project' do
      it 'moves the descendant forks' do
        expect(project_with_forks.forks.count).to eq 2
        expect(target_project.forks.count).to eq 0

        subject.execute(project_with_forks)

        expect(project_with_forks.forks.count).to eq 0
        expect(target_project.forks.count).to eq 2
        expect(lvl1_forked_project_1.forked_from_project).to eq target_project
        expect(lvl1_forked_project_1.fork_network_member.forked_from_project).to eq target_project
        expect(lvl1_forked_project_2.forked_from_project).to eq target_project
        expect(lvl1_forked_project_2.fork_network_member.forked_from_project).to eq target_project
      end

      it 'updates the fork network' do
        expect(project_with_forks.fork_network.root_project).to eq project_with_forks
        expect(project_with_forks.fork_network.fork_network_members.map(&:project)).to include project_with_forks

        subject.execute(project_with_forks)

        expect(target_project.reload.fork_network.root_project).to eq target_project
        expect(target_project.fork_network.fork_network_members.map(&:project)).not_to include project_with_forks
      end
    end

    context 'when moving a intermediate forked project' do
      it 'moves the descendant forks' do
        expect(lvl1_forked_project_1.forks.count).to eq 2
        expect(target_project.forks.count).to eq 0

        subject.execute(lvl1_forked_project_1)

        expect(lvl1_forked_project_1.forks.count).to eq 0
        expect(target_project.forks.count).to eq 2
        expect(lvl2_forked_project_1_1.forked_from_project).to eq target_project
        expect(lvl2_forked_project_1_1.fork_network_member.forked_from_project).to eq target_project
        expect(lvl2_forked_project_1_2.forked_from_project).to eq target_project
        expect(lvl2_forked_project_1_2.fork_network_member.forked_from_project).to eq target_project
      end

      it 'moves the ascendant fork' do
        subject.execute(lvl1_forked_project_1)

        expect(target_project.forked_from_project).to eq project_with_forks
        expect(target_project.fork_network_member.forked_from_project).to eq project_with_forks
      end

      it 'does not update fork network' do
        subject.execute(lvl1_forked_project_1)

        expect(target_project.reload.fork_network.root_project).to eq project_with_forks
      end
    end

    context 'when moving a leaf forked project' do
      it 'moves the ascendant fork' do
        subject.execute(lvl2_forked_project_1_1)

        expect(target_project.forked_from_project).to eq lvl1_forked_project_1
        expect(target_project.fork_network_member.forked_from_project).to eq lvl1_forked_project_1
      end

      it 'does not update fork network' do
        subject.execute(lvl2_forked_project_1_1)

        expect(target_project.reload.fork_network.root_project).to eq project_with_forks
      end
    end

    it 'rollbacks changes if transaction fails' do
      allow(subject).to receive(:success).and_raise(StandardError)

      expect { subject.execute(project_with_forks) }.to raise_error(StandardError)

      expect(project_with_forks.forks.count).to eq 2
      expect(target_project.forks.count).to eq 0
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class MoveUsersStarProjectsService < BaseMoveRelationsService
    def execute(source_project, remove_remaining_elements: true)
      return unless super

      user_stars = source_project.users_star_projects

      return unless user_stars.any?

      Project.transaction do
        user_stars.update_all(project_id: @project.id)

        @project.update(star_count: @project.starrers.with_state(:active).size)
        source_project.update(star_count: source_project.starrers.with_state(:active).size)

        success
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::MoveUsersStarProjectsService, feature_category: :groups_and_projects do
  let!(:user) { create(:user) }
  let!(:project_with_stars) { create(:project, namespace: user.namespace) }
  let!(:target_project) { create(:project, namespace: user.namespace) }

  subject { described_class.new(target_project, user) }

  describe '#execute' do
    before do
      create_list(:users_star_project, 2, project: project_with_stars)
    end

    it 'moves the user\'s stars from one project to another' do
      project_with_stars.reload
      target_project.reload

      expect(project_with_stars.users_star_projects.count).to eq 2
      expect(project_with_stars.star_count).to eq 2
      expect(target_project.users_star_projects.count).to eq 0
      expect(target_project.star_count).to eq 0

      subject.execute(project_with_stars)
      project_with_stars.reload
      target_project.reload

      expect(project_with_stars.users_star_projects.count).to eq 0
      expect(project_with_stars.star_count).to eq 0
      expect(target_project.users_star_projects.count).to eq 2
      expect(target_project.star_count).to eq 2
    end

    it 'rollbacks changes if transaction fails' do
      allow(subject).to receive(:success).and_raise(StandardError)

      expect { subject.execute(project_with_stars) }.to raise_error(StandardError)
      project_with_stars.reload
      target_project.reload

      expect(project_with_stars.users_star_projects.count).to eq 2
      expect(project_with_stars.star_count).to eq 2
      expect(target_project.users_star_projects.count).to eq 0
      expect(target_project.star_count).to eq 0
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class AutocompleteService < BaseService
    include LabelsAsHash
    def issues
      IssuesFinder.new(current_user, project_id: project.id, state: 'opened').execute.select([:iid, :title])
    end

    def milestones
      finder_params = {
        project_ids: [@project.id],
        state: :active,
        order: { due_date: :asc, title: :asc }
      }

      finder_params[:group_ids] = @project.group.self_and_ancestors.select(:id) if @project.group

      MilestonesFinder.new(finder_params).execute.select([:iid, :title, :due_date])
    end

    def merge_requests
      MergeRequestsFinder.new(current_user, project_id: project.id, state: 'opened').execute.select([:iid, :title])
    end

    def commands(noteable)
      return [] unless noteable && current_user

      QuickActions::InterpretService.new(project, current_user).available_commands(noteable)
    end

    def snippets
      SnippetsFinder.new(current_user, project: project).execute.select([:id, :title])
    end

    def contacts(target)
      available_contacts = Crm::ContactsFinder.new(current_user, group: project.group).execute
        .select([:id, :email, :first_name, :last_name, :state])

      contact_hashes = available_contacts.as_json

      return contact_hashes unless target.is_a?(Issue)

      ids = target.customer_relations_contacts.ids # rubocop:disable CodeReuse/ActiveRecord

      contact_hashes.each do |hash|
        hash[:set] = ids.include?(hash['id'])
      end

      contact_hashes
    end

    def labels_as_hash(target)
      super(target, project_id: project.id, include_ancestor_groups: true)
    end
  end
end

Projects::AutocompleteService.prepend_mod_with('Projects::AutocompleteService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::AutocompleteService, feature_category: :groups_and_projects do
  describe '#issues' do
    describe 'confidential issues' do
      let(:author) { create(:user) }
      let(:assignee) { create(:user) }
      let(:non_member) { create(:user) }
      let(:member) { create(:user) }
      let(:admin) { create(:admin) }
      let(:project) { create(:project, :public) }
      let!(:issue) { create(:issue, project: project, title: 'Issue 1') }
      let!(:security_issue_1) { create(:issue, :confidential, project: project, title: 'Security issue 1', author: author) }
      let!(:security_issue_2) { create(:issue, :confidential, title: 'Security issue 2', project: project, assignees: [assignee]) }

      it 'does not list project confidential issues for guests' do
        autocomplete = described_class.new(project, nil)
        issues = autocomplete.issues.map(&:iid)

        expect(issues).to include issue.iid
        expect(issues).not_to include security_issue_1.iid
        expect(issues).not_to include security_issue_2.iid
        expect(issues.count).to eq 1
      end

      it 'does not list project confidential issues for non project members' do
        autocomplete = described_class.new(project, non_member)
        issues = autocomplete.issues.map(&:iid)

        expect(issues).to include issue.iid
        expect(issues).not_to include security_issue_1.iid
        expect(issues).not_to include security_issue_2.iid
        expect(issues.count).to eq 1
      end

      it 'does not list project confidential issues for project members with guest role' do
        project.add_guest(member)

        autocomplete = described_class.new(project, non_member)
        issues = autocomplete.issues.map(&:iid)

        expect(issues).to include issue.iid
        expect(issues).not_to include security_issue_1.iid
        expect(issues).not_to include security_issue_2.iid
        expect(issues.count).to eq 1
      end

      it 'lists project confidential issues for author' do
        autocomplete = described_class.new(project, author)
        issues = autocomplete.issues.map(&:iid)

        expect(issues).to include issue.iid
        expect(issues).to include security_issue_1.iid
        expect(issues).not_to include security_issue_2.iid
        expect(issues.count).to eq 2
      end

      it 'lists project confidential issues for assignee' do
        autocomplete = described_class.new(project, assignee)
        issues = autocomplete.issues.map(&:iid)

        expect(issues).to include issue.iid
        expect(issues).not_to include security_issue_1.iid
        expect(issues).to include security_issue_2.iid
        expect(issues.count).to eq 2
      end

      it 'lists project confidential issues for project members' do
        project.add_developer(member)

        autocomplete = described_class.new(project, member)
        issues = autocomplete.issues.map(&:iid)

        expect(issues).to include issue.iid
        expect(issues).to include security_issue_1.iid
        expect(issues).to include security_issue_2.iid
        expect(issues.count).to eq 3
      end

      context 'when admin mode is enabled', :enable_admin_mode do
        it 'lists all project issues for admin', :enable_admin_mode do
          autocomplete = described_class.new(project, admin)
          issues = autocomplete.issues.map(&:iid)

          expect(issues).to include issue.iid
          expect(issues).to include security_issue_1.iid
          expect(issues).to include security_issue_2.iid
          expect(issues.count).to eq 3
        end
      end

      context 'when admin mode is disabled' do
        it 'does not list project confidential issues for admin' do
          autocomplete = described_class.new(project, admin)
          issues = autocomplete.issues.map(&:iid)

          expect(issues).to include issue.iid
          expect(issues).not_to include security_issue_1.iid
          expect(issues).not_to include security_issue_2.iid
          expect(issues.count).to eq 1
        end
      end
    end
  end

  describe '#milestones' do
    let(:user) { create(:user) }
    let(:group) { create(:group) }
    let(:project) { create(:project, group: group) }
    let!(:group_milestone1) { create(:milestone, group: group, due_date: '2017-01-01', title: 'Second Title') }
    let!(:group_milestone2) { create(:milestone, group: group, due_date: '2017-01-01', title: 'First Title') }
    let!(:project_milestone) { create(:milestone, project: project, due_date: '2016-01-01') }

    let(:milestone_titles) { described_class.new(project, user).milestones.map(&:title) }

    it 'includes project and group milestones and sorts them correctly' do
      expect(milestone_titles).to eq([project_milestone.title, group_milestone2.title, group_milestone1.title])
    end

    it 'does not include closed milestones' do
      group_milestone1.close

      expect(milestone_titles).to eq([project_milestone.title, group_milestone2.title])
    end

    it 'does not include milestones from other projects in the group' do
      other_project = create(:project, group: group)
      project_milestone.update!(project: other_project)

      expect(milestone_titles).to eq([group_milestone2.title, group_milestone1.title])
    end

    context 'with nested groups' do
      let(:subgroup) { create(:group, :public, parent: group) }
      let!(:subgroup_milestone) { create(:milestone, group: subgroup) }

      before do
        project.update!(namespace: subgroup)
      end

      it 'includes project milestones and all acestors milestones' do
        expect(milestone_titles).to match_array(
          [project_milestone.title, group_milestone2.title, group_milestone1.title, subgroup_milestone.title]
        )
      end
    end
  end

  describe '#contacts' do
    let_it_be(:user) { create(:user) }
    let_it_be(:group) { create(:group, :crm_enabled) }
    let_it_be(:project) { create(:project, group: group) }
    let_it_be(:contact_1) { create(:contact, group: group) }
    let_it_be(:contact_2) { create(:contact, group: group) }
    let_it_be(:contact_3) { create(:contact, :inactive, group: group) }

    let(:issue) { nil }

    subject { described_class.new(project, user).contacts(issue).as_json }

    before do
      group.add_developer(user)
    end

    it 'returns CRM contacts from group' do
      expected_contacts = [
        { 'id' => contact_1.id, 'email' => contact_1.email,
          'first_name' => contact_1.first_name, 'last_name' => contact_1.last_name, 'state' => contact_1.state },
        { 'id' => contact_2.id, 'email' => contact_2.email,
          'first_name' => contact_2.first_name, 'last_name' => contact_2.last_name, 'state' => contact_2.state },
        { 'id' => contact_3.id, 'email' => contact_3.email,
          'first_name' => contact_3.first_name, 'last_name' => contact_3.last_name, 'state' => contact_3.state }
      ]

      expect(subject).to match_array(expected_contacts)
    end

    context 'some contacts are already assigned to the issue' do
      let(:issue) { create(:issue, project: project) }

      before do
        issue.customer_relations_contacts << [contact_2, contact_3]
      end

      it 'marks already assigned contacts as set' do
        expected_contacts = [
          { 'id' => contact_1.id, 'email' => contact_1.email,
            'first_name' => contact_1.first_name, 'last_name' => contact_1.last_name, 'state' => contact_1.state, 'set' => false },
          { 'id' => contact_2.id, 'email' => contact_2.email,
            'first_name' => contact_2.first_name, 'last_name' => contact_2.last_name, 'state' => contact_2.state, 'set' => true },
          { 'id' => contact_3.id, 'email' => contact_3.email,
            'first_name' => contact_3.first_name, 'last_name' => contact_3.last_name, 'state' => contact_3.state, 'set' => true }
        ]

        expect(subject).to match_array(expected_contacts)
      end
    end
  end

  describe '#labels_as_hash' do
    def expect_labels_to_equal(labels, expected_labels)
      expect(labels.size).to eq(expected_labels.size)
      extract_title = lambda { |label| label['title'] }
      expect(labels.map(&extract_title)).to match_array(expected_labels.map(&extract_title))
    end

    let(:user) { create(:user) }
    let(:group) { create(:group, :nested) }
    let!(:sub_group) { create(:group, parent: group) }
    let(:project) { create(:project, :public, group: group) }
    let(:issue) { create(:issue, project: project) }

    let!(:label1) { create(:label, project: project) }
    let!(:label2) { create(:label, project: project) }
    let!(:sub_group_label) { create(:group_label, group: sub_group) }
    let!(:parent_group_label) { create(:group_label, group: group.parent, group_id: group.id) }

    before do
      create(:group_member, group: group, user: user)
    end

    it 'returns labels from project and ancestor groups' do
      service = described_class.new(project, user)
      results = service.labels_as_hash(nil)
      expected_labels = [label1, label2, parent_group_label]

      expect_labels_to_equal(results, expected_labels)
    end

    context 'some labels are already assigned' do
      before do
        issue.labels << label1
      end

      it 'marks already assigned as set' do
        service = described_class.new(project, user)
        results = service.labels_as_hash(issue)
        expected_labels = [label1, label2, parent_group_label]

        expect_labels_to_equal(results, expected_labels)

        assigned_label_titles = issue.labels.map(&:title)
        results.each do |hash|
          if assigned_label_titles.include?(hash['title'])
            expect(hash[:set]).to eq(true)
          else
            expect(hash.key?(:set)).to eq(false)
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Projects::BranchesByModeService uses Gitaly page-token pagination
# in order to optimally fetch branches.
# The drawback of the page-token pagination is that it doesn't provide
# an option of going to the previous page of the collection.
# That's why we need to fall back to offset pagination when previous page
# is requested.
class Projects::BranchesByModeService
  include Gitlab::Routing

  attr_reader :project, :params

  def initialize(project, params = {})
    @project = project
    @params = params
  end

  def execute
    return fetch_branches_via_gitaly_pagination if use_gitaly_pagination?

    fetch_branches_via_offset_pagination
  end

  private

  def mode
    params[:mode]
  end

  def by_mode(branches)
    return branches unless %w[active stale].include?(mode)

    branches.select { |b| b.state.to_s == mode }
  end

  def use_gitaly_pagination?
    return false if params[:page].present? || params[:search].present?

    Feature.enabled?(:branch_list_keyset_pagination, project)
  end

  def fetch_branches_via_offset_pagination
    branches = BranchesFinder.new(project.repository, params).execute
    branches = Kaminari.paginate_array(by_mode(branches)).page(params[:page])

    branches_with_links(branches, last_page: branches.last_page?)
  end

  def fetch_branches_via_gitaly_pagination
    per_page = Kaminari.config.default_per_page
    options = params.merge(per_page: per_page + 1, page_token: params[:page_token])

    branches = BranchesFinder.new(project.repository, options).execute(gitaly_pagination: true)

    # Branch is stale if it hasn't been updated for 3 months
    # This logic is specified in Gitlab Rails and isn't specified in Gitaly
    # To display stale branches we fetch branches sorted as most-stale-at-the-top
    # If the result contains active branches we filter them out and define that no more stale branches left
    # Same logic applies to fetching active branches
    branches = by_mode(branches)
    last_page = branches.size <= per_page

    branches = branches.take(per_page) # rubocop:disable CodeReuse/ActiveRecord

    branches_with_links(branches, last_page: last_page)
  end

  def branches_with_links(branches, last_page:)
    # To fall back to offset pagination we need to track current page via offset param
    # And increase it whenever we go to the next page
    previous_offset = params[:offset].to_i

    previous_path = nil
    next_path = nil

    return [branches, previous_path, next_path] if branches.blank?

    unless last_page
      next_path = project_branches_filtered_path(project, state: mode, page_token: branches.last.name, sort: params[:sort], offset: previous_offset + 1)
    end

    if previous_offset > 0
      previous_path = project_branches_filtered_path(project, state: mode, sort: params[:sort], page: previous_offset, offset: previous_offset - 1)
    end

    [branches, previous_path, next_path]
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::BranchesByModeService, feature_category: :source_code_management do
  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project, :repository) }

  let(:finder) { described_class.new(project, params) }
  let(:params) { { mode: 'all' } }

  subject { finder.execute }

  describe '#execute' do
    context 'page is passed' do
      let(:page) { (TestEnv::BRANCH_SHA.length.to_f / Kaminari.config.default_per_page).ceil }
      let(:params) { { page: page, mode: 'all', offset: page - 1 } }

      it 'uses offset pagination' do
        expect(finder).to receive(:fetch_branches_via_offset_pagination).and_call_original

        branches, prev_page, next_page = subject
        remaining = TestEnv::BRANCH_SHA.length % Kaminari.config.default_per_page

        expect(branches.size).to eq(remaining > 0 ? remaining : 20)
        expect(next_page).to be_nil
        expect(prev_page).to eq(""/#{project.full_path}/-/branches/all?offset=#{page - 2}&page=#{page - 1}"")
      end

      context 'but the page does not contain any branches' do
        let(:params) { { page: 100, mode: 'all' } }

        it 'uses offset pagination' do
          expect(finder).to receive(:fetch_branches_via_offset_pagination).and_call_original

          branches, prev_page, next_page = subject

          expect(branches).to eq([])
          expect(next_page).to be_nil
          expect(prev_page).to be_nil
        end
      end
    end

    context 'search is passed' do
      let(:params) { { search: 'feature' } }

      it 'uses offset pagination' do
        expect(finder).to receive(:fetch_branches_via_offset_pagination).and_call_original

        branches, prev_page, next_page = subject

        expect(branches.map(&:name)).to match_array(%w[feature feature_conflict])
        expect(next_page).to be_nil
        expect(prev_page).to be_nil
      end
    end

    context 'branch_list_keyset_pagination is disabled' do
      it 'uses offset pagination' do
        stub_feature_flags(branch_list_keyset_pagination: false)

        expect(finder).to receive(:fetch_branches_via_offset_pagination).and_call_original

        branches, prev_page, next_page = subject
        expected_page_token = ERB::Util.url_encode(TestEnv::BRANCH_SHA.sort[19][0])

        expect(branches.size).to eq(20)
        expect(next_page).to eq(""/#{project.full_path}/-/branches/all?offset=1&page_token=#{expected_page_token}"")
        expect(prev_page).to be_nil
      end
    end

    context 'uses gitaly pagination' do
      before do
        expect(finder).to receive(:fetch_branches_via_gitaly_pagination).and_call_original
      end

      it 'returns branches for the first page' do
        branches, prev_page, next_page = subject
        expected_page_token = ERB::Util.url_encode(TestEnv::BRANCH_SHA.sort[19][0])

        expect(branches.size).to eq(20)
        expect(next_page).to eq(""/#{project.full_path}/-/branches/all?offset=1&page_token=#{expected_page_token}"")
        expect(prev_page).to be_nil
      end

      context 'when second page is requested' do
        let(:page_token) { 'conflict-resolvable' }
        let(:params) { { page_token: page_token, mode: 'all', sort: 'name_asc', offset: 1 } }

        it 'returns branches for the first page' do
          branches, prev_page, next_page = subject
          branch_index = TestEnv::BRANCH_SHA.sort.find_index { |a| a[0] == page_token }
          expected_page_token = ERB::Util.url_encode(TestEnv::BRANCH_SHA.sort[20 + branch_index][0])

          expect(branches.size).to eq(20)
          expect(next_page).to eq(""/#{project.full_path}/-/branches/all?offset=2&page_token=#{expected_page_token}&sort=name_asc"")
          expect(prev_page).to eq(""/#{project.full_path}/-/branches/all?offset=0&page=1&sort=name_asc"")
        end
      end

      context 'when last page is requested' do
        let(:page_token) { TestEnv::BRANCH_SHA.sort[-16][0] }
        let(:params) { { page_token: page_token, mode: 'all', sort: 'name_asc', offset: 4 } }

        it 'returns branches after the specified branch' do
          branches, prev_page, next_page = subject

          expect(branches.size).to eq(15)
          expect(next_page).to be_nil
          expect(prev_page).to eq(""/#{project.full_path}/-/branches/all?offset=3&page=4&sort=name_asc"")
        end
      end
    end

    context 'filter by mode' do
      let(:stale) { double(state: 'stale') }
      let(:active) { double(state: 'active') }

      before do
        allow_next_instance_of(BranchesFinder) do |instance|
          allow(instance).to receive(:execute).and_return([stale, active])
        end
      end

      context 'stale' do
        let(:params) { { mode: 'stale' } }

        it 'returns stale branches' do
          is_expected.to eq([[stale], nil, nil])
        end
      end

      context 'active' do
        let(:params) { { mode: 'active' } }

        it 'returns active branches' do
          is_expected.to eq([[active], nil, nil])
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# This service is an adapter used to for the GitLab Import feature, and
# creating a project from a template.
# The latter will under the hood just import an archive supplied by GitLab.
module Projects
  class GitlabProjectsImportService
    include Gitlab::Utils::StrongMemoize
    include Gitlab::TemplateHelper

    attr_reader :current_user, :params

    def initialize(user, import_params, override_params = nil)
      @current_user = user
      @params = import_params.dup
      @override_params = override_params
    end

    def execute
      prepare_template_environment(template_file)

      prepare_import_params

      ::Projects::CreateService.new(current_user, params).execute
    end

    private

    def overwrite_project?
      overwrite? && project_with_same_full_path?
    end

    def project_with_same_full_path?
      Project.find_by_full_path(project_path).present?
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def current_namespace
      strong_memoize(:current_namespace) do
        Namespace.find_by(id: params[:namespace_id]) || current_user.namespace
      end
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def project_path
      ""#{current_namespace.full_path}/#{params[:path]}""
    end

    def overwrite?
      strong_memoize(:overwrite) do
        params.delete(:overwrite)
      end
    end

    def template_file
      strong_memoize(:template_file) do
        params.delete(:file)
      end
    end

    def prepare_import_params
      data = {}
      data[:override_params] = @override_params if @override_params

      if overwrite_project?
        data[:original_path] = params[:path]
        params[:path] += ""-#{tmp_filename}""
      end

      if template_file
        data[:sample_data] = params.delete(:sample_data) if params.key?(:sample_data)
        params[:import_type] = 'gitlab_project'
      end

      params[:import_data] = { data: data } if data.present?
    end
  end
end

Projects::GitlabProjectsImportService.prepend_mod_with('Projects::GitlabProjectsImportService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::GitlabProjectsImportService, feature_category: :importers do
  let_it_be(:namespace) { create(:namespace) }

  let(:path) { 'test-path' }
  let(:file) { fixture_file_upload('spec/fixtures/project_export.tar.gz') }
  let(:overwrite) { false }
  let(:import_params) { { namespace_id: namespace.id, path: path, file: file, overwrite: overwrite } }

  subject { described_class.new(namespace.owner, import_params) }

  describe '#execute' do
    it_behaves_like 'gitlab projects import validations'
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  # Service class for counting and caching the number of all merge requests of
  # a project.
  class AllMergeRequestsCountService < Projects::CountService
    def relation_for_count
      @project.merge_requests
    end

    def cache_key_name
      'all_merge_requests_count'
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::AllMergeRequestsCountService, :use_clean_rails_memory_store_caching, feature_category: :groups_and_projects do
  let_it_be(:project) { create(:project) }

  subject { described_class.new(project) }

  it_behaves_like 'a counter caching service'

  describe '#count' do
    it 'returns the number of all merge requests' do
      create(:merge_request, :opened, source_project: project, target_project: project)
      create(:merge_request, :closed, source_project: project, target_project: project)
      create(:merge_request, :merged, source_project: project, target_project: project)

      expect(subject.count).to eq(3)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  # Service class for counting and caching the number of all issues of a
  # project.
  class AllIssuesCountService < Projects::CountService
    def relation_for_count
      @project.issues
    end

    def cache_key_name
      'all_issues_count'
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::AllIssuesCountService, :use_clean_rails_memory_store_caching, feature_category: :groups_and_projects do
  let_it_be(:group) { create(:group, :public) }
  let_it_be(:project) { create(:project, :public, namespace: group) }
  let_it_be(:banned_user) { create(:user, :banned) }

  subject { described_class.new(project) }

  it_behaves_like 'a counter caching service'

  describe '#count' do
    it 'returns the number of all issues' do
      create(:issue, :opened, project: project)
      create(:issue, :opened, confidential: true, project: project)
      create(:issue, :opened, author: banned_user, project: project)
      create(:issue, :closed, project: project)

      expect(subject.count).to eq(4)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class ParticipantsService < BaseService
    include Users::ParticipableService

    def execute(noteable)
      @noteable = noteable

      participants =
        noteable_owner +
        participants_in_noteable +
        all_members +
        project_members +
        groups

      render_participants_as_hash(participants.uniq)
    end

    def project_members
      @project_members ||= sorted(project.authorized_users)
    end

    def all_members
      return [] if Feature.enabled?(:disable_all_mention)

      [{ username: ""all"", name: ""All Project and Group Members"", count: project_members.count }]
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::ParticipantsService, feature_category: :groups_and_projects do
  describe '#execute' do
    let_it_be(:user) { create(:user) }
    let_it_be(:project) { create(:project, :public) }
    let_it_be(:noteable) { create(:issue, project: project) }

    before_all do
      project.add_developer(user)

      stub_feature_flags(disable_all_mention: false)
    end

    def run_service
      described_class.new(project, user).execute(noteable)
    end

    it 'returns results in correct order' do
      group = create(:group).tap { |g| g.add_owner(user) }

      expect(run_service.pluck(:username)).to eq([
        noteable.author.username, 'all', user.username, group.full_path
      ])
    end

    it 'includes `All Project and Group Members`' do
      expect(run_service).to include(a_hash_including({ username: ""all"", name: ""All Project and Group Members"" }))
    end

    context 'N+1 checks' do
      before do
        run_service # warmup, runs table cache queries and create queries
        BatchLoader::Executor.clear_current
      end

      it 'avoids N+1 UserDetail queries' do
        project.add_developer(create(:user))

        control_count = ActiveRecord::QueryRecorder.new { run_service.to_a }.count

        BatchLoader::Executor.clear_current

        project.add_developer(create(:user, status: build(:user_status, availability: :busy)))

        expect { run_service.to_a }.not_to exceed_query_limit(control_count)
      end

      it 'avoids N+1 groups queries' do
        group_1 = create(:group)
        group_1.add_owner(user)

        control_count = ActiveRecord::QueryRecorder.new { run_service }.count

        BatchLoader::Executor.clear_current

        group_2 = create(:group)
        group_2.add_owner(user)

        expect { run_service }.not_to exceed_query_limit(control_count)
      end
    end

    it 'does not return duplicate author' do
      participants = run_service

      expect(participants.count { |p| p[:username] == noteable.author.username }).to eq 1
    end

    describe 'group items' do
      subject(:group_items) { run_service.select { |hash| hash[:type].eql?('Group') } }

      describe 'group user counts' do
        let(:group_1) { create(:group) }
        let(:group_2) { create(:group) }

        before do
          group_1.add_owner(user)
          group_1.add_owner(create(:user))

          group_2.add_owner(user)
          create(:group_member, :access_request, group: group_2, user: create(:user))
        end

        it 'returns correct user counts for groups' do
          expect(group_items).to contain_exactly(
            a_hash_including(name: group_1.full_name, count: 2),
            a_hash_including(name: group_2.full_name, count: 1)
          )
        end
      end

      describe 'avatar_url' do
        let(:group) { create(:group, avatar: fixture_file_upload('spec/fixtures/dk.png')) }

        before do
          group.add_owner(user)
        end

        it 'returns an url for the avatar' do
          expect(group_items.size).to eq 1
          expect(group_items.first[:avatar_url]).to eq(""/uploads/-/system/group/avatar/#{group.id}/dk.png"")
        end

        it 'returns an url for the avatar with relative url' do
          stub_config_setting(relative_url_root: '/gitlab')
          stub_config_setting(url: Settings.send(:build_gitlab_url))

          expect(group_items.size).to eq 1
          expect(group_items.first[:avatar_url]).to eq(""/gitlab/uploads/-/system/group/avatar/#{group.id}/dk.png"")
        end
      end

      context 'with subgroups' do
        let(:group_1) { create(:group, path: 'bb') }
        let(:group_2) { create(:group, path: 'zz') }
        let(:subgroup) { create(:group, path: 'aa', parent: group_1) }

        before do
          group_1.add_owner(user)
          group_2.add_owner(user)
          subgroup.add_owner(user)
        end

        it 'returns results ordered by full path' do
          expect(group_items.pluck(:username)).to eq([
            group_1.full_path, subgroup.full_path, group_2.full_path
          ])
        end
      end
    end

    context 'when `disable_all_mention` FF is enabled' do
      before do
        stub_feature_flags(disable_all_mention: true)
      end

      it 'does not include `All Project and Group Members`' do
        expect(run_service).not_to include(a_hash_including({ username: ""all"", name: ""All Project and Group Members"" }))
      end
    end
  end

  describe '#project_members' do
    subject(:usernames) { service.project_members.map { |member| member[:username] } }

    context 'when there is a project in group namespace' do
      let_it_be(:public_group) { create(:group, :public) }
      let_it_be(:public_project, reload: true) { create(:project, :public, namespace: public_group) }

      let_it_be(:public_group_owner) { create(:user) }

      let(:service) { described_class.new(public_project, create(:user)) }

      before do
        public_group.add_owner(public_group_owner)
      end

      it 'returns members of a group' do
        expect(usernames).to include(public_group_owner.username)
      end
    end

    context 'when there is a private group and a public project' do
      let_it_be(:public_group) { create(:group, :public) }
      let_it_be(:private_group) { create(:group, :private, :nested) }
      let_it_be(:public_project, reload: true) { create(:project, :public, namespace: public_group) }

      let_it_be(:project_issue) { create(:issue, project: public_project) }

      let_it_be(:public_group_owner) { create(:user) }
      let_it_be(:private_group_member) { create(:user) }
      let_it_be(:public_project_maintainer) { create(:user) }
      let_it_be(:private_group_owner) { create(:user) }

      let_it_be(:group_ancestor_owner) { create(:user) }

      before_all do
        public_group.add_owner public_group_owner
        private_group.add_developer private_group_member
        public_project.add_maintainer public_project_maintainer

        private_group.add_owner private_group_owner
        private_group.parent.add_owner group_ancestor_owner
      end

      context 'when the private group is invited to the public project' do
        before_all do
          create(:project_group_link, group: private_group, project: public_project)
        end

        let(:service) { described_class.new(public_project, create(:user)) }

        it 'does not return the private group' do
          expect(usernames).not_to include(private_group.name)
        end

        it 'returns private group members' do
          expect(usernames).to include(private_group_member.username)
        end

        it 'returns the project maintainer' do
          expect(usernames).to include(public_project_maintainer.username)
        end

        it 'returns project members from an invited public group' do
          invited_public_group = create(:group, :public)
          invited_public_group.add_owner create(:user)

          create(:project_group_link, group: invited_public_group, project: public_project)

          expect(usernames).to include(invited_public_group.users.first.username)
        end

        it 'returns members of the ancestral groups of the private group' do
          expect(usernames).to include(group_ancestor_owner.username)
        end

        it 'returns invited group members of the private group' do
          invited_group = create(:group, :public)
          create(:group_group_link, shared_group: private_group, shared_with_group: invited_group)

          other_user = create(:user)
          invited_group.add_guest(other_user)

          expect(usernames).to include(other_user.username)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class MoveNotificationSettingsService < BaseMoveRelationsService
    def execute(source_project, remove_remaining_elements: true)
      return unless super

      Project.transaction do
        move_notification_settings
        remove_remaining_notification_settings if remove_remaining_elements

        success
      end
    end

    private

    def move_notification_settings
      non_existent_notifications.update_all(source_id: @project.id)
    end

    # Remove remaining notification settings from source_project
    def remove_remaining_notification_settings
      source_project.notification_settings.destroy_all # rubocop: disable Cop/DestroyAll
    end

    # Get users of current notification_settings
    def users_in_target_project
      @project.notification_settings.select(:user_id)
    end

    # Look for notification_settings in source_project that are not in the target project
    # rubocop: disable CodeReuse/ActiveRecord
    def non_existent_notifications
      source_project.notification_settings
        .select(:id)
        .where.not(user_id: users_in_target_project)
    end
    # rubocop: enable CodeReuse/ActiveRecord
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::MoveNotificationSettingsService, feature_category: :groups_and_projects do
  let(:user) { create(:user) }
  let(:project_with_notifications) { create(:project, namespace: user.namespace) }
  let(:target_project) { create(:project, namespace: user.namespace) }

  subject { described_class.new(target_project, user) }

  describe '#execute' do
    context 'with notification settings' do
      before do
        create_list(:notification_setting, 2, source: project_with_notifications)
      end

      it 'moves the user\'s notification settings from one project to another' do
        expect(project_with_notifications.notification_settings.count).to eq 3
        expect(target_project.notification_settings.count).to eq 1

        subject.execute(project_with_notifications)

        expect(project_with_notifications.notification_settings.count).to eq 0
        expect(target_project.notification_settings.count).to eq 3
      end

      it 'rollbacks changes if transaction fails' do
        allow(subject).to receive(:success).and_raise(StandardError)

        expect { subject.execute(project_with_notifications) }.to raise_error(StandardError)

        expect(project_with_notifications.notification_settings.count).to eq 3
        expect(target_project.notification_settings.count).to eq 1
      end
    end

    it 'does not move existent notification settings in the current project' do
      expect(project_with_notifications.notification_settings.count).to eq 1
      expect(target_project.notification_settings.count).to eq 1
      expect(user.notification_settings.count).to eq 2

      subject.execute(project_with_notifications)

      expect(user.notification_settings.count).to eq 1
    end

    context 'when remove_remaining_elements is false' do
      let(:options) { { remove_remaining_elements: false } }

      it 'does not remove remaining notification settings' do
        subject.execute(project_with_notifications, **options)

        expect(project_with_notifications.notification_settings.count).not_to eq 0
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class OverwriteProjectService < BaseService
    def execute(source_project)
      return unless source_project && source_project.namespace_id == @project.namespace_id

      start_time = ::Gitlab::Metrics::System.monotonic_time
      original_source_name = source_project.name
      original_source_path = source_project.path
      tmp_source_name, tmp_source_path = tmp_source_project_name(source_project)

      move_relationships_between(source_project, @project)

      source_project_rename = rename_project(source_project, tmp_source_name, tmp_source_path)

      if source_project_rename[:status] == :error
        raise 'Source project rename failed during project overwrite'
      end

      new_project_rename = rename_project(@project, original_source_name, original_source_path)

      if new_project_rename[:status] == :error
        rename_project(source_project, original_source_name, original_source_path)

        raise 'New project rename failed during project overwrite'
      end

      schedule_source_project_deletion(source_project)

      @project
    rescue StandardError => e
      move_relationships_between(@project, source_project)
      remove_source_project_from_fork_network(source_project)

      raise e
    ensure
      track_service(start_time, source_project, e)
    end

    private

    def track_service(start_time, source_project, exception)
      return if ::Feature.disabled?(:project_overwrite_service_tracking, source_project)

      duration = ::Gitlab::Metrics::System.monotonic_time - start_time

      Gitlab::AppJsonLogger.info(
        class: self.class.name,
        namespace_id: source_project.namespace_id,
        project_id: source_project.id,
        duration_s: duration.to_f,
        error: exception.class.name
      )
    end

    def move_relationships_between(source_project, target_project)
      options = { remove_remaining_elements: false }

      Project.transaction do
        ::Projects::MoveUsersStarProjectsService.new(target_project, @current_user).execute(source_project, **options)
        ::Projects::MoveAccessService.new(target_project, @current_user).execute(source_project, **options)
        ::Projects::MoveDeployKeysProjectsService.new(target_project, @current_user).execute(source_project, **options)
        ::Projects::MoveNotificationSettingsService.new(target_project, @current_user).execute(source_project, **options)
        ::Projects::MoveForksService.new(target_project, @current_user).execute(source_project, **options)
        ::Projects::MoveLfsObjectsProjectsService.new(target_project, @current_user).execute(source_project, **options)

        add_source_project_to_fork_network(source_project)
      end
    end

    def schedule_source_project_deletion(source_project)
      ::Projects::DestroyService.new(source_project, @current_user).async_execute
    end

    def rename_project(target_project, name, path)
      ::Projects::UpdateService.new(target_project, @current_user, { name: name, path: path }).execute
    end

    def add_source_project_to_fork_network(source_project)
      return if source_project == @project
      return unless fork_network

      # Because they have moved all references in the fork network from the source_project
      # we won't be able to query the database (only through its cached data),
      # for its former relationships. That's why we're adding it to the network
      # as a fork of the target project
      ForkNetworkMember.create!(
        fork_network: fork_network,
        project: source_project,
        forked_from_project: @project
      )
    end

    def remove_source_project_from_fork_network(source_project)
      return unless fork_network

      fork_member = ForkNetworkMember.find_by( # rubocop: disable CodeReuse/ActiveRecord
        fork_network: fork_network,
        project: source_project,
        forked_from_project: @project)

      fork_member&.destroy
    end

    def tmp_source_project_name(source_project)
      random_string = SecureRandom.hex
      tmp_name = ""#{source_project.name}-old-#{random_string}""
      tmp_path = ""#{source_project.path}-old-#{random_string}""

      [tmp_name, tmp_path]
    end

    def fork_network
      @project.fork_network_member&.fork_network
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::OverwriteProjectService, feature_category: :groups_and_projects do
  include ProjectForksHelper

  let(:user) { create(:user) }
  let(:project_from) { create(:project, namespace: user.namespace) }
  let(:project_to) { create(:project, namespace: user.namespace) }
  let!(:lvl1_forked_project_1) { fork_project(project_from, user) }
  let!(:lvl1_forked_project_2) { fork_project(project_from, user) }
  let!(:lvl2_forked_project_1_1) { fork_project(lvl1_forked_project_1, user) }
  let!(:lvl2_forked_project_1_2) { fork_project(lvl1_forked_project_1, user) }

  subject { described_class.new(project_to, user) }

  before do
    project_to.project_feature.reload

    allow(project_to).to receive(:import_data).and_return(double(data: { 'original_path' => project_from.path }))
  end

  describe '#execute' do
    shared_examples 'overwrite actions' do
      it 'moves deploy keys' do
        deploy_keys_count = project_from.deploy_keys_projects.count

        subject.execute(project_from)

        expect(project_to.deploy_keys_projects.count).to eq deploy_keys_count
      end

      it 'moves notification settings' do
        notification_count = project_from.notification_settings.count

        subject.execute(project_from)

        expect(project_to.notification_settings.count).to eq notification_count
      end

      it 'moves users stars' do
        stars_count = project_from.users_star_projects.count

        subject.execute(project_from)
        project_to.reload

        expect(project_to.users_star_projects.count).to eq stars_count
        expect(project_to.star_count).to eq stars_count
      end

      it 'moves project group links' do
        group_links_count = project_from.project_group_links.count

        subject.execute(project_from)

        expect(project_to.project_group_links.count).to eq group_links_count
      end

      it 'moves memberships and authorizations' do
        members_count = project_from.project_members.count
        project_authorizations = project_from.project_authorizations.count

        subject.execute(project_from)

        expect(project_to.project_members.count).to eq members_count
        expect(project_to.project_authorizations.count).to eq project_authorizations
      end

      context 'moves lfs objects relationships' do
        before do
          create_list(:lfs_objects_project, 3, project: project_from)
        end

        it do
          lfs_objects_count = project_from.lfs_objects.count

          subject.execute(project_from)

          expect(project_to.lfs_objects.count).to eq lfs_objects_count
        end
      end

      it 'schedules original project for deletion' do
        expect_next_instance_of(Projects::DestroyService) do |service|
          expect(service).to receive(:async_execute)
        end

        subject.execute(project_from)
      end

      it 'renames the project' do
        original_path = project_from.full_path

        subject.execute(project_from)

        expect(project_to.full_path).to eq(original_path)
      end

      it 'renames source project to temp name' do
        allow(SecureRandom).to receive(:hex).and_return('test')

        subject.execute(project_from)

        expect(project_from.full_path).to include('-old-test')
      end

      context 'when project rename fails' do
        before do
          expect(subject).to receive(:move_relationships_between).with(project_from, project_to)
          expect(subject).to receive(:move_relationships_between).with(project_to, project_from)
        end

        context 'source rename' do
          it 'moves relations back to source project and raises an exception' do
            allow(subject).to receive(:rename_project).and_return(status: :error)

            expect { subject.execute(project_from) }.to raise_error(StandardError, 'Source project rename failed during project overwrite')
          end
        end

        context 'new project rename' do
          it 'moves relations back, renames source project back to original name and raises' do
            name = project_from.name
            path = project_from.path

            allow(subject).to receive(:rename_project).and_call_original
            allow(subject).to receive(:rename_project).with(project_to, name, path).and_return(status: :error)

            expect { subject.execute(project_from) }.to raise_error(StandardError, 'New project rename failed during project overwrite')

            expect(project_from.name).to eq(name)
            expect(project_from.path).to eq(path)
          end
        end
      end
    end

    context 'when project does not have any relation' do
      it_behaves_like 'overwrite actions'
    end

    context 'when project with elements' do
      it_behaves_like 'overwrite actions' do
        let(:maintainer_user) { create(:user) }
        let(:reporter_user) { create(:user) }
        let(:developer_user) { create(:user) }
        let(:maintainer_group) { create(:group) }
        let(:reporter_group) { create(:group) }
        let(:developer_group) { create(:group) }

        before do
          create_list(:deploy_keys_project, 2, project: project_from)
          create_list(:notification_setting, 2, source: project_from)
          create_list(:users_star_project, 2, project: project_from)
          project_from.project_group_links.create!(group: maintainer_group, group_access: Gitlab::Access::MAINTAINER)
          project_from.project_group_links.create!(group: developer_group, group_access: Gitlab::Access::DEVELOPER)
          project_from.project_group_links.create!(group: reporter_group, group_access: Gitlab::Access::REPORTER)
          project_from.add_maintainer(maintainer_user)
          project_from.add_developer(developer_user)
          project_from.add_reporter(reporter_user)
        end
      end
    end

    context 'forks', :sidekiq_inline do
      context 'when moving a root forked project' do
        it 'moves the descendant forks' do
          expect(project_from.forks.count).to eq 2
          expect(project_to.forks.count).to eq 0

          subject.execute(project_from)

          expect(project_from.forks.count).to eq 0
          expect(project_to.forks.count).to eq 2
          expect(lvl1_forked_project_1.forked_from_project).to eq project_to
          expect(lvl1_forked_project_1.fork_network_member.forked_from_project).to eq project_to
          expect(lvl1_forked_project_2.forked_from_project).to eq project_to
          expect(lvl1_forked_project_2.fork_network_member.forked_from_project).to eq project_to
        end

        it 'updates the fork network' do
          expect(project_from.fork_network.root_project).to eq project_from
          expect(project_from.fork_network.fork_network_members.map(&:project)).to include project_from

          subject.execute(project_from)

          expect(project_to.reload.fork_network.root_project).to eq project_to
          expect(project_to.fork_network.fork_network_members.map(&:project)).not_to include project_from
        end
      end

      context 'when moving a intermediate forked project' do
        let(:project_to) { create(:project, namespace: lvl1_forked_project_1.namespace) }

        it 'moves the descendant forks' do
          expect(lvl1_forked_project_1.forks.count).to eq 2
          expect(project_to.forks.count).to eq 0

          subject.execute(lvl1_forked_project_1)

          expect(lvl1_forked_project_1.forks.count).to eq 0
          expect(project_to.forks.count).to eq 2
          expect(lvl2_forked_project_1_1.forked_from_project).to eq project_to
          expect(lvl2_forked_project_1_1.fork_network_member.forked_from_project).to eq project_to
          expect(lvl2_forked_project_1_2.forked_from_project).to eq project_to
          expect(lvl2_forked_project_1_2.fork_network_member.forked_from_project).to eq project_to
        end

        it 'moves the ascendant fork' do
          subject.execute(lvl1_forked_project_1)

          expect(project_to.reload.forked_from_project).to eq project_from
          expect(project_to.fork_network_member.forked_from_project).to eq project_from
        end

        it 'does not update fork network' do
          subject.execute(lvl1_forked_project_1)

          expect(project_to.reload.fork_network.root_project).to eq project_from
        end
      end
    end

    context 'if an exception is raised' do
      before do
        allow(subject).to receive(:rename_project).and_raise(StandardError)
      end

      it 'rollbacks changes' do
        updated_at = project_from.updated_at

        expect { subject.execute(project_from) }.to raise_error(StandardError)
        expect(Project.find(project_from.id)).not_to be_nil
        expect(project_from.reload.updated_at.change(usec: 0)).to eq updated_at.change(usec: 0)
      end

      it 'removes fork network member' do
        expect(ForkNetworkMember).to receive(:create!)
        expect(ForkNetworkMember).to receive(:find_by)
        expect(subject).to receive(:remove_source_project_from_fork_network).and_call_original

        expect { subject.execute(project_from) }.to raise_error(StandardError)

        expect(project_from.fork_network_member).to be_nil
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class CreateFromTemplateService < BaseService
    include Gitlab::Utils::StrongMemoize

    attr_reader :template_name

    def initialize(user, params)
      @current_user = user
      @params = params.to_h.dup
      @template_name = @params.delete(:template_name).presence
    end

    def execute
      return project unless validate_template!

      file = built_in_template&.file || sample_data_template&.file

      override_params = params.dup

      if built_in_template
        params[:file] = built_in_template.file
      elsif sample_data_template
        params[:file] = sample_data_template.file
        params[:sample_data] = true
      end

      GitlabProjectsImportService.new(current_user, params, override_params).execute
    ensure
      file&.close
    end

    private

    def validate_template!
      return true if built_in_template || sample_data_template

      project.errors.add(:template_name, _(""'%{template_name}' is unknown or invalid"" % { template_name: template_name }))
      false
    end

    def built_in_template
      strong_memoize(:built_in_template) do
        Gitlab::ProjectTemplate.find(template_name)
      end
    end

    def sample_data_template
      strong_memoize(:sample_data_template) do
        Gitlab::SampleDataTemplate.find(template_name)
      end
    end

    def project
      @project ||= ::Project.new(namespace_id: params[:namespace_id])
    end
  end
end

Projects::CreateFromTemplateService.prepend_mod_with('Projects::CreateFromTemplateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::CreateFromTemplateService, feature_category: :groups_and_projects do
  let(:user) { create(:user) }
  let(:template_name) { 'rails' }
  let(:project_params) do
    {
        path: user.to_param,
        template_name: template_name,
        description: 'project description',
        visibility_level: Gitlab::VisibilityLevel::PUBLIC
    }
  end

  subject { described_class.new(user, project_params) }

  it 'calls the importer service' do
    import_service_double = double

    allow(Projects::GitlabProjectsImportService).to receive(:new).and_return(import_service_double)
    expect(import_service_double).to receive(:execute)

    subject.execute
  end

  it 'returns the project that is created' do
    project = subject.execute

    expect(project).to be_saved
    expect(project.import_scheduled?).to be(true)
  end

  context 'when template is not present' do
    let(:template_name) { 'non_existent' }
    let(:project) { subject.execute }

    before do
      expect(project).not_to be_saved
    end

    it 'does not set import set import type' do
      expect(project.import_type).to be nil
    end

    it 'does not set import set import source' do
      expect(project.import_source).to be nil
    end

    it 'is not scheduled' do
      expect(project.import_scheduled?).to be(false)
    end

    it 'repository is empty' do
      expect(project.repository.empty?).to be(true)
    end
  end

  context 'the result project' do
    before do
      perform_enqueued_jobs do
        @project = subject.execute
      end

      @project.reload
    end

    it 'overrides template description' do
      expect(@project.description).to match('project description')
    end

    it 'overrides template visibility_level' do
      expect(@project.visibility_level).to eq(Gitlab::VisibilityLevel::PUBLIC)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class DownloadService < BaseService
    ALLOWLIST = [
      /^[^.]+\.fogbugz.com$/
    ].freeze

    def initialize(project, url)
      @project = project
      @url = url
    end

    def execute
      return unless valid_url?(@url)

      uploader = FileUploader.new(@project)
      uploader.download!(@url)
      uploader.store!

      uploader.to_h
    end

    private

    def valid_url?(url)
      url && http?(url) && valid_domain?(url)
    end

    def http?(url)
      url =~ /\A#{URI::DEFAULT_PARSER.make_regexp(%w[http https])}\z/
    end

    def valid_domain?(url)
      host = URI.parse(url).host
      ALLOWLIST.any? { |entry| entry === host }
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::DownloadService, feature_category: :groups_and_projects do
  describe 'File service' do
    before do
      @user = create(:user)
      @project = create(:project, creator_id: @user.id, namespace: @user.namespace)
    end

    context 'for a URL that is not on allowlist' do
      before do
        url = 'https://code.jquery.com/jquery-2.1.4.min.js'
        @link_to_file = download_file(@project, url)
      end

      it { expect(@link_to_file).to eq(nil) }
    end

    context 'for URLs that are on the allowlist' do
      before do
        # `ssrf_filter` resolves the hostname. See https://github.com/carrierwaveuploader/carrierwave/commit/91714adda998bc9e8decf5b1f5d260d808761304
        stub_request(:get, %r{http://[\d.]+/rails_sample.jpg}).to_return(body: File.read(Rails.root + 'spec/fixtures/rails_sample.jpg'))
        stub_request(:get, %r{http://[\d.]+/doc_sample.txt}).to_return(body: File.read(Rails.root + 'spec/fixtures/doc_sample.txt'))
      end

      context 'an image file' do
        before do
          url = 'http://mycompany.fogbugz.com/rails_sample.jpg'
          @link_to_file = download_file(@project, url)
        end

        it { expect(@link_to_file).to have_key(:alt) }
        it { expect(@link_to_file).to have_key(:url) }
        it { expect(@link_to_file[:url]).to match('rails_sample.jpg') }
        it { expect(@link_to_file[:alt]).to eq('rails_sample') }
      end

      context 'a txt file' do
        before do
          url = 'http://mycompany.fogbugz.com/doc_sample.txt'
          @link_to_file = download_file(@project, url)
        end

        it { expect(@link_to_file).to have_key(:alt) }
        it { expect(@link_to_file).to have_key(:url) }
        it { expect(@link_to_file[:url]).to match('doc_sample.txt') }
        it { expect(@link_to_file[:alt]).to eq('doc_sample.txt') }
      end
    end
  end

  def download_file(repository, url)
    Projects::DownloadService.new(repository, url).execute
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class RepositoryLanguagesService < BaseService
    def execute
      perform_language_detection unless project.detected_repository_languages?
      persisted_repository_languages
    end

    private

    def perform_language_detection
      if persisted_repository_languages.blank?
        ::DetectRepositoryLanguagesWorker.perform_async(project.id)
      else
        project.update_column(:detected_repository_languages, true)
      end
    end

    def persisted_repository_languages
      project.repository_languages
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::RepositoryLanguagesService, feature_category: :source_code_management do
  let(:service) { described_class.new(project, project.first_owner) }

  context 'when detected_repository_languages flag is set' do
    let(:project) { create(:project) }

    context 'when a project is without detected programming languages' do
      it 'schedules a worker and returns the empty result' do
        expect(::DetectRepositoryLanguagesWorker).to receive(:perform_async).with(project.id)
        expect(service.execute).to eq([])
      end
    end

    context 'when a project is with detected programming languages' do
      let!(:repository_language) { create(:repository_language, project: project) }

      it 'does not schedule a worker and returns the detected languages' do
        expect(::DetectRepositoryLanguagesWorker).not_to receive(:perform_async).with(project.id)

        languages = service.execute

        expect(languages.size).to eq(1)
        expect(languages.last.attributes.values).to eq(
          [project.id, repository_language.programming_language_id, repository_language.share]
        )
      end

      it 'sets detected_repository_languages flag' do
        expect { service.execute }.to change(project, :detected_repository_languages).from(nil).to(true)
      end
    end
  end

  context 'when detected_repository_languages flag is not set' do
    let!(:repository_language) { create(:repository_language, project: project) }
    let(:project) { create(:project, detected_repository_languages: true) }
    let(:languages) { service.execute }

    it 'returns repository languages' do
      expect(languages.size).to eq(1)
      expect(languages.last.attributes.values).to eq(
        [project.id, repository_language.programming_language_id, repository_language.share]
      )
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Projects::TransferService class
#
# Used to transfer a project to another namespace
#
# Ex.
#   # Move project to namespace by user
#   Projects::TransferService.new(project, user).execute(namespace)
#
module Projects
  class TransferService < BaseService
    include Gitlab::ShellAdapter
    TransferError = Class.new(StandardError)

    def log_project_transfer_success(project, new_namespace)
      log_transfer(project, new_namespace, nil)
    end

    def log_project_transfer_error(project, new_namespace, error_message)
      log_transfer(project, new_namespace, error_message)
    end

    def execute(new_namespace)
      @new_namespace = new_namespace

      if @new_namespace.blank?
        raise TransferError, s_('TransferProject|Please select a new namespace for your project.')
      end

      if @new_namespace.id == project.namespace_id
        raise TransferError, s_('TransferProject|Project is already in this namespace.')
      end

      unless allowed_transfer_project?(current_user, project)
        raise TransferError, s_(""TransferProject|You don't have permission to transfer this project."")
      end

      unless allowed_to_transfer_to_namespace?(current_user, @new_namespace)
        raise TransferError, s_(""TransferProject|You don't have permission to transfer projects into that namespace."")
      end

      @owner_of_personal_project_before_transfer = project.namespace.owner if project.personal?

      transfer(project)

      log_project_transfer_success(project, @new_namespace)

      true
    rescue Projects::TransferService::TransferError => ex
      project.reset
      project.errors.add(:new_namespace, ex.message)

      log_project_transfer_error(project, @new_namespace, ex.message)

      false
    end

    private

    attr_reader :old_path, :new_path, :new_namespace, :old_namespace

    def log_transfer(project, new_namespace, error_message = nil)
      action = error_message.nil? ? ""was"" : ""was not""

      log_payload = {
        message: ""Project #{action} transferred to a new namespace"",
        project_id: project.id,
        project_path: project.full_path,
        project_namespace: project.namespace.full_path,
        namespace_id: project.namespace_id,
        new_namespace_id: new_namespace&.id,
        new_project_namespace: new_namespace&.full_path,
        error_message: error_message
      }

      if error_message.nil?
        ::Gitlab::AppLogger.info(log_payload)
      else
        ::Gitlab::AppLogger.error(log_payload)
      end
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def transfer(project)
      @old_path = project.full_path
      @old_group = project.group
      @new_path = File.join(@new_namespace.try(:full_path) || '', project.path)
      @old_namespace = project.namespace

      if Project.where(namespace_id: @new_namespace.try(:id)).where('path = ? or name = ?', project.path, project.name).exists?
        raise TransferError, s_(""TransferProject|Project with same name or path in target namespace already exists"")
      end

      if project.has_container_registry_tags?
        # We currently don't support renaming repository if it contains tags in container registry
        raise TransferError, s_('TransferProject|Project cannot be transferred, because tags are present in its container registry')
      end

      if !new_namespace_has_same_root?(project) && project.has_namespaced_npm_packages?
        raise TransferError, s_(""TransferProject|Root namespace can't be updated if the project has NPM packages scoped to the current root level namespace."")
      end

      proceed_to_transfer
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def new_namespace_has_same_root?(project)
      new_namespace.root_ancestor == project.namespace.root_ancestor
    end

    def proceed_to_transfer
      Gitlab::Database::QueryAnalyzers::PreventCrossDatabaseModification.temporary_ignore_tables_in_transaction(
        %w[routes redirect_routes], url: 'https://gitlab.com/gitlab-org/gitlab/-/issues/424282'
      ) do
        Project.transaction do
          project.expire_caches_before_rename(@old_path)

          # Apply changes to the project
          update_namespace_and_visibility(@new_namespace)
          project.reconcile_shared_runners_setting!
          project.save!

          # Notifications
          project.send_move_instructions(@old_path)

          transfer_missing_group_resources(@old_group)

          # Move uploads
          move_project_uploads(project)

          update_integrations

          remove_paid_features

          project.old_path_with_namespace = @old_path

          update_repository_configuration(@new_path)

          remove_issue_contacts

          execute_system_hooks
        end
      end

      update_pending_builds

      post_update_hooks(project, @old_group)
    rescue Exception # rubocop:disable Lint/RescueException
      rollback_side_effects
      raise
    ensure
      refresh_permissions
    end

    # Overridden in EE
    def post_update_hooks(project, _old_group)
      ensure_personal_project_owner_membership(project)
      invalidate_personal_projects_counts

      publish_event
    end

    # Overridden in EE
    def remove_paid_features
    end

    def invalidate_personal_projects_counts
      # If the project was moved out of a personal namespace,
      # the cache of the namespace owner, before the transfer, should be cleared.
      if @owner_of_personal_project_before_transfer.present?
        @owner_of_personal_project_before_transfer.invalidate_personal_projects_count
      end

      # If the project has now moved into a personal namespace,
      # the cache of the target namespace owner should be cleared.
      project.invalidate_personal_projects_count_of_owner
    end

    def transfer_missing_group_resources(group)
      Labels::TransferService.new(current_user, group, project).execute

      Milestones::TransferService.new(current_user, group, project).execute
    end

    def allowed_transfer_project?(current_user, project)
      current_user.can?(:change_namespace, project)
    end

    def allowed_to_transfer_to_namespace?(current_user, namespace)
      current_user.can?(:transfer_projects, namespace)
    end

    def update_namespace_and_visibility(to_namespace)
      # Apply new namespace id and visibility level
      project.namespace = to_namespace
      project.visibility_level = to_namespace.visibility_level unless project.visibility_level_allowed_by_group?
    end

    def update_repository_configuration(full_path)
      project.set_full_path(gl_full_path: full_path)
      project.track_project_repository
    end

    def ensure_personal_project_owner_membership(project)
      # In case of personal projects, we want to make sure that
      # a membership record with `OWNER` access level exists for the owner of the namespace.
      return unless project.personal?

      namespace_owner = project.namespace.owner
      existing_membership_record = project.member(namespace_owner)

      return if existing_membership_record.present? && existing_membership_record.access_level == Gitlab::Access::OWNER

      project.add_owner(namespace_owner)
    end

    def refresh_permissions
      # This ensures we only schedule 1 job for every user that has access to
      # the namespaces.
      user_ids = @old_namespace.user_ids_for_project_authorizations |
        @new_namespace.user_ids_for_project_authorizations

      AuthorizedProjectUpdate::ProjectRecalculateWorker.perform_async(project.id)

      # Until we compare the inconsistency rates of the new specialized worker and
      # the old approach, we still run AuthorizedProjectsWorker
      # but with some delay and lower urgency as a safety net.
      UserProjectAccessChangedService.new(user_ids).execute(
        priority: UserProjectAccessChangedService::LOW_PRIORITY
      )
    end

    def rollback_side_effects
      project.reset
      update_namespace_and_visibility(@old_namespace)
      update_repository_configuration(@old_path)
    end

    def execute_system_hooks
      system_hook_service.execute_hooks_for(project, :transfer)
    end

    def move_project_uploads(project)
      return if project.hashed_storage?(:attachments)

      Gitlab::UploadsTransfer.new.move_project(
        project.path,
        @old_namespace.full_path,
        @new_namespace.full_path
      )
    end

    def old_wiki_repo_path
      ""#{old_path}#{::Gitlab::GlRepository::WIKI.path_suffix}""
    end

    def new_wiki_repo_path
      ""#{new_path}#{::Gitlab::GlRepository::WIKI.path_suffix}""
    end

    def old_design_repo_path
      ""#{old_path}#{::Gitlab::GlRepository::DESIGN.path_suffix}""
    end

    def new_design_repo_path
      ""#{new_path}#{::Gitlab::GlRepository::DESIGN.path_suffix}""
    end

    def update_integrations
      project.integrations.with_default_settings.delete_all
      Integration.create_from_active_default_integrations(project, :project_id)
    end

    def update_pending_builds
      ::Ci::PendingBuilds::UpdateProjectWorker.perform_async(project.id, pending_builds_params)
    end

    def pending_builds_params
      {
        namespace_id: new_namespace.id,
        namespace_traversal_ids: new_namespace.traversal_ids
      }
    end

    def remove_issue_contacts
      return unless @old_group&.root_ancestor != @new_namespace&.root_ancestor

      CustomerRelations::IssueContact.delete_for_project(project.id)
    end

    def publish_event
      event = ::Projects::ProjectTransferedEvent.new(data: {
        project_id: project.id,
        old_namespace_id: old_namespace.id,
        old_root_namespace_id: old_namespace.root_ancestor.id,
        new_namespace_id: new_namespace.id,
        new_root_namespace_id: new_namespace.root_ancestor.id
      })

      Gitlab::EventStore.publish(event)
    end
  end
end

Projects::TransferService.prepend_mod_with('Projects::TransferService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::TransferService, feature_category: :groups_and_projects do
  let_it_be(:group) { create(:group) }
  let_it_be(:user) { create(:user) }
  let_it_be(:group_integration) { create(:integrations_slack, :group, group: group, webhook: 'http://group.slack.com') }

  let(:project) { create(:project, :repository, :legacy_storage, namespace: user.namespace) }
  let(:target) { group }
  let(:executor) { user }

  subject(:execute_transfer) { described_class.new(project, executor).execute(target).tap { project.reload } }

  context 'with npm packages' do
    before do
      group.add_owner(user)
    end

    subject(:transfer_service) { described_class.new(project, user) }

    let!(:package) { create(:npm_package, project: project, name: ""@testscope/test"") }

    context 'with a root namespace change' do
      it 'allow the transfer' do
        expect(transfer_service.execute(group)).to be true
        expect(project.errors[:new_namespace]).to be_empty
      end
    end

    context 'with pending destruction package' do
      before do
        package.pending_destruction!
      end

      it 'allow the transfer' do
        expect(transfer_service.execute(group)).to be true
        expect(project.errors[:new_namespace]).to be_empty
      end
    end

    context 'with namespaced packages present' do
      let!(:package) { create(:npm_package, project: project, name: ""@#{project.root_namespace.path}/test"") }

      it 'does not allow the transfer' do
        expect(transfer_service.execute(group)).to be false
        expect(project.errors[:new_namespace]).to include(""Root namespace can't be updated if the project has NPM packages scoped to the current root level namespace."")
      end
    end

    context 'without a root namespace change' do
      let(:root) { create(:group) }
      let(:group) { create(:group, parent: root) }
      let(:other_group) { create(:group, parent: root) }
      let(:project) { create(:project, :repository, namespace: group) }

      before do
        other_group.add_owner(user)
      end

      it 'allow the transfer' do
        expect(transfer_service.execute(other_group)).to be true
        expect(project.errors[:new_namespace]).to be_empty
      end
    end
  end

  context 'namespace -> namespace' do
    before do
      allow_next_instance_of(Gitlab::UploadsTransfer) do |service|
        allow(service).to receive(:move_project).and_return(true)
      end

      group.add_owner(user)
    end

    it 'updates the namespace' do
      transfer_result = execute_transfer

      expect(transfer_result).to be_truthy
      expect(project.namespace).to eq(group)
    end

    context 'EventStore' do
      let(:group) do
        create(:group, :nested).tap { |g| g.add_owner(user) }
      end

      let(:target) do
        create(:group, :nested).tap { |g| g.add_owner(user) }
      end

      let(:project) { create(:project, namespace: group) }

      it 'publishes a ProjectTransferedEvent' do
        expect { execute_transfer }
          .to publish_event(Projects::ProjectTransferedEvent)
          .with(
            project_id: project.id,
            old_namespace_id: group.id,
            old_root_namespace_id: group.root_ancestor.id,
            new_namespace_id: target.id,
            new_root_namespace_id: target.root_ancestor.id
          )
      end
    end

    context 'when project has an associated project namespace' do
      it 'keeps project namespace in sync with project' do
        transfer_result = execute_transfer

        expect(transfer_result).to be_truthy

        project_namespace_in_sync(group)
      end

      context 'when project is transferred to a deeper nested group' do
        let(:parent_group) { create(:group) }
        let(:sub_group) { create(:group, parent: parent_group) }
        let(:sub_sub_group) { create(:group, parent: sub_group) }
        let(:group) { sub_sub_group }

        it 'keeps project namespace in sync with project' do
          transfer_result = execute_transfer

          expect(transfer_result).to be_truthy

          project_namespace_in_sync(sub_sub_group)
        end
      end
    end
  end

  context 'project in a group -> a personal namespace', :enable_admin_mode do
    let(:project) { create(:project, :repository, :legacy_storage, group: group) }
    let(:target) { user.namespace }
    # We need to use an admin user as the executor because
    # only an admin user has required permissions to transfer projects
    # under _all_ the different circumstances specified below.
    let(:executor) { create(:user, :admin) }

    it 'executes the transfer to personal namespace successfully' do
      execute_transfer

      expect(project.namespace).to eq(user.namespace)
    end

    it 'invalidates personal_project_count cache of the the owner of the personal namespace' do
      expect(user).to receive(:invalidate_personal_projects_count)

      execute_transfer
    end

    context 'the owner of the namespace does not have a direct membership in the project residing in the group' do
      it 'creates a project membership record for the owner of the namespace, with OWNER access level, after the transfer' do
        execute_transfer

        expect(project.members.owners.find_by(user_id: user.id)).to be_present
      end
    end

    context 'the owner of the namespace has a direct membership in the project residing in the group' do
      context 'that membership has an access level of OWNER' do
        before do
          project.add_owner(user)
        end

        it 'retains the project membership record for the owner of the namespace, with OWNER access level, after the transfer' do
          execute_transfer

          expect(project.members.owners.find_by(user_id: user.id)).to be_present
        end
      end

      context 'that membership has an access level that is not OWNER' do
        before do
          project.add_developer(user)
        end

        it 'updates the project membership record for the owner of the namespace, to OWNER access level, after the transfer' do
          execute_transfer

          expect(project.members.owners.find_by(user_id: user.id)).to be_present
        end
      end
    end
  end

  context 'personal namespace -> group', :enable_admin_mode do
    let(:executor) { create(:admin) }

    it 'invalidates personal_project_count cache of the the owner of the personal namespace' \
       'that previously held the project' do
      expect(user).to receive(:invalidate_personal_projects_count)

      execute_transfer
    end
  end

  context 'when transfer succeeds' do
    before do
      group.add_owner(user)
    end

    it 'sends notifications' do
      expect_any_instance_of(NotificationService).to receive(:project_was_moved)

      execute_transfer
    end

    it 'invalidates the user\'s personal_project_count cache' do
      expect(user).to receive(:invalidate_personal_projects_count)

      execute_transfer
    end

    it 'executes system hooks' do
      expect_next_instance_of(described_class) do |service|
        expect(service).to receive(:execute_system_hooks)
      end

      execute_transfer
    end

    it 'moves the disk path', :aggregate_failures do
      old_path = project.repository.disk_path
      old_full_path = project.repository.full_path

      execute_transfer

      project.reload_repository!

      expect(project.repository.disk_path).not_to eq(old_path)
      expect(project.repository.full_path).not_to eq(old_full_path)
      expect(project.disk_path).not_to eq(old_path)
      expect(project.disk_path).to start_with(group.path)
    end

    it 'updates project full path in gitaly' do
      execute_transfer

      expect(project.repository.full_path).to eq ""#{group.full_path}/#{project.path}""
    end

    it 'updates storage location' do
      execute_transfer

      expect(project.project_repository).to have_attributes(
        disk_path: ""#{group.full_path}/#{project.path}"",
        shard_name: project.repository_storage
      )
    end

    context 'with a project integration' do
      let_it_be_with_reload(:project) { create(:project, namespace: user.namespace) }
      let_it_be(:instance_integration) { create(:integrations_slack, :instance) }
      let_it_be(:project_integration) { create(:integrations_slack, project: project) }

      context 'when it inherits from instance_integration' do
        before do
          project_integration.update!(inherit_from_id: instance_integration.id, webhook: instance_integration.webhook)
        end

        it 'replaces inherited integrations', :aggregate_failures do
          expect { execute_transfer }
            .to change(Integration, :count).by(0)
            .and change { project.slack_integration.webhook }.to eq(group_integration.webhook)
        end
      end

      context 'with a custom integration' do
        it 'does not update the integrations' do
          expect { execute_transfer }.not_to change { project.slack_integration.webhook }
        end
      end
    end

    context 'when project has pending builds', :sidekiq_inline do
      let!(:other_project) { create(:project) }
      let!(:pending_build) { create(:ci_pending_build, project: project.reload) }
      let!(:unrelated_pending_build) { create(:ci_pending_build, project: other_project) }

      before do
        group.reload
      end

      it 'updates pending builds for the project', :aggregate_failures do
        execute_transfer

        pending_build.reload
        unrelated_pending_build.reload

        expect(pending_build.namespace_id).to eq(group.id)
        expect(pending_build.namespace_traversal_ids).to eq(group.traversal_ids)
        expect(unrelated_pending_build.namespace_id).to eq(other_project.namespace_id)
        expect(unrelated_pending_build.namespace_traversal_ids).to eq(other_project.namespace.traversal_ids)
      end
    end
  end

  context 'when transfer fails' do
    let!(:original_path) { project.repository.relative_path }

    def attempt_project_transfer(&block)
      expect do
        execute_transfer
      end.to raise_error(ActiveRecord::ActiveRecordError)
    end

    before do
      group.add_owner(user)

      expect_any_instance_of(Labels::TransferService).to receive(:execute).and_raise(ActiveRecord::StatementInvalid, ""PG ERROR"")
    end

    it 'rolls back repo location' do
      attempt_project_transfer

      expect(project.repository.raw.exists?).to be(true)
      expect(original_path).to eq project.repository.relative_path
    end

    it 'rolls back project full path in gitaly' do
      attempt_project_transfer

      expect(project.repository.full_path).to eq project.full_path
    end

    it ""doesn't send move notifications"" do
      expect_any_instance_of(NotificationService).not_to receive(:project_was_moved)

      attempt_project_transfer
    end

    it ""doesn't run system hooks"" do
      attempt_project_transfer do |service|
        expect(service).not_to receive(:execute_system_hooks)
      end
    end

    it 'does not update storage location' do
      attempt_project_transfer

      expect(project.project_repository).to have_attributes(
        disk_path: project.disk_path,
        shard_name: project.repository_storage
      )
    end

    it 'does not publish a ProjectTransferedEvent' do
      expect { attempt_project_transfer }
        .not_to publish_event(Projects::ProjectTransferedEvent)
    end

    context 'when project has pending builds', :sidekiq_inline do
      let!(:other_project) { create(:project) }
      let!(:pending_build) { create(:ci_pending_build, project: project.reload) }
      let!(:unrelated_pending_build) { create(:ci_pending_build, project: other_project) }

      it 'does not update pending builds for the project', :aggregate_failures do
        attempt_project_transfer

        pending_build.reload
        unrelated_pending_build.reload

        expect(pending_build.namespace_id).to eq(project.namespace_id)
        expect(pending_build.namespace_traversal_ids).to eq(project.namespace.traversal_ids)
        expect(unrelated_pending_build.namespace_id).to eq(other_project.namespace_id)
        expect(unrelated_pending_build.namespace_traversal_ids).to eq(other_project.namespace.traversal_ids)
      end
    end

    context 'when project has an associated project namespace' do
      it 'keeps project namespace in sync with project' do
        attempt_project_transfer

        project_namespace_in_sync(user.namespace)
      end
    end
  end

  context 'namespace -> no namespace' do
    let(:group) { nil }

    it 'does not allow the project transfer' do
      transfer_result = execute_transfer

      expect(transfer_result).to eq false
      expect(project.namespace).to eq(user.namespace)
      expect(project.errors.messages[:new_namespace].first).to eq 'Please select a new namespace for your project.'
    end

    context 'when project has an associated project namespace' do
      it 'keeps project namespace in sync with project' do
        transfer_result = execute_transfer

        expect(transfer_result).to be false

        project_namespace_in_sync(user.namespace)
      end
    end
  end

  context 'disallow transferring of project with tags' do
    let(:container_repository) { create(:container_repository) }

    before do
      stub_container_registry_config(enabled: true)
      stub_container_registry_tags(repository: :any, tags: ['tag'])
      project.container_repositories << container_repository
    end

    it 'does not allow the project transfer' do
      expect(execute_transfer).to eq false
    end
  end

  context 'namespace -> not allowed namespace' do
    it 'does not allow the project transfer' do
      transfer_result = execute_transfer

      expect(transfer_result).to eq false
      expect(project.namespace).to eq(user.namespace)
    end
  end

  context 'target namespace containing the same project name' do
    before do
      group.add_owner(user)
      create(:project, name: project.name, group: group, path: 'other')
    end

    it 'does not allow the project transfer' do
      transfer_result = execute_transfer

      expect(transfer_result).to eq false
      expect(project.namespace).to eq(user.namespace)
      expect(project.errors[:new_namespace]).to include('Project with same name or path in target namespace already exists')
    end
  end

  context 'target namespace containing the same project path' do
    before do
      group.add_owner(user)
      create(:project, name: 'other-name', path: project.path, group: group)
    end

    it 'does not allow the project transfer' do
      transfer_result = execute_transfer

      expect(transfer_result).to eq false
      expect(project.namespace).to eq(user.namespace)
      expect(project.errors[:new_namespace]).to include('Project with same name or path in target namespace already exists')
    end
  end

  context 'target namespace matches current namespace' do
    let(:group) { user.namespace }

    it 'does not allow project transfer' do
      transfer_result = execute_transfer

      expect(transfer_result).to eq false
      expect(project.namespace).to eq(user.namespace)
      expect(project.errors[:new_namespace]).to include('Project is already in this namespace.')
    end
  end

  context 'target namespace belongs to bot user', :enable_admin_mode do
    let(:bot) { create(:user, :project_bot) }
    let(:target) { bot.namespace }
    let(:executor) { create(:user, :admin) }

    it 'does not allow project transfer' do
      namespace = project.namespace

      transfer_result = execute_transfer

      expect(transfer_result).to eq false
      expect(project.namespace).to eq(namespace)
      expect(project.errors[:new_namespace]).to include(""You don't have permission to transfer projects into that namespace."")
    end
  end

  context 'when user does not own the project' do
    let(:project) { create(:project, :repository, :legacy_storage) }

    before do
      project.add_developer(user)
    end

    it 'does not allow project transfer to the target namespace' do
      transfer_result = execute_transfer

      expect(transfer_result).to eq false
      expect(project.errors[:new_namespace]).to include(""You don't have permission to transfer this project."")
    end
  end

  context 'when user can create projects in the target namespace' do
    let(:group) { create(:group, project_creation_level: ::Gitlab::Access::DEVELOPER_MAINTAINER_PROJECT_ACCESS) }

    context 'but has only developer permissions in the target namespace' do
      before do
        group.add_developer(user)
      end

      it 'does not allow project transfer to the target namespace' do
        transfer_result = execute_transfer

        expect(transfer_result).to eq false
        expect(project.namespace).to eq(user.namespace)
        expect(project.errors[:new_namespace]).to include(""You don't have permission to transfer projects into that namespace."")
      end
    end
  end

  context 'visibility level' do
    let(:group) { create(:group, :internal) }

    before do
      group.add_owner(user)
    end

    context 'when namespace visibility level < project visibility level' do
      let(:project) { create(:project, :public, :repository, namespace: user.namespace) }

      before do
        execute_transfer
      end

      it { expect(project.visibility_level).to eq(group.visibility_level) }
    end

    context 'when namespace visibility level > project visibility level' do
      let(:project) { create(:project, :private, :repository, namespace: user.namespace) }

      before do
        execute_transfer
      end

      it { expect(project.visibility_level).to eq(Gitlab::VisibilityLevel::PRIVATE) }
    end
  end

  context 'shared Runners group level configurations' do
    using RSpec::Parameterized::TableSyntax

    where(:project_shared_runners_enabled, :shared_runners_setting, :expected_shared_runners_enabled) do
      true  | :shared_runners_disabled_and_unoverridable | false
      false | :shared_runners_disabled_and_unoverridable | false
      true  | :shared_runners_disabled_and_overridable   | true
      false | :shared_runners_disabled_and_overridable   | false
      true  | :shared_runners_enabled                    | true
      false | :shared_runners_enabled                    | false
    end

    with_them do
      let(:project) { create(:project, :public, :repository, namespace: user.namespace, shared_runners_enabled: project_shared_runners_enabled) }
      let(:group) { create(:group, shared_runners_setting) }

      it 'updates shared runners based on the parent group' do
        group.add_owner(user)

        expect(execute_transfer).to eq(true)

        expect(project.shared_runners_enabled).to eq(expected_shared_runners_enabled)
      end
    end
  end

  context 'missing group labels applied to issues or merge requests' do
    it 'delegates transfer to Labels::TransferService' do
      group.add_owner(user)

      expect_next_instance_of(Labels::TransferService, user, project.group, project) do |labels_transfer_service|
        expect(labels_transfer_service).to receive(:execute).once.and_call_original
      end

      execute_transfer
    end
  end

  context 'missing group milestones applied to issues or merge requests' do
    it 'delegates transfer to Milestones::TransferService' do
      group.add_owner(user)

      expect_next_instance_of(Milestones::TransferService, user, project.group, project) do |milestones_transfer_service|
        expect(milestones_transfer_service).to receive(:execute).once.and_call_original
      end

      execute_transfer
    end
  end

  context 'when hashed storage in use' do
    let!(:project) { create(:project, :repository, namespace: user.namespace) }
    let!(:old_disk_path) { project.repository.disk_path }

    before do
      group.add_owner(user)
    end

    it 'does not move the disk path', :aggregate_failures do
      new_full_path = ""#{group.full_path}/#{project.path}""

      execute_transfer

      project.reload_repository!

      expect(project.repository).to have_attributes(
        disk_path: old_disk_path,
        full_path: new_full_path
      )
      expect(project.disk_path).to eq(old_disk_path)
    end

    it 'does not move the disk path when the transfer fails', :aggregate_failures do
      old_full_path = project.full_path

      expect_next_instance_of(described_class) do |service|
        allow(service).to receive(:execute_system_hooks).and_raise('foo')
      end

      expect { execute_transfer }.to raise_error('foo')

      project.reload_repository!

      expect(project.repository).to have_attributes(
        disk_path: old_disk_path,
        full_path: old_full_path
      )
      expect(project.disk_path).to eq(old_disk_path)
    end
  end

  describe 'refreshing project authorizations' do
    let(:old_group) { create(:group) }
    let!(:project) { create(:project, namespace: old_group) }
    let(:member_of_old_group) { create(:user) }
    let(:group) { create(:group) }
    let(:member_of_new_group) { create(:user) }

    before do
      old_group.add_developer(member_of_old_group)
      group.add_maintainer(member_of_new_group)

      # Add the executing user as owner in both groups, so that
      # transfer can be executed.
      old_group.add_owner(user)
      group.add_owner(user)
    end

    it 'calls AuthorizedProjectUpdate::ProjectRecalculateWorker to update project authorizations' do
      expect(AuthorizedProjectUpdate::ProjectRecalculateWorker)
        .to receive(:perform_async).with(project.id)

      execute_transfer
    end

    it 'calls AuthorizedProjectUpdate::UserRefreshFromReplicaWorker with a delay to update project authorizations' do
      stub_feature_flags(do_not_run_safety_net_auth_refresh_jobs: false)

      user_ids = [user.id, member_of_old_group.id, member_of_new_group.id].map { |id| [id] }

      expect(AuthorizedProjectUpdate::UserRefreshFromReplicaWorker).to(
        receive(:bulk_perform_in).with(
          1.hour,
          user_ids,
          batch_delay: 30.seconds, batch_size: 100
        )
      )

      subject
    end

    it 'refreshes the permissions of the members of the old and new namespace', :sidekiq_inline do
      expect { execute_transfer }
        .to change { member_of_old_group.authorized_projects.include?(project) }.from(true).to(false)
        .and change { member_of_new_group.authorized_projects.include?(project) }.from(false).to(true)
    end
  end

  describe 'transferring a design repository' do
    subject { described_class.new(project, user) }

    before do
      group.add_owner(user)
    end

    def design_repository
      project.design_repository
    end

    def clear_design_repo_memoization
      project&.design_management_repository&.clear_memoization(:repository)
      project.clear_memoization(:design_repository)
    end

    it 'does not create a design repository' do
      expect(subject.execute(group)).to be true

      clear_design_repo_memoization

      expect(design_repository.exists?).to be false
    end

    describe 'when the project has a design repository' do
      let(:project_repo_path) { ""#{project.path}#{::Gitlab::GlRepository::DESIGN.path_suffix}"" }
      let(:old_full_path) { ""#{user.namespace.full_path}/#{project_repo_path}"" }
      let(:new_full_path) { ""#{group.full_path}/#{project_repo_path}"" }

      context 'with legacy storage' do
        let(:project) { create(:project, :repository, :legacy_storage, :design_repo, namespace: user.namespace) }

        it 'moves the repository' do
          expect(subject.execute(group)).to be true

          clear_design_repo_memoization

          expect(design_repository).to have_attributes(
            disk_path: new_full_path,
            full_path: new_full_path
          )
        end

        it 'does not move the repository when an error occurs', :aggregate_failures do
          allow(subject).to receive(:execute_system_hooks).and_raise('foo')
          expect { subject.execute(group) }.to raise_error('foo')

          clear_design_repo_memoization

          expect(design_repository).to have_attributes(
            disk_path: old_full_path,
            full_path: old_full_path
          )
        end
      end

      context 'with hashed storage' do
        let(:project) { create(:project, :repository, namespace: user.namespace) }

        it 'does not move the repository' do
          old_disk_path = design_repository.disk_path

          expect(subject.execute(group)).to be true

          clear_design_repo_memoization

          expect(design_repository).to have_attributes(
            disk_path: old_disk_path,
            full_path: new_full_path
          )
        end

        it 'does not move the repository when an error occurs' do
          old_disk_path = design_repository.disk_path

          allow(subject).to receive(:execute_system_hooks).and_raise('foo')
          expect { subject.execute(group) }.to raise_error('foo')

          clear_design_repo_memoization

          expect(design_repository).to have_attributes(
            disk_path: old_disk_path,
            full_path: old_full_path
          )
        end
      end
    end
  end

  context 'handling issue contacts' do
    let_it_be(:root_group) { create(:group) }

    let(:project) { create(:project, group: root_group) }

    before do
      root_group.add_owner(user)
      target.add_owner(user)
      create_list(:issue_customer_relations_contact, 2, :for_issue, issue: create(:issue, project: project))
    end

    context 'with the same root_ancestor' do
      let(:target) { create(:group, parent: root_group) }

      it 'retains issue contacts' do
        expect { execute_transfer }.not_to change { CustomerRelations::IssueContact.count }
      end
    end

    context 'with a different root_ancestor' do
      it 'deletes issue contacts' do
        expect { execute_transfer }.to change { CustomerRelations::IssueContact.count }.by(-2)
      end
    end
  end

  def project_namespace_in_sync(group)
    project.reload
    expect(project.namespace).to eq(group)
    expect(project.project_namespace.visibility_level).to eq(project.visibility_level)
    expect(project.project_namespace.path).to eq(project.path)
    expect(project.project_namespace.parent).to eq(project.namespace)
    expect(project.project_namespace.traversal_ids).to eq([*project.namespace.traversal_ids, project.project_namespace.id])
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class RefreshBuildArtifactsSizeStatisticsService
    BATCH_SIZE = 500
    REFRESH_INTERVAL_SECONDS = 0.1

    def execute
      refresh = Projects::BuildArtifactsSizeRefresh.process_next_refresh!

      return unless refresh&.running?

      batch = refresh.next_batch(limit: BATCH_SIZE).to_a

      if batch.any?
        increments = batch.map do |artifact|
          Gitlab::Counters::Increment.new(amount: artifact.size.to_i, ref: artifact.id)
        end

        Projects::BuildArtifactsSizeRefresh.transaction do
          # Mark the refresh ready for another worker to pick up and process the next batch
          refresh.requeue!(batch.last.id)

          ProjectStatistics.bulk_increment_statistic(refresh.project, :build_artifacts_size, increments)
        end

        sleep REFRESH_INTERVAL_SECONDS
      else
        refresh.schedule_finalize!
      end

      refresh
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::RefreshBuildArtifactsSizeStatisticsService, :clean_gitlab_redis_shared_state, feature_category: :build_artifacts do
  let(:service) { described_class.new }

  describe '#execute' do
    let_it_be(:project, reload: true) { create(:project) }

    let_it_be(:artifact_1) { create(:ci_job_artifact, project: project, size: 1, created_at: 14.days.ago) }
    let_it_be(:artifact_2) { create(:ci_job_artifact, project: project, size: 2, created_at: 13.days.ago) }
    let_it_be(:artifact_3) { create(:ci_job_artifact, project: project, size: nil, created_at: 13.days.ago) }
    let_it_be(:artifact_4) { create(:ci_job_artifact, project: project, size: 5, created_at: 12.days.ago) }

    # This should not be included in the recalculation as it is created later than the refresh start time
    let_it_be(:future_artifact) { create(:ci_job_artifact, project: project, size: 8, created_at: 2.days.from_now) }

    let!(:refresh) do
      create(
        :project_build_artifacts_size_refresh,
        :created,
        project: project,
        updated_at: 2.days.ago,
        refresh_started_at: nil,
        last_job_artifact_id: nil
      )
    end

    let(:now) { Time.zone.now }
    let(:statistics) { project.statistics }
    let(:increment) { Gitlab::Counters::Increment.new(amount: 30) }

    around do |example|
      freeze_time { example.run }
    end

    before do
      stub_const(""#{described_class}::BATCH_SIZE"", 3)
      stub_const(""#{described_class}::REFRESH_INTERVAL_SECONDS"", 0)

      stats = create(:project_statistics, project: project, build_artifacts_size: 120)
      stats.increment_counter(:build_artifacts_size, increment)
    end

    it 'resets the build artifacts size stats' do
      expect { service.execute }.to change { statistics.reload.build_artifacts_size }.from(120).to(0)
    end

    it 'resets the buffered counter' do
      expect { service.execute }
        .to change { Gitlab::Counters::BufferedCounter.new(statistics, :build_artifacts_size).get }.to(0)
    end

    it 'updates the last_job_artifact_id to the ID of the last artifact from the batch' do
      expect { service.execute }.to change { refresh.reload.last_job_artifact_id.to_i }.to(artifact_3.id)
    end

    it 'updates the last_job_artifact_id to the ID of the last artifact from the project' do
      expect { service.execute }
        .to change { refresh.reload.last_job_artifact_id_on_refresh_start.to_i }
              .to(project.job_artifacts.last.id)
    end

    it 'requeues the refresh job' do
      service.execute
      expect(refresh.reload).to be_pending
    end

    context 'when an error happens after the recalculation has started' do
      let!(:refresh) do
        create(
          :project_build_artifacts_size_refresh,
          :pending,
          project: project,
          last_job_artifact_id: artifact_3.id,
          last_job_artifact_id_on_refresh_start: artifact_4.id
        )
      end

      before do
        allow(Gitlab::Redis::SharedState).to receive(:with).and_raise(StandardError, 'error')

        expect { service.execute }.to raise_error(StandardError)
      end

      it 'keeps the last_job_artifact_id unchanged' do
        expect(refresh.reload.last_job_artifact_id).to eq(artifact_3.id)
      end

      it 'keeps the last_job_artifact_id_on_refresh_start unchanged' do
        expect(refresh.reload.last_job_artifact_id_on_refresh_start).to eq(artifact_4.id)
      end

      it 'keeps the state of the refresh record at running' do
        expect(refresh.reload).to be_running
      end
    end

    context 'when there are no more artifacts to recalculate for the next refresh job' do
      let!(:refresh) do
        create(
          :project_build_artifacts_size_refresh,
          :pending,
          project: project,
          updated_at: 2.days.ago,
          refresh_started_at: now,
          last_job_artifact_id: artifact_4.id
        )
      end

      it 'schedules the refresh to be finalized' do
        service.execute

        expect(refresh.reload.finalizing?).to be(true)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class ForkService < BaseService
    def execute(fork_to_project = nil)
      forked_project = fork_to_project ? link_existing_project(fork_to_project) : fork_new_project

      if forked_project&.saved?
        refresh_forks_count
        stream_audit_event(forked_project)
      end

      forked_project
    end

    def valid_fork_targets(options = {})
      @valid_fork_targets ||= ForkTargetsFinder.new(@project, current_user).execute(options)
    end

    def valid_fork_branch?(branch)
      @project.repository.branch_exists?(branch)
    end

    def valid_fork_target?(namespace = target_namespace)
      return true if current_user.admin?

      valid_fork_targets.include?(namespace)
    end

    private

    def link_existing_project(fork_to_project)
      return if fork_to_project.forked?

      build_fork_network_member(fork_to_project)

      fork_to_project if link_fork_network(fork_to_project)
    end

    def fork_new_project
      new_project = CreateService.new(current_user, new_fork_params).execute
      return new_project unless new_project.persisted?

      new_project.project_feature.update!(
        @project.project_feature.slice(ProjectFeature::FEATURES.map { |f| ""#{f}_access_level"" })
      )

      new_project
    end

    def new_fork_params
      new_params = {
        forked_from_project: @project,
        visibility_level: target_visibility_level,
        description: target_description,
        name: target_name,
        path: target_path,
        shared_runners_enabled: @project.shared_runners_enabled,
        namespace_id: target_namespace.id,
        fork_network: fork_network,
        ci_config_path: @project.ci_config_path,
        # We need to set ci_default_git_depth to 0 for the forked project when
        # @project.ci_default_git_depth is nil in order to keep the same behaviour
        # and not get ProjectCiCdSetting::DEFAULT_GIT_DEPTH set on create
        ci_cd_settings_attributes: { default_git_depth: @project.ci_default_git_depth || 0 },
        # We need to assign the fork network membership after the project has
        # been instantiated to avoid ActiveRecord trying to create it when
        # initializing the project, as that would cause a foreign key constraint
        # exception.
        relations_block: -> (project) { build_fork_network_member(project) },
        skip_disk_validation: skip_disk_validation,
        external_authorization_classification_label: @project.external_authorization_classification_label,
        suggestion_commit_message: @project.suggestion_commit_message,
        merge_commit_template: @project.merge_commit_template,
        squash_commit_template: @project.squash_commit_template,
        import_data: { data: { fork_branch: branch } }
      }

      if @project.avatar.present? && @project.avatar.image?
        new_params[:avatar] = @project.avatar
      end

      new_params[:mr_default_target_self] = target_mr_default_target_self unless target_mr_default_target_self.nil?

      new_params.merge!(@project.object_pool_params)

      new_params
    end

    def allowed_fork?
      current_user.can?(:fork_project, @project)
    end

    def fork_network
      @fork_network ||= @project.fork_network || @project.build_root_of_fork_network
    end

    def build_fork_network_member(fork_to_project)
      if allowed_fork?
        fork_to_project.build_fork_network_member(
          forked_from_project: @project,
          fork_network: fork_network
        )
      else
        fork_to_project.errors.add(:forked_from_project_id, 'is forbidden')
      end
    end

    def link_fork_network(fork_to_project)
      return if fork_to_project.errors.any?

      fork_to_project.fork_network_member.save
    end

    def refresh_forks_count
      Projects::ForksCountService.new(@project).refresh_cache
    end

    def target_path
      @target_path ||= @params[:path] || @project.path
    end

    def target_name
      @target_name ||= @params[:name] || @project.name
    end

    def target_description
      @target_description ||= @params[:description] || @project.description
    end

    def target_namespace
      @target_namespace ||= @params[:namespace] || current_user.namespace
    end

    def skip_disk_validation
      @skip_disk_validation ||= @params[:skip_disk_validation] || false
    end

    def target_visibility_level
      target_level = [@project.visibility_level, target_namespace.visibility_level].min
      target_level = [target_level, Gitlab::VisibilityLevel.level_value(params[:visibility])].min if params.key?(:visibility)

      Gitlab::VisibilityLevel.closest_allowed_level(target_level)
    end

    def target_mr_default_target_self
      @target_mr_default_target_self ||= params[:mr_default_target_self]
    end

    def stream_audit_event(forked_project)
      # Defined in EE
    end

    def branch
      # We extract branch name from @params[:branches] because the front end
      # insists on sending it as 'branches'.
      @params[:branches]
    end
  end
end

Projects::ForkService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::ForkService, feature_category: :source_code_management do
  include ProjectForksHelper

  shared_examples 'forks count cache refresh' do
    it 'flushes the forks count cache of the source project', :clean_gitlab_redis_cache do
      expect(from_project.forks_count).to be_zero

      fork_project(from_project, to_user, using_service: true)
      BatchLoader::Executor.clear_current

      expect(from_project.forks_count).to eq(1)
    end
  end

  context 'when forking a new project' do
    describe 'fork by user' do
      before do
        @from_user = create(:user)
        @from_namespace = @from_user.namespace
        avatar = fixture_file_upload(""spec/fixtures/dk.png"", ""image/png"")
        @from_project = create(
          :project,
          :repository,
          creator_id: @from_user.id,
          namespace: @from_namespace,
          star_count: 107,
          avatar: avatar,
          description: 'wow such project',
          external_authorization_classification_label: 'classification-label'
        )
        @to_user = create(:user)
        @to_namespace = @to_user.namespace
        @from_project.add_member(@to_user, :developer)
      end

      context 'fork project' do
        context 'when forker is a guest' do
          before do
            @guest = create(:user)
            @from_project.add_member(@guest, :guest)
          end
          subject { fork_project(@from_project, @guest, using_service: true) }

          it { is_expected.not_to be_persisted }
          it { expect(subject.errors[:forked_from_project_id]).to eq(['is forbidden']) }

          it 'does not create a fork network' do
            expect { subject }.not_to change { @from_project.reload.fork_network }
          end
        end

        it_behaves_like 'forks count cache refresh' do
          let(:from_project) { @from_project }
          let(:to_user) { @to_user }
        end

        describe ""successfully creates project in the user namespace"" do
          let(:to_project) { fork_project(@from_project, @to_user, namespace: @to_user.namespace, using_service: true) }

          it { expect(to_project).to be_persisted }
          it { expect(to_project.errors).to be_empty }
          it { expect(to_project.first_owner).to eq(@to_user) }
          it { expect(to_project.namespace).to eq(@to_user.namespace) }
          it { expect(to_project.star_count).to be_zero }
          it { expect(to_project.description).to eq(@from_project.description) }
          it { expect(to_project.avatar.file).to be_exists }
          it { expect(to_project.ci_config_path).to eq(@from_project.ci_config_path) }
          it { expect(to_project.external_authorization_classification_label).to eq(@from_project.external_authorization_classification_label) }
          it { expect(to_project.suggestion_commit_message).to eq(@from_project.suggestion_commit_message) }
          it { expect(to_project.merge_commit_template).to eq(@from_project.merge_commit_template) }
          it { expect(to_project.squash_commit_template).to eq(@from_project.squash_commit_template) }

          # This test is here because we had a bug where the from-project lost its
          # avatar after being forked.
          # https://gitlab.com/gitlab-org/gitlab-foss/issues/26158
          it ""after forking the from-project still has its avatar"" do
            # If we do not fork the project first we cannot detect the bug.
            expect(to_project).to be_persisted

            expect(@from_project.avatar.file).to be_exists
          end

          it_behaves_like 'forks count cache refresh' do
            let(:from_project) { @from_project }
            let(:to_user) { @to_user }
          end

          it 'creates a fork network with the new project and the root project set' do
            to_project
            fork_network = @from_project.reload.fork_network

            expect(fork_network).not_to be_nil
            expect(fork_network.root_project).to eq(@from_project)
            expect(fork_network.projects).to contain_exactly(@from_project, to_project)
          end

          it 'imports the repository of the forked project', :sidekiq_might_not_need_inline do
            to_project = fork_project(@from_project, @to_user, repository: true, using_service: true)

            expect(to_project.empty_repo?).to be_falsy
          end
        end

        context 'creating a fork of a fork' do
          let(:from_forked_project) { fork_project(@from_project, @to_user, using_service: true) }
          let(:other_namespace) do
            group = create(:group)
            group.add_owner(@to_user)
            group
          end

          let(:to_project) { fork_project(from_forked_project, @to_user, namespace: other_namespace, using_service: true) }

          it 'sets the root of the network to the root project' do
            expect(to_project.fork_network.root_project).to eq(@from_project)
          end

          it 'sets the forked_from_project on the membership' do
            expect(to_project.fork_network_member.forked_from_project).to eq(from_forked_project)
          end

          context 'when the forked project has higher visibility than the root project' do
            let(:root_project) { create(:project, :public) }

            it 'successfully creates a fork of the fork with correct visibility' do
              forked_project = fork_project(root_project, @to_user, using_service: true)

              root_project.update!(visibility_level: Gitlab::VisibilityLevel::INTERNAL)

              # Forked project visibility is not affected by root project visibility change
              expect(forked_project).to have_attributes(visibility_level: Gitlab::VisibilityLevel::PUBLIC)

              fork_of_the_fork = fork_project(forked_project, @to_user, namespace: other_namespace, using_service: true)

              expect(fork_of_the_fork).to be_valid
              expect(fork_of_the_fork).to have_attributes(visibility_level: Gitlab::VisibilityLevel::PUBLIC)
            end
          end

          it_behaves_like 'forks count cache refresh' do
            let(:from_project) { from_forked_project }
            let(:to_user) { @to_user }
          end
        end
      end

      context 'project already exists' do
        it ""fails due to validation, not transaction failure"" do
          @existing_project = create(:project, :repository, creator_id: @to_user.id, path: @from_project.path, namespace: @to_namespace)
          @to_project = fork_project(@from_project, @to_user, namespace: @to_namespace, using_service: true)
          expect(@existing_project).to be_persisted

          expect(@to_project).not_to be_persisted
          expect(@to_project.errors[:path]).to eq(['has already been taken'])
        end
      end

      context 'repository in legacy storage already exists' do
        let(:raw_fake_repo) { Gitlab::Git::Repository.new('default', File.join(@to_user.namespace.full_path, ""#{@from_project.path}.git""), nil, nil) }
        let(:params) { { namespace: @to_user.namespace, using_service: true } }

        before do
          stub_application_setting(hashed_storage_enabled: false)
          raw_fake_repo.create_repository
        end

        after do
          raw_fake_repo.remove
        end

        subject { fork_project(@from_project, @to_user, params) }

        it 'does not allow creation' do
          expect(subject).not_to be_persisted
          expect(subject.errors.messages).to have_key(:base)
          expect(subject.errors.messages[:base].first).to match('There is already a repository with that name on disk')
        end

        context 'when repository disk validation is explicitly skipped' do
          let(:params) { super().merge(skip_disk_validation: true) }

          it 'allows fork project creation' do
            expect(subject).to be_persisted
            expect(subject.errors.messages).to be_empty
          end
        end
      end

      context ""CI/CD settings"" do
        let(:to_project) { fork_project(@from_project, @to_user, using_service: true) }

        context ""when origin has git depth specified"" do
          before do
            @from_project.update!(ci_default_git_depth: 42)
          end

          it ""inherits default_git_depth from the origin project"" do
            expect(to_project.ci_default_git_depth).to eq(42)
          end
        end

        context ""when origin does not define git depth"" do
          before do
            @from_project.update!(ci_default_git_depth: nil)
          end

          it ""the fork has git depth set to 0"" do
            expect(to_project.ci_default_git_depth).to eq(0)
          end
        end
      end

      context ""when project has restricted visibility level"" do
        context ""and only one visibility level is restricted"" do
          before do
            @from_project.update!(visibility_level: Gitlab::VisibilityLevel::INTERNAL)
            stub_application_setting(restricted_visibility_levels: [Gitlab::VisibilityLevel::INTERNAL])
          end

          it ""creates fork with lowest level"" do
            forked_project = fork_project(@from_project, @to_user, using_service: true)

            expect(forked_project.visibility_level).to eq(Gitlab::VisibilityLevel::PRIVATE)
          end
        end

        context ""and all visibility levels are restricted"" do
          before do
            stub_application_setting(restricted_visibility_levels: [Gitlab::VisibilityLevel::PUBLIC, Gitlab::VisibilityLevel::INTERNAL, Gitlab::VisibilityLevel::PRIVATE])
          end

          it ""creates fork with private visibility levels"" do
            forked_project = fork_project(@from_project, @to_user, using_service: true)

            expect(forked_project.visibility_level).to eq(Gitlab::VisibilityLevel::PRIVATE)
          end
        end
      end

      context 'when forking is disabled' do
        before do
          @from_project.project_feature.update_attribute(
            :forking_access_level, ProjectFeature::DISABLED)
        end

        it 'fails' do
          to_project = fork_project(@from_project, @to_user, namespace: @to_user.namespace, using_service: true)

          expect(to_project.errors[:forked_from_project_id]).to eq(['is forbidden'])
        end
      end
    end

    describe 'fork to namespace' do
      before do
        @group_owner = create(:user)
        @developer   = create(:user)
        @project     = create(
          :project, :repository,
          creator_id: @group_owner.id,
          star_count: 777,
          description: 'Wow, such a cool project!',
          ci_config_path: 'debian/salsa-ci.yml'
        )
        @group = create(:group)
        @group.add_member(@group_owner, GroupMember::OWNER)
        @group.add_member(@developer,   GroupMember::DEVELOPER)
        @project.add_member(@developer,   :developer)
        @project.add_member(@group_owner, :developer)
        @opts = { namespace: @group, using_service: true }
      end

      context 'fork project for group' do
        it 'group owner successfully forks project into the group' do
          to_project = fork_project(@project, @group_owner, @opts)

          expect(to_project).to                be_persisted
          expect(to_project.errors).to         be_empty
          expect(to_project.first_owner).to    eq(@group_owner)
          expect(to_project.namespace).to      eq(@group)
          expect(to_project.name).to           eq(@project.name)
          expect(to_project.path).to           eq(@project.path)
          expect(to_project.description).to    eq(@project.description)
          expect(to_project.ci_config_path).to eq(@project.ci_config_path)
          expect(to_project.star_count).to     be_zero
        end
      end

      context 'fork project for group when user not owner' do
        it 'group developer fails to fork project into the group' do
          to_project = fork_project(@project, @developer, @opts)

          expect(to_project.errors[:namespace]).to eq(['is not valid'])
        end
      end

      context 'project already exists in group' do
        it 'fails due to validation, not transaction failure' do
          existing_project = create(:project, :repository, path: @project.path, namespace: @group)
          to_project = fork_project(@project, @group_owner, @opts)
          expect(existing_project.persisted?).to be_truthy
          expect(to_project.errors[:path]).to eq(['has already been taken'])
        end
      end

      context 'when the namespace has a lower visibility level than the project' do
        it 'creates the project with the lower visibility level' do
          public_project = create(:project, :public)
          private_group = create(:group, :private)
          group_owner = create(:user)
          private_group.add_owner(group_owner)

          forked_project = fork_project(public_project, group_owner, namespace: private_group, using_service: true)

          expect(forked_project.visibility_level).to eq(Gitlab::VisibilityLevel::PRIVATE)
        end
      end
    end

    describe 'fork with optional attributes' do
      let(:public_project) { create(:project, :public) }

      it 'sets optional attributes to specified values' do
        forked_project = fork_project(
          public_project,
          nil,
          namespace: public_project.namespace,
          path: 'forked',
          name: 'My Fork',
          description: 'Description',
          visibility: 'internal',
          using_service: true
        )

        expect(forked_project.path).to eq('forked')
        expect(forked_project.name).to eq('My Fork')
        expect(forked_project.description).to eq('Description')
        expect(forked_project.visibility_level).to eq(Gitlab::VisibilityLevel::INTERNAL)
      end

      it 'sets visibility level to private if an unknown visibility is requested' do
        forked_project = fork_project(public_project, nil, using_service: true, visibility: 'unknown')

        expect(forked_project.visibility_level).to eq(Gitlab::VisibilityLevel::PRIVATE)
      end

      it 'sets visibility level to project visibility level if requested visibility is greater' do
        private_project = create(:project, :private)

        forked_project = fork_project(private_project, nil, using_service: true, visibility: 'public')

        expect(forked_project.visibility_level).to eq(Gitlab::VisibilityLevel::PRIVATE)
      end

      it 'sets visibility level to target namespace visibility level if requested visibility is greater' do
        private_group = create(:group, :private)

        forked_project = fork_project(public_project, nil, namespace: private_group, using_service: true, visibility: 'public')

        expect(forked_project.visibility_level).to eq(Gitlab::VisibilityLevel::PRIVATE)
      end

      it 'copies project features visibility settings to the fork', :aggregate_failures do
        attrs = ProjectFeature::FEATURES.to_h do |f|
          [""#{f}_access_level"", ProjectFeature::PRIVATE]
        end

        public_project.project_feature.update!(attrs)

        user = create(:user, developer_projects: [public_project])
        forked_project = described_class.new(public_project, user).execute

        expect(forked_project.project_feature.slice(attrs.keys)).to eq(attrs)
      end
    end
  end

  context 'when a project is already forked' do
    it 'creates a new pool repository after the project is moved to a new shard' do
      project = create(:project, :public, :repository)
      fork_before_move = fork_project(project, nil, using_service: true)

      # Stub everything required to move a project to a Gitaly shard that does not exist
      allow(Gitlab::GitalyClient).to receive(:filesystem_id).with('default').and_call_original
      allow(Gitlab::GitalyClient).to receive(:filesystem_id).with('test_second_storage').and_return(SecureRandom.uuid)
      stub_storage_settings('test_second_storage' => {})
      allow_any_instance_of(Gitlab::Git::Repository).to receive(:create_repository)
        .and_return(true)
      allow_any_instance_of(Gitlab::Git::Repository).to receive(:replicate)
      allow_any_instance_of(Gitlab::Git::Repository).to receive(:checksum)
        .and_return(::Gitlab::Git::BLANK_SHA)
      allow_next_instance_of(Gitlab::Git::ObjectPool) do |object_pool|
        allow(object_pool).to receive(:link)
      end

      storage_move = create(
        :project_repository_storage_move,
        :scheduled,
        container: project,
        destination_storage_name: 'test_second_storage'
      )
      Projects::UpdateRepositoryStorageService.new(storage_move).execute
      fork_after_move = fork_project(project.reload, nil, using_service: true)
      pool_repository_before_move = PoolRepository.joins(:shard)
                                      .find_by(source_project: project, shards: { name: 'default' })
      pool_repository_after_move = PoolRepository.joins(:shard)
                                     .find_by(source_project: project, shards: { name: 'test_second_storage' })

      expect(fork_before_move.pool_repository).to eq(pool_repository_before_move)
      expect(fork_after_move.pool_repository).to eq(pool_repository_after_move)
    end
  end

  context 'when forking with object pools' do
    let(:fork_from_project) { create(:project, :repository, :public) }
    let(:forker) { create(:user) }

    context 'when no pool exists' do
      it 'creates a new object pool' do
        forked_project = fork_project(fork_from_project, forker, using_service: true)

        expect(forked_project.pool_repository).to eq(fork_from_project.pool_repository)
      end
    end

    context 'when a pool already exists' do
      let!(:pool_repository) { create(:pool_repository, source_project: fork_from_project) }

      it 'joins the object pool' do
        forked_project = fork_project(fork_from_project, forker, using_service: true)

        expect(forked_project.pool_repository).to eq(fork_from_project.pool_repository)
      end
    end
  end

  context 'when linking fork to an existing project' do
    let(:fork_from_project) { create(:project, :public) }
    let(:fork_to_project) { create(:project, :public) }
    let(:user) do
      create(:user).tap { |u| fork_to_project.add_maintainer(u) }
    end

    subject { described_class.new(fork_from_project, user) }

    def forked_from_project(project)
      project.fork_network_member&.forked_from_project
    end

    context 'if project is already forked' do
      it 'does not create fork relation' do
        allow(fork_to_project).to receive(:forked?).and_return(true)
        expect(forked_from_project(fork_to_project)).to be_nil
        expect(subject.execute(fork_to_project)).to be_nil
        expect(forked_from_project(fork_to_project)).to be_nil
      end
    end

    context 'if project is not forked' do
      it 'creates fork relation' do
        expect(fork_to_project.forked?).to be_falsy
        expect(forked_from_project(fork_to_project)).to be_nil

        subject.execute(fork_to_project)

        fork_to_project.reload

        expect(fork_to_project.forked?).to be true
        expect(forked_from_project(fork_to_project)).to eq fork_from_project
        expect(fork_to_project.forked_from_project).to eq fork_from_project
      end

      it 'flushes the forks count cache of the source project' do
        expect(fork_from_project.forks_count).to be_zero

        subject.execute(fork_to_project)
        BatchLoader::Executor.clear_current

        expect(fork_from_project.forks_count).to eq(1)
      end

      context 'if the fork is not allowed' do
        let(:fork_from_project) { create(:project, :private) }

        it 'does not delete the LFS objects' do
          create(:lfs_objects_project, project: fork_to_project)

          expect { subject.execute(fork_to_project) }
            .not_to change { fork_to_project.lfs_objects_projects.size }
        end
      end
    end
  end

  describe '#valid_fork_targets' do
    let(:finder_mock) { instance_double('ForkTargetsFinder', execute: ['finder_return_value']) }
    let(:current_user) { instance_double('User') }
    let(:project) { instance_double('Project') }

    before do
      allow(ForkTargetsFinder).to receive(:new).with(project, current_user).and_return(finder_mock)
    end

    it 'returns whatever finder returns' do
      expect(described_class.new(project, current_user).valid_fork_targets).to eq ['finder_return_value']
    end
  end

  describe '#valid_fork_branch?' do
    let_it_be(:user) { create(:user) }
    let_it_be(:project) { create(:project, :small_repo, creator_id: user.id) }
    let_it_be(:branch) { nil }

    subject { described_class.new(project, user).valid_fork_branch?(branch) }

    context 'when branch exists' do
      let(:branch) { project.default_branch_or_main }

      it { is_expected.to be_truthy }
    end

    context 'when branch does not exist' do
      let(:branch) { 'branch-that-does-not-exist' }

      it { is_expected.to be_falsey }
    end
  end

  describe '#valid_fork_target?' do
    let(:project) { Project.new }
    let(:params) { {} }

    context 'when target is not passed' do
      subject { described_class.new(project, user, params).valid_fork_target? }

      context 'when current user is an admin' do
        let(:user) { build(:user, :admin) }

        it { is_expected.to be_truthy }
      end

      context 'when current_user is not an admin' do
        let(:user) { create(:user) }

        let(:finder_mock) { instance_double('ForkTargetsFinder', execute: [user.namespace]) }
        let(:project) { create(:project) }

        before do
          allow(ForkTargetsFinder).to receive(:new).with(project, user).and_return(finder_mock)
        end

        context 'when target namespace is in valid fork targets' do
          let(:params) { { namespace: user.namespace } }

          it { is_expected.to be_truthy }
        end

        context 'when target namespace is not in valid fork targets' do
          let(:params) { { namespace: create(:group) } }

          it { is_expected.to be_falsey }
        end
      end
    end

    context 'when target is passed' do
      let(:target) { create(:group) }

      subject { described_class.new(project, user, params).valid_fork_target?(target) }

      context 'when current user is an admin' do
        let(:user) { build(:user, :admin) }

        it { is_expected.to be_truthy }
      end

      context 'when current user is not an admin' do
        let(:user) { create(:user) }

        before do
          allow(ForkTargetsFinder).to receive(:new).with(project, user).and_return(finder_mock)
        end

        context 'when target namespace is in valid fork targets' do
          let(:finder_mock) { instance_double('ForkTargetsFinder', execute: [target]) }

          it { is_expected.to be_truthy }
        end

        context 'when target namespace is not in valid fork targets' do
          let(:finder_mock) { instance_double('ForkTargetsFinder', execute: [create(:group)]) }

          it { is_expected.to be_falsey }
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class UnlinkForkService < BaseService
    # Close existing MRs coming from the project and remove it from the fork network
    def execute(refresh_statistics: true)
      fork_network = @project.fork_network
      forked_from = @project.forked_from_project

      return unless fork_network

      log_info(message: ""UnlinkForkService: Unlinking fork network"", fork_network_id: fork_network.id)

      merge_requests = fork_network
                         .merge_requests
                         .opened
                         .from_and_to_forks(@project)

      merge_requests.find_each do |mr|
        ::MergeRequests::CloseService.new(project: @project, current_user: @current_user).execute(mr)
        log_info(message: ""UnlinkForkService: Closed merge request"", merge_request_id: mr.id)
      end

      Project.transaction do
        # Get out of the fork network as a member and
        # remove references from all its direct forks.
        @project.fork_network_member.destroy
        @project.forked_to_members.update_all(forked_from_project_id: nil)

        # The project is not necessarily a fork, so update the fork network originating
        # from this project
        if fork_network = @project.root_of_fork_network
          fork_network.update(root_project: nil, deleted_root_project_name: @project.full_name)
        end

        @project.leave_pool_repository
      end

      # rubocop: disable Cop/InBatches
      Project.uncached do
        @project.forked_to_members.in_batches do |fork_relation|
          fork_relation.pluck(:id).each do |fork_id| # rubocop: disable CodeReuse/ActiveRecord
            log_info(message: ""UnlinkForkService: Unlinked fork of root_project"", project_id: @project.id, forked_project_id: fork_id)
          end
        end
      end
      # rubocop: enable Cop/InBatches

      if Feature.enabled?(:refresh_statistics_on_unlink_fork, @project.namespace) && refresh_statistics
        ProjectCacheWorker.perform_async(project.id, [], [:repository_size])
      end

      # When the project getting out of the network is a node with parent
      # and children, both the parent and the node needs a cache refresh.
      [forked_from, @project].compact.each do |project|
        refresh_forks_count(project)
      end
    end

    private

    def refresh_forks_count(project)
      Projects::ForksCountService.new(project).refresh_cache
    end
  end
end

Projects::UnlinkForkService.prepend_mod_with('Projects::UnlinkForkService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::UnlinkForkService, :use_clean_rails_memory_store_caching, feature_category: :source_code_management do
  include ProjectForksHelper

  subject { described_class.new(forked_project, user) }

  let(:project) { create(:project, :public) }
  let!(:forked_project) { fork_project(project, user) }
  let(:user) { create(:user) }

  context 'with opened merge request on the source project' do
    let(:merge_request) { create(:merge_request, source_project: forked_project, target_project: forked_project.forked_from_project) }
    let(:merge_request2) { create(:merge_request, source_project: forked_project, target_project: fork_project(project)) }
    let(:merge_request_in_fork) { create(:merge_request, source_project: forked_project, target_project: forked_project) }

    let(:mr_close_service) { MergeRequests::CloseService.new(project: forked_project, current_user: user) }

    before do
      allow(MergeRequests::CloseService).to receive(:new)
        .with(project: forked_project, current_user: user)
        .and_return(mr_close_service)
    end

    it 'close all pending merge requests' do
      expect(mr_close_service).to receive(:execute).with(merge_request)
      expect(mr_close_service).to receive(:execute).with(merge_request2)

      subject.execute
    end

    it 'does not close merge requests for the project being unlinked' do
      expect(mr_close_service).not_to receive(:execute).with(merge_request_in_fork)
    end
  end

  it 'removes the link to the fork network' do
    expect(forked_project.fork_network_member).to be_present
    expect(forked_project.fork_network).to be_present

    subject.execute
    forked_project.reload

    expect(forked_project.fork_network_member).to be_nil
    expect(forked_project.reload.fork_network).to be_nil
  end

  it 'refreshes the forks count cache of the source project' do
    source = forked_project.forked_from_project

    expect(source.forks_count).to eq(1)

    subject.execute
    BatchLoader::Executor.clear_current

    expect(source.forks_count).to be_zero
  end

  it 'refreshes the project statistics of the forked project' do
    expect(ProjectCacheWorker).to receive(:perform_async).with(forked_project.id, [], [:repository_size])

    subject.execute
  end

  it 'does not refresh project statistics when refresh_statistics is false' do
    expect(ProjectCacheWorker).not_to receive(:perform_async)

    subject.execute(refresh_statistics: false)
  end

  it 'does not refresh project statistics when the feature flag is disabled' do
    stub_feature_flags(refresh_statistics_on_unlink_fork: false)

    expect(ProjectCacheWorker).not_to receive(:perform_async)

    subject.execute
  end

  context 'when the original project was deleted' do
    it 'does not fail when the original project is deleted' do
      source = forked_project.forked_from_project
      source.destroy!
      forked_project.reload

      expect { subject.execute }.not_to raise_error
    end
  end

  context 'when given project is a source of forks' do
    let!(:forked_project_2) { fork_project(project, user) }
    let!(:fork_of_fork) { fork_project(forked_project, user) }

    subject { described_class.new(project, user) }

    context 'with opened merge requests from fork back to root project' do
      let!(:merge_request) { create(:merge_request, source_project: project, target_project: forked_project) }
      let!(:merge_request2) { create(:merge_request, source_project: project, target_project: fork_project(project)) }
      let!(:merge_request_in_fork) { create(:merge_request, source_project: forked_project, target_project: forked_project) }

      let(:mr_close_service) { MergeRequests::CloseService.new(project: project, current_user: user) }

      before do
        allow(MergeRequests::CloseService).to receive(:new)
                                                .with(project: project, current_user: user)
                                                .and_return(mr_close_service)
      end

      it 'closes all pending merge requests' do
        expect(mr_close_service).to receive(:execute).with(merge_request)
        expect(mr_close_service).to receive(:execute).with(merge_request2)

        subject.execute
      end

      it 'does not close merge requests that do not come from the project being unlinked' do
        expect(mr_close_service).not_to receive(:execute).with(merge_request_in_fork)

        subject.execute
      end
    end

    it 'removes its link to the fork network and updates direct network members' do
      expect(project.fork_network_member).to be_present
      expect(project.fork_network).to be_present
      expect(project.forked_to_members.count).to eq(2)
      expect(forked_project.forked_to_members.count).to eq(1)
      expect(fork_of_fork.forked_to_members.count).to eq(0)

      subject.execute

      project.reload
      forked_project.reload
      fork_of_fork.reload

      expect(project.fork_network_member).to be_nil
      expect(project.fork_network).to be_nil
      expect(forked_project.fork_network).to have_attributes(
        root_project_id: nil,
        deleted_root_project_name: project.full_name
      )
      expect(project.forked_to_members.count).to eq(0)
      expect(forked_project.forked_to_members.count).to eq(1)
      expect(fork_of_fork.forked_to_members.count).to eq(0)
    end

    it 'refreshes the forks count cache of the given project' do
      expect(project.forks_count).to eq(2)

      subject.execute
      BatchLoader::Executor.clear_current

      expect(project.forks_count).to be_zero
    end

    context 'and is node with a parent' do
      subject { described_class.new(forked_project, user) }

      context 'with opened merge requests from and to given project' do
        let!(:mr_from_parent) { create(:merge_request, source_project: project, target_project: forked_project) }
        let!(:mr_to_parent) { create(:merge_request, source_project: forked_project, target_project: project) }
        let!(:mr_to_child) { create(:merge_request, source_project: forked_project, target_project: fork_of_fork) }
        let!(:mr_from_child) { create(:merge_request, source_project: fork_of_fork, target_project: forked_project) }
        let!(:merge_request_in_fork) { create(:merge_request, source_project: forked_project, target_project: forked_project) }

        let(:mr_close_service) { MergeRequests::CloseService.new(project: forked_project, current_user: user) }

        before do
          allow(MergeRequests::CloseService).to receive(:new)
            .with(project: forked_project, current_user: user)
            .and_return(mr_close_service)
        end

        it 'close all pending merge requests' do
          merge_requests = [mr_from_parent, mr_to_parent, mr_from_child, mr_to_child]

          merge_requests.each do |mr|
            expect(mr_close_service).to receive(:execute).with(mr).and_call_original
          end

          subject.execute

          merge_requests = MergeRequest.where(id: merge_requests)

          expect(merge_requests).to all(have_attributes(state: 'closed'))
        end

        it 'does not close merge requests which do not come from the project being unlinked' do
          expect(mr_close_service).not_to receive(:execute).with(merge_request_in_fork)

          subject.execute
        end
      end

      it 'refreshes the forks count cache of the parent and the given project' do
        expect(project.forks_count).to eq(2)
        expect(forked_project.forks_count).to eq(1)

        subject.execute
        BatchLoader::Executor.clear_current

        expect(project.forks_count).to eq(1)
        expect(forked_project.forks_count).to eq(0)
      end

      it 'removes its link to the fork network and updates direct network members' do
        expect(project.fork_network).to be_present
        expect(forked_project.fork_network).to be_present
        expect(fork_of_fork.fork_network).to be_present

        expect(project.forked_to_members.count).to eq(2)
        expect(forked_project.forked_to_members.count).to eq(1)
        expect(fork_of_fork.forked_to_members.count).to eq(0)

        subject.execute
        project.reload
        forked_project.reload
        fork_of_fork.reload

        expect(project.fork_network).to be_present
        expect(forked_project.fork_network).to be_nil
        expect(fork_of_fork.fork_network).to be_present

        expect(project.forked_to_members.count).to eq(1) # 1 child is gone
        expect(forked_project.forked_to_members.count).to eq(0)
        expect(fork_of_fork.forked_to_members.count).to eq(0)
      end
    end
  end

  context 'a project with pool repository' do
    let(:project) { create(:project, :public, :repository) }
    let!(:pool_repository) { create(:pool_repository, :ready, source_project: project) }

    subject { described_class.new(project, user) }

    it 'when unlinked leaves pool repository' do
      expect { subject.execute }.to change { project.reload.has_pool_repository? }.from(true).to(false)
    end
  end

  context 'when given project is not part of a fork network' do
    let!(:project_without_forks) { create(:project, :public) }

    subject { described_class.new(project_without_forks, user) }

    it 'does not raise errors' do
      expect { subject.execute }.not_to raise_error
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  # Service class for getting and caching the number of forks of a project.
  class ForksCountService < Projects::CountService
    def cache_key_name
      'forks_count'
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def self.query(project_ids)
      ForkNetworkMember.where(forked_from_project: project_ids)
    end
    # rubocop: enable CodeReuse/ActiveRecord
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::ForksCountService, :use_clean_rails_memory_store_caching, feature_category: :source_code_management do
  let(:project) { build(:project) }

  subject { described_class.new(project) }

  it_behaves_like 'a counter caching service'

  describe '#count' do
    it 'returns the number of forks' do
      allow(subject).to receive(:uncached_count).and_return(1)

      expect(subject.count).to eq(1)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  # The CleanupService removes data from the project repository following a
  # BFG rewrite: https://rtyley.github.io/bfg-repo-cleaner/
  #
  # Before executing this service, all refs rewritten by BFG should have been
  # pushed to the repository
  class CleanupService < BaseService
    NoUploadError = StandardError.new(""Couldn't find uploaded object map"")

    include Gitlab::Utils::StrongMemoize

    class << self
      def enqueue(project, current_user, bfg_object_map)
        Projects::UpdateService.new(project, current_user, bfg_object_map: bfg_object_map).execute.tap do |result|
          next unless result[:status] == :success

          project.set_repository_read_only!
          RepositoryCleanupWorker.perform_async(project.id, current_user.id)
        end
      rescue Project::RepositoryReadOnlyError => err
        { status: :error, message: (_('Failed to make repository read-only. %{reason}') % { reason: err.message }) }
      end

      def cleanup_after(project)
        project.bfg_object_map.remove!
        project.set_repository_writable!
      end
    end

    # Attempt to clean up the project following the push. Warning: this is
    # destructive!
    #
    # path is the path of an upload of a BFG object map file. It contains a line
    # per rewritten object, with the old and new SHAs space-separated. It can be
    # used to update or remove content that references the objects that BFG has
    # altered
    def execute
      apply_bfg_object_map!

      # Remove older objects that are no longer referenced
      Projects::GitGarbageCollectWorker.new.perform(project.id, :prune, ""project_cleanup:gc:#{project.id}"")

      # The cache may now be inaccurate, and holding onto it could prevent
      # bugs assuming the presence of some object from manifesting for some
      # time. Better to feel the pain immediately.
      project.repository.expire_all_method_caches

      self.class.cleanup_after(project)
    end

    private

    def apply_bfg_object_map!
      raise NoUploadError unless project.bfg_object_map.exists?

      project.bfg_object_map.open do |io|
        repository_cleaner.apply_bfg_object_map_stream(io) do |response|
          cleanup_diffs(response)
        end
      end
    end

    def cleanup_diffs(response)
      old_commit_shas = extract_old_commit_shas(response.entries)

      ApplicationRecord.transaction do
        cleanup_merge_request_diffs(old_commit_shas)
        cleanup_note_diff_files(old_commit_shas)
      end
    end

    def extract_old_commit_shas(batch)
      batch.lazy.select { |entry| entry.type == :COMMIT }.map(&:old_oid).force
    end

    def cleanup_merge_request_diffs(old_commit_shas)
      merge_request_diffs = MergeRequestDiff
        .by_project_id(project.id)
        .by_commit_sha(old_commit_shas)

      # It's important to run the ActiveRecord callbacks here
      merge_request_diffs.destroy_all # rubocop:disable Cop/DestroyAll

      # TODO: ensure the highlight cache is removed immediately. It's too hard
      # to calculate the Redis keys at present.
      #
      # https://gitlab.com/gitlab-org/gitlab-foss/issues/61115
    end

    def cleanup_note_diff_files(old_commit_shas)
      # Pluck the IDs instead of running the query twice to ensure we clear the
      # cache for exactly the note diffs we remove
      ids = NoteDiffFile
        .referencing_sha(old_commit_shas, project_id: project.id)
        .pluck_primary_key

      NoteDiffFile.id_in(ids).delete_all

      # A highlighted version of the diff is stored in redis. Remove it now.
      Gitlab::DiscussionsDiff::HighlightCache.clear_multiple(ids)
    end

    def repository_cleaner
      @repository_cleaner ||= Gitlab::Git::RepositoryCleaner.new(repository.raw)
    end
  end
end

Projects::CleanupService.prepend_mod_with('Projects::CleanupService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::CleanupService, feature_category: :source_code_management do
  subject(:service) { described_class.new(project) }

  describe '.enqueue' do
    let_it_be(:project) { create(:project, :repository) }
    let_it_be(:user) { create(:user) }

    let(:object_map_file) { fixture_file_upload('spec/fixtures/bfg_object_map.txt') }

    subject(:enqueue) { described_class.enqueue(project, user, object_map_file) }

    it 'makes the repository read-only' do
      expect { enqueue }
        .to change(project, :repository_read_only?)
        .from(false)
        .to(true)
    end

    it 'sets the bfg_object_map of the project' do
      enqueue

      expect(project.bfg_object_map.read).to eq(object_map_file.read)
    end

    it 'enqueues a RepositoryCleanupWorker' do
      enqueue

      expect(RepositoryCleanupWorker.jobs.count).to eq(1)
    end

    it 'returns success' do
      expect(enqueue[:status]).to eq(:success)
    end

    it 'returns an error if making the repository read-only fails' do
      project.set_repository_read_only!

      expect(enqueue[:status]).to eq(:error)
    end

    it 'returns an error if updating the project fails' do
      expect_next_instance_of(Projects::UpdateService) do |service|
        expect(service).to receive(:execute).and_return(status: :error)
      end

      expect(enqueue[:status]).to eq(:error)
      expect(project.reload.repository_read_only?).to be_falsy
    end
  end

  describe '.cleanup_after' do
    let(:project) { create(:project, :repository, bfg_object_map: fixture_file_upload('spec/fixtures/bfg_object_map.txt')) }

    subject(:cleanup_after) { described_class.cleanup_after(project) }

    before do
      project.set_repository_read_only!
    end

    it 'sets the repository read-write' do
      expect { cleanup_after }.to change(project, :repository_read_only?).from(true).to(false)
    end

    it 'removes the BFG object map' do
      cleanup_after

      expect(project.bfg_object_map).not_to be_exist
    end
  end

  describe '#execute' do
    let(:project) { create(:project, :repository, bfg_object_map: fixture_file_upload('spec/fixtures/bfg_object_map.txt')) }
    let(:object_map) { project.bfg_object_map }
    let(:cleaner) { service.__send__(:repository_cleaner) }

    before do
      project.set_repository_read_only!
    end

    it 'runs the apply_bfg_object_map_stream gitaly RPC' do
      expect(cleaner).to receive(:apply_bfg_object_map_stream).with(kind_of(IO))

      service.execute
    end

    it 'runs garbage collection on the repository' do
      expect_next_instance_of(Projects::GitGarbageCollectWorker) do |worker|
        expect(worker).to receive(:perform).with(project.id, :prune, ""project_cleanup:gc:#{project.id}"")
      end

      service.execute
    end

    it 'clears the repository cache' do
      expect(project.repository).to receive(:expire_all_method_caches)

      service.execute
    end

    it 'removes the object map file' do
      service.execute

      expect(object_map.exists?).to be_falsy
    end

    it 'makes the repository read-write again' do
      expect { service.execute }
        .to change(project, :repository_read_only?)
        .from(true)
        .to(false)
    end

    context 'with a tainted merge request diff' do
      let(:merge_request) { create(:merge_request, source_project: project, target_project: project) }
      let(:diff) { merge_request.merge_request_diff }
      let(:entry) { build_entry(diff.commits.first.id) }

      before do
        allow(cleaner)
          .to receive(:apply_bfg_object_map_stream)
          .and_yield(Gitaly::ApplyBfgObjectMapStreamResponse.new(entries: [entry]))
      end

      it 'removes the tainted commit from the database' do
        service.execute

        expect(MergeRequestDiff.exists?(diff.id)).to be_falsy
      end

      it 'ignores non-commit responses from Gitaly' do
        entry.type = :UNKNOWN

        service.execute

        expect(MergeRequestDiff.exists?(diff.id)).to be_truthy
      end
    end

    context 'with a tainted diff note' do
      let(:diff_note) { create(:diff_note_on_commit, project: project) }
      let(:note_diff_file) { diff_note.note_diff_file }
      let(:entry) { build_entry(diff_note.commit_id) }

      let(:highlight_cache) { Gitlab::DiscussionsDiff::HighlightCache }
      let(:cache_id) { note_diff_file.id }

      before do
        allow(cleaner)
          .to receive(:apply_bfg_object_map_stream)
          .and_yield(Gitaly::ApplyBfgObjectMapStreamResponse.new(entries: [entry]))
      end

      it 'removes the tainted commit from the database' do
        service.execute

        expect(NoteDiffFile.exists?(note_diff_file.id)).to be_falsy
      end

      it 'removes the highlight cache from redis' do
        write_cache(highlight_cache, cache_id, [{}])

        expect(read_cache(highlight_cache, cache_id)).not_to be_nil

        service.execute

        expect(read_cache(highlight_cache, cache_id)).to be_nil
      end

      it 'ignores non-commit responses from Gitaly' do
        entry.type = :UNKNOWN

        service.execute

        expect(NoteDiffFile.exists?(note_diff_file.id)).to be_truthy
      end
    end

    it 'raises an error if no object map can be found' do
      object_map.remove!

      expect { service.execute }.to raise_error(described_class::NoUploadError)
    end
  end

  def build_entry(old_oid)
    Gitaly::ApplyBfgObjectMapStreamResponse::Entry.new(
      type: :COMMIT,
      old_oid: old_oid,
      new_oid: Gitlab::Git::BLANK_SHA
    )
  end

  def read_cache(cache, key)
    cache.read_multiple([key]).first
  end

  def write_cache(cache, key, value)
    cache.write_multiple(key => value)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class UpdateRemoteMirrorService < BaseService
    include Gitlab::Utils::StrongMemoize

    MAX_TRIES = 3

    def execute(remote_mirror, tries)
      return success unless remote_mirror.enabled?

      # Blocked URLs are a hard failure, no need to attempt to retry
      if Gitlab::UrlBlocker.blocked_url?(normalized_url(remote_mirror.url), schemes: Project::VALID_MIRROR_PROTOCOLS)
        hard_retry_or_fail(remote_mirror, _('The remote mirror URL is invalid.'), tries)
        return error(remote_mirror.last_error)
      end

      update_mirror(remote_mirror)

      success
    rescue Gitlab::Git::CommandError => e
      # This happens if one of the gitaly calls above fail, for example when
      # branches have diverged, or the pre-receive hook fails.
      hard_retry_or_fail(remote_mirror, e.message, tries)

      error(e.message)
    rescue StandardError => e
      remote_mirror.hard_fail!(e.message)
      raise e
    end

    private

    def normalized_url(url)
      strong_memoize(:normalized_url) do
        CGI.unescape(Gitlab::UrlSanitizer.sanitize(url))
      end
    end

    def update_mirror(remote_mirror)
      remote_mirror.update_start!

      # LFS objects must be sent first, or the push has dangling pointers
      lfs_status = send_lfs_objects!(remote_mirror)

      response = remote_mirror.update_repository
      failed, failure_message = failure_status(lfs_status, response, remote_mirror)

      # When the issue https://gitlab.com/gitlab-org/gitlab/-/issues/349262 is closed,
      # we can move this block within failure_status.
      if failed
        remote_mirror.mark_as_failed!(failure_message)
      else
        remote_mirror.update_finish!
      end
    end

    def failure_status(lfs_status, response, remote_mirror)
      message = ''
      failed = false
      lfs_sync_failed = false

      if lfs_status&.dig(:status) == :error
        lfs_sync_failed = true
        message += ""Error synchronizing LFS files:""
        message += ""\n\n#{lfs_status[:message]}\n\n""

        failed = Feature.enabled?(:remote_mirror_fail_on_lfs, project)
      end

      if response.divergent_refs.any?
        message += ""Some refs have diverged and have not been updated on the remote:""
        message += ""\n\n#{response.divergent_refs.join(""\n"")}""
        failed = true
      end

      if message.present?
        Gitlab::AppJsonLogger.info(
          message: ""Error synching remote mirror"",
          project_id: project.id,
          project_path: project.full_path,
          remote_mirror_id: remote_mirror.id,
          lfs_sync_failed: lfs_sync_failed,
          divergent_ref_list: response.divergent_refs
        )
      end

      [failed, message]
    end

    def send_lfs_objects!(remote_mirror)
      return unless project.lfs_enabled?

      # TODO: Support LFS sync over SSH
      # https://gitlab.com/gitlab-org/gitlab/-/issues/249587
      return unless %r{\Ahttps?://}i.match?(remote_mirror.url)
      return unless remote_mirror.password_auth?

      Lfs::PushService.new(
        project,
        current_user,
        url: remote_mirror.bare_url,
        credentials: remote_mirror.credentials
      ).execute
    end

    def hard_retry_or_fail(mirror, message, tries)
      if tries < MAX_TRIES
        mirror.hard_retry!(message)
      else
        # It's not likely we'll be able to recover from this ourselves, so we'll
        # notify the users of the problem, and don't trigger any sidekiq retries
        # Instead, we'll wait for the next change to try the push again, or until
        # a user manually retries.
        mirror.hard_fail!(message)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::UpdateRemoteMirrorService, feature_category: :source_code_management do
  let_it_be(:project) { create(:project, :repository, lfs_enabled: true) }
  let_it_be(:remote_project) { create(:forked_project_with_submodules) }
  let_it_be(:remote_mirror) { create(:remote_mirror, project: project, enabled: true) }

  subject(:service) { described_class.new(project, project.creator) }

  describe '#execute' do
    let(:retries) { 0 }

    subject(:execute!) { service.execute(remote_mirror, retries) }

    before do
      project.repository.add_branch(project.first_owner, 'existing-branch', 'master')

      allow(remote_mirror)
        .to receive(:update_repository)
        .and_return(double(divergent_refs: []))
    end

    it 'does not fetch the remote repository' do
      # See https://gitlab.com/gitlab-org/gitaly/-/issues/2670
      expect(project.repository).not_to receive(:fetch_remote)

      execute!
    end

    it 'marks the mirror as started when beginning' do
      expect(remote_mirror).to receive(:update_start!).and_call_original

      execute!
    end

    it 'marks the mirror as successfully finished' do
      result = execute!

      expect(result[:status]).to eq(:success)
      expect(remote_mirror).to be_finished
    end

    it 'marks the mirror as failed and raises the error when an unexpected error occurs' do
      allow(remote_mirror).to receive(:update_repository).and_raise('Badly broken')

      expect { execute! }.to raise_error(/Badly broken/)

      expect(remote_mirror).to be_failed
      expect(remote_mirror.last_error).to include('Badly broken')
    end

    context 'when the URL is blocked' do
      before do
        allow(Gitlab::UrlBlocker).to receive(:blocked_url?).and_return(true)
      end

      it 'hard retries and returns error status' do
        expect(execute!).to eq(status: :error, message: 'The remote mirror URL is invalid.')
        expect(remote_mirror).to be_to_retry
      end

      context 'when retries are exceeded' do
        let(:retries) { 4 }

        it 'hard fails and returns error status' do
          expect(execute!).to eq(status: :error, message: 'The remote mirror URL is invalid.')
          expect(remote_mirror).to be_failed
        end
      end
    end

    context ""when given URLs containing escaped elements"" do
      it_behaves_like ""URLs containing escaped elements return expected status"" do
        let(:result) { execute! }

        before do
          allow(remote_mirror).to receive(:url).and_return(url)
        end
      end
    end

    context 'when the update fails because of a `Gitlab::Git::CommandError`' do
      before do
        allow(remote_mirror).to receive(:update_repository)
          .and_raise(Gitlab::Git::CommandError.new('update failed'))
      end

      it 'wraps `Gitlab::Git::CommandError`s in a service error' do
        expect(execute!).to eq(status: :error, message: 'update failed')
      end

      it 'marks the mirror as to be retried' do
        execute!

        expect(remote_mirror).to be_to_retry
        expect(remote_mirror.last_error).to include('update failed')
      end

      it ""marks the mirror as failed after #{described_class::MAX_TRIES} tries"" do
        service.execute(remote_mirror, described_class::MAX_TRIES)

        expect(remote_mirror).to be_failed
        expect(remote_mirror.last_error).to include('update failed')
      end
    end

    context 'when there are divergent refs' do
      it 'marks the mirror as failed and sets an error message' do
        response = double(divergent_refs: %w[refs/heads/master refs/heads/develop])
        expect(remote_mirror).to receive(:update_repository).and_return(response)

        execute!

        expect(remote_mirror).to be_failed
        expect(remote_mirror.last_error).to include(""Some refs have diverged"")
        expect(remote_mirror.last_error).to include(""refs/heads/master\n"")
        expect(remote_mirror.last_error).to include(""refs/heads/develop"")
      end
    end

    context ""sending lfs objects"" do
      let_it_be(:lfs_pointer) { create(:lfs_objects_project, project: project) }

      before do
        stub_lfs_setting(enabled: true)
      end

      it 'pushes LFS objects to a HTTP repository' do
        expect_next_instance_of(Lfs::PushService) do |service|
          expect(service).to receive(:execute)
        end
        expect(Gitlab::AppJsonLogger).not_to receive(:info)

        execute!

        expect(remote_mirror.update_status).to eq('finished')
        expect(remote_mirror.last_error).to be_nil
      end

      context 'when LFS objects fail to push' do
        before do
          expect_next_instance_of(Lfs::PushService) do |service|
            expect(service).to receive(:execute).and_return({ status: :error, message: 'unauthorized' })
          end
        end

        context 'when remote_mirror_fail_on_lfs feature flag enabled' do
          it 'fails update' do
            expect(Gitlab::AppJsonLogger).to receive(:info).with(
              hash_including(message: ""Error synching remote mirror"")).and_call_original

            execute!

            expect(remote_mirror.update_status).to eq('failed')
            expect(remote_mirror.last_error).to eq(""Error synchronizing LFS files:\n\nunauthorized\n\n"")
          end
        end

        context 'when remote_mirror_fail_on_lfs feature flag is disabled' do
          before do
            stub_feature_flags(remote_mirror_fail_on_lfs: false)
          end

          it 'does not fail update' do
            expect(Gitlab::AppJsonLogger).to receive(:info).with(
              hash_including(message: ""Error synching remote mirror"")).and_call_original

            execute!

            expect(remote_mirror.update_status).to eq('finished')
            expect(remote_mirror.last_error).to be_nil
          end
        end
      end

      context 'with SSH repository' do
        let(:ssh_mirror) { create(:remote_mirror, project: project, enabled: true) }

        before do
          allow(ssh_mirror)
            .to receive(:update_repository)
            .and_return(double(divergent_refs: []))
        end

        it 'does nothing to an SSH repository' do
          ssh_mirror.update!(url: 'ssh://example.com')

          expect_any_instance_of(Lfs::PushService).not_to receive(:execute)

          service.execute(ssh_mirror, retries)
        end

        it 'does nothing if LFS is disabled' do
          expect(project).to receive(:lfs_enabled?) { false }

          expect_any_instance_of(Lfs::PushService).not_to receive(:execute)

          service.execute(ssh_mirror, retries)
        end

        it 'does nothing if non-password auth is specified' do
          ssh_mirror.update!(auth_method: 'ssh_public_key')

          expect_any_instance_of(Lfs::PushService).not_to receive(:execute)

          service.execute(ssh_mirror, retries)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class MoveAccessService < BaseMoveRelationsService
    def execute(source_project, remove_remaining_elements: true)
      return unless super

      @project.with_transaction_returning_status do
        if @project.namespace != source_project.namespace
          @project.run_after_commit do
            source_project.namespace.refresh_project_authorizations
            self.namespace.refresh_project_authorizations
          end
        end

        ::Projects::MoveProjectMembersService.new(@project, @current_user)
          .execute(source_project, remove_remaining_elements: remove_remaining_elements)
        ::Projects::MoveProjectGroupLinksService.new(@project, @current_user)
          .execute(source_project, remove_remaining_elements: remove_remaining_elements)
        ::Projects::MoveProjectAuthorizationsService.new(@project, @current_user)
          .execute(source_project, remove_remaining_elements: remove_remaining_elements)

        @project.save(touch: false)

        success
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::MoveAccessService, feature_category: :groups_and_projects do
  let(:user) { create(:user) }
  let(:group) { create(:group) }
  let(:project_with_access) { create(:project, namespace: user.namespace) }
  let(:maintainer_user) { create(:user) }
  let(:reporter_user) { create(:user) }
  let(:developer_user) { create(:user) }
  let(:maintainer_group) { create(:group) }
  let(:reporter_group) { create(:group) }
  let(:developer_group) { create(:group) }

  before do
    project_with_access.add_maintainer(maintainer_user)
    project_with_access.add_developer(developer_user)
    project_with_access.add_reporter(reporter_user)
    project_with_access.project_group_links.create!(group: maintainer_group, group_access: Gitlab::Access::MAINTAINER)
    project_with_access.project_group_links.create!(group: developer_group, group_access: Gitlab::Access::DEVELOPER)
    project_with_access.project_group_links.create!(group: reporter_group, group_access: Gitlab::Access::REPORTER)
  end

  subject { described_class.new(target_project, user) }

  describe '#execute' do
    shared_examples 'move the accesses' do
      it 'moves the accesses', :sidekiq_inline do
        expect(project_with_access.project_members.count).to eq 4
        expect(project_with_access.project_group_links.count).to eq 3
        expect(project_with_access.authorized_users.count).to eq 4

        subject.execute(project_with_access)

        expect(project_with_access.project_members.count).to eq 0
        expect(project_with_access.project_group_links.count).to eq 0
        expect(project_with_access.authorized_users.count).to eq 1
        expect(target_project.project_members.count).to eq 4
        expect(target_project.project_group_links.count).to eq 3
        expect(target_project.authorized_users.count).to eq 4
      end

      it 'rollbacks if an exception is raised' do
        allow(subject).to receive(:success).and_raise(StandardError)

        expect { subject.execute(project_with_groups) }.to raise_error(StandardError)

        expect(project_with_access.project_members.count).to eq 4
        expect(project_with_access.project_group_links.count).to eq 3
        expect(project_with_access.authorized_users.count).to eq 4
      end
    end

    context 'when both projects are in the same namespace' do
      let(:target_project) { create(:project, namespace: user.namespace) }

      it 'does not refresh project owner authorized projects' do
        allow(project_with_access).to receive(:namespace).and_return(user.namespace)
        expect(project_with_access.namespace).not_to receive(:refresh_project_authorizations)
        expect(target_project.namespace).not_to receive(:refresh_project_authorizations)

        subject.execute(project_with_access)
      end

      it_behaves_like 'move the accesses'
    end

    context 'when projects are in different namespaces' do
      let(:target_project) { create(:project, namespace: group) }

      before do
        group.add_owner(user)
      end

      it 'refreshes both project owner authorized projects' do
        allow(project_with_access).to receive(:namespace).and_return(user.namespace)
        expect(user.namespace).to receive(:refresh_project_authorizations).once
        expect(group).to receive(:refresh_project_authorizations).once

        subject.execute(project_with_access)
      end

      it_behaves_like 'move the accesses'
    end

    context 'when remove_remaining_elements is false' do
      let(:target_project) { create(:project, namespace: user.namespace) }
      let(:options) { { remove_remaining_elements: false } }

      it 'does not remove remaining memberships' do
        target_project.add_maintainer(maintainer_user)

        subject.execute(project_with_access, **options)

        expect(project_with_access.project_members.count).not_to eq 0
      end

      it 'does not remove remaining group links' do
        target_project.project_group_links.create!(group: maintainer_group, group_access: Gitlab::Access::MAINTAINER)

        subject.execute(project_with_access, **options)

        expect(project_with_access.project_group_links.count).not_to eq 0
      end

      it 'does not remove remaining authorizations' do
        target_project.add_developer(developer_user)

        subject.execute(project_with_access, **options)

        expect(project_with_access.project_authorizations.count).not_to eq 0
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# NOTE: This service cannot be used directly because it is part of a
# a bigger process. Instead, use the service MoveAccessService which moves
# project memberships, project group links, authorizations and refreshes
# the authorizations if necessary
module Projects
  class MoveProjectAuthorizationsService < BaseMoveRelationsService
    def execute(source_project, remove_remaining_elements: true)
      return unless super

      Project.transaction do
        move_project_authorizations

        remove_remaining_authorizations if remove_remaining_elements

        success
      end
    end

    private

    def move_project_authorizations
      non_existent_authorization.update_all(project_id: @project.id)
    end

    def remove_remaining_authorizations
      # I think because the Project Authorization table does not have a primary key
      # it brings a lot a problems/bugs. First, Rails raises PG::SyntaxException if we use
      # destroy_all instead of delete_all.
      source_project.project_authorizations.delete_all(:delete_all)
    end

    # Look for authorizations in source_project that are not in the target project
    # rubocop: disable CodeReuse/ActiveRecord
    def non_existent_authorization
      source_project.project_authorizations
                    .select(:user_id)
                    .where.not(user: @project.authorized_users)
    end
    # rubocop: enable CodeReuse/ActiveRecord
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::MoveProjectAuthorizationsService, feature_category: :groups_and_projects do
  let!(:user) { create(:user) }
  let(:project_with_users) { create(:project, namespace: user.namespace) }
  let(:target_project) { create(:project, namespace: user.namespace) }
  let(:maintainer_user) { create(:user) }
  let(:reporter_user) { create(:user) }
  let(:developer_user) { create(:user) }

  subject { described_class.new(target_project, user) }

  describe '#execute' do
    before do
      project_with_users.add_maintainer(maintainer_user)
      project_with_users.add_developer(developer_user)
      project_with_users.add_reporter(reporter_user)
    end

    it 'moves the authorizations from one project to another' do
      expect(project_with_users.authorized_users.count).to eq 4
      expect(target_project.authorized_users.count).to eq 1

      subject.execute(project_with_users)

      expect(project_with_users.authorized_users.count).to eq 0
      expect(target_project.authorized_users.count).to eq 4
    end

    it 'does not move existent authorizations to the current project' do
      target_project.add_maintainer(developer_user)
      target_project.add_developer(reporter_user)

      expect(project_with_users.authorized_users.count).to eq 4
      expect(target_project.authorized_users.count).to eq 3

      subject.execute(project_with_users)

      expect(project_with_users.authorized_users.count).to eq 0
      expect(target_project.authorized_users.count).to eq 4
    end

    context 'when remove_remaining_elements is false' do
      let(:options) { { remove_remaining_elements: false } }

      it 'does not remove remaining project authorizations' do
        target_project.add_maintainer(developer_user)
        target_project.add_developer(reporter_user)

        subject.execute(project_with_users, **options)

        expect(project_with_users.project_authorizations.count).not_to eq 0
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  # Tries to schedule a move for every project with repositories on the source shard
  class ScheduleBulkRepositoryShardMovesService
    include ScheduleBulkRepositoryShardMovesMethods
    extend ::Gitlab::Utils::Override

    private

    override :repository_klass
    def repository_klass
      ProjectRepository
    end

    override :container_klass
    def container_klass
      Project
    end

    override :container_column
    def container_column
      :project_id
    end

    override :schedule_bulk_worker_klass
    def self.schedule_bulk_worker_klass
      ::Projects::ScheduleBulkRepositoryShardMovesWorker
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::ScheduleBulkRepositoryShardMovesService, feature_category: :source_code_management do
  it_behaves_like 'moves repository shard in bulk' do
    let_it_be_with_reload(:container) { create(:project, :repository) }

    let(:move_service_klass) { Projects::RepositoryStorageMove }
    let(:bulk_worker_klass) { ::Projects::ScheduleBulkRepositoryShardMovesWorker }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class ReadmeRendererService < BaseService
    include Rails.application.routes.url_helpers

    TEMPLATE_PATH = Rails.root.join('app', 'views', 'projects', 'readme_templates')

    def execute
      render(params[:template_name] || :default)
    end

    private

    def render(template_name)
      ERB.new(File.read(sanitized_filename(template_name)), trim_mode: '<>').result(binding)
    end

    def sanitized_filename(template_name)
      path = Gitlab::PathTraversal.check_path_traversal!(""#{template_name}.md.tt"")
      path = TEMPLATE_PATH.join(path).to_s
      Gitlab::PathTraversal.check_allowed_absolute_path!(path, [TEMPLATE_PATH.to_s])

      path
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::ReadmeRendererService, '#execute', feature_category: :groups_and_projects do
  using RSpec::Parameterized::TableSyntax

  subject(:service) { described_class.new(project, nil, opts) }

  let_it_be(:project) { create(:project, title: 'My Project', description: '_custom_description_') }

  let(:opts) { { default_branch: 'master' } }

  it 'renders the an ERB readme template' do
    expect(service.execute).to start_with(<<~MARKDOWN)
      # My Project

      _custom_description_

      ## Getting started

      To make it easy for you to get started with GitLab, here's a list of recommended next steps.

      Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!

      ## Add your files

      - [ ] [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files
      - [ ] [Add files using the command line](https://docs.gitlab.com/ee/gitlab-basics/add-file.html#add-a-file-using-the-command-line) or push an existing Git repository with the following command:

      ```
      cd existing_repo
      git remote add origin #{project.http_url_to_repo}
      git branch -M master
      git push -uf origin master
      ```
    MARKDOWN
  end

  context 'with a custom template' do
    before do
      allow(File).to receive(:read).and_call_original
    end

    it 'renders that template file' do
      opts[:template_name] = :custom_readme

      expect(service).to receive(:sanitized_filename).with(:custom_readme).and_return('custom_readme.md.tt')
      expect(File).to receive(:read).with('custom_readme.md.tt').and_return('_custom_readme_file_content_')
      expect(service.execute).to eq('_custom_readme_file_content_')
    end

    context 'with path traversal in mind' do
      where(:template_name, :exception, :expected_path) do
        '../path/traversal/bad' | [Gitlab::PathTraversal::PathTraversalAttackError, 'Invalid path'] | nil
        '/bad/template' | [StandardError, 'path /bad/template.md.tt is not allowed'] | nil
        'good/template' | nil | 'good/template.md.tt'
      end

      with_them do
        it 'raises the expected exception on bad paths' do
          opts[:template_name] = template_name

          if exception
            expect { subject.execute }.to raise_error(*exception)
          else
            expect(File).to receive(:read).with(described_class::TEMPLATE_PATH.join(expected_path).to_s).and_return('')

            expect { subject.execute }.not_to raise_error
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class DestroyService < BaseService
    include Gitlab::ShellAdapter

    DestroyError = Class.new(StandardError)
    BATCH_SIZE = 100

    def async_execute
      project.update_attribute(:pending_delete, true)

      job_id = ProjectDestroyWorker.perform_async(project.id, current_user.id, params)
      log_info(""User #{current_user.id} scheduled destruction of project #{project.full_path} with job ID #{job_id}"")
    end

    def execute
      return false unless can?(current_user, :remove_project, project)

      project.update_attribute(:pending_delete, true)

      # There is a possibility of active repository move processes for
      # project and snippets. An attempt to delete the project at the same time
      # can lead to race condition and an inconsistent state.
      #
      # This validation stops the project delete process if it detects active
      # repository move schedules for it.
      validate_active_repositories_move!

      # Flush the cache for both repositories. This has to be done _before_
      # removing the physical repositories as some expiration code depends on
      # Git data (e.g. a list of branch names).
      flush_caches(project)

      ::Ci::AbortPipelinesService.new.execute(project.all_pipelines, :project_deleted)

      Projects::UnlinkForkService.new(project, current_user).execute(refresh_statistics: false)

      attempt_destroy(project)

      system_hook_service.execute_hooks_for(project, :destroy)
      log_info(""Project \""#{project.full_path}\"" was deleted"")

      publish_project_deleted_event_for(project)

      project.invalidate_personal_projects_count_of_owner

      true
    rescue StandardError => error
      context = Gitlab::ApplicationContext.current.merge(project_id: project.id)
      Gitlab::ErrorTracking.track_exception(error, **context)
      attempt_rollback(project, error.message)
      false
    rescue Exception => error # rubocop:disable Lint/RescueException
      # Project.transaction can raise Exception
      attempt_rollback(project, error.message)
      raise
    end

    private

    def validate_active_repositories_move!
      if project.repository_storage_moves.scheduled_or_started.exists?
        raise_error(s_(""DeleteProject|Couldn't remove the project. A project repository storage move is in progress. Try again when it's complete.""))
      end

      if ::ProjectSnippet.by_project(project).with_repository_storage_moves.merge(::Snippets::RepositoryStorageMove.scheduled_or_started).exists?
        raise_error(s_(""DeleteProject|Couldn't remove the project. A related snippet repository storage move is in progress. Try again when it's complete.""))
      end
    end

    def trash_project_repositories!
      unless remove_repository(project.repository)
        raise_error(s_('DeleteProject|Failed to remove project repository. Please try again or contact administrator.'))
      end

      unless remove_repository(project.wiki.repository)
        raise_error(s_('DeleteProject|Failed to remove wiki repository. Please try again or contact administrator.'))
      end

      unless remove_repository(project.design_repository)
        raise_error(s_('DeleteProject|Failed to remove design repository. Please try again or contact administrator.'))
      end
    end

    def trash_relation_repositories!
      unless remove_snippets
        raise_error(s_('DeleteProject|Failed to remove project snippets. Please try again or contact administrator.'))
      end
    end

    def remove_snippets
      # We're setting the skip_authorization param because we dont need to perform the access checks within the service since
      # the user has enough access rights to remove the project and its resources.
      response = ::Snippets::BulkDestroyService.new(current_user, project.snippets).execute(skip_authorization: true)

      if response.error?
        log_error(""Snippet deletion failed on #{project.full_path} with the following message: #{response.message}"")
      end

      response.success?
    end

    def destroy_events!
      unless remove_events
        raise_error(s_('DeleteProject|Failed to remove events. Please try again or contact administrator.'))
      end
    end

    def remove_events
      log_info(""Attempting to destroy events from #{project.full_path} (#{project.id})"")

      response = ::Events::DestroyService.new(project).execute

      if response.error?
        log_error(""Event deletion failed on #{project.full_path} with the following message: #{response.message}"")
      end

      response.success?
    end

    def remove_repository(repository)
      return true unless repository

      result = Repositories::DestroyService.new(repository).execute

      result[:status] == :success
    end

    def attempt_rollback(project, message)
      return unless project

      # It's possible that the project was destroyed, but some after_commit
      # hook failed and caused us to end up here. A destroyed model will be a frozen hash,
      # which cannot be altered.
      unless project.destroyed?
        # Restrict project visibility if the parent group visibility was made more restrictive while the project was scheduled for deletion.
        visibility_level = project.visibility_level_allowed_by_group? ? project.visibility_level : project.group.visibility_level
        project.update(delete_error: message, pending_delete: false, visibility_level: visibility_level)
      end

      log_error(""Deletion failed on #{project.full_path} with the following message: #{message}"")
    end

    def attempt_destroy(project)
      unless remove_registry_tags
        raise_error(s_('DeleteProject|Failed to remove some tags in project container registry. Please try again or contact administrator.'))
      end

      project.leave_pool_repository
      destroy_project_related_records(project)
    end

    def destroy_project_related_records(project)
      log_destroy_event
      trash_relation_repositories!
      trash_project_repositories!
      destroy_events!
      destroy_web_hooks!
      destroy_project_bots!
      destroy_ci_records!
      destroy_mr_diff_relations!

      destroy_merge_request_diffs!

      # Rails attempts to load all related records into memory before
      # destroying: https://github.com/rails/rails/issues/22510
      # This ensures we delete records in batches.
      #
      # Exclude container repositories because its before_destroy would be
      # called multiple times, and it doesn't destroy any database records.
      project.destroy_dependent_associations_in_batches(exclude: [:container_repositories, :snippets])
      project.destroy!
    end

    def log_destroy_event
      log_info(""Attempting to destroy #{project.full_path} (#{project.id})"")
    end

    # Projects will have at least one merge_request_diff_commit for every commit
    #   contained in every MR, which deleting via `project.destroy!` and
    #   cascading deletes may exceed statement timeouts, causing failures.
    #   (see https://gitlab.com/gitlab-org/gitlab/-/issues/346166)
    #
    # Removing merge_request_diff_files records may also cause timeouts, so they
    #   can be deleted in batches as well.
    #
    # rubocop: disable CodeReuse/ActiveRecord
    def destroy_mr_diff_relations!
      delete_batch_size = 1000

      project.merge_requests.each_batch(column: :iid, of: BATCH_SIZE) do |relation_ids|
        [MergeRequestDiffCommit, MergeRequestDiffFile].each do |model|
          loop do
            inner_query = model
              .select(:merge_request_diff_id, :relative_order)
              .where(merge_request_diff_id: MergeRequestDiff.where(merge_request_id: relation_ids).select(:id))
              .limit(delete_batch_size)

            deleted_rows = model
              .where(""(#{model.table_name}.merge_request_diff_id, #{model.table_name}.relative_order) IN (?)"", inner_query) # rubocop:disable GitlabSecurity/SqlInjection
              .delete_all

            break if deleted_rows == 0
          end
        end
      end
    end
    # rubocop: enable CodeReuse/ActiveRecord

    # rubocop: disable CodeReuse/ActiveRecord
    def destroy_merge_request_diffs!
      delete_batch_size = 1000

      project.merge_requests.each_batch(column: :iid, of: BATCH_SIZE) do |relation|
        loop do
          deleted_rows = MergeRequestDiff
            .where(merge_request: relation)
            .limit(delete_batch_size)
            .delete_all

          break if deleted_rows == 0
        end
      end
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def destroy_ci_records!
      # Make sure to destroy this first just in case the project is undergoing stats refresh.
      # This is to avoid logging the artifact deletion in Ci::JobArtifacts::DestroyBatchService.
      project.build_artifacts_size_refresh&.destroy

      project.all_pipelines.find_each(batch_size: BATCH_SIZE) do |pipeline| # rubocop: disable CodeReuse/ActiveRecord
        # Destroy artifacts, then builds, then pipelines
        # All builds have already been dropped by Ci::AbortPipelinesService,
        # so no Ci::Build-instantiating cancellations happen here.
        # https://gitlab.com/gitlab-org/gitlab/-/merge_requests/71342#note_691523196

        ::Ci::DestroyPipelineService.new(project, current_user).execute(pipeline)
      end

      project.secure_files.find_each(batch_size: BATCH_SIZE) do |secure_file| # rubocop: disable CodeReuse/ActiveRecord
        ::Ci::DestroySecureFileService.new(project, current_user).execute(secure_file)
      end

      deleted_count = ::CommitStatus.for_project(project).delete_all

      Gitlab::AppLogger.info(
        class: 'Projects::DestroyService',
        project_id: project.id,
        message: 'leftover commit statuses',
        orphaned_commit_status_count: deleted_count
      )
    end

    # The project can have multiple webhooks with hundreds of thousands of web_hook_logs.
    # By default, they are removed with ""DELETE CASCADE"" option defined via foreign_key.
    # But such queries can exceed the statement_timeout limit and fail to delete the project.
    # (see https://gitlab.com/gitlab-org/gitlab/-/issues/26259)
    #
    # To prevent that we use WebHooks::DestroyService. It deletes logs in batches and
    # produces smaller and faster queries to the database.
    def destroy_web_hooks!
      project.hooks.find_each do |web_hook|
        result = ::WebHooks::DestroyService.new(current_user).execute(web_hook)

        unless result[:status] == :success
          raise_error(s_('DeleteProject|Failed to remove webhooks. Please try again or contact administrator.'))
        end
      end
    end

    # The project can have multiple project bots with personal access tokens generated.
    # We need to remove them when a project is deleted
    # rubocop: disable CodeReuse/ActiveRecord
    def destroy_project_bots!
      members = project.members
        .allow_cross_joins_across_databases(url: 'https://gitlab.com/gitlab-org/gitlab/-/issues/422405')
        .includes(:user).references(:user).merge(User.project_bot)

      members.each do |member|
        Users::DestroyService.new(current_user).execute(member.user, skip_authorization: true)
      end
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def remove_registry_tags
      return true unless Gitlab.config.registry.enabled
      return false unless remove_legacy_registry_tags

      results = []
      project.container_repositories.find_each do |container_repository|
        results << destroy_repository(project, container_repository)
      end

      results.all?
    end

    ##
    # This method makes sure that we correctly remove registry tags
    # for legacy image repository (when repository path equals project path).
    #
    def remove_legacy_registry_tags
      return true unless Gitlab.config.registry.enabled

      root_repository = ::ContainerRepository.build_root_repository(project)
      root_repository.has_tags? ? destroy_repository(project, root_repository) : true
    end

    def destroy_repository(project, repository)
      service = ContainerRepository::DestroyService.new(project, current_user, { skip_permission_check: true })
      response = service.execute(repository)
      response[:status] == :success
    end

    def raise_error(message)
      raise DestroyError, message
    end

    def flush_caches(project)
      Projects::ForksCountService.new(project).delete_cache
    end

    def publish_project_deleted_event_for(project)
      event = Projects::ProjectDeletedEvent.new(data: {
        project_id: project.id,
        namespace_id: project.namespace_id,
        root_namespace_id: project.root_namespace.id
      })

      Gitlab::EventStore.publish(event)
    end
  end
end

Projects::DestroyService.prepend_mod_with('Projects::DestroyService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::DestroyService, :aggregate_failures, :event_store_publisher, feature_category: :groups_and_projects do
  include ProjectForksHelper
  include BatchDestroyDependentAssociationsHelper

  let_it_be(:user) { create(:user) }

  let!(:project) { create(:project, :repository, namespace: user.namespace) }
  let(:path) { project.repository.disk_path }
  let(:async) { false } # execute or async_execute

  before do
    stub_container_registry_config(enabled: true)
    stub_container_registry_tags(repository: :any, tags: [])
  end

  shared_examples 'deleting the project' do
    it 'deletes the project', :sidekiq_inline do
      destroy_project(project, user, {})

      expect(Project.unscoped.all).not_to include(project)

      expect(project.gitlab_shell.repository_exists?(project.repository_storage, path + '.git')).to be_falsey
    end

    it 'publishes a ProjectDeletedEvent' do
      expected_data = {
        project_id: project.id,
        namespace_id: project.namespace_id,
        root_namespace_id: project.root_namespace.id
      }

      expect { destroy_project(project, user, {}) }.to publish_event(Projects::ProjectDeletedEvent).with(expected_data)
    end
  end

  shared_examples 'deleting the project with pipeline and build' do
    context 'with pipeline and build related records', :sidekiq_inline do # which has optimistic locking
      let!(:pipeline) { create(:ci_pipeline, project: project) }
      let!(:build) { create(:ci_build, :artifacts, :with_runner_session, pipeline: pipeline) }
      let!(:trace_chunks) { create(:ci_build_trace_chunk, build: build) }
      let!(:job_variables) { create(:ci_job_variable, job: build) }
      let!(:report_result) { create(:ci_build_report_result, build: build) }
      let!(:pending_state) { create(:ci_build_pending_state, build: build) }
      let!(:pipeline_artifact) { create(:ci_pipeline_artifact, pipeline: pipeline) }
      let!(:secure_file) { create(:ci_secure_file, project: project) }

      it 'deletes build and pipeline related records' do
        expect { destroy_project(project, user, {}) }
          .to  change { Ci::Build.count }.by(-1)
          .and change { Ci::BuildTraceChunk.count }.by(-1)
          .and change { Ci::JobArtifact.count }.by(-2)
          .and change { Ci::DeletedObject.count }.by(2)
          .and change { Ci::PipelineArtifact.count }.by(-1)
          .and change { Ci::JobVariable.count }.by(-1)
          .and change { Ci::BuildPendingState.count }.by(-1)
          .and change { Ci::BuildReportResult.count }.by(-1)
          .and change { Ci::BuildRunnerSession.count }.by(-1)
          .and change { Ci::Pipeline.count }.by(-1)
          .and change { Ci::SecureFile.count }.by(-1)
      end

      it 'avoids N+1 queries' do
        recorder = ActiveRecord::QueryRecorder.new { destroy_project(project, user, {}) }

        project = create(:project, :repository, namespace: user.namespace)
        pipeline = create(:ci_pipeline, project: project)
        builds = create_list(:ci_build, 3, :artifacts, pipeline: pipeline)
        create(:ci_pipeline_artifact, pipeline: pipeline)
        create_list(:ci_build_trace_chunk, 3, build: builds[0])

        expect { destroy_project(project, project.first_owner, {}) }.not_to exceed_query_limit(recorder)
      end

      it_behaves_like 'deleting the project'

      context 'when project is undergoing refresh' do
        let!(:build_artifacts_size_refresh) { create(:project_build_artifacts_size_refresh, :pending, project: project) }

        it 'does not log about artifact deletion but continues to delete artifacts' do
          expect(Gitlab::ProjectStatsRefreshConflictsLogger).not_to receive(:warn_artifact_deletion_during_stats_refresh)

          expect { destroy_project(project, user, {}) }
            .to change { Ci::JobArtifact.count }.by(-2)
            .and change { Projects::BuildArtifactsSizeRefresh.count }.by(-1)
        end
      end
    end
  end

  shared_examples 'handles errors thrown during async destroy' do |error_message|
    it 'does not allow the error to bubble up' do
      expect do
        destroy_project(project, user, {})
      end.not_to raise_error
    end

    it 'reports the error' do
      expect(Gitlab::ErrorTracking).to receive(:track_exception).and_call_original
      destroy_project(project, user, {})
    end

    it 'unmarks the project as ""pending deletion""' do
      destroy_project(project, user, {})

      expect(project.reload.pending_delete).to be(false)
    end

    it 'stores an error message in `projects.delete_error`' do
      destroy_project(project, user, {})

      expect(project.reload.delete_error).to be_present
      expect(project.delete_error).to match(error_message)
    end

    context 'when parent group visibility was made more restrictive while project was marked ""pending deletion""' do
      let!(:group) { create(:group, :public) }
      let!(:project) { create(:project, :repository, :public, namespace: group) }

      it 'sets the project visibility level to that of the parent group' do
        group.add_owner(user)
        project.group.update_attribute(:visibility_level, Gitlab::VisibilityLevel::INTERNAL)

        expect(project.reload.visibility_level).to be(Gitlab::VisibilityLevel::PUBLIC)
        expect(project.group.visibility_level).to be(Gitlab::VisibilityLevel::INTERNAL)

        destroy_project(project, user, {})

        expect(project.reload.visibility_level).to be(Gitlab::VisibilityLevel::INTERNAL)
      end
    end
  end

  context ""deleting a project with merge requests"" do
    let!(:merge_request) { create(:merge_request, source_project: project) }

    before do
      allow(project).to receive(:destroy!).and_return(true)
    end

    [MergeRequestDiffCommit, MergeRequestDiffFile].each do |model|
      it ""deletes #{model} records of the merge request"" do
        merge_request_diffs = merge_request.merge_request_diffs
        expect(merge_request_diffs.size).to eq(1)

        records_count = model.where(merge_request_diff_id: merge_request_diffs.first.id).count

        expect { destroy_project(project, user, {}) }.to change { model.count }.by(-records_count)
      end
    end
  end

  context 'deleting a project with merge request diffs' do
    let!(:merge_request) { create(:merge_request, source_project: project) }
    let!(:another_project_mr) { create(:merge_request, source_project: create(:project)) }

    it 'deletes merge request diffs' do
      merge_request_diffs = merge_request.merge_request_diffs
      expect(merge_request_diffs.size).to eq(1)

      expect { destroy_project(project, user, {}) }.to change(MergeRequestDiff, :count).by(-1)
      expect { another_project_mr.reload }.not_to raise_error
    end
  end

  it_behaves_like 'deleting the project'

  context 'personal projects count cache' do
    context 'when the executor is the creator of the project itself' do
      it 'invalidates personal_project_count cache of the the owner of the personal namespace' do
        expect(user).to receive(:invalidate_personal_projects_count)

        destroy_project(project, user, {})
      end
    end

    context 'when the executor is the instance administrator', :enable_admin_mode do
      it 'invalidates personal_project_count cache of the the owner of the personal namespace' do
        expect(user).to receive(:invalidate_personal_projects_count)

        destroy_project(project, create(:admin), {})
      end
    end
  end

  context 'with running pipelines' do
    let!(:pipelines)               { create_list(:ci_pipeline, 3, :running, project: project) }
    let(:destroy_pipeline_service) { double('DestroyPipelineService', execute: nil) }

    it 'bulks-fails with AbortPipelineService and then executes DestroyPipelineService for each pipelines' do
      allow(::Ci::DestroyPipelineService).to receive(:new).and_return(destroy_pipeline_service)

      expect(::Ci::AbortPipelinesService)
        .to receive_message_chain(:new, :execute)
        .with(project.all_pipelines, :project_deleted)

      pipelines.each do |pipeline|
        expect(destroy_pipeline_service).to receive(:execute).with(pipeline)
      end

      destroy_project(project, user, {})
    end
  end

  context 'when project has remote mirrors' do
    let!(:project) do
      create(:project, :repository, namespace: user.namespace).tap do |project|
        project.remote_mirrors.create!(url: 'http://test.com')
      end
    end

    it 'destroys them' do
      expect(RemoteMirror.count).to eq(1)

      destroy_project(project, user, {})

      expect(RemoteMirror.count).to eq(0)
    end
  end

  context 'when project has exports' do
    let!(:project_with_export) do
      create(:project, :repository, namespace: user.namespace).tap do |project|
        create(
          :import_export_upload,
          project: project,
          export_file: fixture_file_upload('spec/fixtures/project_export.tar.gz')
        )
      end
    end

    it 'destroys project and export' do
      expect do
        destroy_project(project_with_export, user, {})
      end.to change(ImportExportUpload, :count).by(-1)

      expect(Project.all).not_to include(project_with_export)
    end
  end

  context 'Sidekiq fake' do
    before do
      # Dont run sidekiq to check if renamed repository exists
      Sidekiq::Testing.fake! { destroy_project(project, user, {}) }
    end

    it { expect(Project.all).not_to include(project) }

    it do
      expect(project.gitlab_shell.repository_exists?(project.repository_storage, path + '.git')).to be_falsey
    end
  end

  context 'when flushing caches fail due to Git errors' do
    before do
      allow(project.repository).to receive(:before_delete).and_raise(::Gitlab::Git::CommandError)
      allow(Gitlab::GitLogger).to receive(:warn).with(
        class: Repositories::DestroyService.name,
        container_id: project.id,
        disk_path: project.disk_path,
        message: 'Gitlab::Git::CommandError').and_call_original
    end

    it_behaves_like 'deleting the project'
  end

  context 'when flushing caches fail due to Redis' do
    before do
      new_user = create(:user)
      project.team.add_member(new_user, Gitlab::Access::DEVELOPER)
      allow_any_instance_of(described_class).to receive(:flush_caches).and_raise(::Redis::CannotConnectError)
    end

    it 'keeps project team intact upon an error' do
      perform_enqueued_jobs do
        destroy_project(project, user, {})
      rescue ::Redis::CannotConnectError
      end

      expect(project.team.members.count).to eq 2
    end
  end

  context 'with async_execute', :sidekiq_inline do
    let(:async) { true }

    context 'async delete of project with private issue visibility' do
      before do
        project.project_feature.update_attribute(""issues_access_level"", ProjectFeature::PRIVATE)
      end

      it_behaves_like 'deleting the project'
    end

    it_behaves_like 'deleting the project with pipeline and build'

    context 'errors' do
      context 'when `remove_legacy_registry_tags` fails' do
        before do
          expect_any_instance_of(described_class)
            .to receive(:remove_legacy_registry_tags).and_return(false)
        end

        it_behaves_like 'handles errors thrown during async destroy', /Failed to remove some tags/
      end

      context 'when `remove_repository` fails' do
        before do
          expect_any_instance_of(described_class)
            .to receive(:remove_repository).and_return(false)
        end

        it_behaves_like 'handles errors thrown during async destroy', /Failed to remove/
      end

      context 'when `execute` raises expected error' do
        before do
          expect_any_instance_of(Project)
            .to receive(:destroy!).and_raise(StandardError.new(""Other error message""))
        end

        it_behaves_like 'handles errors thrown during async destroy', /Other error message/
      end

      context 'when `execute` raises unexpected error' do
        before do
          expect_any_instance_of(Project)
            .to receive(:destroy!).and_raise(Exception.new('Other error message'))
        end

        it 'allows error to bubble up and rolls back project deletion' do
          expect do
            destroy_project(project, user, {})
          end.to raise_error(Exception, 'Other error message')

          expect(project.reload.pending_delete).to be(false)
          expect(project.delete_error).to include(""Other error message"")
        end
      end
    end

    context 'for an archived project' do
      before do
        project.update!(archived: true)
      end

      it_behaves_like 'deleting the project with pipeline and build'
    end
  end

  describe 'container registry' do
    context 'when there are regular container repositories' do
      let(:container_repository) { create(:container_repository) }

      before do
        stub_container_registry_tags(repository: project.full_path + '/image', tags: ['tag'])
        project.container_repositories << container_repository
      end

      context 'when image repository deletion succeeds' do
        it 'returns true' do
          expect_next_instance_of(Projects::ContainerRepository::CleanupTagsService) do |instance|
            expect(instance).to receive(:execute).and_return(status: :success)
          end

          expect(destroy_project(project, user)).to be true
        end
      end

      context 'when image repository deletion raises an error' do
        it 'returns false' do
          expect_next_instance_of(Projects::ContainerRepository::CleanupTagsService) do |service|
            expect(service).to receive(:execute).and_raise(RuntimeError)
          end

          expect(destroy_project(project, user)).to be false
        end
      end

      context 'when image repository deletion fails' do
        it 'returns false' do
          expect_next_instance_of(Projects::ContainerRepository::DestroyService) do |service|
            expect(service).to receive(:execute).and_return({ status: :error })
          end

          expect(destroy_project(project, user)).to be false
        end
      end

      context 'when registry is disabled' do
        before do
          stub_container_registry_config(enabled: false)
        end

        it 'does not attempting to remove any tags' do
          expect(Projects::ContainerRepository::DestroyService).not_to receive(:new)

          destroy_project(project, user)
        end
      end
    end

    context 'when there are tags for legacy root repository' do
      before do
        stub_container_registry_tags(repository: project.full_path, tags: ['tag'])
      end

      context 'when image repository tags deletion succeeds' do
        it 'removes tags' do
          expect_next_instance_of(Projects::ContainerRepository::DestroyService) do |service|
            expect(service).to receive(:execute).and_return({ status: :sucess })
          end

          destroy_project(project, user)
        end
      end

      context 'when image repository tags deletion fails' do
        it 'raises an exception' do
          expect_next_instance_of(Projects::ContainerRepository::DestroyService) do |service|
            expect(service).to receive(:execute).and_return({ status: :error })
          end

          expect(destroy_project(project, user)).to be false
        end
      end
    end

    context 'when there are no tags for legacy root repository' do
      before do
        stub_container_registry_tags(repository: project.full_path, tags: [])
      end

      it 'does not try to destroy the repository' do
        expect(Projects::ContainerRepository::DestroyService).not_to receive(:new)

        destroy_project(project, user)
      end
    end
  end

  context 'for a forked project with LFS objects' do
    let(:forked_project) { fork_project(project, user) }

    before do
      project.lfs_objects << create(:lfs_object)
      forked_project.reload
    end

    it 'destroys the fork' do
      expect { destroy_project(forked_project, user) }
        .not_to raise_error
    end

    it 'does not update project statistics for the deleted project' do
      expect(ProjectCacheWorker).not_to receive(:perform_async)

      destroy_project(forked_project, user)
    end
  end

  context 'as the root of a fork network' do
    let!(:fork_1) { fork_project(project, user) }
    let!(:fork_2) { fork_project(project, user) }

    it 'updates the fork network with the project name' do
      fork_network = project.fork_network

      destroy_project(project, user)

      fork_network.reload

      expect(fork_network.deleted_root_project_name).to eq(project.full_name)
      expect(fork_network.root_project).to be_nil
    end
  end

  context 'with related storage move records' do
    context 'when project has active repository storage move records' do
      let!(:project_repository_storage_move) { create(:project_repository_storage_move, :scheduled, container: project) }

      it 'does not delete the project' do
        expect(destroy_project(project, user)).to be_falsey

        expect(project.delete_error).to eq ""Couldn't remove the project. A project repository storage move is in progress. Try again when it's complete.""
        expect(project.pending_delete).to be_falsey
      end
    end

    context 'when project has active snippet storage move records' do
      let(:project_snippet) { create(:project_snippet, project: project) }
      let!(:snippet_repository_storage_move) { create(:snippet_repository_storage_move, :started, container: project_snippet) }

      it 'does not delete the project' do
        expect(destroy_project(project, user)).to be_falsey

        expect(project.delete_error).to eq ""Couldn't remove the project. A related snippet repository storage move is in progress. Try again when it's complete.""
        expect(project.pending_delete).to be_falsey
      end
    end
  end

  context 'repository removal' do
    describe '.trash_project_repositories!' do
      let(:trash_project_repositories!) { described_class.new(project, user, {}).send(:trash_project_repositories!) }

      # Destroys 3 repositories:
      # 1. Project repository
      # 2. Wiki repository
      # 3. Design repository

      it 'Repositories::DestroyService is called for existing repos' do
        expect_next_instances_of(Repositories::DestroyService, 3) do |instance|
          expect(instance).to receive(:execute).and_return(status: :success)
        end

        trash_project_repositories!
      end

      context 'when the removal has errors' do
        using RSpec::Parameterized::TableSyntax

        let(:mock_error) { instance_double(Repositories::DestroyService, execute: { message: 'foo', status: :error }) }
        let(:project_repository) { project.repository }
        let(:wiki_repository) { project.wiki.repository }
        let(:design_repository) { project.design_repository }

        where(:repo, :message) do
          ref(:project_repository) | 'Failed to remove project repository. Please try again or contact administrator.'
          ref(:wiki_repository)    | 'Failed to remove wiki repository. Please try again or contact administrator.'
          ref(:design_repository)  | 'Failed to remove design repository. Please try again or contact administrator.'
        end

        with_them do
          before do
            allow(Repositories::DestroyService).to receive(:new).with(anything).and_call_original
            allow(Repositories::DestroyService).to receive(:new).with(repo).and_return(mock_error)
          end

          it 'raises correct error' do
            expect { trash_project_repositories! }.to raise_error(Projects::DestroyService::DestroyError, message)
          end
        end
      end
    end

    it 'removes project repository' do
      expect { destroy_project(project, user, {}) }.to change { project.repository.exists? }.from(true).to(false)
    end

    it 'removes wiki repository' do
      project.create_wiki unless project.wiki.repository.exists?

      expect { destroy_project(project, user, {}) }.to change { project.wiki.repository.exists? }.from(true).to(false)
    end

    it 'removes design repository' do
      project.design_repository.create_if_not_exists

      expect { destroy_project(project, user, {}) }.to change { project.design_repository.exists? }.from(true).to(false)
    end
  end

  context 'snippets' do
    let!(:snippet1) { create(:project_snippet, project: project, author: user) }
    let!(:snippet2) { create(:project_snippet, project: project, author: user) }

    it 'does not include snippets when deleting in batches' do
      expect(project).to receive(:destroy_dependent_associations_in_batches).with({ exclude: [:container_repositories, :snippets] })

      destroy_project(project, user)
    end

    it 'calls the bulk snippet destroy service with the skip_authorization param set to true' do
      expect(project.snippets.count).to eq 2

      expect_next_instance_of(Snippets::BulkDestroyService, user, project.snippets) do |instance|
        expect(instance).to receive(:execute).with(skip_authorization: true).and_call_original
      end

      expect do
        destroy_project(project, user)
      end.to change(Snippet, :count).by(-2)
    end

    context 'when an error is raised deleting snippets' do
      let(:error_message) { 'foo' }

      it 'does not delete project' do
        allow_next_instance_of(Snippets::BulkDestroyService) do |instance|
          allow(instance).to receive(:execute).and_return(ServiceResponse.error(message: error_message))
        end

        expect(Gitlab::AppLogger).to receive(:error).with(""Snippet deletion failed on #{project.full_path} with the following message: #{error_message}"")
        expect(Gitlab::AppLogger).to receive(:error).with(/Failed to remove project snippets/)
        expect(destroy_project(project, user)).to be_falsey
        expect(project.gitlab_shell.repository_exists?(project.repository_storage, path + '.git')).to be_truthy
      end
    end
  end

  context 'when project has webhooks' do
    let!(:web_hook1) { create(:project_hook, project: project) }
    let!(:web_hook2) { create(:project_hook, project: project) }
    let!(:another_project_web_hook) { create(:project_hook) }
    let!(:web_hook_log) { create(:web_hook_log, web_hook: web_hook1) }

    it 'deletes webhooks and logs related to project' do
      expect_next_instance_of(WebHooks::DestroyService, user) do |instance|
        expect(instance).to receive(:execute).with(web_hook1).and_call_original
      end
      expect_next_instance_of(WebHooks::DestroyService, user) do |instance|
        expect(instance).to receive(:execute).with(web_hook2).and_call_original
      end

      expect do
        destroy_project(project, user)
      end.to change(WebHook, :count).by(-2)
    end

    context 'when an error is raised deleting webhooks' do
      before do
        allow_next_instance_of(WebHooks::DestroyService) do |instance|
          allow(instance).to receive(:execute).and_return(message: 'foo', status: :error)
        end
      end

      it_behaves_like 'handles errors thrown during async destroy', /Failed to remove webhooks/
    end
  end

  context 'when project has project bots' do
    let!(:project_bot) { create(:user, :project_bot).tap { |user| project.add_maintainer(user) } }

    it 'deletes bot user as well' do
      expect_next_instance_of(Users::DestroyService, user) do |instance|
        expect(instance).to receive(:execute).with(project_bot, skip_authorization: true).and_call_original
      end

      destroy_project(project, user)
    end
  end

  context 'when project has events' do
    let!(:event) { create(:event, :created, project: project, target: project, author: user) }

    it 'deletes events from the project' do
      expect do
        destroy_project(project, user)
      end.to change(Event, :count).by(-1)
    end

    context 'when an error is returned while deleting events' do
      it 'does not delete project' do
        allow_next_instance_of(Events::DestroyService) do |instance|
          allow(instance).to receive(:execute).and_return(ServiceResponse.error(message: 'foo'))
        end

        expect(destroy_project(project, user)).to be_falsey
        expect(project.delete_error).to include('Failed to remove events')
      end
    end
  end

  context 'error while destroying', :sidekiq_inline do
    let!(:pipeline) { create(:ci_pipeline, project: project) }
    let!(:builds) { create_list(:ci_build, 2, :artifacts, pipeline: pipeline) }
    let!(:build_trace) { create(:ci_build_trace_chunk, build: builds[0]) }

    it 'deletes on retry' do
      # We can expect this to timeout for very large projects
      # TODO: remove allow_next_instance_of: https://gitlab.com/gitlab-org/gitlab/-/issues/220440
      allow_any_instance_of(Ci::Build).to receive(:destroy).and_raise('boom')
      destroy_project(project, user, {})

      allow_any_instance_of(Ci::Build).to receive(:destroy).and_call_original
      destroy_project(project, user, {})

      expect(Project.unscoped.all).not_to include(project)
      expect(project.gitlab_shell.repository_exists?(project.repository_storage, path + '.git')).to be_falsey
      expect(project.all_pipelines).to be_empty
      expect(project.builds).to be_empty
    end
  end

  context 'associations destoyed in batches' do
    let!(:merge_request) { create(:merge_request, source_project: project) }
    let!(:issue) { create(:issue, project: project) }
    let!(:label) { create(:label, project: project) }

    it 'destroys the associations marked as `dependent: :destroy`, in batches' do
      query_recorder = ActiveRecord::QueryRecorder.new do
        destroy_project(project, user, {})
      end

      expect(project.merge_requests).to be_empty
      expect(project.issues).to be_empty
      expect(project.labels).to be_empty

      expected_queries = [
        delete_in_batches_regexps(:merge_requests, :target_project_id, project, [merge_request]),
        delete_in_batches_regexps(:issues, :project_id, project, [issue]),
        delete_in_batches_regexps(:labels, :project_id, project, [label])
      ].flatten

      expect(query_recorder.log).to include(*expected_queries)
    end
  end

  def destroy_project(project, user, params = {})
    described_class.new(project, user, params).public_send(async ? :async_execute : :execute)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# NOTE: This service cannot be used directly because it is part of a
# a bigger process. Instead, use the service MoveAccessService which moves
# project memberships, project group links, authorizations and refreshes
# the authorizations if necessary
module Projects
  class MoveProjectGroupLinksService < BaseMoveRelationsService
    def execute(source_project, remove_remaining_elements: true)
      return unless super

      Project.transaction do
        move_group_links
        remove_remaining_project_group_links if remove_remaining_elements

        success
      end
    end

    private

    def move_group_links
      non_existent_group_links.update_all(project_id: @project.id)
    end

    # Remove remaining project group links from source_project
    def remove_remaining_project_group_links
      source_project.reset.project_group_links.destroy_all # rubocop: disable Cop/DestroyAll
    end

    def group_links_in_target_project
      @project.project_group_links.select(:group_id)
    end

    # Look for groups in source_project that are not in the target project
    # rubocop: disable CodeReuse/ActiveRecord
    def non_existent_group_links
      source_project.project_group_links
                    .where.not(group_id: group_links_in_target_project)
    end
    # rubocop: enable CodeReuse/ActiveRecord
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::MoveProjectGroupLinksService, feature_category: :groups_and_projects do
  let!(:user) { create(:user) }
  let(:project_with_groups) { create(:project, namespace: user.namespace) }
  let(:target_project) { create(:project, namespace: user.namespace) }
  let(:maintainer_group) { create(:group) }
  let(:reporter_group) { create(:group) }
  let(:developer_group) { create(:group) }

  subject { described_class.new(target_project, user) }

  describe '#execute' do
    before do
      project_with_groups.project_group_links.create!(group: maintainer_group, group_access: Gitlab::Access::MAINTAINER)
      project_with_groups.project_group_links.create!(group: developer_group, group_access: Gitlab::Access::DEVELOPER)
      project_with_groups.project_group_links.create!(group: reporter_group, group_access: Gitlab::Access::REPORTER)
    end

    it 'moves the group links from one project to another' do
      expect(project_with_groups.project_group_links.count).to eq 3
      expect(target_project.project_group_links.count).to eq 0

      subject.execute(project_with_groups)

      expect(project_with_groups.project_group_links.count).to eq 0
      expect(target_project.project_group_links.count).to eq 3
    end

    it 'does not move existent group links in the current project' do
      target_project.project_group_links.create!(group: maintainer_group, group_access: Gitlab::Access::MAINTAINER)
      target_project.project_group_links.create!(group: developer_group, group_access: Gitlab::Access::DEVELOPER)

      expect(project_with_groups.project_group_links.count).to eq 3
      expect(target_project.project_group_links.count).to eq 2

      subject.execute(project_with_groups)

      expect(project_with_groups.project_group_links.count).to eq 0
      expect(target_project.project_group_links.count).to eq 3
    end

    it 'rollbacks changes if transaction fails' do
      allow(subject).to receive(:success).and_raise(StandardError)

      expect { subject.execute(project_with_groups) }.to raise_error(StandardError)

      expect(project_with_groups.project_group_links.count).to eq 3
      expect(target_project.project_group_links.count).to eq 0
    end

    context 'when remove_remaining_elements is false' do
      let(:options) { { remove_remaining_elements: false } }

      it 'does not remove remaining project group links' do
        target_project.project_group_links.create!(group: maintainer_group, group_access: Gitlab::Access::MAINTAINER)
        target_project.project_group_links.create!(group: developer_group, group_access: Gitlab::Access::DEVELOPER)

        subject.execute(project_with_groups, **options)

        expect(project_with_groups.project_group_links.count).not_to eq 0
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class UpdateService < BaseService
    include UpdateVisibilityLevel
    include ValidatesClassificationLabel

    ValidationError = Class.new(StandardError)

    def execute
      build_topics
      remove_unallowed_params
      add_pages_unique_domain

      validate!

      ensure_wiki_exists if enabling_wiki?

      if changing_repository_storage?
        storage_move = project.repository_storage_moves.build(
          source_storage_name: project.repository_storage,
          destination_storage_name: params.delete(:repository_storage)
        )
        storage_move.schedule
      end

      yield if block_given?

      validate_classification_label(project, :external_authorization_classification_label)

      # If the block added errors, don't try to save the project
      return update_failed! if project.errors.any?

      if project.update(params.except(:default_branch))
        after_update

        success
      else
        update_failed!
      end
    rescue ValidationError => e
      error(e.message)
    end

    def run_auto_devops_pipeline?
      return false if project.repository.gitlab_ci_yml || !project.auto_devops&.previous_changes&.include?('enabled')

      project.auto_devops_enabled?
    end

    private

    def add_pages_unique_domain
      return unless params.dig(:project_setting_attributes, :pages_unique_domain_enabled)

      Gitlab::Pages.add_unique_domain_to(project)
    end

    def validate!
      unless valid_visibility_level_change?(project, project.visibility_attribute_value(params))
        raise_validation_error(s_('UpdateProject|New visibility level not allowed!'))
      end

      validate_default_branch_change
      validate_renaming_project_with_tags
    end

    def validate_default_branch_change
      return unless changing_default_branch?

      previous_default_branch = project.default_branch
      new_default_branch = params[:default_branch]

      if project.change_head(new_default_branch)
        params[:previous_default_branch] = previous_default_branch

        if !project.root_ref?(new_default_branch) && has_custom_head_branch?
          raise_validation_error(
            format(
              s_(""UpdateProject|Could not set the default branch. Do you have a branch named 'HEAD' in your repository? (%{linkStart}How do I fix this?%{linkEnd})""),
              linkStart: ambiguous_head_documentation_link, linkEnd: '</a>'
            ).html_safe
          )
        end

        after_default_branch_change(previous_default_branch)
      else
        raise_validation_error(s_(""UpdateProject|Could not set the default branch""))
      end
    end

    def validate_renaming_project_with_tags
      return unless renaming_project_with_container_registry_tags?

      unless Feature.enabled?(:renaming_project_with_tags, project) &&
          ContainerRegistry::GitlabApiClient.supports_gitlab_api?
        raise ValidationError, s_('UpdateProject|Cannot rename project because it contains container registry tags!')
      end

      dry_run = ContainerRegistry::GitlabApiClient.rename_base_repository_path(
        project.full_path, name: params[:path], dry_run: true)

      return if dry_run == :accepted

      log_error(""Dry run failed for renaming project with tags: #{project.full_path}, error: #{dry_run}"")
      raise_validation_error(
        format(
          s_(""UpdateProject|Cannot rename project, the container registry path rename validation failed: %{error}""),
          error: dry_run.to_s.titleize
        )
      )
    end

    def ambiguous_head_documentation_link
      url = Rails.application.routes.url_helpers.help_page_path('user/project/repository/branches/index', anchor: 'error-ambiguous-head-branch-exists')

      format('<a href=""%{url}"" target=""_blank"" rel=""noopener noreferrer"">', url: url)
    end

    # See issue: https://gitlab.com/gitlab-org/gitlab/-/issues/381731
    def has_custom_head_branch?
      project.repository.branch_names.any? { |name| name.casecmp('head') == 0 }
    end

    def after_default_branch_change(previous_default_branch)
      # overridden by EE module
    end

    # overridden by EE module
    def remove_unallowed_params
      params.delete(:emails_enabled) unless can?(current_user, :set_emails_disabled, project)

      params.delete(:runner_registration_enabled) if Gitlab::CurrentSettings.valid_runner_registrars.exclude?('project')
    end

    def after_update
      todos_features_changes = %w[
        issues_access_level
        merge_requests_access_level
        repository_access_level
      ]
      project_changed_feature_keys = project.project_feature.previous_changes.keys

      if project.visibility_level_previous_changes && project.private?
        # don't enqueue immediately to prevent todos removal in case of a mistake
        TodosDestroyer::ConfidentialIssueWorker.perform_in(Todo::WAIT_FOR_DELETE, nil, project.id)
        TodosDestroyer::ProjectPrivateWorker.perform_in(Todo::WAIT_FOR_DELETE, project.id)
      elsif (project_changed_feature_keys & todos_features_changes).present?
        TodosDestroyer::PrivateFeaturesWorker.perform_in(Todo::WAIT_FOR_DELETE, project.id)
      end

      if project.previous_changes.include?('path')
        after_rename_service(project).execute
      else
        system_hook_service.execute_hooks_for(project, :update)
      end

      update_pending_builds if runners_settings_toggled?

      publish_events
    end

    def after_rename_service(project)
      AfterRenameService.new(project, path_before: project.path_before_last_save, full_path_before: project.full_path_before_last_save)
    end

    def raise_validation_error(message)
      raise ValidationError, message
    end

    def update_failed!
      model_errors = project.errors.full_messages.to_sentence
      error_message = model_errors.presence || s_('UpdateProject|Project could not be updated!')

      error(error_message)
    end

    def renaming_project_with_container_registry_tags?
      new_path = params[:path]

      new_path && new_path != project.path &&
        project.has_container_registry_tags?
    end

    def changing_default_branch?
      new_branch = params[:default_branch]

      new_branch && project.repository.exists? &&
        new_branch != project.default_branch
    end

    def enabling_wiki?
      return false if project.wiki_enabled?

      params.dig(:project_feature_attributes, :wiki_access_level).to_i > ProjectFeature::DISABLED
    end

    def ensure_wiki_exists
      return if project.create_wiki

      log_error(""Could not create wiki for #{project.full_name}"")
      Gitlab::Metrics.counter(:wiki_can_not_be_created_total, 'Counts the times we failed to create a wiki').increment
    end

    def changing_repository_storage?
      new_repository_storage = params[:repository_storage]

      new_repository_storage && project.repository.exists? &&
        project.repository_storage != new_repository_storage &&
        can?(current_user, :change_repository_storage, project)
    end

    def build_topics
      topics = params.delete(:topics)
      tag_list = params.delete(:tag_list)
      topic_list = topics || tag_list

      params[:topic_list] ||= topic_list if topic_list
    end

    def update_pending_builds
      update_params = {
        instance_runners_enabled: project.shared_runners_enabled?,
        namespace_traversal_ids: group_runner_traversal_ids
      }

      ::Ci::UpdatePendingBuildService
        .new(project, update_params)
        .execute
    end

    def shared_runners_settings_toggled?
      project.previous_changes.include?(:shared_runners_enabled)
    end

    def group_runners_settings_toggled?
      return false unless project.ci_cd_settings.present?

      project.ci_cd_settings.previous_changes.include?(:group_runners_enabled)
    end

    def runners_settings_toggled?
      shared_runners_settings_toggled? || group_runners_settings_toggled?
    end

    def group_runner_traversal_ids
      if project.group_runners_enabled?
        project.namespace.traversal_ids
      else
        []
      end
    end

    def publish_events
      publish_project_archived_event
      publish_project_attributed_changed_event
      publish_project_features_changed_event
    end

    def publish_project_archived_event
      return unless project.archived_previously_changed?

      event = Projects::ProjectArchivedEvent.new(data: {
        project_id: @project.id,
        namespace_id: @project.namespace_id,
        root_namespace_id: @project.root_namespace.id
      })

      Gitlab::EventStore.publish(event)
    end

    def publish_project_attributed_changed_event
      changes = @project.previous_changes

      return if changes.blank?

      event = Projects::ProjectAttributesChangedEvent.new(data: {
        project_id: @project.id,
        namespace_id: @project.namespace_id,
        root_namespace_id: @project.root_namespace.id,
        attributes: changes.keys
      })

      Gitlab::EventStore.publish(event)
    end

    def publish_project_features_changed_event
      changes = @project.project_feature.previous_changes

      return if changes.blank?

      event = Projects::ProjectFeaturesChangedEvent.new(data: {
        project_id: @project.id,
        namespace_id: @project.namespace_id,
        root_namespace_id: @project.root_namespace.id,
        features: changes.keys
      })

      Gitlab::EventStore.publish(event)
    end
  end
end

Projects::UpdateService.prepend_mod_with('Projects::UpdateService')

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Projects::UpdateService, feature_category: :groups_and_projects do
  include ExternalAuthorizationServiceHelpers
  include ProjectForksHelper

  let(:user) { create(:user) }
  let(:project) do
    create(:project, creator: user, namespace: user.namespace)
  end

  shared_examples 'publishing Projects::ProjectAttributesChangedEvent' do |params:, attributes:|
    it ""publishes Projects::ProjectAttributesChangedEvent"" do
      expect { update_project(project, user, params) }
        .to publish_event(Projects::ProjectAttributesChangedEvent)
        .with(
          project_id: project.id,
          namespace_id: project.namespace_id,
          root_namespace_id: project.root_namespace.id,
          attributes: attributes
        )
    end
  end

  describe '#execute' do
    let(:admin) { create(:admin) }

    context 'when changing visibility level' do
      it_behaves_like 'publishing Projects::ProjectAttributesChangedEvent',
        params: { visibility_level: Gitlab::VisibilityLevel::INTERNAL },
        attributes: %w[updated_at visibility_level]

      context 'when visibility_level changes to INTERNAL' do
        it 'updates the project to internal' do
          expect(TodosDestroyer::ProjectPrivateWorker).not_to receive(:perform_in)

          result = update_project(project, user, visibility_level: Gitlab::VisibilityLevel::INTERNAL)

          expect(result).to eq({ status: :success })
          expect(project).to be_internal
        end
      end

      context 'when visibility_level changes to PUBLIC' do
        it 'updates the project to public' do
          expect(TodosDestroyer::ProjectPrivateWorker).not_to receive(:perform_in)

          result = update_project(project, user, visibility_level: Gitlab::VisibilityLevel::PUBLIC)

          expect(result).to eq({ status: :success })
          expect(project).to be_public
        end

        context 'and project is PRIVATE' do
          it 'does not unlink project from fork network' do
            expect(Projects::UnlinkForkService).not_to receive(:new)

            update_project(project, user, visibility_level: Gitlab::VisibilityLevel::PUBLIC)
          end
        end
      end

      context 'when visibility_level changes to PRIVATE' do
        before do
          project.update!(visibility_level: Gitlab::VisibilityLevel::PUBLIC)
        end

        it 'updates the project to private' do
          expect(TodosDestroyer::ProjectPrivateWorker).to receive(:perform_in).with(Todo::WAIT_FOR_DELETE, project.id)
          expect(TodosDestroyer::ConfidentialIssueWorker).to receive(:perform_in).with(Todo::WAIT_FOR_DELETE, nil, project.id)

          result = update_project(project, user, visibility_level: Gitlab::VisibilityLevel::PRIVATE)

          expect(result).to eq({ status: :success })
          expect(project).to be_private
        end
      end

      context 'when visibility levels are restricted to PUBLIC only' do
        before do
          stub_application_setting(restricted_visibility_levels: [Gitlab::VisibilityLevel::PUBLIC])
        end

        context 'when visibility_level is INTERNAL' do
          it 'updates the project to internal' do
            result = update_project(project, user, visibility_level: Gitlab::VisibilityLevel::INTERNAL)

            expect(result).to eq({ status: :success })
            expect(project).to be_internal
          end
        end

        context 'when visibility_level is PUBLIC' do
          it 'does not update the project to public' do
            result = update_project(project, user, visibility_level: Gitlab::VisibilityLevel::PUBLIC)

            expect(result).to eq({ status: :error, message: 'New visibility level not allowed!' })
            expect(project).to be_private
          end

          context 'when updated by an admin' do
            context 'when admin mode is enabled', :enable_admin_mode do
              it 'updates the project to public' do
                result = update_project(project, admin, visibility_level: Gitlab::VisibilityLevel::PUBLIC)

                expect(result).to eq({ status: :success })
                expect(project).to be_public
              end
            end

            context 'when admin mode is disabled' do
              it 'does not update the project to public' do
                result = update_project(project, admin, visibility_level: Gitlab::VisibilityLevel::PUBLIC)

                expect(result).to eq({ status: :error, message: 'New visibility level not allowed!' })
                expect(project).to be_private
              end
            end
          end
        end
      end

      context 'when project visibility is higher than parent group' do
        let(:group) { create(:group, visibility_level: Gitlab::VisibilityLevel::INTERNAL) }

        before do
          project.update!(namespace: group, visibility_level: group.visibility_level)
        end

        it 'does not update project visibility level even if admin', :enable_admin_mode do
          result = update_project(project, admin, visibility_level: Gitlab::VisibilityLevel::PUBLIC)

          expect(result).to eq({ status: :error, message: 'Visibility level public is not allowed in a internal group.' })
          expect(project.reload).to be_internal
        end
      end

      context 'when user is not project owner' do
        let_it_be(:maintainer) { create(:user) }

        before do
          project.add_maintainer(maintainer)
        end

        context 'when project is private' do
          it 'does not update the project to public' do
            result = update_project(project, maintainer, visibility_level: Gitlab::VisibilityLevel::PUBLIC)

            expect(result).to eq({ status: :error, message: 'New visibility level not allowed!' })
            expect(project).to be_private
          end

          it 'does not update the project to public with tricky value' do
            result = update_project(project, maintainer, visibility_level: Gitlab::VisibilityLevel::PUBLIC.to_s + 'r')

            expect(result).to eq({ status: :error, message: 'New visibility level not allowed!' })
            expect(project).to be_private
          end
        end

        context 'when project is public' do
          before do
            project.update!(visibility_level: Gitlab::VisibilityLevel::PUBLIC)
          end

          it 'does not update the project to private' do
            result = update_project(project, maintainer, visibility_level: Gitlab::VisibilityLevel::PRIVATE)

            expect(result).to eq({ status: :error, message: 'New visibility level not allowed!' })
            expect(project).to be_public
          end

          it 'does not update the project to private with invalid string value' do
            result = update_project(project, maintainer, visibility_level: 'invalid')

            expect(result).to eq({ status: :error, message: 'New visibility level not allowed!' })
            expect(project).to be_public
          end

          it 'does not update the project to private with valid string value' do
            result = update_project(project, maintainer, visibility_level: 'private')

            expect(result).to eq({ status: :error, message: 'New visibility level not allowed!' })
            expect(project).to be_public
          end

          # See https://gitlab.com/gitlab-org/gitlab/-/issues/359910
          it 'does not update the project to private because of Active Record typecasting' do
            result = update_project(project, maintainer, visibility_level: 'public')

            expect(result).to eq({ status: :success })
            expect(project).to be_public
          end
        end
      end

      context 'when updating shared runners' do
        context 'can enable shared runners' do
          let(:group) { create(:group, shared_runners_enabled: true) }
          let(:project) { create(:project, namespace: group, shared_runners_enabled: false) }

          it 'enables shared runners' do
            result = update_project(project, user, shared_runners_enabled: true)

            expect(result).to eq({ status: :success })
            expect(project.reload.shared_runners_enabled).to be_truthy
          end
        end

        context 'cannot enable shared runners' do
          let(:group) { create(:group, :shared_runners_disabled) }
          let(:project) { create(:project, namespace: group, shared_runners_enabled: false) }

          it 'does not enable shared runners' do
            result = update_project(project, user, shared_runners_enabled: true)

            expect(result).to eq({ status: :error, message: 'Shared runners enabled cannot be enabled because parent group does not allow it' })
            expect(project.reload.shared_runners_enabled).to be_falsey
          end
        end
      end
    end

    describe 'when updating project that has forks' do
      let(:project) { create(:project, :internal) }
      let(:user) { project.first_owner }
      let(:forked_project) { fork_project(project) }

      it 'does not change visibility of forks' do
        opts = { visibility_level: Gitlab::VisibilityLevel::PRIVATE }

        expect(project).to be_internal
        expect(forked_project).to be_internal

        expect(update_project(project, user, opts)).to eq({ status: :success })

        expect(project).to be_private
        expect(forked_project.reload).to be_internal
      end
    end

    context 'when updating a default branch' do
      let(:project) { create(:project, :repository) }

      it 'changes default branch, tracking the previous branch' do
        previous_default_branch = project.default_branch

        update_project(project, admin, default_branch: 'feature')

        project.reload

        expect(project.default_branch).to eq('feature')
        expect(project.previous_default_branch).to eq(previous_default_branch)

        update_project(project, admin, default_branch: previous_default_branch)

        project.reload

        expect(project.default_branch).to eq(previous_default_branch)
        expect(project.previous_default_branch).to eq('feature')
      end

      it 'does not change a default branch' do
        # The branch 'unexisted-branch' does not exist.
        update_project(project, admin, default_branch: 'unexisted-branch')

        project.reload

        expect(project.default_branch).to eq 'master'
        expect(project.previous_default_branch).to be_nil
      end

      context 'when repository has an ambiguous branch named ""HEAD""' do
        before do
          allow(project.repository.raw).to receive(:write_ref).and_return(false)
          allow(project.repository).to receive(:branch_names) { %w[fix master main HEAD] }
        end

        it 'returns an error to the user' do
          result = update_project(project, admin, default_branch: 'fix')

          expect(result).to include(status: :error)
          expect(result[:message]).to include(""Could not set the default branch. Do you have a branch named 'HEAD' in your repository?"")

          project.reload

          expect(project.default_branch).to eq 'master'
          expect(project.previous_default_branch).to be_nil
        end
      end
    end

    context 'when we update project but not enabling a wiki' do
      it 'does not try to create an empty wiki' do
        project.wiki.repository.raw.remove

        result = update_project(project, user, { name: 'test1' })

        expect(result).to eq({ status: :success })
        expect(project.wiki_repository_exists?).to be false
      end

      it 'handles empty project feature attributes' do
        project.project_feature.update!(wiki_access_level: ProjectFeature::DISABLED)

        result = update_project(project, user, { name: 'test1' })

        expect(result).to eq({ status: :success })
        expect(project.wiki_repository_exists?).to be false
      end
    end

    context 'when enabling a wiki' do
      it 'creates a wiki' do
        project.project_feature.update!(wiki_access_level: ProjectFeature::DISABLED)
        project.wiki.repository.raw.remove

        result = update_project(project, user, project_feature_attributes: { wiki_access_level: ProjectFeature::ENABLED })

        expect(result).to eq({ status: :success })
        expect(project.wiki_repository_exists?).to be true
        expect(project.wiki_enabled?).to be true
      end

      it 'logs an error and creates a metric when wiki can not be created' do
        project.project_feature.update!(wiki_access_level: ProjectFeature::DISABLED)

        expect_next_instance_of(ProjectWiki) do |project_wiki|
          expect(project_wiki).to receive(:create_wiki_repository).and_raise(Wiki::CouldNotCreateWikiError)
        end
        expect_any_instance_of(described_class).to receive(:log_error).with(""Could not create wiki for #{project.full_name}"")

        counter = double(:counter)
        expect(Gitlab::Metrics).to receive(:counter).with(:wiki_can_not_be_created_total, 'Counts the times we failed to create a wiki').and_return(counter)
        expect(counter).to receive(:increment)

        update_project(project, user, project_feature_attributes: { wiki_access_level: ProjectFeature::ENABLED })
      end
    end

    context 'when changing feature visibility to private' do
      it 'updates the visibility correctly' do
        expect(TodosDestroyer::PrivateFeaturesWorker)
          .to receive(:perform_in).with(Todo::WAIT_FOR_DELETE, project.id)

        result = update_project(project, user, project_feature_attributes:
                                 { issues_access_level: ProjectFeature::PRIVATE }
        )

        expect(result).to eq({ status: :success })
        expect(project.project_feature.issues_access_level).to be(ProjectFeature::PRIVATE)
      end
    end

    context 'when changes project features' do
      # Using some sample features for testing.
      # Not using all the features because some of them must be enabled/disabled together
      %w[issues wiki forking model_experiments].each do |feature_name|
        context ""with feature_name:#{feature_name}"" do
          let(:feature) { ""#{feature_name}_access_level"" }
          let(:params) do
            { project_feature_attributes: { feature => ProjectFeature::ENABLED } }
          end

          before do
            project.project_feature.update!(feature => ProjectFeature::DISABLED)
          end

          it 'publishes Projects::ProjectFeaturesChangedEvent' do
            expect { update_project(project, user, params) }
              .to publish_event(Projects::ProjectFeaturesChangedEvent)
              .with(
                project_id: project.id,
                namespace_id: project.namespace_id,
                root_namespace_id: project.root_namespace.id,
                features: array_including(feature, ""updated_at"")
              )
          end
        end
      end
    end

    context 'when archiving a project' do
      it_behaves_like 'publishing Projects::ProjectAttributesChangedEvent',
        params: { archived: true },
        attributes: %w[updated_at archived]

      it 'publishes a ProjectTransferedEvent' do
        expect { update_project(project, user, archived: true) }
          .to publish_event(Projects::ProjectArchivedEvent)
          .with(
            project_id: project.id,
            namespace_id: project.namespace_id,
            root_namespace_id: project.root_namespace.id
          )
      end
    end

    context 'when changing operations feature visibility' do
      let(:feature_params) { { operations_access_level: ProjectFeature::DISABLED } }

      it 'does not sync the changes to the related fields' do
        result = update_project(project, user, project_feature_attributes: feature_params)

        expect(result).to eq({ status: :success })
        feature = project.project_feature

        expect(feature.operations_access_level).to eq(ProjectFeature::DISABLED)
        expect(feature.monitor_access_level).not_to eq(ProjectFeature::DISABLED)
        expect(feature.infrastructure_access_level).not_to eq(ProjectFeature::DISABLED)
        expect(feature.feature_flags_access_level).not_to eq(ProjectFeature::DISABLED)
        expect(feature.environments_access_level).not_to eq(ProjectFeature::DISABLED)
      end
    end

    context 'when updating a project that contains container images' do
      let(:new_name) { 'renamed' }

      before do
        stub_container_registry_config(enabled: true)
        stub_container_registry_tags(repository: /image/, tags: %w[rc1])
        create(:container_repository, project: project, name: :image)
      end

      shared_examples 'renaming the project fails with message' do |error_message|
        it 'does not allow to rename the project' do
          result = update_project(project, admin, path: new_name)

          expect(result).to include(status: :error)
          expect(result[:message]).to match(error_message)
        end
      end

      context 'when feature renaming_project_with_tags is disabled' do
        before do
          stub_feature_flags(renaming_project_with_tags: false)
        end

        it_behaves_like 'renaming the project fails with message', /contains container registry tags/
      end

      context ""when the GitlabAPI is not supported"" do
        before do
          allow(ContainerRegistry::GitlabApiClient).to receive(:supports_gitlab_api?).and_return(false)
        end

        it_behaves_like 'renaming the project fails with message', /contains container registry tags/
      end

      context 'when Gitlab API is supported' do
        before do
          allow(ContainerRegistry::GitlabApiClient).to receive(:supports_gitlab_api?).and_return(true)
        end

        it 'executes a dry run of the project rename' do
          stub_rename_base_repository_in_registry(dry_run: true)

          update_project(project, admin, path: new_name)

          expect_rename_of_base_repository_in_registry(dry_run: true)
        end

        context 'when the dry run fails' do
          before do
            stub_rename_base_repository_in_registry(dry_run: true, result: :bad_request)
          end

          it_behaves_like 'renaming the project fails with message', /container registry path rename validation failed/

          it 'logs the error' do
            expect_any_instance_of(described_class).to receive(:log_error).with(""Dry run failed for renaming project with tags: #{project.full_path}, error: bad_request"")

            update_project(project, admin, path: new_name)
          end
        end

        context 'when the dry run succeeds' do
          before do
            stub_rename_base_repository_in_registry(dry_run: true, result: :accepted)
          end

          it 'continues with the project rename' do
            stub_rename_base_repository_in_registry(dry_run: false, result: :ok)
            old_project_full_path = project.full_path

            update_project(project, admin, path: new_name)

            expect_rename_of_base_repository_in_registry(dry_run: true, path: old_project_full_path)
            expect_rename_of_base_repository_in_registry(dry_run: false, path: old_project_full_path)
          end
        end

        def stub_rename_base_repository_in_registry(dry_run:, result: nil)
          options = { name: new_name }
          options[:dry_run] = true if dry_run

          allow(ContainerRegistry::GitlabApiClient)
            .to receive(:rename_base_repository_path)
            .with(project.full_path, options)
            .and_return(result)
        end

        def expect_rename_of_base_repository_in_registry(dry_run:, path: nil)
          options = { name: new_name }
          options[:dry_run] = true if dry_run

          expect(ContainerRegistry::GitlabApiClient)
            .to have_received(:rename_base_repository_path)
            .with(path || project.full_path, options)
        end
      end

      it 'allows to update other settings' do
        result = update_project(project, admin, public_builds: true)

        expect(result[:status]).to eq :success
        expect(project.reload.public_builds).to be true
      end
    end

    context 'when renaming a project' do
      let(:raw_fake_repo) { Gitlab::Git::Repository.new('default', File.join(user.namespace.full_path, 'existing.git'), nil, nil) }

      context 'with legacy storage' do
        let(:project) { create(:project, :legacy_storage, :repository, creator: user, namespace: user.namespace) }

        before do
          raw_fake_repo.create_repository
        end

        after do
          raw_fake_repo.remove
        end

        it 'does not allow renaming when new path matches existing repository on disk' do
          result = update_project(project, admin, path: 'existing')

          expect(result).to include(status: :error)
          expect(result[:message]).to match('There is already a repository with that name on disk')
          expect(project).not_to be_valid
          expect(project.errors.messages).to have_key(:base)
          expect(project.errors.messages[:base]).to include('There is already a repository with that name on disk')
        end

        context 'when hashed storage is enabled' do
          before do
            stub_application_setting(hashed_storage_enabled: true)
          end

          it 'migrates project to a hashed storage instead of renaming the repo to another legacy name' do
            result = update_project(project, admin, path: 'new-path')

            expect(result).not_to include(status: :error)
            expect(project).to be_valid
            expect(project.errors).to be_empty
            expect(project.reload.hashed_storage?(:repository)).to be_truthy
          end
        end
      end

      context 'with hashed storage' do
        let(:project) { create(:project, :repository, creator: user, namespace: user.namespace) }

        before do
          stub_application_setting(hashed_storage_enabled: true)
        end

        it 'does not check if new path matches existing repository on disk' do
          expect(project).not_to receive(:repository_with_same_path_already_exists?)

          result = update_project(project, admin, path: 'existing')

          expect(result).to include(status: :success)
        end
      end
    end

    context 'when passing invalid parameters' do
      it 'returns an error result when record cannot be updated' do
        result = update_project(project, admin, { name: 'foo&bar' })

        expect(result).to eq({
          status: :error,
          message: ""Name can contain only letters, digits, emoji, '_', '.', '+', dashes, or spaces. It must start with a letter, digit, emoji, or '_'.""
        })
      end
    end

    context 'when updating #emails_enabled' do
      it 'updates the attribute for the project owner' do
        expect { update_project(project, user, emails_enabled: false) }
          .to change { project.emails_enabled }
          .to(false)
      end

      it 'does not update when not project owner' do
        maintainer = create(:user)
        project.add_member(maintainer, :maintainer)

        expect { update_project(project, maintainer, emails_enabled: false) }
          .not_to change { project.emails_enabled }
      end
    end

    context 'when updating #runner_registration_enabled' do
      it 'updates the attribute' do
        expect { update_project(project, user, runner_registration_enabled: false) }
          .to change { project.runner_registration_enabled }
          .to(false)
      end

      context 'when runner registration is disabled for all projects' do
        before do
          stub_application_setting(valid_runner_registrars: [])
        end

        it 'restricts updating the attribute' do
          expect { update_project(project, user, runner_registration_enabled: false) }
            .not_to change { project.runner_registration_enabled }
        end
      end
    end

    context 'when updating runners settings' do
      let(:settings) do
        { instance_runners_enabled: true, namespace_traversal_ids: [123] }
      end

      let!(:pending_build) do
        create(:ci_pending_build, project: project, **settings)
      end

      context 'when project has shared runners enabled' do
        let(:project) { create(:project, shared_runners_enabled: true) }

        it 'updates builds queue when shared runners get disabled' do
          expect { update_project(project, admin, shared_runners_enabled: false) }
            .to change { pending_build.reload.instance_runners_enabled }.to(false)

          expect(pending_build.reload.instance_runners_enabled).to be false
        end
      end

      context 'when project has shared runners disabled' do
        let(:project) { create(:project, shared_runners_enabled: false) }

        it 'updates builds queue when shared runners get enabled' do
          expect { update_project(project, admin, shared_runners_enabled: true) }
            .to not_change { pending_build.reload.instance_runners_enabled }

          expect(pending_build.reload.instance_runners_enabled).to be true
        end
      end

      context 'when project has group runners enabled' do
        let(:project) { create(:project, group_runners_enabled: true) }

        before do
          project.ci_cd_settings.update!(group_runners_enabled: true)
        end

        it 'updates builds queue when group runners get disabled' do
          update_project(project, admin, group_runners_enabled: false)

          expect(pending_build.reload.namespace_traversal_ids).to be_empty
        end
      end

      context 'when project has group runners disabled' do
        let(:project) { create(:project, :in_subgroup, group_runners_enabled: false) }

        before do
          project.reload.ci_cd_settings.update!(group_runners_enabled: false)
        end

        it 'updates builds queue when group runners get enabled' do
          update_project(project, admin, group_runners_enabled: true)

          expect(pending_build.reload.namespace_traversal_ids).to include(project.namespace.id)
        end
      end
    end

    context 'with external authorization enabled' do
      before do
        enable_external_authorization_service_check

        allow(::Gitlab::ExternalAuthorization)
          .to receive(:access_allowed?).with(user, 'default_label', project.full_path).and_call_original
      end

      it 'does not save the project with an error if the service denies access' do
        expect(::Gitlab::ExternalAuthorization)
          .to receive(:access_allowed?).with(user, 'new-label') { false }

        result = update_project(project, user, { external_authorization_classification_label: 'new-label' })

        expect(result[:message]).to be_present
        expect(result[:status]).to eq(:error)
      end

      it 'saves the new label if the service allows access' do
        expect(::Gitlab::ExternalAuthorization)
          .to receive(:access_allowed?).with(user, 'new-label') { true }

        result = update_project(project, user, { external_authorization_classification_label: 'new-label' })

        expect(result[:status]).to eq(:success)
        expect(project.reload.external_authorization_classification_label).to eq('new-label')
      end

      it 'checks the default label when the classification label was cleared' do
        expect(::Gitlab::ExternalAuthorization)
          .to receive(:access_allowed?).with(user, 'default_label') { true }

        update_project(project, user, { external_authorization_classification_label: '' })
      end

      it 'does not check the label when it does not change' do
        expect(::Gitlab::ExternalAuthorization).to receive(:access_allowed?).once

        update_project(project, user, { name: 'New name' })
      end
    end

    context 'when updating nested attributes for prometheus integration' do
      context 'prometheus integration exists' do
        let(:prometheus_integration_attributes) do
          attributes_for(
            :prometheus_integration,
            project: project,
            properties: { api_url: ""http://new.prometheus.com"", manual_configuration: ""0"" }
          )
        end

        let!(:prometheus_integration) do
          create(
            :prometheus_integration,
            project: project,
            properties: { api_url: ""http://old.prometheus.com"", manual_configuration: ""0"" }
          )
        end

        it 'updates existing record' do
          expect { update_project(project, user, prometheus_integration_attributes: prometheus_integration_attributes) }
            .to change { prometheus_integration.reload.api_url }
            .from(""http://old.prometheus.com"")
            .to(""http://new.prometheus.com"")
        end
      end

      context 'prometheus integration does not exist' do
        context 'valid parameters' do
          let(:prometheus_integration_attributes) do
            attributes_for(
              :prometheus_integration,
              project: project,
              properties: { api_url: ""http://example.prometheus.com"", manual_configuration: ""0"" }
            )
          end

          it 'creates new record' do
            expect { update_project(project, user, prometheus_integration_attributes: prometheus_integration_attributes) }
              .to change { ::Integrations::Prometheus.where(project: project).count }
              .from(0)
              .to(1)
          end
        end

        context 'invalid parameters' do
          let(:prometheus_integration_attributes) do
            attributes_for(
              :prometheus_integration,
              project: project,
              properties: { api_url: 'invalid-url', manual_configuration: ""1"" }
            )
          end

          it 'does not create new record' do
            expect { update_project(project, user, prometheus_integration_attributes: prometheus_integration_attributes) }
              .not_to change { ::Integrations::Prometheus.where(project: project).count }
          end
        end
      end
    end

    describe 'when changing repository_storage' do
      let(:repository_read_only) { false }
      let(:project) { create(:project, :repository, repository_read_only: repository_read_only) }
      let(:opts) { { repository_storage: 'test_second_storage' } }

      before do
        stub_storage_settings('test_second_storage' => {})
      end

      shared_examples 'the transfer was not scheduled' do
        it 'does not schedule the transfer' do
          expect do
            update_project(project, user, opts)
          end.not_to change(project.repository_storage_moves, :count)
        end
      end

      context 'authenticated as admin' do
        let(:user) { create(:admin) }

        context 'when admin mode is enabled', :enable_admin_mode do
          it 'schedules the transfer of the repository to the new storage and locks the project' do
            update_project(project, admin, opts)

            expect(project).to be_repository_read_only
            expect(project.repository_storage_moves.last).to have_attributes(
              state: ::Projects::RepositoryStorageMove.state_machines[:state].states[:scheduled].value,
              source_storage_name: 'default',
              destination_storage_name: 'test_second_storage'
            )
          end
        end

        context 'when admin mode is disabled' do
          it_behaves_like 'the transfer was not scheduled'
        end

        context 'the repository is read-only' do
          let(:repository_read_only) { true }

          it_behaves_like 'the transfer was not scheduled'
        end

        context 'the storage has not changed' do
          let(:opts) { { repository_storage: 'default' } }

          it_behaves_like 'the transfer was not scheduled'
        end

        context 'the storage does not exist' do
          let(:opts) { { repository_storage: 'nonexistent' } }

          it_behaves_like 'the transfer was not scheduled'
        end
      end

      context 'authenticated as user' do
        let(:user) { create(:user) }

        it_behaves_like 'the transfer was not scheduled'
      end
    end

    describe 'when updating topics' do
      let(:project) { create(:project, topic_list: 'topic1, topic2') }

      it 'update using topics' do
        result = update_project(project, user, { topics: 'topics' })

        expect(result[:status]).to eq(:success)
        expect(project.topic_list).to eq(%w[topics])
      end

      it 'update using topic_list' do
        result = update_project(project, user, { topic_list: 'topic_list' })

        expect(result[:status]).to eq(:success)
        expect(project.topic_list).to eq(%w[topic_list])
      end

      it 'update using tag_list (deprecated)' do
        result = update_project(project, user, { tag_list: 'tag_list' })

        expect(result[:status]).to eq(:success)
        expect(project.topic_list).to eq(%w[tag_list])
      end
    end

    describe 'when updating pages unique domain', feature_category: :pages do
      before do
        stub_pages_setting(enabled: true)
      end

      context 'when turning it on' do
        it 'adds pages unique domain' do
          expect(Gitlab::Pages).to receive(:add_unique_domain_to)

          expect { update_project(project, user, project_setting_attributes: { pages_unique_domain_enabled: true }) }
            .to change { project.project_setting.pages_unique_domain_enabled }
            .from(false).to(true)
        end
      end

      context 'when turning it off' do
        it 'adds pages unique domain' do
          expect(Gitlab::Pages).not_to receive(:add_unique_domain_to)

          expect { update_project(project, user, project_setting_attributes: { pages_unique_domain_enabled: false }) }
            .not_to change { project.project_setting.pages_unique_domain_enabled }
        end
      end
    end
  end

  describe '#run_auto_devops_pipeline?' do
    subject { described_class.new(project, user).run_auto_devops_pipeline? }

    context 'when master contains a .gitlab-ci.yml file' do
      before do
        allow(project.repository).to receive(:gitlab_ci_yml).and_return(""script: ['test']"")
      end

      it { is_expected.to eq(false) }
    end

    context 'when auto devops is nil' do
      it { is_expected.to eq(false) }
    end

    context 'when auto devops is explicitly enabled' do
      before do
        project.create_auto_devops!(enabled: true)
      end

      it { is_expected.to eq(true) }
    end

    context 'when auto devops is explicitly disabled' do
      before do
        project.create_auto_devops!(enabled: false)
      end

      it { is_expected.to eq(false) }
    end

    context 'when auto devops is set to instance setting' do
      before do
        project.create_auto_devops!(enabled: nil)
        project.reload

        allow(project.auto_devops).to receive(:previous_changes).and_return('enabled' => true)
      end

      context 'when auto devops is enabled system-wide' do
        before do
          stub_application_setting(auto_devops_enabled: true)
        end

        it { is_expected.to eq(true) }
      end

      context 'when auto devops is disabled system-wide' do
        before do
          stub_application_setting(auto_devops_enabled: false)
        end

        it { is_expected.to eq(false) }
      end
    end
  end

  def update_project(project, user, opts)
    described_class.new(project, user, opts).execute
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class EnableDeployKeyService < BaseService
    def execute
      key_id = params[:key_id] || params[:id]
      key = find_accessible_key(key_id)

      return unless key

      unless project.deploy_keys.include?(key)
        project.deploy_keys << key
      end

      key
    end

    private

    def find_accessible_key(key_id)
      if current_user.admin?
        DeployKey.find_by_id(key_id)
      else
        current_user.accessible_deploy_keys.find_by_id(key_id)
      end
    end
  end
end

Projects::EnableDeployKeyService.prepend_mod_with('Projects::EnableDeployKeyService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::EnableDeployKeyService, feature_category: :continuous_delivery do
  let(:deploy_key)  { create(:deploy_key, public: true) }
  let(:project)     { create(:project) }
  let(:user)        { project.creator }
  let!(:params)     { { key_id: deploy_key.id } }

  it 'enables the key' do
    expect do
      service.execute
    end.to change { project.deploy_keys.count }.from(0).to(1)
  end

  context 'trying to add an unaccessable key' do
    let(:another_key) { create(:another_key) }
    let!(:params)     { { key_id: another_key.id } }

    it 'returns nil if the key cannot be added' do
      expect(service.execute).to be nil
    end
  end

  context 'add the same key twice' do
    before do
      project.deploy_keys << deploy_key
    end

    it 'returns existing key' do
      expect(service.execute).to eq(deploy_key)
    end
  end

  def service
    Projects::EnableDeployKeyService.new(project, user, params)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class MoveLfsObjectsProjectsService < BaseMoveRelationsService
    def execute(source_project, remove_remaining_elements: true)
      return unless super

      Project.transaction do
        move_lfs_objects_projects
        remove_remaining_lfs_objects_project if remove_remaining_elements

        success
      end
    end

    private

    def move_lfs_objects_projects
      non_existent_lfs_objects_projects.update_all(project_id: @project.id)
    end

    def remove_remaining_lfs_objects_project
      source_project.lfs_objects_projects.destroy_all # rubocop: disable Cop/DestroyAll
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def non_existent_lfs_objects_projects
      source_project.lfs_objects_projects.where.not(lfs_object: @project.lfs_objects)
    end
    # rubocop: enable CodeReuse/ActiveRecord
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::MoveLfsObjectsProjectsService, feature_category: :source_code_management do
  let!(:user) { create(:user) }
  let!(:project_with_lfs_objects) { create(:project, namespace: user.namespace) }
  let!(:target_project) { create(:project, namespace: user.namespace) }

  subject { described_class.new(target_project, user) }

  before do
    create_list(:lfs_objects_project, 3, project: project_with_lfs_objects)
  end

  describe '#execute' do
    it 'links the lfs objects from existent in source project' do
      expect(target_project.lfs_objects.count).to eq 0

      subject.execute(project_with_lfs_objects)

      expect(project_with_lfs_objects.reload.lfs_objects.count).to eq 0
      expect(target_project.reload.lfs_objects.count).to eq 3
    end

    it 'does not link existent lfs_object in the current project' do
      target_project.lfs_objects << project_with_lfs_objects.lfs_objects.first(2)

      expect(target_project.lfs_objects.count).to eq 2

      subject.execute(project_with_lfs_objects)

      expect(target_project.lfs_objects.count).to eq 3
    end

    it 'rollbacks changes if transaction fails' do
      allow(subject).to receive(:success).and_raise(StandardError)

      expect { subject.execute(project_with_lfs_objects) }.to raise_error(StandardError)

      expect(project_with_lfs_objects.lfs_objects.count).to eq 3
      expect(target_project.lfs_objects.count).to eq 0
    end

    context 'when remove_remaining_elements is false' do
      let(:options) { { remove_remaining_elements: false } }

      it 'does not remove remaining lfs objects' do
        target_project.lfs_objects << project_with_lfs_objects.lfs_objects.first(2)

        subject.execute(project_with_lfs_objects, **options)

        expect(project_with_lfs_objects.lfs_objects.count).not_to eq 0
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  # Service class to detect target platforms of a project made for the Apple
  # Ecosystem.
  #
  # This service searches project.pbxproj and *.xcconfig files (contains build
  # settings) for the string ""SDKROOT = <SDK_name>"" where SDK_name can be
  # 'iphoneos', 'macosx', 'appletvos' or 'watchos'. Currently, the service is
  # intentionally limited (for performance reasons) to detect if a project
  # targets iOS.
  #
  # Ref: https://developer.apple.com/documentation/xcode/build-settings-reference/
  #
  # Example usage:
  # > AppleTargetPlatformDetectorService.new(a_project).execute
  # => []
  # > AppleTargetPlatformDetectorService.new(an_ios_project).execute
  # => [:ios]
  # > AppleTargetPlatformDetectorService.new(multiplatform_project).execute
  # => [:ios, :osx, :tvos, :watchos]
  class AppleTargetPlatformDetectorService < BaseService
    BUILD_CONFIG_FILENAMES = %w[project.pbxproj *.xcconfig].freeze

    # For the current iteration, we only want to detect when the project targets
    # iOS. In the future, we can use the same logic to detect projects that
    # target OSX, TvOS, and WatchOS platforms with SDK names 'macosx', 'appletvos',
    # and 'watchos', respectively.
    PLATFORM_SDK_NAMES = { ios: 'iphoneos' }.freeze

    def execute
      detect_platforms
    end

    private

    def file_finder
      @file_finder ||= ::Gitlab::FileFinder.new(project, project.default_branch)
    end

    def detect_platforms
      # Return array of SDK names for which ""SDKROOT = <sdk_name>"" setting
      # definition can be found in either project.pbxproj or *.xcconfig files.
      PLATFORM_SDK_NAMES.select do |_, sdk|
        config_files_containing_sdk_setting(sdk).present?
      end.keys
    end

    # Return array of project.pbxproj and/or *.xcconfig files
    # (Gitlab::Search::FoundBlob) that contain the setting definition string
    # ""SDKROOT = <sdk_name>""
    def config_files_containing_sdk_setting(sdk)
      BUILD_CONFIG_FILENAMES.map do |filename|
        file_finder.find(""SDKROOT = #{sdk} filename:#{filename}"")
      end.flatten
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::AppleTargetPlatformDetectorService, feature_category: :groups_and_projects do
  let_it_be(:project) { build(:project) }

  subject { described_class.new(project).execute }

  context 'when project is not an xcode project' do
    before do
      allow(Gitlab::FileFinder).to receive(:new) { instance_double(Gitlab::FileFinder, find: []) }
    end

    it 'returns an empty array' do
      is_expected.to match_array []
    end
  end

  context 'when project is an xcode project' do
    using RSpec::Parameterized::TableSyntax

    let(:finder) { instance_double(Gitlab::FileFinder) }

    before do
      allow(Gitlab::FileFinder).to receive(:new) { finder }
    end

    def search_query(sdk, filename)
      ""SDKROOT = #{sdk} filename:#{filename}""
    end

    context 'when setting string is found' do
      where(:sdk, :filename, :result) do
        'iphoneos'  | 'project.pbxproj' | [:ios]
        'iphoneos'  | '*.xcconfig'      | [:ios]
      end

      with_them do
        before do
          allow(finder).to receive(:find).with(anything) { [] }
          allow(finder).to receive(:find).with(search_query(sdk, filename)) { [instance_double(Gitlab::Search::FoundBlob)] }
        end

        it 'returns an array of unique detected targets' do
          is_expected.to match_array result
        end
      end
    end

    context 'when setting string is not found' do
      before do
        allow(finder).to receive(:find).with(anything) { [] }
      end

      it 'returns an empty array' do
        is_expected.to match_array []
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class RecordTargetPlatformsService < BaseService
    include Gitlab::Utils::StrongMemoize

    def initialize(project, detector_service)
      @project = project
      @detector_service = detector_service
    end

    def execute
      record_target_platforms
    end

    private

    attr_reader :project, :detector_service

    def target_platforms
      strong_memoize(:target_platforms) do
        Array(detector_service.new(project).execute)
      end
    end

    def record_target_platforms
      return unless target_platforms.present?

      project_setting.target_platforms = target_platforms
      project_setting.save
      project_setting.target_platforms
    end

    def project_setting
      @project_setting ||= ::ProjectSetting.find_or_initialize_by(project: project) # rubocop:disable CodeReuse/ActiveRecord
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::RecordTargetPlatformsService, '#execute', feature_category: :groups_and_projects do
  let_it_be(:project) { create(:project) }

  let(:detector_service) { Projects::AppleTargetPlatformDetectorService }

  subject(:execute) { described_class.new(project, detector_service).execute }

  context 'when project is an XCode project' do
    def project_setting
      ProjectSetting.find_by_project_id(project.id)
    end

    before do
      double = instance_double(detector_service, execute: [:ios, :osx])
      allow(Projects::AppleTargetPlatformDetectorService).to receive(:new) { double }
    end

    it 'creates a new setting record for the project', :aggregate_failures do
      expect { execute }.to change { ProjectSetting.count }.from(0).to(1)
      expect(ProjectSetting.last.target_platforms).to match_array(%w[ios osx])
    end

    it 'returns array of detected target platforms' do
      expect(execute).to match_array %w[ios osx]
    end

    context 'when a project has an existing setting record' do
      before do
        create(:project_setting, project: project, target_platforms: saved_target_platforms)
      end

      context 'when target platforms changed' do
        let(:saved_target_platforms) { %w[tvos] }

        it 'updates' do
          expect { execute }.to change { project_setting.target_platforms }.from(%w[tvos]).to(%w[ios osx])
        end

        it { is_expected.to match_array %w[ios osx] }
      end

      context 'when target platforms are the same' do
        let(:saved_target_platforms) { %w[osx ios] }

        it 'does not update' do
          expect { execute }.not_to change { project_setting.updated_at }
        end
      end
    end
  end

  context 'when project is not an XCode project' do
    before do
      double = instance_double(Projects::AppleTargetPlatformDetectorService, execute: [])
      allow(Projects::AppleTargetPlatformDetectorService).to receive(:new).with(project) { double }
    end

    it 'does nothing' do
      expect { execute }.not_to change { ProjectSetting.count }
    end

    it { is_expected.to be_nil }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  # Service class for counting and caching the number of open issues of a
  # project.
  class OpenIssuesCountService < Projects::CountService
    include Gitlab::Utils::StrongMemoize

    # Cache keys used to store issues count
    PUBLIC_COUNT_KEY = 'public_open_issues_count'
    TOTAL_COUNT_KEY = 'total_open_issues_count'

    def initialize(project, user = nil)
      @user = user

      super(project)
    end

    def cache_key_name
      public_only? ? PUBLIC_COUNT_KEY : TOTAL_COUNT_KEY
    end

    def public_only?
      !user_is_at_least_reporter?
    end

    def user_is_at_least_reporter?
      strong_memoize(:user_is_at_least_reporter) do
        @project.member?(@user, Gitlab::Access::REPORTER)
      end
    end

    def relation_for_count
      self.class.query(@project, public_only: public_only?)
    end

    def public_count_cache_key
      cache_key(PUBLIC_COUNT_KEY)
    end

    def total_count_cache_key
      cache_key(TOTAL_COUNT_KEY)
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def refresh_cache(&block)
      count_grouped_by_confidential = self.class.query(@project, public_only: false).group(:confidential).count
      public_count = count_grouped_by_confidential[false] || 0
      total_count = public_count + (count_grouped_by_confidential[true] || 0)

      update_cache_for_key(public_count_cache_key) do
        public_count
      end

      update_cache_for_key(total_count_cache_key) do
        total_count
      end
    end

    # We only show issues count including confidential for reporters, who are allowed to view confidential issues.
    # This will still show a discrepancy on issues number but should be less than before.
    # Check https://gitlab.com/gitlab-org/gitlab-foss/issues/38418 description.

    # rubocop: disable CodeReuse/ActiveRecord
    def self.query(projects, public_only: true)
      open_issues = Issue.opened

      if public_only
        open_issues.public_only.where(project: projects)
      else
        open_issues.where(project: projects)
      end
    end
    # rubocop: enable CodeReuse/ActiveRecord
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::OpenIssuesCountService, :use_clean_rails_memory_store_caching, feature_category: :team_planning do
  let(:project) { create(:project) }

  subject { described_class.new(project) }

  it_behaves_like 'a counter caching service'

  describe '#count' do
    context 'when user is nil' do
      it 'does not include confidential issues in the issue count' do
        create(:issue, :opened, project: project)
        create(:issue, :opened, confidential: true, project: project)

        expect(described_class.new(project).count).to eq(1)
      end
    end

    context 'when user is provided' do
      let(:user) { create(:user) }

      context 'when user can read confidential issues' do
        before do
          project.add_reporter(user)
        end

        it 'returns the right count with confidential issues' do
          create(:issue, :opened, project: project)
          create(:issue, :opened, confidential: true, project: project)

          expect(described_class.new(project, user).count).to eq(2)
        end

        it 'uses total_open_issues_count cache key' do
          expect(described_class.new(project, user).cache_key_name).to eq('total_open_issues_count')
        end
      end

      context 'when user cannot read confidential issues' do
        before do
          project.add_guest(user)
        end

        it 'does not include confidential issues' do
          create(:issue, :opened, project: project)
          create(:issue, :opened, confidential: true, project: project)

          expect(described_class.new(project, user).count).to eq(1)
        end

        it 'uses public_open_issues_count cache key' do
          expect(described_class.new(project, user).cache_key_name).to eq('public_open_issues_count')
        end
      end
    end

    describe '#refresh_cache' do
      before do
        create(:issue, :opened, project: project)
        create(:issue, :opened, project: project)
        create(:issue, :opened, confidential: true, project: project)
      end

      context 'when cache is empty' do
        it 'refreshes cache keys correctly' do
          subject.refresh_cache

          expect(Rails.cache.read(subject.cache_key(described_class::PUBLIC_COUNT_KEY))).to eq(2)
          expect(Rails.cache.read(subject.cache_key(described_class::TOTAL_COUNT_KEY))).to eq(3)
        end
      end

      context 'when cache is outdated' do
        before do
          subject.refresh_cache
        end

        it 'refreshes cache keys correctly' do
          create(:issue, :opened, project: project)
          create(:issue, :opened, confidential: true, project: project)

          subject.refresh_cache

          expect(Rails.cache.read(subject.cache_key(described_class::PUBLIC_COUNT_KEY))).to eq(3)
          expect(Rails.cache.read(subject.cache_key(described_class::TOTAL_COUNT_KEY))).to eq(5)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Service class for getting and caching the number of issues of several projects
# Warning: do not user this service with a really large set of projects
# because the service use maps to retrieve the project ids
module Projects
  class BatchOpenIssuesCountService < Projects::BatchCountService
    # rubocop: disable CodeReuse/ActiveRecord
    def global_count
      @global_count ||= count_service.query(project_ids).group(:project_id).count
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def count_service
      ::Projects::OpenIssuesCountService
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::BatchOpenIssuesCountService, feature_category: :groups_and_projects do
  let!(:project_1) { create(:project) }
  let!(:project_2) { create(:project) }

  let(:subject) { described_class.new([project_1, project_2]) }

  describe '#refresh_cache_and_retrieve_data', :use_clean_rails_memory_store_caching do
    before do
      create(:issue, project: project_1)
      create(:issue, project: project_1, confidential: true)

      create(:issue, project: project_2)
      create(:issue, project: project_2, confidential: true)
    end

    context 'when cache is clean' do
      it 'refreshes cache keys correctly' do
        subject.refresh_cache_and_retrieve_data

        # It does not update total issues cache
        expect(Rails.cache.read(get_cache_key(subject, project_1))).to eq(nil)
        expect(Rails.cache.read(get_cache_key(subject, project_2))).to eq(nil)

        expect(Rails.cache.read(get_cache_key(subject, project_1, true))).to eq(1)
        expect(Rails.cache.read(get_cache_key(subject, project_1, true))).to eq(1)
      end
    end
  end

  def get_cache_key(subject, project, public_key = false)
    service = subject.count_service.new(project)

    if public_key
      service.cache_key(service.class::PUBLIC_COUNT_KEY)
    else
      service.cache_key(service.class::TOTAL_COUNT_KEY)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class GitDeduplicationService < BaseService
    include ExclusiveLeaseGuard

    LEASE_TIMEOUT = 86400

    delegate :pool_repository, to: :project
    attr_reader :project

    def initialize(project)
      @project = project
    end

    def execute
      try_obtain_lease do
        unless project.has_pool_repository?
          disconnect_git_alternates
          break
        end

        if source_project? && pool_can_fetch_from_source?
          fetch_from_source
        end

        project.link_pool_repository if same_storage_as_pool?(project.repository)
      end
    end

    private

    def disconnect_git_alternates
      project.repository.disconnect_alternates
    end

    def pool_can_fetch_from_source?
      project.git_objects_poolable? &&
        same_storage_as_pool?(pool_repository.source_project.repository)
    end

    def same_storage_as_pool?(repository)
      pool_repository.object_pool.repository.storage == repository.storage
    end

    def fetch_from_source
      project.pool_repository.object_pool.fetch
    end

    def source_project?
      return unless project.has_pool_repository?

      project.pool_repository.source_project == project
    end

    def lease_timeout
      LEASE_TIMEOUT
    end

    def lease_key
      ""git_deduplication:#{project.id}""
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::GitDeduplicationService, feature_category: :source_code_management do
  include ExclusiveLeaseHelpers

  let(:pool) { create(:pool_repository, :ready) }
  let(:project) { create(:project, :repository) }
  let(:lease_key) { ""git_deduplication:#{project.id}"" }
  let(:lease_timeout) { Projects::GitDeduplicationService::LEASE_TIMEOUT }

  subject(:service) { described_class.new(project) }

  describe '#execute' do
    context 'when there is not already a lease' do
      context 'when the project does not have a pool repository' do
        it 'calls disconnect_git_alternates' do
          stub_exclusive_lease(lease_key, timeout: lease_timeout)

          expect(project.repository).to receive(:disconnect_alternates)

          service.execute
        end
      end

      context 'when the project has a pool repository' do
        let(:project) { create(:project, :repository, pool_repository: pool) }

        context 'when the project is a source project' do
          let(:lease_key) { ""git_deduplication:#{pool.source_project.id}"" }

          subject(:service) { described_class.new(pool.source_project) }

          it 'calls fetch' do
            stub_exclusive_lease(lease_key, timeout: lease_timeout)
            allow(pool.source_project).to receive(:git_objects_poolable?).and_return(true)

            expect(pool.object_pool).to receive(:fetch)

            service.execute
          end

          it 'does not call fetch if git objects are not poolable' do
            stub_exclusive_lease(lease_key, timeout: lease_timeout)
            allow(pool.source_project).to receive(:git_objects_poolable?).and_return(false)

            expect(pool.object_pool).not_to receive(:fetch)

            service.execute
          end

          it 'does not call fetch if pool and project are not on the same storage' do
            stub_exclusive_lease(lease_key, timeout: lease_timeout)
            allow(pool.source_project.repository).to receive(:storage).and_return('special_storage_001')

            expect(pool.object_pool).not_to receive(:fetch)

            service.execute
          end

          context 'when visibility level of the project' do
            before do
              allow(pool.source_project).to receive(:repository_access_level).and_return(ProjectFeature::ENABLED)
            end

            context 'is private' do
              it 'does not call fetch' do
                allow(pool.source_project).to receive(:visibility_level).and_return(Gitlab::VisibilityLevel::PRIVATE)
                expect(pool.object_pool).not_to receive(:fetch)

                service.execute
              end
            end

            context 'is public' do
              it 'calls fetch' do
                allow(pool.source_project).to receive(:visibility_level).and_return(Gitlab::VisibilityLevel::PUBLIC)
                expect(pool.object_pool).to receive(:fetch)

                service.execute
              end
            end

            context 'is internal' do
              it 'calls fetch' do
                allow(pool.source_project).to receive(:visibility_level).and_return(Gitlab::VisibilityLevel::INTERNAL)
                expect(pool.object_pool).to receive(:fetch)

                service.execute
              end
            end
          end

          context 'when the repository access level' do
            before do
              allow(pool.source_project).to receive(:visibility_level).and_return(Gitlab::VisibilityLevel::PUBLIC)
            end

            context 'is private' do
              it 'does not call fetch' do
                allow(pool.source_project).to receive(:repository_access_level).and_return(ProjectFeature::PRIVATE)

                expect(pool.object_pool).not_to receive(:fetch)

                service.execute
              end
            end

            context 'is greater than private' do
              it 'calls fetch' do
                allow(pool.source_project).to receive(:repository_access_level).and_return(ProjectFeature::PUBLIC)

                expect(pool.object_pool).to receive(:fetch)

                service.execute
              end
            end
          end
        end

        it 'links the repository to the object pool' do
          expect(project).to receive(:link_pool_repository)

          service.execute
        end

        it 'does not link the repository to the object pool if they are not on the same storage' do
          allow(project.repository).to receive(:storage).and_return('special_storage_001')
          expect(project).not_to receive(:link_pool_repository)

          service.execute
        end
      end

      context 'when a lease is already out' do
        before do
          stub_exclusive_lease_taken(lease_key, timeout: lease_timeout)
        end

        it 'fails when a lease is already out' do
          expect(Gitlab::AppJsonLogger).to receive(:error).with({ message: ""Cannot obtain an exclusive lease. There must be another instance already in execution."", lease_key: lease_key, class_name: described_class.name, lease_timeout: lease_timeout })

          service.execute
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class UpdateStatisticsService < BaseService
    include ::Gitlab::Utils::StrongMemoize

    STAT_TO_CACHED_METHOD = {
      repository_size: [:size, :recent_objects_size],
      commit_count: :commit_count
    }.freeze

    def execute
      return unless project

      Gitlab::AppLogger.info(""Updating statistics for project #{project.id}"")

      expire_repository_caches
      expire_wiki_caches
      project.statistics.refresh!(only: statistics)
    end

    private

    def expire_repository_caches
      if statistics.empty?
        project.repository.expire_statistics_caches
      elsif method_caches_to_expire.present?
        project.repository.expire_method_caches(method_caches_to_expire)
      end
    end

    def expire_wiki_caches
      return unless project.wiki_enabled? && statistics.include?(:wiki_size)

      project.wiki.repository.expire_method_caches([:size])
    end

    def method_caches_to_expire
      strong_memoize(:method_caches_to_expire) do
        statistics.flat_map { |stat| STAT_TO_CACHED_METHOD[stat] }.compact
      end
    end

    def statistics
      strong_memoize(:statistics) do
        params[:statistics]&.map(&:to_sym)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::UpdateStatisticsService, feature_category: :groups_and_projects do
  using RSpec::Parameterized::TableSyntax

  let(:service) { described_class.new(project, nil, statistics: statistics) }
  let(:statistics) { %w[repository_size] }

  describe '#execute' do
    context 'with a non-existing project' do
      let(:project) { nil }

      it 'does nothing' do
        expect_any_instance_of(ProjectStatistics).not_to receive(:refresh!)

        service.execute
      end
    end

    context 'with an existing project' do
      let_it_be(:project) { create(:project) }

      where(:statistics, :method_caches) do
        []                                                   | %i[size recent_objects_size commit_count]
        ['repository_size']                                  | %i[size recent_objects_size]
        [:repository_size]                                   | %i[size recent_objects_size]
        [:lfs_objects_size]                                  | nil
        [:commit_count]                                      | [:commit_count]
        [:repository_size, :commit_count]                    | %i[size recent_objects_size commit_count]
        [:repository_size, :commit_count, :lfs_objects_size] | %i[size recent_objects_size commit_count]
      end

      with_them do
        it 'refreshes the project statistics' do
          expect(project.statistics).to receive(:refresh!).with(only: statistics.map(&:to_sym)).and_call_original

          service.execute
        end

        it 'invalidates the method caches after a refresh' do
          expect(project.wiki.repository).not_to receive(:expire_method_caches)

          if method_caches.present?
            expect(project.repository).to receive(:expire_method_caches).with(method_caches).and_call_original
          else
            expect(project.repository).not_to receive(:expire_method_caches)
          end

          service.execute
        end
      end
    end

    context 'with an existing project with a Wiki' do
      let(:project) { create(:project, :repository, :wiki_enabled) }
      let(:statistics) { [:wiki_size] }

      it 'invalidates and refreshes Wiki size' do
        expect(project.statistics).to receive(:refresh!).with(only: statistics).and_call_original
        expect(project.wiki.repository).to receive(:expire_method_caches).with(%i[size]).and_call_original

        service.execute
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  # Base class for the various service classes that count project data (e.g.
  # issues or forks).
  class CountService < BaseCountService
    # The version of the cache format. This should be bumped whenever the
    # underlying logic changes. This removes the need for explicitly flushing
    # all caches.
    VERSION = 1

    attr_reader :project

    def initialize(project)
      @project = project
    end

    def relation_for_count
      self.class.query(@project.id)
    end

    def cache_key_name
      raise(
        NotImplementedError,
        '""cache_key_name"" must be implemented and return a String'
      )
    end

    def cache_key(key = nil)
      cache_key = key || cache_key_name

      ['projects', 'count_service', VERSION, @project.id, cache_key]
    end

    def self.query(project_ids)
      raise(
        NotImplementedError,
        '""query"" must be implemented and return an ActiveRecord::Relation'
      )
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::CountService, feature_category: :groups_and_projects do
  let(:project) { build(:project, id: 1) }
  let(:service) { described_class.new(project) }

  describe '.query' do
    it 'raises NotImplementedError' do
      expect { described_class.query(project.id) }.to raise_error(NotImplementedError)
    end
  end

  describe '#relation_for_count' do
    it 'calls the class method query with the project id' do
      expect(described_class).to receive(:query).with(project.id)

      service.relation_for_count
    end
  end

  describe '#count' do
    before do
      allow(service).to receive(:cache_key_name).and_return('count_service')
    end

    it 'returns the number of rows' do
      allow(service).to receive(:uncached_count).and_return(1)

      expect(service.count).to eq(1)
    end

    it 'caches the number of rows', :use_clean_rails_memory_store_caching do
      expect(service).to receive(:uncached_count).once.and_return(1)

      2.times do
        expect(service.count).to eq(1)
      end
    end
  end

  describe '#refresh_cache', :use_clean_rails_memory_store_caching do
    before do
      allow(service).to receive(:cache_key_name).and_return('count_service')
    end

    it 'refreshes the cache' do
      expect(service).to receive(:uncached_count).once.and_return(1)

      service.refresh_cache

      expect(service.count).to eq(1)
    end
  end

  describe '#delete_cache', :use_clean_rails_memory_store_caching do
    before do
      allow(service).to receive(:cache_key_name).and_return('count_service')
    end

    it 'removes the cache' do
      expect(service).to receive(:uncached_count).twice.and_return(1)

      service.count
      service.delete_cache
      service.count
    end
  end

  describe '#cache_key_name' do
    it 'raises NotImplementedError' do
      expect { service.cache_key_name }.to raise_error(NotImplementedError)
    end
  end

  describe '#cache_key' do
    it 'returns the cache key as an Array' do
      allow(service).to receive(:cache_key_name).and_return('foo')
      expect(service.cache_key).to eq(['projects', 'count_service', described_class::VERSION, 1, 'foo'])
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class MoveDeployKeysProjectsService < BaseMoveRelationsService
    def execute(source_project, remove_remaining_elements: true)
      return unless super

      # The SHA256 fingerprint should be there, but just in case it isn't
      # we want to make sure it's generated. Otherwise we might delete keys.
      ensure_sha256_fingerprints

      Project.transaction do
        move_deploy_keys_projects
        remove_remaining_deploy_keys_projects if remove_remaining_elements

        success
      end
    end

    private

    def ensure_sha256_fingerprints
      @project.deploy_keys.each(&:ensure_sha256_fingerprint!)
      source_project.deploy_keys.each(&:ensure_sha256_fingerprint!)
    end

    def move_deploy_keys_projects
      non_existent_deploy_keys_projects.update_all(project_id: @project.id)
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def non_existent_deploy_keys_projects
      source_project.deploy_keys_projects
                    .joins(:deploy_key)
                    .where.not(keys: { fingerprint_sha256: @project.deploy_keys.select(:fingerprint_sha256) })
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def remove_remaining_deploy_keys_projects
      source_project.deploy_keys_projects.destroy_all # rubocop: disable Cop/DestroyAll
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::MoveDeployKeysProjectsService, feature_category: :continuous_delivery do
  let!(:user) { create(:user) }
  let!(:project_with_deploy_keys) { create(:project, namespace: user.namespace) }
  let!(:target_project) { create(:project, namespace: user.namespace) }

  subject { described_class.new(target_project, user) }

  describe '#execute' do
    before do
      create_list(:deploy_keys_project, 2, project: project_with_deploy_keys)
    end

    it 'moves the user\'s deploy keys from one project to another' do
      expect(project_with_deploy_keys.deploy_keys_projects.count).to eq 2
      expect(target_project.deploy_keys_projects.count).to eq 0

      subject.execute(project_with_deploy_keys)

      expect(project_with_deploy_keys.deploy_keys_projects.count).to eq 0
      expect(target_project.deploy_keys_projects.count).to eq 2
    end

    it 'does not link existent deploy_keys in the current project' do
      target_project.deploy_keys << project_with_deploy_keys.deploy_keys.first

      expect(project_with_deploy_keys.deploy_keys_projects.count).to eq 2
      expect(target_project.deploy_keys_projects.count).to eq 1

      subject.execute(project_with_deploy_keys)

      expect(project_with_deploy_keys.deploy_keys_projects.count).to eq 0
      expect(target_project.deploy_keys_projects.count).to eq 2
    end

    it 'rollbacks changes if transaction fails' do
      allow(subject).to receive(:success).and_raise(StandardError)

      expect { subject.execute(project_with_deploy_keys) }.to raise_error(StandardError)

      expect(project_with_deploy_keys.deploy_keys_projects.count).to eq 2
      expect(target_project.deploy_keys_projects.count).to eq 0
    end

    context 'when remove_remaining_elements is false' do
      let(:options) { { remove_remaining_elements: false } }

      it 'does not remove remaining deploy keys projects' do
        target_project.deploy_keys << project_with_deploy_keys.deploy_keys.first

        subject.execute(project_with_deploy_keys, **options)

        expect(project_with_deploy_keys.deploy_keys_projects.count).not_to eq 0
      end
    end

    context 'when SHA256 fingerprint is missing' do
      before do
        create(:deploy_keys_project, project: target_project)
        DeployKey.all.update_all(fingerprint_sha256: nil)
      end

      it 'moves the user\'s deploy keys from one project to another' do
        combined_keys = project_with_deploy_keys.deploy_keys + target_project.deploy_keys

        subject.execute(project_with_deploy_keys)

        expect(project_with_deploy_keys.deploy_keys.reload).to be_empty
        expect(target_project.deploy_keys.reload).to match_array(combined_keys)
        expect(DeployKey.all.select(:fingerprint_sha256)).to all(be_present)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class DetectRepositoryLanguagesService < BaseService
    attr_reader :programming_languages

    # rubocop: disable CodeReuse/ActiveRecord
    def execute
      repository_languages = project.repository_languages
      detection = Gitlab::LanguageDetection.new(repository, repository_languages)

      matching_programming_languages = ensure_programming_languages(detection)

      RepositoryLanguage.transaction do
        RepositoryLanguage.where(project_id: project.id, programming_language_id: detection.deletions).delete_all

        detection.updates.each do |update|
          RepositoryLanguage
            .where(project_id: project.id)
            .where(programming_language_id: update[:programming_language_id])
            .update_all(share: update[:share])
        end

        ApplicationRecord.legacy_bulk_insert( # rubocop:disable Gitlab/BulkInsert
          RepositoryLanguage.table_name,
          detection.insertions(matching_programming_languages)
        )

        set_detected_repository_languages
      end

      project.repository_languages.reset
    end
    # rubocop: enable CodeReuse/ActiveRecord

    private

    # rubocop: disable CodeReuse/ActiveRecord
    def ensure_programming_languages(detection)
      existing_languages = ProgrammingLanguage.where(name: detection.languages)
      return existing_languages if detection.languages.size == existing_languages.size

      missing_languages = detection.languages - existing_languages.map(&:name)
      created_languages = missing_languages.map do |name|
        create_language(name, detection.language_color(name))
      end

      existing_languages + created_languages
    end
    # rubocop: enable CodeReuse/ActiveRecord

    # rubocop: disable CodeReuse/ActiveRecord
    def create_language(name, color)
      ProgrammingLanguage.transaction do
        ProgrammingLanguage.where(name: name).first_or_create(color: color)
      end
    rescue ActiveRecord::RecordNotUnique
      retry
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def set_detected_repository_languages
      return if project.detected_repository_languages?

      project.update_column(:detected_repository_languages, true)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::DetectRepositoryLanguagesService, :clean_gitlab_redis_shared_state, feature_category: :groups_and_projects do
  let_it_be(:project, reload: true) { create(:project, :repository) }

  subject { described_class.new(project) }

  describe '#execute' do
    context 'without previous detection' do
      it 'inserts new programming languages in the database' do
        subject.execute

        expect(ProgrammingLanguage.exists?(name: 'Ruby')).to be(true)
        expect(ProgrammingLanguage.count).to be(4)
      end

      it 'inserts the repository langauges' do
        names = subject.execute.map(&:name)

        expect(names).to eq(%w[Ruby JavaScript HTML CoffeeScript])
      end

      it 'updates detected_repository_languages flag' do
        expect { subject.execute }.to change(project, :detected_repository_languages).to(true)
      end
    end

    context 'with a previous detection' do
      before do
        subject.execute

        allow(project.repository).to receive(:languages).and_return(
          [{ value: 99.63, label: ""Ruby"", color: ""#701516"", highlight: ""#701516"" },
           { value: 0.3, label: ""D"", color: ""#701516"", highlight: ""#701516"" }]
        )
      end

      it 'updates the repository languages' do
        repository_languages = subject.execute.map(&:name)

        expect(repository_languages).to eq(%w[Ruby D])
      end

      it ""doesn't touch detected_repository_languages flag"" do
        expect(project).not_to receive(:update_column).with(:detected_repository_languages, true)

        subject.execute
      end
    end

    context 'when no repository exists' do
      let_it_be(:project) { create(:project) }

      it 'has no languages' do
        expect(subject.execute).to be_empty
        expect(project.repository_languages).to be_empty
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  class CreateService < BaseService
    include ValidatesClassificationLabel

    ImportSourceDisabledError = Class.new(StandardError)
    INTERNAL_IMPORT_SOURCES = %w[gitlab_custom_project_template gitlab_project_migration].freeze

    def initialize(user, params)
      @current_user = user
      @params = params.dup
      @skip_wiki = @params.delete(:skip_wiki)
      @initialize_with_sast = Gitlab::Utils.to_boolean(@params.delete(:initialize_with_sast))
      @initialize_with_readme = Gitlab::Utils.to_boolean(@params.delete(:initialize_with_readme))
      @use_sha256_repository = Gitlab::Utils.to_boolean(@params.delete(:use_sha256_repository)) && Feature.enabled?(:support_sha256_repositories, user)
      @import_data = @params.delete(:import_data)
      @relations_block = @params.delete(:relations_block)
      @default_branch = @params.delete(:default_branch)
      @readme_template = @params.delete(:readme_template)

      build_topics
    end

    def execute
      params[:wiki_enabled] = params[:wiki_access_level] if params[:wiki_access_level]
      params[:builds_enabled] = params[:builds_access_level] if params[:builds_access_level]
      params[:snippets_enabled] = params[:snippets_access_level] if params[:snippets_access_level]
      params[:merge_requests_enabled] = params[:merge_requests_access_level] if params[:merge_requests_access_level]
      params[:issues_enabled] = params[:issues_access_level] if params[:issues_access_level]

      if create_from_template?
        return ::Projects::CreateFromTemplateService.new(current_user, params).execute
      end

      @project = Project.new(params.merge(creator: current_user))

      validate_import_source_enabled!

      @project.visibility_level = @project.group.visibility_level unless @project.visibility_level_allowed_by_group?

      # If a project is newly created it should have shared runners settings
      # based on its group having it enabled. This is like the ""default value""
      @project.shared_runners_enabled = false if !params.key?(:shared_runners_enabled) && @project.group && @project.group.shared_runners_setting != 'enabled'

      # Make sure that the user is allowed to use the specified visibility level
      if project_visibility.restricted?
        deny_visibility_level(@project, project_visibility.visibility_level)
        return @project
      end

      set_project_name_from_path

      # get namespace id
      namespace_id = params[:namespace_id] || current_user.namespace_id
      @project.namespace_id = namespace_id.to_i

      @project.check_personal_projects_limit
      return @project if @project.errors.any?

      validate_create_permissions
      validate_import_permissions
      return @project if @project.errors.any?

      @relations_block&.call(@project)
      yield(@project) if block_given?

      validate_classification_label(@project, :external_authorization_classification_label)

      # If the block added errors, don't try to save the project
      return @project if @project.errors.any?

      @project.creator = current_user

      save_project_and_import_data

      Gitlab::ApplicationContext.with_context(project: @project) do
        after_create_actions if @project.persisted?

        import_schedule
      end

      @project
    rescue ActiveRecord::RecordInvalid => e
      message = ""Unable to save #{e.inspect}: #{e.record.errors.full_messages.join("", "")}""
      fail(error: message)
    rescue ImportSourceDisabledError => e
      @project.errors.add(:import_source_disabled, e.message) if @project
      fail(error: e.message)
    rescue StandardError => e
      @project.errors.add(:base, e.message) if @project
      fail(error: e.message)
    end

    protected

    def validate_create_permissions
      return if current_user.can?(:create_projects, parent_namespace)

      @project.errors.add(:namespace, ""is not valid"")
    end

    def validate_import_permissions
      return unless @project.import?
      return if current_user.can?(:import_projects, parent_namespace)

      @project.errors.add(:user, 'is not allowed to import projects')
    end

    def after_create_actions
      log_info(""#{current_user.name} created a new project \""#{@project.full_name}\"""")

      if @project.import?
        Gitlab::Tracking.event(self.class.name, 'import_project', user: current_user)
      else
        # Skip writing the config for project imports/forks because it
        # will always fail since the Git directory doesn't exist until
        # a background job creates it (see Project#add_import_job).
        @project.set_full_path
      end

      unless @project.gitlab_project_import?
        @project.create_wiki unless skip_wiki?
      end

      @project.track_project_repository

      create_project_settings

      yield if block_given?

      event_service.create_project(@project, current_user)
      system_hook_service.execute_hooks_for(@project, :create)

      setup_authorizations

      project.invalidate_personal_projects_count_of_owner

      Projects::PostCreationWorker.perform_async(@project.id)

      create_readme if @initialize_with_readme
      create_sast_commit if @initialize_with_sast

      publish_event
    end

    def create_project_settings
      Gitlab::Pages.add_unique_domain_to(project)

      @project.project_setting.save if @project.project_setting.changed?
    end

    # Add an authorization for the current user authorizations inline
    # (so they can access the project immediately after this request
    # completes), and any other affected users in the background
    def setup_authorizations
      if @project.group
        group_access_level = @project.group.max_member_access_for_user(
          current_user,
          only_concrete_membership: true
        )

        if group_access_level > GroupMember::NO_ACCESS
          current_user.project_authorizations.safe_find_or_create_by!(
            project: @project,
            access_level: group_access_level)
        end

        AuthorizedProjectUpdate::ProjectRecalculateWorker.perform_async(@project.id)
        # AuthorizedProjectsWorker uses an exclusive lease per user but
        # specialized workers might have synchronization issues. Until we
        # compare the inconsistency rates of both approaches, we still run
        # AuthorizedProjectsWorker but with some delay and lower urgency as a
        # safety net.
        @project.group.refresh_members_authorized_projects(
          priority: UserProjectAccessChangedService::LOW_PRIORITY
        )
      else
        owner_user = @project.namespace.owner
        owner_member = @project.add_owner(owner_user, current_user: current_user)

        # There is a possibility that the sidekiq job to refresh the authorizations of the owner_user in this project
        # isn't picked up (or finished) by the time the user is redirected to the newly created project's page.
        # If that happens, the user will hit a 404. To avoid that scenario, we manually create a `project_authorizations` record for the user here.
        if owner_member.persisted?
          owner_user.project_authorizations.safe_find_or_create_by(
            project: @project,
            access_level: ProjectMember::OWNER
          )
        end
        # During the process of adding a project owner, a check on permissions is made on the user which caches
        # the max member access for that user on this project.
        # Since that is `0` before the member is created - and we are still inside the request
        # cycle when we need to do other operations that might check those permissions (e.g. write a commit)
        # we need to purge that cache so that the updated permissions is fetched instead of using the outdated cached value of 0
        # from before member creation
        @project.team.purge_member_access_cache_for_user_id(owner_user.id)
      end
    end

    def create_readme
      commit_attrs = {
        branch_name: default_branch,
        commit_message: 'Initial commit',
        file_path: 'README.md',
        file_content: readme_content
      }

      Files::CreateService.new(@project, current_user, commit_attrs).execute
    end

    def create_sast_commit
      ::Security::CiConfiguration::SastCreateService.new(@project, current_user, { initialize_with_sast: true }, commit_on_default: true).execute
    end

    def repository_object_format
      @use_sha256_repository ? Repository::FORMAT_SHA256 : Repository::FORMAT_SHA1
    end

    def readme_content
      readme_attrs = {
        default_branch: default_branch
      }

      @readme_template.presence || ReadmeRendererService.new(@project, current_user, readme_attrs).execute
    end

    def skip_wiki?
      !@project.feature_available?(:wiki, current_user) || @skip_wiki
    end

    def save_project_and_import_data
      Gitlab::Database::QueryAnalyzers::PreventCrossDatabaseModification.temporary_ignore_tables_in_transaction(
        %w[routes redirect_routes], url: 'https://gitlab.com/gitlab-org/gitlab/-/issues/424281'
      ) do
        ApplicationRecord.transaction do
          @project.build_or_assign_import_data(data: @import_data[:data], credentials: @import_data[:credentials]) if @import_data

          # Avoid project callbacks being triggered multiple times by saving the parent first.
          # See https://github.com/rails/rails/issues/41701.
          Namespaces::ProjectNamespace.create_from_project!(@project) if @project.valid?

          if @project.saved?
            Integration.create_from_active_default_integrations(@project, :project_id)

            @project.create_labels unless @project.gitlab_project_import?

            next if @project.import?

            unless @project.create_repository(default_branch: default_branch, object_format: repository_object_format)
              raise 'Failed to create repository'
            end
          end
        end
      end
    end

    def fail(error:)
      message = ""Unable to save project. Error: #{error}""
      log_message = message.dup

      log_message << "" Project ID: #{@project.id}"" if @project&.id
      Gitlab::AppLogger.error(log_message)

      if @project && @project.persisted? && @project.import_state
        @project.import_state.mark_as_failed(message)
      end

      @project
    end

    def set_project_name_from_path
      # if both name and path set - everything is ok
      return if @project.name.present? && @project.path.present?

      if @project.path.present?
        # Set project name from path
        @project.name = @project.path.dup
      elsif @project.name.present?
        # For compatibility - set path from name
        @project.path = @project.name.dup

        # TODO: Retained for backwards compatibility. Remove in API v5.
        #       When removed, validation errors will get bubbled up automatically.
        #       See https://gitlab.com/gitlab-org/gitlab/-/merge_requests/52725
        unless @project.path.match?(Gitlab::PathRegex.project_path_format_regex)
          @project.path = @project.path.parameterize
        end
      end
    end

    def extra_attributes_for_measurement
      {
        current_user: current_user&.name,
        project_full_path: ""#{parent_namespace&.full_path}/#{@params[:path]}""
      }
    end

    private

    def default_branch
      @default_branch.presence || @project.default_branch_or_main
    end

    def validate_import_source_enabled!
      return unless @params[:import_type]

      import_type = @params[:import_type].to_s

      return if INTERNAL_IMPORT_SOURCES.include?(import_type)

      # Skip validation when creating project from a built in template
      return if @params[:import_export_upload].present? && import_type == 'gitlab_project'

      unless ::Gitlab::CurrentSettings.import_sources&.include?(import_type)
        raise ImportSourceDisabledError, ""#{import_type} import source is disabled""
      end
    end

    def parent_namespace
      @parent_namespace ||= Namespace.find_by_id(@params[:namespace_id]) || current_user.namespace
    end

    def create_from_template?
      @params[:template_name].present? || @params[:template_project_id].present?
    end

    def import_schedule
      if @project.errors.empty?
        @project.import_state.schedule if @project.import? && !@project.gitlab_project_migration?
      else
        fail(error: @project.errors.full_messages.join(', '))
      end
    end

    def project_visibility
      @project_visibility ||= Gitlab::VisibilityLevelChecker
        .new(current_user, @project, project_params: { import_data: @import_data })
        .level_restricted?
    end

    def build_topics
      topics = params.delete(:topics)
      tag_list = params.delete(:tag_list)
      topic_list = topics || tag_list

      params[:topic_list] ||= topic_list if topic_list
    end

    def publish_event
      event = Projects::ProjectCreatedEvent.new(data: {
        project_id: project.id,
        namespace_id: project.namespace_id,
        root_namespace_id: project.root_namespace.id
      })

      Gitlab::EventStore.publish(event)
    end
  end
end

Projects::CreateService.prepend_mod_with('Projects::CreateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::CreateService, '#execute', feature_category: :groups_and_projects do
  include ExternalAuthorizationServiceHelpers

  let(:user) { create :user }
  let(:project_name) { 'GitLab' }
  let(:opts) do
    {
      name: project_name,
      namespace_id: user.namespace.id
    }
  end

  context 'with labels' do
    subject(:project) { create_project(user, opts) }

    before_all do
      Label.create!(title: 'bug', template: true)
    end

    it 'creates labels on project creation' do
      expect(project.labels).to include have_attributes(
        type: eq('ProjectLabel'),
        project_id: eq(project.id),
        title: eq('bug')
      )
    end

    context 'using gitlab project import' do
      before do
        opts[:import_type] = 'gitlab_project'
      end

      it 'does not creates labels on project creation' do
        expect(project.labels.size).to eq(0)
      end
    end
  end

  describe 'setting name and path' do
    subject(:project) { create_project(user, opts) }

    context 'when both are set' do
      let(:opts) { { name: 'one', path: 'two' } }

      it 'keeps them as specified' do
        expect(project.name).to eq('one')
        expect(project.path).to eq('two')
        expect(project.project_namespace).to be_in_sync_with_project(project)
      end
    end

    context 'when path is set' do
      let(:opts) { { path: 'one.two_three-four' } }

      it 'sets name == path' do
        expect(project.path).to eq('one.two_three-four')
        expect(project.name).to eq(project.path)
        expect(project.project_namespace).to be_in_sync_with_project(project)
      end
    end

    context 'when name is a valid path' do
      let(:opts) { { name: 'one.two_three-four' } }

      it 'sets path == name' do
        expect(project.name).to eq('one.two_three-four')
        expect(project.path).to eq(project.name)
        expect(project.project_namespace).to be_in_sync_with_project(project)
      end
    end

    context 'when name is not a valid path' do
      let(:opts) { { name: 'one.two_three-four and five' } }

      # TODO: Retained for backwards compatibility. Remove in API v5.
      #       See https://gitlab.com/gitlab-org/gitlab/-/merge_requests/52725
      it 'parameterizes the name' do
        expect(project.name).to eq('one.two_three-four and five')
        expect(project.path).to eq('one-two_three-four-and-five')
        expect(project.project_namespace).to be_in_sync_with_project(project)
      end
    end
  end

  describe 'topics' do
    subject(:project) { create_project(user, opts) }

    context ""with 'topics' parameter"" do
      let(:opts) { { name: 'topic-project', topics: 'topics' } }

      it 'keeps them as specified' do
        expect(project.topic_list).to eq(%w[topics])
      end
    end

    context ""with 'topic_list' parameter"" do
      let(:opts) { { name: 'topic-project', topic_list: 'topic_list' } }

      it 'keeps them as specified' do
        expect(project.topic_list).to eq(%w[topic_list])
      end
    end

    context ""with 'tag_list' parameter (deprecated)"" do
      let(:opts) { { name: 'topic-project', tag_list: 'tag_list' } }

      it 'keeps them as specified' do
        expect(project.topic_list).to eq(%w[tag_list])
      end
    end
  end

  context 'user namespace' do
    it 'creates a project in user namespace' do
      project = create_project(user, opts)

      expect(project).to be_valid
      expect(project.first_owner).to eq(user)
      expect(project.team.maintainers).not_to include(user)
      expect(project.team.owners).to contain_exactly(user)
      expect(project.namespace).to eq(user.namespace)
      expect(project.project_namespace).to be_in_sync_with_project(project)
    end

    context 'project_authorizations record creation' do
      context 'when the project_authrizations records are not created via the callback' do
        it 'still creates project_authrizations record for the user' do
          # stub out the callback that creates project_authorizations records on the `ProjectMember` model.
          expect_next_instance_of(ProjectMember) do |member|
            expect(member).to receive(:refresh_member_authorized_projects).and_return(nil)
          end

          project = create_project(user, opts)

          expected_record = project.project_authorizations.where(
            user: user,
            access_level: ProjectMember::OWNER
          )

          expect(expected_record).to exist
        end
      end
    end

    context 'when the passed in namespace is for a bot user' do
      let(:bot_user) { create(:user, :project_bot) }
      let(:opts) do
        { name: project_name, namespace_id: bot_user.namespace.id }
      end

      it 'raises an error' do
        project = create_project(bot_user, opts)

        expect(project.errors.errors.length).to eq 1
        expect(project.errors.messages[:namespace].first).to eq(""is not valid"")
      end
    end
  end

  describe 'after create actions' do
    it 'invalidate personal_projects_count caches' do
      expect(Rails.cache).to receive(:delete).with(['users', user.id, 'personal_projects_count'])

      create_project(user, opts)
    end

    it 'creates associated project settings' do
      project = create_project(user, opts)

      expect(project.project_setting).to be_persisted
    end

    it_behaves_like 'storing arguments in the application context' do
      let(:expected_params) { { project: subject.full_path } }

      subject { create_project(user, opts) }
    end

    it 'logs creation' do
      expect(Gitlab::AppLogger).to receive(:info).with(/#{user.name} created a new project/)

      create_project(user, opts)
    end

    it 'publishes a ProjectCreatedEvent' do
      group = create(:group, :nested).tap do |group|
        group.add_owner(user)
      end

      expect { create_project(user, name: 'Project', path: 'project', namespace_id: group.id) }
        .to publish_event(Projects::ProjectCreatedEvent)
        .with(
          project_id: kind_of(Numeric),
          namespace_id: group.id,
          root_namespace_id: group.parent_id
        )
    end
  end

  context ""admin creates project with other user's namespace_id"" do
    context 'when admin mode is enabled', :enable_admin_mode do
      it 'sets the correct permissions' do
        admin = create(:admin)
        project = create_project(admin, opts)

        expect(project).to be_persisted
        expect(project.owner).to eq(user)
        expect(project.first_owner).to eq(user)
        expect(project.team.owners).to contain_exactly(user)
        expect(project.namespace).to eq(user.namespace)
        expect(project.project_namespace).to be_in_sync_with_project(project)
      end
    end

    context 'when admin mode is disabled' do
      it 'is not allowed' do
        admin = create(:admin)
        project = create_project(admin, opts)

        expect(project).not_to be_persisted
        expect(project.project_namespace).to be_in_sync_with_project(project)
      end
    end
  end

  context 'group namespace' do
    let(:group) do
      create(:group).tap do |group|
        group.add_owner(user)
      end
    end

    before do
      user.refresh_authorized_projects # Ensure cache is warm
    end

    subject(:project) { create_project(user, opts.merge!(namespace_id: group.id)) }

    shared_examples 'has sync-ed traversal_ids' do
      specify { expect(project.reload.project_namespace.traversal_ids).to eq([project.namespace.traversal_ids, project.project_namespace.id].flatten.compact) }
    end

    it 'creates the project' do
      expect(project).to be_valid
      expect(project.owner).to eq(group)
      expect(project.namespace).to eq(group)
      expect(project.team.owners).to include(user)
      expect(user.authorized_projects).to include(project)
      expect(project.project_namespace).to be_in_sync_with_project(project)
    end

    it_behaves_like 'has sync-ed traversal_ids'

    context 'when project is an import' do
      before do
        stub_application_setting(import_sources: ['gitlab_project'])
      end

      context 'when user is not allowed to import projects' do
        let(:group) do
          create(:group).tap do |group|
            group.add_developer(user)
          end
        end

        it 'does not create the project' do
          project = create_project(user, opts.merge!(namespace_id: group.id, import_type: 'gitlab_project'))

          expect(project).not_to be_persisted
          expect(project.errors.messages[:user].first).to eq('is not allowed to import projects')
        end
      end
    end
  end

  context 'group sharing', :sidekiq_inline do
    let_it_be(:group) { create(:group) }
    let_it_be(:shared_group) { create(:group) }
    let_it_be(:shared_group_user) { create(:user) }

    let(:opts) do
      {
        name: project_name,
        namespace_id: shared_group.id
      }
    end

    before do
      create(:group_group_link, shared_group: shared_group, shared_with_group: group)

      shared_group.add_maintainer(shared_group_user)
      group.add_developer(user)
    end

    it 'updates authorization' do
      shared_group_project = create_project(shared_group_user, opts)

      expect(
        Ability.allowed?(shared_group_user, :read_project, shared_group_project)
      ).to be_truthy
      expect(
        Ability.allowed?(user, :read_project, shared_group_project)
      ).to be_truthy
    end
  end

  context 'user with project limit' do
    let_it_be(:user_with_projects_limit) { create(:user, projects_limit: 0) }

    let(:params) { opts.merge!(namespace_id: target_namespace.id) }

    subject(:project) { create_project(user_with_projects_limit, params) }

    context 'under personal namespace' do
      let(:target_namespace) { user_with_projects_limit.namespace }

      it 'cannot create a project' do
        expect(project.errors.errors.length).to eq 1
        expect(project.errors.messages[:limit_reached].first).to eq(_('You cannot create projects in your personal namespace. Contact your GitLab administrator.'))
      end
    end

    context 'under group namespace' do
      let_it_be(:group) do
        create(:group).tap do |group|
          group.add_owner(user_with_projects_limit)
        end
      end

      let(:target_namespace) { group }

      it 'can create a project' do
        expect(project).to be_valid
        expect(project).to be_saved
        expect(project.errors.errors.length).to eq 0
      end
    end
  end

  context 'membership overrides', :sidekiq_inline do
    let_it_be(:group) { create(:group, :private) }
    let_it_be(:subgroup_for_projects) { create(:group, :private, parent: group) }
    let_it_be(:subgroup_for_access) { create(:group, :private, parent: group) }
    let_it_be(:group_maintainer) { create(:user) }

    let(:group_access_level) { Gitlab::Access::REPORTER }
    let(:subgroup_access_level) { Gitlab::Access::DEVELOPER }
    let(:share_max_access_level) { Gitlab::Access::MAINTAINER }
    let(:opts) do
      {
        name: project_name,
        namespace_id: subgroup_for_projects.id
      }
    end

    before do
      group.add_maintainer(group_maintainer)

      create(
        :group_group_link,
        shared_group: subgroup_for_projects,
        shared_with_group: subgroup_for_access,
        group_access: share_max_access_level
      )
    end

    context 'membership is higher from group hierarchy' do
      let(:group_access_level) { Gitlab::Access::MAINTAINER }

      it 'updates authorization' do
        create(:group_member, access_level: subgroup_access_level, group: subgroup_for_access, user: user)
        create(:group_member, access_level: group_access_level, group: group, user: user)

        subgroup_project = create_project(group_maintainer, opts)

        project_authorization = ProjectAuthorization.where(
          project_id: subgroup_project.id,
          user_id: user.id,
          access_level: group_access_level)

        expect(project_authorization).to exist
      end
    end

    context 'membership is higher from group share' do
      let(:subgroup_access_level) { Gitlab::Access::MAINTAINER }

      context 'share max access level is not limiting' do
        it 'updates authorization' do
          create(:group_member, access_level: group_access_level, group: group, user: user)
          create(:group_member, access_level: subgroup_access_level, group: subgroup_for_access, user: user)

          subgroup_project = create_project(group_maintainer, opts)

          project_authorization = ProjectAuthorization.where(
            project_id: subgroup_project.id,
            user_id: user.id,
            access_level: subgroup_access_level)

          expect(project_authorization).to exist
        end
      end

      context 'share max access level is limiting' do
        let(:share_max_access_level) { Gitlab::Access::DEVELOPER }

        it 'updates authorization' do
          create(:group_member, access_level: group_access_level, group: group, user: user)
          create(:group_member, access_level: subgroup_access_level, group: subgroup_for_access, user: user)

          subgroup_project = create_project(group_maintainer, opts)

          project_authorization = ProjectAuthorization.where(
            project_id: subgroup_project.id,
            user_id: user.id,
            access_level: share_max_access_level)

          expect(project_authorization).to exist
        end
      end
    end
  end

  context 'error handling' do
    it 'handles invalid options' do
      opts[:invalid] = 'option'
      expect(create_project(user, opts)).to eq(nil)
    end
  end

  context 'wiki_enabled creates repository directory' do
    context 'wiki_enabled true creates wiki repository directory' do
      it do
        project = create_project(user, opts)

        expect(wiki_repo(project).exists?).to be_truthy
      end
    end

    context 'wiki_enabled false does not create wiki repository directory' do
      it do
        opts[:wiki_enabled] = false
        project = create_project(user, opts)

        expect(wiki_repo(project).exists?).to be_falsey
      end
    end

    def wiki_repo(project)
      relative_path = ProjectWiki.new(project).disk_path + '.git'
      Gitlab::Git::Repository.new(project.repository_storage, relative_path, 'foobar', project.full_path)
    end
  end

  context 'import data' do
    let(:import_data) { { data: { 'test' => 'some data' } } }
    let(:imported_project) { create_project(user, { name: 'test', import_url: 'http://import-url', import_data: import_data }) }

    it 'does not write repository config' do
      expect_next_instance_of(Project) do |project|
        expect(project).not_to receive(:set_full_path)
      end

      imported_project
      expect(imported_project.project_namespace).to be_in_sync_with_project(imported_project)
    end

    it 'stores import data and URL' do
      expect(imported_project.import_data).to be_persisted
      expect(imported_project.import_data.data).to eq(import_data[:data])
      expect(imported_project.import_url).to eq('http://import-url')
    end

    it 'tracks for imported project' do
      imported_project

      expect_snowplow_event(category: described_class.name, action: 'import_project', user: user)
    end

    describe 'import scheduling' do
      context 'when project import type is gitlab project migration' do
        it 'does not schedule project import' do
          opts[:import_type] = 'gitlab_project_migration'

          project = create_project(user, opts)

          expect(project.import_state.status).to eq('none')
        end
      end
    end
  end

  context 'builds_enabled global setting' do
    let(:project) { create_project(user, opts) }

    subject { project.builds_enabled? }

    context 'global builds_enabled false does not enable CI by default' do
      before do
        project.project_feature.update_attribute(:builds_access_level, ProjectFeature::DISABLED)
      end

      it { is_expected.to be_falsey }
    end

    context 'global builds_enabled true does enable CI by default' do
      it { is_expected.to be_truthy }
    end
  end

  context 'default visibility level' do
    let(:group) { create(:group, :private) }

    using RSpec::Parameterized::TableSyntax

    where(:case_name, :group_level, :project_level) do
      [
        ['in public group',   Gitlab::VisibilityLevel::PUBLIC,   Gitlab::VisibilityLevel::INTERNAL],
        ['in internal group', Gitlab::VisibilityLevel::INTERNAL, Gitlab::VisibilityLevel::INTERNAL],
        ['in private group',  Gitlab::VisibilityLevel::PRIVATE,  Gitlab::VisibilityLevel::PRIVATE]
      ]
    end

    with_them do
      before do
        stub_application_setting(default_project_visibility: Gitlab::VisibilityLevel::INTERNAL)
        group.add_developer(user)
        group.update!(visibility_level: group_level)

        opts.merge!(
          name: 'test',
          namespace: group,
          path: 'foo'
        )
      end

      it 'creates project with correct visibility level', :aggregate_failures do
        project = create_project(user, opts)

        expect(project).to respond_to(:errors)
        expect(project.errors).to be_blank
        expect(project.visibility_level).to eq(project_level)
        expect(project).to be_saved
        expect(project).to be_valid
        expect(project.project_namespace).to be_in_sync_with_project(project)
      end
    end
  end

  context 'restricted visibility level' do
    before do
      stub_application_setting(restricted_visibility_levels: [Gitlab::VisibilityLevel::PUBLIC])
    end

    shared_examples 'restricted visibility' do
      it 'does not allow a restricted visibility level for non-admins' do
        project = create_project(user, opts)

        expect(project).to respond_to(:errors)
        expect(project.errors.messages).to have_key(:visibility_level)
        expect(project.errors.messages[:visibility_level].first).to(
          match('restricted by your GitLab administrator')
        )
        expect(project.project_namespace).to be_in_sync_with_project(project)
      end

      it 'does not allow a restricted visibility level for admins when admin mode is disabled' do
        admin = create(:admin)
        project = create_project(admin, opts)

        expect(project.errors.any?).to be(true)
        expect(project.saved?).to be_falsey
      end

      it 'allows a restricted visibility level for admins when admin mode is enabled', :enable_admin_mode do
        admin = create(:admin)
        project = create_project(admin, opts)

        expect(project.errors.any?).to be(false)
        expect(project.saved?).to be(true)
      end
    end

    context 'when visibility is project based' do
      before do
        opts.merge!(
          visibility_level: Gitlab::VisibilityLevel::PUBLIC
        )
      end

      include_examples 'restricted visibility'
    end

    context 'when visibility is overridden' do
      let(:visibility) { 'public' }

      before do
        opts.merge!(
          import_data: {
            data: {
              override_params: {
                visibility: visibility
              }
            }
          }
        )
      end

      include_examples 'restricted visibility'

      context 'when visibility is misspelled' do
        let(:visibility) { 'publik' }

        it 'does not restrict project creation' do
          project = create_project(user, opts)

          expect(project.errors.any?).to be(false)
          expect(project.saved?).to be(true)
        end
      end
    end
  end

  context 'repository creation' do
    it 'synchronously creates the repository' do
      expect_next_instance_of(Project) do |instance|
        expect(instance).to receive(:create_repository).and_return(true)
      end

      project = create_project(user, opts)

      expect(project).to be_valid
      expect(project).to be_persisted
      expect(project.owner).to eq(user)
      expect(project.namespace).to eq(user.namespace)
      expect(project.project_namespace).to be_in_sync_with_project(project)
    end

    it 'raises when repository fails to create' do
      expect_next_instance_of(Project) do |instance|
        expect(instance).to receive(:create_repository).and_return(false)
      end

      project = create_project(user, opts)
      expect(project).not_to be_persisted
      expect(project.errors.messages).to have_key(:base)
      expect(project.errors.messages[:base].first).to match('Failed to create repository')
    end

    context 'when another repository already exists on disk' do
      let(:opts) do
        {
          name: 'existing',
          namespace_id: user.namespace.id
        }
      end

      context 'with legacy storage' do
        let(:raw_fake_repo) { Gitlab::Git::Repository.new('default', File.join(user.namespace.full_path, 'existing.git'), nil, nil) }

        before do
          stub_application_setting(hashed_storage_enabled: false)
          raw_fake_repo.create_repository
        end

        after do
          raw_fake_repo.remove
        end

        it 'does not allow to create a project when path matches existing repository on disk' do
          project = create_project(user, opts)

          expect(project).not_to be_persisted
          expect(project).to respond_to(:errors)
          expect(project.errors.messages).to have_key(:base)
          expect(project.errors.messages[:base].first).to match('There is already a repository with that name on disk')
          expect(project.project_namespace).to be_in_sync_with_project(project)
        end

        it 'does not allow to import project when path matches existing repository on disk' do
          project = create_project(user, opts.merge({ import_url: 'https://gitlab.com/gitlab-org/gitlab-test.git' }))

          expect(project).not_to be_persisted
          expect(project).to respond_to(:errors)
          expect(project.errors.messages).to have_key(:base)
          expect(project.errors.messages[:base].first).to match('There is already a repository with that name on disk')
          expect(project.project_namespace).to be_in_sync_with_project(project)
        end
      end

      context 'with hashed storage' do
        let(:hash) { '6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b' }
        let(:hashed_path) { '@hashed/6b/86/6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b' }
        let(:raw_fake_repo) { Gitlab::Git::Repository.new('default', ""#{hashed_path}.git"", nil, nil) }

        before do
          allow(Digest::SHA2).to receive(:hexdigest) { hash }
          raw_fake_repo.create_repository
        end

        after do
          raw_fake_repo.remove
        end

        it 'does not allow to create a project when path matches existing repository on disk' do
          project = create_project(user, opts)

          expect(project).not_to be_persisted
          expect(project).to respond_to(:errors)
          expect(project.errors.messages).to have_key(:base)
          expect(project.errors.messages[:base].first).to match('There is already a repository with that name on disk')
          expect(project.project_namespace).to be_in_sync_with_project(project)
        end
      end
    end
  end

  context 'when readme initialization is requested' do
    let(:project) { create_project(user, opts) }

    before do
      opts[:initialize_with_readme] = '1'
    end

    shared_examples 'a repo with a README.md' do
      it { expect(project.repository.commit_count).to be(1) }
      it { expect(project.repository.readme.name).to eql('README.md') }
      it { expect(project.repository.readme.data).to include(expected_content) }
    end

    it_behaves_like 'a repo with a README.md' do
      let(:expected_content) do
        <<~MARKDOWN
          cd existing_repo
          git remote add origin #{project.http_url_to_repo}
          git branch -M master
          git push -uf origin master
        MARKDOWN
      end
    end

    context 'and a readme_template is specified' do
      before do
        opts[:readme_template] = ""# GitLab\nThis is customized readme.""
      end

      it_behaves_like 'a repo with a README.md' do
        let(:expected_content) { ""# GitLab\nThis is customized readme."" }
      end
    end

    context 'and default_branch is specified' do
      before do
        opts[:default_branch] = 'example_branch'
      end

      it 'creates the correct branch' do
        expect(project.repository.branch_names).to contain_exactly('example_branch')
      end

      it_behaves_like 'a repo with a README.md' do
        let(:expected_content) do
          <<~MARKDOWN
            cd existing_repo
            git remote add origin #{project.http_url_to_repo}
            git branch -M example_branch
            git push -uf origin example_branch
          MARKDOWN
        end
      end
    end

    context 'and the default branch setting is configured' do
      before do
        allow(Gitlab::CurrentSettings).to receive(:default_branch_name).and_return('example_branch')
      end

      it 'creates the correct branch' do
        expect(project.repository.branch_names).to contain_exactly('example_branch')
      end

      it_behaves_like 'a repo with a README.md' do
        let(:expected_content) do
          <<~MARKDOWN
            cd existing_repo
            git remote add origin #{project.http_url_to_repo}
            git branch -M example_branch
            git push -uf origin example_branch
          MARKDOWN
        end
      end
    end
  end

  context 'when SAST initialization is requested' do
    let(:project) { create_project(user, opts) }

    before do
      opts[:initialize_with_sast] = '1'
      allow(Gitlab::CurrentSettings).to receive(:default_branch_name).and_return('main')
    end

    it 'creates a commit for SAST', :aggregate_failures do
      expect(project.repository.commit_count).to be(1)
      expect(project.repository.commit.message).to eq(
        'Configure SAST in `.gitlab-ci.yml`, creating this file if it does not already exist'
      )
    end
  end

  context 'when SHA256 format is requested' do
    let(:project) { create_project(user, opts) }
    let(:opts) { super().merge(initialize_with_readme: true, use_sha256_repository: true) }

    before do
      allow(Gitlab::CurrentSettings).to receive(:default_branch_name).and_return('main')
    end

    it 'creates a repository with SHA256 commit hashes', :aggregate_failures do
      expect(project.repository.commit_count).to be(1)
      expect(project.commit.id.size).to eq 64
    end

    context 'when ""support_sha256_repositories"" feature flag is disabled' do
      before do
        stub_feature_flags(support_sha256_repositories: false)
      end

      it 'creates a repository with default SHA1 commit hash' do
        expect(project.repository.commit_count).to be(1)
        expect(project.commit.id.size).to eq 40
      end
    end
  end

  describe 'create integration for the project' do
    subject(:project) { create_project(user, opts) }

    context 'with an active instance-level integration' do
      let!(:instance_integration) { create(:prometheus_integration, :instance, api_url: 'https://prometheus.instance.com/') }

      it 'creates an integration from the instance-level integration' do
        expect(project.integrations.count).to eq(1)
        expect(project.integrations.first.api_url).to eq(instance_integration.api_url)
        expect(project.integrations.first.inherit_from_id).to eq(instance_integration.id)
      end

      context 'with an active group-level integration' do
        let!(:group_integration) { create(:prometheus_integration, :group, group: group, api_url: 'https://prometheus.group.com/') }
        let!(:group) do
          create(:group).tap do |group|
            group.add_owner(user)
          end
        end

        let(:opts) do
          {
            name: project_name,
            namespace_id: group.id
          }
        end

        it 'creates an integration from the group-level integration' do
          expect(project.integrations.count).to eq(1)
          expect(project.integrations.first.api_url).to eq(group_integration.api_url)
          expect(project.integrations.first.inherit_from_id).to eq(group_integration.id)
        end

        context 'with an active subgroup' do
          let!(:subgroup_integration) { create(:prometheus_integration, :group, group: subgroup, api_url: 'https://prometheus.subgroup.com/') }
          let!(:subgroup) do
            create(:group, parent: group).tap do |subgroup|
              subgroup.add_owner(user)
            end
          end

          let(:opts) do
            {
              name: project_name,
              namespace_id: subgroup.id
            }
          end

          it 'creates an integration from the subgroup-level integration' do
            expect(project.integrations.count).to eq(1)
            expect(project.integrations.first.api_url).to eq(subgroup_integration.api_url)
            expect(project.integrations.first.inherit_from_id).to eq(subgroup_integration.id)
          end
        end
      end
    end
  end

  context 'when skip_disk_validation is used' do
    it 'sets the project attribute' do
      opts[:skip_disk_validation] = true
      project = create_project(user, opts)

      expect(project.skip_disk_validation).to be_truthy
    end
  end

  it 'calls the passed block' do
    fake_block = double('block')
    opts[:relations_block] = fake_block

    expect_next_instance_of(Project) do |project|
      expect(fake_block).to receive(:call).with(project)
    end

    create_project(user, opts)
  end

  it 'writes project full path to gitaly' do
    project = create_project(user, opts)

    expect(project.repository.full_path).to eq project.full_path
  end

  it 'triggers PostCreationWorker' do
    expect(Projects::PostCreationWorker).to receive(:perform_async).with(a_kind_of(Integer))

    create_project(user, opts)
  end

  context 'when import source is enabled' do
    before do
      stub_application_setting(import_sources: ['github'])
    end

    it 'does not raise an error when import_source is string' do
      opts[:import_type] = 'github'

      project = create_project(user, opts)

      expect(project).to be_persisted
      expect(project.errors).to be_blank
    end

    it 'does not raise an error when import_source is symbol' do
      opts[:import_type] = :github

      project = create_project(user, opts)

      expect(project).to be_persisted
      expect(project.errors).to be_blank
    end
  end

  context 'when import source is disabled' do
    before do
      stub_application_setting(import_sources: [])
      opts[:import_type] = 'git'
    end

    it 'raises an error' do
      project = create_project(user, opts)

      expect(project).to respond_to(:errors)
      expect(project.errors).to have_key(:import_source_disabled)
      expect(project.saved?).to be_falsey
    end
  end

  context 'with external authorization enabled' do
    before do
      enable_external_authorization_service_check
    end

    it 'does not save the project with an error if the service denies access' do
      expect(::Gitlab::ExternalAuthorization)
        .to receive(:access_allowed?).with(user, 'new-label', any_args) { false }

      project = create_project(user, opts.merge({ external_authorization_classification_label: 'new-label' }))

      expect(project.errors[:external_authorization_classification_label]).to be_present
      expect(project).not_to be_persisted
    end

    it 'saves the project when the user has access to the label' do
      expect(::Gitlab::ExternalAuthorization)
        .to receive(:access_allowed?).with(user, 'new-label', any_args) { true }.at_least(1).time

      project = create_project(user, opts.merge({ external_authorization_classification_label: 'new-label' }))

      expect(project).to be_persisted
      expect(project.external_authorization_classification_label).to eq('new-label')
    end

    it 'does not save the project when the user has no access to the default label and no label is provided' do
      expect(::Gitlab::ExternalAuthorization)
        .to receive(:access_allowed?).with(user, 'default_label', any_args) { false }

      project = create_project(user, opts)

      expect(project.errors[:external_authorization_classification_label]).to be_present
      expect(project).not_to be_persisted
    end
  end

  context 'with specialized project_authorization workers' do
    let_it_be(:other_user) { create(:user) }
    let_it_be(:group) { create(:group) }

    let(:opts) do
      {
        name: project_name,
        namespace_id: group.id
      }
    end

    before do
      group.add_maintainer(user)
      group.add_developer(other_user)
    end

    it 'updates authorization for current_user' do
      project = create_project(user, opts)

      expect(
        Ability.allowed?(user, :read_project, project)
      ).to be_truthy
    end

    it 'schedules authorization update for users with access to group', :sidekiq_inline do
      stub_feature_flags(do_not_run_safety_net_auth_refresh_jobs: false)

      expect(AuthorizedProjectsWorker).not_to(
        receive(:bulk_perform_async)
      )
      expect(AuthorizedProjectUpdate::ProjectRecalculateWorker).to(
        receive(:perform_async).and_call_original
      )
      expect(AuthorizedProjectUpdate::UserRefreshFromReplicaWorker).to(
        receive(:bulk_perform_in).with(
          1.hour,
          array_including([user.id], [other_user.id]),
          batch_delay: 30.seconds, batch_size: 100
        ).and_call_original
      )

      project = create_project(user, opts)

      expect(
        Ability.allowed?(other_user, :developer_access, project)
      ).to be_truthy
    end
  end

  def create_project(user, opts)
    Projects::CreateService.new(user, opts).execute
  end

  context 'shared Runners config' do
    using RSpec::Parameterized::TableSyntax

    let_it_be(:user) { create :user }

    context 'when parent group is present' do
      let_it_be(:group, reload: true) do
        create(:group) do |group|
          group.add_owner(user)
        end
      end

      before do
        group.update!(shared_runners_enabled: shared_runners_enabled,
          allow_descendants_override_disabled_shared_runners: allow_to_override)

        user.refresh_authorized_projects # Ensure cache is warm
      end

      context 'default value based on parent group setting' do
        where(:shared_runners_enabled, :allow_to_override, :desired_config_for_new_project, :expected_result_for_project) do
          true  | false | nil | true
          false | true  | nil | false
          false | false | nil | false
        end

        with_them do
          it 'creates project following the parent config' do
            params = opts.merge(namespace_id: group.id)
            params = params.merge(shared_runners_enabled: desired_config_for_new_project) unless desired_config_for_new_project.nil?
            project = create_project(user, params)

            expect(project).to be_valid
            expect(project.shared_runners_enabled).to eq(expected_result_for_project)
            expect(project.project_namespace).to be_in_sync_with_project(project)
          end
        end
      end

      context 'parent group is present and allows desired config' do
        where(:shared_runners_enabled, :allow_to_override, :desired_config_for_new_project, :expected_result_for_project) do
          true  | false | true  | true
          true  | false | false | false
          false | true  | false | false
          false | true  | true  | true
          false | false | false | false
        end

        with_them do
          it 'creates project following the parent config' do
            params = opts.merge(namespace_id: group.id, shared_runners_enabled: desired_config_for_new_project)
            project = create_project(user, params)

            expect(project).to be_valid
            expect(project.shared_runners_enabled).to eq(expected_result_for_project)
            expect(project.project_namespace).to be_in_sync_with_project(project)
          end
        end
      end

      context 'parent group is present and disallows desired config' do
        where(:shared_runners_enabled, :allow_to_override, :desired_config_for_new_project) do
          false | false | true
        end

        with_them do
          it 'does not create project' do
            params = opts.merge(namespace_id: group.id, shared_runners_enabled: desired_config_for_new_project)
            project = create_project(user, params)

            expect(project.persisted?).to eq(false)
            expect(project).to be_invalid
            expect(project.errors[:shared_runners_enabled]).to include('cannot be enabled because parent group does not allow it')
            expect(project.project_namespace).to be_in_sync_with_project(project)
          end
        end
      end
    end

    context 'parent group is not present' do
      where(:desired_config, :expected_result) do
        true  | true
        false | false
        nil   | true
      end

      with_them do
        it 'follows desired config' do
          opts[:shared_runners_enabled] = desired_config unless desired_config.nil?
          project = create_project(user, opts)

          expect(project).to be_valid
          expect(project.shared_runners_enabled).to eq(expected_result)
          expect(project.project_namespace).to be_in_sync_with_project(project)
        end
      end
    end
  end

  context 'when using access_level params' do
    def expect_not_disabled_features(project, exclude: [])
      ProjectFeature::FEATURES.excluding(exclude)
        .excluding(project.project_feature.send(:feature_validation_exclusion))
        .each do |feature|
          expect(project.project_feature.public_send(ProjectFeature.access_level_attribute(feature))).not_to eq(Featurable::DISABLED)
        end
    end

    # repository is tested on its own below because it requires other features to be set as well
    # package_registry has different behaviour and is modified from the model based on other attributes
    ProjectFeature::FEATURES.excluding(:repository, :package_registry).each do |feature|
      it ""when using #{feature}"", :aggregate_failures do
        feature_attribute = ProjectFeature.access_level_attribute(feature)
        opts[feature_attribute] = ProjectFeature.str_from_access_level(Featurable::DISABLED)
        project = create_project(user, opts)

        expect(project).to be_valid
        expect(project.project_feature.public_send(feature_attribute)).to eq(Featurable::DISABLED)

        expect_not_disabled_features(project, exclude: [feature])
      end
    end

    it 'when using repository', :aggregate_failures do
      # model validation will fail if builds or merge_requests have higher visibility than repository
      disabled = ProjectFeature.str_from_access_level(Featurable::DISABLED)
      opts[:repository_access_level] = disabled
      opts[:builds_access_level] = disabled
      opts[:merge_requests_access_level] = disabled
      project = create_project(user, opts)

      expect(project).to be_valid
      expect(project.project_feature.repository_access_level).to eq(Featurable::DISABLED)
      expect(project.project_feature.builds_access_level).to eq(Featurable::DISABLED)
      expect(project.project_feature.merge_requests_access_level).to eq(Featurable::DISABLED)

      expect_not_disabled_features(project, exclude: [:repository, :builds, :merge_requests])
    end
  end

  it 'adds pages unique domain', feature_category: :pages do
    stub_pages_setting(enabled: true)

    expect(Gitlab::Pages)
    .to receive(:add_unique_domain_to)
    .and_call_original

    project = create_project(user, opts)

    expect(project.project_setting.pages_unique_domain_enabled).to eq(true)
    expect(project.project_setting.pages_unique_domain).to be_present
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  # Used by project imports, it removes any potential paths
  # included in an error message that could be stored in the DB
  class ImportErrorFilter
    ERROR_MESSAGE_FILTER = /[^\s]*#{File::SEPARATOR}[^\s]*(?=(\s|\z))/
    FILTER_MESSAGE = '[FILTERED]'

    def self.filter_message(message)
      message.gsub(ERROR_MESSAGE_FILTER, FILTER_MESSAGE)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::ImportErrorFilter, feature_category: :importers do
  it 'filters any full paths' do
    message = 'Error importing into /my/folder Permission denied @ unlink_internal - /var/opt/gitlab/gitlab-rails/shared/a/b/c/uploads/file'

    expect(described_class.filter_message(message)).to eq('Error importing into [FILTERED] Permission denied @ unlink_internal - [FILTERED]')
  end

  it 'filters any relative paths ignoring single slash ones' do
    message = 'Error importing into my/project Permission denied @ unlink_internal - ../file/ and folder/../file'

    expect(described_class.filter_message(message)).to eq('Error importing into [FILTERED] Permission denied @ unlink_internal - [FILTERED] and [FILTERED]')
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  module Alerting
    class NotifyService < ::BaseProjectService
      extend ::Gitlab::Utils::Override
      include ::AlertManagement::AlertProcessing
      include ::AlertManagement::Responses

      def initialize(project, params)
        super(project: project, params: params.to_h)
      end

      def execute(token, integration = nil)
        @integration = integration

        return bad_request unless valid_payload_size?
        return forbidden unless active_integration?
        return unauthorized unless valid_token?(token)

        process_alert
        return bad_request unless alert.persisted?

        complete_post_processing_tasks

        success(alert)
      end

      private

      attr_reader :integration
      alias_method :payload, :params

      def valid_payload_size?
        Gitlab::Utils::DeepSize.new(params).valid?
      end

      def active_integration?
        integration&.active?
      end

      def valid_token?(token)
        token == integration.token
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::Alerting::NotifyService, feature_category: :groups_and_projects do
  let_it_be_with_reload(:project) { create(:project) }

  let(:payload) { ActionController::Parameters.new(payload_raw).permit! }
  let(:payload_raw) { {} }

  let(:service) { described_class.new(project, payload) }

  before do
    stub_licensed_features(oncall_schedules: false, generic_alert_fingerprinting: false)
  end

  describe '#execute' do
    include_context 'incident management settings enabled'

    subject { service.execute(token, integration) }

    context 'with HTTP integration' do
      let_it_be_with_reload(:integration) { create(:alert_management_http_integration, project: project) }

      context 'with valid token' do
        let(:token) { integration.token }

        context 'with valid payload' do
          let_it_be(:environment) { create(:environment, project: project) }
          let_it_be(:fingerprint) { 'testing' }
          let_it_be(:source) { 'GitLab RSpec' }
          let_it_be(:starts_at) { Time.current.change(usec: 0) }

          let(:ended_at) { nil }
          let(:domain) { 'operations' }
          let(:payload_raw) do
            {
              title: 'alert title',
              start_time: starts_at.rfc3339,
              end_time: ended_at&.rfc3339,
              severity: 'low',
              monitoring_tool: source,
              service: 'GitLab Test Suite',
              description: 'Very detailed description',
              hosts: ['1.1.1.1', '2.2.2.2'],
              fingerprint: fingerprint,
              gitlab_environment_name: environment.name
            }.with_indifferent_access
          end

          let(:last_alert_attributes) do
            AlertManagement::Alert.last.attributes
              .except('id', 'iid', 'created_at', 'updated_at')
              .with_indifferent_access
          end

          it_behaves_like 'processes new firing alert'
          it_behaves_like 'properly assigns the alert properties'
          include_examples 'handles race condition in alert creation'

          it 'passes the integration to alert processing' do
            expect(Gitlab::AlertManagement::Payload)
              .to receive(:parse)
              .with(project, payload.to_h, integration: integration)
              .and_call_original

            subject
          end

          context 'with partial payload' do
            let_it_be(:source) { integration.name }
            let_it_be(:payload_raw) do
              {
                title: 'alert title',
                start_time: starts_at.rfc3339
              }
            end

            include_examples 'processes never-before-seen alert'

            it 'assigns the alert properties' do
              subject

              expect(last_alert_attributes).to match(
                project_id: project.id,
                title: payload_raw.fetch(:title),
                started_at: Time.zone.parse(payload_raw.fetch(:start_time)),
                severity: 'critical',
                status: AlertManagement::Alert.status_value(:triggered),
                events: 1,
                hosts: [],
                domain: 'operations',
                payload: payload_raw.with_indifferent_access,
                issue_id: nil,
                description: nil,
                monitoring_tool: nil,
                service: nil,
                fingerprint: nil,
                ended_at: nil,
                prometheus_alert_id: nil,
                environment_id: nil
              )
            end

            context 'with existing alert with matching payload' do
              let_it_be(:fingerprint) { payload_raw.except(:start_time).stringify_keys }
              let_it_be(:gitlab_fingerprint) { Gitlab::AlertManagement::Fingerprint.generate(fingerprint) }
              let_it_be(:alert) { create(:alert_management_alert, project: project, fingerprint: gitlab_fingerprint) }

              include_examples 'processes never-before-seen alert'
            end
          end

          context 'with resolving payload' do
            let(:ended_at) { Time.current.change(usec: 0) }

            it_behaves_like 'processes recovery alert'
          end
        end

        context 'with overlong payload' do
          let(:payload_raw) { { 'the-payload-is-too-big' => true } }

          before do
            stub_const('::Gitlab::Utils::DeepSize::DEFAULT_MAX_DEPTH', 0)
          end

          it_behaves_like 'alerts service responds with an error and takes no actions', :bad_request
        end

        context 'with inactive integration' do
          before do
            integration.update!(active: false)
          end

          it_behaves_like 'alerts service responds with an error and takes no actions', :forbidden
        end
      end

      context 'with invalid token' do
        let(:token) { 'invalid-token' }

        it_behaves_like 'alerts service responds with an error and takes no actions', :unauthorized
      end
    end

    context 'without HTTP integration' do
      let(:integration) { nil }
      let(:token) { nil }

      it_behaves_like 'alerts service responds with an error and takes no actions', :forbidden
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  module ContainerRepository
    class DeleteTagsService < BaseService
      LOG_DATA_BASE = { service_class: self.to_s }.freeze

      def execute(container_repository)
        @container_repository = container_repository

        unless container_expiration_policy?
          return error('access denied') unless can?(current_user, :destroy_container_image, project)
        end

        @tag_names = params[:tags]
        return error('not tags specified') if @tag_names.blank?
        return error('repository importing') if cancel_while_importing?

        delete_tags
      end

      private

      def delete_tags
        delete_service
          .execute
          .tap { |response| log_response(response) }
      end

      def delete_service
        if @container_repository.client.supports_tag_delete?
          ::Projects::ContainerRepository::Gitlab::DeleteTagsService.new(@container_repository, @tag_names)
        else
          ::Projects::ContainerRepository::ThirdParty::DeleteTagsService.new(@container_repository, @tag_names)
        end
      end

      def log_response(response)
        log_data = LOG_DATA_BASE.merge(
          container_repository_id: @container_repository.id,
          project_id: @container_repository.project_id,
          message: 'deleted tags',
          deleted_tags_count: response[:deleted]&.size
        ).compact

        if response[:status] == :success
          log_info(log_data)
        else
          log_data[:message] = response[:message]
          log_error(log_data)
        end
      end

      def cancel_while_importing?
        return true if @container_repository.importing?

        if container_expiration_policy?
          return @container_repository.pre_importing? || @container_repository.pre_import_done?
        end

        false
      end

      def container_expiration_policy?
        params[:container_expiration_policy].present?
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::ContainerRepository::DeleteTagsService, feature_category: :container_registry do
  using RSpec::Parameterized::TableSyntax
  include_context 'container repository delete tags service shared context'

  let(:service) { described_class.new(project, user, params) }

  let_it_be(:available_service_classes) do
    [
      ::Projects::ContainerRepository::Gitlab::DeleteTagsService,
      ::Projects::ContainerRepository::ThirdParty::DeleteTagsService
    ]
  end

  shared_examples 'logging a success response' do
    it 'logs an info message' do
      expect(service).to receive(:log_info).with(
        {
          service_class: 'Projects::ContainerRepository::DeleteTagsService',
          message: 'deleted tags',
          container_repository_id: repository.id,
          project_id: repository.project_id,
          deleted_tags_count: tags.size
        }
      )

      subject
    end
  end

  shared_examples 'logging an error response' do |message: 'could not delete tags', extra_log: {}|
    it 'logs an error message' do
      log_data = {
          service_class: 'Projects::ContainerRepository::DeleteTagsService',
          message: message,
          container_repository_id: repository.id,
          project_id: repository.project_id
      }

      log_data.merge!(extra_log) if extra_log.any?

      expect(service).to receive(:log_error).with(log_data)

      subject
    end
  end

  shared_examples 'calling the correct delete tags service' do |expected_service_class|
    let(:service_response) { { status: :success, deleted: tags } }
    let(:excluded_service_class) { available_service_classes.excluding(expected_service_class).first }

    before do
      service_double = double
      expect(expected_service_class).to receive(:new).with(repository, tags).and_return(service_double)
      expect(excluded_service_class).not_to receive(:new)
      expect(service_double).to receive(:execute).and_return(service_response)
    end

    it { is_expected.to include(status: :success) }

    it_behaves_like 'logging a success response'

    context 'with an error service response' do
      let(:service_response) { { status: :error, message: 'could not delete tags' } }

      it { is_expected.to include(status: :error) }

      it_behaves_like 'logging an error response'
    end
  end

  shared_examples 'handling invalid params' do
    context 'with invalid params' do
      before do
        expect(::Projects::ContainerRepository::Gitlab::DeleteTagsService).not_to receive(:new)
        expect(::Projects::ContainerRepository::ThirdParty::DeleteTagsService).not_to receive(:new)
        expect_any_instance_of(ContainerRegistry::Client).not_to receive(:delete_repository_tag_by_digest)
      end

      context 'when no params are specified' do
        let_it_be(:params) { {} }

        it { is_expected.to include(status: :error) }
      end

      context 'with empty tags' do
        let_it_be(:tags) { [] }

        it { is_expected.to include(status: :error) }
      end
    end
  end

  shared_examples 'supporting fast delete' do
    context 'when the registry supports fast delete' do
      before do
        allow(repository.client).to receive(:supports_tag_delete?).and_return(true)
      end

      it_behaves_like 'calling the correct delete tags service', ::Projects::ContainerRepository::Gitlab::DeleteTagsService

      it_behaves_like 'handling invalid params'

      context 'with the real service' do
        before do
          stub_delete_reference_requests(tags)
          expect_delete_tags(tags)
        end

        it { is_expected.to include(status: :success) }

        it_behaves_like 'logging a success response'
      end

      context 'with a timeout error' do
        before do
          expect_next_instance_of(::Projects::ContainerRepository::Gitlab::DeleteTagsService) do |delete_service|
            expect(delete_service).to receive(:delete_tags).and_raise(::Projects::ContainerRepository::Gitlab::DeleteTagsService::TimeoutError)
          end
        end

        it { is_expected.to include(status: :error, message: 'error while deleting tags') }

        it_behaves_like 'logging an error response', message: 'error while deleting tags', extra_log: { deleted_tags_count: 0 }
      end
    end
  end

  describe '#execute' do
    let(:tags) { %w[A Ba] }

    subject { service.execute(repository) }

    context 'without permissions' do
      it { is_expected.to include(status: :error) }
    end

    context 'with permissions' do
      before do
        project.add_developer(user)
      end

      it_behaves_like 'supporting fast delete'

      context 'when the registry does not support fast delete' do
        before do
          allow(repository.client).to receive(:supports_tag_delete?).and_return(false)
        end

        it_behaves_like 'calling the correct delete tags service', ::Projects::ContainerRepository::ThirdParty::DeleteTagsService

        it_behaves_like 'handling invalid params'
      end

      context 'when the repository is importing' do
        where(:migration_state, :called_by_policy, :error_expected) do
          'default'         | false | false
          'default'         | true  | false
          'pre_importing'   | false | false
          'pre_importing'   | true  | true
          'pre_import_done' | false | false
          'pre_import_done' | true  | true
          'importing'       | false | true
          'importing'       | true  | true
          'import_done'     | false | false
          'import_done'     | true  | false
          'import_aborted'  | false | false
          'import_aborted'  | true  | false
          'import_skipped'  | false | false
          'import_skipped'  | true  | false
        end

        with_them do
          let(:params) { { tags: tags, container_expiration_policy: called_by_policy ? true : nil } }

          before do
            repository.update_columns(migration_state: migration_state, migration_import_started_at: Time.zone.now, migration_pre_import_started_at: Time.zone.now, migration_pre_import_done_at: Time.zone.now)
          end

          it 'returns an error response if expected' do
            if error_expected
              expect(subject).to include(status: :error, message: 'repository importing')
            else
              expect(service).to receive(:delete_tags).and_return(status: :success)
              expect(subject).not_to include(status: :error)
            end
          end
        end
      end
    end

    context 'without user' do
      let_it_be(:user) { nil }

      context 'when not run by a cleanup policy' do
        it { is_expected.to include(status: :error) }
      end

      context 'when run by a cleanup policy' do
        let(:params) { { tags: tags, container_expiration_policy: true } }

        it_behaves_like 'supporting fast delete'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  module ContainerRepository
    class CleanupTagsService < BaseContainerRepositoryService
      def execute
        return error('access denied') unless can_destroy?
        return error('invalid regex') unless valid_regex?

        cleanup_tags_service_class.new(container_repository: container_repository, current_user: current_user, params: params)
                                  .execute
      end

      private

      def cleanup_tags_service_class
        log_data = {
          container_repository_id: container_repository.id,
          container_repository_path: container_repository.path,
          project_id: project.id
        }

        if use_gitlab_service?
          log_info(log_data.merge(gitlab_cleanup_tags_service: true))
          ::Projects::ContainerRepository::Gitlab::CleanupTagsService
        else
          log_info(log_data.merge(third_party_cleanup_tags_service: true))
          ::Projects::ContainerRepository::ThirdParty::CleanupTagsService
        end
      end

      def use_gitlab_service?
        container_repository.migrated? &&
          container_repository.gitlab_api_client.supports_gitlab_api?
      end

      def can_destroy?
        return true if container_expiration_policy

        can?(current_user, :destroy_container_image, project)
      end

      def valid_regex?
        %w[name_regex_delete name_regex name_regex_keep].each do |param_name|
          regex = params[param_name]
          ::Gitlab::UntrustedRegexp.new(regex) unless regex.blank?
        end
        true
      rescue RegexpError => e
        ::Gitlab::ErrorTracking.log_exception(e, project_id: project.id)
        false
      end

      def container_expiration_policy
        params['container_expiration_policy']
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::ContainerRepository::CleanupTagsService, feature_category: :container_registry do
  let_it_be_with_reload(:container_repository) { create(:container_repository) }
  let_it_be(:user) { container_repository.project.owner }

  let(:params) { {} }
  let(:extra_params) { {} }
  let(:service) { described_class.new(container_repository: container_repository, current_user: user, params: params.merge(extra_params)) }

  before do
    stub_container_registry_config(enabled: true)
  end

  describe '#execute' do
    subject { service.execute }

    shared_examples 'returning error message' do |message|
      it ""returns error #{message}"" do
        expect(::Projects::ContainerRepository::Gitlab::CleanupTagsService).not_to receive(:new)
        expect(::Projects::ContainerRepository::ThirdParty::CleanupTagsService).not_to receive(:new)
        expect(service).not_to receive(:log_info)

        expect(subject).to eq(status: :error, message: message)
      end
    end

    shared_examples 'handling invalid regular expressions' do
      shared_examples 'handling invalid regex' do
        it_behaves_like 'returning error message', 'invalid regex'

        it 'calls error tracking service' do
          expect(::Gitlab::ErrorTracking).to receive(:log_exception).and_call_original

          subject
        end
      end

      context 'when name_regex_delete is invalid' do
        let(:extra_params) { { 'name_regex_delete' => '*test*' } }

        it_behaves_like 'handling invalid regex'
      end

      context 'when name_regex is invalid' do
        let(:extra_params) { { 'name_regex' => '*test*' } }

        it_behaves_like 'handling invalid regex'
      end

      context 'when name_regex_keep is invalid' do
        let(:extra_params) { { 'name_regex_keep' => '*test*' } }

        it_behaves_like 'handling invalid regex'
      end
    end

    shared_examples 'handling all types of container repositories' do
      shared_examples 'calling service' do |service_class, extra_log_data: {}|
        let(:service_double) { instance_double(service_class.to_s) }

        it ""uses cleanup tags service #{service_class}"" do
          expect(service_class).to receive(:new).with(container_repository: container_repository, current_user: user, params: params).and_return(service_double)
          expect(service_double).to receive(:execute).and_return('return value')
          expect(service).to receive(:log_info)
                               .with(
                                 {
                                   container_repository_id: container_repository.id,
                                   container_repository_path: container_repository.path,
                                   project_id: container_repository.project.id
                                 }.merge(extra_log_data))
          expect(subject).to eq('return value')
        end
      end

      context 'with a migrated repository' do
        before do
          allow(container_repository).to receive(:migrated?).and_return(true)
        end

        context 'supporting the gitlab api' do
          before do
            allow(container_repository.gitlab_api_client).to receive(:supports_gitlab_api?).and_return(true)
          end

          it_behaves_like 'calling service', ::Projects::ContainerRepository::Gitlab::CleanupTagsService, extra_log_data: { gitlab_cleanup_tags_service: true }
        end

        context 'not supporting the gitlab api' do
          before do
            allow(container_repository.gitlab_api_client).to receive(:supports_gitlab_api?).and_return(false)
          end

          it_behaves_like 'calling service', ::Projects::ContainerRepository::ThirdParty::CleanupTagsService, extra_log_data: { third_party_cleanup_tags_service: true }
        end
      end

      context 'with a non migrated repository' do
        before do
          allow(container_repository).to receive(:migrated?).and_return(false)
        end

        it_behaves_like 'calling service', ::Projects::ContainerRepository::ThirdParty::CleanupTagsService, extra_log_data: { third_party_cleanup_tags_service: true }
      end
    end

    context 'with valid user' do
      it_behaves_like 'handling invalid regular expressions'
      it_behaves_like 'handling all types of container repositories'
    end

    context 'for container expiration policy' do
      let(:user) { nil }
      let(:params) { { 'container_expiration_policy' => true } }

      it_behaves_like 'handling invalid regular expressions'
      it_behaves_like 'handling all types of container repositories'
    end

    context 'with not allowed user' do
      let_it_be(:user) { create(:user) }

      it_behaves_like 'returning error message', 'access denied'
    end

    context 'with no user' do
      let(:user) { nil }

      it_behaves_like 'returning error message', 'access denied'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  module ContainerRepository
    class DestroyService < BaseService
      CLEANUP_TAGS_SERVICE_PARAMS = {
        'name_regex_delete' => '.*',
        'container_expiration_policy' => true, # to avoid permissions checks
        'keep_latest' => false
      }.freeze

      def execute(container_repository, disable_timeout: true)
        return error('Unauthorized access') unless can_destroy?

        # Delete tags outside of the transaction to avoid hitting an idle-in-transaction timeout
        if delete_tags(container_repository, disable_timeout) &&
            destroy_container_repository(container_repository)
          success
        else
          container_repository.delete_failed!
          error('Deletion failed for container repository')
        end
      end

      private

      def delete_tags(container_repository, disable_timeout)
        service = Projects::ContainerRepository::CleanupTagsService.new(
          container_repository: container_repository,
          params: CLEANUP_TAGS_SERVICE_PARAMS.merge('disable_timeout' => disable_timeout)
        )
        result = service.execute
        return true if result[:status] == :success

        log_error(error_message(container_repository, 'error in deleting tags'))
        false
      end

      def destroy_container_repository(container_repository)
        return true if container_repository.destroy

        log_error(error_message(container_repository, container_repository.errors.full_messages.join('. ')))
        false
      end

      def can_destroy?
        return true if skip_permission_check?

        can?(current_user, :destroy_container_image, project)
      end

      def error_message(container_repository, message)
        ""Container repository with ID: #{container_repository.id} and path: #{container_repository.path} "" \
          ""failed with message: #{message}""
      end

      def skip_permission_check?
        !!params[:skip_permission_check]
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::ContainerRepository::DestroyService, feature_category: :container_registry do
  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project, :private) }
  let_it_be(:params) { {} }

  subject { described_class.new(project, user, params) }

  before do
    stub_container_registry_config(enabled: true)
  end

  shared_examples 'returning an error status with message' do |error_message|
    it 'returns an error status' do
      response = subject.execute(repository)

      expect(response).to include(status: :error, message: error_message)
    end
  end

  shared_examples 'executing with permissions' do
    let_it_be_with_refind(:repository) { create(:container_repository, :root, project: project) }

    before do
      stub_container_registry_tags(repository: :any, tags: %w[latest stable])
    end

    it 'deletes the repository' do
      expect_cleanup_tags_service_with(container_repository: repository, return_status: :success)
      expect { subject.execute(repository) }.to change { ContainerRepository.count }.by(-1)
    end

    it 'sends disable_timeout = true as part of the params as default' do
      expect_cleanup_tags_service_with(container_repository: repository, return_status: :success, disable_timeout: true)
      expect { subject.execute(repository) }.to change { ContainerRepository.count }.by(-1)
    end

    it 'sends disable_timeout = false as part of the params if it is set to false' do
      expect_cleanup_tags_service_with(container_repository: repository, return_status: :success, disable_timeout: false)
      expect { subject.execute(repository, disable_timeout: false) }.to change { ContainerRepository.count }.by(-1)
    end

    context 'when deleting the tags fails' do
      before do
        expect_cleanup_tags_service_with(container_repository: repository, return_status: :error)
        allow(Gitlab::AppLogger).to receive(:error).and_call_original
      end

      it 'sets status as deleted_failed' do
        subject.execute(repository)

        expect(repository).to be_delete_failed
      end

      it 'logs the error' do
        subject.execute(repository)

        expect(Gitlab::AppLogger).to have_received(:error)
        .with(""Container repository with ID: #{repository.id} and path: #{repository.path} failed with message: error in deleting tags"")
      end

      it_behaves_like 'returning an error status with message', 'Deletion failed for container repository'
    end

    context 'when destroying the repository fails' do
      before do
        expect_cleanup_tags_service_with(container_repository: repository, return_status: :success)
        allow(repository).to receive(:destroy).and_return(false)
        allow(repository.errors).to receive(:full_messages).and_return(['Error 1', 'Error 2'])
        allow(Gitlab::AppLogger).to receive(:error).and_call_original
      end

      it 'sets status as deleted_failed' do
        subject.execute(repository)

        expect(repository).to be_delete_failed
      end

      it 'logs the error' do
        subject.execute(repository)

        expect(Gitlab::AppLogger).to have_received(:error)
        .with(""Container repository with ID: #{repository.id} and path: #{repository.path} failed with message: Error 1. Error 2"")
      end

      it_behaves_like 'returning an error status with message', 'Deletion failed for container repository'
    end
  end

  context 'when user has access to registry' do
    before do
      project.add_developer(user)
    end

    it_behaves_like 'executing with permissions'
  end

  context 'when user does not have access to registry' do
    let_it_be(:repository) { create(:container_repository, :root, project: project) }

    it 'does not delete a repository' do
      expect { subject.execute(repository) }.not_to change { ContainerRepository.count }
    end

    it_behaves_like 'returning an error status with message', 'Unauthorized access'
  end

  context 'when called during project deletion' do
    let(:user) { nil }
    let(:params) { { skip_permission_check: true } }

    it_behaves_like 'executing with permissions'
  end

  context 'when there is no user' do
    let(:user) { nil }
    let(:repository) { create(:container_repository, :root, project: project) }

    it_behaves_like 'returning an error status with message', 'Unauthorized access'
  end

  def expect_cleanup_tags_service_with(container_repository:, return_status:, disable_timeout: true)
    delete_tags_service = instance_double(Projects::ContainerRepository::CleanupTagsService)

    expect(Projects::ContainerRepository::CleanupTagsService).to receive(:new).with(
      container_repository: container_repository,
      params: described_class::CLEANUP_TAGS_SERVICE_PARAMS.merge('disable_timeout' => disable_timeout)
    ).and_return(delete_tags_service)

    expect(delete_tags_service).to receive(:execute).and_return(status: return_status)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  module ContainerRepository
    module Gitlab
      class DeleteTagsService
        include BaseServiceUtility
        include ::Gitlab::Utils::StrongMemoize
        include ::Projects::ContainerRepository::Gitlab::Timeoutable

        def initialize(container_repository, tag_names)
          @container_repository = container_repository
          @tag_names = tag_names
          @deleted_tags = []
        end

        # Delete tags by name with a single DELETE request. This is only supported
        # by the GitLab Container Registry fork. See
        # https://gitlab.com/gitlab-org/gitlab/-/merge_requests/23325 for details.
        def execute
          return success(deleted: []) if @tag_names.empty?

          delete_tags
        rescue TimeoutError, ::Faraday::Error => e
          ::Gitlab::ErrorTracking.track_exception(e, tags_count: @tag_names&.size, container_repository_id: @container_repository&.id)
          error('error while deleting tags', nil, pass_back: { deleted: @deleted_tags, exception_class_name: e.class.name })
        end

        private

        def delete_tags
          start_time = Time.zone.now

          @tag_names.each do |name|
            raise TimeoutError if timeout?(start_time)

            if @container_repository.delete_tag(name)
              @deleted_tags.append(name)
            end
          end

          @deleted_tags.any? ? success(deleted: @deleted_tags) : error(""could not delete tags: #{@tag_names.join(', ')}"".truncate(1000))
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::ContainerRepository::Gitlab::DeleteTagsService, feature_category: :container_registry do
  include_context 'container repository delete tags service shared context'

  let(:service) { described_class.new(repository, tags) }

  describe '#execute' do
    let(:tags) { %w[A Ba] }

    subject { service.execute }

    RSpec.shared_examples 'deleting tags' do
      it 'deletes the tags by name' do
        stub_delete_reference_requests(tags)
        expect_delete_tags(tags)

        is_expected.to eq(status: :success, deleted: tags)
      end
    end

    context 'with tags to delete' do
      let(:timeout) { 10 }

      before do
        stub_application_setting(container_registry_delete_tags_service_timeout: timeout)
      end

      it_behaves_like 'deleting tags'

      it 'succeeds when tag delete returns 404' do
        stub_delete_reference_requests('A' => 200, 'Ba' => 404)

        is_expected.to eq(status: :success, deleted: tags)
      end

      it 'succeeds when a tag delete returns 500' do
        stub_delete_reference_requests('A' => 200, 'Ba' => 500)

        is_expected.to eq(status: :success, deleted: ['A'])
      end

      context 'with failures' do
        context 'when the delete request fails' do
          before do
            stub_delete_reference_requests('A' => 500, 'Ba' => 500)
          end

          it { is_expected.to eq(status: :error, message: ""could not delete tags: #{tags.join(', ')}"") }

          context 'when a large list of tag delete fails' do
            let(:tags) { Array.new(135) { |i| ""tag#{i}"" } }
            let(:container_repository) { instance_double(ContainerRepository) }

            before do
              allow(ContainerRepository).to receive(:find).with(repository).and_return(container_repository)
              tags.each do |tag|
                stub_delete_reference_requests(tag => 500)
              end
              allow(container_repository).to receive(:delete_tag).and_return(false)
            end

            it 'truncates the log message' do
              expect(subject).to eq(status: :error, message: ""could not delete tags: #{tags.join(', ')}"".truncate(1000))
            end
          end
        end
      end

      context 'with timeout' do
        context 'set to a valid value' do
          before do
            allow(service).to receive(:timeout?).and_return(false, true)
            stub_delete_reference_requests('A' => 200)
          end

          it { is_expected.to eq(status: :error, message: 'error while deleting tags', deleted: ['A'], exception_class_name: Projects::ContainerRepository::Gitlab::DeleteTagsService::TimeoutError.name) }

          it 'tracks the exception' do
            expect(::Gitlab::ErrorTracking)
              .to receive(:track_exception).with(::Projects::ContainerRepository::Gitlab::DeleteTagsService::TimeoutError, tags_count: tags.size, container_repository_id: repository.id)

            subject
          end
        end

        context 'set to 0' do
          let(:timeout) { 0 }

          it_behaves_like 'deleting tags'
        end

        context 'set to nil' do
          let(:timeout) { nil }

          it_behaves_like 'deleting tags'
        end
      end

      context 'with a network error' do
        before do
          expect(service).to receive(:delete_tags).and_raise(::Faraday::TimeoutError)
        end

        it { is_expected.to eq(status: :error, message: 'error while deleting tags', deleted: [], exception_class_name: ::Faraday::TimeoutError.name) }

        it 'tracks the exception' do
          expect(::Gitlab::ErrorTracking)
            .to receive(:track_exception).with(::Faraday::TimeoutError, tags_count: tags.size, container_repository_id: repository.id)

          subject
        end
      end
    end

    context 'with empty tags' do
      let_it_be(:tags) { [] }

      it 'does not remove anything' do
        expect_any_instance_of(ContainerRegistry::Client).not_to receive(:delete_repository_tag_by_digest)

        is_expected.to eq(status: :success, deleted: [])
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  module ContainerRepository
    module Gitlab
      class CleanupTagsService < CleanupTagsBaseService
        include ::Projects::ContainerRepository::Gitlab::Timeoutable

        TAGS_PAGE_SIZE = 1000

        def initialize(container_repository:, current_user: nil, params: {})
          super
          @params = params.dup
        end

        def execute
          with_timeout do |start_time, result|
            container_repository.each_tags_page(page_size: TAGS_PAGE_SIZE) do |tags|
              execute_for_tags(tags, result)

              raise TimeoutError if !timeout_disabled? && timeout?(start_time)
            end
          end
        end

        private

        def execute_for_tags(tags, overall_result)
          original_size = tags.size

          filter_out_latest!(tags)
          filter_by_name!(tags)

          tags = filter_by_keep_n(tags)
          tags = filter_by_older_than(tags)

          overall_result[:before_delete_size] += tags.size
          overall_result[:original_size] += original_size

          result = delete_tags(tags)

          overall_result[:deleted_size] += result[:deleted]&.size
          overall_result[:deleted] += result[:deleted]
          overall_result[:status] = result[:status] unless overall_result[:status] == :error
        end

        def with_timeout
          result = success(
            original_size: 0,
            before_delete_size: 0,
            deleted_size: 0,
            deleted: []
          )

          yield Time.zone.now, result

          result
        rescue TimeoutError
          result[:status] = :error

          result
        end

        def filter_by_keep_n(tags)
          partition_by_keep_n(tags).first
        end

        def filter_by_older_than(tags)
          partition_by_older_than(tags).first
        end

        def pushed_at(tag)
          tag.updated_at || tag.created_at
        end

        def timeout_disabled?
          params['disable_timeout'] || false
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::ContainerRepository::Gitlab::CleanupTagsService, feature_category: :container_registry do
  using RSpec::Parameterized::TableSyntax

  include_context 'for a cleanup tags service'

  let_it_be(:user) { create(:user) }
  let_it_be(:user) { create(:user) }
  let_it_be(:project, reload: true) { create(:project, :private) }

  let(:repository) { create(:container_repository, :root, project: project) }
  let(:service) { described_class.new(container_repository: repository, current_user: user, params: params) }
  let(:tags) { %w[latest A Ba Bb C D E] }

  before do
    allow(repository).to receive(:migrated?).and_return(true)

    project.add_maintainer(user) if user

    stub_container_registry_config(enabled: true)

    stub_const(""#{described_class}::TAGS_PAGE_SIZE"", tags_page_size)

    one_hour_ago = 1.hour.ago
    five_days_ago = 5.days.ago
    six_days_ago = 6.days.ago
    one_month_ago = 1.month.ago

    stub_tags(
      {
        'latest' => one_hour_ago,
        'A' => one_hour_ago,
        'Ba' => five_days_ago,
        'Bb' => six_days_ago,
        'C' => one_month_ago,
        'D' => nil,
        'E' => nil
      }
    )
  end

  describe '#execute' do
    subject { service.execute }

    context 'with several tags pages' do
      let(:tags_page_size) { 2 }

      it_behaves_like 'when regex matching everything is specified',
        delete_expectations: [%w[A], %w[Ba Bb], %w[C D], %w[E]]

      it_behaves_like 'when regex matching everything is specified and latest is not kept',
        delete_expectations: [%w[latest A], %w[Ba Bb], %w[C D], %w[E]]

      it_behaves_like 'when delete regex matching specific tags is used'

      it_behaves_like 'when delete regex matching specific tags is used with overriding allow regex'

      it_behaves_like 'with allow regex value',
        delete_expectations: [%w[A], %w[C D], %w[E]]

      it_behaves_like 'when keeping only N tags',
        delete_expectations: [%w[Bb]]

      it_behaves_like 'when not keeping N tags',
        delete_expectations: [%w[A], %w[Ba Bb], %w[C]]

      context 'when removing keeping only 3' do
        let(:params) do
          {
            'name_regex_delete' => '.*',
            'keep_n' => 3
          }
        end

        it_behaves_like 'not removing anything'
      end

      it_behaves_like 'when removing older than 1 day',
        delete_expectations: [%w[Ba Bb], %w[C]]

      it_behaves_like 'when combining all parameters',
        delete_expectations: [%w[Bb], %w[C]]

      it_behaves_like 'when running a container_expiration_policy',
        delete_expectations: [%w[Bb], %w[C]]

      context 'with a timeout' do
        let(:params) do
          { 'name_regex_delete' => '.*' }
        end

        it 'removes the first few pages' do
          expect(service).to receive(:timeout?).and_return(false, true)

          expect_delete(%w[A])
          expect_delete(%w[Ba Bb])

          response = expected_service_response(status: :error, deleted: %w[A Ba Bb], original_size: 4)

          is_expected.to eq(response)
        end

        context 'when disable_timeout is set to true' do
          let(:params) do
            { 'name_regex_delete' => '.*', 'disable_timeout' => true }
          end

          it 'does not check if it timed out' do
            expect(service).not_to receive(:timeout?)
          end

          it_behaves_like 'when regex matching everything is specified',
            delete_expectations: [%w[A], %w[Ba Bb], %w[C D], %w[E]]
        end
      end
    end

    context 'with a single tags page' do
      let(:tags_page_size) { 1000 }

      it_behaves_like 'when regex matching everything is specified',
        delete_expectations: [%w[A Ba Bb C D E]]

      it_behaves_like 'when delete regex matching specific tags is used'

      it_behaves_like 'when delete regex matching specific tags is used with overriding allow regex'

      it_behaves_like 'with allow regex value',
        delete_expectations: [%w[A C D E]]

      it_behaves_like 'when keeping only N tags',
        delete_expectations: [%w[Ba Bb C]]

      it_behaves_like 'when not keeping N tags',
        delete_expectations: [%w[A Ba Bb C]]

      it_behaves_like 'when removing keeping only 3',
        delete_expectations: [%w[Ba Bb C]]

      it_behaves_like 'when removing older than 1 day',
        delete_expectations: [%w[Ba Bb C]]

      it_behaves_like 'when combining all parameters',
        delete_expectations: [%w[Ba Bb C]]

      it_behaves_like 'when running a container_expiration_policy',
        delete_expectations: [%w[Ba Bb C]]
    end

    context 'with no tags page' do
      let(:tags_page_size) { 1000 }
      let(:deleted) { [] }
      let(:params) { {} }

      before do
        allow(repository.gitlab_api_client)
          .to receive(:tags)
          .and_return({})
      end

      it { is_expected.to eq(expected_service_response(status: :success, deleted: [], original_size: 0)) }
    end
  end

  private

  def stub_tags(tags)
    chunked = tags_page_size < tags.size
    previous_last = nil
    max_chunk_index = tags.size / tags_page_size

    tags.keys.in_groups_of(tags_page_size, false).each_with_index do |chunked_tag_names, index|
      last = index == max_chunk_index
      pagination_needed = chunked && !last

      response = {
        pagination: pagination_needed ? pagination_with(last: chunked_tag_names.last) : {},
        response_body: chunked_tag_names.map do |name|
          tag_raw_response(name, tags[name])
        end
      }

      allow(repository.gitlab_api_client)
        .to receive(:tags)
        .with(repository.path, page_size: described_class::TAGS_PAGE_SIZE, last: previous_last)
        .and_return(response)
      previous_last = chunked_tag_names.last
    end
  end

  def pagination_with(last:)
    {
      next: {
        uri: URI(""http://test.org?last=#{last}"")
      }
    }
  end

  def tag_raw_response(name, timestamp)
    timestamp_field = name.start_with?('B') ? 'updated_at' : 'created_at'
    {
      'name' => name,
      'digest' => 'sha256:1234567890',
      'media_type' => 'application/vnd.oci.image.manifest.v1+json',
      timestamp_field => timestamp&.iso8601
    }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  module ContainerRepository
    module ThirdParty
      class DeleteTagsService
        include BaseServiceUtility

        def initialize(container_repository, tag_names)
          @container_repository = container_repository
          @tag_names = tag_names
        end

        # Replace a tag on the registry with a dummy tag.
        # This is a hack as the registry doesn't support deleting individual
        # tags. This code effectively pushes a dummy image and assigns the tag to it.
        # This way when the tag is deleted only the dummy image is affected.
        # This is used to preserve compatibility with third-party registries that
        # don't support fast delete.
        # See https://gitlab.com/gitlab-org/gitlab/issues/15737 for a discussion
        def execute
          return success(deleted: []) if @tag_names.empty?

          # generates the blobs for the dummy image
          dummy_manifest = @container_repository.client.generate_empty_manifest(@container_repository.path)
          return error('could not generate manifest') if dummy_manifest.nil?

          deleted_tags = replace_tag_manifests(dummy_manifest)

          # Deletes the dummy image
          # All created tag digests are the same since they all have the same dummy image.
          # a single delete is sufficient to remove all tags with it
          if deleted_tags.any? && @container_repository.delete_tag(deleted_tags.each_value.first)
            success(deleted: deleted_tags.keys)
          else
            error(""could not delete tags: #{@tag_names.join(', ')}"".truncate(1000))
          end
        end

        private

        # update the manifests of the tags with the new dummy image
        def replace_tag_manifests(dummy_manifest)
          deleted_tags = @tag_names.map do |name|
            digest = @container_repository.client.put_tag(@container_repository.path, name, dummy_manifest)
            next unless digest

            [name, digest]
          end.compact.to_h

          # make sure the digests are the same (it should always be)
          digests = deleted_tags.values.uniq

          # rubocop: disable CodeReuse/ActiveRecord
          Gitlab::ErrorTracking.track_and_raise_for_dev_exception(ArgumentError.new('multiple tag digests')) if digests.many?

          deleted_tags
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::ContainerRepository::ThirdParty::DeleteTagsService, feature_category: :container_registry do
  include_context 'container repository delete tags service shared context'

  let(:service) { described_class.new(repository, tags) }

  describe '#execute' do
    let(:tags) { %w[A Ba] }

    subject { service.execute }

    context 'with tags to delete' do
      it 'deletes the tags by name' do
        stub_upload('sha256:4435000728ee66e6a80e55637fc22725c256b61de344a2ecdeaac6bdb36e8bc3')

        tags.each { |tag| stub_put_manifest_request(tag) }

        expect_delete_tags(['sha256:dummy'])

        is_expected.to eq(status: :success, deleted: tags)
      end

      it 'succeeds when tag delete returns 404' do
        stub_upload('sha256:4435000728ee66e6a80e55637fc22725c256b61de344a2ecdeaac6bdb36e8bc3')

        stub_put_manifest_request('A')
        stub_put_manifest_request('Ba')

        stub_request(:delete, ""http://registry.gitlab/v2/#{repository.path}/manifests/sha256:dummy"")
          .to_return(status: 404, body: '', headers: {})

        is_expected.to eq(status: :success, deleted: tags)
      end

      context 'with failures' do
        context 'when the dummy manifest generation fails' do
          before do
            stub_upload('sha256:4435000728ee66e6a80e55637fc22725c256b61de344a2ecdeaac6bdb36e8bc3', success: false)
          end

          it { is_expected.to eq(status: :error, message: 'could not generate manifest') }
        end

        context 'when updating tags fails' do
          before do
            stub_upload('sha256:4435000728ee66e6a80e55637fc22725c256b61de344a2ecdeaac6bdb36e8bc3')

            stub_request(:delete, ""http://registry.gitlab/v2/#{repository.path}/manifests/sha256:4435000728ee66e6a80e55637fc22725c256b61de344a2ecdeaac6bdb36e8bc3"")
              .to_return(status: 200, body: '', headers: {})
          end

          context 'all tag updates fail' do
            before do
              stub_put_manifest_request('A', 500, {})
              stub_put_manifest_request('Ba', 500, {})
            end

            it { is_expected.to eq(status: :error, message: ""could not delete tags: #{tags.join(', ')}"") }

            context 'when a large list of tag updates fails' do
              let(:tags) { Array.new(1000) { |i| ""tag_#{i}"" } }

              before do
                expect(service).to receive(:replace_tag_manifests).and_return({})
              end

              it 'truncates the log message' do
                expect(subject).to eq(status: :error, message: ""could not delete tags: #{tags.join(', ')}"".truncate(1000))
              end
            end
          end

          context 'a single tag update fails' do
            before do
              stub_put_manifest_request('A')
              stub_put_manifest_request('Ba', 500, {})

              stub_request(:delete, ""http://registry.gitlab/v2/#{repository.path}/manifests/sha256:dummy"")
                .to_return(status: 404, body: '', headers: {})
            end

            it { is_expected.to eq(status: :success, deleted: ['A']) }
          end
        end
      end
    end

    context 'with empty tags' do
      let_it_be(:tags) { [] }

      it 'does not remove anything' do
        expect_any_instance_of(ContainerRegistry::Client).not_to receive(:delete_repository_tag_by_digest)

        is_expected.to eq(status: :success, deleted: [])
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  module ContainerRepository
    module ThirdParty
      class CleanupTagsService < CleanupTagsBaseService
        def initialize(container_repository:, current_user: nil, params: {})
          super

          @params = params.dup
          @counts = { cached_tags_count: 0 }
        end

        def execute
          tags = container_repository.tags
          @counts[:original_size] = tags.size

          filter_out_latest!(tags)
          filter_by_name!(tags)

          tags = truncate(tags)
          populate_from_cache(tags)

          tags = filter_keep_n(tags)
          tags = filter_by_older_than(tags)

          @counts[:before_delete_size] = tags.size

          delete_tags(tags).merge(@counts).tap do |result|
            result[:deleted_size] = result[:deleted]&.size

            result[:status] = :error if @counts[:before_truncate_size] != @counts[:after_truncate_size]
          end
        end

        private

        def filter_keep_n(tags)
          tags, tags_to_keep = partition_by_keep_n(tags)

          cache_tags(tags_to_keep)

          tags
        end

        def filter_by_older_than(tags)
          tags, tags_to_keep = partition_by_older_than(tags)

          cache_tags(tags_to_keep)

          tags
        end

        def pushed_at(tag)
          tag.created_at
        end

        def truncate(tags)
          @counts[:before_truncate_size] = tags.size
          @counts[:after_truncate_size] = tags.size

          return tags if max_list_size == 0

          # truncate the list to make sure that after the #filter_keep_n
          # execution, the resulting list will be max_list_size
          truncated_size = max_list_size + keep_n_as_integer

          return tags if tags.size <= truncated_size

          tags = tags.sample(truncated_size)
          @counts[:after_truncate_size] = tags.size
          tags
        end

        def populate_from_cache(tags)
          @counts[:cached_tags_count] = cache.populate(tags) if caching_enabled?
        end

        def cache_tags(tags)
          cache.insert(tags, older_than_in_seconds) if caching_enabled?
        end

        def cache
          strong_memoize(:cache) do
            ::Gitlab::ContainerRepository::Tags::Cache.new(container_repository)
          end
        end

        def caching_enabled?
          result = current_application_settings.container_registry_expiration_policies_caching &&
            container_expiration_policy &&
            older_than.present?
          !!result
        end

        def max_list_size
          current_application_settings.container_registry_cleanup_tags_service_max_list_size.to_i
        end

        def current_application_settings
          ::Gitlab::CurrentSettings.current_application_settings
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::ContainerRepository::ThirdParty::CleanupTagsService, :clean_gitlab_redis_cache, feature_category: :container_registry do
  using RSpec::Parameterized::TableSyntax

  include_context 'for a cleanup tags service'

  let_it_be(:user) { create(:user) }
  let_it_be(:project, reload: true) { create(:project, :private) }

  let(:repository) { create(:container_repository, :root, project: project) }
  let(:service) { described_class.new(container_repository: repository, current_user: user, params: params) }
  let(:tags) { %w[latest A Ba Bb C D E] }

  before do
    project.add_maintainer(user) if user

    stub_container_registry_config(enabled: true)

    stub_container_registry_tags(
      repository: repository.path,
      tags: tags
    )

    stub_tag_digest('latest', 'sha256:configA')
    stub_tag_digest('A', 'sha256:configA')
    stub_tag_digest('Ba', 'sha256:configB')
    stub_tag_digest('Bb', 'sha256:configB')
    stub_tag_digest('C', 'sha256:configC')
    stub_tag_digest('D', 'sha256:configD')
    stub_tag_digest('E', nil)

    stub_digest_config('sha256:configA', 1.hour.ago)
    stub_digest_config('sha256:configB', 5.days.ago)
    stub_digest_config('sha256:configC', 1.month.ago)
    stub_digest_config('sha256:configD', nil)
  end

  describe '#execute' do
    subject { service.execute }

    it_behaves_like 'when regex matching everything is specified',
      delete_expectations: [%w[A Ba Bb C D E]],
      service_response_extra: {
        before_truncate_size: 6,
        after_truncate_size: 6,
        before_delete_size: 6,
        cached_tags_count: 0
      },
      supports_caching: true

    it_behaves_like 'when regex matching everything is specified and latest is not kept',
      delete_expectations: [%w[A Ba Bb C D E latest]],
      service_response_extra: {
        before_truncate_size: 7,
        after_truncate_size: 7,
        before_delete_size: 7,
        cached_tags_count: 0
      },
      supports_caching: true

    it_behaves_like 'when delete regex matching specific tags is used',
      service_response_extra: {
        before_truncate_size: 2,
        after_truncate_size: 2,
        before_delete_size: 2,
        cached_tags_count: 0
      },
      supports_caching: true

    it_behaves_like 'when delete regex matching specific tags is used with overriding allow regex',
      service_response_extra: {
        before_truncate_size: 1,
        after_truncate_size: 1,
        before_delete_size: 1,
        cached_tags_count: 0
      },
      supports_caching: true

    it_behaves_like 'with allow regex value',
      delete_expectations: [%w[A C D E]],
      service_response_extra: {
        before_truncate_size: 4,
        after_truncate_size: 4,
        before_delete_size: 4,
        cached_tags_count: 0
      },
      supports_caching: true

    it_behaves_like 'when keeping only N tags',
      delete_expectations: [%w[Bb Ba C]],
      service_response_extra: {
        before_truncate_size: 4,
        after_truncate_size: 4,
        before_delete_size: 3,
        cached_tags_count: 0
      },
      supports_caching: true

    it_behaves_like 'when not keeping N tags',
      delete_expectations: [%w[A Ba Bb C]],
      service_response_extra: {
        before_truncate_size: 4,
        after_truncate_size: 4,
        before_delete_size: 4,
        cached_tags_count: 0
      },
      supports_caching: true

    it_behaves_like 'when removing keeping only 3',
      delete_expectations: [%w[Bb Ba C]],
      service_response_extra: {
        before_truncate_size: 6,
        after_truncate_size: 6,
        before_delete_size: 3,
        cached_tags_count: 0
      },
      supports_caching: true

    it_behaves_like 'when removing older than 1 day',
      delete_expectations: [%w[Ba Bb C]],
      service_response_extra: {
        before_truncate_size: 6,
        after_truncate_size: 6,
        before_delete_size: 3,
        cached_tags_count: 0
      },
      supports_caching: true

    it_behaves_like 'when combining all parameters',
      delete_expectations: [%w[Bb Ba C]],
      service_response_extra: {
        before_truncate_size: 6,
        after_truncate_size: 6,
        before_delete_size: 3,
        cached_tags_count: 0
      },
      supports_caching: true

    it_behaves_like 'when running a container_expiration_policy',
      delete_expectations: [%w[Bb Ba C]],
      service_response_extra: {
        before_truncate_size: 6,
        after_truncate_size: 6,
        before_delete_size: 3,
        cached_tags_count: 0
      },
      supports_caching: true

    context 'when running a container_expiration_policy with caching' do
      let(:user) { nil }
      let(:params) do
        {
          'name_regex_delete' => '.*',
          'keep_n' => 1,
          'older_than' => '1 day',
          'container_expiration_policy' => true
        }
      end

      it 'expects caching to be used' do
        expect_delete(%w[Bb Ba C], container_expiration_policy: true)
        expect_caching

        subject
      end

      context 'when setting set to false' do
        before do
          stub_application_setting(container_registry_expiration_policies_caching: false)
        end

        it 'does not use caching' do
          expect_delete(%w[Bb Ba C], container_expiration_policy: true)
          expect_no_caching

          subject
        end
      end
    end

    context 'when truncating the tags list' do
      let(:params) do
        {
          'name_regex_delete' => '.*',
          'keep_n' => 1
        }
      end

      shared_examples 'returning the response' do
        |status:, original_size:, before_truncate_size:, after_truncate_size:, before_delete_size:|
        it 'returns the response' do
          expect_no_caching

          result = subject

          service_response = expected_service_response(
            status: status,
            original_size: original_size,
            deleted: nil
          ).merge(
            before_truncate_size: before_truncate_size,
            after_truncate_size: after_truncate_size,
            before_delete_size: before_delete_size,
            cached_tags_count: 0
          )

          expect(result).to eq(service_response)
        end
      end

      where(:max_list_size, :delete_tags_service_status, :expected_status, :expected_truncated) do
        10 | :success | :success | false
        10 | :error   | :error   | false
        3  | :success | :error   | true
        3  | :error   | :error   | true
        0  | :success | :success | false
        0  | :error   | :error   | false
      end

      with_them do
        before do
          stub_application_setting(container_registry_cleanup_tags_service_max_list_size: max_list_size)
          allow_next_instance_of(Projects::ContainerRepository::DeleteTagsService) do |service|
            allow(service).to receive(:execute).and_return(status: delete_tags_service_status)
          end
        end

        original_size = 7
        keep_n = 1

        it_behaves_like(
          'returning the response',
          status: params[:expected_status],
          original_size: original_size,
          before_truncate_size: original_size - keep_n,
          after_truncate_size: params[:expected_truncated] ? params[:max_list_size] + keep_n : original_size - keep_n,
          # one tag is filtered out with older_than filter
          before_delete_size: params[:expected_truncated] ? params[:max_list_size] : original_size - keep_n - 1
        )
      end
    end

    context 'with caching', :freeze_time do
      let(:params) do
        {
          'name_regex_delete' => '.*',
          'keep_n' => 1,
          'older_than' => '1 day',
          'container_expiration_policy' => true
        }
      end

      let(:tags_and_created_ats) do
        {
          'A' => 1.hour.ago,
          'Ba' => 5.days.ago,
          'Bb' => 5.days.ago,
          'C' => 1.month.ago,
          'D' => nil,
          'E' => nil
        }
      end

      let(:cacheable_tags) { tags_and_created_ats.reject { |_, value| value.nil? } }

      before do
        expect_delete(%w[Bb Ba C], container_expiration_policy: true)
        # We froze time so we need to set the created_at stubs again
        stub_digest_config('sha256:configA', 1.hour.ago)
        stub_digest_config('sha256:configB', 5.days.ago)
        stub_digest_config('sha256:configC', 1.month.ago)
      end

      it 'caches the created_at values' do
        expect_mget(tags_and_created_ats.keys)
        expect_set(cacheable_tags)

        expect(subject).to include(cached_tags_count: 0)
      end

      context 'with cached values' do
        before do
          ::Gitlab::Redis::Cache.with do |redis|
            redis.set(cache_key('C'), rfc3339(1.month.ago))
          end
        end

        it 'uses them' do
          expect_mget(tags_and_created_ats.keys)

          # because C is already in cache, it should not be cached again
          expect_set(cacheable_tags.except('C'))

          # We will ping the container registry for all tags *except* for C because it's cached
          expect(ContainerRegistry::Blob)
            .to receive(:new).with(repository, { ""digest"" => ""sha256:configA"" }).and_call_original
          expect(ContainerRegistry::Blob)
            .to receive(:new).with(repository, { ""digest"" => ""sha256:configB"" }).twice.and_call_original
          expect(ContainerRegistry::Blob).not_to receive(:new).with(repository, { ""digest"" => ""sha256:configC"" })
          expect(ContainerRegistry::Blob)
            .to receive(:new).with(repository, { ""digest"" => ""sha256:configD"" }).and_call_original

          expect(subject).to include(cached_tags_count: 1)
        end
      end

      def expect_mget(keys)
        Gitlab::Redis::Cache.with do |redis|
          parameters = keys.map { |k| cache_key(k) }
          expect(redis).to receive(:mget).with(parameters).and_call_original
        end
      end

      def expect_set(tags)
        selected_tags = tags.map do |tag_name, created_at|
          ex = 1.day.seconds - (Time.zone.now - created_at).seconds
          [tag_name, created_at, ex.to_i] if ex.positive?
        end.compact

        return if selected_tags.count.zero?

        Gitlab::Redis::Cache.with do |redis|
          expect(redis).to receive(:pipelined).and_call_original

          expect_next_instance_of(Redis::PipelinedConnection) do |pipeline|
            selected_tags.each do |tag_name, created_at, ex|
              expect(pipeline).to receive(:set).with(cache_key(tag_name), rfc3339(created_at), ex: ex).and_call_original
            end
          end
        end
      end

      def cache_key(tag_name)
        ""container_repository:{#{repository.id}}:tag:#{tag_name}:created_at""
      end

      def rfc3339(date_time)
        # DateTime rfc3339 is different ActiveSupport::TimeWithZone rfc3339
        # The caching will use DateTime rfc3339
        DateTime.rfc3339(date_time.rfc3339).rfc3339
      end
    end
  end

  private

  def stub_tag_digest(tag, digest)
    allow(repository.client)
      .to receive(:repository_tag_digest)
      .with(repository.path, tag) { digest }

    allow(repository.client)
      .to receive(:repository_manifest)
      .with(repository.path, tag) do
      { 'config' => { 'digest' => digest } } if digest
    end
  end

  def stub_digest_config(digest, created_at)
    allow(repository.client)
      .to receive(:blob)
      .with(repository.path, digest, nil) do
      { 'created' => created_at.to_datetime.rfc3339 }.to_json if created_at
    end
  end

  def expect_caching
    ::Gitlab::Redis::Cache.with do |redis|
      expect(redis).to receive(:mget).and_call_original
      expect(redis).to receive(:pipelined).and_call_original

      expect_next_instance_of(Redis::PipelinedConnection) do |pipeline|
        expect(pipeline).to receive(:set).and_call_original
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  module GroupLinks
    class DestroyService < BaseService
      def execute(group_link, skip_authorization: false)
        unless valid_to_destroy?(group_link, skip_authorization)
          return ServiceResponse.error(message: 'Not found', reason: :not_found)
        end

        if group_link.project.private?
          TodosDestroyer::ProjectPrivateWorker.perform_in(Todo::WAIT_FOR_DELETE, project.id)
        else
          TodosDestroyer::ConfidentialIssueWorker.perform_in(Todo::WAIT_FOR_DELETE, nil, project.id)
        end

        link = group_link.destroy

        refresh_project_authorizations_asynchronously(link.project)

        # Until we compare the inconsistency rates of the new specialized worker and
        # the old approach, we still run AuthorizedProjectsWorker
        # but with some delay and lower urgency as a safety net.
        link.group.refresh_members_authorized_projects(
          priority: UserProjectAccessChangedService::LOW_PRIORITY
        )

        ServiceResponse.success(payload: { link: link })
      end

      private

      def valid_to_destroy?(group_link, skip_authorization)
        return false unless group_link
        return true if skip_authorization

        current_user.can?(:admin_project_group_link, group_link)
      end

      def refresh_project_authorizations_asynchronously(project)
        AuthorizedProjectUpdate::ProjectRecalculateWorker.perform_async(project.id)
      end
    end
  end
end

Projects::GroupLinks::DestroyService.prepend_mod_with('Projects::GroupLinks::DestroyService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::GroupLinks::DestroyService, '#execute', feature_category: :groups_and_projects do
  let_it_be(:user) { create :user }
  let_it_be(:project) { create(:project, :private) }
  let_it_be(:group) { create(:group) }
  let_it_be(:group_user) { create(:user).tap { |user| group.add_guest(user) } }

  let(:group_access) { Gitlab::Access::DEVELOPER }
  let!(:group_link) { create(:project_group_link, project: project, group: group, group_access: group_access) }

  subject { described_class.new(project, user) }

  shared_examples_for 'removes group from project' do
    it 'removes group from project' do
      expect { subject.execute(group_link) }.to change { project.reload.project_group_links.count }.from(1).to(0)
    end
  end

  shared_examples_for 'returns not_found' do
    it do
      expect do
        result = subject.execute(group_link)

        expect(result[:status]).to eq(:error)
        expect(result[:reason]).to eq(:not_found)
      end.not_to change { project.reload.project_group_links.count }
    end
  end

  context 'if group_link is blank' do
    let!(:group_link) { nil }

    it_behaves_like 'returns not_found'
  end

  context 'if the user does not have access to destroy the link' do
    it_behaves_like 'returns not_found'
  end

  context 'when the user has proper permissions to remove a group-link from a project' do
    context 'when the user is a MAINTAINER in the project' do
      before do
        project.add_maintainer(user)
      end

      it_behaves_like 'removes group from project'

      context 'project authorizations refresh' do
        it 'calls AuthorizedProjectUpdate::ProjectRecalculateWorker to update project authorizations' do
          expect(AuthorizedProjectUpdate::ProjectRecalculateWorker)
            .to receive(:perform_async).with(group_link.project.id)

          subject.execute(group_link)
        end

        it 'calls AuthorizedProjectUpdate::UserRefreshFromReplicaWorker with a delay to update project authorizations' do
          stub_feature_flags(do_not_run_safety_net_auth_refresh_jobs: false)

          expect(AuthorizedProjectUpdate::UserRefreshFromReplicaWorker).to(
            receive(:bulk_perform_in).with(
              1.hour,
              [[group_user.id]],
              batch_delay: 30.seconds, batch_size: 100
            )
          )

          subject.execute(group_link)
        end

        it 'updates project authorizations of users who had access to the project via the group share', :sidekiq_inline do
          expect { subject.execute(group_link) }.to(
            change { Ability.allowed?(group_user, :read_project, project) }
              .from(true).to(false))
        end
      end

      describe 'todos cleanup' do
        context 'when project is private' do
          it 'triggers todos cleanup' do
            expect(TodosDestroyer::ProjectPrivateWorker).to receive(:perform_in).with(Todo::WAIT_FOR_DELETE, project.id)
            expect(project.private?).to be true

            subject.execute(group_link)
          end
        end

        context 'when project is public or internal' do
          shared_examples_for 'removes confidential todos' do
            it 'does not trigger todos cleanup' do
              expect(TodosDestroyer::ProjectPrivateWorker).not_to receive(:perform_in).with(Todo::WAIT_FOR_DELETE, project.id)
              expect(TodosDestroyer::ConfidentialIssueWorker).to receive(:perform_in).with(Todo::WAIT_FOR_DELETE, nil, project.id)
              expect(project.private?).to be false

              subject.execute(group_link)
            end
          end

          context 'when project is public' do
            let(:project) { create(:project, :public) }

            it_behaves_like 'removes confidential todos'
          end

          context 'when project is internal' do
            let(:project) { create(:project, :public) }

            it_behaves_like 'removes confidential todos'
          end
        end
      end
    end
  end

  context 'when skipping authorization' do
    context 'without providing a user' do
      it 'destroys the link' do
        expect do
          described_class.new(project, nil).execute(group_link, skip_authorization: true)
        end.to change { project.reload.project_group_links.count }.by(-1)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  module GroupLinks
    class UpdateService < BaseService
      def initialize(group_link, user = nil)
        super(group_link.project, user)

        @group_link = group_link
      end

      def execute(group_link_params)
        return ServiceResponse.error(message: 'Not found', reason: :not_found) unless allowed_to_update?

        group_link.update!(group_link_params)

        refresh_authorizations if requires_authorization_refresh?(group_link_params)

        ServiceResponse.success
      end

      private

      attr_reader :group_link

      def allowed_to_update?
        current_user.can?(:admin_project_member, project)
      end

      def refresh_authorizations
        AuthorizedProjectUpdate::ProjectRecalculateWorker.perform_async(project.id)

        # Until we compare the inconsistency rates of the new specialized worker and
        # the old approach, we still run AuthorizedProjectsWorker
        # but with some delay and lower urgency as a safety net.
        group_link.group.refresh_members_authorized_projects(
          priority: UserProjectAccessChangedService::LOW_PRIORITY
        )
      end

      def requires_authorization_refresh?(params)
        params.include?(:group_access)
      end
    end
  end
end

Projects::GroupLinks::UpdateService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::GroupLinks::UpdateService, '#execute', feature_category: :groups_and_projects do
  let_it_be(:user) { create :user }
  let_it_be(:group) { create :group }
  let_it_be(:project) { create :project }
  let_it_be(:group_user) { create(:user).tap { |user| group.add_developer(user) } }

  let(:group_access) { Gitlab::Access::DEVELOPER }

  let!(:link) { create(:project_group_link, project: project, group: group, group_access: group_access) }

  let(:expiry_date) { 1.month.from_now.to_date }
  let(:group_link_params) do
    { group_access: Gitlab::Access::GUEST,
      expires_at: expiry_date }
  end

  subject { described_class.new(link, user).execute(group_link_params) }

  shared_examples_for 'returns not_found' do
    it do
      result = subject

      expect(result[:status]).to eq(:error)
      expect(result[:reason]).to eq(:not_found)
    end
  end

  context 'when the user does not have proper permissions to update a project group link' do
    it_behaves_like 'returns not_found'
  end

  context 'when user has proper permissions to update a project group link' do
    context 'when the user is a MAINTAINER in the project' do
      before do
        project.add_maintainer(user)
      end

      it 'updates existing link' do
        expect(link.group_access).to eq(Gitlab::Access::DEVELOPER)
        expect(link.expires_at).to be_nil

        subject

        link.reload

        expect(link.group_access).to eq(Gitlab::Access::GUEST)
        expect(link.expires_at).to eq(expiry_date)
      end

      context 'project authorizations update' do
        it 'calls AuthorizedProjectUpdate::ProjectRecalculateWorker to update project authorizations' do
          expect(AuthorizedProjectUpdate::ProjectRecalculateWorker)
            .to receive(:perform_async).with(link.project.id)

          subject
        end

        it 'calls AuthorizedProjectUpdate::UserRefreshFromReplicaWorker ' \
           'with a delay to update project authorizations' do
          stub_feature_flags(do_not_run_safety_net_auth_refresh_jobs: false)

          expect(AuthorizedProjectUpdate::UserRefreshFromReplicaWorker).to(
            receive(:bulk_perform_in).with(
              1.hour,
              [[group_user.id]],
              batch_delay: 30.seconds, batch_size: 100
            )
          )

          subject
        end

        it 'updates project authorizations of users who had access to the project via the group share',
          :sidekiq_inline do
          expect { subject }.to(
            change { Ability.allowed?(group_user, :developer_access, project) }
              .from(true).to(false))
        end
      end

      context 'with only param not requiring authorization refresh' do
        let(:group_link_params) { { expires_at: Date.tomorrow } }

        it 'does not perform any project authorizations update using ' \
           '`AuthorizedProjectUpdate::ProjectRecalculateWorker`' do
          expect(AuthorizedProjectUpdate::ProjectRecalculateWorker).not_to receive(:perform_async)

          subject
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  module GroupLinks
    class CreateService < BaseService
      include GroupLinkable

      def initialize(project, shared_with_group, user, params)
        @shared_with_group = shared_with_group

        super(project, user, params)
      end

      private

      delegate :root_ancestor, to: :project

      def valid_to_create?
        can?(current_user, :read_namespace_via_membership, shared_with_group) && sharing_allowed?
      end

      def build_link
        @link = project.project_group_links.new(
          group: shared_with_group,
          group_access: params[:link_group_access],
          expires_at: params[:expires_at]
        )
      end

      def setup_authorizations
        AuthorizedProjectUpdate::ProjectRecalculateWorker.perform_async(project.id)

        # AuthorizedProjectsWorker uses an exclusive lease per user but
        # specialized workers might have synchronization issues. Until we
        # compare the inconsistency rates of both approaches, we still run
        # AuthorizedProjectsWorker but with some delay and lower urgency as a
        # safety net.
        shared_with_group.refresh_members_authorized_projects(
          priority: UserProjectAccessChangedService::LOW_PRIORITY
        )
      end
    end
  end
end

Projects::GroupLinks::CreateService.prepend_mod_with('Projects::GroupLinks::CreateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::GroupLinks::CreateService, '#execute', feature_category: :groups_and_projects do
  let_it_be(:user) { create :user }
  let_it_be(:group) { create :group }
  let_it_be(:project) { create(:project, namespace: create(:namespace, :with_namespace_settings)) }
  let_it_be(:group_user) { create(:user).tap { |user| group.add_guest(user) } }

  let(:opts) do
    {
      link_group_access: Gitlab::Access::DEVELOPER,
      expires_at: nil
    }
  end

  subject { described_class.new(project, group, user, opts) }

  shared_examples_for 'not shareable' do
    it 'does not share and returns an error' do
      expect do
        result = subject.execute

        expect(result[:status]).to eq(:error)
        expect(result[:http_status]).to eq(404)
      end.not_to change { project.project_group_links.count }
    end
  end

  shared_examples_for 'shareable' do
    it 'adds group to project' do
      expect do
        result = subject.execute

        expect(result[:status]).to eq(:success)
      end.to change { project.project_group_links.count }.from(0).to(1)
    end
  end

  context 'when user has proper permissions to share a project with a group' do
    before do
      group.add_guest(user)
    end

    context 'when the user is a MAINTAINER in the project' do
      before do
        project.add_maintainer(user)
      end

      it_behaves_like 'shareable'

      it 'updates authorization', :sidekiq_inline do
        expect { subject.execute }.to(
          change { Ability.allowed?(group_user, :read_project, project) }
            .from(false).to(true))
      end

      context 'with specialized project_authorization workers' do
        let_it_be(:other_user) { create(:user) }

        before do
          group.add_developer(other_user)
        end

        it 'schedules authorization update for users with access to group' do
          stub_feature_flags(do_not_run_safety_net_auth_refresh_jobs: false)

          expect(AuthorizedProjectsWorker).not_to(
            receive(:bulk_perform_async)
          )
          expect(AuthorizedProjectUpdate::ProjectRecalculateWorker).to(
            receive(:perform_async)
              .with(project.id)
              .and_call_original
          )
          expect(AuthorizedProjectUpdate::UserRefreshFromReplicaWorker).to(
            receive(:bulk_perform_in).with(
              1.hour,
              array_including([user.id], [other_user.id]),
              batch_delay: 30.seconds, batch_size: 100
            ).and_call_original
          )

          subject.execute
        end
      end

      context 'when sharing outside the hierarchy is disabled' do
        let_it_be(:shared_group_parent) do
          create(:group,
            namespace_settings: create(:namespace_settings, prevent_sharing_groups_outside_hierarchy: true)
          )
        end

        let_it_be(:project, reload: true) { create(:project, group: shared_group_parent) }

        it_behaves_like 'not shareable'

        context 'when group is inside hierarchy' do
          let(:group) { create(:group, :private, parent: shared_group_parent) }

          it_behaves_like 'shareable'
        end
      end
    end
  end

  context 'when user does not have permissions to share the project with a group' do
    it_behaves_like 'not shareable'
  end

  context 'when group is blank' do
    let(:group) { nil }

    it_behaves_like 'not shareable'
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  module ImportExport
    class ExportService < BaseService
      def initialize(*args)
        super

        @shared = project.import_export_shared
        @logger = Gitlab::Export::Logger.build
      end

      def execute(after_export_strategy = nil)
        unless project.template_source? || can?(current_user, :admin_project, project)
          raise ::Gitlab::ImportExport::Error.permission_error(current_user, project)
        end

        save_all!
        execute_after_export_action(after_export_strategy)
      ensure
        cleanup
      end

      def exporters
        [
          version_saver, avatar_saver, project_tree_saver, uploads_saver,
          repo_saver, wiki_repo_saver, lfs_saver, snippets_repo_saver, design_repo_saver
        ]
      end

      protected

      def extra_attributes_for_measurement
        {
          current_user: current_user&.name,
          project_full_path: project&.full_path,
          file_path: shared.export_path
        }
      end

      private

      attr_accessor :shared
      attr_reader :logger

      def execute_after_export_action(after_export_strategy)
        return unless after_export_strategy

        unless after_export_strategy.execute(current_user, project)
          notify_error
        end
      end

      def save_all!
        log_info('Project export started')

        if save_exporters && save_export_archive
          log_info('Project successfully exported')
        else
          notify_error!
        end
      end

      def save_exporters
        exporters.all? do |exporter|
          log_info(""#{exporter.class.name} saver started"")

          exporter.save
        end
      end

      def save_export_archive
        @export_saver ||= Gitlab::ImportExport::Saver.save(exportable: project, shared: shared)
      end

      def version_saver
        @version_saver ||= Gitlab::ImportExport::VersionSaver.new(shared: shared)
      end

      def avatar_saver
        @avatar_saver ||= Gitlab::ImportExport::AvatarSaver.new(project: project, shared: shared)
      end

      def project_tree_saver
        @project_tree_saver ||= tree_saver_class.new(
          project: project,
          current_user: current_user,
          shared: shared,
          params: params,
          logger: logger)
      end

      def tree_saver_class
        Gitlab::ImportExport::Project::TreeSaver
      end

      def uploads_saver
        @uploads_saver ||= Gitlab::ImportExport::UploadsSaver.new(project: project, shared: shared)
      end

      def repo_saver
        @repo_saver ||= Gitlab::ImportExport::RepoSaver.new(exportable: project, shared: shared)
      end

      def wiki_repo_saver
        @wiki_repo_saver ||= Gitlab::ImportExport::WikiRepoSaver.new(exportable: project, shared: shared)
      end

      def lfs_saver
        @lfs_saver ||= Gitlab::ImportExport::LfsSaver.new(project: project, shared: shared)
      end

      def snippets_repo_saver
        @snippets_repo_saver ||= Gitlab::ImportExport::SnippetsRepoSaver.new(
          current_user: current_user,
          project: project,
          shared: shared
        )
      end

      def design_repo_saver
        @design_repo_saver ||= Gitlab::ImportExport::DesignRepoSaver.new(exportable: project, shared: shared)
      end

      def cleanup
        FileUtils.rm_rf(shared.archive_path) if shared&.archive_path
      end

      def notify_error!
        notify_error

        raise Gitlab::ImportExport::Error, shared.errors.to_sentence
      end

      def log_info(message)
        logger.info(
          message: message,
          **log_base_data
        )
      end

      def notify_error
        logger.error(
          message: 'Project export error',
          export_errors: shared.errors.join(', '),
          **log_base_data
        )

        user = current_user
        errors = shared.errors

        project.run_after_commit_or_now do |project|
          NotificationService.new.project_not_exported(project, user, errors)
        end
      end

      def log_base_data
        @log_base_data ||= Gitlab::ImportExport::LogUtil.exportable_to_log_payload(project)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::ImportExport::ExportService, feature_category: :importers do
  describe '#execute' do
    let_it_be(:user) { create(:user) }
    let_it_be(:group) { create(:group) }
    let_it_be_with_reload(:project) { create(:project, group: group) }

    let(:shared) { project.import_export_shared }
    let!(:after_export_strategy) { Gitlab::ImportExport::AfterExportStrategies::DownloadNotificationStrategy.new }

    subject(:service) { described_class.new(project, user) }

    before do
      project.add_maintainer(user)
    end

    it 'saves the version' do
      expect(Gitlab::ImportExport::VersionSaver).to receive(:new).and_call_original

      service.execute
    end

    it 'saves the avatar' do
      expect(Gitlab::ImportExport::AvatarSaver).to receive(:new).and_call_original

      service.execute
    end

    it 'saves the models' do
      saver_params = {
        project: project,
        current_user: user,
        shared: shared,
        params: {},
        logger: an_instance_of(Gitlab::Export::Logger)
      }
      expect(Gitlab::ImportExport::Project::TreeSaver).to receive(:new).with(saver_params).and_call_original

      service.execute
    end

    it 'saves the uploads' do
      expect(Gitlab::ImportExport::UploadsSaver).to receive(:new).and_call_original

      service.execute
    end

    it 'saves the repo' do
      # This spec errors when run against the EE codebase as there will be a third repository
      # saved (the EE-specific design repository).
      #
      # Instead, skip this test when run within EE. There is a spec for the EE-specific design repo
      # in the corresponding EE spec.
      skip if Gitlab.ee?

      # once for the normal repo, once for the wiki repo, and once for the design repo
      expect(Gitlab::ImportExport::RepoSaver).to receive(:new).exactly(3).times.and_call_original

      service.execute
    end

    it 'saves the wiki repo' do
      expect(Gitlab::ImportExport::WikiRepoSaver).to receive(:new).and_call_original

      service.execute
    end

    it 'saves the design repo' do
      expect(Gitlab::ImportExport::DesignRepoSaver).to receive(:new).and_call_original

      service.execute
    end

    it 'saves the lfs objects' do
      expect(Gitlab::ImportExport::LfsSaver).to receive(:new).and_call_original

      service.execute
    end

    it 'saves the snippets' do
      expect_next_instance_of(Gitlab::ImportExport::SnippetsRepoSaver) do |instance|
        expect(instance).to receive(:save).and_call_original
      end

      service.execute
    end

    context 'when all saver services succeed' do
      before do
        allow(service).to receive(:save_exporters).and_return(true)
      end

      it 'logs a successful message' do
        allow(Gitlab::ImportExport::Saver).to receive(:save).and_return(true)

        expect(service.instance_variable_get(:@logger)).to receive(:info).ordered.with(
          hash_including({ message: 'Project export started', project_id: project.id })
        )

        expect(service.instance_variable_get(:@logger)).to receive(:info).ordered.with(
          hash_including({ message: 'Project successfully exported', project_id: project.id })
        )

        service.execute
      end

      it 'saves the project in the file system' do
        expect(Gitlab::ImportExport::Saver).to receive(:save).with(exportable: project, shared: shared).and_return(true)

        service.execute
      end

      context 'when the upload fails' do
        before do
          expect(Gitlab::ImportExport::Saver).to receive(:save).with(exportable: project, shared: shared).and_return(false)
        end

        it 'notifies the user of an error' do
          expect(service).to receive(:notify_error).and_call_original

          expect { service.execute }.to raise_error(Gitlab::ImportExport::Error)
        end
      end

      it 'calls the after export strategy' do
        allow(Gitlab::ImportExport::Saver).to receive(:save).and_return(true)
        expect(after_export_strategy).to receive(:execute)

        service.execute(after_export_strategy)
      end

      context 'when after export strategy fails' do
        before do
          allow(after_export_strategy).to receive(:execute).and_return(false)
          allow(Gitlab::ImportExport::Saver).to receive(:save).and_return(true)
        end

        after do
          service.execute(after_export_strategy)
        end

        it 'removes the remaining exported data' do
          allow(shared).to receive(:archive_path).and_return('whatever')
          allow(FileUtils).to receive(:rm_rf)

          expect(FileUtils).to receive(:rm_rf).with(shared.archive_path)
        end

        it 'notifies the user' do
          expect_next_instance_of(NotificationService) do |instance|
            expect(instance).to receive(:project_not_exported)
          end
        end

        it 'notifies logger' do
          expect(service.instance_variable_get(:@logger)).to receive(:error).with(
            hash_including({ message: 'Project export error', project_id: project.id })
          )
        end
      end
    end

    context 'when saving services fail' do
      before do
        allow(service).to receive(:save_exporters).and_return(false)
      end

      after do
        expect { service.execute }.to raise_error(Gitlab::ImportExport::Error)
      end

      it 'removes the remaining exported data' do
        allow(shared).to receive(:archive_path).and_return('whatever')
        allow(FileUtils).to receive(:rm_rf)

        expect(FileUtils).to receive(:rm_rf).with(shared.archive_path)
      end

      it 'notifies the user' do
        expect_next_instance_of(NotificationService) do |instance|
          expect(instance).to receive(:project_not_exported)
        end
      end

      it 'notifies logger' do
        expect(service.instance_variable_get(:@logger)).to receive(:error)
      end

      it 'does not call the export strategy' do
        expect(service).not_to receive(:execute_after_export_action)
      end
    end

    context 'when one of the savers fail unexpectedly' do
      let(:archive_path) { shared.archive_path }

      before do
        allow(service).to receive_message_chain(:uploads_saver, :save).and_return(false)
      end

      it 'removes the remaining exported data' do
        expect { service.execute }.to raise_error(Gitlab::ImportExport::Error)

        expect(project.import_export_upload).to be_nil
        expect(File.exist?(shared.archive_path)).to eq(false)
      end
    end

    context 'when user does not have admin_project permission' do
      let!(:another_user) { create(:user) }

      subject(:service) { described_class.new(project, another_user) }

      it 'fails' do
        expected_message =
          ""User with ID: %s does not have required permissions for Project: %s with ID: %s"" %
          [another_user.id, project.name, project.id]
        expect { service.execute }.to raise_error(Gitlab::ImportExport::Error).with_message(expected_message)
      end
    end

    it ""avoids N+1 when exporting project members"" do
      group.add_owner(user)
      group.add_maintainer(create(:user))
      project.add_maintainer(create(:user))

      # warm up
      service.execute

      control = ActiveRecord::QueryRecorder.new { service.execute }

      group.add_maintainer(create(:user))
      project.add_maintainer(create(:user))

      expect { service.execute }.not_to exceed_query_limit(control)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  module ImportExport
    class ParallelExportService
      def initialize(export_job, current_user, after_export_strategy)
        @export_job = export_job
        @current_user = current_user
        @after_export_strategy = after_export_strategy
        @shared = project.import_export_shared
        @logger = Gitlab::Export::Logger.build
      end

      def execute
        log_info('Parallel project export started')

        if save_exporters && save_export_archive
          log_info('Parallel project export finished successfully')
          execute_after_export_action(after_export_strategy)
        else
          notify_error
        end

      ensure
        cleanup
      end

      private

      attr_reader :export_job, :current_user, :after_export_strategy, :shared, :logger

      delegate :project, to: :export_job

      def execute_after_export_action(after_export_strategy)
        return if after_export_strategy.execute(current_user, project)

        notify_error
      end

      def exporters
        [version_saver, exported_relations_merger]
      end

      def save_exporters
        exporters.all? do |exporter|
          log_info(""Parallel project export - #{exporter.class.name} saver started"")

          exporter.save
        end
      end

      def save_export_archive
        Gitlab::ImportExport::Saver.save(exportable: project, shared: shared)
      end

      def version_saver
        @version_saver ||= Gitlab::ImportExport::VersionSaver.new(shared: shared)
      end

      def exported_relations_merger
        @relation_saver ||= Gitlab::ImportExport::Project::ExportedRelationsMerger.new(
          export_job: export_job,
          shared: shared)
      end

      def cleanup
        FileUtils.rm_rf(shared.export_path) if File.exist?(shared.export_path)
        FileUtils.rm_rf(shared.archive_path) if File.exist?(shared.archive_path)
      end

      def log_info(message)
        logger.info(
          message: message,
          **log_base_data
        )
      end

      def notify_error
        logger.error(
          message: 'Parallel project export error',
          export_errors: shared.errors.join(', '),
          export_job_id: export_job.id,
          **log_base_data
        )

        NotificationService.new.project_not_exported(project, current_user, shared.errors)
      end

      def log_base_data
        {
          project_id: project.id,
          project_name: project.name,
          project_path: project.full_path
        }
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::ImportExport::ParallelExportService, feature_category: :importers do
  let_it_be(:user) { create(:user) }

  let(:export_job) { create(:project_export_job) }
  let(:after_export_strategy) { Gitlab::ImportExport::AfterExportStrategies::DownloadNotificationStrategy.new }
  let(:project) { export_job.project }

  before do
    allow_next_instance_of(Gitlab::ImportExport::Project::ExportedRelationsMerger) do |saver|
      allow(saver).to receive(:save).and_return(true)
    end

    allow_next_instance_of(Gitlab::ImportExport::VersionSaver) do |saver|
      allow(saver).to receive(:save).and_return(true)
    end
  end

  describe '#execute' do
    subject(:service) { described_class.new(export_job, user, after_export_strategy) }

    it 'creates a project export archive file' do
      expect(Gitlab::ImportExport::Saver).to receive(:save)
        .with(exportable: project, shared: project.import_export_shared)

      service.execute
    end

    it 'logs export progress' do
      allow(Gitlab::ImportExport::Saver).to receive(:save).and_return(true)

      logger = service.instance_variable_get(:@logger)
      messages = [
        'Parallel project export started',
        'Parallel project export - Gitlab::ImportExport::VersionSaver saver started',
        'Parallel project export - Gitlab::ImportExport::Project::ExportedRelationsMerger saver started',
        'Parallel project export finished successfully'
      ]
      messages.each do |message|
        expect(logger).to receive(:info).ordered.with(hash_including(message: message))
      end

      service.execute
    end

    it 'executes after export stragegy on export success' do
      allow(Gitlab::ImportExport::Saver).to receive(:save).and_return(true)

      expect(after_export_strategy).to receive(:execute)

      service.execute
    end

    it 'ensures files are cleaned up' do
      shared = project.import_export_shared
      FileUtils.mkdir_p(shared.archive_path)
      FileUtils.mkdir_p(shared.export_path)

      allow(Gitlab::ImportExport::Saver).to receive(:save).and_raise(StandardError)

      expect { service.execute }.to raise_error(StandardError)

      expect(File.exist?(shared.export_path)).to eq(false)
      expect(File.exist?(shared.archive_path)).to eq(false)
    end

    context 'when export fails' do
      it 'notifies the error to the user' do
        allow(Gitlab::ImportExport::Saver).to receive(:save).and_return(false)

        allow(project.import_export_shared).to receive(:errors).and_return(['Error'])

        expect_next_instance_of(NotificationService) do |instance|
          expect(instance).to receive(:project_not_exported).with(project, user, ['Error'])
        end

        service.execute
      end
    end

    context 'when after export stragegy fails' do
      it 'notifies the error to the user' do
        allow(Gitlab::ImportExport::Saver).to receive(:save).and_return(true)
        allow(after_export_strategy).to receive(:execute).and_return(false)
        allow(project.import_export_shared).to receive(:errors).and_return(['Error'])

        expect_next_instance_of(NotificationService) do |instance|
          expect(instance).to receive(:project_not_exported).with(project, user, ['Error'])
        end

        service.execute
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  module ImportExport
    class RelationExportService
      include Gitlab::ImportExport::CommandLineUtil

      def initialize(relation_export, jid)
        @relation_export = relation_export
        @jid = jid
        @logger = Gitlab::Export::Logger.build
      end

      def execute
        relation_export.update!(status_event: :start, jid: jid)

        mkdir_p(shared.export_path)
        mkdir_p(shared.archive_path)

        if relation_saver.save
          compress_export_path
          upload_compressed_file
          relation_export.finish!
        else
          fail_export(shared.errors.join(', '))
        end
      rescue StandardError => e
        fail_export(e.message)
      ensure
        FileUtils.remove_entry(shared.export_path) if File.exist?(shared.export_path)
        FileUtils.remove_entry(shared.archive_path) if File.exist?(shared.archive_path)
      end

      private

      attr_reader :relation_export, :jid, :logger

      delegate :relation, :project_export_job, to: :relation_export
      delegate :project, to: :project_export_job

      def shared
        project.import_export_shared
      end

      def relation_saver
        case relation
        when Projects::ImportExport::RelationExport::UPLOADS_RELATION
          Gitlab::ImportExport::UploadsSaver.new(project: project, shared: shared)
        when Projects::ImportExport::RelationExport::REPOSITORY_RELATION
          Gitlab::ImportExport::RepoSaver.new(exportable: project, shared: shared)
        when Projects::ImportExport::RelationExport::WIKI_REPOSITORY_RELATION
          Gitlab::ImportExport::WikiRepoSaver.new(exportable: project, shared: shared)
        when Projects::ImportExport::RelationExport::LFS_OBJECTS_RELATION
          Gitlab::ImportExport::LfsSaver.new(project: project, shared: shared)
        when Projects::ImportExport::RelationExport::SNIPPETS_REPOSITORY_RELATION
          Gitlab::ImportExport::SnippetsRepoSaver.new(project: project, shared: shared, current_user: nil)
        when Projects::ImportExport::RelationExport::DESIGN_REPOSITORY_RELATION
          Gitlab::ImportExport::DesignRepoSaver.new(exportable: project, shared: shared)
        else
          Gitlab::ImportExport::Project::RelationSaver.new(
            project: project,
            shared: shared,
            relation: relation
          )
        end
      end

      def upload_compressed_file
        upload = relation_export.build_upload
        File.open(archive_file_full_path) { |file| upload.export_file = file }
        upload.save!
      end

      def compress_export_path
        tar_czf(archive: archive_file_full_path, dir: shared.export_path)
      end

      def archive_file_full_path
        @archive_file ||= File.join(shared.archive_path, ""#{relation}.tar.gz"")
      end

      def fail_export(error_message)
        relation_export.update!(status_event: :fail_op, export_error: error_message.truncate(300))

        logger.error(
          message: 'Project relation export failed',
          export_error: error_message,
          relation: relation_export.relation,
          project_export_job_id: project_export_job.id,
          project_name: project.name,
          project_id: project.id
        )
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::ImportExport::RelationExportService, feature_category: :importers do
  using RSpec::Parameterized::TableSyntax

  subject(:service) { described_class.new(relation_export, 'jid') }

  let_it_be(:project_export_job) { create(:project_export_job) }
  let_it_be(:export_path) { ""#{Dir.tmpdir}/project_tree_saver_spec"" }
  let_it_be(:archive_path) { ""#{Dir.tmpdir}/project_archive_spec"" }

  let(:relation_export) { create(:project_relation_export, relation: relation, project_export_job: project_export_job) }

  before do
    stub_uploads_object_storage(ImportExportUploader, enabled: false)

    allow(project_export_job.project.import_export_shared).to receive(:export_path).and_return(export_path)
    allow(project_export_job.project.import_export_shared).to receive(:archive_path).and_return(archive_path)
    allow(FileUtils).to receive(:remove_entry).with(any_args).and_call_original
  end

  describe '#execute' do
    let(:relation) { 'labels' }

    it 'removes temporary paths used to export files' do
      expect(FileUtils).to receive(:remove_entry).with(export_path)
      expect(FileUtils).to receive(:remove_entry).with(archive_path)

      service.execute
    end

    context 'when saver fails to export relation' do
      before do
        allow_next_instance_of(Gitlab::ImportExport::Project::RelationSaver) do |saver|
          allow(saver).to receive(:save).and_return(false)
        end
      end

      it 'flags export as failed' do
        service.execute

        expect(relation_export.failed?).to eq(true)
      end

      it 'logs failed message' do
        expect_next_instance_of(Gitlab::Export::Logger) do |logger|
          expect(logger).to receive(:error).with(
            export_error: '',
            message: 'Project relation export failed',
            relation: relation_export.relation,
            project_export_job_id: project_export_job.id,
            project_id: project_export_job.project.id,
            project_name: project_export_job.project.name
          )
        end

        service.execute
      end
    end

    context 'when an exception is raised' do
      before do
        allow_next_instance_of(Gitlab::ImportExport::Project::RelationSaver) do |saver|
          allow(saver).to receive(:save).and_raise('Error!')
        end
      end

      it 'flags export as failed' do
        service.execute

        expect(relation_export.failed?).to eq(true)
        expect(relation_export.export_error).to eq('Error!')
      end

      it 'logs exception error message' do
        expect_next_instance_of(Gitlab::Export::Logger) do |logger|
          expect(logger).to receive(:error).with(
            export_error: 'Error!',
            message: 'Project relation export failed',
            relation: relation_export.relation,
            project_export_job_id: project_export_job.id,
            project_id: project_export_job.project.id,
            project_name: project_export_job.project.name
          )
        end

        service.execute
      end
    end

    describe 'relation name and saver class' do
      where(:relation_name, :saver) do
        Projects::ImportExport::RelationExport::UPLOADS_RELATION | Gitlab::ImportExport::UploadsSaver
        Projects::ImportExport::RelationExport::REPOSITORY_RELATION | Gitlab::ImportExport::RepoSaver
        Projects::ImportExport::RelationExport::WIKI_REPOSITORY_RELATION | Gitlab::ImportExport::WikiRepoSaver
        Projects::ImportExport::RelationExport::LFS_OBJECTS_RELATION | Gitlab::ImportExport::LfsSaver
        Projects::ImportExport::RelationExport::SNIPPETS_REPOSITORY_RELATION | Gitlab::ImportExport::SnippetsRepoSaver
        Projects::ImportExport::RelationExport::DESIGN_REPOSITORY_RELATION | Gitlab::ImportExport::DesignRepoSaver
        Projects::ImportExport::RelationExport::ROOT_RELATION | Gitlab::ImportExport::Project::RelationSaver
        'labels' | Gitlab::ImportExport::Project::RelationSaver
      end

      with_them do
        let(:relation) { relation_name }

        it 'exports relation using correct saver' do
          expect(saver).to receive(:new).and_call_original

          service.execute
        end

        it 'assigns finished status and relation file' do
          service.execute

          expect(relation_export.finished?).to eq(true)
          expect(relation_export.upload.export_file.filename).to eq(""#{relation}.tar.gz"")
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  module HashedStorage
    class MigrateAttachmentsService < BaseAttachmentService
      extend ::Gitlab::Utils::Override

      # List of paths that can be excluded while evaluation if a target can be discarded
      DISCARDABLE_PATHS = %w[tmp tmp/cache tmp/work].freeze

      def initialize(project:, old_disk_path:, logger: nil)
        super

        @skipped = false
      end

      def execute
        origin = find_old_attachments_path(project)

        project.storage_version = ::Project::HASHED_STORAGE_FEATURES[:attachments]
        target = FileUploader.absolute_base_dir(project)

        @new_disk_path = project.disk_path

        result = move_folder!(origin, target)

        if result
          project.save!(validate: false)

          yield if block_given?
        end

        result
      end

      override :target_path_discardable?
      # Check if target path has discardable content
      #
      # @param [String] new_path
      # @return [Boolean] whether we can discard the target path or not
      def target_path_discardable?(new_path)
        return false unless File.directory?(new_path)

        found = Dir.glob(File.join(new_path, '**', '**'))

        (found - discardable_paths(new_path)).empty?
      end

      private

      def discardable_paths(new_path)
        DISCARDABLE_PATHS.collect { |path| File.join(new_path, path) }
      end

      def find_old_attachments_path(project)
        origin = FileUploader.absolute_base_dir(project)

        # It's possible that old_disk_path does not match project.disk_path.
        # For example, that happens when we rename a project
        #
        origin.sub(/#{Regexp.escape(project.full_path)}\z/, old_disk_path)
      end
    end
  end
end

Projects::HashedStorage::MigrateAttachmentsService.prepend_mod_with('Projects::HashedStorage::MigrateAttachmentsService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::HashedStorage::MigrateAttachmentsService, feature_category: :groups_and_projects do
  subject(:service) { described_class.new(project: project, old_disk_path: project.full_path, logger: nil) }

  let(:project) { create(:project, :repository, storage_version: 1, skip_disk_validation: true) }
  let(:legacy_storage) { Storage::LegacyProject.new(project) }
  let(:hashed_storage) { Storage::Hashed.new(project) }

  let!(:upload) { Upload.find_by(path: file_uploader.upload_path) }
  let(:file_uploader) { build(:file_uploader, project: project) }
  let(:old_disk_path) { File.join(base_path(legacy_storage), upload.path) }
  let(:new_disk_path) { File.join(base_path(hashed_storage), upload.path) }

  describe '#execute' do
    context 'when succeeds' do
      it 'moves attachments to hashed storage layout' do
        expect(File.file?(old_disk_path)).to be_truthy
        expect(File.file?(new_disk_path)).to be_falsey
        expect(File.exist?(base_path(legacy_storage))).to be_truthy
        expect(File.exist?(base_path(hashed_storage))).to be_falsey
        expect(FileUtils).to receive(:mv).with(base_path(legacy_storage), base_path(hashed_storage)).and_call_original

        service.execute

        expect(File.exist?(base_path(hashed_storage))).to be_truthy
        expect(File.exist?(base_path(legacy_storage))).to be_falsey
        expect(File.file?(old_disk_path)).to be_falsey
        expect(File.file?(new_disk_path)).to be_truthy
      end

      it 'returns true' do
        expect(service.execute).to be_truthy
      end

      it 'sets skipped to false' do
        service.execute

        expect(service.skipped?).to be_falsey
      end
    end

    context 'when original folder does not exist anymore' do
      before do
        FileUtils.rm_rf(base_path(legacy_storage))
      end

      it 'skips moving folders and go to next' do
        expect(FileUtils).not_to receive(:mv).with(base_path(legacy_storage), base_path(hashed_storage))

        service.execute

        expect(File.exist?(base_path(hashed_storage))).to be_falsey
        expect(File.file?(new_disk_path)).to be_falsey
      end

      it 'returns true' do
        expect(service.execute).to be_truthy
      end

      it 'sets skipped to true' do
        service.execute

        expect(service.skipped?).to be_truthy
      end
    end

    context 'when target folder already exists' do
      before do
        FileUtils.mkdir_p(base_path(hashed_storage))
      end

      it 'succeed when target is empty' do
        expect { service.execute }.not_to raise_error
      end

      it 'succeed when target include only discardable items' do
        Projects::HashedStorage::MigrateAttachmentsService::DISCARDABLE_PATHS.each do |path_fragment|
          discardable_path = File.join(base_path(hashed_storage), path_fragment)
          FileUtils.mkdir_p(discardable_path)
        end

        expect { service.execute }.not_to raise_error
      end

      it 'raises AttachmentCannotMoveError when there are non discardable items on target path' do
        not_discardable_path = File.join(base_path(hashed_storage), 'something')
        FileUtils.mkdir_p(not_discardable_path)

        expect(FileUtils).not_to receive(:mv).with(base_path(legacy_storage), base_path(hashed_storage))

        expect { service.execute }.to raise_error(Projects::HashedStorage::AttachmentCannotMoveError)
      end
    end

    it 'works even when project validation fails' do
      allow(project).to receive(:valid?) { false }

      expect { service.execute }.to change { project.hashed_storage?(:attachments) }.to(true)
    end
  end

  describe '#old_disk_path' do
    it 'returns old disk_path for project' do
      expect(service.old_disk_path).to eq(project.full_path)
    end
  end

  describe '#new_disk_path' do
    it 'returns new disk_path for project' do
      service.execute

      expect(service.new_disk_path).to eq(project.disk_path)
    end
  end

  describe '#target_path_discardable?' do
    it 'returns true when it include only items on the discardable list' do
      hashed_attachments_path = File.join(base_path(hashed_storage))
      Projects::HashedStorage::MigrateAttachmentsService::DISCARDABLE_PATHS.each do |path_fragment|
        discardable_path = File.join(hashed_attachments_path, path_fragment)
        FileUtils.mkdir_p(discardable_path)
      end

      expect(service.target_path_discardable?(hashed_attachments_path)).to be_truthy
    end
  end

  def base_path(storage)
    File.join(FileUploader.root, storage.disk_path)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  module HashedStorage
    AttachmentMigrationError = Class.new(StandardError)

    AttachmentCannotMoveError = Class.new(StandardError)

    class BaseAttachmentService < BaseService
      # Returns the disk_path value before the execution
      attr_reader :old_disk_path

      # Returns the disk_path value after the execution
      attr_reader :new_disk_path

      # Returns the logger currently in use
      attr_reader :logger

      def initialize(project:, old_disk_path:, logger: nil)
        @project = project
        @old_disk_path = old_disk_path
        @logger = logger || Gitlab::AppLogger
      end

      # Return whether this operation was skipped or not
      #
      # @return [Boolean] true if skipped of false otherwise
      def skipped?
        @skipped
      end

      # Check if target path has discardable content
      #
      # @param [String] new_path
      # @return [Boolean] whether we can discard the target path or not
      def target_path_discardable?(new_path)
        false
      end

      protected

      def move_folder!(old_path, new_path)
        unless File.directory?(old_path)
          logger.info(""Skipped attachments move from '#{old_path}' to '#{new_path}', source path doesn't exist or is not a directory (PROJECT_ID=#{project.id})"")
          @skipped = true

          return true
        end

        if File.exist?(new_path)
          if target_path_discardable?(new_path)
            discard_path!(new_path)
          else
            logger.error(""Cannot move attachments from '#{old_path}' to '#{new_path}', target path already exist (PROJECT_ID=#{project.id})"")

            raise AttachmentCannotMoveError, ""Target path '#{new_path}' already exists""
          end
        end

        # Create base path folder on the new storage layout
        FileUtils.mkdir_p(File.dirname(new_path))

        FileUtils.mv(old_path, new_path)
        logger.info(""Project attachments moved from '#{old_path}' to '#{new_path}' (PROJECT_ID=#{project.id})"")

        true
      end

      # Rename a path adding a suffix in order to prevent data-loss.
      #
      # @param [String] new_path
      def discard_path!(new_path)
        discarded_path = ""#{new_path}-#{Time.current.utc.to_i}""

        logger.info(""Moving existing empty attachments folder from '#{new_path}' to '#{discarded_path}', (PROJECT_ID=#{project.id})"")
        FileUtils.mv(new_path, discarded_path)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::HashedStorage::BaseAttachmentService, feature_category: :groups_and_projects do
  let(:project) { create(:project, :repository, storage_version: 0, skip_disk_validation: true) }

  subject(:service) { described_class.new(project: project, old_disk_path: project.full_path, logger: nil) }

  describe '#old_disk_path' do
    it { is_expected.to respond_to :old_disk_path }
  end

  describe '#new_disk_path' do
    it { is_expected.to respond_to :new_disk_path }
  end

  describe '#skipped?' do
    it { is_expected.to respond_to :skipped? }
  end

  describe '#target_path_discardable?' do
    it 'returns false' do
      expect(subject.target_path_discardable?('something/something')).to be_falsey
    end
  end

  describe '#discard_path!' do
    it 'renames target path adding a timestamp at the end' do
      target_path = Dir.mktmpdir
      expect(Dir.exist?(target_path)).to be_truthy

      freeze_time do
        suffix = Time.current.utc.to_i
        subject.send(:discard_path!, target_path)

        expected_renamed_path = ""#{target_path}-#{suffix}""

        expect(Dir.exist?(target_path)).to be_falsey
        expect(Dir.exist?(expected_renamed_path)).to be_truthy
      end
    end
  end

  describe '#move_folder!' do
    context 'when old_path is not a directory' do
      it 'adds information to the logger and returns true' do
        Tempfile.create do |old_path| # rubocop:disable Rails/SaveBang
          new_path = ""#{old_path}-new""

          expect(subject.send(:move_folder!, old_path, new_path)).to be_truthy
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  module HashedStorage
    class MigrationService < BaseService
      attr_reader :logger, :old_disk_path

      def initialize(project, old_disk_path, logger: nil)
        @project = project
        @old_disk_path = old_disk_path
        @logger = logger || Gitlab::AppLogger
      end

      def execute
        # Migrate attachments from Legacy to Hashed Storage
        unless project.hashed_storage?(:attachments)
          return false unless migrate_attachments_service.execute
        end

        true
      end

      private

      def migrate_attachments_service
        HashedStorage::MigrateAttachmentsService.new(project: project, old_disk_path: old_disk_path, logger: logger)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::HashedStorage::MigrationService, feature_category: :groups_and_projects do
  let(:project) { create(:project, :empty_repo, :wiki_repo, :legacy_storage) }
  let(:logger) { double }
  let!(:project_attachment) { build(:file_uploader, project: project) }
  let(:project_hashed_path) { Storage::Hashed.new(project).disk_path }
  let(:project_legacy_path) { Storage::LegacyProject.new(project).disk_path }
  let(:wiki_hashed_path) { ""#{project_hashed_path}.wiki"" }
  let(:wiki_legacy_path) { ""#{project_legacy_path}.wiki"" }

  subject(:service) { described_class.new(project, project.full_path, logger: logger) }

  describe '#execute' do
    context 'attachments migration' do
      let(:project) { create(:project, :empty_repo, :wiki_repo, storage_version: ::Project::HASHED_STORAGE_FEATURES[:repository]) }

      let(:attachments_service) do
        Projects::HashedStorage::MigrateAttachmentsService.new(
          project: project,
          old_disk_path: project.full_path,
          logger: logger
        )
      end

      it 'does not delegate migration if attachments are already migrated' do
        project.storage_version = ::Project::LATEST_STORAGE_VERSION
        expect(Projects::HashedStorage::MigrateAttachmentsService).not_to receive(:new)

        service.execute
      end

      it 'migrates legacy attachments to hashed storage' do
        legacy_attachments_path = FileUploader.absolute_base_dir(project)
        hashed_project = project.dup.tap { |p| p.id = project.id }
        hashed_project.storage_version = ::Project::HASHED_STORAGE_FEATURES[:attachments]
        hashed_attachments_path = FileUploader.absolute_base_dir(hashed_project)

        expect(logger).to receive(:info).with(/Project attachments moved from '#{legacy_attachments_path}' to '#{hashed_attachments_path}'/)

        expect { service.execute }.to change { project.storage_version }.from(1).to(2)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  module Operations
    class UpdateService < BaseService
      def execute
        Projects::UpdateService
          .new(project, current_user, project_update_params)
          .execute
      end

      private

      def project_update_params
        error_tracking_params
          .merge(alerting_setting_params)
          .merge(prometheus_integration_params)
          .merge(incident_management_setting_params)
      end

      def alerting_setting_params
        return {} unless can?(current_user, :read_prometheus_alerts, project)

        attr = params[:alerting_setting_attributes]
        return {} unless attr

        regenerate_token = attr.delete(:regenerate_token)

        if regenerate_token
          attr[:token] = nil
        else
          attr = attr.except(:token)
        end

        { alerting_setting_attributes: attr }
      end

      def error_tracking_params
        settings = params[:error_tracking_setting_attributes]
        return {} if settings.blank?

        if error_tracking_params_partial_updates?(settings)
          error_tracking_params_for_partial_update(settings)
        else
          error_tracking_params_for_update(settings)
        end
      end

      def error_tracking_params_partial_updates?(settings)
        # Help from @splattael :bow:
        # Make sure we're converting to symbols because
        # * ActionController::Parameters#keys returns a list of strings
        # * in specs we're using hashes with symbols as keys
        update_keys = settings.keys.map(&:to_sym)

        # Integrated error tracking works without Sentry integration,
        # so we don't need to update all those values from error_tracking_params_for_update method.
        # Instead we turn it on/off with partial update together with ""enabled"" attribute.
        # But since its optional, we exclude it from the condition below.
        update_keys.delete(:integrated)

        update_keys == %i[enabled]
      end

      def error_tracking_params_for_partial_update(settings)
        { error_tracking_setting_attributes: settings }
      end

      def error_tracking_params_for_update(settings)
        api_url = ::ErrorTracking::ProjectErrorTrackingSetting.build_api_url_from(
          api_host: settings[:api_host],
          project_slug: settings.dig(:project, :slug),
          organization_slug: settings.dig(:project, :organization_slug)
        )

        params = {
          error_tracking_setting_attributes: {
            api_url: api_url,
            enabled: settings[:enabled],
            project_name: settings.dig(:project, :name),
            organization_name: settings.dig(:project, :organization_name),
            sentry_project_id: settings.dig(:project, :sentry_project_id)
          }
        }
        params[:error_tracking_setting_attributes][:token] = settings[:token] unless ::ErrorTracking::SentryClient::Token.masked_token?(settings[:token]) # Don't update token if we receive masked value
        params[:error_tracking_setting_attributes][:integrated] = settings[:integrated] unless settings[:integrated].nil?

        params
      end

      def prometheus_integration_params
        return {} unless attrs = params[:prometheus_integration_attributes]

        integration = project.find_or_initialize_integration(::Integrations::Prometheus.to_param)
        integration.assign_attributes(attrs)
        attrs = integration.to_database_hash

        { prometheus_integration_attributes: attrs }
      end

      def incident_management_setting_params
        attrs = params[:incident_management_setting_attributes]
        return {} unless attrs

        regenerate_token = attrs.delete(:regenerate_token)

        if regenerate_token
          attrs[:pagerduty_token] = nil
        else
          attrs = attrs.except(:pagerduty_token)
        end

        { incident_management_setting_attributes: attrs }
      end
    end
  end
end

Projects::Operations::UpdateService.prepend_mod_with('Projects::Operations::UpdateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::Operations::UpdateService, feature_category: :groups_and_projects do
  let_it_be_with_refind(:project) { create(:project) }
  let_it_be(:user) { create(:user) }

  let(:result) { subject.execute }

  subject { described_class.new(project, user, params) }

  describe '#execute' do
    context 'alerting setting' do
      before_all do
        project.add_maintainer(user)
      end

      shared_examples 'no operation' do
        it 'does nothing' do
          expect(result[:status]).to eq(:success)
          expect(project.reload.alerting_setting).to be_nil
        end
      end

      context 'with valid params' do
        let(:params) { { alerting_setting_attributes: alerting_params } }

        shared_examples 'setting creation' do
          it 'creates a setting' do
            expect(project.alerting_setting).to be_nil

            expect(result[:status]).to eq(:success)
            expect(project.reload.alerting_setting).not_to be_nil
          end
        end

        context 'when regenerate_token is not set' do
          let(:alerting_params) { { token: 'some token' } }

          context 'with an existing setting' do
            let!(:alerting_setting) do
              create(:project_alerting_setting, project: project)
            end

            it 'ignores provided token' do
              expect(result[:status]).to eq(:success)
              expect(project.reload.alerting_setting.token)
                .to eq(alerting_setting.token)
            end
          end

          context 'without an existing setting' do
            it_behaves_like 'setting creation'
          end
        end

        context 'when regenerate_token is set' do
          let(:alerting_params) { { regenerate_token: true } }

          context 'with an existing setting' do
            let(:token) { 'some token' }

            let!(:alerting_setting) do
              create(:project_alerting_setting, project: project, token: token)
            end

            it 'regenerates token' do
              expect(result[:status]).to eq(:success)
              expect(project.reload.alerting_setting.token).not_to eq(token)
            end
          end

          context 'without an existing setting' do
            it_behaves_like 'setting creation'

            context 'with insufficient permissions' do
              before do
                project.add_reporter(user)
              end

              it_behaves_like 'no operation'
            end
          end
        end
      end

      context 'with empty params' do
        let(:params) { {} }

        it_behaves_like 'no operation'
      end
    end

    context 'error tracking' do
      context 'with existing error tracking setting' do
        let(:params) do
          {
            error_tracking_setting_attributes: {
              enabled: false,
              integrated: true,
              api_host: 'http://gitlab.com/',
              token: 'token',
              project: {
                slug: 'project',
                name: 'Project',
                organization_slug: 'org',
                organization_name: 'Org'
              }
            }
          }
        end

        before do
          create(:project_error_tracking_setting, project: project)
        end

        it 'updates the settings' do
          expect(result[:status]).to eq(:success)

          project.reload
          expect(project.error_tracking_setting).not_to be_enabled
          expect(project.error_tracking_setting.integrated).to be_truthy
          expect(project.error_tracking_setting.api_url).to eq(
            'http://gitlab.com/api/0/projects/org/project/'
          )
          expect(project.error_tracking_setting.token).to eq('token')
          expect(project.error_tracking_setting[:project_name]).to eq('Project')
          expect(project.error_tracking_setting[:organization_name]).to eq('Org')
        end

        context 'disable error tracking' do
          before do
            params[:error_tracking_setting_attributes][:api_host] = ''
            params[:error_tracking_setting_attributes][:enabled] = false
          end

          it 'can set api_url to nil' do
            expect(result[:status]).to eq(:success)

            project.reload
            expect(project.error_tracking_setting).not_to be_enabled
            expect(project.error_tracking_setting.api_url).to be_nil
            expect(project.error_tracking_setting.token).to eq('token')
            expect(project.error_tracking_setting[:project_name]).to eq('Project')
            expect(project.error_tracking_setting[:organization_name]).to eq('Org')
          end
        end
      end

      context 'without an existing error tracking setting' do
        let(:params) do
          {
            error_tracking_setting_attributes: {
              enabled: true,
              integrated: true,
              api_host: 'http://gitlab.com/',
              token: 'token',
              project: {
                slug: 'project',
                name: 'Project',
                organization_slug: 'org',
                organization_name: 'Org'
              }
            }
          }
        end

        it 'creates a setting' do
          expect(result[:status]).to eq(:success)

          expect(project.error_tracking_setting).to be_enabled
          expect(project.error_tracking_setting.integrated).to be_truthy
          expect(project.error_tracking_setting.api_url).to eq(
            'http://gitlab.com/api/0/projects/org/project/'
          )
          expect(project.error_tracking_setting.token).to eq('token')
          expect(project.error_tracking_setting[:project_name]).to eq('Project')
          expect(project.error_tracking_setting[:organization_name]).to eq('Org')
        end
      end

      context 'partial_update' do
        let(:params) do
          {
            error_tracking_setting_attributes: {
              enabled: true
            }
          }
        end

        context 'with setting' do
          before do
            create(:project_error_tracking_setting, :disabled, project: project)
          end

          it 'service succeeds' do
            expect(result[:status]).to eq(:success)
          end

          it 'updates attributes' do
            expect { result }
              .to change { project.reload.error_tracking_setting.enabled }
              .from(false)
              .to(true)
          end

          it 'only updates enabled attribute' do
            result

            expect(project.error_tracking_setting.previous_changes.keys)
              .to contain_exactly('enabled')
          end

          context 'with integrated attribute' do
            let(:params) do
              {
                error_tracking_setting_attributes: {
                  enabled: true,
                  integrated: true
                }
              }
            end

            it 'updates integrated attribute' do
              expect { result }
                .to change { project.reload.error_tracking_setting.integrated }
                .from(false)
                .to(true)
            end

            it 'only updates enabled and integrated attributes' do
              result

              expect(project.error_tracking_setting.previous_changes.keys)
                .to contain_exactly('enabled', 'integrated')
            end
          end
        end

        context 'without setting' do
          it 'creates setting with default values' do
            expect(result[:status]).to eq(:success)
            expect(project.error_tracking_setting.enabled).to be_truthy
            expect(project.error_tracking_setting.integrated).to be_truthy
          end
        end
      end

      context 'with masked param token' do
        let(:params) do
          {
            error_tracking_setting_attributes: {
              api_host: 'https://sentrytest.gitlab.com/',
              project: {
                slug: 'sentry-project',
                organization_slug: 'sentry-org'
              },
              enabled: false,
              token: '*' * 8
            }
          }
        end

        before do
          create(:project_error_tracking_setting, project: project, token: 'token', api_url: 'https://sentrytest.gitlab.com/api/0/projects/sentry-org/sentry-project/')
        end

        it 'does not update token' do
          expect(result[:status]).to eq(:success)

          expect(project.error_tracking_setting.token).to eq('token')
        end
      end

      context 'with invalid parameters' do
        let(:params) { {} }

        let!(:error_tracking_setting) do
          create(:project_error_tracking_setting, project: project)
        end

        it 'does nothing' do
          expect(result[:status]).to eq(:success)
          expect(project.reload.error_tracking_setting)
            .to eq(error_tracking_setting)
        end
      end
    end

    context 'with inappropriate params' do
      let(:params) { { name: '' } }

      let!(:original_name) { project.name }

      it 'ignores params' do
        expect(result[:status]).to eq(:success)
        expect(project.reload.name).to eq(original_name)
      end
    end

    context 'prometheus integration' do
      context 'prometheus params were passed into service' do
        let!(:prometheus_integration) do
          create(:prometheus_integration, :instance, properties: {
            api_url: ""http://example.prometheus.com"",
            manual_configuration: ""0"",
            google_iap_audience_client_id: 123
          })
        end

        let(:params) do
          {
            prometheus_integration_attributes: {
              'api_url' => 'http://new.prometheus.com',
              'manual_configuration' => '1'
            }
          }
        end

        it 'uses Project#find_or_initialize_integration to include instance defined defaults and pass them to Projects::UpdateService', :aggregate_failures do
          expect(Projects::UpdateService).to receive(:new) do |project_arg, user_arg, update_params_hash|
            prometheus_attrs = update_params_hash[:prometheus_integration_attributes]

            expect(project_arg).to eq project
            expect(user_arg).to eq user
            expect(prometheus_attrs).to have_key('encrypted_properties')
            expect(prometheus_attrs.keys).not_to include(*%w[id project_id created_at updated_at properties])
            expect(prometheus_attrs['encrypted_properties']).not_to eq(prometheus_integration.encrypted_properties)
          end.and_call_original

          expect { subject.execute }.to change(Integrations::Prometheus, :count).by(1)

          expect(Integrations::Prometheus.last).to have_attributes(
            api_url: 'http://new.prometheus.com',
            manual_configuration: true,
            google_iap_audience_client_id: 123
          )
        end
      end

      context 'when prometheus params are not passed into service' do
        let(:params) { { something: :else } }

        it 'does not pass any prometheus params into Projects::UpdateService', :aggregate_failures do
          project_update_service = double(Projects::UpdateService)

          expect(project).not_to receive(:find_or_initialize_integration)
          expect(Projects::UpdateService)
            .to receive(:new)
            .with(project, user, {})
            .and_return(project_update_service)
          expect(project_update_service).to receive(:execute)

          subject.execute
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  module AutoDevops
    class DisableService < BaseService
      def execute
        return false unless implicitly_enabled_and_first_pipeline_failure?

        disable_auto_devops
      end

      private

      def implicitly_enabled_and_first_pipeline_failure?
        project.has_auto_devops_implicitly_enabled? &&
          first_pipeline_failure?
      end

      # We're using `limit` to optimize `auto_devops pipeline` query,
      # since we only care about the first element, and using only `.count`
      # is an expensive operation. See
      # https://gitlab.com/gitlab-org/gitlab-foss/merge_requests/21172#note_99037378
      # for more context.
      # rubocop: disable CodeReuse/ActiveRecord
      def first_pipeline_failure?
        auto_devops_pipelines.success.limit(1).count == 0 &&
          auto_devops_pipelines.failed.limit(1).count.nonzero?
      end
      # rubocop: enable CodeReuse/ActiveRecord

      def disable_auto_devops
        project.auto_devops_attributes = { enabled: false }
        project.save!
      end

      def auto_devops_pipelines
        @auto_devops_pipelines ||= project.ci_pipelines.auto_devops_source
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Projects::AutoDevops::DisableService, '#execute', feature_category: :auto_devops do
  let(:project) { create(:project, :repository, :auto_devops) }
  let(:auto_devops) { project.auto_devops }

  subject { described_class.new(project).execute }

  context 'when Auto DevOps disabled at instance level' do
    before do
      stub_application_setting(auto_devops_enabled: false)
    end

    it { is_expected.to be_falsy }
  end

  context 'when Auto DevOps enabled at instance level' do
    before do
      stub_application_setting(auto_devops_enabled: true)
    end

    context 'when Auto DevOps explicitly enabled on project' do
      before do
        auto_devops.update!(enabled: true)
      end

      it { is_expected.to be_falsy }
    end

    context 'when Auto DevOps explicitly disabled on project' do
      before do
        auto_devops.update!(enabled: false)
      end

      it { is_expected.to be_falsy }
    end

    context 'when Auto DevOps is implicitly enabled' do
      before do
        auto_devops.update!(enabled: nil)
      end

      context 'when is the first pipeline failure' do
        before do
          create(:ci_pipeline, :failed, :auto_devops_source, project: project)
        end

        it 'disables Auto DevOps for project' do
          subject

          expect(auto_devops.enabled).to eq(false)
        end
      end

      context 'when it is not the first pipeline failure' do
        before do
          create_list(:ci_pipeline, 2, :failed, :auto_devops_source, project: project)
        end

        it 'explicitly disables Auto DevOps for project' do
          subject

          expect(auto_devops.reload.enabled).to eq(false)
        end
      end

      context 'when an Auto DevOps pipeline has succeeded before' do
        before do
          create(:ci_pipeline, :success, :auto_devops_source, project: project)
        end

        it 'does not disable Auto DevOps for project' do
          subject

          expect(auto_devops.reload.enabled).to be_nil
        end
      end
    end

    context 'when project does not have an Auto DevOps record related' do
      let(:project) { create(:project, :repository) }

      before do
        create(:ci_pipeline, :failed, :auto_devops_source, project: project)
      end

      it 'disables Auto DevOps for project' do
        subject
        auto_devops = project.reload.auto_devops

        expect(auto_devops.enabled).to eq(false)
      end

      it 'creates a ProjectAutoDevops record' do
        expect { subject }.to change { ProjectAutoDevops.count }.from(0).to(1)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  module DeployTokens
    class DestroyService < BaseService
      include DeployTokenMethods

      def execute
        destroy_deploy_token(@project, params)
      end
    end
  end
end

Projects::DeployTokens::DestroyService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::DeployTokens::DestroyService, feature_category: :continuous_delivery do
  it_behaves_like 'a deploy token deletion service' do
    let_it_be(:entity) { create(:project) }
    let_it_be(:deploy_token_class) { ProjectDeployToken }
    let_it_be(:deploy_token) { create(:deploy_token, projects: [entity]) }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  module DeployTokens
    class CreateService < BaseService
      include DeployTokenMethods

      def execute
        deploy_token = create_deploy_token_for(@project, current_user, params)

        create_deploy_token_payload_for(deploy_token)
      end
    end
  end
end

Projects::DeployTokens::CreateService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::DeployTokens::CreateService, feature_category: :continuous_delivery do
  it_behaves_like 'a deploy token creation service' do
    let(:entity) { create(:project) }
    let(:deploy_token_class) { ProjectDeployToken }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  module Forks
    # A service for fetching upstream default branch and merging it to the fork's specified branch.
    class SyncService < BaseService
      ONGOING_MERGE_ERROR = 'The synchronization did not happen due to another merge in progress'

      MergeError = Class.new(StandardError)

      def initialize(project, user, target_branch)
        super(project, user)

        @source_project = project.fork_source
        @head_sha = project.repository.commit(target_branch).sha
        @target_branch = target_branch
        @details = Projects::Forks::Details.new(project, target_branch)
      end

      def execute
        execute_service

        ServiceResponse.success
      rescue MergeError => e
        Gitlab::ErrorTracking.log_exception(e, { project_id: project.id, user_id: current_user.id })

        ServiceResponse.error(message: e.message)
      ensure
        details.exclusive_lease.cancel
      end

      private

      attr_reader :source_project, :head_sha, :target_branch, :details

      # The method executes multiple steps:
      #
      # 1. Gitlab::Git::CrossRepo fetches upstream default branch into a temporary ref and returns new source sha.
      # 2. New divergence counts are calculated using the source sha.
      # 3. If the fork is not behind, there is nothing to merge -> exit.
      # 4. Otherwise, continue with the new source sha.
      # 5. If Gitlab::Git::CommandError is raised it means that merge couldn't happen due to a merge conflict. The
      #    details are updated to transfer this error to the user.
      def execute_service
        counts = []
        source_sha = source_project.commit.sha

        Gitlab::Git::CrossRepo.new(repository, source_project.repository)
          .execute(source_sha) do |cross_repo_source_sha|
            counts = repository.diverging_commit_count(head_sha, cross_repo_source_sha)
            ahead, behind = counts
            next if behind == 0

            execute_with_fetched_source(cross_repo_source_sha, ahead)
          end
      rescue Gitlab::Git::CommandError => e
        details.update!({ sha: head_sha, source_sha: source_sha, counts: counts, has_conflicts: true })

        raise MergeError, e.message
      end

      def execute_with_fetched_source(cross_repo_source_sha, ahead)
        with_linked_lfs_pointers(cross_repo_source_sha) do
          merge_commit_id = perform_merge(cross_repo_source_sha, ahead)
          raise MergeError, ONGOING_MERGE_ERROR unless merge_commit_id
        end
      end

      # This method merges the upstream default branch to the fork specified branch.
      # Depending on whether the fork branch is ahead of upstream or not, a different type of
      # merge is performed.
      #
      # If the fork's branch is not ahead of the upstream (only behind), fast-forward merge is performed.
      # However, if the fork's branch contains commits that don't exist upstream, a merge commit is created.
      # In this case, a conflict may happen, which interrupts the merge and returns a message to the user.
      def perform_merge(cross_repo_source_sha, ahead)
        if ahead > 0
          message = ""Merge branch #{source_project.path}:#{source_project.default_branch} into #{target_branch}""

          repository.merge_to_branch(current_user,
            source_sha: cross_repo_source_sha,
            target_branch: target_branch,
            target_sha: head_sha,
            message: message)
        else
          repository.ff_merge(current_user, cross_repo_source_sha, target_branch, target_sha: head_sha)
        end
      end

      # This method links the newly merged lfs objects (if any) with the existing ones upstream.
      # The LfsLinkService service has a limit and may raise an error if there are too many lfs objects to link.
      # This is the reason why the block is passed:
      #
      # 1. Verify that there are not too many lfs objects to link
      # 2. Execute the block (which basically performs the merge)
      # 3. Link lfs objects
      def with_linked_lfs_pointers(newrev, &block)
        return yield unless project.lfs_enabled?

        oldrev = head_sha
        new_lfs_oids =
          Gitlab::Git::LfsChanges
            .new(repository, newrev)
            .new_pointers(not_in: [oldrev])
            .map(&:lfs_oid)

        Projects::LfsPointers::LfsLinkService.new(project).execute(new_lfs_oids, &block)
      rescue Projects::LfsPointers::LfsLinkService::TooManyOidsError => e
        raise MergeError, e.message
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::Forks::SyncService, feature_category: :source_code_management do
  include ProjectForksHelper
  include RepoHelpers

  let_it_be(:user) { create(:user) }
  let_it_be(:source_project) { create(:project, :repository, :public) }
  let_it_be(:project) { fork_project(source_project, user, { repository: true }) }

  let(:fork_branch) { project.default_branch }
  let(:service) { described_class.new(project, user, fork_branch) }

  def details
    Projects::Forks::Details.new(project, fork_branch)
  end

  def expect_to_cancel_exclusive_lease
    expect(Gitlab::ExclusiveLease).to receive(:cancel)
  end

  describe '#execute' do
    context 'when fork is up-to-date with the upstream' do
      it 'does not perform merge' do
        expect_to_cancel_exclusive_lease
        expect(project.repository).not_to receive(:merge_to_branch)
        expect(project.repository).not_to receive(:ff_merge)

        expect(service.execute).to be_success
      end
    end

    context 'when fork is behind the upstream' do
      let_it_be(:base_commit) { source_project.commit.sha }

      before_all do
        source_project.repository.commit_files(
          user,
          branch_name: source_project.repository.root_ref, message: 'Commit to root ref',
          actions: [{ action: :create, file_path: 'encoding/CHANGELOG', content: 'One more' }]
        )

        source_project.repository.commit_files(
          user,
          branch_name: source_project.repository.root_ref, message: 'Another commit to root ref',
          actions: [{ action: :create, file_path: 'encoding/NEW-CHANGELOG', content: 'One more time' }]
        )
      end

      before do
        project.repository.create_branch(fork_branch, base_commit)
      end

      context 'when fork is not ahead of the upstream' do
        let(:fork_branch) { 'fork-without-new-commits' }

        it 'updates the fork using ff merge' do
          expect_to_cancel_exclusive_lease
          expect(project.commit(fork_branch).sha).to eq(base_commit)
          expect(project.repository).to receive(:ff_merge)
            .with(user, source_project.commit.sha, fork_branch, target_sha: base_commit)
            .and_call_original

          expect do
            expect(service.execute).to be_success
          end.to change { details.counts }.from({ ahead: 0, behind: 2 }).to({ ahead: 0, behind: 0 })
        end
      end

      context 'when fork is ahead of the upstream' do
        context 'and has conflicts with the upstream', :use_clean_rails_redis_caching do
          let(:fork_branch) { 'fork-with-conflicts' }

          it 'returns an error' do
            project.repository.commit_files(
              user,
              branch_name: fork_branch, message: 'Committing something',
              actions: [{ action: :create, file_path: 'encoding/CHANGELOG', content: 'New file' }]
            )

            expect_to_cancel_exclusive_lease
            expect(details).not_to have_conflicts

            expect do
              result = service.execute

              expect(result).to be_error
              expect(result.message).to eq(""9:merging commits: merge: there are conflicting files."")
            end.not_to change { details.counts }

            expect(details).to have_conflicts
          end
        end

        context 'and does not have conflicts with the upstream' do
          let(:fork_branch) { 'fork-with-new-commits' }

          it 'updates the fork using merge' do
            project.repository.commit_files(
              user,
              branch_name: fork_branch, message: 'Committing completely new changelog',
              actions: [{ action: :create, file_path: 'encoding/COMPLETELY-NEW-CHANGELOG', content: 'New file' }]
            )

            commit_message = ""Merge branch #{source_project.path}:#{source_project.default_branch} into #{fork_branch}""
            expect(project.repository).to receive(:merge_to_branch).with(
              user,
              source_sha: source_project.commit.sha,
              target_branch: fork_branch,
              target_sha: project.commit(fork_branch).sha,
              message: commit_message
            ).and_call_original
            expect_to_cancel_exclusive_lease

            expect do
              expect(service.execute).to be_success
            end.to change { details.counts }.from({ ahead: 1, behind: 2 }).to({ ahead: 2, behind: 0 })

            commits = project.repository.commits_between(source_project.commit.sha, project.commit(fork_branch).sha)
            expect(commits.map(&:message)).to eq([
              ""Committing completely new changelog"",
              commit_message
            ])
          end
        end
      end

      context 'when a merge cannot happen due to another ongoing merge' do
        it 'does not merge' do
          expect(service).to receive(:perform_merge).and_return(nil)

          result = service.execute

          expect(result).to be_error
          expect(result.message).to eq(described_class::ONGOING_MERGE_ERROR)
        end
      end

      context 'when upstream branch contains lfs reference' do
        let(:source_project) { create(:project, :repository, :public) }
        let(:project) { fork_project(source_project, user, { repository: true }) }
        let(:fork_branch) { 'fork-fetches-lfs-pointers' }

        before do
          source_project.change_head('lfs')

          allow(source_project).to receive(:lfs_enabled?).and_return(true)
          allow(project).to receive(:lfs_enabled?).and_return(true)

          create_file_in_repo(source_project, 'lfs', 'lfs', 'one.lfs', 'One')
          create_file_in_repo(source_project, 'lfs', 'lfs', 'two.lfs', 'Two')
        end

        it 'links fetched lfs objects to the fork project', :aggregate_failures do
          expect_to_cancel_exclusive_lease

          expect do
            expect(service.execute).to be_success
          end.to change { project.reload.lfs_objects.size }.from(0).to(2)
            .and change { details.counts }.from({ ahead: 0, behind: 3 }).to({ ahead: 0, behind: 0 })

          expect(project.lfs_objects).to match_array(source_project.lfs_objects)
        end

        context 'and there are too many of them for a single sync' do
          let(:fork_branch) { 'fork-too-many-lfs-pointers' }

          it 'updates the fork successfully' do
            expect_to_cancel_exclusive_lease
            stub_const('Projects::LfsPointers::LfsLinkService::MAX_OIDS', 1)

            expect do
              result = service.execute

              expect(result).to be_error
              expect(result.message).to eq('Too many LFS object ids to link, please push them manually')
            end.not_to change { details.counts }
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  module Prometheus
    module Metrics
      class DestroyService < Metrics::BaseService
        def execute
          metric.destroy
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::Prometheus::Metrics::DestroyService, feature_category: :metrics do
  let(:metric) { create(:prometheus_metric) }

  subject { described_class.new(metric) }

  it 'destroys metric' do
    subject.execute

    expect(PrometheusMetric.find_by(id: metric.id)).to be_nil
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Projects
  module Prometheus
    module Alerts
      class NotifyService < ::BaseProjectService
        include Gitlab::Utils::StrongMemoize
        include ::AlertManagement::Responses

        # This set of keys identifies a payload as a valid Prometheus
        # payload and thus processable by this service. See also
        # https://prometheus.io/docs/alerting/configuration/#webhook_config
        REQUIRED_PAYLOAD_KEYS = %w[
          version groupKey status receiver groupLabels commonLabels
          commonAnnotations externalURL alerts
        ].to_set.freeze

        SUPPORTED_VERSION = '4'

        # If feature flag :prometheus_notify_max_alerts is enabled truncate
        # alerts to 100 and process only them.
        # If feature flag is disabled process any amount of alerts.
        #
        # This is to mitigate incident:
        # https://gitlab.com/gitlab-com/gl-infra/production/-/issues/6086
        PROCESS_MAX_ALERTS = 100

        def initialize(project, params)
          super(project: project, params: params.to_h)
        end

        def execute(token, integration = nil)
          return bad_request unless valid_payload_size?
          return unprocessable_entity unless self.class.processable?(params)
          return unauthorized unless valid_alert_manager_token?(token, integration)

          truncate_alerts! if max_alerts_exceeded?

          process_prometheus_alerts(integration)

          created
        end

        def self.processable?(payload)
          # Workaround for https://gitlab.com/gitlab-org/gitlab/-/issues/220496
          return false unless payload

          REQUIRED_PAYLOAD_KEYS.subset?(payload.keys.to_set) &&
            payload['version'] == SUPPORTED_VERSION
        end

        private

        def valid_payload_size?
          Gitlab::Utils::DeepSize.new(params).valid?
        end

        def max_alerts_exceeded?
          return false unless Feature.enabled?(:prometheus_notify_max_alerts, project, type: :ops)

          alerts.size > PROCESS_MAX_ALERTS
        end

        def truncate_alerts!
          Gitlab::AppLogger.warn(
            message: 'Prometheus payload exceeded maximum amount of alerts. Truncating alerts.',
            project_id: project.id,
            alerts: {
              total: alerts.size,
              max: PROCESS_MAX_ALERTS
            }
          )

          params['alerts'] = alerts.first(PROCESS_MAX_ALERTS)
        end

        def alerts
          params['alerts']
        end

        def valid_alert_manager_token?(token, integration)
          valid_for_alerts_endpoint?(token, integration) ||
            valid_for_manual?(token)
        end

        def valid_for_manual?(token)
          # If migration from Integrations::Prometheus to
          # AlertManagement::HttpIntegrations is complete,
          # we should use use the HttpIntegration as SSOT.
          # Remove with https://gitlab.com/gitlab-org/gitlab/-/issues/409734
          return false if project.alert_management_http_integrations
                            .for_endpoint_identifier('legacy-prometheus')
                            .any?

          prometheus = project.find_or_initialize_integration('prometheus')
          return false unless prometheus.manual_configuration?

          if setting = project.alerting_setting
            compare_token(token, setting.token)
          else
            token.nil?
          end
        end

        def valid_for_alerts_endpoint?(token, integration)
          return false unless integration&.active?

          compare_token(token, integration.token)
        end

        def compare_token(expected, actual)
          return unless expected && actual

          ActiveSupport::SecurityUtils.secure_compare(expected, actual)
        end

        def process_prometheus_alerts(integration)
          alerts.map do |alert|
            AlertManagement::ProcessPrometheusAlertService
              .new(project, alert, integration: integration)
              .execute
          end
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Projects::Prometheus::Alerts::NotifyService, feature_category: :incident_management do
  include PrometheusHelpers
  using RSpec::Parameterized::TableSyntax

  let_it_be_with_reload(:project) { create(:project) }
  let_it_be_with_refind(:setting) do
    create(:project_incident_management_setting, project: project, send_email: true, create_issue: true)
  end

  let(:service) { described_class.new(project, payload) }
  let(:token_input) { 'token' }

  subject { service.execute(token_input) }

  context 'with valid payload' do
    let(:payload_raw) { prometheus_alert_payload(firing: ['Alert A'], resolved: ['Alert B']) }
    let(:payload) { ActionController::Parameters.new(payload_raw).permit! }
    let(:payload_alert_firing) { payload_raw['alerts'].first }
    let(:token) { 'token' }
    let(:source) { 'Prometheus' }

    context 'with manual prometheus installation' do
      where(:alerting_setting, :configured_token, :token_input, :result) do
        true  | token | token | :success
        true  | token | 'x'   | :failure
        true  | token | nil   | :failure
        false | nil   | nil   | :success
        false | nil   | token | :failure
      end

      with_them do
        let(:alert_manager_token) { token_input }

        before do
          create(:prometheus_integration, project: project)

          if alerting_setting
            create(
              :project_alerting_setting,
              project: project,
              token: configured_token
            )
          end
        end

        case result = params[:result]
        when :success
          it_behaves_like 'processes one firing and one resolved prometheus alerts'
        when :failure
          it_behaves_like 'alerts service responds with an error and takes no actions', :unauthorized
        else
          raise ""invalid result: #{result.inspect}""
        end
      end
    end

    context 'with HTTP integration' do
      where(:active, :token, :result) do
        :active   | :valid    | :success
        :active   | :invalid  | :failure
        :active   | nil       | :failure
        :inactive | :valid    | :failure
        nil       | nil       | :failure
      end

      with_them do
        let(:valid) { integration.token }
        let(:invalid) { 'invalid token' }
        let(:token_input) { public_send(token) if token }
        let(:integration) { create(:alert_management_http_integration, active, project: project) if active }

        subject { service.execute(token_input, integration) }

        case result = params[:result]
        when :success
          it_behaves_like 'processes one firing and one resolved prometheus alerts'
        when :failure
          it_behaves_like 'alerts service responds with an error and takes no actions', :unauthorized
        else
          raise ""invalid result: #{result.inspect}""
        end
      end

      context 'with simultaneous manual configuration' do
        let_it_be(:alerting_setting) { create(:project_alerting_setting, :with_http_integration, project: project) }
        let_it_be(:old_prometheus_integration) { create(:prometheus_integration, project: project) }
        let_it_be(:integration) { project.alert_management_http_integrations.last! }

        subject { service.execute(integration.token, integration) }

        it_behaves_like 'processes one firing and one resolved prometheus alerts'

        context 'when HTTP integration is inactive' do
          before do
            integration.update!(active: false)
          end

          it_behaves_like 'alerts service responds with an error and takes no actions', :unauthorized
        end
      end
    end

    context 'incident settings' do
      before do
        create(:prometheus_integration, project: project)
        create(:project_alerting_setting, project: project, token: token)
      end

      it_behaves_like 'processes one firing and one resolved prometheus alerts'

      context 'when incident_management_setting does not exist' do
        before do
          setting.destroy!
        end

        it { is_expected.to be_success }

        include_examples 'does not send alert notification emails'
        include_examples 'does not process incident issues'
      end

      context 'incident_management_setting.send_email is false' do
        before do
          setting.update!(send_email: false)
        end

        it { is_expected.to be_success }

        include_examples 'does not send alert notification emails'
      end

      context 'incident_management_setting.create_issue is false' do
        before do
          setting.update!(create_issue: false)
        end

        it { is_expected.to be_success }

        include_examples 'does not process incident issues'
      end
    end

    context 'process Alert Management alerts' do
      let(:integration) { build_stubbed(:alert_management_http_integration, project: project, token: token) }

      subject { service.execute(token_input, integration) }

      context 'with multiple firing alerts and resolving alerts' do
        let(:payload_raw) do
          prometheus_alert_payload(firing: ['Alert A', 'Alert A'], resolved: ['Alert B'])
        end

        it 'processes Prometheus alerts' do
          expect(AlertManagement::ProcessPrometheusAlertService)
            .to receive(:new)
            .with(project, kind_of(Hash), integration: integration)
            .exactly(3).times
            .and_call_original

          subject
        end
      end
    end

    context 'when payload exceeds max amount of processable alerts' do
      # We are defining 2 alerts in payload_raw above
      let(:max_alerts) { 1 }
      let(:fingerprint) { prometheus_alert_payload_fingerprint('Alert A') }

      before do
        stub_const(""#{described_class}::PROCESS_MAX_ALERTS"", max_alerts)

        create(:prometheus_integration, project: project)
        create(:project_alerting_setting, project: project, token: token)
        create(:alert_management_alert, project: project, fingerprint: fingerprint)

        allow(Gitlab::AppLogger).to receive(:warn)
      end

      shared_examples 'process truncated alerts' do
        it 'returns 201 but skips processing and logs a warning', :aggregate_failures do
          expect(subject).to be_success
          expect(subject.payload).to eq({})
          expect(subject.http_status).to eq(:created)
          expect(Gitlab::AppLogger)
            .to have_received(:warn)
            .with(
              message: 'Prometheus payload exceeded maximum amount of alerts. Truncating alerts.',
              project_id: project.id,
              alerts: {
                total: 2,
                max: max_alerts
              })
        end
      end

      shared_examples 'process all alerts' do
        it 'returns 201 and process alerts without warnings', :aggregate_failures do
          expect(subject).to be_success
          expect(subject.payload).to eq({})
          expect(subject.http_status).to eq(:created)
          expect(Gitlab::AppLogger).not_to have_received(:warn)
        end
      end

      context 'with feature flag globally enabled' do
        before do
          stub_feature_flags(prometheus_notify_max_alerts: true)
        end

        include_examples 'process truncated alerts'
      end

      context 'with feature flag enabled on project' do
        before do
          stub_feature_flags(prometheus_notify_max_alerts: project)
        end

        include_examples 'process truncated alerts'
      end

      context 'with feature flag enabled on unrelated project' do
        let(:another_project) { create(:project) }

        before do
          stub_feature_flags(prometheus_notify_max_alerts: another_project)
        end

        include_examples 'process all alerts'
      end

      context 'with feature flag disabled' do
        before do
          stub_feature_flags(prometheus_notify_max_alerts: false)
        end

        include_examples 'process all alerts'
      end
    end
  end

  context 'with invalid payload' do
    context 'when payload is not processable' do
      let(:payload) { {} }

      before do
        allow(described_class).to receive(:processable?).with(payload)
          .and_return(false)
      end

      it_behaves_like 'alerts service responds with an error and takes no actions', :unprocessable_entity
    end

    context 'when the payload is too big' do
      let(:payload_raw) { { 'the-payload-is-too-big' => true } }
      let(:payload) { ActionController::Parameters.new(payload_raw).permit! }

      before do
        stub_const('::Gitlab::Utils::DeepSize::DEFAULT_MAX_DEPTH', 0)
      end

      it_behaves_like 'alerts service responds with an error and takes no actions', :bad_request
    end
  end

  describe '.processable?' do
    let(:valid_payload) { prometheus_alert_payload }

    subject { described_class.processable?(payload) }

    context 'with valid payload' do
      let(:payload) { valid_payload }

      it { is_expected.to eq(true) }

      context 'containing unrelated keys' do
        let(:payload) { valid_payload.merge('unrelated' => 'key') }

        it { is_expected.to eq(true) }
      end
    end

    context 'with invalid payload' do
      where(:missing_key) do
        described_class::REQUIRED_PAYLOAD_KEYS.to_a
      end

      with_them do
        let(:payload) { valid_payload.except(missing_key) }

        it { is_expected.to eq(false) }
      end
    end

    context 'with unsupported version' do
      let(:payload) { valid_payload.merge('version' => '5') }

      it { is_expected.to eq(false) }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# This service yields operation on each download link from a remote source based on the
# oids provided
module Projects
  module LfsPointers
    class LfsDownloadLinkListService < BaseService
      DOWNLOAD_ACTION = 'download'

      # This could be different per server, but it seems like a reasonable value to start with.
      # https://github.com/git-lfs/git-lfs/issues/419
      REQUEST_BATCH_SIZE = 100

      DownloadLinksError = Class.new(StandardError)
      DownloadLinkNotFound = Class.new(StandardError)
      DownloadLinksRequestEntityTooLargeError = Class.new(StandardError)

      attr_reader :remote_uri

      def initialize(project, remote_uri: nil)
        super(project)

        @remote_uri = remote_uri
      end

      # - oids: hash of oids to query. The structure is { lfs_file_oid => lfs_file_size }
      # Yields operation for each link batch-by-batch
      def each_link(oids, &block)
        return unless project&.lfs_enabled? && remote_uri && oids.present?

        download_links_in_batches(oids, &block)
      end

      private

      def download_links_in_batches(oids, batch_size = REQUEST_BATCH_SIZE, &block)
        oids.each_slice(batch_size) do |batch|
          download_links_for(batch).each(&block)
        end
      rescue DownloadLinksRequestEntityTooLargeError => e
        # Log this exceptions to see how often it happens
        Gitlab::ErrorTracking
          .track_exception(e, project_id: project&.id, batch_size: batch_size, oids_count: oids.count)

        # Try again with a smaller batch
        batch_size /= 2

        retry if batch_size > REQUEST_BATCH_SIZE / 3

        raise DownloadLinksError, 'Unable to download due to RequestEntityTooLarge errors'
      end

      def download_links_for(oids)
        response = Gitlab::HTTP.post(remote_uri, body: request_body(oids), headers: headers)

        raise DownloadLinksRequestEntityTooLargeError if response.request_entity_too_large?
        raise DownloadLinksError, response.message unless response.success?

        # Since the LFS Batch API may return a Content-Ttpe of
        # application/vnd.git-lfs+json
        # (https://github.com/git-lfs/git-lfs/blob/master/docs/api/batch.md#requests),
        # HTTParty does not know this is actually JSON.
        data = Gitlab::Json.parse(response.body)

        raise DownloadLinksError, ""LFS Batch API did return any objects"" unless data.is_a?(Hash) && data.key?('objects')

        parse_response_links(data['objects'])
      rescue JSON::ParserError
        raise DownloadLinksError, ""LFS Batch API response is not JSON""
      end

      def parse_response_links(objects_response)
        objects_response.each_with_object([]) do |entry, link_list|
          link = entry.dig('actions', DOWNLOAD_ACTION, 'href')
          headers = entry.dig('actions', DOWNLOAD_ACTION, 'header')

          raise DownloadLinkNotFound unless link

          link_list << LfsDownloadObject.new(
            oid: entry['oid'],
            size: entry['size'],
            headers: headers,
            link: add_credentials(link)
          )
        rescue DownloadLinkNotFound, Addressable::URI::InvalidURIError
          log_error(""Link for Lfs Object with oid #{entry['oid']} not found or invalid."")
        end
      end

      def request_body(oids)
        body = {
          operation: DOWNLOAD_ACTION,
          objects: oids.map { |oid, size| { oid: oid, size: size } }
        }

        Gitlab::Json.dump(body)
      end

      def headers
        {
          'Accept' => LfsRequest::CONTENT_TYPE,
          'Content-Type' => LfsRequest::CONTENT_TYPE
        }.freeze
      end

      def add_credentials(link)
        uri = Addressable::URI.parse(link)

        if should_add_credentials?(uri)
          uri.user = remote_uri.user
          uri.password = remote_uri.password
        end

        uri.to_s
      end

      # The download link can be a local url or an object storage url
      # If the download link has the some host as the import url then
      # we add the same credentials because we may need them
      def should_add_credentials?(link_uri)
        url_credentials? && link_uri.host == remote_uri.host
      end

      def url_credentials?
        remote_uri.user.present? || remote_uri.password.present?
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Projects::LfsPointers::LfsDownloadLinkListService, feature_category: :source_code_management do
  let(:import_url) { 'http://www.gitlab.com/demo/repo.git' }
  let(:lfs_endpoint) { ""#{import_url}/info/lfs/objects/batch"" }
  let!(:project) { create(:project, import_url: import_url) }
  let(:new_oids) { { 'oid1' => 123, 'oid2' => 125 } }
  let(:headers) { { 'X-Some-Header' => '456' } }
  let(:remote_uri) { URI.parse(lfs_endpoint) }

  let(:request_object) { HTTParty::Request.new(Net::HTTP::Post, '/') }
  let(:parsed_block) { lambda {} }
  let(:success_net_response) { Net::HTTPOK.new('', '', '') }
  let(:response) { Gitlab::HTTP::Response.new(request_object, net_response, parsed_block) }

  def objects_response(oids)
    body = oids.map do |oid, size|
      {
        'oid' => oid, 'size' => size,
        'actions' => {
          'download' => { 'href' => ""#{import_url}/gitlab-lfs/objects/#{oid}"", header: headers }
        }
      }
    end

    Struct.new(:success?, :objects).new(true, body).to_json
  end

  def custom_response(net_response, body = nil)
    allow(net_response).to receive(:body).and_return(body)
    Gitlab::HTTP::Response.new(request_object, net_response, parsed_block)
  end

  let(:invalid_object_response) do
    [
      'oid' => 'whatever',
      'size' => 123
    ]
  end

  subject(:service) { described_class.new(project, remote_uri: remote_uri) }

  before do
    allow(project).to receive(:lfs_enabled?).and_return(true)

    response = custom_response(success_net_response, objects_response(new_oids))
    allow(Gitlab::HTTP).to receive(:post).and_return(response)
  end

  describe '#each_link' do
    it 'retrieves each download link of every non existent lfs object' do
      links = []
      service.each_link(new_oids) { |lfs_download_object| links << lfs_download_object.link }

      expect(links).to contain_exactly(
        ""#{import_url}/gitlab-lfs/objects/oid1"",
        ""#{import_url}/gitlab-lfs/objects/oid2""
      )
    end

    it 'stores headers' do
      expected_headers = []
      service.each_link(new_oids) do |lfs_download_object|
        expected_headers << lfs_download_object.headers
      end

      expect(expected_headers).to contain_exactly(headers, headers)
    end

    context 'when lfs objects size is larger than the batch size' do
      def stub_successful_request(batch)
        response = custom_response(success_net_response, objects_response(batch))
        stub_request(batch, response)
      end

      def stub_entity_too_large_error_request(batch)
        entity_too_large_net_response = Net::HTTPRequestEntityTooLarge.new('', '', '')
        response = custom_response(entity_too_large_net_response)
        stub_request(batch, response)
      end

      def stub_request(batch, response)
        expect(Gitlab::HTTP).to receive(:post).with(
          remote_uri,
          {
            body: { operation: 'download', objects: batch.map { |k, v| { oid: k, size: v } } }.to_json,
            headers: subject.send(:headers)
          }
        ).and_return(response)
      end

      let(:new_oids) { { 'oid1' => 123, 'oid2' => 125, 'oid3' => 126, 'oid4' => 127, 'oid5' => 128 } }

      context 'when batch size' do
        before do
          stub_const(""#{described_class.name}::REQUEST_BATCH_SIZE"", 2)

          data = new_oids.to_a
          stub_successful_request([data[0], data[1]])
          stub_successful_request([data[2], data[3]])
          stub_successful_request([data[4]])
        end

        it 'retrieves them in batches' do
          checksum = 0
          service.each_link(new_oids) do |lfs_download_object|
            expect(lfs_download_object.link).to eq ""#{import_url}/gitlab-lfs/objects/#{lfs_download_object.oid}""
            checksum += 1
          end
          expect(checksum).to eq new_oids.size
        end
      end

      context 'when request fails with PayloadTooLarge error' do
        let(:error_class) { described_class::DownloadLinksRequestEntityTooLargeError }

        context 'when the smaller batch eventually works' do
          before do
            stub_const(""#{described_class.name}::REQUEST_BATCH_SIZE"", 5)

            data = new_oids.to_a

            # with the batch size of 5
            stub_entity_too_large_error_request(data)

            # with the batch size of 2
            stub_successful_request([data[0], data[1]])
            stub_successful_request([data[2], data[3]])
            stub_successful_request([data[4]])
          end

          it 'retreives them eventually and logs exceptions' do
            expect(Gitlab::ErrorTracking).to receive(:track_exception).with(
              an_instance_of(error_class), project_id: project.id, batch_size: 5, oids_count: 5
            )

            checksum = 0
            service.each_link(new_oids) do |lfs_download_object|
              expect(lfs_download_object.link).to eq ""#{import_url}/gitlab-lfs/objects/#{lfs_download_object.oid}""
              checksum += 1
            end
            expect(checksum).to eq new_oids.size
          end
        end

        context 'when batch size cannot be any smaller' do
          before do
            stub_const(""#{described_class.name}::REQUEST_BATCH_SIZE"", 5)

            data = new_oids.to_a

            # with the batch size of 5
            stub_entity_too_large_error_request(data)

            # with the batch size of 2
            stub_entity_too_large_error_request([data[0], data[1]])
          end

          it 'raises an error and logs exceptions' do
            expect(Gitlab::ErrorTracking).to receive(:track_exception).with(
              an_instance_of(error_class), project_id: project.id, batch_size: 5, oids_count: 5
            )
            expect(Gitlab::ErrorTracking).to receive(:track_exception).with(
              an_instance_of(error_class), project_id: project.id, batch_size: 2, oids_count: 5
            )
            expect { service.each_link(new_oids) }.to raise_error(described_class::DownloadLinksError)
          end
        end
      end
    end

    context 'credentials' do
      context 'when the download link and the lfs_endpoint have the same host' do
        context 'when lfs_endpoint has credentials' do
          let(:import_url) { 'http://user:password@www.gitlab.com/demo/repo.git' }

          it 'adds credentials to the download_link' do
            checksum = 0
            service.each_link(new_oids) do |lfs_download_object|
              expect(lfs_download_object.link.starts_with?('http://user:password@')).to be_truthy
              checksum += 1
            end
            expect(checksum).to eq new_oids.size
          end
        end

        context 'when lfs_endpoint does not have any credentials' do
          it 'does not add any credentials' do
            checksum = 0
            service.each_link(new_oids) do |lfs_download_object|
              expect(lfs_download_object.link.starts_with?('http://user:password@')).to be_falsey
              checksum += 1
            end
            expect(checksum).to eq new_oids.size
          end
        end
      end

      context 'when the download link and the lfs_endpoint have different hosts' do
        let(:import_url_with_credentials) { 'http://user:password@www.otherdomain.com/demo/repo.git' }
        let(:lfs_endpoint) { ""#{import_url_with_credentials}/info/lfs/objects/batch"" }

        it 'downloads without any credentials' do
          checksum = 0
          service.each_link(new_oids) do |lfs_download_object|
            expect(lfs_download_object.link.starts_with?('http://user:password@')).to be_falsey
            checksum += 1
          end
          expect(checksum).to eq new_oids.size
        end
      end
    end
  end

  describe '#download_links_for' do
    context 'if request fails' do
      before do
        request_timeout_net_response = Net::HTTPRequestTimeout.new('', '', '')
        response = custom_response(request_timeout_net_response)
        allow(Gitlab::HTTP).to receive(:post).and_return(response)
      end

      it 'raises an error' do
        expect { subject.send(:download_links_for, new_oids) }.to raise_error(described_class::DownloadLinksError)
      end
    end

    shared_examples 'JSON parse errors' do |body|
      it 'raises an error' do
        response = custom_response(success_net_response)
        allow(response).to receive(:body).and_return(body)
        allow(Gitlab::HTTP).to receive(:post).and_return(response)

        expect { subject.send(:download_links_for, new_oids) }.to raise_error(described_class::DownloadLinksError)
      end
    end

    it_behaves_like 'JSON parse errors', '{'
    it_behaves_like 'JSON parse errors', '{}'
    it_behaves_like 'JSON parse errors', '{ foo: 123 }'
  end

  describe '#parse_response_links' do
    it 'does not add oid entry if href not found' do
      expect(subject).to receive(:log_error).with(""Link for Lfs Object with oid whatever not found or invalid."")

      result = subject.send(:parse_response_links, invalid_object_response)

      expect(result).to be_empty
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# This service is responsible of managing the retrieval of the lfs objects,
# and call the service LfsDownloadService, which performs the download
# for each of the retrieved lfs objects
module Projects
  module LfsPointers
    class LfsImportService < BaseService
      def execute
        return success unless project&.lfs_enabled?

        LfsObjectDownloadListService.new(project).each_list_item do |lfs_download_object|
          LfsDownloadService.new(project, lfs_download_object).execute
        end

        success
      rescue StandardError, GRPC::Core::CallError => e
        error(e.message)
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Projects::LfsPointers::LfsImportService, feature_category: :source_code_management do
  let(:project) { create(:project) }
  let(:user) { project.creator }
  let(:import_url) { 'http://www.gitlab.com/demo/repo.git' }
  let(:oid_download_links) do
    [
      { 'oid1' => ""#{import_url}/gitlab-lfs/objects/oid1"" },
      { 'oid2' => ""#{import_url}/gitlab-lfs/objects/oid2"" }
    ]
  end

  subject { described_class.new(project, user) }

  context 'when lfs is enabled for the project' do
    before do
      allow(project).to receive(:lfs_enabled?).and_return(true)
    end

    it 'downloads lfs objects' do
      service = double
      expect_next_instance_of(Projects::LfsPointers::LfsObjectDownloadListService) do |instance|
        expect(instance).to receive(:each_list_item)
          .and_yield(oid_download_links[0]).and_yield(oid_download_links[1])
      end
      expect(Projects::LfsPointers::LfsDownloadService).to receive(:new).and_return(service).twice
      expect(service).to receive(:execute).twice

      result = subject.execute

      expect(result[:status]).to eq :success
    end

    context 'when no downloadable lfs object links' do
      it 'does not call LfsDownloadService' do
        expect_next_instance_of(Projects::LfsPointers::LfsObjectDownloadListService) do |instance|
          expect(instance).to receive(:each_list_item)
        end
        expect(Projects::LfsPointers::LfsDownloadService).not_to receive(:new)

        result = subject.execute

        expect(result[:status]).to eq :success
      end
    end

    context 'when an exception is raised' do
      it 'returns error' do
        error_message = ""error message""
        expect_next_instance_of(Projects::LfsPointers::LfsObjectDownloadListService) do |instance|
          expect(instance).to receive(:each_list_item).and_raise(StandardError, error_message)
        end

        result = subject.execute

        expect(result[:status]).to eq :error
        expect(result[:message]).to eq error_message
      end
    end

    context 'when an GRPC::Core::CallError exception raised' do
      it 'returns error' do
        error_message = ""error message""
        expect_next_instance_of(Projects::LfsPointers::LfsObjectDownloadListService) do |instance|
          expect(instance).to receive(:each_list_item).and_raise(GRPC::Core::CallError, error_message)
        end

        result = subject.execute

        expect(result[:status]).to eq :error
        expect(result[:message]).to eq error_message
      end
    end
  end

  context 'when lfs is not enabled for the project' do
    it 'does not download lfs objects' do
      allow(project).to receive(:lfs_enabled?).and_return(false)
      expect(Projects::LfsPointers::LfsObjectDownloadListService).not_to receive(:new)
      expect(Projects::LfsPointers::LfsDownloadService).not_to receive(:new)

      result = subject.execute

      expect(result[:status]).to eq :success
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Given a list of oids, this services links the existent Lfs Objects to the project
module Projects
  module LfsPointers
    class LfsLinkService < BaseService
      TooManyOidsError = Class.new(StandardError)

      MAX_OIDS = ENV.fetch('GITLAB_LFS_MAX_OID_TO_FETCH', 100_000).to_i
      BATCH_SIZE = 1000

      # Accept an array of oids to link
      #
      # Returns an array with the oid of the existent lfs objects
      def execute(oids)
        return [] unless project&.lfs_enabled?

        validate!(oids)

        yield if block_given?

        # Search and link existing LFS Object
        link_existing_lfs_objects(oids)
      end

      private

      def validate!(oids)
        return if oids.size <= MAX_OIDS

        raise TooManyOidsError, 'Too many LFS object ids to link, please push them manually'
      end

      def link_existing_lfs_objects(oids)
        linked_existing_objects = []
        iterations = 0

        oids.each_slice(BATCH_SIZE) do |oids_batch|
          # Load all existing LFS Objects immediately so we don't issue an extra
          # query for the `.any?`
          existent_lfs_objects = LfsObject.for_oids(oids_batch).load
          next unless existent_lfs_objects.any?

          rows = existent_lfs_objects
                   .not_linked_to_project(project)
                   .map { |existing_lfs_object| { project_id: project.id, lfs_object_id: existing_lfs_object.id } }
          ApplicationRecord.legacy_bulk_insert(:lfs_objects_projects, rows) # rubocop:disable Gitlab/BulkInsert
          iterations += 1

          linked_existing_objects += existent_lfs_objects.map(&:oid)
        end

        log_lfs_link_results(linked_existing_objects.count, iterations)

        linked_existing_objects
      end

      def log_lfs_link_results(lfs_objects_linked_count, iterations)
        Gitlab::Import::Logger.info(
          class: self.class.name,
          project_id: project.id,
          project_path: project.full_path,
          lfs_objects_linked_count: lfs_objects_linked_count,
          iterations: iterations)
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Projects::LfsPointers::LfsLinkService, feature_category: :source_code_management do
  let_it_be(:project) { create(:project, lfs_enabled: true) }
  let_it_be(:lfs_objects_project) { create_list(:lfs_objects_project, 2, project: project) }

  let(:new_oids) { { 'oid1' => 123, 'oid2' => 125 } }
  let(:all_oids) { LfsObject.pluck(:oid, :size).to_h.merge(new_oids) }
  let(:new_lfs_object) { create(:lfs_object) }
  let(:new_oid_list) { all_oids.merge(new_lfs_object.oid => new_lfs_object.size) }

  subject { described_class.new(project) }

  before do
    allow(project).to receive(:lfs_enabled?).and_return(true)
  end

  describe '#execute' do
    it 'raises an error when trying to link too many objects at once' do
      stub_const(""#{described_class}::MAX_OIDS"", 5)

      oids = Array.new(described_class::MAX_OIDS) { |i| ""oid-#{i}"" }
      oids << 'the straw'

      expect { subject.execute(oids) }.to raise_error(described_class::TooManyOidsError)
    end

    it 'executes a block after validation and before execution' do
      block = instance_double(Proc)

      expect(subject).to receive(:validate!).ordered
      expect(block).to receive(:call).ordered
      expect(subject).to receive(:link_existing_lfs_objects).ordered

      subject.execute([]) do
        block.call
      end
    end

    it 'links existing lfs objects to the project' do
      expect(project.lfs_objects.count).to eq 2

      linked = subject.execute(new_oid_list.keys)

      expect(project.lfs_objects.count).to eq 3
      expect(linked.size).to eq 3
    end

    it 'returns linked oids' do
      linked = lfs_objects_project.map(&:lfs_object).map(&:oid) << new_lfs_object.oid

      expect(subject.execute(new_oid_list.keys)).to contain_exactly(*linked)
    end

    it 'links in batches' do
      stub_const(""#{described_class}::BATCH_SIZE"", 3)

      expect(Gitlab::Import::Logger).to receive(:info).with(
        class: described_class.name,
        project_id: project.id,
        project_path: project.full_path,
        lfs_objects_linked_count: 7,
        iterations: 3
      )

      lfs_objects = create_list(:lfs_object, 7)
      linked = subject.execute(lfs_objects.pluck(:oid))

      expect(project.lfs_objects.count).to eq 9
      expect(linked.size).to eq 7
    end

    it 'only queries for the batch that will be processed', :aggregate_failures do
      stub_const(""#{described_class}::BATCH_SIZE"", 1)
      oids = %w[one two]

      expect(LfsObject).to receive(:for_oids).with(%w[one]).once.and_call_original
      expect(LfsObject).to receive(:for_oids).with(%w[two]).once.and_call_original

      subject.execute(oids)
    end

    it 'only queries 3 times' do
      # make sure that we don't count the queries in the setup
      new_oid_list

      # These are repeated for each batch of oids: maximum (MAX_OIDS / BATCH_SIZE) times
      # 1. Load the batch of lfs object ids that we might know already
      # 2. Load the objects that have not been linked to the project yet
      # 3. Insert the lfs_objects_projects for that batch
      expect { subject.execute(new_oid_list.keys) }.not_to exceed_query_limit(3)
    end

    context 'when MAX_OIDS is 5' do
      let(:max_oids) { 5 }
      let(:oids) { Array.new(max_oids) { |i| ""oid-#{i}"" } }

      before do
        stub_const(""#{described_class}::MAX_OIDS"", max_oids)
      end

      it 'does not raise an error when trying to link exactly the OID limit' do
        expect { subject.execute(oids) }.not_to raise_error
      end

      it 'raises an error when trying to link more than OID limit' do
        oids << 'the straw'
        expect { subject.execute(oids) }.to raise_error(described_class::TooManyOidsError)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# This service downloads and links lfs objects from a remote URL
module Projects
  module LfsPointers
    class LfsDownloadService < BaseService
      SizeError = Class.new(StandardError)
      OidError = Class.new(StandardError)
      ResponseError = Class.new(StandardError)

      LARGE_FILE_SIZE = 1.megabytes

      attr_reader :lfs_download_object

      delegate :oid, :size, :credentials, :sanitized_url, :headers, to: :lfs_download_object, prefix: :lfs

      def initialize(project, lfs_download_object)
        super(project)

        @lfs_download_object = lfs_download_object
      end

      def execute
        return unless project&.lfs_enabled? && lfs_download_object
        return error(""LFS file with oid #{lfs_oid} has invalid attributes"") unless lfs_download_object.valid?
        return link_existing_lfs_object! if Feature.enabled?(:lfs_link_existing_object, project) && lfs_size > LARGE_FILE_SIZE && lfs_object

        wrap_download_errors do
          download_lfs_file!
        end
      end

      private

      def wrap_download_errors(&block)
        yield
      rescue SizeError, OidError, ResponseError, StandardError => e
        error(""LFS file with oid #{lfs_oid} couldn't be downloaded from #{lfs_sanitized_url}: #{e.message}"")
      end

      def download_lfs_file!
        with_tmp_file do |tmp_file|
          download_and_save_file!(tmp_file)

          project.lfs_objects << find_or_create_lfs_object(tmp_file)

          success
        end
      end

      def find_or_create_lfs_object(tmp_file)
        lfs_obj = LfsObject.safe_find_or_create_by!(
          oid: lfs_oid,
          size: lfs_size
        )

        lfs_obj.update!(file: tmp_file) unless lfs_obj.file.file

        lfs_obj
      end

      def download_and_save_file!(file)
        digester = Digest::SHA256.new
        fetch_file do |fragment|
          if digest_fragment?(fragment)
            digester << fragment
            file.write(fragment)
          end

          raise_size_error! if file.size > lfs_size
        end

        raise_size_error! if file.size != lfs_size
        raise_oid_error! if digester.hexdigest != lfs_oid
      end

      def digest_fragment?(fragment)
        fragment.http_response.is_a?(Net::HTTPSuccess)
      end

      def download_options
        http_options = { headers: lfs_headers, stream_body: true }

        return http_options if lfs_download_object.has_authorization_header?

        http_options.tap do |options|
          if lfs_credentials[:user].present? || lfs_credentials[:password].present?
            # Using authentication headers in the request
            options[:basic_auth] = { username: lfs_credentials[:user], password: lfs_credentials[:password] }
          end
        end
      end

      def fetch_file(&block)
        attempts ||= 1
        response = Gitlab::HTTP.get(lfs_sanitized_url, download_options, &block)

        raise ResponseError, ""Received error code #{response.code}"" unless response.success?
      rescue Net::OpenTimeout
        raise if attempts >= 3

        attempts += 1
        retry
      end

      def with_tmp_file
        create_tmp_storage_dir

        File.open(tmp_filename, 'wb') do |file|
          yield file
        rescue StandardError => e
          # If the lfs file is successfully downloaded it will be removed
          # when it is added to the project's lfs files.
          # Nevertheless if any exception raises the file would remain
          # in the file system. Here we ensure to remove it
          File.unlink(file) if File.exist?(file)

          raise e
        end
      end

      def tmp_filename
        File.join(tmp_storage_dir, lfs_oid)
      end

      def create_tmp_storage_dir
        FileUtils.makedirs(tmp_storage_dir) unless Dir.exist?(tmp_storage_dir)
      end

      def tmp_storage_dir
        @tmp_storage_dir ||= File.join(storage_dir, 'tmp', 'download')
      end

      def storage_dir
        @storage_dir ||= Gitlab.config.lfs.storage_path
      end

      def raise_size_error!
        raise SizeError, 'Size mistmatch'
      end

      def raise_oid_error!
        raise OidError, 'Oid mismatch'
      end

      def error(message, http_status = nil)
        log_error(message)

        super
      end

      def lfs_object
        @lfs_object ||= LfsObject.find_by_oid(lfs_oid)
      end

      def link_existing_lfs_object!
        existing_file = lfs_object.file.open
        buffer_size = 0
        result = fetch_file do |fragment|
          unless fragment == existing_file.read(fragment.size)
            break error(""LFS file with oid #{lfs_oid} cannot be linked with an existing LFS object"")
          end

          buffer_size += fragment.size
          break success if buffer_size > LARGE_FILE_SIZE
        end

        project.lfs_objects << lfs_object

        result
      ensure
        existing_file&.close
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Projects::LfsPointers::LfsDownloadService, feature_category: :source_code_management do
  include StubRequests

  let_it_be(:project) { create(:project) }

  let(:lfs_content) { SecureRandom.random_bytes(10) }
  let(:oid) { Digest::SHA256.hexdigest(lfs_content) }
  let(:download_link) { ""http://gitlab.com/#{oid}"" }
  let(:size) { lfs_content.size }
  let(:lfs_object) { LfsDownloadObject.new(oid: oid, size: size, link: download_link) }
  let(:local_request_setting) { false }

  subject { described_class.new(project, lfs_object) }

  before_all do
    ApplicationSetting.create_from_defaults
  end

  before do
    stub_application_setting(allow_local_requests_from_web_hooks_and_services: local_request_setting)
    allow(project).to receive(:lfs_enabled?).and_return(true)
  end

  shared_examples 'lfs temporal file is removed' do
    it do
      subject.execute

      expect(File.exist?(subject.send(:tmp_filename))).to be false
    end
  end

  shared_examples 'no lfs object is created' do
    it do
      expect { subject.execute }.not_to change { LfsObject.count }
    end

    it 'returns error result' do
      expect(subject.execute[:status]).to eq :error
    end

    it 'an error is logged' do
      expect(subject).to receive(:log_error)

      subject.execute
    end

    it_behaves_like 'lfs temporal file is removed'
  end

  shared_examples 'lfs object is created' do
    it 'creates and associate the LFS object to project' do
      expect(subject).to receive(:download_and_save_file!).and_call_original

      expect { subject.execute }.to change { LfsObject.count }.by(1)
      expect(LfsObject.first.projects).to include(project)
    end

    it 'returns success result' do
      expect(subject.execute[:status]).to eq :success
    end

    it_behaves_like 'lfs temporal file is removed'
  end

  describe '#execute' do
    context 'when file download succeeds' do
      before do
        stub_full_request(download_link).to_return(body: lfs_content)
      end

      it_behaves_like 'lfs object is created'

      it 'has the same oid' do
        subject.execute

        expect(LfsObject.first.oid).to eq oid
      end

      it 'has the same size' do
        subject.execute

        expect(LfsObject.first.size).to eq size
      end

      it 'stores the content' do
        subject.execute

        expect(File.binread(LfsObject.first.file.file.file)).to eq lfs_content
      end

      it 'streams the download' do
        expected_options = { headers: anything, stream_body: true }

        expect(Gitlab::HTTP).to receive(:get).with(anything, expected_options)

        subject.execute
      end

      it 'skips read_total_timeout', :aggregate_failures do
        stub_const('GitLab::HTTP::DEFAULT_READ_TOTAL_TIMEOUT', 0)

        expect(ProjectCacheWorker).to receive(:perform_async).once
        expect(Gitlab::Metrics::System).not_to receive(:monotonic_time)
        expect(subject.execute).to include(status: :success)
      end
    end

    context 'when file downloading response code is not success' do
      before do
        allow(Gitlab::HTTP).to receive(:get).and_return(code: 500, 'success?' => false)
      end

      it_behaves_like 'no lfs object is created'

      it 'raise StandardError exception' do
        expect(subject).to receive(:download_and_save_file!).and_raise(StandardError)

        subject.execute
      end
    end

    context 'when file downloading request timeout few times' do
      before do
        allow(Gitlab::HTTP).to receive(:get).and_raise(Net::OpenTimeout)
      end

      it_behaves_like 'no lfs object is created'

      it 'retries to get LFS object 3 times before raising exception' do
        subject.execute

        expect(Gitlab::HTTP).to have_received(:get).exactly(3).times
      end
    end

    context 'when file download returns a redirect' do
      let(:redirect_link) { 'http://external-link' }

      before do
        stub_full_request(download_link).to_return(status: 301, body: 'You are being redirected', headers: { 'Location' => redirect_link })
        stub_full_request(redirect_link).to_return(body: lfs_content)
      end

      it_behaves_like 'lfs object is created'

      it 'correctly stores lfs object' do
        subject.execute

        new_lfs_object = LfsObject.first

        expect(new_lfs_object).to have_attributes(oid: oid, size: size)
        expect(File.binread(new_lfs_object.file.file.file)).to eq lfs_content
      end
    end

    context 'when downloaded lfs file has a different size' do
      let(:size) { 1 }

      before do
        stub_full_request(download_link).to_return(body: lfs_content)
      end

      it_behaves_like 'no lfs object is created'

      it 'raise SizeError exception' do
        expect(subject).to receive(:download_and_save_file!).and_raise(described_class::SizeError)

        subject.execute
      end
    end

    context 'when downloaded lfs file has a different oid' do
      before do
        stub_full_request(download_link).to_return(body: lfs_content)
        allow_any_instance_of(Digest::SHA256).to receive(:hexdigest).and_return('foobar')
      end

      it_behaves_like 'no lfs object is created'

      it 'raise OidError exception' do
        expect(subject).to receive(:download_and_save_file!).and_raise(described_class::OidError)

        subject.execute
      end
    end

    context 'when an lfs object with the same oid already exists' do
      let!(:existing_lfs_object) { create(:lfs_object, oid: oid) }

      before do
        stub_full_request(download_link).to_return(body: lfs_content)
      end

      it_behaves_like 'no lfs object is created'

      it 'does not update the file attached to the existing LfsObject' do
        expect { subject.execute }
          .not_to change { existing_lfs_object.reload.file.file.file }
      end
    end

    context 'when credentials present' do
      let(:download_link_with_credentials) { ""http://user:password@gitlab.com/#{oid}"" }
      let(:lfs_object) { LfsDownloadObject.new(oid: oid, size: size, link: download_link_with_credentials) }
      let!(:request_stub) { stub_full_request(download_link).with(headers: { 'Authorization' => 'Basic dXNlcjpwYXNzd29yZA==' }).to_return(body: lfs_content) }

      it 'the request adds authorization headers' do
        subject.execute

        expect(request_stub).to have_been_requested
      end

      context 'when Authorization header is present' do
        let(:auth_header) { { 'Authorization' => 'Basic 12345' } }
        let(:lfs_object) { LfsDownloadObject.new(oid: oid, size: size, link: download_link_with_credentials, headers: auth_header) }
        let!(:request_stub) { stub_full_request(download_link).with(headers: auth_header).to_return(body: lfs_content) }

        it 'request uses the header auth' do
          subject.execute

          expect(request_stub).to have_been_requested
        end
      end
    end

    context 'when localhost requests are allowed' do
      let(:download_link) { 'http://192.168.2.120' }
      let(:local_request_setting) { true }

      before do
        stub_full_request(download_link, ip_address: '192.168.2.120').to_return(body: lfs_content)
      end

      it_behaves_like 'lfs object is created'
    end

    context 'when a bad URL is used' do
      where(download_link: ['/etc/passwd', 'ftp://example.com', 'http://127.0.0.2', 'http://192.168.2.120'])

      with_them do
        it 'does not download the file' do
          expect(subject).not_to receive(:download_lfs_file!)

          expect { subject.execute }.not_to change { LfsObject.count }
        end
      end
    end

    context 'when the URL points to a redirected URL' do
      context 'that is blocked' do
        where(redirect_link: ['ftp://example.com', 'http://127.0.0.2', 'http://192.168.2.120'])

        with_them do
          before do
            stub_full_request(download_link, ip_address: '192.168.2.120')
              .to_return(status: 301, headers: { 'Location' => redirect_link })
          end

          it_behaves_like 'no lfs object is created'
        end
      end

      context 'that is not blocked' do
        let(:redirect_link) { ""http://example.com/"" }

        before do
          stub_full_request(download_link).to_return(status: 301, headers: { 'Location' => redirect_link })
          stub_full_request(redirect_link).to_return(body: lfs_content)
        end

        it_behaves_like 'lfs object is created'
      end
    end

    context 'when the lfs object attributes are invalid' do
      let(:oid) { 'foobar' }

      before do
        expect(lfs_object).to be_invalid
      end

      it_behaves_like 'no lfs object is created'

      it 'does not download the file' do
        expect(subject).not_to receive(:download_lfs_file!)

        subject.execute
      end
    end

    context 'when a large lfs object with the same oid already exists' do
      let!(:existing_lfs_object) { create(:lfs_object, :with_file, :correct_oid) }

      before do
        stub_const(""#{described_class}::LARGE_FILE_SIZE"", 500)
        stub_full_request(download_link).to_return(body: lfs_content)
      end

      context 'and first fragments are the same' do
        let(:lfs_content) { existing_lfs_object.file.read }

        context 'when lfs_link_existing_object feature flag disabled' do
          before do
            stub_feature_flags(lfs_link_existing_object: false)
          end

          it 'does not call link_existing_lfs_object!' do
            expect(subject).not_to receive(:link_existing_lfs_object!)

            subject.execute
          end
        end

        it 'returns success' do
          expect(subject.execute).to eq({ status: :success })
        end

        it 'links existing lfs object to the project' do
          expect { subject.execute }
            .to change { project.lfs_objects.include?(existing_lfs_object) }.from(false).to(true)
        end
      end

      context 'and first fragments diverges' do
        let(:lfs_content) { SecureRandom.random_bytes(1000) }
        let(:oid) { existing_lfs_object.oid }

        it 'raises oid mismatch error' do
          expect(subject.execute).to eq({
            status: :error,
            message: ""LFS file with oid #{oid} cannot be linked with an existing LFS object""
          })
        end

        it 'does not change lfs objects' do
          expect { subject.execute }.not_to change { project.lfs_objects }
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# This service discovers the Lfs files that are linked in repository,
# but not downloaded yet and yields the operation
# on each Lfs file link (url) to remote repository.
module Projects
  module LfsPointers
    class LfsObjectDownloadListService < BaseService
      include Gitlab::Utils::StrongMemoize

      HEAD_REV = 'HEAD'
      LFS_ENDPOINT_PATTERN = /^\t?url\s*=\s*(.+)$/
      LFS_BATCH_API_ENDPOINT = '/info/lfs/objects/batch'

      LfsObjectDownloadListError = Class.new(StandardError)

      def each_list_item(&block)
        return unless context_valid?

        # Downloading the required information and gathering it inside an
        #   LfsDownloadObject for each oid
        LfsDownloadLinkListService
          .new(project, remote_uri: current_endpoint_uri)
          .each_link(missing_lfs_files, &block)
      rescue LfsDownloadLinkListService::DownloadLinksError => e
        raise LfsObjectDownloadListError, ""The LFS objects download list couldn't be imported. Error: #{e.message}""
      end

      private

      def context_valid?
        return false unless project&.lfs_enabled?
        return true unless external_lfs_endpoint?

        # If the endpoint host is different from the import_url it means
        # that the repo is using a third party service for storing the LFS files.
        # In this case, we have to disable lfs in the project
        disable_lfs!
        false
      end

      def external_lfs_endpoint?
        lfsconfig_endpoint_uri && lfsconfig_endpoint_uri.host != import_uri.host
      end

      def disable_lfs!
        unless project.update(lfs_enabled: false)
          raise LfsDownloadLinkListService::DownloadLinksError, ""Invalid project state""
        end
      end

      # Retrieves all lfs pointers in the repository
      def lfs_pointers_in_repository
        @lfs_pointers_in_repository ||= LfsListService.new(project).execute
      end

      def existing_lfs_objects
        project.lfs_objects
      end

      def existing_lfs_objects_hash
        {}.tap do |hash|
          existing_lfs_objects.find_each do |lfs_object|
            hash[lfs_object.oid] = lfs_object.size
          end
        end
      end

      def missing_lfs_files
        lfs_pointers_in_repository.except(*existing_lfs_objects_hash.keys)
      end

      def lfsconfig_endpoint_uri
        strong_memoize(:lfsconfig_endpoint_uri) do
          # Retrieveing the blob data from the .lfsconfig file
          data = project.repository.lfsconfig_for(HEAD_REV)
          # Parsing the data to retrieve the url
          parsed_data = data&.match(LFS_ENDPOINT_PATTERN)

          if parsed_data
            URI.parse(parsed_data[1]).tap do |endpoint|
              endpoint.user ||= import_uri.user
              endpoint.password ||= import_uri.password
            end
          end
        end
      rescue URI::InvalidURIError
        raise LfsObjectDownloadListError, 'Invalid URL in .lfsconfig file'
      end

      def import_uri
        @import_uri ||= URI.parse(project.import_url)
      rescue URI::InvalidURIError
        raise LfsObjectDownloadListError, 'Invalid project import URL'
      end

      def current_endpoint_uri
        (lfsconfig_endpoint_uri || default_endpoint_uri)
      end

      # The import url must end with '.git' here we ensure it is
      def default_endpoint_uri
        @default_endpoint_uri ||= import_uri.dup.tap do |uri|
          path = uri.path.gsub(%r{/$}, '')
          path += '.git' unless path.ends_with?('.git')
          uri.path = path + LFS_BATCH_API_ENDPOINT
        end
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Projects::LfsPointers::LfsObjectDownloadListService, feature_category: :source_code_management do
  let(:import_url) { 'http://www.gitlab.com/demo/repo.git' }
  let(:default_endpoint) { ""#{import_url}/info/lfs/objects/batch"" }
  let(:group) { create(:group, lfs_enabled: true) }
  let!(:project) { create(:project, namespace: group, import_url: import_url, lfs_enabled: true) }
  let!(:lfs_objects_project) { create_list(:lfs_objects_project, 2, project: project) }
  let!(:existing_lfs_objects) { LfsObject.pluck(:oid, :size).to_h }
  let(:oids) { { 'oid1' => 123, 'oid2' => 125 } }
  let(:oid_download_links) do
    [
      { 'oid1' => ""#{import_url}/gitlab-lfs/objects/oid1"" },
      { 'oid2' => ""#{import_url}/gitlab-lfs/objects/oid2"" }
    ]
  end

  let(:all_oids) { existing_lfs_objects.merge(oids) }
  let(:remote_uri) { URI.parse(lfs_endpoint) }

  subject { described_class.new(project) }

  before do
    allow(project.repository).to receive(:lfsconfig_for).and_return(nil)
    allow(Gitlab.config.lfs).to receive(:enabled).and_return(true)
    allow_any_instance_of(Projects::LfsPointers::LfsListService).to receive(:execute).and_return(all_oids)
  end

  describe '#each_list_item' do
    context 'when no lfs pointer is linked' do
      before do
        allow_any_instance_of(Projects::LfsPointers::LfsDownloadLinkListService)
          .to receive(:each_link).with(oids)
          .and_yield(oid_download_links[0])
          .and_yield(oid_download_links[1])
      end

      it 'retrieves all lfs pointers in the project repository' do
        expect(Projects::LfsPointers::LfsDownloadLinkListService)
          .to receive(:new).with(project, remote_uri: URI.parse(default_endpoint))
          .and_call_original
        expect_any_instance_of(Projects::LfsPointers::LfsListService).to receive(:execute)

        checksum = 0
        subject.each_list_item { |lfs_object| checksum += 1 }
        expect(checksum).to eq 2
      end

      context 'when no LFS objects exist' do
        before do
          project.lfs_objects.delete_all
        end

        it 'retrieves all LFS objects' do
          expect(Projects::LfsPointers::LfsDownloadLinkListService)
            .to receive(:new).with(project, remote_uri: URI.parse(default_endpoint)).and_call_original
          expect_any_instance_of(Projects::LfsPointers::LfsDownloadLinkListService)
            .to receive(:each_link).with(all_oids)

          subject.each_list_item {}
        end
      end

      context 'when some LFS objects already exist' do
        it 'retrieves the download links of non-existent objects' do
          expect_any_instance_of(Projects::LfsPointers::LfsDownloadLinkListService)
            .to receive(:each_link).with(oids)

          checksum = 0
          subject.each_list_item { |lfs_object| checksum += 1 }
          expect(checksum).to eq 2
        end
      end
    end

    context 'when lfsconfig file exists' do
      before do
        allow(project.repository).to receive(:lfsconfig_for).and_return(""[lfs]\n\turl = #{lfs_endpoint}\n"")
      end

      context 'when url points to the same import url host' do
        let(:lfs_endpoint) { ""#{import_url}/different_endpoint"" }
        let(:service) { instance_double(Projects::LfsPointers::LfsDownloadLinkListService, each_link: nil) }

        it 'downloads lfs object using the new endpoint' do
          expect(Projects::LfsPointers::LfsDownloadLinkListService)
            .to receive(:new)
            .with(project, remote_uri: remote_uri)
            .and_return(service)

          subject.each_list_item {}
        end

        context 'when import url has credentials' do
          let(:import_url) { 'http://user:password@www.gitlab.com/demo/repo.git' }

          it 'adds the credentials to the new endpoint' do
            expect(Projects::LfsPointers::LfsDownloadLinkListService)
              .to receive(:new)
              .with(
                project,
                remote_uri: URI.parse(""http://user:password@www.gitlab.com/demo/repo.git/different_endpoint"")
              )
              .and_return(service)

            subject.each_list_item {}
          end

          context 'when url has its own credentials' do
            let(:lfs_endpoint) { ""http://user1:password1@www.gitlab.com/demo/repo.git/different_endpoint"" }

            it 'does not add the import url credentials' do
              expect(Projects::LfsPointers::LfsDownloadLinkListService)
                .to receive(:new).with(project, remote_uri: remote_uri)
                .and_return(service)

              subject.each_list_item {}
            end
          end
        end
      end

      context 'when url points to a third party service' do
        let(:lfs_endpoint) { 'http://third_party_service.com/info/lfs/objects/' }

        it 'disables lfs from the project' do
          expect(project.lfs_enabled?).to be_truthy

          subject.each_list_item {}

          expect(project.lfs_enabled?).to be_falsey
        end

        it 'does not download anything' do
          expect_any_instance_of(Projects::LfsPointers::LfsListService).not_to receive(:execute)

          subject.each_list_item {}
        end
      end
    end
  end

  describe '#default_endpoint_uri' do
    let(:import_url) { 'http://www.gitlab.com/demo/repo' }

    it 'adds suffix .git if the url does not have it' do
      expect(subject.send(:default_endpoint_uri).path).to match(/repo.git/)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Emails
  class ConfirmService < ::Emails::BaseService
    def execute(email)
      email.resend_confirmation_instructions
    end
  end
end

Emails::ConfirmService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Emails::ConfirmService, feature_category: :user_management do
  let_it_be(:user) { create(:user) }

  subject(:service) { described_class.new(user) }

  describe '#execute' do
    it 'enqueues a background job to send confirmation email again' do
      email = user.emails.create!(email: 'new@email.com')

      travel_to(10.minutes.from_now) do
        expect { service.execute(email) }.to have_enqueued_job.on_queue('mailers')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Emails
  class DestroyService < ::Emails::BaseService
    def execute(email)
      raise StandardError, 'Cannot delete primary email' if email.user_primary_email?

      email.destroy && update_secondary_emails!(email.email)
    end

    private

    def update_secondary_emails!(deleted_email)
      result = ::Users::UpdateService.new(@current_user, user: @user).execute do |user|
        user.unset_secondary_emails_matching_deleted_email!(deleted_email)
      end

      result[:status] == :success
    end
  end
end

Emails::DestroyService.prepend_mod_with('Emails::DestroyService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Emails::DestroyService, feature_category: :user_management do
  let!(:user) { create(:user) }
  let!(:email) { create(:email, user: user) }

  subject(:service) { described_class.new(user, user: user) }

  describe '#execute' do
    it 'removes an email' do
      response = service.execute(email)

      expect(user.emails).not_to include(email)
      expect(response).to be true
    end

    context 'when it corresponds to the user primary email' do
      let(:email) { user.emails.find_by!(email: user.email) }

      it 'does not remove the email and raises an exception' do
        expect { service.execute(email) }.to raise_error(StandardError, 'Cannot delete primary email')

        expect(user.emails).to include(email)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Emails
  class CreateService < ::Emails::BaseService
    def execute(extra_params = {})
      skip_confirmation = params.delete(:skip_confirmation)

      user.emails.create(params.merge(extra_params)).tap do |email|
        email&.confirm if skip_confirmation && current_user.admin?
        notification_service.new_email_address_added(user, email.email) if email.persisted? && !email.user_primary_email?
      end
    end
  end
end

Emails::CreateService.prepend_mod_with('Emails::CreateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Emails::CreateService, feature_category: :user_management do
  let_it_be(:user) { create(:user) }

  let(:opts) { { email: 'new@email.com', user: user } }

  subject(:service) { described_class.new(user, opts) }

  describe '#execute' do
    it 'creates an email with valid attributes' do
      expect { service.execute }.to change { Email.count }.by(1)
      expect(Email.where(opts)).not_to be_empty
    end

    it 'creates an email with additional attributes' do
      expect { service.execute(confirmation_token: 'abc') }.to change { Email.count }.by(1)
      expect(Email.find_by(opts).confirmation_token).to eq 'abc'
    end

    it 'has the right user association' do
      service.execute

      expect(user.emails).to include(Email.find_by(opts))
    end

    it 'sends a notification to the user' do
      expect_next_instance_of(NotificationService) do |notification_service|
        expect(notification_service).to receive(:new_email_address_added)
      end

      service.execute
    end

    it 'does not send a notification when the email is not persisted' do
      allow_next_instance_of(NotificationService) do |notification_service|
        expect(notification_service).not_to receive(:new_email_address_added)
      end

      service.execute(email: 'invalid@@example.com')
    end

    it 'does not send a notification email when the email is the primary, because we are creating the user' do
      allow_next_instance_of(NotificationService) do |notification_service|
        expect(notification_service).not_to receive(:new_email_address_added)
      end

      # This is here to ensure that the service is actually called.
      allow_next_instance_of(described_class) do |create_service|
        expect(create_service).to receive(:execute).and_call_original
      end

      create(:user)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module TwoFactor
  class DestroyService < ::TwoFactor::BaseService
    def execute
      return error(_('You are not authorized to perform this action')) unless authorized?
      return error(_('Two-factor authentication is not enabled for this user')) unless user.two_factor_enabled?

      result = disable_two_factor

      notify_on_success(user) if result[:status] == :success

      result
    end

    private

    def authorized?
      can?(current_user, :disable_two_factor, user)
    end

    def disable_two_factor
      ::Users::UpdateService.new(current_user, user: user).execute do |user|
        user.disable_two_factor!
      end
    end

    def notify_on_success(user)
      notification_service.disabled_two_factor(user)
    end
  end
end

TwoFactor::DestroyService.prepend_mod_with('TwoFactor::DestroyService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe TwoFactor::DestroyService, feature_category: :system_access do
  let_it_be(:current_user) { create(:user) }

  subject { described_class.new(current_user, user: user).execute }

  context 'disabling two-factor authentication' do
    shared_examples_for 'does not send notification email' do
      context 'notification', :mailer do
        it 'does not send a notification' do
          perform_enqueued_jobs do
            subject
          end

          should_not_email(user)
        end
      end
    end

    context 'when the user does not have two-factor authentication enabled' do
      let(:user) { current_user }

      it 'returns error' do
        expect(subject).to eq(
          {
            status: :error,
            message: 'Two-factor authentication is not enabled for this user'
          }
        )
      end

      it_behaves_like 'does not send notification email'
    end

    context 'when the user has two-factor authentication enabled' do
      context 'when the executor is not authorized to disable two-factor authentication' do
        context 'disabling the two-factor authentication of another user' do
          let(:user) { create(:user, :two_factor) }

          it 'returns error' do
            expect(subject).to eq(
              {
                status: :error,
                message: 'You are not authorized to perform this action'
              }
            )
          end

          it 'does not disable two-factor authentication' do
            expect { subject }.not_to change { user.reload.two_factor_enabled? }.from(true)
          end

          it_behaves_like 'does not send notification email'
        end
      end

      context 'when the executor is authorized to disable two-factor authentication' do
        shared_examples_for 'disables two-factor authentication' do
          it 'returns success' do
            expect(subject).to eq({ status: :success })
          end

          it 'disables the two-factor authentication of the user' do
            expect { subject }.to change { user.reload.two_factor_enabled? }.from(true).to(false)
          end

          context 'notification', :mailer do
            it 'sends a notification' do
              perform_enqueued_jobs do
                subject
              end

              should_email(user)
            end
          end
        end

        context 'disabling their own two-factor authentication' do
          let(:current_user) { create(:user, :two_factor) }
          let(:user) { current_user }

          it_behaves_like 'disables two-factor authentication'
        end

        context 'admin disables the two-factor authentication of another user', :enable_admin_mode do
          let(:current_user) { create(:admin) }
          let(:user) { create(:user, :two_factor) }

          it_behaves_like 'disables two-factor authentication'
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Wikis
  class CreateAttachmentService < Files::CreateService
    ATTACHMENT_PATH = 'uploads'
    MAX_FILENAME_LENGTH = 255

    attr_reader :container

    delegate :wiki, to: :container
    delegate :repository, to: :wiki

    def initialize(container:, current_user: nil, params: {})
      super(nil, current_user, params)

      @container = container
      @file_name = clean_file_name(params[:file_name])
      @file_path = File.join(ATTACHMENT_PATH, SecureRandom.hex, @file_name) if @file_name
      @commit_message ||= ""Upload attachment #{@file_name}""
      @branch_name ||= wiki.default_branch
    end

    def create_commit!
      wiki.create_wiki_repository

      commit_result(create_transformed_commit(@file_content))
    rescue Wiki::CouldNotCreateWikiError
      raise_error(""Error creating the wiki repository"")
    end

    private

    def clean_file_name(file_name)
      return unless file_name.present?

      file_name = truncate_file_name(file_name)
      # CommonMark does not allow Urls with whitespaces, so we have to replace them
      # Using the same regex Carrierwave use to replace invalid characters
      file_name.gsub(CarrierWave::SanitizedFile.sanitize_regexp, '_')
    end

    def truncate_file_name(file_name)
      return file_name if file_name.length <= MAX_FILENAME_LENGTH

      extension = File.extname(file_name)
      truncate_at = MAX_FILENAME_LENGTH - extension.length - 1
      base_name = File.basename(file_name, extension)[0..truncate_at]
      base_name + extension
    end

    def validate!
      validate_file_name!
      validate_permissions!
    end

    def validate_file_name!
      raise_error('The file name cannot be empty') unless @file_name
    end

    def validate_permissions!
      unless can?(current_user, :create_wiki, container)
        raise_error('You are not allowed to push to the wiki')
      end
    end

    def create_transformed_commit(content)
      repository.create_file(
        current_user,
        @file_path,
        content,
        message: @commit_message,
        branch_name: @branch_name,
        author_email: @author_email,
        author_name: @author_name)
    end

    def commit_result(commit_id)
      {
        file_name: @file_name,
        file_path: @file_path,
        branch: @branch_name,
        commit: commit_id
      }
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Wikis::CreateAttachmentService, feature_category: :wiki do
  let(:container) { create(:project, :wiki_repo) }
  let(:user) { create(:user) }
  let(:file_name) { 'filename.txt' }
  let(:file_path_regex) { %r{#{described_class::ATTACHMENT_PATH}/\h{32}/#{file_name}} }

  let(:file_opts) do
    {
      file_name: file_name,
      file_content: 'Content of attachment'
    }
  end

  let(:opts) { file_opts }

  subject(:service) { described_class.new(container: container, current_user: user, params: opts) }

  before do
    container.add_developer(user)
  end

  describe 'initialization' do
    context 'author commit info' do
      it 'does not raise error if user is nil' do
        service = described_class.new(container: container, current_user: nil, params: opts)

        expect(service.instance_variable_get(:@author_email)).to be_nil
        expect(service.instance_variable_get(:@author_name)).to be_nil
      end

      context 'when no author info provided' do
        it 'fills author_email and author_name from current_user info' do
          expect(service.instance_variable_get(:@author_email)).to eq user.email
          expect(service.instance_variable_get(:@author_name)).to eq user.name
        end
      end

      context 'when author info provided' do
        let(:author_email) { 'author_email' }
        let(:author_name) { 'author_name' }
        let(:opts) { file_opts.merge(author_email: author_email, author_name: author_name) }

        it 'fills author_email and author_name from params' do
          expect(service.instance_variable_get(:@author_email)).to eq author_email
          expect(service.instance_variable_get(:@author_name)).to eq author_name
        end
      end
    end

    context 'commit message' do
      context 'when no commit message provided' do
        it 'sets a default commit message' do
          expect(service.instance_variable_get(:@commit_message)).to eq ""Upload attachment #{opts[:file_name]}""
        end
      end

      context 'when commit message provided' do
        let(:commit_message) { 'whatever' }
        let(:opts) { file_opts.merge(commit_message: commit_message) }

        it 'use the commit message from params' do
          expect(service.instance_variable_get(:@commit_message)).to eq commit_message
        end
      end
    end

    context 'branch name' do
      context 'when no branch provided' do
        it 'sets the branch from the wiki default_branch' do
          expect(service.instance_variable_get(:@branch_name)).to eq container.wiki.default_branch
        end
      end

      context 'when branch provided' do
        let(:branch_name) { 'whatever' }
        let(:opts) { file_opts.merge(branch_name: branch_name) }

        it 'use the commit message from params' do
          expect(service.instance_variable_get(:@branch_name)).to eq branch_name
        end
      end
    end
  end

  describe '#parse_file_name' do
    context 'when file_name' do
      context 'has white spaces' do
        let(:file_name) { 'file with spaces' }

        it ""replaces all of them with '_'"" do
          result = service.execute

          expect(result[:status]).to eq :success
          expect(result[:result][:file_name]).to eq 'file_with_spaces'
        end
      end

      context 'has other invalid characters' do
        let(:file_name) { ""file\twith\tinvalid chars"" }

        it ""replaces all of them with '_'"" do
          result = service.execute

          expect(result[:status]).to eq :success
          expect(result[:result][:file_name]).to eq 'file_with_invalid_chars'
        end
      end

      context 'is not present' do
        let(:file_name) { nil }

        it 'returns error' do
          result = service.execute

          expect(result[:status]).to eq :error
          expect(result[:message]).to eq 'The file name cannot be empty'
        end
      end

      context 'length' do
        context 'is bigger than 255' do
          let(:file_name) { ""#{'0' * 256}.jpg"" }

          it 'truncates file name' do
            result = service.execute

            expect(result[:status]).to eq :success
            expect(result[:result][:file_name].length).to eq 255
            expect(result[:result][:file_name]).to match(/0{251}\.jpg/)
          end
        end

        context 'is less or equal to 255 does not return error' do
          let(:file_name) { '0' * 255 }

          it 'does not return error' do
            result = service.execute

            expect(result[:status]).to eq :success
          end
        end
      end
    end

    context 'when user' do
      shared_examples 'wiki attachment user validations' do
        it 'returns error' do
          result = described_class.new(container: container, current_user: user2, params: opts).execute

          expect(result[:status]).to eq :error
          expect(result[:message]).to eq 'You are not allowed to push to the wiki'
        end
      end

      context 'does not have permission' do
        let(:user2) { create(:user) }

        it_behaves_like 'wiki attachment user validations'
      end

      context 'is nil' do
        let(:user2) { nil }

        it_behaves_like 'wiki attachment user validations'
      end
    end
  end

  it_behaves_like 'Wikis::CreateAttachmentService#execute', :project
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Clusters
  module Kubernetes
    GITLAB_SERVICE_ACCOUNT_NAME = 'gitlab'
    GITLAB_SERVICE_ACCOUNT_NAMESPACE = 'default'
    GITLAB_ADMIN_TOKEN_NAME = 'gitlab-token'
    GITLAB_CLUSTER_ROLE_BINDING_NAME = 'gitlab-admin'
    GITLAB_CLUSTER_ROLE_NAME = 'cluster-admin'
    PROJECT_CLUSTER_ROLE_NAME = 'admin'
    GITLAB_KNATIVE_SERVING_ROLE_NAME = 'gitlab-knative-serving-role'
    GITLAB_KNATIVE_SERVING_ROLE_BINDING_NAME = 'gitlab-knative-serving-rolebinding'
    GITLAB_CROSSPLANE_DATABASE_ROLE_NAME = 'gitlab-crossplane-database-role'
    GITLAB_CROSSPLANE_DATABASE_ROLE_BINDING_NAME = 'gitlab-crossplane-database-rolebinding'
    KNATIVE_SERVING_NAMESPACE = 'knative-serving'
    ISTIO_SYSTEM_NAMESPACE = 'istio-system'
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Clusters::Kubernetes, feature_category: :deployment_management do
  it { is_expected.to be_const_defined(:GITLAB_SERVICE_ACCOUNT_NAME) }
  it { is_expected.to be_const_defined(:GITLAB_SERVICE_ACCOUNT_NAMESPACE) }
  it { is_expected.to be_const_defined(:GITLAB_ADMIN_TOKEN_NAME) }
  it { is_expected.to be_const_defined(:GITLAB_CLUSTER_ROLE_BINDING_NAME) }
  it { is_expected.to be_const_defined(:GITLAB_CLUSTER_ROLE_NAME) }
  it { is_expected.to be_const_defined(:PROJECT_CLUSTER_ROLE_NAME) }
  it { is_expected.to be_const_defined(:GITLAB_KNATIVE_SERVING_ROLE_NAME) }
  it { is_expected.to be_const_defined(:GITLAB_KNATIVE_SERVING_ROLE_BINDING_NAME) }
  it { is_expected.to be_const_defined(:GITLAB_CROSSPLANE_DATABASE_ROLE_NAME) }
  it { is_expected.to be_const_defined(:GITLAB_CROSSPLANE_DATABASE_ROLE_BINDING_NAME) }
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Clusters
  class BuildService
    def initialize(subject)
      @subject = subject
    end

    def execute
      ::Clusters::Cluster.new.tap do |cluster|
        case @subject
        when ::Project
          cluster.cluster_type = :project_type
        when ::Group
          cluster.cluster_type = :group_type
        when Instance
          cluster.cluster_type = :instance_type
        else
          raise NotImplementedError
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Clusters::BuildService, feature_category: :deployment_management do
  describe '#execute' do
    subject { described_class.new(cluster_subject).execute }

    describe 'when cluster subject is a project' do
      let(:cluster_subject) { build(:project) }

      it 'sets the cluster_type to project_type' do
        is_expected.to be_project_type
      end
    end

    describe 'when cluster subject is a group' do
      let(:cluster_subject) { build(:group) }

      it 'sets the cluster_type to group_type' do
        is_expected.to be_group_type
      end
    end

    describe 'when cluster subject is an instance' do
      let(:cluster_subject) { Clusters::Instance.new }

      it 'sets the cluster_type to instance_type' do
        is_expected.to be_instance_type
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Clusters
  class BuildKubernetesNamespaceService
    attr_reader :cluster, :environment

    def initialize(cluster, environment:)
      @cluster = cluster
      @environment = environment
    end

    def execute
      cluster.kubernetes_namespaces.build(attributes)
    end

    private

    def attributes
      attributes = {
        project: environment.project,
        namespace: namespace,
        service_account_name: ""#{namespace}-service-account""
      }

      attributes[:cluster_project] = cluster.cluster_project if cluster.project_type?
      attributes[:environment] = environment if cluster.namespace_per_environment?

      attributes
    end

    def namespace
      Gitlab::Kubernetes::DefaultNamespace.new(cluster, project: environment.project).from_environment_slug(environment.slug)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Clusters::BuildKubernetesNamespaceService, feature_category: :deployment_management do
  let(:cluster) { create(:cluster, :project, :provided_by_gcp) }
  let(:environment) { create(:environment) }
  let(:project) { environment.project }

  let(:namespace_generator) { double(from_environment_slug: namespace) }
  let(:namespace) { 'namespace' }

  subject { described_class.new(cluster, environment: environment).execute }

  before do
    allow(Gitlab::Kubernetes::DefaultNamespace).to receive(:new).and_return(namespace_generator)
  end

  shared_examples 'shared attributes' do
    it 'initializes a new namespace and sets default values' do
      expect(subject).to be_new_record
      expect(subject.cluster).to eq cluster
      expect(subject.project).to eq project
      expect(subject.namespace).to eq namespace
      expect(subject.service_account_name).to eq ""#{namespace}-service-account""
    end
  end

  include_examples 'shared attributes'

  it 'sets cluster_project and environment' do
    expect(subject.cluster_project).to eq cluster.cluster_project
    expect(subject.environment).to eq environment
  end

  context 'namespace per environment is disabled' do
    let(:cluster) { create(:cluster, :project, :provided_by_gcp, :namespace_per_environment_disabled) }

    include_examples 'shared attributes'

    it 'does not set environment' do
      expect(subject.cluster_project).to eq cluster.cluster_project
      expect(subject.environment).to be_nil
    end
  end

  context 'group cluster' do
    let(:cluster) { create(:cluster, :group, :provided_by_gcp) }

    include_examples 'shared attributes'

    it 'does not set cluster_project' do
      expect(subject.cluster_project).to be_nil
      expect(subject.environment).to eq environment
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Clusters
  class DestroyService
    attr_reader :current_user, :params

    def initialize(user = nil, params = {})
      @current_user = user
      @params = params.dup
      @response = {}
    end

    def execute(cluster)
      cleanup? ? start_cleanup!(cluster) : destroy_cluster!(cluster)

      @response
    end

    private

    def cleanup?
      Gitlab::Utils.to_boolean(params[:cleanup])
    end

    def start_cleanup!(cluster)
      cluster.start_cleanup!
      @response[:message] = _('Kubernetes cluster integration and resources are being removed.')
    end

    def destroy_cluster!(cluster)
      cluster.destroy!
      @response[:message] = _('Kubernetes cluster integration was successfully removed.')
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Clusters::DestroyService, feature_category: :deployment_management do
  describe '#execute' do
    subject { described_class.new(cluster.user, params).execute(cluster) }

    let!(:cluster) { create(:cluster, :project, :provided_by_user) }

    context 'when correct params' do
      shared_examples 'only removes cluster' do
        it 'does not start cleanup' do
          expect(cluster).not_to receive(:start_cleanup)
          subject
        end

        it 'destroys the cluster' do
          subject
          expect { cluster.reload }.to raise_error ActiveRecord::RecordNotFound
        end
      end

      context 'when params are empty' do
        let(:params) { {} }

        it_behaves_like 'only removes cluster'
      end

      context 'when cleanup param is false' do
        let(:params) { { cleanup: 'false' } }

        it_behaves_like 'only removes cluster'
      end

      context 'when cleanup param is true' do
        let(:params) { { cleanup: 'true' } }

        before do
          allow(Clusters::Cleanup::ProjectNamespaceWorker).to receive(:perform_async)
        end

        it 'does not destroy cluster' do
          subject
          expect(Clusters::Cluster.where(id: cluster.id).exists?).not_to be_falsey
        end

        it 'transition cluster#cleanup_status from cleanup_not_started to cleanup_removing_project_namespaces' do
          expect { subject }.to change { cluster.cleanup_status_name }
            .from(:cleanup_not_started)
            .to(:cleanup_removing_project_namespaces)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Clusters
  class UpdateService
    attr_reader :current_user, :params

    def initialize(user = nil, params = {})
      @current_user = user
      @params = params.dup
    end

    def execute(cluster)
      if validate_params(cluster)
        token = params.dig(:platform_kubernetes_attributes, :token)

        if token.blank?
          params[:platform_kubernetes_attributes]&.delete(:token)
        end

        cluster.update(params)
      else
        false
      end
    end

    private

    def validate_params(cluster)
      ::Clusters::Management::ValidateManagementProjectPermissionsService.new(current_user)
        .execute(cluster, params[:management_project_id])
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Clusters::UpdateService, feature_category: :deployment_management do
  include KubernetesHelpers

  describe '#execute' do
    subject { described_class.new(cluster.user, params).execute(cluster) }

    let(:cluster) { create(:cluster, :project, :provided_by_user) }

    context 'when correct params' do
      context 'when enabled is true' do
        let(:params) { { enabled: true } }

        it 'enables cluster' do
          is_expected.to eq(true)
          expect(cluster.enabled).to be_truthy
        end
      end

      context 'when enabled is false' do
        let(:params) { { enabled: false } }

        it 'disables cluster' do
          is_expected.to eq(true)
          expect(cluster.enabled).to be_falsy
        end
      end

      context 'when namespace is specified' do
        let(:params) do
          {
            platform_kubernetes_attributes: {
              namespace: 'custom-namespace'
            }
          }
        end

        before do
          stub_kubeclient_get_namespace('https://kubernetes.example.com', namespace: 'my-namespace')
        end

        it 'updates namespace' do
          is_expected.to eq(true)
          expect(cluster.platform.namespace).to eq('custom-namespace')
        end
      end

      context 'when service token is empty' do
        let(:params) do
          {
              platform_kubernetes_attributes: {
                  token: ''
              }
          }
        end

        it 'does not update the token' do
          current_token = cluster.platform.token
          is_expected.to eq(true)
          cluster.platform.reload

          expect(cluster.platform.token).to eq(current_token)
        end
      end

      context 'when service token is not empty' do
        let(:params) do
          {
              platform_kubernetes_attributes: {
                  token: 'new secret token'
              }
          }
        end

        it 'updates the token' do
          is_expected.to eq(true)
          expect(cluster.platform.token).to eq('new secret token')
        end
      end
    end

    context 'when invalid params' do
      let(:params) do
        {
          platform_kubernetes_attributes: {
            namespace: '!!!'
          }
        }
      end

      it 'returns false' do
        is_expected.to eq(false)
        expect(cluster.errors[:""platform_kubernetes.namespace""]).to be_present
      end
    end

    context 'when cluster is provided by GCP' do
      let(:cluster) { create(:cluster, :project, :provided_by_gcp) }

      let(:params) do
        {
          name: 'my-new-name'
        }
      end

      it 'does not change cluster name' do
        is_expected.to eq(false)

        cluster.reload
        expect(cluster.name).to eq('test-cluster')
      end

      context 'when cluster is being created' do
        let(:cluster) { create(:cluster, :providing_by_gcp) }

        it 'rejects changes' do
          is_expected.to eq(false)

          expect(cluster.errors.full_messages).to include('Cannot modify provider during creation')
        end
      end
    end

    context 'when params includes :management_project_id' do
      context 'management_project is non-existent' do
        let(:params) do
          { management_project_id: 0 }
        end

        it 'does not update management_project_id' do
          is_expected.to eq(false)

          expect(cluster.errors[:management_project_id]).to include('Project does not exist or you don\'t have permission to perform this action')

          cluster.reload
          expect(cluster.management_project_id).to be_nil
        end
      end

      shared_examples 'setting a management project' do
        context 'user is authorized to adminster manangement_project' do
          before do
            management_project.add_maintainer(cluster.user)
          end

          let(:params) do
            { management_project_id: management_project.id }
          end

          it 'updates management_project_id' do
            is_expected.to eq(true)

            expect(cluster.management_project).to eq(management_project)
          end
        end

        context 'user is not authorized to adminster manangement_project' do
          let(:params) do
            { management_project_id: management_project.id }
          end

          it 'does not update management_project_id' do
            is_expected.to eq(false)

            expect(cluster.errors[:management_project_id]).to include('Project does not exist or you don\'t have permission to perform this action')

            cluster.reload
            expect(cluster.management_project_id).to be_nil
          end
        end

        context 'cluster already has a management project set' do
          before do
            cluster.update!(management_project: create(:project))
          end

          let(:params) do
            { management_project_id: '' }
          end

          it 'unsets management_project_id' do
            is_expected.to eq(true)

            cluster.reload
            expect(cluster.management_project_id).to be_nil
          end
        end
      end

      context 'project cluster' do
        include_examples 'setting a management project' do
          let(:management_project) { create(:project, namespace: cluster.first_project.namespace) }
        end

        context 'manangement_project is outside of the namespace scope' do
          before do
            management_project.update!(group: create(:group))
          end

          let(:params) do
            { management_project_id: management_project.id }
          end

          it 'does not update management_project_id' do
            is_expected.to eq(false)

            expect(cluster.errors[:management_project_id]).to include('Project does not exist or you don\'t have permission to perform this action')

            cluster.reload
            expect(cluster.management_project_id).to be_nil
          end
        end
      end

      context 'group cluster' do
        let(:cluster) { create(:cluster, :group) }

        include_examples 'setting a management project' do
          let(:management_project) { create(:project, group: cluster.first_group) }
        end

        context 'manangement_project is outside of the namespace scope' do
          before do
            management_project.update!(group: create(:group))
          end

          let(:params) do
            { management_project_id: management_project.id }
          end

          it 'does not update management_project_id' do
            is_expected.to eq(false)

            expect(cluster.errors[:management_project_id]).to include('Project does not exist or you don\'t have permission to perform this action')

            cluster.reload
            expect(cluster.management_project_id).to be_nil
          end
        end
      end

      context 'instance cluster' do
        let(:cluster) { create(:cluster, :instance) }

        include_examples 'setting a management project' do
          let(:management_project) { create(:project) }
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Clusters
  class CreateService
    attr_reader :current_user, :params

    def initialize(user = nil, params = {})
      @current_user = user
      @params = params.dup
    end

    def execute(access_token: nil)
      raise ArgumentError, 'Unknown clusterable provided' unless clusterable

      cluster_params = params.merge(global_params).merge(clusterable_params)

      cluster_params[:provider_gcp_attributes].try do |provider|
        provider[:access_token] = access_token
      end

      cluster = Clusters::Cluster.new(cluster_params)

      validate_management_project_permissions(cluster)

      return cluster if cluster.errors.present?

      cluster.tap(&:save)
    end

    private

    def clusterable
      @clusterable ||= params.delete(:clusterable)
    end

    def global_params
      { user: current_user }
    end

    def clusterable_params
      case clusterable
      when ::Project
        { cluster_type: :project_type, projects: [clusterable] }
      when ::Group
        { cluster_type: :group_type, groups: [clusterable] }
      when Instance
        { cluster_type: :instance_type }
      else
        raise NotImplementedError
      end
    end

    def validate_management_project_permissions(cluster)
      Clusters::Management::ValidateManagementProjectPermissionsService.new(current_user)
        .execute(cluster, params[:management_project_id])
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Clusters::CreateService, feature_category: :deployment_management do
  let(:access_token) { 'xxx' }
  let(:project) { create(:project) }
  let(:user) { create(:user) }

  subject { described_class.new(user, params).execute(access_token: access_token) }

  context 'when provider is gcp' do
    context 'when project has no clusters' do
      context 'when correct params' do
        let(:params) do
          {
            name: 'test-cluster',
            provider_type: :gcp,
            provider_gcp_attributes: {
              gcp_project_id: 'gcp-project',
              zone: 'us-central1-a',
              num_nodes: 1,
              machine_type: 'machine_type-a',
              legacy_abac: 'true'
            },
            clusterable: project
          }
        end

        include_examples 'create cluster service success'
      end

      context 'when invalid params' do
        let(:params) do
          {
            name: 'test-cluster',
            provider_type: :gcp,
            provider_gcp_attributes: {
              gcp_project_id: '!!!!!!!',
              zone: 'us-central1-a',
              num_nodes: 1,
              machine_type: 'machine_type-a'
            },
            clusterable: project
          }
        end

        include_examples 'create cluster service error'
      end
    end

    context 'when project has a cluster' do
      include_context 'with valid cluster create params'
      let!(:cluster) { create(:cluster, :provided_by_gcp, :production_environment, projects: [project]) }

      it 'creates another cluster' do
        expect { subject }.to change { Clusters::Cluster.count }.by(1)
      end
    end
  end

  context 'when another cluster exists' do
    let!(:cluster) { create(:cluster, :provided_by_gcp, :production_environment, projects: [project]) }

    context 'when correct params' do
      let(:params) do
        {
          name: 'test-cluster',
          provider_type: :gcp,
          provider_gcp_attributes: {
            gcp_project_id: 'gcp-project',
            zone: 'us-central1-a',
            num_nodes: 1,
            machine_type: 'machine_type-a',
            legacy_abac: 'true'
          },
          clusterable: project
        }
      end

      include_examples 'create cluster service success'
    end

    context 'when invalid params' do
      let(:params) do
        {
          name: 'test-cluster',
          provider_type: :gcp,
          provider_gcp_attributes: {
            gcp_project_id: '!!!!!!!',
            zone: 'us-central1-a',
            num_nodes: 1,
            machine_type: 'machine_type-a'
          },
          clusterable: project
        }
      end

      include_examples 'create cluster service error'
    end
  end

  context 'when params includes :management_project_id' do
    subject(:cluster) { described_class.new(user, params).execute(access_token: access_token) }

    let(:params) do
      {
        name: 'test-cluster',
        provider_type: :gcp,
        provider_gcp_attributes: {
          gcp_project_id: 'gcp-project',
          zone: 'us-central1-a',
          num_nodes: 1,
          machine_type: 'machine_type-a',
          legacy_abac: 'true'
        },
        clusterable: clusterable,
        management_project_id: management_project_id
      }
    end

    let(:clusterable) { project }
    let(:management_project_id) { management_project.id }
    let(:management_project_namespace) { project.namespace }
    let(:management_project) { create(:project, namespace: management_project_namespace) }

    shared_examples 'invalid project or cluster permissions' do
      it 'does not persist the cluster and adds errors' do
        expect(cluster).not_to be_persisted

        expect(cluster.errors[:management_project_id]).to include('Project does not exist or you don\'t have permission to perform this action')
      end
    end

    shared_examples 'setting a management project' do
      context 'when user is authorized to adminster manangement_project' do
        before do
          management_project.add_maintainer(user)
        end

        it 'persists the cluster' do
          expect(cluster).to be_persisted

          expect(cluster.management_project).to eq(management_project)
        end
      end

      context 'when user is not authorized to adminster manangement_project' do
        include_examples 'invalid project or cluster permissions'
      end
    end

    shared_examples 'setting a management project outside of scope' do
      context 'when manangement_project is outside of the namespace scope' do
        let(:management_project_namespace) { create(:group) }

        it 'does not persist the cluster' do
          expect(cluster).not_to be_persisted

          expect(cluster.errors[:management_project_id]).to include('Project does not exist or you don\'t have permission to perform this action')
        end
      end
    end

    context 'management_project is non-existent' do
      let(:management_project_id) { 0 }

      include_examples 'invalid project or cluster permissions'
    end

    context 'project cluster' do
      include_examples 'setting a management project'
      include_examples 'setting a management project outside of scope'
    end

    context 'group cluster' do
      let(:management_project_namespace) { create(:group) }
      let(:clusterable) { management_project_namespace }

      include_examples 'setting a management project'
      include_examples 'setting a management project outside of scope'
    end

    context 'instance cluster' do
      let(:clusterable) { Clusters::Instance.new }

      include_examples 'setting a management project'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Clusters
  module Management
    class ValidateManagementProjectPermissionsService
      attr_reader :current_user

      def initialize(user = nil)
        @current_user = user
      end

      def execute(cluster, management_project_id)
        if management_project_id.present?
          management_project = management_project_scope(cluster).find_by_id(management_project_id)

          unless management_project && can_admin_pipeline_for_project?(management_project)
            cluster.errors.add(:management_project_id, _('Project does not exist or you don\'t have permission to perform this action'))

            return false
          end
        end

        true
      end

      private

      def can_admin_pipeline_for_project?(project)
        Ability.allowed?(current_user, :admin_pipeline, project)
      end

      def management_project_scope(cluster)
        return ::Project.all if cluster.instance_type?

        group =
          if cluster.group_type?
            cluster.first_group
          elsif cluster.project_type?
            cluster.first_project&.namespace
          end

        # Prevent users from selecting nested projects until
        # https://gitlab.com/gitlab-org/gitlab/issues/34650 is resolved
        include_subgroups = cluster.group_type?

        ::GroupProjectsFinder.new(
          group: group,
          current_user: current_user,
          options: { exclude_shared: true, include_subgroups: include_subgroups }
        ).execute
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Clusters::Management::ValidateManagementProjectPermissionsService, feature_category: :deployment_management do
  describe '#execute' do
    subject { described_class.new(user).execute(cluster, management_project_id) }

    let(:cluster) { build(:cluster, :project, projects: [create(:project)]) }
    let(:user) { create(:user) }

    context 'when management_project_id is nil' do
      let(:management_project_id) { nil }

      it { is_expected.to be true }
    end

    context 'when management_project_id is not nil' do
      let(:management_project_id) { management_project.id }
      let(:management_project_namespace) { create(:group) }
      let(:management_project) { create(:project, namespace: management_project_namespace) }

      context 'when management_project does not exist' do
        let(:management_project_id) { 0 }

        it 'adds errors to the cluster and returns false' do
          is_expected.to eq false

          expect(cluster.errors[:management_project_id]).to include('Project does not exist or you don\'t have permission to perform this action')
        end
      end

      shared_examples 'management project is in scope' do
        context 'when user is authorized to administer manangement_project' do
          before do
            management_project.add_maintainer(user)
          end

          it 'adds no error and returns true' do
            is_expected.to eq true

            expect(cluster.errors).to be_empty
          end
        end

        context 'when user is not authorized to adminster manangement_project' do
          it 'adds an error and returns false' do
            is_expected.to eq false

            expect(cluster.errors[:management_project_id]).to include('Project does not exist or you don\'t have permission to perform this action')
          end
        end
      end

      shared_examples 'management project is out of scope' do
        context 'when manangement_project is outside of the namespace scope' do
          let(:management_project_namespace) { create(:group) }

          it 'adds an error and returns false' do
            is_expected.to eq false

            expect(cluster.errors[:management_project_id]).to include('Project does not exist or you don\'t have permission to perform this action')
          end
        end
      end

      context 'project cluster' do
        let(:cluster) { build(:cluster, :project, projects: [create(:project, namespace: management_project_namespace)]) }

        include_examples 'management project is in scope'
        include_examples 'management project is out of scope'
      end

      context 'group cluster' do
        let(:cluster) { build(:cluster, :group, groups: [management_project_namespace]) }

        include_examples 'management project is in scope'
        include_examples 'management project is out of scope'
      end

      context 'instance cluster' do
        let(:cluster) { build(:cluster, :instance) }

        include_examples 'management project is in scope'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Clusters
  module Agents
    class CreateActivityEventService
      def initialize(agent, **params)
        @agent = agent
        @params = params
      end

      def execute
        agent.activity_events.create!(params)

        DeleteExpiredEventsWorker.perform_at(schedule_cleanup_at, agent.id)

        ServiceResponse.success
      rescue StandardError => e
        Gitlab::ErrorTracking.track_exception(e, agent_id: agent.id)

        ServiceResponse.error(message: e.message)
      end

      private

      attr_reader :agent, :params

      def schedule_cleanup_at
        1.hour.from_now.change(min: agent.id % 60)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Clusters::Agents::CreateActivityEventService, feature_category: :deployment_management do
  let_it_be(:agent) { create(:cluster_agent) }
  let_it_be(:token) { create(:cluster_agent_token, agent: agent) }
  let_it_be(:user) { create(:user) }

  describe '#execute' do
    let(:params) do
      {
        kind: :token_created,
        level: :info,
        recorded_at: token.created_at,
        user: user,
        agent_token: token
      }
    end

    subject { described_class.new(agent, **params).execute }

    it 'creates an activity event record' do
      expect { subject }.to change(agent.activity_events, :count).from(0).to(1)

      event = agent.activity_events.last

      expect(event).to have_attributes(
        kind: 'token_created',
        level: 'info',
        recorded_at: token.reload.created_at,
        user: user,
        agent_token_id: token.id
      )
    end

    it 'schedules the cleanup worker' do
      expect(Clusters::Agents::DeleteExpiredEventsWorker).to receive(:perform_at)
        .with(1.hour.from_now.change(min: agent.id % 60), agent.id)

      subject
    end

    context 'when activity event creation fails' do
      let(:params) { {} }

      it 'tracks the exception without raising' do
        expect(Gitlab::ErrorTracking).to receive(:track_exception)
          .with(instance_of(ActiveRecord::RecordInvalid), agent_id: agent.id)

        subject
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Clusters
  module Agents
    class AuthorizeProxyUserService < ::BaseService
      include ::Gitlab::Utils::StrongMemoize

      def initialize(current_user, agent)
        @current_user = current_user
        @agent = agent
      end

      def execute
        return forbidden('`user_access` keyword is not found in agent config file.') unless user_access_config.present?

        access_as = user_access_config['access_as']

        return forbidden('`access_as` is not found under the `user_access` keyword.') unless access_as.present?
        return forbidden('`access_as` must exist only once under the `user_access` keyword.') if access_as.size != 1

        handle_access(access_as)
      end

      private

      attr_reader :current_user, :agent

      # Override in EE
      def handle_access(access_as)
        access_as_agent if access_as.key?('agent')
      end

      def authorizations
        @authorizations ||= ::Clusters::Agents::Authorizations::UserAccess::Finder
          .new(current_user, agent: agent).execute
      end

      def response_base
        {
          agent: {
            id: agent.id,
            config_project: { id: agent.project_id }
          },
          user: {
            id: current_user.id,
            username: current_user.username
          }
        }
      end

      def access_as_agent
        if authorizations.empty?
          return forbidden('You must be a member of `projects` or `groups` under the `user_access` keyword.')
        end

        success(payload: response_base.merge(access_as: { agent: {} }))
      end

      def user_access_config
        agent.user_access_config
      end
      strong_memoize_attr :user_access_config

      delegate :success, to: ServiceResponse, private: true

      def forbidden(message)
        ServiceResponse.error(reason: :forbidden, message: message)
      end
    end
  end
end

Clusters::Agents::AuthorizeProxyUserService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Clusters::Agents::AuthorizeProxyUserService, feature_category: :deployment_management do
  subject(:service_response) { service.execute }

  let(:service) { described_class.new(user, agent) }
  let(:user) { create(:user) }

  let_it_be(:organization) { create(:group) }
  let_it_be(:configuration_project) { create(:project, group: organization) }
  let_it_be(:agent) { create(:cluster_agent, name: 'the-agent', project: configuration_project) }
  let_it_be(:deployment_project) { create(:project, group: organization) }
  let_it_be(:deployment_group) { create(:group, parent: organization) }

  let(:user_access_config) do
    {
      'user_access' => {
        'access_as' => { 'agent' => {} },
        'projects' => [{ 'id' => deployment_project.full_path }],
        'groups' => [{ 'id' => deployment_group.full_path }]
      }
    }
  end

  before do
    Clusters::Agents::Authorizations::UserAccess::RefreshService.new(agent, config: user_access_config).execute
  end

  it 'returns forbidden when user has no access to any project', :aggregate_failures do
    expect(service_response).to be_error
    expect(service_response.reason).to eq :forbidden
    expect(service_response.message)
      .to eq 'You must be a member of `projects` or `groups` under the `user_access` keyword.'
  end

  context 'when user is member of an authorized group' do
    it 'authorizes developers', :aggregate_failures do
      deployment_group.add_member(user, :developer)
      expect(service_response).to be_success
      expect(service_response.payload[:user]).to include(id: user.id, username: user.username)
      expect(service_response.payload[:agent]).to include(id: agent.id, config_project: { id: agent.project.id })
    end

    it 'does not authorize reporters', :aggregate_failures do
      deployment_group.add_member(user, :reporter)
      expect(service_response).to be_error
      expect(service_response.reason).to eq :forbidden
      expect(service_response.message)
        .to eq 'You must be a member of `projects` or `groups` under the `user_access` keyword.'
    end
  end

  context 'when user is member of an authorized project' do
    it 'authorizes developers', :aggregate_failures do
      deployment_project.add_member(user, :developer)
      expect(service_response).to be_success
      expect(service_response.payload[:user]).to include(id: user.id, username: user.username)
      expect(service_response.payload[:agent]).to include(id: agent.id, config_project: { id: agent.project.id })
    end

    it 'does not authorize reporters', :aggregate_failures do
      deployment_project.add_member(user, :reporter)
      expect(service_response).to be_error
      expect(service_response.reason).to eq :forbidden
      expect(service_response.message)
        .to eq 'You must be a member of `projects` or `groups` under the `user_access` keyword.'
    end
  end

  context 'when config is empty' do
    let(:user_access_config) { {} }

    it 'returns an error', :aggregate_failures do
      expect(service_response).to be_error
      expect(service_response.reason).to eq :forbidden
      expect(service_response.message).to eq '`user_access` keyword is not found in agent config file.'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Clusters
  module Agents
    class DeleteExpiredEventsService
      def initialize(agent)
        @agent = agent
      end

      def execute
        agent.activity_events
          .recorded_before(remove_events_before)
          .each_batch { |batch| batch.delete_all }
      end

      private

      attr_reader :agent

      def remove_events_before
        agent.activity_event_deletion_cutoff
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Clusters::Agents::DeleteExpiredEventsService, feature_category: :deployment_management do
  let_it_be(:agent) { create(:cluster_agent) }

  describe '#execute' do
    let_it_be(:event1) { create(:agent_activity_event, agent: agent, recorded_at: 1.hour.ago) }
    let_it_be(:event2) { create(:agent_activity_event, agent: agent, recorded_at: 2.hours.ago) }
    let_it_be(:event3) { create(:agent_activity_event, agent: agent, recorded_at: 3.hours.ago) }
    let_it_be(:event4) { create(:agent_activity_event, agent: agent, recorded_at: 4.hours.ago) }
    let_it_be(:event5) { create(:agent_activity_event, agent: agent, recorded_at: 5.hours.ago) }

    let(:deletion_cutoff) { 1.day.ago }

    subject { described_class.new(agent).execute }

    before do
      allow(agent).to receive(:activity_event_deletion_cutoff).and_return(deletion_cutoff)
    end

    it 'does not delete events if the limit has not been reached' do
      expect { subject }.not_to change(agent.activity_events, :count)
    end

    context 'there are more events than the limit' do
      let(:deletion_cutoff) { event3.recorded_at }

      it 'removes events to remain at the limit, keeping the most recent' do
        expect { subject }.to change(agent.activity_events, :count).from(5).to(3)
        expect(agent.activity_events).to contain_exactly(event1, event2, event3)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Clusters
  module Agents
    class CreateService < BaseService
      def execute(name:)
        return error_no_permissions unless cluster_agent_permissions?

        agent = ::Clusters::Agent.new(name: name, project: project, created_by_user: current_user)

        if agent.save
          success.merge(cluster_agent: agent)
        else
          error(agent.errors.full_messages)
        end
      end

      private

      def cluster_agent_permissions?
        current_user.can?(:admin_pipeline, project) && current_user.can?(:create_cluster, project)
      end

      def error_no_permissions
        error(s_('ClusterAgent|You have insufficient permissions to create a cluster agent for this project'))
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Clusters::Agents::CreateService, feature_category: :deployment_management do
  subject(:service) { described_class.new(project, user) }

  let(:project) { create(:project, :public, :repository) }
  let(:user) { create(:user) }

  describe '#execute' do
    context 'without user permissions' do
      it 'returns errors when user does not have permissions' do
        expect(service.execute(name: 'missing-permissions')).to eq({
          status: :error,
          message: 'You have insufficient permissions to create a cluster agent for this project'
        })
      end
    end

    context 'with user permissions' do
      before do
        project.add_maintainer(user)
      end

      it 'creates a new clusters_agent' do
        expect { service.execute(name: 'with-user') }.to change { ::Clusters::Agent.count }.by(1)
      end

      it 'returns success status', :aggregate_failures do
        result = service.execute(name: 'success')

        expect(result[:status]).to eq(:success)
        expect(result[:message]).to be_nil
      end

      it 'returns agent values', :aggregate_failures do
        new_agent = service.execute(name: 'new-agent')[:cluster_agent]

        expect(new_agent.name).to eq('new-agent')
        expect(new_agent.created_by_user).to eq(user)
      end

      it 'generates an error message when name is invalid' do
        expect(service.execute(name: '@bad_agent_name!')).to eq({
          status: :error,
          message: [""Name can contain only lowercase letters, digits, and '-', but cannot start or end with '-'""]
        })
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Clusters
  module Agents
    class DeleteService < ::BaseContainerService
      def execute(cluster_agent)
        return error_no_permissions unless current_user.can?(:admin_cluster, cluster_agent)

        if cluster_agent.destroy
          ServiceResponse.success
        else
          ServiceResponse.error(message: cluster_agent.errors.full_messages)
        end
      end

      private

      def error_no_permissions
        ServiceResponse.error(message: s_('ClusterAgent|You have insufficient permissions to delete this cluster agent'))
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Clusters::Agents::DeleteService, feature_category: :deployment_management do
  subject(:service) { described_class.new(container: project, current_user: user) }

  let(:cluster_agent) { create(:cluster_agent) }
  let(:project) { cluster_agent.project }
  let(:user) { create(:user) }

  describe '#execute' do
    context 'without user permissions' do
      it 'fails to delete when the user has no permissions', :aggregate_failures do
        response = service.execute(cluster_agent)

        expect(response.status).to eq(:error)
        expect(response.message).to eq('You have insufficient permissions to delete this cluster agent')

        expect { cluster_agent.reload }.not_to raise_error
      end
    end

    context 'with user permissions' do
      before do
        project.add_maintainer(user)
      end

      it 'deletes a cluster agent', :aggregate_failures do
        expect { service.execute(cluster_agent) }.to change { ::Clusters::Agent.count }.by(-1)
        expect { cluster_agent.reload }.to raise_error(ActiveRecord::RecordNotFound)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Clusters
  module Agents
    module Authorizations
      module UserAccess
        class RefreshService
          include Gitlab::Utils::StrongMemoize

          AUTHORIZED_ENTITY_LIMIT = 100

          delegate :project, to: :agent, private: true
          delegate :root_ancestor, to: :project, private: true

          def initialize(agent, config:)
            @agent = agent
            @config = config
          end

          def execute
            refresh_projects!
            refresh_groups!

            true
          end

          private

          attr_reader :agent, :config

          def refresh_projects!
            if allowed_project_configurations.present?
              project_ids = allowed_project_configurations.map { |config| config.fetch(:project_id) }

              agent.with_lock do
                agent.user_access_project_authorizations.upsert_configs(allowed_project_configurations)
                agent.user_access_project_authorizations.delete_unlisted(project_ids)
              end
            else
              agent.user_access_project_authorizations.delete_all(:delete_all)
            end
          end

          def refresh_groups!
            if allowed_group_configurations.present?
              group_ids = allowed_group_configurations.map { |config| config.fetch(:group_id) }

              agent.with_lock do
                agent.user_access_group_authorizations.upsert_configs(allowed_group_configurations)
                agent.user_access_group_authorizations.delete_unlisted(group_ids)
              end
            else
              agent.user_access_group_authorizations.delete_all(:delete_all)
            end
          end

          def allowed_project_configurations
            project_entries = extract_config_entries(entity: 'projects')

            return unless project_entries

            allowed_projects.where_full_path_in(project_entries.keys, use_includes: false).map do |project|
              { project_id: project.id, config: user_access_as }
            end
          end
          strong_memoize_attr :allowed_project_configurations

          def allowed_group_configurations
            group_entries = extract_config_entries(entity: 'groups')

            return unless group_entries

            allowed_groups.where_full_path_in(group_entries.keys, use_includes: false).map do |group|
              { group_id: group.id, config: user_access_as }
            end
          end
          strong_memoize_attr :allowed_group_configurations

          def extract_config_entries(entity:)
            config.dig('user_access', entity)
              &.first(AUTHORIZED_ENTITY_LIMIT)
              &.index_by { |config| config.delete('id').downcase }
          end

          def allowed_projects
            root_ancestor.all_projects
          end

          def allowed_groups
            if group_root_ancestor?
              root_ancestor.self_and_descendants
            else
              ::Group.none
            end
          end

          def group_root_ancestor?
            root_ancestor.group_namespace?
          end

          def user_access_as
            @user_access_as ||= config['user_access']&.slice('access_as') || {}
          end
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Clusters::Agents::Authorizations::UserAccess::RefreshService, feature_category: :deployment_management do
  describe '#execute' do
    let_it_be(:root_ancestor) { create(:group) }
    let_it_be(:agent_management_project) { create(:project, namespace: root_ancestor) }
    let_it_be(:group_1) { create(:group, path: 'group-path-with-UPPERCASE', parent: root_ancestor) }
    let_it_be(:group_2) { create(:group, parent: root_ancestor) }
    let_it_be(:project_1) { create(:project, path: 'project-path-with-UPPERCASE', namespace: root_ancestor) }
    let_it_be(:project_2) { create(:project, namespace: root_ancestor) }

    let(:agent) { create(:cluster_agent, project: agent_management_project) }

    let(:config) do
      {
        user_access: {
          groups: [
            { id: group_2.full_path }
          ],
          projects: [
            { id: project_2.full_path }
          ]
        }
      }.deep_merge(extra_config).deep_stringify_keys
    end

    let(:extra_config) { {} }

    subject { described_class.new(agent, config: config).execute }

    before do
      agent.user_access_group_authorizations.create!(group: group_1, config: {})
      agent.user_access_project_authorizations.create!(project: project_1, config: {})
    end

    shared_examples 'removing authorization' do
      context 'when config contains no groups or projects' do
        let(:config) { {} }

        it 'removes all authorizations' do
          expect(subject).to be_truthy
          expect(authorizations).to be_empty
        end
      end

      context 'when config contains groups or projects outside of the configuration project hierarchy' do
        let_it_be(:agent_management_project) { create(:project, namespace: create(:group)) }

        it 'removes all authorizations' do
          expect(subject).to be_truthy
          expect(authorizations).to be_empty
        end
      end

      context 'when configuration project does not belong to a group' do
        let_it_be(:agent_management_project) { create(:project) }

        it 'removes all authorizations' do
          expect(subject).to be_truthy
          expect(authorizations).to be_empty
        end
      end
    end

    describe 'group authorization' do
      it 'refreshes authorizations for the agent' do
        expect(subject).to be_truthy
        expect(agent.user_access_authorized_groups).to contain_exactly(group_2)

        added_authorization = agent.user_access_group_authorizations.find_by(group: group_2)
        expect(added_authorization.config).to eq({})
      end

      context 'when config contains ""access_as"" keyword' do
        let(:extra_config) do
          {
            user_access: {
              access_as: {
                agent: {}
              }
            }
          }
        end

        it 'refreshes authorizations for the agent' do
          expect(subject).to be_truthy
          expect(agent.user_access_authorized_groups).to contain_exactly(group_2)

          added_authorization = agent.user_access_group_authorizations.find_by(group: group_2)
          expect(added_authorization.config).to eq({ 'access_as' => { 'agent' => {} } })
        end
      end

      context 'when config contains too many groups' do
        before do
          stub_const(""#{described_class}::AUTHORIZED_ENTITY_LIMIT"", 0)
        end

        it 'authorizes groups up to the limit' do
          expect(subject).to be_truthy
          expect(agent.user_access_authorized_groups).to be_empty
        end
      end

      include_examples 'removing authorization' do
        let(:authorizations) { agent.user_access_authorized_groups }
      end
    end

    describe 'project authorization' do
      it 'refreshes authorizations for the agent' do
        expect(subject).to be_truthy
        expect(agent.user_access_authorized_projects).to contain_exactly(project_2)

        added_authorization = agent.user_access_project_authorizations.find_by(project: project_2)
        expect(added_authorization.config).to eq({})
      end

      context 'when config contains ""access_as"" keyword' do
        let(:extra_config) do
          {
            user_access: {
              access_as: {
                agent: {}
              }
            }
          }
        end

        it 'refreshes authorizations for the agent' do
          expect(subject).to be_truthy
          expect(agent.user_access_authorized_projects).to contain_exactly(project_2)

          added_authorization = agent.user_access_project_authorizations.find_by(project: project_2)
          expect(added_authorization.config).to eq({ 'access_as' => { 'agent' => {} } })
        end
      end

      context 'when project belongs to a user namespace, and is in the same namespace as the agent' do
        let_it_be(:root_ancestor) { create(:namespace) }
        let_it_be(:agent_management_project) { create(:project, namespace: root_ancestor) }
        let_it_be(:project_1) { create(:project, path: 'project-path-with-UPPERCASE', namespace: root_ancestor) }
        let_it_be(:project_2) { create(:project, namespace: root_ancestor) }

        it 'creates an authorization record for the project' do
          expect(subject).to be_truthy
          expect(agent.user_access_authorized_projects).to contain_exactly(project_2)
        end
      end

      context 'when project belongs to a user namespace, and is authorizing itself' do
        let_it_be(:root_ancestor) { create(:namespace) }
        let_it_be(:agent_management_project) { create(:project, namespace: root_ancestor) }
        let_it_be(:project_1) { create(:project, path: 'project-path-with-UPPERCASE', namespace: root_ancestor) }
        let_it_be(:project_2) { agent_management_project }

        it 'creates an authorization record for the project' do
          expect(subject).to be_truthy
          expect(agent.user_access_authorized_projects).to contain_exactly(project_2)
        end
      end

      context 'when config contains too many projects' do
        before do
          stub_const(""#{described_class}::AUTHORIZED_ENTITY_LIMIT"", 0)
        end

        it 'authorizes projects up to the limit' do
          expect(subject).to be_truthy
          expect(agent.user_access_authorized_projects).to be_empty
        end
      end

      include_examples 'removing authorization' do
        let(:authorizations) { agent.user_access_authorized_projects }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Clusters
  module Agents
    module Authorizations
      module CiAccess
        class FilterService
          def initialize(authorizations, filter_params)
            @authorizations = authorizations
            @filter_params = filter_params

            @environments_matcher = {}
          end

          def execute
            filter_by_environment(authorizations)
          end

          private

          attr_reader :authorizations, :filter_params

          def filter_by_environment(auths)
            return auths unless filter_by_environment?

            auths.select do |auth|
              next true if auth.config['environments'].blank?

              auth.config['environments'].any? { |environment_pattern| matches_environment?(environment_pattern) }
            end
          end

          def filter_by_environment?
            filter_params.has_key?(:environment)
          end

          def environment_filter
            @environment_filter ||= filter_params[:environment]
          end

          def matches_environment?(environment_pattern)
            return false if environment_filter.nil?

            environments_matcher(environment_pattern).match?(environment_filter)
          end

          def environments_matcher(environment_pattern)
            @environments_matcher[environment_pattern] ||= ::Gitlab::Ci::EnvironmentMatcher.new(environment_pattern)
          end
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Clusters::Agents::Authorizations::CiAccess::FilterService, feature_category: :continuous_integration do
  describe '#execute' do
    let_it_be(:group) { create(:group) }
    let_it_be(:project) { create(:project, group: group) }

    let(:agent_authorizations_without_env) do
      [
        build(:agent_ci_access_project_authorization, project: project, agent: build(:cluster_agent, project: project)),
        build(:agent_ci_access_group_authorization, group: group, agent: build(:cluster_agent, project: project)),
        ::Clusters::Agents::Authorizations::CiAccess::ImplicitAuthorization.new(agent: build(:cluster_agent, project: project))
      ]
    end

    let(:filter_params) { {} }

    subject(:execute_filter) { described_class.new(agent_authorizations, filter_params).execute }

    context 'when there are no filters' do
      let(:agent_authorizations) { agent_authorizations_without_env }

      it 'returns the authorizations as is' do
        expect(execute_filter).to eq agent_authorizations
      end
    end

    context 'when filtering by environment' do
      let(:agent_authorizations_with_env) do
        [
          build(
            :agent_ci_access_project_authorization,
            project: project,
            agent: build(:cluster_agent, project: project),
            environments: ['staging', 'review/*', 'production']
          ),
          build(
            :agent_ci_access_group_authorization,
            group: group,
            agent: build(:cluster_agent, project: project),
            environments: ['staging', 'review/*', 'production']
          )
        ]
      end

      let(:agent_authorizations_with_different_env) do
        [
          build(
            :agent_ci_access_project_authorization,
            project: project,
            agent: build(:cluster_agent, project: project),
            environments: ['staging']
          ),
          build(
            :agent_ci_access_group_authorization,
            group: group,
            agent: build(:cluster_agent, project: project),
            environments: ['staging']
          )
        ]
      end

      let(:agent_authorizations) do
        (
          agent_authorizations_without_env +
          agent_authorizations_with_env +
          agent_authorizations_with_different_env
        )
      end

      let(:filter_params) { { environment: 'production' } }

      it 'returns the authorizations with the given environment AND authorizations without any environment' do
        expected_authorizations = agent_authorizations_with_env + agent_authorizations_without_env

        expect(execute_filter).to match_array expected_authorizations
      end

      context 'when environment filter has a wildcard' do
        let(:filter_params) { { environment: 'review/123' } }

        it 'returns the authorizations with matching environments AND authorizations without any environment' do
          expected_authorizations = agent_authorizations_with_env + agent_authorizations_without_env

          expect(execute_filter).to match_array expected_authorizations
        end
      end

      context 'when environment filter is nil' do
        let(:filter_params) { { environment: nil } }

        it 'returns the authorizations without any environment' do
          expect(execute_filter).to match_array agent_authorizations_without_env
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Clusters
  module Agents
    module Authorizations
      module CiAccess
        class RefreshService
          include Gitlab::Utils::StrongMemoize

          AUTHORIZED_ENTITY_LIMIT = 100

          delegate :project, to: :agent, private: true
          delegate :root_ancestor, to: :project, private: true

          def initialize(agent, config:)
            @agent = agent
            @config = config
          end

          def execute
            refresh_projects!
            refresh_groups!

            true
          end

          private

          attr_reader :agent, :config

          def refresh_projects!
            if allowed_project_configurations.present?
              project_ids = allowed_project_configurations.map { |config| config.fetch(:project_id) }

              agent.with_lock do
                agent.ci_access_project_authorizations.upsert_all(allowed_project_configurations, unique_by: [:agent_id, :project_id])
                agent.ci_access_project_authorizations.where.not(project_id: project_ids).delete_all # rubocop: disable CodeReuse/ActiveRecord
              end
            else
              agent.ci_access_project_authorizations.delete_all(:delete_all)
            end
          end

          def refresh_groups!
            if allowed_group_configurations.present?
              group_ids = allowed_group_configurations.map { |config| config.fetch(:group_id) }

              agent.with_lock do
                agent.ci_access_group_authorizations.upsert_all(allowed_group_configurations, unique_by: [:agent_id, :group_id])
                agent.ci_access_group_authorizations.where.not(group_id: group_ids).delete_all # rubocop: disable CodeReuse/ActiveRecord
              end
            else
              agent.ci_access_group_authorizations.delete_all(:delete_all)
            end
          end

          def allowed_project_configurations
            strong_memoize(:allowed_project_configurations) do
              project_entries = extract_config_entries(entity: 'projects')

              if project_entries
                allowed_projects.where_full_path_in(project_entries.keys).map do |project|
                  { project_id: project.id, config: project_entries[project.full_path.downcase] }
                end
              end
            end
          end

          def allowed_group_configurations
            strong_memoize(:allowed_group_configurations) do
              group_entries = extract_config_entries(entity: 'groups')

              if group_entries
                allowed_groups.where_full_path_in(group_entries.keys).map do |group|
                  { group_id: group.id, config: group_entries[group.full_path.downcase] }
                end
              end
            end
          end

          def extract_config_entries(entity:)
            config.dig('ci_access', entity)
              &.first(AUTHORIZED_ENTITY_LIMIT)
              &.index_by { |config| config.delete('id').downcase }
          end

          def allowed_projects
            root_ancestor.all_projects
          end

          def allowed_groups
            if group_root_ancestor?
              root_ancestor.self_and_descendants
            else
              ::Group.none
            end
          end

          def group_root_ancestor?
            root_ancestor.group_namespace?
          end
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Clusters::Agents::Authorizations::CiAccess::RefreshService, feature_category: :deployment_management do
  describe '#execute' do
    let_it_be(:root_ancestor) { create(:group) }

    let_it_be(:removed_group) { create(:group, parent: root_ancestor) }
    let_it_be(:modified_group) { create(:group, parent: root_ancestor) }
    let_it_be(:added_group) { create(:group, path: 'group-path-with-UPPERCASE', parent: root_ancestor) }

    let_it_be(:removed_project) { create(:project, namespace: root_ancestor) }
    let_it_be(:modified_project) { create(:project, namespace: root_ancestor) }
    let_it_be(:added_project) { create(:project, path: 'project-path-with-UPPERCASE', namespace: root_ancestor) }

    let(:project) { create(:project, namespace: root_ancestor) }
    let(:agent) { create(:cluster_agent, project: project) }

    let(:config) do
      {
        ci_access: {
          groups: [
            { id: added_group.full_path, default_namespace: 'default' },
            # Uppercase path verifies case-insensitive matching.
            { id: modified_group.full_path.upcase, default_namespace: 'new-namespace' }
          ],
          projects: [
            { id: added_project.full_path, default_namespace: 'default' },
            # Uppercase path verifies case-insensitive matching.
            { id: modified_project.full_path.upcase, default_namespace: 'new-namespace' }
          ]
        }
      }.deep_stringify_keys
    end

    subject { described_class.new(agent, config: config).execute }

    before do
      default_config = { default_namespace: 'default' }

      agent.ci_access_group_authorizations.create!(group: removed_group, config: default_config)
      agent.ci_access_group_authorizations.create!(group: modified_group, config: default_config)

      agent.ci_access_project_authorizations.create!(project: removed_project, config: default_config)
      agent.ci_access_project_authorizations.create!(project: modified_project, config: default_config)
    end

    shared_examples 'removing authorization' do
      context 'config contains no groups' do
        let(:config) { {} }

        it 'removes all authorizations' do
          expect(subject).to be_truthy
          expect(authorizations).to be_empty
        end
      end

      context 'config contains groups outside of the configuration project hierarchy' do
        let(:project) { create(:project, namespace: create(:group)) }

        it 'removes all authorizations' do
          expect(subject).to be_truthy
          expect(authorizations).to be_empty
        end
      end

      context 'configuration project does not belong to a group' do
        let(:project) { create(:project) }

        it 'removes all authorizations' do
          expect(subject).to be_truthy
          expect(authorizations).to be_empty
        end
      end
    end

    describe 'group authorization' do
      it 'refreshes authorizations for the agent' do
        expect(subject).to be_truthy
        expect(agent.ci_access_authorized_groups).to contain_exactly(added_group, modified_group)

        added_authorization = agent.ci_access_group_authorizations.find_by(group: added_group)
        expect(added_authorization.config).to eq({ 'default_namespace' => 'default' })

        modified_authorization = agent.ci_access_group_authorizations.find_by(group: modified_group)
        expect(modified_authorization.config).to eq({ 'default_namespace' => 'new-namespace' })
      end

      context 'config contains too many groups' do
        before do
          stub_const(""#{described_class}::AUTHORIZED_ENTITY_LIMIT"", 1)
        end

        it 'authorizes groups up to the limit' do
          expect(subject).to be_truthy
          expect(agent.ci_access_authorized_groups).to contain_exactly(added_group)
        end
      end

      include_examples 'removing authorization' do
        let(:authorizations) { agent.ci_access_authorized_groups }
      end
    end

    describe 'project authorization' do
      it 'refreshes authorizations for the agent' do
        expect(subject).to be_truthy
        expect(agent.ci_access_authorized_projects).to contain_exactly(added_project, modified_project)

        added_authorization = agent.ci_access_project_authorizations.find_by(project: added_project)
        expect(added_authorization.config).to eq({ 'default_namespace' => 'default' })

        modified_authorization = agent.ci_access_project_authorizations.find_by(project: modified_project)
        expect(modified_authorization.config).to eq({ 'default_namespace' => 'new-namespace' })
      end

      context 'project does not belong to a group, and is in the same namespace as the agent' do
        let(:root_ancestor) { create(:namespace) }
        let(:added_project) { create(:project, namespace: root_ancestor) }

        it 'creates an authorization record for the project' do
          expect(subject).to be_truthy
          expect(agent.ci_access_authorized_projects).to contain_exactly(added_project)
        end
      end

      context 'project does not belong to a group, and is authorizing itself' do
        let(:root_ancestor) { create(:namespace) }
        let(:added_project) { project }

        it 'creates an authorization record for the project' do
          expect(subject).to be_truthy
          expect(agent.ci_access_authorized_projects).to contain_exactly(added_project)
        end
      end

      context 'config contains too many projects' do
        before do
          stub_const(""#{described_class}::AUTHORIZED_ENTITY_LIMIT"", 1)
        end

        it 'authorizes projects up to the limit' do
          expect(subject).to be_truthy
          expect(agent.ci_access_authorized_projects).to contain_exactly(added_project)
        end
      end

      include_examples 'removing authorization' do
        let(:authorizations) { agent.ci_access_authorized_projects }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Clusters
  module Integrations
    class CreateService < BaseContainerService
      attr_accessor :cluster

      def initialize(container:, cluster:, current_user: nil, params: {})
        @cluster = cluster

        super(container: container, current_user: current_user, params: params)
      end

      def execute
        return ServiceResponse.error(message: 'Unauthorized') unless authorized?

        integration.enabled = params[:enabled]
        integration.save!

        if integration.enabled?
          ServiceResponse.success(message: s_('ClusterIntegration|Integration enabled'), payload: { integration: integration })
        else
          ServiceResponse.success(message: s_('ClusterIntegration|Integration disabled'), payload: { integration: integration })
        end
      end

      private

      def integration
        @integration ||= \
          case params[:application_type]
          when 'prometheus'
            cluster.find_or_build_integration_prometheus
          else
            raise ArgumentError, ""invalid application_type: #{params[:application_type]}""
          end
      end

      def authorized?
        Ability.allowed?(current_user, :admin_cluster, cluster)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Clusters::Integrations::CreateService, '#execute', feature_category: :deployment_management do
  let_it_be(:project) { create(:project) }
  let_it_be_with_reload(:cluster) { create(:cluster, :provided_by_gcp, projects: [project]) }

  let(:service) do
    described_class.new(container: project, cluster: cluster, current_user: project.first_owner, params: params)
  end

  shared_examples_for 'a cluster integration' do |application_type|
    let(:integration) { cluster.public_send(""integration_#{application_type}"") }

    context 'when enabled param is true' do
      let(:params) do
        { application_type: application_type, enabled: true }
      end

      it 'creates a new enabled integration' do
        expect(service.execute).to be_success

        expect(integration).to be_present
        expect(integration).to be_persisted
        expect(integration).to be_enabled
      end
    end

    context 'when enabled param is false' do
      let(:params) do
        { application_type: application_type, enabled: false }
      end

      it 'creates a new disabled integration' do
        expect(service.execute).to be_success

        expect(integration).to be_present
        expect(integration).to be_persisted
        expect(integration).not_to be_enabled
      end
    end

    context 'when integration already exists' do
      before do
        create(:""clusters_integrations_#{application_type}"", cluster: cluster, enabled: false)
      end

      let(:params) do
        { application_type: application_type, enabled: true }
      end

      it 'updates the integration' do
        expect(integration).not_to be_enabled

        expect(service.execute).to be_success

        expect(integration.reload).to be_enabled
      end
    end
  end

  it_behaves_like 'a cluster integration', 'prometheus'

  context 'when application_type is invalid' do
    let(:params) do
      { application_type: 'something_else', enabled: true }
    end

    it 'errors' do
      expect { service.execute }.to raise_error(ArgumentError)
    end
  end

  context 'when user is unauthorized' do
    let(:params) do
      { application_type: 'prometheus', enabled: true }
    end

    let(:service) do
      unauthorized_user = create(:user)

      described_class.new(container: project, cluster: cluster, current_user: unauthorized_user, params: params)
    end

    it 'returns error and does not create a new integration record' do
      expect(service.execute).to be_error

      expect(cluster.integration_prometheus).to be_nil
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Clusters
  module Cleanup
    class ProjectNamespaceService < ::Clusters::Cleanup::BaseService
      KUBERNETES_NAMESPACE_BATCH_SIZE = 100

      def execute
        delete_project_namespaces_in_batches

        # Keep calling the worker untill all namespaces are deleted
        if cluster.kubernetes_namespaces.exists?
          return schedule_next_execution(Clusters::Cleanup::ProjectNamespaceWorker)
        end

        cluster.continue_cleanup!
      end

      private

      def delete_project_namespaces_in_batches
        kubernetes_namespaces_batch = cluster.kubernetes_namespaces.first(KUBERNETES_NAMESPACE_BATCH_SIZE)

        kubernetes_namespaces_batch.each do |kubernetes_namespace|
          log_event(:deleting_project_namespace, namespace: kubernetes_namespace.namespace)

          begin
            kubeclient_delete_namespace(kubernetes_namespace)
          rescue Kubeclient::HttpError => e
            # unauthorized, forbidden: GitLab's access has been revoked
            # certificate verify failed: Cluster is probably gone forever
            raise unless /unauthorized|forbidden|certificate verify failed/i.match?(e.message)
          end

          kubernetes_namespace.destroy!
        end
      end

      def kubeclient_delete_namespace(kubernetes_namespace)
        cluster.kubeclient&.delete_namespace(kubernetes_namespace.namespace)
      rescue Kubeclient::ResourceNotFoundError
        # The resources have already been deleted, possibly on a previous attempt that timed out
      rescue Gitlab::HTTP_V2::UrlBlocker::BlockedUrlError
        # User gave an invalid cluster from the start, or deleted the endpoint before this job ran
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Clusters::Cleanup::ProjectNamespaceService, feature_category: :deployment_management do
  describe '#execute' do
    subject { service.execute }

    let!(:service) { described_class.new(cluster) }
    let!(:cluster) { create(:cluster, :with_environments, :cleanup_removing_project_namespaces) }
    let!(:logger) { service.send(:logger) }
    let(:log_meta) do
      {
        service: described_class.name,
        cluster_id: cluster.id,
        execution_count: 0
      }
    end

    let(:kubeclient_instance_double) do
      instance_double(Gitlab::Kubernetes::KubeClient, delete_namespace: nil, delete_service_account: nil)
    end

    before do
      allow_any_instance_of(Clusters::Cluster).to receive(:kubeclient).and_return(kubeclient_instance_double)
    end

    context 'when cluster has namespaces to be deleted' do
      it 'deletes namespaces from cluster' do
        expect(kubeclient_instance_double).to receive(:delete_namespace)
          .with cluster.kubernetes_namespaces[0].namespace
        expect(kubeclient_instance_double).to receive(:delete_namespace)
          .with(cluster.kubernetes_namespaces[1].namespace)

        subject
      end

      it 'deletes namespaces from database' do
        expect { subject }.to change { cluster.kubernetes_namespaces.exists? }.from(true).to(false)
      end

      it 'schedules ::ServiceAccountWorker' do
        expect(Clusters::Cleanup::ServiceAccountWorker).to receive(:perform_async).with(cluster.id)
        subject
      end

      it 'logs all events' do
        expect(logger).to receive(:info)
          .with(
            log_meta.merge(
              event: :deleting_project_namespace,
              namespace: cluster.kubernetes_namespaces[0].namespace))
        expect(logger).to receive(:info)
          .with(
            log_meta.merge(
              event: :deleting_project_namespace,
              namespace: cluster.kubernetes_namespaces[1].namespace))

        subject
      end

      context 'when cluster.kubeclient is nil' do
        let(:kubeclient_instance_double) { nil }

        it 'schedules ::ServiceAccountWorker' do
          expect(Clusters::Cleanup::ServiceAccountWorker).to receive(:perform_async).with(cluster.id)
          subject
        end

        it 'deletes namespaces from database' do
          expect { subject }.to change { cluster.kubernetes_namespaces.exists? }.from(true).to(false)
        end
      end
    end

    context 'when cluster has no namespaces' do
      let!(:cluster) { create(:cluster, :cleanup_removing_project_namespaces) }

      it 'schedules Clusters::Cleanup::ServiceAccountWorker' do
        expect(Clusters::Cleanup::ServiceAccountWorker).to receive(:perform_async).with(cluster.id)

        subject
      end

      it 'transitions to cleanup_removing_service_account' do
        expect { subject }
          .to change { cluster.reload.cleanup_status_name }
          .from(:cleanup_removing_project_namespaces)
          .to(:cleanup_removing_service_account)
      end

      it 'does not try to delete namespaces' do
        expect(kubeclient_instance_double).not_to receive(:delete_namespace)

        subject
      end
    end

    context 'when there is a Kubeclient::HttpError' do
      let(:kubeclient_instance_double) do
        instance_double(Gitlab::Kubernetes::KubeClient)
      end

      ['Unauthorized', 'forbidden', 'Certificate verify Failed'].each do |message|
        it 'schedules ::ServiceAccountWorker with accepted errors' do
          allow(kubeclient_instance_double)
            .to receive(:delete_namespace)
            .and_raise(Kubeclient::HttpError.new(401, message, nil))

          expect(Clusters::Cleanup::ServiceAccountWorker).to receive(:perform_async).with(cluster.id)

          subject
        end
      end

      it 'raises error with unaccepted errors' do
        allow(kubeclient_instance_double)
          .to receive(:delete_namespace)
          .and_raise(Kubeclient::HttpError.new(401, 'unexpected message', nil))

        expect { subject }.to raise_error(Kubeclient::HttpError)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Clusters
  module Cleanup
    class ServiceAccountService < ::Clusters::Cleanup::BaseService
      def execute
        delete_gitlab_service_account

        log_event(:destroying_cluster)

        cluster.destroy!
      end

      private

      def delete_gitlab_service_account
        log_event(:deleting_gitlab_service_account)

        cluster.kubeclient&.delete_service_account(
          ::Clusters::Kubernetes::GITLAB_SERVICE_ACCOUNT_NAME,
          ::Clusters::Kubernetes::GITLAB_SERVICE_ACCOUNT_NAMESPACE
        )
      rescue Kubeclient::ResourceNotFoundError
        # The resources have already been deleted, possibly on a previous attempt that timed out
      rescue Gitlab::HTTP_V2::UrlBlocker::BlockedUrlError
        # User gave an invalid cluster from the start, or deleted the endpoint before this job ran
      rescue Kubeclient::HttpError => e
        # unauthorized, forbidden: GitLab's access has been revoked
        # certificate verify failed: Cluster is probably gone forever
        raise unless /unauthorized|forbidden|certificate verify failed/i.match?(e.message)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Clusters::Cleanup::ServiceAccountService, feature_category: :deployment_management do
  describe '#execute' do
    subject { service.execute }

    let!(:service) { described_class.new(cluster) }
    let!(:cluster) { create(:cluster, :cleanup_removing_service_account) }
    let!(:logger) { service.send(:logger) }
    let(:log_meta) do
      {
        service: described_class.name,
        cluster_id: cluster.id,
        execution_count: 0
      }
    end

    let(:kubeclient_instance_double) do
      instance_double(Gitlab::Kubernetes::KubeClient, delete_namespace: nil, delete_service_account: nil)
    end

    before do
      allow_any_instance_of(Clusters::Cluster).to receive(:kubeclient).and_return(kubeclient_instance_double)
    end

    it 'deletes gitlab service account' do
      expect(kubeclient_instance_double).to receive(:delete_service_account)
        .with(
          ::Clusters::Kubernetes::GITLAB_SERVICE_ACCOUNT_NAME,
          ::Clusters::Kubernetes::GITLAB_SERVICE_ACCOUNT_NAMESPACE)

      subject
    end

    it 'logs all events' do
      expect(logger).to receive(:info).with(log_meta.merge(event: :deleting_gitlab_service_account))
      expect(logger).to receive(:info).with(log_meta.merge(event: :destroying_cluster))

      subject
    end

    it 'deletes cluster' do
      expect { subject }.to change { Clusters::Cluster.where(id: cluster.id).exists? }.from(true).to(false)
    end

    context 'when cluster.kubeclient is nil' do
      let(:kubeclient_instance_double) { nil }

      it 'deletes cluster' do
        expect { subject }.to change { Clusters::Cluster.where(id: cluster.id).exists? }.from(true).to(false)
      end
    end

    context 'when there is a Kubeclient::HttpError' do
      ['Unauthorized', 'forbidden', 'Certificate verify Failed'].each do |message|
        context ""with error:#{message}"" do
          before do
            allow(kubeclient_instance_double)
              .to receive(:delete_service_account)
              .and_raise(Kubeclient::HttpError.new(401, message, nil))
          end

          it 'destroys cluster' do
            expect { subject }.to change { Clusters::Cluster.where(id: cluster.id).exists? }.from(true).to(false)
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Clusters
  module AgentTokens
    class TrackUsageService
      # The `UPDATE_USED_COLUMN_EVERY` defines how often the token DB entry can be updated
      UPDATE_USED_COLUMN_EVERY = (40.minutes..55.minutes)

      delegate :agent, to: :token

      def initialize(token)
        @token = token
      end

      def execute
        track_values = { last_used_at: Time.current.utc }

        token.cache_attributes(track_values)

        if can_update_track_values?
          log_activity_event!(track_values[:last_used_at]) unless agent.connected?

          # Use update_column so updated_at is skipped
          token.update_columns(track_values)
        end
      end

      private

      attr_reader :token

      def can_update_track_values?
        # Use a random threshold to prevent beating DB updates.
        last_used_at_max_age = Random.rand(UPDATE_USED_COLUMN_EVERY)

        real_last_used_at = token.read_attribute(:last_used_at)

        # Handle too many updates from high token traffic
        real_last_used_at.nil? ||
          (Time.current - real_last_used_at) >= last_used_at_max_age
      end

      def log_activity_event!(recorded_at)
        Clusters::Agents::CreateActivityEventService.new(
          agent,
          kind: :agent_connected,
          level: :info,
          recorded_at: recorded_at,
          agent_token: token
        ).execute
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Clusters::AgentTokens::TrackUsageService, feature_category: :deployment_management do
  let_it_be(:agent) { create(:cluster_agent) }

  describe '#execute', :clean_gitlab_redis_cache do
    let(:agent_token) { create(:cluster_agent_token, agent: agent) }

    subject { described_class.new(agent_token).execute }

    context 'when last_used_at was updated recently' do
      before do
        agent_token.update!(last_used_at: 10.minutes.ago)
      end

      it 'updates cache but not database' do
        expect { subject }.not_to change { agent_token.reload.read_attribute(:last_used_at) }

        expect_redis_update
      end
    end

    context 'when last_used_at was not updated recently' do
      it 'updates cache and database' do
        does_db_update
        expect_redis_update
      end

      context 'with invalid token' do
        before do
          agent_token.description = SecureRandom.hex(2000)
        end

        it 'still updates caches and database' do
          expect(agent_token).to be_invalid

          does_db_update
          expect_redis_update
        end
      end

      context 'agent is not connected' do
        before do
          allow(agent).to receive(:connected?).and_return(false)
        end

        it 'creates an activity event' do
          expect { subject }.to change { agent.activity_events.count }

          event = agent.activity_events.last
          expect(event).to have_attributes(
            kind: 'agent_connected',
            level: 'info',
            recorded_at: agent_token.reload.read_attribute(:last_used_at),
            agent_token: agent_token
          )
        end
      end

      context 'agent is connected' do
        before do
          allow(agent).to receive(:connected?).and_return(true)
        end

        it 'does not create an activity event' do
          expect { subject }.not_to change { agent.activity_events.count }
        end
      end
    end

    def expect_redis_update
      Gitlab::Redis::Cache.with do |redis|
        redis_key = ""cache:#{agent_token.class}:#{agent_token.id}:attributes""
        expect(redis.get(redis_key)).to be_present
      end
    end

    def does_db_update
      expect { subject }.to change { agent_token.reload.read_attribute(:last_used_at) }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Clusters
  module AgentTokens
    class RevokeService
      attr_reader :current_project, :current_user, :token

      def initialize(token:, current_user:)
        @token = token
        @current_user = current_user
      end

      def execute
        return error_no_permissions unless current_user.can?(:create_cluster, token.agent.project)

        if token.revoke!
          log_activity_event(token)

          ServiceResponse.success
        else
          ServiceResponse.error(message: token.errors.full_messages)
        end
      end

      private

      def error_no_permissions
        ServiceResponse.error(
          message: s_('ClusterAgent|User has insufficient permissions to revoke the token for this project'))
      end

      def log_activity_event(token)
        Clusters::Agents::CreateActivityEventService.new(
          token.agent,
          kind: :token_revoked,
          level: :info,
          recorded_at: token.updated_at,
          user: current_user,
          agent_token: token
        ).execute
      end
    end
  end
end

Clusters::AgentTokens::RevokeService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Clusters::AgentTokens::RevokeService, feature_category: :deployment_management do
  describe '#execute' do
    subject { described_class.new(token: agent_token, current_user: user).execute }

    let(:agent) { create(:cluster_agent) }
    let(:agent_token) { create(:cluster_agent_token, agent: agent) }
    let(:project) { agent.project }
    let(:user) { agent.created_by_user }

    before do
      project.add_maintainer(user)
    end

    context 'when user is authorized' do
      before do
        project.add_maintainer(user)
      end

      context 'when user revokes agent token' do
        it 'succeeds' do
          subject

          expect(agent_token.revoked?).to be true
        end

        it 'creates an activity event' do
          expect { subject }.to change { ::Clusters::Agents::ActivityEvent.count }.by(1)

          event = agent.activity_events.last

          expect(event).to have_attributes(
            kind: 'token_revoked',
            level: 'info',
            recorded_at: agent_token.reload.updated_at,
            user: user,
            agent_token: agent_token
          )
        end
      end

      context 'when there is a validation failure' do
        before do
          agent_token.name = '' # make the record invalid, as we require a name to be present
        end

        it 'fails without raising an error', :aggregate_failures do
          expect(subject[:status]).to eq(:error)
          expect(subject[:message]).to eq([""Name can't be blank""])
        end

        it 'does not create an activity event' do
          expect { subject }.not_to change { ::Clusters::Agents::ActivityEvent.count }
        end
      end
    end

    context 'when user is not authorized' do
      let(:user) { create(:user) }

      before do
        project.add_guest(user)
      end

      context 'when user attempts to revoke agent token' do
        it 'fails' do
          subject

          expect(agent_token.revoked?).to be false
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Clusters
  module AgentTokens
    class CreateService
      ALLOWED_PARAMS = %i[agent_id description name].freeze
      ACTIVE_TOKENS_LIMIT = 2

      attr_reader :agent, :current_user, :params

      def initialize(agent:, current_user:, params:)
        @agent = agent
        @current_user = current_user
        @params = params
      end

      def execute
        return error_no_permissions unless current_user.can?(:create_cluster, agent.project)
        return error_active_tokens_limit_reached if active_tokens_limit_reached?

        token = ::Clusters::AgentToken.new(filtered_params.merge(agent_id: agent.id, created_by_user: current_user))

        if token.save
          log_activity_event(token)

          ServiceResponse.success(payload: { secret: token.token, token: token })
        else
          ServiceResponse.error(message: token.errors.full_messages)
        end
      end

      private

      def error_no_permissions
        ServiceResponse.error(message: s_('ClusterAgent|User has insufficient permissions to create a token for this project'))
      end

      def error_active_tokens_limit_reached
        ServiceResponse.error(message: s_('ClusterAgent|An agent can have only two active tokens at a time'))
      end

      def active_tokens_limit_reached?
        ::Clusters::AgentTokensFinder.new(agent, current_user, status: :active).execute.count >= ACTIVE_TOKENS_LIMIT
      end

      def filtered_params
        params.slice(*ALLOWED_PARAMS)
      end

      def log_activity_event(token)
        Clusters::Agents::CreateActivityEventService.new(
          token.agent,
          kind: :token_created,
          level: :info,
          recorded_at: token.created_at,
          user: current_user,
          agent_token: token
        ).execute
      end
    end
  end
end

Clusters::AgentTokens::CreateService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Clusters::AgentTokens::CreateService, feature_category: :deployment_management do
  subject(:service) { described_class.new(agent: cluster_agent, current_user: user, params: params) }

  let_it_be(:user) { create(:user) }

  let(:cluster_agent) { create(:cluster_agent) }
  let(:project) { cluster_agent.project }
  let(:params) { { description: 'token description', name: 'token name' } }

  describe '#execute' do
    subject { service.execute }

    it 'does not create a new token due to user permissions' do
      expect { subject }.not_to change(::Clusters::AgentToken, :count)
    end

    it 'returns permission errors', :aggregate_failures do
      expect(subject.status).to eq(:error)
      expect(subject.message).to eq('User has insufficient permissions to create a token for this project')
    end

    context 'with user permissions' do
      before do
        project.add_maintainer(user)
      end

      it 'creates a new token' do
        expect { subject }.to change { ::Clusters::AgentToken.count }.by(1)
      end

      it 'returns success status', :aggregate_failures do
        expect(subject.status).to eq(:success)
        expect(subject.message).to be_nil
      end

      it 'returns token information', :aggregate_failures do
        token = subject.payload[:token]

        expect(subject.payload[:secret]).not_to be_nil

        expect(token.created_by_user).to eq(user)
        expect(token.description).to eq(params[:description])
        expect(token.name).to eq(params[:name])
      end

      it 'creates an activity event' do
        expect { subject }.to change { ::Clusters::Agents::ActivityEvent.count }.by(1)

        token = subject.payload[:token].reload
        event = cluster_agent.activity_events.last

        expect(event).to have_attributes(
          kind: 'token_created',
          level: 'info',
          recorded_at: token.created_at,
          user: token.created_by_user,
          agent_token: token
        )
      end

      context 'when params are invalid' do
        let(:params) { { agent_id: 'bad_id' } }

        it 'does not create a new token' do
          expect { subject }.not_to change(::Clusters::AgentToken, :count)
        end

        it 'does not create an activity event' do
          expect { subject }.not_to change { ::Clusters::Agents::ActivityEvent.count }
        end

        it 'returns validation errors', :aggregate_failures do
          expect(subject.status).to eq(:error)
          expect(subject.message).to eq([""Name can't be blank""])
        end
      end

      context 'when the active agent tokens limit is reached' do
        before do
          create(:cluster_agent_token, agent: cluster_agent)
          create(:cluster_agent_token, agent: cluster_agent)
        end

        it 'returns an error' do
          expect(subject.status).to eq(:error)
          expect(subject.message).to eq('An agent can have only two active tokens at a time')
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Clusters
  module Kubernetes
    class FetchKubernetesTokenService
      DEFAULT_TOKEN_RETRY_DELAY = 5.seconds
      TOKEN_RETRY_LIMIT = 5

      attr_reader :kubeclient, :service_account_token_name, :namespace

      def initialize(kubeclient, service_account_token_name, namespace, token_retry_delay: DEFAULT_TOKEN_RETRY_DELAY)
        @kubeclient = kubeclient
        @service_account_token_name = service_account_token_name
        @namespace = namespace
        @token_retry_delay = token_retry_delay
      end

      def execute
        # Kubernetes will create the Secret and set the token asynchronously
        # so it is necessary to retry
        # https://kubernetes.io/docs/reference/access-authn-authz/service-accounts-admin/#token-controller
        TOKEN_RETRY_LIMIT.times do
          token_base64 = get_secret&.dig('data', 'token')
          return Base64.decode64(token_base64) if token_base64

          sleep @token_retry_delay
        end

        nil
      end

      private

      def get_secret
        kubeclient.get_secret(service_account_token_name, namespace).as_json
      rescue Kubeclient::ResourceNotFoundError
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Clusters::Kubernetes::FetchKubernetesTokenService, feature_category: :deployment_management do
  include KubernetesHelpers

  describe '#execute' do
    let(:api_url) { 'http://111.111.111.111' }
    let(:namespace) { 'my-namespace' }
    let(:service_account_token_name) { 'gitlab-token' }

    let(:kubeclient) do
      Gitlab::Kubernetes::KubeClient.new(
        api_url,
        auth_options: { username: 'admin', password: 'xxx' }
      )
    end

    subject { described_class.new(kubeclient, service_account_token_name, namespace, token_retry_delay: 0).execute }

    before do
      stub_kubeclient_discover(api_url)
    end

    context 'when params correct' do
      let(:decoded_token) { 'xxx.token.xxx' }
      let(:token) { Base64.encode64(decoded_token) }

      context 'when the secret exists' do
        before do
          stub_kubeclient_get_secret(
            api_url,
            metadata_name: service_account_token_name,
            namespace: namespace,
            token: token
          )
        end

        it { is_expected.to eq(decoded_token) }
      end

      context 'when there is a 500 error' do
        before do
          stub_kubeclient_get_secret_error(api_url, service_account_token_name, namespace: namespace, status: 500)
        end

        it { expect { subject }.to raise_error(Kubeclient::HttpError) }
      end

      context 'when the secret does not exist on the first try' do
        before do
          stub_kubeclient_get_secret_not_found_then_found(
            api_url,
            metadata_name: service_account_token_name,
            namespace: namespace,
            token: token
          )
        end

        it 'retries and finds the token' do
          expect(subject).to eq(decoded_token)
        end
      end

      context 'when the secret permanently does not exist' do
        before do
          stub_kubeclient_get_secret_error(api_url, service_account_token_name, namespace: namespace, status: 404)
        end

        it { is_expected.to be_nil }
      end

      context 'when the secret is missing a token on the first try' do
        before do
          stub_kubeclient_get_secret_missing_token_then_with_token(
            api_url,
            metadata_name: service_account_token_name,
            namespace: namespace,
            token: token
          )
        end

        it 'retries and finds the token' do
          expect(subject).to eq(decoded_token)
        end
      end

      context 'when the secret is permanently missing a token' do
        before do
          stub_kubeclient_get_secret(
            api_url,
            metadata_name: service_account_token_name,
            namespace: namespace,
            token: nil
          )
        end

        it { is_expected.to be_nil }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Clusters
  module Kubernetes
    class CreateOrUpdateServiceAccountService
      def initialize(kubeclient, service_account_name:, service_account_namespace:, token_name:, rbac:, service_account_namespace_labels: nil, namespace_creator: false, role_binding_name: nil)
        @kubeclient = kubeclient
        @service_account_name = service_account_name
        @service_account_namespace = service_account_namespace
        @service_account_namespace_labels = service_account_namespace_labels
        @token_name = token_name
        @rbac = rbac
        @namespace_creator = namespace_creator
        @role_binding_name = role_binding_name
      end

      def self.gitlab_creator(kubeclient, rbac:)
        self.new(
          kubeclient,
          service_account_name: Clusters::Kubernetes::GITLAB_SERVICE_ACCOUNT_NAME,
          service_account_namespace: Clusters::Kubernetes::GITLAB_SERVICE_ACCOUNT_NAMESPACE,
          token_name: Clusters::Kubernetes::GITLAB_ADMIN_TOKEN_NAME,
          rbac: rbac
        )
      end

      def self.namespace_creator(kubeclient, service_account_name:, service_account_namespace:, service_account_namespace_labels:, rbac:)
        self.new(
          kubeclient,
          service_account_name: service_account_name,
          service_account_namespace: service_account_namespace,
          service_account_namespace_labels: service_account_namespace_labels,
          token_name: ""#{service_account_namespace}-token"",
          rbac: rbac,
          namespace_creator: true,
          role_binding_name: ""gitlab-#{service_account_namespace}""
        )
      end

      def execute
        ensure_project_namespace_exists if namespace_creator

        kubeclient.create_or_update_service_account(service_account_resource)
        kubeclient.create_or_update_secret(service_account_token_resource)

        return unless rbac

        create_role_or_cluster_role_binding

        return unless namespace_creator

        create_or_update_knative_serving_role
        create_or_update_knative_serving_role_binding
        create_or_update_crossplane_database_role
        create_or_update_crossplane_database_role_binding
      end

      private

      attr_reader :kubeclient, :service_account_name, :service_account_namespace, :service_account_namespace_labels, :token_name, :rbac, :namespace_creator, :role_binding_name

      def ensure_project_namespace_exists
        Gitlab::Kubernetes::Namespace.new(
          service_account_namespace,
          kubeclient,
          labels: service_account_namespace_labels
        ).ensure_exists!
      end

      def create_role_or_cluster_role_binding
        if namespace_creator
          begin
            kubeclient.delete_role_binding(role_binding_name, service_account_namespace)
          rescue Kubeclient::ResourceNotFoundError
            # Do nothing as we will create new role binding below
          end

          kubeclient.update_role_binding(role_binding_resource)
        else
          kubeclient.create_or_update_cluster_role_binding(cluster_role_binding_resource)
        end
      end

      def create_or_update_knative_serving_role
        kubeclient.update_role(knative_serving_role_resource)
      end

      def create_or_update_knative_serving_role_binding
        kubeclient.update_role_binding(knative_serving_role_binding_resource)
      end

      def create_or_update_crossplane_database_role
        kubeclient.update_role(crossplane_database_role_resource)
      end

      def create_or_update_crossplane_database_role_binding
        kubeclient.update_role_binding(crossplane_database_role_binding_resource)
      end

      def service_account_resource
        Gitlab::Kubernetes::ServiceAccount.new(
          service_account_name,
          service_account_namespace
        ).generate
      end

      def service_account_token_resource
        Gitlab::Kubernetes::ServiceAccountToken.new(
          token_name,
          service_account_name,
          service_account_namespace
        ).generate
      end

      def cluster_role_binding_resource
        subjects = [{ kind: 'ServiceAccount', name: service_account_name, namespace: service_account_namespace }]

        Gitlab::Kubernetes::ClusterRoleBinding.new(
          Clusters::Kubernetes::GITLAB_CLUSTER_ROLE_BINDING_NAME,
          Clusters::Kubernetes::GITLAB_CLUSTER_ROLE_NAME,
          subjects
        ).generate
      end

      def role_binding_resource
        Gitlab::Kubernetes::RoleBinding.new(
          name: role_binding_name,
          role_name: Clusters::Kubernetes::PROJECT_CLUSTER_ROLE_NAME,
          role_kind: :ClusterRole,
          namespace: service_account_namespace,
          service_account_name: service_account_name
        ).generate
      end

      def knative_serving_role_resource
        Gitlab::Kubernetes::Role.new(
          name: Clusters::Kubernetes::GITLAB_KNATIVE_SERVING_ROLE_NAME,
          namespace: service_account_namespace,
          rules: [{
            apiGroups: %w[serving.knative.dev],
            resources: %w[configurations configurationgenerations routes revisions revisionuids autoscalers services],
            verbs: %w[get list create update delete patch watch]
          }]
        ).generate
      end

      def knative_serving_role_binding_resource
        Gitlab::Kubernetes::RoleBinding.new(
          name: Clusters::Kubernetes::GITLAB_KNATIVE_SERVING_ROLE_BINDING_NAME,
          role_name: Clusters::Kubernetes::GITLAB_KNATIVE_SERVING_ROLE_NAME,
          role_kind: :Role,
          namespace: service_account_namespace,
          service_account_name: service_account_name
        ).generate
      end

      def crossplane_database_role_resource
        Gitlab::Kubernetes::Role.new(
          name: Clusters::Kubernetes::GITLAB_CROSSPLANE_DATABASE_ROLE_NAME,
          namespace: service_account_namespace,
          rules: [{
            apiGroups: %w[database.crossplane.io],
            resources: %w[postgresqlinstances],
            verbs: %w[get list create watch]
          }]
        ).generate
      end

      def crossplane_database_role_binding_resource
        Gitlab::Kubernetes::RoleBinding.new(
          name: Clusters::Kubernetes::GITLAB_CROSSPLANE_DATABASE_ROLE_BINDING_NAME,
          role_name: Clusters::Kubernetes::GITLAB_CROSSPLANE_DATABASE_ROLE_NAME,
          role_kind: :Role,
          namespace: service_account_namespace,
          service_account_name: service_account_name
        ).generate
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Clusters::Kubernetes::CreateOrUpdateServiceAccountService, feature_category: :deployment_management do
  include KubernetesHelpers

  let(:api_url) { 'http://111.111.111.111' }
  let(:platform_kubernetes) { cluster.platform_kubernetes }
  let(:cluster_project) { cluster.cluster_project }
  let(:project) { cluster_project.project }
  let(:cluster) do
    create(
      :cluster,
      :project,
      :provided_by_gcp,
      platform_kubernetes: create(:cluster_platform_kubernetes, :configured)
    )
  end

  let(:kubeclient) do
    Gitlab::Kubernetes::KubeClient.new(
      api_url,
      auth_options: { username: 'admin', password: 'xxx' }
    )
  end

  shared_examples 'creates service account and token' do
    it 'creates a kubernetes service account' do
      subject

      expect(WebMock).to have_requested(:post, api_url + ""/api/v1/namespaces/#{namespace}/serviceaccounts"").with(
        body: hash_including(
          kind: 'ServiceAccount',
          metadata: { name: service_account_name, namespace: namespace }
        )
      )
    end

    it 'creates a kubernetes secret' do
      subject

      expect(WebMock).to have_requested(:post, api_url + ""/api/v1/namespaces/#{namespace}/secrets"").with(
        body: hash_including(
          kind: 'Secret',
          metadata: {
            name: token_name,
            namespace: namespace,
            annotations: {
              'kubernetes.io/service-account.name': service_account_name
            }
          },
          type: 'kubernetes.io/service-account-token'
        )
      )
    end
  end

  before do
    stub_kubeclient_discover(api_url)
    stub_kubeclient_get_namespace(api_url, namespace: namespace)

    stub_kubeclient_get_service_account_error(api_url, service_account_name, namespace: namespace)
    stub_kubeclient_create_service_account(api_url, namespace: namespace)

    stub_kubeclient_get_secret_error(api_url, token_name, namespace: namespace)
    stub_kubeclient_create_secret(api_url, namespace: namespace)
  end

  describe '.gitlab_creator' do
    let(:namespace) { 'default' }
    let(:service_account_name) { 'gitlab' }
    let(:token_name) { 'gitlab-token' }

    subject { described_class.gitlab_creator(kubeclient, rbac: rbac).execute }

    context 'with ABAC cluster' do
      let(:rbac) { false }

      it_behaves_like 'creates service account and token'
    end

    context 'with RBAC cluster' do
      let(:rbac) { true }
      let(:cluster_role_binding_name) { 'gitlab-admin' }

      before do
        cluster.platform_kubernetes.rbac!

        stub_kubeclient_put_cluster_role_binding(api_url, cluster_role_binding_name)
      end

      it_behaves_like 'creates service account and token'

      it 'creates a cluster role binding with cluster-admin access' do
        subject

        expect(WebMock).to have_requested(:put, api_url + ""/apis/rbac.authorization.k8s.io/v1/clusterrolebindings/gitlab-admin"").with(
          body: hash_including(
            metadata: { name: 'gitlab-admin' },
            roleRef: {
              apiGroup: 'rbac.authorization.k8s.io',
              kind: 'ClusterRole',
              name: 'cluster-admin'
            },
            subjects: [
              {
                kind: 'ServiceAccount',
                name: service_account_name,
                namespace: namespace
              }
            ]
          )
        )
      end
    end
  end

  describe '.namespace_creator' do
    let(:namespace) { ""#{project.path}-#{project.id}"" }
    let(:namespace_labels) { { app: project.full_path_slug, env: ""staging"" } }
    let(:service_account_name) { ""#{namespace}-service-account"" }
    let(:token_name) { ""#{namespace}-token"" }

    subject do
      described_class.namespace_creator(
        kubeclient,
        service_account_name: service_account_name,
        service_account_namespace: namespace,
        service_account_namespace_labels: namespace_labels,
        rbac: rbac
      ).execute
    end

    context 'with ABAC cluster' do
      let(:rbac) { false }

      it_behaves_like 'creates service account and token'
    end

    context 'With RBAC enabled cluster' do
      let(:rbac) { true }
      let(:role_binding_name) { ""gitlab-#{namespace}"" }

      before do
        cluster.platform_kubernetes.rbac!

        stub_kubeclient_delete_role_binding(api_url, role_binding_name, namespace: namespace)
        stub_kubeclient_put_role_binding(api_url, role_binding_name, namespace: namespace)
        stub_kubeclient_put_role(api_url, Clusters::Kubernetes::GITLAB_KNATIVE_SERVING_ROLE_NAME, namespace: namespace)
        stub_kubeclient_put_role_binding(api_url, Clusters::Kubernetes::GITLAB_KNATIVE_SERVING_ROLE_BINDING_NAME, namespace: namespace)
        stub_kubeclient_put_role(api_url, Clusters::Kubernetes::GITLAB_CROSSPLANE_DATABASE_ROLE_NAME, namespace: namespace)
        stub_kubeclient_put_role_binding(api_url, Clusters::Kubernetes::GITLAB_CROSSPLANE_DATABASE_ROLE_BINDING_NAME, namespace: namespace)
      end

      it 'creates a namespace object' do
        kubernetes_namespace = double(Gitlab::Kubernetes::Namespace)
        expect(Gitlab::Kubernetes::Namespace).to(
          receive(:new).with(namespace, kubeclient, labels: namespace_labels).and_return(kubernetes_namespace)
        )
        expect(kubernetes_namespace).to receive(:ensure_exists!)

        subject
      end

      it_behaves_like 'creates service account and token'

      it 'creates a namespaced role binding with admin access' do
        subject

        expect(WebMock).to have_requested(:put, api_url + ""/apis/rbac.authorization.k8s.io/v1/namespaces/#{namespace}/rolebindings/#{role_binding_name}"").with(
          body: hash_including(
            metadata: { name: ""gitlab-#{namespace}"", namespace: namespace.to_s },
            roleRef: {
              apiGroup: 'rbac.authorization.k8s.io',
              kind: 'ClusterRole',
              name: 'admin'
            },
            subjects: [
              {
                kind: 'ServiceAccount',
                name: service_account_name,
                namespace: namespace
              }
            ]
          )
        )
      end

      it 'creates a role binding granting crossplane database permissions to the service account' do
        subject

        expect(WebMock).to have_requested(:put, api_url + ""/apis/rbac.authorization.k8s.io/v1/namespaces/#{namespace}/rolebindings/#{Clusters::Kubernetes::GITLAB_CROSSPLANE_DATABASE_ROLE_BINDING_NAME}"").with(
          body: hash_including(
            metadata: {
              name: Clusters::Kubernetes::GITLAB_CROSSPLANE_DATABASE_ROLE_BINDING_NAME,
              namespace: namespace
            },
            roleRef: {
              apiGroup: 'rbac.authorization.k8s.io',
              kind: 'Role',
              name: Clusters::Kubernetes::GITLAB_CROSSPLANE_DATABASE_ROLE_NAME
            },
            subjects: [
              {
                kind: 'ServiceAccount',
                name: service_account_name,
                namespace: namespace
              }
            ]
          )
        )
      end

      it 'creates a role and role binding granting knative serving permissions to the service account' do
        subject

        expect(WebMock).to have_requested(:put, api_url + ""/apis/rbac.authorization.k8s.io/v1/namespaces/#{namespace}/roles/#{Clusters::Kubernetes::GITLAB_KNATIVE_SERVING_ROLE_NAME}"").with(
          body: hash_including(
            metadata: {
              name: Clusters::Kubernetes::GITLAB_KNATIVE_SERVING_ROLE_NAME,
              namespace: namespace
            },
            rules: [{
              apiGroups: %w[serving.knative.dev],
              resources: %w[configurations configurationgenerations routes revisions revisionuids autoscalers services],
              verbs: %w[get list create update delete patch watch]
            }]
          )
        )
      end

      it 'creates a role and role binding granting crossplane database permissions to the service account' do
        subject

        expect(WebMock).to have_requested(:put, api_url + ""/apis/rbac.authorization.k8s.io/v1/namespaces/#{namespace}/roles/#{Clusters::Kubernetes::GITLAB_CROSSPLANE_DATABASE_ROLE_NAME}"").with(
          body: hash_including(
            metadata: {
              name: Clusters::Kubernetes::GITLAB_CROSSPLANE_DATABASE_ROLE_NAME,
              namespace: namespace
            },
            rules: [{
              apiGroups: %w[database.crossplane.io],
              resources: %w[postgresqlinstances],
              verbs: %w[get list create watch]
            }]
          )
        )
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Clusters
  module Kubernetes
    class CreateOrUpdateNamespaceService
      def initialize(cluster:, kubernetes_namespace:)
        @cluster = cluster
        @kubernetes_namespace = kubernetes_namespace
        @platform = cluster.platform
      end

      def execute
        create_project_service_account
        configure_kubernetes_token

        kubernetes_namespace.save!
      end

      private

      attr_reader :cluster, :kubernetes_namespace, :platform

      def create_project_service_account
        environment_slug = kubernetes_namespace.environment&.slug
        namespace_labels = { 'app.gitlab.com/app' => kubernetes_namespace.project.full_path_slug }
        namespace_labels['app.gitlab.com/env'] = environment_slug if environment_slug

        Clusters::Kubernetes::CreateOrUpdateServiceAccountService.namespace_creator(
          platform.kubeclient,
          service_account_name: kubernetes_namespace.service_account_name,
          service_account_namespace: kubernetes_namespace.namespace,
          service_account_namespace_labels: namespace_labels,
          rbac: platform.rbac?
        ).execute
      end

      def configure_kubernetes_token
        kubernetes_namespace.service_account_token = fetch_service_account_token
      end

      def fetch_service_account_token
        Clusters::Kubernetes::FetchKubernetesTokenService.new(
          platform.kubeclient,
          kubernetes_namespace.token_name,
          kubernetes_namespace.namespace
        ).execute
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Clusters::Kubernetes::CreateOrUpdateNamespaceService, '#execute', feature_category: :deployment_management do
  include KubernetesHelpers

  let(:cluster) { create(:cluster, :project, :provided_by_gcp) }
  let(:platform) { cluster.platform }
  let(:api_url) { 'https://kubernetes.example.com' }
  let(:project) { cluster.project }
  let(:environment) { create(:environment, project: project) }
  let(:cluster_project) { cluster.cluster_project }
  let(:namespace) { ""#{project.path}-#{project.id}-#{environment.slug}"" }

  subject do
    described_class.new(
      cluster: cluster,
      kubernetes_namespace: kubernetes_namespace
    ).execute
  end

  before do
    stub_kubeclient_discover(api_url)
    stub_kubeclient_get_namespace(api_url)
    stub_kubeclient_get_service_account_error(api_url, 'gitlab')
    stub_kubeclient_create_service_account(api_url)
    stub_kubeclient_get_secret_error(api_url, 'gitlab-token')
    stub_kubeclient_create_secret(api_url)

    stub_kubeclient_delete_role_binding(api_url, ""gitlab-#{namespace}"", namespace: namespace)
    stub_kubeclient_put_role_binding(api_url, ""gitlab-#{namespace}"", namespace: namespace)
    stub_kubeclient_get_namespace(api_url, namespace: namespace)
    stub_kubeclient_get_service_account_error(api_url, ""#{namespace}-service-account"", namespace: namespace)
    stub_kubeclient_create_service_account(api_url, namespace: namespace)
    stub_kubeclient_create_secret(api_url, namespace: namespace)
    stub_kubeclient_put_secret(api_url, ""#{namespace}-token"", namespace: namespace)
    stub_kubeclient_put_role(api_url, Clusters::Kubernetes::GITLAB_KNATIVE_SERVING_ROLE_NAME, namespace: namespace)
    stub_kubeclient_put_role_binding(api_url, Clusters::Kubernetes::GITLAB_KNATIVE_SERVING_ROLE_BINDING_NAME, namespace: namespace)
    stub_kubeclient_put_role(api_url, Clusters::Kubernetes::GITLAB_CROSSPLANE_DATABASE_ROLE_NAME, namespace: namespace)
    stub_kubeclient_put_role_binding(api_url, Clusters::Kubernetes::GITLAB_CROSSPLANE_DATABASE_ROLE_BINDING_NAME, namespace: namespace)

    stub_kubeclient_get_secret(
      api_url,
      metadata_name: ""#{namespace}-token"",
      token: Base64.encode64('sample-token'),
      namespace: namespace
    )
  end

  shared_examples 'successful creation of kubernetes namespace' do
    it 'creates a Clusters::KubernetesNamespace' do
      expect do
        subject
      end.to change(Clusters::KubernetesNamespace, :count).by(1)
    end

    it 'creates project service account and namespace' do
      account_service = double(Clusters::Kubernetes::CreateOrUpdateServiceAccountService)
      expect(Clusters::Kubernetes::CreateOrUpdateServiceAccountService).to(
        receive(:namespace_creator).with(
          cluster.platform.kubeclient,
          service_account_name: ""#{namespace}-service-account"",
          service_account_namespace: namespace,
          service_account_namespace_labels: {
            'app.gitlab.com/app' => project.full_path_slug,
            'app.gitlab.com/env' => environment.slug
          },
          rbac: true
        ).and_return(account_service)
      )
      expect(account_service).to receive(:execute).once
      subject
    end

    it 'configures kubernetes token' do
      subject

      kubernetes_namespace.reload
      expect(kubernetes_namespace.namespace).to eq(namespace)
      expect(kubernetes_namespace.service_account_name).to eq(""#{namespace}-service-account"")
      expect(kubernetes_namespace.encrypted_service_account_token).to be_present
    end

    context 'without environment' do
      before do
        kubernetes_namespace.environment = nil
      end

      it 'creates project service account and namespace' do
        account_service = double(Clusters::Kubernetes::CreateOrUpdateServiceAccountService)
        expect(Clusters::Kubernetes::CreateOrUpdateServiceAccountService).to(
          receive(:namespace_creator).with(
            cluster.platform.kubeclient,
            service_account_name: ""#{namespace}-service-account"",
            service_account_namespace: namespace,
            service_account_namespace_labels: {
              'app.gitlab.com/app' => project.full_path_slug
            },
            rbac: true
          ).and_return(account_service)
        )
        expect(account_service).to receive(:execute).once
        subject
      end
    end
  end

  context 'group clusters' do
    let(:cluster) { create(:cluster, :group, :provided_by_gcp) }
    let(:group) { cluster.group }
    let(:project) { create(:project, group: group) }

    context 'when kubernetes namespace is not persisted' do
      let(:kubernetes_namespace) do
        build(
          :cluster_kubernetes_namespace,
          cluster: cluster,
          project: project,
          environment: environment
        )
      end

      it_behaves_like 'successful creation of kubernetes namespace'
    end
  end

  context 'project clusters' do
    context 'when kubernetes namespace is not persisted' do
      let(:kubernetes_namespace) do
        build(
          :cluster_kubernetes_namespace,
          cluster: cluster,
          project: cluster_project.project,
          cluster_project: cluster_project,
          environment: environment
        )
      end

      it_behaves_like 'successful creation of kubernetes namespace'
    end

    context 'when there is a Kubernetes Namespace associated' do
      let(:namespace) { ""new-namespace-#{environment.slug}"" }

      let(:kubernetes_namespace) do
        create(
          :cluster_kubernetes_namespace,
          cluster: cluster,
          project: cluster_project.project,
          cluster_project: cluster_project,
          environment: environment
        )
      end

      before do
        platform.update_column(:namespace, 'new-namespace')
      end

      it 'does not create any Clusters::KubernetesNamespace' do
        subject

        expect(cluster.kubernetes_namespaces).to eq([kubernetes_namespace])
      end

      it 'creates project service account' do
        expect_next_instance_of(Clusters::Kubernetes::CreateOrUpdateServiceAccountService) do |instance|
          expect(instance).to receive(:execute).once
        end

        subject
      end

      it 'updates Clusters::KubernetesNamespace' do
        subject

        kubernetes_namespace.reload

        expect(kubernetes_namespace.namespace).to eq(namespace)
        expect(kubernetes_namespace.service_account_name).to eq(""#{namespace}-service-account"")
        expect(kubernetes_namespace.encrypted_service_account_token).to be_present
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module CustomerRelations
  module Organizations
    class UpdateService < BaseService
      def execute(organization)
        return error_no_permissions unless allowed?

        handle_active_param
        return error_updating(organization) unless organization.update(params)

        ServiceResponse.success(payload: organization)
      end

      private

      def handle_active_param
        return if params[:active].nil?

        active = params.delete(:active)
        params[:state] = active ? 'active' : 'inactive'
      end

      def error_no_permissions
        error('You have insufficient permissions to update an organization for this group')
      end

      def error_updating(organization)
        error(organization&.errors&.full_messages || 'Failed to update organization')
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe CustomerRelations::Organizations::UpdateService, feature_category: :service_desk do
  let_it_be(:user) { create(:user) }

  let(:crm_organization) { create(:crm_organization, name: 'Test', group: group, state: 'active') }

  subject(:update) { described_class.new(group: group, current_user: user, params: params).execute(crm_organization) }

  describe '#execute' do
    context 'when the user has no permission' do
      let_it_be(:group) { create(:group, :crm_enabled) }

      let(:params) { { name: 'GitLab' } }

      it 'returns an error' do
        response = update

        expect(response).to be_error
        expect(response.message).to eq(['You have insufficient permissions to update an organization for this group'])
      end
    end

    context 'when user has permission' do
      let_it_be(:group) { create(:group, :crm_enabled) }

      before_all do
        group.add_developer(user)
      end

      context 'when name is changed' do
        let(:params) { { name: 'GitLab' } }

        it 'updates the crm_organization' do
          response = update

          expect(response).to be_success
          expect(response.payload.name).to eq('GitLab')
        end
      end

      context 'when activating' do
        let(:crm_organization) { create(:crm_organization, state: 'inactive') }
        let(:params) { { active: true } }

        it 'updates the contact' do
          response = update

          expect(response).to be_success
          expect(response.payload.active?).to be_truthy
        end
      end

      context 'when deactivating' do
        let(:params) { { active: false } }

        it 'updates the crm_organization' do
          response = update

          expect(response).to be_success
          expect(response.payload.active?).to be_falsy
        end
      end

      context 'when the crm_organization is invalid' do
        let(:params) { { name: nil } }

        it 'returns an error' do
          response = update

          expect(response).to be_error
          expect(response.message).to eq([""Name can't be blank""])
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module CustomerRelations
  module Organizations
    class CreateService < BaseService
      # returns the created organization
      def execute
        return error_no_permissions unless allowed?

        organization = Organization.create(params.merge(group_id: group.id))

        return error_creating(organization) unless organization.persisted?

        ServiceResponse.success(payload: organization)
      end

      private

      def error_no_permissions
        error('You have insufficient permissions to create an organization for this group')
      end

      def error_creating(organization)
        error(organization&.errors&.full_messages || 'Failed to create organization')
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe CustomerRelations::Organizations::CreateService, feature_category: :service_desk do
  describe '#execute' do
    let_it_be(:user) { create(:user) }

    let(:group) { create(:group, :crm_enabled) }
    let(:params) { attributes_for(:crm_organization, group: group) }

    subject(:response) { described_class.new(group: group, current_user: user, params: params).execute }

    it 'creates a crm_organization' do
      group.add_developer(user)

      expect(response).to be_success
    end

    it 'returns an error when user does not have permission' do
      group.add_reporter(user)

      expect(response).to be_error
      expect(response.message).to match_array(['You have insufficient permissions to create an organization for this group'])
    end

    it 'returns an error when the crm_organization is not persisted' do
      group.add_developer(user)
      params[:name] = nil

      expect(response).to be_error
      expect(response.message).to match_array([""Name can't be blank""])
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module CustomerRelations
  module Contacts
    class UpdateService < BaseService
      def execute(contact)
        return error_no_permissions unless allowed?

        handle_active_param
        return error_organization_invalid unless organization_valid?
        return error_updating(contact) unless contact.update(params)

        ServiceResponse.success(payload: contact)
      end

      private

      def handle_active_param
        return if params[:active].nil?

        active = params.delete(:active)
        params[:state] = active ? 'active' : 'inactive'
      end

      def error_updating(contact)
        error(contact&.errors&.full_messages || 'Failed to update contact')
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe CustomerRelations::Contacts::UpdateService, feature_category: :service_desk do
  let_it_be(:user) { create(:user) }

  let(:contact) { create(:contact, first_name: 'Mark', group: group, state: 'active') }

  subject(:update) { described_class.new(group: group, current_user: user, params: params).execute(contact) }

  describe '#execute' do
    context 'when the user has no permission' do
      let_it_be(:group) { create(:group, :crm_enabled) }

      let(:params) { { first_name: 'Gary' } }

      it 'returns an error' do
        response = update

        expect(response).to be_error
        expect(response.message).to match_array(['You have insufficient permissions to manage contacts for this group'])
      end
    end

    context 'when user has permission' do
      let_it_be(:group) { create(:group, :crm_enabled) }

      before_all do
        group.add_developer(user)
      end

      context 'when first_name is changed' do
        let(:params) { { first_name: 'Gary' } }

        it 'updates the contact' do
          response = update

          expect(response).to be_success
          expect(response.payload.first_name).to eq('Gary')
        end
      end

      context 'when activating' do
        let(:contact) { create(:contact, state: 'inactive') }
        let(:params) { { active: true } }

        it 'updates the contact' do
          response = update

          expect(response).to be_success
          expect(response.payload.active?).to be_truthy
        end
      end

      context 'when deactivating' do
        let(:params) { { active: false } }

        it 'updates the contact' do
          response = update

          expect(response).to be_success
          expect(response.payload.active?).to be_falsy
        end
      end

      context 'when the contact is invalid' do
        let(:params) { { first_name: nil } }

        it 'returns an error' do
          response = update

          expect(response).to be_error
          expect(response.message).to match_array([""First name can't be blank""])
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module CustomerRelations
  module Contacts
    class CreateService < BaseService
      def execute
        return error_no_permissions unless allowed?
        return error_organization_invalid unless organization_valid?

        contact = Contact.create(params.merge(group_id: group.id))
        return error_creating(contact) unless contact.persisted?

        ServiceResponse.success(payload: contact)
      end

      private

      def error_creating(contact)
        error(contact&.errors&.full_messages || 'Failed to create contact')
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe CustomerRelations::Contacts::CreateService, feature_category: :service_desk do
  describe '#execute' do
    let_it_be(:user) { create(:user) }
    let_it_be(:not_found_or_does_not_belong) { 'The specified organization was not found or does not belong to this group' }

    let(:params) { attributes_for(:contact, group: group) }

    subject(:response) { described_class.new(group: group, current_user: user, params: params).execute }

    context 'when user does not have permission' do
      let_it_be(:group) { create(:group, :crm_enabled) }

      before_all do
        group.add_reporter(user)
      end

      it 'returns an error' do
        expect(response).to be_error
        expect(response.message).to match_array(['You have insufficient permissions to manage contacts for this group'])
      end
    end

    context 'when user has permission' do
      let_it_be(:group) { create(:group, :crm_enabled) }

      before_all do
        group.add_developer(user)
      end

      it 'creates a contact' do
        expect(response).to be_success
      end

      it 'returns an error when the contact is not persisted' do
        params[:last_name] = nil

        expect(response).to be_error
        expect(response.message).to match_array([""Last name can't be blank""])
      end

      it 'returns an error when the organization_id is invalid' do
        params[:organization_id] = non_existing_record_id

        expect(response).to be_error
        expect(response.message).to match_array([not_found_or_does_not_belong])
      end

      it 'returns an error when the organization belongs to a different group' do
        crm_organization = create(:crm_organization)
        params[:organization_id] = crm_organization.id

        expect(response).to be_error
        expect(response.message).to match_array([not_found_or_does_not_belong])
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Admin
  class SetFeatureFlagService
    UnknownOperationError = Class.new(StandardError)

    def initialize(feature_flag_name:, params:)
      @name = feature_flag_name
      @target = Feature::Target.new(params)
      @params = params
      @force = params[:force]
    end

    def execute
      unless force
        error = validate_feature_flag_name
        return ServiceResponse.error(message: error, reason: :invalid_feature_flag) if error
      end

      if target.gate_specified?
        update_targets
      else
        update_global
      end

      feature_flag = Feature.get(name) # rubocop:disable Gitlab/AvoidFeatureGet

      ServiceResponse.success(payload: { feature_flag: feature_flag })
    rescue Feature::InvalidOperation => e
      ServiceResponse.error(message: e.message, reason: :illegal_operation)
    rescue UnknownOperationError => e
      ServiceResponse.error(message: e.message, reason: :illegal_operation)
    rescue Feature::Target::UnknownTargetError => e
      ServiceResponse.error(message: e.message, reason: :actor_not_found)
    end

    private

    attr_reader :name, :params, :target, :force

    # Note: the if expressions in `update_targets` and `update_global` are order dependant.
    def update_targets
      target.targets.each do |target|
        if enable?
          enable(target)
        elsif disable?
          Feature.disable(name, target)
        elsif opt_out?
          Feature.opt_out(name, target)
        elsif remove_opt_out?
          remove_opt_out(target)
        else
          raise UnknownOperationError, ""Cannot set '#{name}' to #{value.inspect} for #{target}""
        end
      end
    end

    def update_global
      if enable?
        Feature.enable(name)
      elsif disable?
        Feature.disable(name)
      elsif percentage_of_actors?
        Feature.enable_percentage_of_actors(name, percentage)
      # Deprecated in favor of Feature.enabled?(name, :instance) + Feature.enable_percentage_of_actors(name, percentage)
      elsif percentage_of_time?
        Feature.enable_percentage_of_time(name, percentage)
      else
        msg = if key.present?
                ""Cannot set '#{name}' (#{key.inspect}) to #{value.inspect}""
              else
                ""Cannot set '#{name}' to #{value.inspect}""
              end

        raise UnknownOperationError, msg
      end
    end

    def remove_opt_out(target)
      raise Feature::InvalidOperation, ""No opt-out exists for #{target}"" unless Feature.opted_out?(name, target)

      Feature.remove_opt_out(name, target)
    end

    def enable(target)
      if Feature.opted_out?(name, target)
        target_name = target.respond_to?(:to_reference) ? target.to_reference : target.to_s
        raise Feature::InvalidOperation, ""Opt-out exists for #{target_name} - remove opt-out before enabling""
      end

      Feature.enable(name, target)
    end

    def value
      params[:value]
    end

    def key
      params[:key]
    end

    def numeric_value?
      params[:value].match?(/^\d+(\.\d+)?$/)
    end

    def percentage
      raise UnknownOperationError, ""Not a percentage"" unless numeric_value?

      value.to_f
    end

    def percentage_of_actors?
      key == 'percentage_of_actors'
    end

    def percentage_of_time?
      return true if key == 'percentage_of_time'
      return numeric_value? if key.nil?

      false
    end

    # Note: `key` is NOT considered - setting to a percentage to 0 is the same as disabling.
    def disable?
      value.in?(%w[0 0.0 false])
    end

    # Note: `key` is NOT considered - setting to a percentage to 100 is the same
    def enable?
      value.in?(%w[100 100.0 true])
    end

    def opt_out?
      value == 'opt_out'
    end

    def remove_opt_out?
      value == 'remove_opt_out'
    end

    def validate_feature_flag_name
      ## Overridden in EE
    end
  end
end

Admin::SetFeatureFlagService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Admin::SetFeatureFlagService, feature_category: :feature_flags do
  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project) }
  let_it_be(:group) { create(:group) }

  let(:feature_name) { known_feature_flag.name }
  let(:service) { described_class.new(feature_flag_name: feature_name, params: params) }

  # Find any `development` feature flag name
  let(:known_feature_flag) do
    Feature::Definition.definitions
      .values.find { |defn| defn.development? && !defn.default_enabled }
  end

  describe 'sequences of executions' do
    subject(:flag) do
      Feature.get(feature_name) # rubocop: disable Gitlab/AvoidFeatureGet
    end

    context 'if we enable_percentage_of_actors and then disable' do
      before do
        described_class
          .new(feature_flag_name: feature_name, params: { key: 'percentage_of_actors', value: '50.0' })
           .execute

        described_class
          .new(feature_flag_name: feature_name, params: { key: 'percentage_of_actors', value: '0.0' })
          .execute
      end

      it 'leaves the flag off' do
        expect(flag.state).to eq(:off)
      end
    end

    context 'if we enable and then enable_percentage_of_actors' do
      before do
        described_class
          .new(feature_flag_name: feature_name, params: { key: 'percentage_of_actors', value: '100.0' })
          .execute
      end

      it 'reports an error' do
        result = described_class
            .new(feature_flag_name: feature_name, params: { key: 'percentage_of_actors', value: '50.0' })
            .execute

        expect(flag.state).to eq(:on)
        expect(result).to be_error
      end

      context 'if we disable the flag first' do
        before do
          described_class
            .new(feature_flag_name: feature_name, params: { value: 'false' })
            .execute
        end

        it 'sets the percentage of actors' do
          result = described_class
              .new(feature_flag_name: feature_name, params: { key: 'percentage_of_actors', value: '50.0' })
              .execute

          expect(flag.state).to eq(:conditional)
          expect(result).not_to be_error
        end
      end
    end
  end

  describe '#execute' do
    before do
      unstub_all_feature_flags

      Feature.reset
      Flipper.unregister_groups
      Flipper.register(:perf_team) do |actor|
        actor.respond_to?(:admin) && actor.admin?
      end
    end

    subject(:result) { service.execute }

    context 'when we cannot interpret the operation' do
      let(:params) { { value: 'wibble', key: 'unknown' } }

      it { is_expected.to be_error }
      it { is_expected.to have_attributes(reason: :illegal_operation) }
      it { is_expected.to have_attributes(message: %(Cannot set '#{feature_name}' (""unknown"") to ""wibble"")) }

      context 'when the key is absent' do
        let(:params) { { value: 'wibble' } }

        it { is_expected.to be_error }
        it { is_expected.to have_attributes(reason: :illegal_operation) }
        it { is_expected.to have_attributes(message: %(Cannot set '#{feature_name}' to ""wibble"")) }
      end
    end

    context 'when the value to set cannot be parsed' do
      let(:params) { { value: 'wibble', key: 'percentage_of_actors' } }

      it { is_expected.to be_error }
      it { is_expected.to have_attributes(reason: :illegal_operation) }
      it { is_expected.to have_attributes(message: 'Not a percentage') }
    end

    context 'when value is ""remove_opt_out""' do
      before do
        Feature.enable(feature_name)
      end

      context 'without a target' do
        let(:params) { { value: 'remove_opt_out' } }

        it 'returns an error' do
          expect(result).to be_error
          expect(result.reason).to eq(:illegal_operation)
        end
      end

      context 'with a target' do
        let(:params) { { value: 'remove_opt_out', user: user.username } }

        context 'when there is currently no opt-out' do
          it 'returns an error' do
            expect(result).to be_error
            expect(result.reason).to eq(:illegal_operation)
            expect(Feature).to be_enabled(feature_name, user)
          end
        end

        context 'when there is currently an opt-out' do
          before do
            Feature.opt_out(feature_name, user)
          end

          it 'removes the opt out' do
            expect(result).to be_success
            expect(Feature).to be_enabled(feature_name, user)
          end
        end
      end
    end

    context 'when value is ""opt_out""' do
      let(:params) { { value: 'opt_out', namespace: group.full_path, user: user.username } }

      it 'opts the user and group out' do
        expect(Feature).to receive(:opt_out).with(feature_name, user)
        expect(Feature).to receive(:opt_out).with(feature_name, group)
        expect(result).to be_success
      end

      context 'without a target' do
        let(:params) { { value: 'opt_out' } }

        it { is_expected.to be_error }

        it { is_expected.to have_attributes(reason: :illegal_operation) }
      end
    end

    context 'when enabling the feature flag' do
      let(:params) { { value: 'true' } }

      it 'enables the feature flag' do
        expect(Feature).to receive(:enable).with(feature_name)
        expect(subject).to be_success

        feature_flag = subject.payload[:feature_flag]
        expect(feature_flag.name).to eq(feature_name)
      end

      context 'when the flag is default_enabled' do
        let(:known_feature_flag) do
          Feature::Definition.definitions
            .values.find { |defn| defn.development? && defn.default_enabled }
        end

        it 'leaves the flag enabled' do
          expect(subject).to be_success
          expect(Feature).to be_enabled(feature_name)
        end
      end

      it 'logs the event' do
        expect(Feature.logger).to receive(:info).once

        subject
      end

      context 'when enabling for a user actor' do
        let(:params) { { value: 'true', user: user.username } }

        it 'enables the feature flag' do
          expect(Feature).to receive(:enable).with(feature_name, user)
          expect(subject).to be_success
        end

        context 'when the flag has been opted out for user' do
          before do
            Feature.enable(feature_name)
            Feature.opt_out(feature_name, user)
          end

          it 'records an error' do
            expect(subject).to be_error
            expect(subject.reason).to eq(:illegal_operation)
            expect(Feature).not_to be_enabled(feature_name, user)
          end
        end

        context 'when the flag is default_enabled' do
          let(:known_feature_flag) do
            Feature::Definition.definitions
              .values.find { |defn| defn.development? && defn.default_enabled }
          end

          it 'leaves the feature enabled' do
            expect(subject).to be_success
            expect(Feature).to be_enabled(feature_name, user)
          end
        end

        context 'when user does not exist' do
          let(:params) { { value: 'true', user: 'unknown-user' } }

          it 'does nothing' do
            expect(Feature).not_to receive(:enable)
            expect(subject).to be_error
            expect(subject.reason).to eq(:actor_not_found)
          end
        end
      end

      context 'when enabling for a feature group' do
        let(:params) { { value: 'true', feature_group: 'perf_team' } }
        let(:feature_group) { Feature.group('perf_team') }

        it 'enables the feature flag' do
          expect(Feature).to receive(:enable).with(feature_name, feature_group)
          expect(subject).to be_success
        end
      end

      context 'when enabling for a project' do
        let(:params) { { value: 'true', project: project.full_path } }

        it 'enables the feature flag' do
          expect(Feature).to receive(:enable).with(feature_name, project)
          expect(subject).to be_success
        end
      end

      context 'when enabling for a group' do
        let(:params) { { value: 'true', group: group.full_path } }

        it 'enables the feature flag' do
          expect(Feature).to receive(:enable).with(feature_name, group)
          expect(subject).to be_success
        end

        context 'when group does not exist' do
          let(:params) { { value: 'true', group: 'unknown-group' } }

          it 'returns an error' do
            expect(Feature).not_to receive(:disable)
            expect(subject).to be_error
            expect(subject.reason).to eq(:actor_not_found)
          end
        end
      end

      context 'when enabling for a user namespace' do
        let(:namespace) { user.namespace }
        let(:params) { { value: 'true', namespace: namespace.full_path } }

        it 'enables the feature flag' do
          expect(Feature).to receive(:enable).with(feature_name, namespace)
          expect(subject).to be_success
        end

        context 'when namespace does not exist' do
          let(:params) { { value: 'true', namespace: 'unknown-namespace' } }

          it 'returns an error' do
            expect(Feature).not_to receive(:disable)
            expect(subject).to be_error
            expect(subject.reason).to eq(:actor_not_found)
          end
        end
      end

      context 'when enabling for a group namespace' do
        let(:params) { { value: 'true', namespace: group.full_path } }

        it 'enables the feature flag' do
          expect(Feature).to receive(:enable).with(feature_name, group)
          expect(subject).to be_success
        end
      end

      context 'when enabling for a repository' do
        let(:params) { { value: 'true', repository: project.repository.full_path } }

        it 'enables the feature flag' do
          expect(Feature).to receive(:enable).with(feature_name, project.repository)
          expect(subject).to be_success
        end
      end

      context 'when enabling for a user actor and a feature group' do
        let(:params) { { value: 'true', user: user.username, feature_group: 'perf_team' } }
        let(:feature_group) { Feature.group('perf_team') }

        it 'enables the feature flag' do
          expect(Feature).to receive(:enable).with(feature_name, user)
          expect(Feature).to receive(:enable).with(feature_name, feature_group)
          expect(subject).to be_success
        end
      end

      context 'when enabling given a percentage of time' do
        let(:params) { { value: '50' } }

        it 'enables the feature flag' do
          expect(Feature).to receive(:enable_percentage_of_time).with(feature_name, 50)
          expect(subject).to be_success
        end

        context 'when value is a float' do
          let(:params) { { value: '0.01' } }

          it 'enables the feature flag' do
            expect(Feature).to receive(:enable_percentage_of_time).with(feature_name, 0.01)
            expect(subject).to be_success
          end
        end

        context 'with a target' do
          before do
            params[:user] = user.username
          end

          it { is_expected.to be_error }

          it { is_expected.to have_attributes(reason: :illegal_operation) }
        end
      end

      context 'when enabling given a percentage of actors' do
        let(:params) { { value: '50', key: 'percentage_of_actors' } }

        it 'enables the feature flag' do
          expect(Feature).to receive(:enable_percentage_of_actors).with(feature_name, 50)
          expect(subject).to be_success
        end

        context 'when value is a float' do
          let(:params) { { value: '0.01', key: 'percentage_of_actors' } }

          it 'enables the feature flag' do
            expect(Feature).to receive(:enable_percentage_of_actors).with(feature_name, 0.01)
            expect(subject).to be_success
          end
        end

        context 'with a target' do
          before do
            params[:user] = user.username
          end

          it { is_expected.to be_error }

          it { is_expected.to have_attributes(reason: :illegal_operation) }
        end
      end
    end

    context 'when disabling the feature flag' do
      before do
        Feature.enable(feature_name)
      end

      let(:params) { { value: 'false' } }

      it 'disables the feature flag' do
        expect(Feature).to receive(:disable).with(feature_name)
        expect(subject).to be_success

        feature_flag = subject.payload[:feature_flag]
        expect(feature_flag.name).to eq(feature_name)
      end

      it 'logs the event' do
        expect(Feature.logger).to receive(:info).once

        subject
      end

      context 'when disabling for a user actor' do
        let(:params) { { value: 'false', user: user.username } }

        it 'disables the feature flag' do
          expect(Feature).to receive(:disable).with(feature_name, user)
          expect(subject).to be_success
        end

        context 'when user does not exist' do
          let(:params) { { value: 'false', user: 'unknown-user' } }

          it 'returns an error' do
            expect(Feature).not_to receive(:disable)
            expect(subject).to be_error
            expect(subject.reason).to eq(:actor_not_found)
          end
        end
      end

      context 'when disabling for a feature group' do
        let(:params) { { value: 'false', feature_group: 'perf_team' } }
        let(:feature_group) { Feature.group('perf_team') }

        it 'disables the feature flag' do
          expect(Feature).to receive(:disable).with(feature_name, feature_group)
          expect(subject).to be_success
        end
      end

      context 'when disabling for a project' do
        let(:params) { { value: 'false', project: project.full_path } }

        it 'disables the feature flag' do
          expect(Feature).to receive(:disable).with(feature_name, project)
          expect(subject).to be_success
        end
      end

      context 'when disabling for a group' do
        let(:params) { { value: 'false', group: group.full_path } }

        it 'disables the feature flag' do
          expect(Feature).to receive(:disable).with(feature_name, group)
          expect(subject).to be_success
        end

        context 'when group does not exist' do
          let(:params) { { value: 'false', group: 'unknown-group' } }

          it 'returns an error' do
            expect(Feature).not_to receive(:disable)
            expect(subject).to be_error
            expect(subject.reason).to eq(:actor_not_found)
          end
        end
      end

      context 'when disabling for a user namespace' do
        let(:namespace) { user.namespace }
        let(:params) { { value: 'false', namespace: namespace.full_path } }

        it 'disables the feature flag' do
          expect(Feature).to receive(:disable).with(feature_name, namespace)
          expect(subject).to be_success
        end

        context 'when namespace does not exist' do
          let(:params) { { value: 'false', namespace: 'unknown-namespace' } }

          it 'returns an error' do
            expect(Feature).not_to receive(:disable)
            expect(subject).to be_error
            expect(subject.reason).to eq(:actor_not_found)
          end
        end
      end

      context 'when disabling for a group namespace' do
        let(:params) { { value: 'false', namespace: group.full_path } }

        it 'disables the feature flag' do
          expect(Feature).to receive(:disable).with(feature_name, group)
          expect(subject).to be_success
        end
      end

      context 'when disabling for a user actor and a feature group' do
        let(:params) { { value: 'false', user: user.username, feature_group: 'perf_team' } }
        let(:feature_group) { Feature.group('perf_team') }

        it 'disables the feature flag' do
          expect(Feature).to receive(:disable).with(feature_name, user)
          expect(Feature).to receive(:disable).with(feature_name, feature_group)
          expect(subject).to be_success
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Admin
  module AbuseReportLabels
    class CreateService < Labels::BaseService
      def initialize(params = {})
        @params = params
      end

      def execute
        params[:color] = convert_color_name_to_hex if params[:color].present?

        ::Admin::AbuseReportLabel.create(params)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Admin::AbuseReportLabels::CreateService, feature_category: :insider_threat do
  describe '#execute' do
    let(:color) { 'red' }
    let(:color_in_hex) { ::Gitlab::Color.of(color) }
    let(:params) { { title: 'FancyLabel', color: color } }

    subject(:execute) { described_class.new(params).execute }

    shared_examples 'creates a label with the correct values' do
      it 'creates a label with the correct values', :aggregate_failures do
        expect { execute }.to change { Admin::AbuseReportLabel.count }.from(0).to(1)

        label = Admin::AbuseReportLabel.last
        expect(label.title).to eq params[:title]
        expect(label.color).to eq color_in_hex
      end

      it 'returns the persisted label' do
        result = execute
        expect(result).to be_an_instance_of(Admin::AbuseReportLabel)
        expect(result.persisted?).to eq true
      end
    end

    it_behaves_like 'creates a label with the correct values'

    context 'without color param' do
      let(:params) { { title: 'FancyLabel' } }
      let(:color_in_hex) { ::Gitlab::Color.of(Label::DEFAULT_COLOR) }

      it_behaves_like 'creates a label with the correct values'
    end

    context 'with errors' do
      let!(:existing_label) { create(:abuse_report_label, title: params[:title]) }

      it 'does not create the label' do
        expect { execute }.not_to change { Admin::AbuseReportLabel.count }
      end

      it 'returns the label with errors' do
        label = execute
        expect(label.errors.messages).to include({ title: [""has already been taken""] })
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Admin
  module AbuseReports
    class ModerateUserService < BaseService
      attr_reader :abuse_report, :params, :current_user, :action

      def initialize(abuse_report, current_user, params)
        @abuse_report = abuse_report
        @current_user = current_user
        @params = params
        @action = determine_action
      end

      def execute
        return ServiceResponse.error(message: 'Admin is required') unless current_user&.can_admin_all_resources?
        return ServiceResponse.error(message: 'Action is required') unless action.present?

        result = perform_action
        if result[:status] == :success
          event = close_report_and_record_event
          ServiceResponse.success(message: event.success_message)
        else
          ServiceResponse.error(message: result[:message])
        end
      end

      private

      def determine_action
        action = params[:user_action]
        if action.in?(ResourceEvents::AbuseReportEvent.actions.keys)
          action.to_sym
        elsif close_report?
          :close_report
        end
      end

      def perform_action
        case action
        when :ban_user then ban_user
        when :block_user then block_user
        when :delete_user then delete_user
        when :close_report then close_report
        when :trust_user then trust_user
        end
      end

      def ban_user
        Users::BanService.new(current_user).execute(abuse_report.user)
      end

      def block_user
        Users::BlockService.new(current_user).execute(abuse_report.user)
      end

      def delete_user
        abuse_report.user.delete_async(deleted_by: current_user)
        success
      end

      def close_report
        return error('Report already closed') if abuse_report.closed?

        close_similar_open_reports
        abuse_report.closed!
        success
      end

      def trust_user
        Users::TrustService.new(current_user).execute(abuse_report.user)
      end

      def close_similar_open_reports
        # admins see the abuse report and other open reports for the same user in one page
        # hence, if the request is to close the report, close other open reports for the same user too
        abuse_report.similar_open_reports_for_user.update_all(status: 'closed')
      end

      def close_report_and_record_event
        event = action

        if close_report? && action != :close_report
          close_report
          event = ""#{action}_and_close_report""
        end

        record_event(event)
      end

      def close_report?
        params[:close].to_s == 'true'
      end

      def record_event(action)
        reason = params[:reason]
        unless reason.in?(ResourceEvents::AbuseReportEvent.reasons.keys)
          reason = ResourceEvents::AbuseReportEvent.reasons[:other]
        end

        abuse_report.events.create(action: action, user: current_user, reason: reason, comment: params[:comment])
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Admin::AbuseReports::ModerateUserService, feature_category: :instance_resiliency do
  let_it_be_with_reload(:abuse_report) { create(:abuse_report) }
  let_it_be_with_reload(:similar_abuse_report) do
    create(:abuse_report, user: abuse_report.user, category: abuse_report.category)
  end

  let(:action) { 'ban_user' }
  let(:close) { true }
  let(:reason) { 'spam' }
  let(:params) { { user_action: action, close: close, reason: reason, comment: 'obvious spam' } }
  let_it_be(:admin) { create(:admin) }

  let(:service) { described_class.new(abuse_report, admin, params) }

  describe '#execute', :enable_admin_mode do
    subject { service.execute }

    shared_examples 'returns an error response' do |error|
      it 'returns an error response' do
        expect(subject.status).to eq :error
        expect(subject.message).to eq error
      end
    end

    shared_examples 'closes the report' do
      it 'closes the report' do
        expect { subject }.to change { abuse_report.closed? }.from(false).to(true)
      end

      context 'when similar open reports for the user exist' do
        it 'closes the similar report' do
          expect { subject }.to change { similar_abuse_report.reload.closed? }.from(false).to(true)
        end
      end
    end

    shared_examples 'does not close the report' do
      it 'does not close the report' do
        subject
        expect(abuse_report.closed?).to be(false)
      end

      context 'when similar open reports for the user exist' do
        it 'does not close the similar report' do
          subject
          expect(similar_abuse_report.reload.closed?).to be(false)
        end
      end
    end

    shared_examples 'does not record an event' do
      it 'does not record an event' do
        expect { subject }.not_to change { abuse_report.events.count }
      end
    end

    shared_examples 'records an event' do |action:|
      it 'records the event', :aggregate_failures do
        expect { subject }.to change { abuse_report.events.count }.by(1)

        expect(abuse_report.events.last).to have_attributes(
          action: action,
          user: admin,
          reason: reason,
          comment: params[:comment]
        )
      end

      it 'returns the event success message' do
        expect(subject.message).to eq(abuse_report.events.last.success_message)
      end
    end

    context 'when invalid parameters are given' do
      describe 'invalid user' do
        describe 'when no user is given' do
          let_it_be(:admin) { nil }

          it_behaves_like 'returns an error response', 'Admin is required'
        end

        describe 'when given user is no admin' do
          let_it_be(:admin) { create(:user) }

          it_behaves_like 'returns an error response', 'Admin is required'
        end
      end

      describe 'invalid action' do
        describe 'when no action is given' do
          let(:action) { '' }
          let(:close) { 'false' }

          it_behaves_like 'returns an error response', 'Action is required'
        end

        describe 'when unknown action is given' do
          let(:action) { 'unknown' }
          let(:close) { 'false' }

          it_behaves_like 'returns an error response', 'Action is required'
        end
      end

      describe 'invalid reason' do
        let(:reason) { '' }

        it 'sets the reason to `other`' do
          subject

          expect(abuse_report.events.last).to have_attributes(reason: 'other')
        end
      end
    end

    describe 'when banning the user' do
      it 'calls the Users::BanService' do
        expect_next_instance_of(Users::BanService, admin) do |service|
          expect(service).to receive(:execute).with(abuse_report.user).and_return(status: :success)
        end

        subject
      end

      context 'when closing the report' do
        it_behaves_like 'closes the report'
        it_behaves_like 'records an event', action: 'ban_user_and_close_report'
      end

      context 'when not closing the report' do
        let(:close) { 'false' }

        it_behaves_like 'does not close the report'
        it_behaves_like 'records an event', action: 'ban_user'
      end

      context 'when banning the user fails' do
        before do
          allow_next_instance_of(Users::BanService, admin) do |service|
            allow(service).to receive(:execute).with(abuse_report.user)
              .and_return(status: :error, message: 'Banning the user failed')
          end
        end

        it_behaves_like 'returns an error response', 'Banning the user failed'
        it_behaves_like 'does not close the report'
        it_behaves_like 'does not record an event'
      end
    end

    describe 'when blocking the user' do
      let(:action) { 'block_user' }

      it 'calls the Users::BlockService' do
        expect_next_instance_of(Users::BlockService, admin) do |service|
          expect(service).to receive(:execute).with(abuse_report.user).and_return(status: :success)
        end

        subject
      end

      context 'when closing the report' do
        it_behaves_like 'closes the report'
        it_behaves_like 'records an event', action: 'block_user_and_close_report'
      end

      context 'when not closing the report' do
        let(:close) { 'false' }

        it_behaves_like 'does not close the report'
        it_behaves_like 'records an event', action: 'block_user'
      end

      context 'when blocking the user fails' do
        before do
          allow_next_instance_of(Users::BlockService, admin) do |service|
            allow(service).to receive(:execute).with(abuse_report.user)
              .and_return(status: :error, message: 'Blocking the user failed')
          end
        end

        it_behaves_like 'returns an error response', 'Blocking the user failed'
        it_behaves_like 'does not close the report'
        it_behaves_like 'does not record an event'
      end
    end

    describe 'when deleting the user' do
      let(:action) { 'delete_user' }

      it 'calls the delete_async method' do
        expect(abuse_report.user).to receive(:delete_async).with(deleted_by: admin)
        subject
      end

      context 'when closing the report' do
        it_behaves_like 'closes the report'
        it_behaves_like 'records an event', action: 'delete_user_and_close_report'
      end

      context 'when not closing the report' do
        let(:close) { 'false' }

        it_behaves_like 'does not close the report'
        it_behaves_like 'records an event', action: 'delete_user'
      end
    end

    describe 'when trusting the user' do
      let(:action) { 'trust_user' }

      it 'calls the Users::TrustService method' do
        expect_next_instance_of(Users::TrustService, admin) do |service|
          expect(service).to receive(:execute).with(abuse_report.user).and_return(status: :success)
        end

        subject
      end

      context 'when not closing the report' do
        let(:close) { false }

        it_behaves_like 'does not close the report'
        it_behaves_like 'records an event', action: 'trust_user'
      end

      context 'when closing the report' do
        it_behaves_like 'closes the report'
        it_behaves_like 'records an event', action: 'trust_user_and_close_report'
      end

      context 'when trusting the user fails' do
        before do
          allow_next_instance_of(Users::TrustService) do |service|
            allow(service).to receive(:execute).with(abuse_report.user)
             .and_return(status: :error, message: 'Trusting the user failed')
          end
        end

        it_behaves_like 'returns an error response', 'Trusting the user failed'
        it_behaves_like 'does not close the report'
        it_behaves_like 'does not record an event'
      end
    end

    describe 'when only closing the report' do
      let(:action) { '' }

      it_behaves_like 'closes the report'
      it_behaves_like 'records an event', action: 'close_report'

      context 'when report is already closed' do
        before do
          abuse_report.closed!
        end

        it_behaves_like 'returns an error response', 'Report already closed'
        it_behaves_like 'does not record an event'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Admin
  module AbuseReports
    class UpdateService < BaseService
      attr_reader :abuse_report, :params, :current_user

      def initialize(abuse_report, current_user, params)
        @abuse_report = abuse_report
        @current_user = current_user
        @params = params
      end

      def execute
        return ServiceResponse.error(message: 'Admin is required') unless current_user&.can_admin_all_resources?

        abuse_report.label_ids = label_ids

        ServiceResponse.success
      end

      private

      def label_ids
        params[:label_ids].filter_map do |id|
          GitlabSchema.parse_gid(id, expected_type: ::Admin::AbuseReportLabel).model_id
        rescue Gitlab::Graphql::Errors::ArgumentError
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Admin::AbuseReports::UpdateService, feature_category: :instance_resiliency do
  let_it_be(:current_user) { create(:admin) }
  let_it_be(:abuse_report) { create(:abuse_report) }
  let_it_be(:label) { create(:abuse_report_label) }

  let(:params) { {} }
  let(:service) { described_class.new(abuse_report, current_user, params) }

  describe '#execute', :enable_admin_mode do
    subject { service.execute }

    shared_examples 'returns an error response' do |error|
      it 'returns an error response' do
        expect(subject).to be_error
        expect(subject.message).to eq error
      end
    end

    context 'with invalid parameters' do
      describe 'invalid user' do
        describe 'when no user is given' do
          let_it_be(:current_user) { nil }

          it_behaves_like 'returns an error response', 'Admin is required'
        end

        describe 'when given user is not an admin' do
          let_it_be(:current_user) { create(:user) }

          it_behaves_like 'returns an error response', 'Admin is required'
        end
      end

      describe 'invalid label_ids' do
        let(:params) { { label_ids: ['invalid_global_id', non_existing_record_id] } }

        it 'does not update the abuse report' do
          expect { subject }.not_to change { abuse_report.labels }
        end

        it { is_expected.to be_success }
      end
    end

    describe 'with valid parameters' do
      context 'when label_ids is empty' do
        let(:params) { { label_ids: [] } }

        context 'when abuse report has existing labels' do
          before do
            abuse_report.labels = [label]
          end

          it 'clears the abuse report labels' do
            expect { subject }.to change { abuse_report.labels.count }.from(1).to(0)
          end

          it { is_expected.to be_success }
        end

        context 'when abuse report has no existing labels' do
          it 'does not update the abuse report' do
            expect { subject }.not_to change { abuse_report.labels }
          end

          it { is_expected.to be_success }
        end
      end

      context 'when label_ids is not empty' do
        let(:params) { { label_ids: [Gitlab::GlobalId.build(label, id: label.id).to_s] } }

        it 'updates the abuse report' do
          expect { subject }.to change { abuse_report.label_ids }.from([]).to([label.id])
        end

        it { is_expected.to be_success }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Admin
  module PlanLimits
    class UpdateService < ::BaseService
      def initialize(params = {}, current_user:, plan:)
        @current_user = current_user
        @params = params
        @plan = plan
        @plan_limits = plan.actual_limits
      end

      def execute
        return error(_('Access denied'), :forbidden) unless can_update?

        add_history_to_params!

        plan_limits.assign_attributes(parsed_params)

        validate_storage_limits

        return error(plan_limits.errors.full_messages, :bad_request) if plan_limits.errors.any?

        if plan_limits.update(parsed_params)
          success
        else
          error(plan_limits.errors.full_messages, :bad_request)
        end
      end

      private

      attr_accessor :current_user, :params, :plan, :plan_limits

      delegate :notification_limit, :storage_size_limit, :enforcement_limit, to: :plan_limits

      def can_update?
        current_user.can_admin_all_resources?
      end

      def add_history_to_params!
        formatted_limits_history = plan_limits.format_limits_history(current_user, parsed_params)
        parsed_params.merge!(limits_history: formatted_limits_history) unless formatted_limits_history.empty?
      end

      def validate_storage_limits
        validate_notification_limit
        validate_enforcement_limit
        validate_storage_size_limit
      end

      def validate_notification_limit
        return unless parsed_params.include?(:notification_limit)
        return if unlimited_value?(:notification_limit)

        if storage_size_limit > 0 && notification_limit < storage_size_limit
          plan_limits.errors.add(
            :notification_limit, ""must be greater than or equal to the dashboard limit (#{storage_size_limit})""
          )
        end

        return unless enforcement_limit > 0 && notification_limit > enforcement_limit

        plan_limits.errors.add(
          :notification_limit, ""must be less than or equal to the enforcement limit (#{enforcement_limit})""
        )
      end

      def validate_enforcement_limit
        return unless parsed_params.include?(:enforcement_limit)
        return if unlimited_value?(:enforcement_limit)

        if storage_size_limit > 0 && enforcement_limit < storage_size_limit
          plan_limits.errors.add(
            :enforcement_limit, ""must be greater than or equal to the dashboard limit (#{storage_size_limit})""
          )
        end

        return unless notification_limit > 0 && enforcement_limit < notification_limit

        plan_limits.errors.add(
          :enforcement_limit, ""must be greater than or equal to the notification limit (#{notification_limit})""
        )
      end

      def validate_storage_size_limit
        return unless parsed_params.include?(:storage_size_limit)
        return if unlimited_value?(:storage_size_limit)

        if enforcement_limit > 0 && storage_size_limit > enforcement_limit
          plan_limits.errors.add(
            :dashboard_limit, ""must be less than or equal to the enforcement limit (#{enforcement_limit})""
          )
        end

        return unless notification_limit > 0 && storage_size_limit > notification_limit

        plan_limits.errors.add(
          :dashboard_limit, ""must be less than or equal to the notification limit (#{notification_limit})""
        )
      end

      # Overridden in EE
      def parsed_params
        params
      end

      def unlimited_value?(limit)
        parsed_params[limit] == 0
      end
    end
  end
end

Admin::PlanLimits::UpdateService.prepend_mod_with('Admin::PlanLimits::UpdateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Admin::PlanLimits::UpdateService, feature_category: :shared do
  let_it_be(:user) { create(:admin) }
  let_it_be(:plan) { create(:plan, name: 'free') }
  let_it_be(:limits) { plan.actual_limits }
  let_it_be(:params) do
    {
      ci_pipeline_size: 101,
      ci_active_jobs: 102,
      ci_project_subscriptions: 104,
      ci_pipeline_schedules: 105,
      ci_needs_size_limit: 106,
      ci_registered_group_runners: 107,
      ci_registered_project_runners: 108,
      conan_max_file_size: 10,
      enforcement_limit: 100,
      generic_packages_max_file_size: 20,
      helm_max_file_size: 25,
      notification_limit: 95,
      maven_max_file_size: 40,
      npm_max_file_size: 60,
      nuget_max_file_size: 60,
      pypi_max_file_size: 70,
      terraform_module_max_file_size: 80,
      storage_size_limit: 90,
      pipeline_hierarchy_size: 250
    }
  end

  subject(:update_plan_limits) { described_class.new(params, current_user: user, plan: plan).execute }

  context 'when current_user is an admin', :enable_admin_mode do
    context 'when the update is successful', :freeze_time do
      let(:current_timestamp) { Time.current.utc.to_i }

      it 'updates all attributes' do
        update_plan_limits

        params.each do |key, value|
          expect(limits.send(key)).to eq value
        end
      end

      it 'logs the allowed attributes only' do
        update_plan_limits

        expect(limits.limits_history).to eq(
          { ""enforcement_limit"" =>
                                [{ ""user_id"" => user.id, ""username"" => user.username,
                                   ""timestamp"" => current_timestamp, ""value"" => 100 }],
            ""notification_limit"" =>
                                [{ ""user_id"" => user.id, ""username"" => user.username,
                                   ""timestamp"" => current_timestamp, ""value"" => 95 }],
            ""storage_size_limit"" =>
                                [{ ""user_id"" => user.id, ""username"" => user.username,
                                   ""timestamp"" => current_timestamp, ""value"" => 90 }] }
        )
      end

      it 'returns success' do
        response = update_plan_limits

        expect(response[:status]).to eq :success
      end
    end

    context 'when the update is unsuccessful' do
      context 'when notification_limit is less than storage_size_limit' do
        let(:params) { { notification_limit: 2 } }

        before do
          limits.update!(
            storage_size_limit: 5,
            enforcement_limit: 10
          )
        end

        it 'returns an error' do
          response = update_plan_limits

          expect(response[:status]).to eq :error
          expect(response[:message]).to eq [
            ""Notification limit must be greater than or equal to the dashboard limit (5)""
          ]
        end
      end

      context 'when notification_limit is greater than enforcement_limit' do
        let(:params) { { notification_limit: 11 } }

        before do
          limits.update!(
            storage_size_limit: 5,
            enforcement_limit: 10
          )
        end

        it 'returns an error' do
          response = update_plan_limits

          expect(response[:status]).to eq :error
          expect(response[:message]).to eq [
            ""Notification limit must be less than or equal to the enforcement limit (10)""
          ]
        end
      end

      context 'when enforcement_limit is less than storage_size_limit' do
        let(:params) { { enforcement_limit: 9 } }

        before do
          limits.update!(
            storage_size_limit: 10,
            notification_limit: 9
          )
        end

        it 'returns an error' do
          response = update_plan_limits

          expect(response[:status]).to eq :error
          expect(response[:message]).to eq [
            ""Enforcement limit must be greater than or equal to the dashboard limit (10)""
          ]
        end
      end

      context 'when enforcement_limit is less than notification_limit' do
        let(:params) { { enforcement_limit: 9 } }

        before do
          limits.update!(
            storage_size_limit: 9,
            notification_limit: 10
          )
        end

        it 'returns an error' do
          response = update_plan_limits

          expect(response[:status]).to eq :error
          expect(response[:message]).to eq [
            ""Enforcement limit must be greater than or equal to the notification limit (10)""
          ]
        end
      end

      context 'when storage_size_limit is greater than notification_limit' do
        let(:params) { { storage_size_limit: 11 } }

        before do
          limits.update!(
            enforcement_limit: 12,
            notification_limit: 10
          )
        end

        it 'returns an error' do
          response = update_plan_limits

          expect(response[:status]).to eq :error
          expect(response[:message]).to eq [
            ""Dashboard limit must be less than or equal to the notification limit (10)""
          ]
        end
      end

      context 'when storage_size_limit is greater than enforcement_limit' do
        let(:params) { { storage_size_limit: 11 } }

        before do
          limits.update!(
            enforcement_limit: 10,
            notification_limit: 11
          )
        end

        it 'returns an error' do
          response = update_plan_limits

          expect(response[:status]).to eq :error
          expect(response[:message]).to eq [
            ""Dashboard limit must be less than or equal to the enforcement limit (10)""
          ]
        end

        context 'when enforcement_limit is 0' do
          before do
            limits.update!(
              enforcement_limit: 0
            )
          end

          it 'does not return an error' do
            response = update_plan_limits

            expect(response[:status]).to eq :success
          end
        end
      end
    end

    context 'when setting limit to unlimited' do
      before do
        limits.update!(
          notification_limit: 10,
          storage_size_limit: 10,
          enforcement_limit: 10
        )
      end

      [:notification_limit, :enforcement_limit, :storage_size_limit].each do |limit|
        context ""for #{limit}"" do
          let(:params) { { limit => 0 } }

          it 'is successful' do
            response = update_plan_limits

            expect(response[:status]).to eq :success
          end
        end
      end
    end
  end

  context 'when the user is not an admin' do
    let(:user) { create(:user) }

    it 'returns an error' do
      response = update_plan_limits

      expect(response[:status]).to eq :error
      expect(response[:message]).to eq 'Access denied'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module IncidentManagement
  module TimelineEventTags
    class CreateService < TimelineEventTags::BaseService
      attr_reader :project, :user, :params

      def initialize(project, user, params)
        @project = project
        @user = user
        @params = params
      end

      def execute
        return error_no_permissions unless allowed?

        timeline_event_tag_params = {
          project: project,
          name: params[:name]
        }

        timeline_event_tag = IncidentManagement::TimelineEventTag.new(timeline_event_tag_params)

        if timeline_event_tag.save
          success(timeline_event_tag)
        else
          error_in_save(timeline_event_tag)
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe IncidentManagement::TimelineEventTags::CreateService, feature_category: :incident_management do
  let_it_be(:user_with_permissions) { create(:user) }
  let_it_be(:user_without_permissions) { create(:user) }
  let_it_be_with_reload(:project) { create(:project) }

  let(:current_user) { user_with_permissions }
  let(:args) { { 'name': 'Test tag 1', 'project_path': project.full_path } }

  let(:service) { described_class.new(project, current_user, args) }

  before do
    project.add_maintainer(user_with_permissions)
    project.add_developer(user_without_permissions)
  end

  describe '#execute' do
    shared_examples 'error response' do |message|
      it 'has an informative message' do
        expect(execute).to be_error
        expect(execute.message).to eq(message)
      end
    end

    shared_examples 'success response' do
      it 'has timeline event tag' do
        expect(execute).to be_success

        result = execute.payload[:timeline_event_tag]
        expect(result).to be_a(::IncidentManagement::TimelineEventTag)
        expect(result.name).to eq(args[:name])
        expect(result.project).to eq(project)
      end
    end

    subject(:execute) { service.execute }

    context 'when current user is nil' do
      let(:current_user) { nil }

      it_behaves_like 'error response',
        'You have insufficient permissions to manage timeline event tags for this project'
    end

    context 'when user does not have permissions to create tags' do
      let(:current_user) { user_without_permissions }

      it_behaves_like 'error response',
        'You have insufficient permissions to manage timeline event tags for this project'
    end

    context 'when error occurs during creation' do
      let(:args) { {} }

      it_behaves_like 'error response', ""Name can't be blank and Name is invalid""
    end

    context 'when user has permissions' do
      it_behaves_like 'success response'

      it 'creates database record' do
        expect { execute }.to change {
          ::IncidentManagement::TimelineEventTag.where(project_id: project.id).count
        }.by(1)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module IncidentManagement
  module LinkAlerts
    class DestroyService < BaseService
      # @param incident [Issue] an incident to unlink alert from
      # @param current_user [User]
      # @param alert [AlertManagement::Alert] an alert to unlink from the incident
      def initialize(incident, current_user, alert)
        @incident = incident
        @current_user = current_user
        @alert = alert

        super(project: incident.project, current_user: current_user)
      end

      def execute
        return error_no_permissions unless allowed?

        incident.alert_management_alerts.delete(alert)

        success
      end

      private

      attr_reader :alert
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe IncidentManagement::LinkAlerts::DestroyService, feature_category: :incident_management do
  let_it_be(:project) { create(:project) }
  let_it_be(:another_project) { create(:project) }
  let_it_be(:developer) { create(:user) }
  let_it_be(:guest) { create(:user) }
  let_it_be(:incident) { create(:incident, project: project) }
  let_it_be(:another_incident) { create(:incident, project: project) }
  let_it_be(:internal_alert) { create(:alert_management_alert, project: project, issue: incident) }
  let_it_be(:external_alert) { create(:alert_management_alert, project: another_project, issue: incident) }
  let_it_be(:unrelated_alert) { create(:alert_management_alert, project: project, issue: another_incident) }

  before_all do
    project.add_guest(guest)
    project.add_developer(developer)
  end

  describe '#execute' do
    subject(:execute) { described_class.new(incident, current_user, alert).execute }

    let(:alert) { internal_alert }

    context 'when current user is a guest' do
      let(:current_user) { guest }

      it 'responds with error', :aggregate_failures do
        response = execute

        expect(response).to be_error
        expect(response.message).to eq('You have insufficient permissions to manage alerts for this project')
      end

      it 'does not unlink alert from the incident' do
        expect { execute }.not_to change { incident.reload.alert_management_alerts.to_a }
      end
    end

    context 'when current user is a developer' do
      let(:current_user) { developer }

      it 'responds with success', :aggregate_failures do
        response = execute

        expect(response).to be_success
        expect(response.payload[:incident]).to eq(incident)
      end

      context 'when unlinking internal alert' do
        let(:alert) { internal_alert }

        it 'unlinks the alert' do
          expect { execute }
            .to change { incident.reload.alert_management_alerts.to_a }
            .to match_array([external_alert])
        end
      end

      context 'when unlinking external alert' do
        let(:alert) { external_alert }

        it 'unlinks the alert' do
          expect { execute }
            .to change { incident.reload.alert_management_alerts.to_a }
            .to match_array([internal_alert])
        end
      end

      context 'when unlinking an alert not related to the incident' do
        let(:alert) { unrelated_alert }

        it ""does not change the incident's alerts"" do
          expect { execute }.not_to change { incident.reload.alert_management_alerts.to_a }
        end

        it ""does not change another incident's alerts"" do
          expect { execute }.not_to change { another_incident.reload.alert_management_alerts.to_a }
        end

        it ""does not change the alert's incident"" do
          expect { execute }.not_to change { unrelated_alert.reload.issue }
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module IncidentManagement
  module LinkAlerts
    class CreateService < BaseService
      # @param incident [Issue] an incident to link alerts
      # @param current_user [User]
      # @param alert_references [[String]] a list of alert references. Can be either a short reference or URL
      #   Examples:
      #     ""^alert#IID""
      #     ""https://gitlab.com/company/project/-/alert_management/IID/details""
      def initialize(incident, current_user, alert_references)
        @incident = incident
        @current_user = current_user
        @alert_references = alert_references

        super(project: incident.project, current_user: current_user)
      end

      def execute
        return error_no_permissions unless allowed?

        references = extract_alerts_from_references
        incident.alert_management_alerts << references if references.present?

        success
      end

      private

      attr_reader :alert_references

      def extract_alerts_from_references
        text = alert_references.join(' ')
        extractor = Gitlab::ReferenceExtractor.new(project, current_user)
        extractor.analyze(text, {})

        extractor.alerts
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe IncidentManagement::LinkAlerts::CreateService, feature_category: :incident_management do
  let_it_be(:project) { create(:project) }
  let_it_be(:another_project) { create(:project) }
  let_it_be(:linked_alert) { create(:alert_management_alert, project: project) }
  let_it_be(:alert1) { create(:alert_management_alert, project: project) }
  let_it_be(:alert2) { create(:alert_management_alert, project: project) }
  let_it_be(:external_alert) { create(:alert_management_alert, project: another_project) }
  let_it_be(:incident) { create(:incident, project: project, alert_management_alerts: [linked_alert]) }
  let_it_be(:guest) { create(:user) }
  let_it_be(:developer) { create(:user) }
  let_it_be(:another_developer) { create(:user) }

  before_all do
    project.add_guest(guest)
    project.add_developer(developer)
    project.add_developer(another_developer)

    another_project.add_guest(guest)
    another_project.add_developer(developer)
  end

  describe '#execute' do
    subject(:execute) { described_class.new(incident, current_user, alert_references).execute }

    let(:alert_references) { [alert1.to_reference, alert2.details_url] }

    context 'when current user is a guest' do
      let(:current_user) { guest }

      it 'responds with error', :aggregate_failures do
        response = execute

        expect(response).to be_error
        expect(response.message).to eq('You have insufficient permissions to manage alerts for this project')
      end

      it 'does not link alerts to the incident' do
        expect { execute }.not_to change { incident.reload.alert_management_alerts.to_a }
      end
    end

    context 'when current user is a developer' do
      let(:current_user) { developer }

      it 'responds with success', :aggregate_failures do
        response = execute

        expect(response).to be_success
        expect(response.payload[:incident]).to eq(incident)
      end

      it 'links alerts to the incident' do
        expect { execute }
          .to change { incident.reload.alert_management_alerts.to_a }
          .from([linked_alert])
          .to match_array([linked_alert, alert1, alert2])
      end

      context 'when linking an already linked alert' do
        let(:alert_references) { [linked_alert.details_url] }

        it 'does not change incident alerts list' do
          expect { execute }.not_to change { incident.reload.alert_management_alerts.to_a }
        end
      end

      context 'when linking an alert from another project' do
        let(:alert_references) { [external_alert.details_url] }

        it 'links an external alert to the incident' do
          expect { execute }
            .to change { incident.reload.alert_management_alerts.to_a }
            .from([linked_alert])
            .to match_array([linked_alert, external_alert])
        end
      end
    end

    context 'when current user does not have permission to read alerts on external project' do
      let(:current_user) { another_developer }

      context 'when linking alerts from current and external projects' do
        let(:alert_references) { [alert1.details_url, external_alert.details_url] }

        it 'links only alerts the current user can read' do
          expect { execute }
            .to change { incident.reload.alert_management_alerts.to_a }
            .from([linked_alert])
            .to match_array([linked_alert, alert1])
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module IncidentManagement
  module TimelineEvents
    class DestroyService < TimelineEvents::BaseService
      # @param timeline_event [IncidentManagement::TimelineEvent]
      # @param user [User]
      def initialize(timeline_event, user)
        @timeline_event = timeline_event
        @user = user
        @incident = timeline_event.incident
        @project = @incident.project
      end

      def execute
        return error_no_permissions unless allowed?

        if timeline_event.destroy
          add_system_note(incident, user)

          track_timeline_event('incident_management_timeline_event_deleted', project)
          success(timeline_event)
        else
          error_in_save(timeline_event)
        end
      end

      private

      attr_reader :project, :timeline_event, :user, :incident

      def add_system_note(incident, user)
        SystemNoteService.delete_timeline_event(incident, user)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe IncidentManagement::TimelineEvents::DestroyService, feature_category: :incident_management do
  let_it_be(:user_with_permissions) { create(:user) }
  let_it_be(:user_without_permissions) { create(:user) }
  let_it_be(:project) { create(:project) }
  let_it_be_with_refind(:incident) { create(:incident, project: project) }

  let!(:timeline_event) { create(:incident_management_timeline_event, incident: incident, project: project) }
  let(:current_user) { user_with_permissions }
  let(:params) { {} }
  let(:service) { described_class.new(timeline_event, current_user) }

  before_all do
    project.add_developer(user_with_permissions)
    project.add_reporter(user_without_permissions)
  end

  describe '#execute' do
    shared_examples 'error response' do |message|
      it 'has an informative message' do
        expect(execute).to be_error
        expect(execute.message).to eq(message)
      end

      it_behaves_like 'does not track incident management event', :incident_management_timeline_event_deleted
    end

    subject(:execute) { service.execute }

    context 'when current user is anonymous' do
      let(:current_user) { nil }

      it_behaves_like 'error response', 'You have insufficient permissions to manage timeline events for this incident'
    end

    context 'when user does not have permissions to remove timeline events' do
      let(:current_user) { user_without_permissions }

      it_behaves_like 'error response', 'You have insufficient permissions to manage timeline events for this incident'
    end

    context 'when an error occurs during removal' do
      before do
        allow(timeline_event).to receive(:destroy).and_return(false)
        timeline_event.errors.add(:note, 'cannot be removed')
      end

      it_behaves_like 'error response', 'Timeline text cannot be removed'
    end

    context 'with success response' do
      it 'successfully returns the timeline event', :aggregate_failures do
        expect(execute).to be_success

        result = execute.payload[:timeline_event]
        expect(result).to be_a(::IncidentManagement::TimelineEvent)
        expect(result.id).to eq(timeline_event.id)
      end

      it 'creates a system note' do
        expect { execute }.to change { incident.notes.reload.count }.by(1)
      end

      it_behaves_like 'an incident management tracked event', :incident_management_timeline_event_deleted

      it_behaves_like 'Snowplow event tracking with RedisHLL context' do
        let(:namespace) { project.namespace.reload }
        let(:category) { described_class.to_s }
        let(:user) { current_user }
        let(:action) { 'incident_management_timeline_event_deleted' }
        let(:label) { 'redis_hll_counters.incident_management.incident_management_total_unique_counts_monthly' }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module IncidentManagement
  module TimelineEvents
    # @param timeline_event [IncidentManagement::TimelineEvent]
    # @param user [User]
    # @param params [Hash]
    # @option params [string] note
    # @option params [datetime] occurred_at
    class UpdateService < TimelineEvents::BaseService
      VALIDATION_CONTEXT = :user_input

      def initialize(timeline_event, user, params)
        @timeline_event = timeline_event
        @incident = timeline_event.incident
        @project = incident.project
        @user = user
        @note = params[:note]
        @occurred_at = params[:occurred_at]
        @validation_context = VALIDATION_CONTEXT
        @timeline_event_tags = params[:timeline_event_tag_names]
      end

      def execute
        return error_no_permissions unless allowed?

        unless timeline_event_tags.nil?
          auto_create_predefined_tags(timeline_event_tags)

          # Refetches the tag objects to consider predefined tags as well
          new_tags = timeline_event
                      .project
                      .incident_management_timeline_event_tags
                      .by_names(timeline_event_tags)

          non_existing_tags = validate_tags(new_tags)

          return error(""#{_(""Following tags don't exist"")}: #{non_existing_tags}"") if non_existing_tags.any?
        end

        begin
          timeline_event_saved = update_timeline_event_and_event_tags(new_tags)
        rescue ActiveRecord::RecordInvalid
          error_in_save(timeline_event)
        end

        if timeline_event_saved
          add_system_note(timeline_event)

          track_timeline_event('incident_management_timeline_event_edited', timeline_event.project)
          success(timeline_event)
        else
          error_in_save(timeline_event)
        end
      end

      private

      attr_reader :timeline_event, :incident, :project, :user,
        :note, :occurred_at, :validation_context, :timeline_event_tags

      def update_timeline_event_and_event_tags(new_tags)
        ApplicationRecord.transaction do
          timeline_event.timeline_event_tags = new_tags unless timeline_event_tags.nil?

          timeline_event.assign_attributes(update_params)

          timeline_event.save!(context: validation_context)
        end
      end

      def update_params
        { updated_by_user: user, note: note, occurred_at: occurred_at }.compact
      end

      def add_system_note(timeline_event)
        changes = was_changed(timeline_event)
        return if changes == :none

        SystemNoteService.edit_timeline_event(timeline_event, user, was_changed: changes)
      end

      def was_changed(timeline_event)
        changes = timeline_event.previous_changes
        occurred_at_changed = changes.key?('occurred_at')
        note_changed = changes.key?('note')

        return :occurred_at_and_note if occurred_at_changed && note_changed
        return :occurred_at if occurred_at_changed
        return :note if note_changed

        :none
      end

      def validate_tags(new_tags)
        timeline_event_tags.map(&:downcase) - new_tags.map(&:name).map(&:downcase)
      end

      def allowed?
        user&.can?(:edit_incident_management_timeline_event, timeline_event)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe IncidentManagement::TimelineEvents::UpdateService, feature_category: :incident_management do
  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project) }
  let_it_be(:incident) { create(:incident, project: project) }
  let_it_be(:tag1) { create(:incident_management_timeline_event_tag, project: project, name: 'Tag 1') }
  let_it_be(:tag2) { create(:incident_management_timeline_event_tag, project: project, name: 'Tag 2') }
  let_it_be(:tag3) { create(:incident_management_timeline_event_tag, project: project, name: 'Tag 3') }

  let!(:tag_link1) do
    create(:incident_management_timeline_event_tag_link,
      timeline_event: timeline_event,
      timeline_event_tag: tag3
    )
  end

  let!(:timeline_event) { create(:incident_management_timeline_event, project: project, incident: incident) }
  let(:occurred_at) { 1.minute.ago }
  let(:params) { { note: 'Updated note', occurred_at: occurred_at } }
  let(:current_user) { user }

  describe '#execute' do
    shared_examples 'successful tag response' do
      it_behaves_like 'successful response'

      it 'adds the new tag' do
        expect { execute }.to change { timeline_event.timeline_event_tags.count }.by(1)
      end

      it 'adds the new tag link' do
        expect { execute }.to change { IncidentManagement::TimelineEventTagLink.count }.by(1)
      end

      it 'returns the new tag in response' do
        timeline_event = execute.payload[:timeline_event]

        expect(timeline_event.timeline_event_tags.pluck_names).to contain_exactly(tag1.name, tag3.name)
      end
    end

    shared_examples 'successful response' do
      it 'responds with success', :aggregate_failures do
        expect(execute).to be_success
        expect(execute.payload).to eq(timeline_event: timeline_event.reload)
      end

      it_behaves_like 'an incident management tracked event', :incident_management_timeline_event_edited

      it_behaves_like 'Snowplow event tracking with RedisHLL context' do
        let(:namespace) { project.namespace.reload }
        let(:category) { described_class.to_s }
        let(:action) { 'incident_management_timeline_event_edited' }
        let(:label) { 'redis_hll_counters.incident_management.incident_management_total_unique_counts_monthly' }
      end
    end

    shared_examples 'error response' do |message|
      it 'has an informative message' do
        expect(execute).to be_error
        expect(execute.message).to eq(message)
      end

      it 'does not update the note' do
        expect { execute }.not_to change { timeline_event.reload.note }
      end

      it_behaves_like 'does not track incident management event', :incident_management_timeline_event_edited
    end

    shared_examples 'passing the correct was_changed value' do |was_changed|
      it 'passes the correct was_changed value into SysteNoteService.edit_timeline_event' do
        expect(SystemNoteService)
          .to receive(:edit_timeline_event)
          .with(timeline_event, user, was_changed: was_changed)
          .and_call_original

        execute
      end
    end

    subject(:execute) { described_class.new(timeline_event, user, params).execute }

    context 'when user has permissions' do
      before do
        project.add_developer(user)
      end

      it_behaves_like 'successful response'

      it 'updates attributes' do
        expect { execute }.to change { timeline_event.note }.to(params[:note])
          .and change { timeline_event.occurred_at }.to(params[:occurred_at])
      end

      it 'creates a system note' do
        expect { execute }.to change { incident.notes.reload.count }.by(1)
      end

      it_behaves_like 'passing the correct was_changed value', :occurred_at_and_note

      context 'when note is nil' do
        let(:params) { { occurred_at: occurred_at, timeline_event_tag_names: [tag3.name, tag2.name] } }

        it_behaves_like 'successful response'
        it_behaves_like 'passing the correct was_changed value', :occurred_at

        it 'does not update the note' do
          expect { execute }.not_to change { timeline_event.reload.note }
        end

        it 'updates occurred_at' do
          expect { execute }.to change { timeline_event.occurred_at }.to(params[:occurred_at])
        end

        it 'updates the tags' do
          expect { execute }.to change { timeline_event.timeline_event_tags.count }.by(1)
        end
      end

      context 'when note is blank' do
        let(:params) { { note: '', occurred_at: occurred_at, timeline_event_tag_names: [tag3.name, tag2.name] } }

        it_behaves_like 'error response', ""Timeline text can't be blank""

        it 'does not add the tags as it rollsback the transaction' do
          expect { execute }.not_to change { timeline_event.timeline_event_tags.count }
        end
      end

      context 'when note is more than 280 characters long' do
        let(:params) { { note: 'n' * 281, occurred_at: occurred_at, timeline_event_tag_names: [tag3.name, tag2.name] } }

        it_behaves_like 'error response', 'Timeline text is too long (maximum is 280 characters)'

        it 'does not add the tags as it rollsback the transaction' do
          expect { execute }.not_to change { timeline_event.timeline_event_tags.count }
        end
      end

      context 'when occurred_at is nil' do
        let(:params) { { note: 'Updated note' } }

        it_behaves_like 'successful response'
        it_behaves_like 'passing the correct was_changed value', :note

        it 'updates the note' do
          expect { execute }.to change { timeline_event.note }.to(params[:note])
        end

        it 'does not update occurred_at' do
          expect { execute }.not_to change { timeline_event.reload.occurred_at }
        end
      end

      context 'when occurred_at is blank' do
        let(:params) { { note: 'Updated note', occurred_at: '', timeline_event_tag_names: [tag3.name, tag2.name] } }

        it_behaves_like 'error response', ""Occurred at can't be blank""

        it 'does not add the tags as it rollsback the transaction' do
          expect { execute }.not_to change { timeline_event.timeline_event_tags.count }
        end
      end

      context 'when both occurred_at and note is nil' do
        let(:params) { {} }

        it_behaves_like 'successful response'

        it 'does not update the note' do
          expect { execute }.not_to change { timeline_event.note }
        end

        it 'does not update occurred_at' do
          expect { execute }.not_to change { timeline_event.reload.occurred_at }
        end

        it 'does not call SysteNoteService.edit_timeline_event' do
          expect(SystemNoteService).not_to receive(:edit_timeline_event)

          execute
        end
      end

      context 'when timeline event is non-editable' do
        let!(:timeline_event) do
          create(:incident_management_timeline_event, :non_editable, project: project, incident: incident)
        end

        it_behaves_like 'error response',
          'You have insufficient permissions to manage timeline events for this incident'
      end

      context 'when timeline event tags are passed' do
        context 'when predefined tags are passed' do
          let(:params) do
            {
              note: 'Updated note',
              occurred_at: occurred_at,
              timeline_event_tag_names: ['start time', 'end time', 'response initiated']
            }
          end

          it 'returns the new tag in response' do
            timeline_event = execute.payload[:timeline_event]

            expect(timeline_event.timeline_event_tags.pluck_names).to contain_exactly(
              'Start time', 'End time', 'Response initiated')
          end

          it 'creates the predefined tags on the project' do
            execute

            expect(project.incident_management_timeline_event_tags.pluck_names).to include(
              'Start time', 'End time', 'Response initiated')
          end
        end

        context 'when they exist' do
          let(:params) do
            {
              note: 'Updated note',
              occurred_at: occurred_at,
              timeline_event_tag_names: [tag3.name, tag1.name]
            }
          end

          it_behaves_like 'successful tag response'

          context 'when tag name is of random case' do
            let(:params) do
              {
                note: 'Updated note',
                occurred_at: occurred_at,
                timeline_event_tag_names: ['tAg 3', 'TaG 1']
              }
            end

            it_behaves_like 'successful tag response'
          end

          context 'when tag is removed' do
            let(:params) { { note: 'Updated note', occurred_at: occurred_at, timeline_event_tag_names: [tag2.name] } }

            it_behaves_like 'successful response'

            it 'adds the new tag and removes the old tag' do
              # Since it adds a tag (+1) and removes old tag (-1) so next change in count in 0
              expect { execute }.to change { timeline_event.timeline_event_tags.count }.by(0)
            end

            it 'adds the new tag link and removes the old tag link' do
              # Since it adds a tag link (+1) and removes old tag link (-1) so next change in count in 0
              expect { execute }.to change { IncidentManagement::TimelineEventTagLink.count }.by(0)
            end

            it 'returns the new tag and does not contain the old tag in response' do
              timeline_event = execute.payload[:timeline_event]

              expect(timeline_event.timeline_event_tags.pluck_names).to contain_exactly(tag2.name)
            end
          end

          context 'when all assigned tags are removed' do
            let(:params) { { note: 'Updated note', occurred_at: occurred_at, timeline_event_tag_names: [] } }

            it_behaves_like 'successful response'

            it 'removes all the assigned tags' do
              expect { execute }.to change { timeline_event.timeline_event_tags.count }.by(-1)
            end

            it 'removes all the assigned tag links' do
              expect { execute }.to change { IncidentManagement::TimelineEventTagLink.count }.by(-1)
            end

            it 'does not contain any tags in response' do
              timeline_event = execute.payload[:timeline_event]

              expect(timeline_event.timeline_event_tags.pluck_names).to be_empty
            end
          end
        end

        context 'when they do not exist' do
          let(:params) do
            {
              note: 'Updated note 2',
              occurred_at: occurred_at,
              timeline_event_tag_names: ['non existing tag']
            }
          end

          it_behaves_like 'error response', ""Following tags don't exist: [\""non existing tag\""]""

          it 'does not update the note' do
            expect { execute }.not_to change { timeline_event.reload.note }
          end
        end
      end
    end

    context 'when user does not have permissions' do
      before do
        project.add_reporter(user)
      end

      it_behaves_like 'error response',
        'You have insufficient permissions to manage timeline events for this incident'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module IncidentManagement
  module TimelineEvents
    DEFAULT_ACTION = 'comment'
    DEFAULT_EDITABLE = false
    DEFAULT_AUTO_CREATED = false

    class CreateService < TimelineEvents::BaseService
      def initialize(incident, user, params)
        @project = incident.project
        @incident = incident
        @user = user
        @params = params
        @auto_created = !!params.fetch(:auto_created, DEFAULT_AUTO_CREATED)
      end

      class << self
        def create_incident(incident, user)
          note = ""@#{user.username} created the incident""
          occurred_at = incident.created_at
          action = 'issues'

          new(incident, user, note: note, occurred_at: occurred_at, action: action, auto_created: true).execute
        end

        def reopen_incident(incident, user)
          note = ""@#{user.username} reopened the incident""
          occurred_at = incident.updated_at
          action = 'issues'

          new(incident, user, note: note, occurred_at: occurred_at, action: action, auto_created: true).execute
        end

        def resolve_incident(incident, user)
          note = ""@#{user.username} resolved the incident""
          occurred_at = incident.updated_at
          action = 'status'

          new(incident, user, note: note, occurred_at: occurred_at, action: action, auto_created: true).execute
        end

        def change_incident_status(incident, user, escalation_status)
          status = escalation_status.status_name.to_s.titleize
          note = ""@#{user.username} changed the incident status to **#{status}**""
          occurred_at = incident.updated_at
          action = 'status'

          new(incident, user, note: note, occurred_at: occurred_at, action: action, auto_created: true).execute
        end

        def change_severity(incident, user)
          severity_label = IssuableSeverity::SEVERITY_LABELS[incident.severity.to_sym]
          note = ""@#{user.username} changed the incident severity to **#{severity_label}**""
          occurred_at = incident.updated_at
          action = 'severity'

          new(incident, user, note: note, occurred_at: occurred_at, action: action, auto_created: true).execute
        end

        def change_labels(incident, user, added_labels: [], removed_labels: [])
          return if Feature.disabled?(:incident_timeline_events_from_labels, incident.project)

          if added_labels.blank? && removed_labels.blank?
            return ServiceResponse.error(message: _('There are no changed labels'))
          end

          labels_note = -> (verb, labels) {
            ""#{verb} #{labels.map(&:to_reference).join(' ')} #{'label'.pluralize(labels.count)}"" if labels.present?
          }

          added_note = labels_note.call('added', added_labels)
          removed_note = labels_note.call('removed', removed_labels)
          note = ""@#{user.username} #{[added_note, removed_note].compact.join(' and ')}""
          occurred_at = incident.updated_at
          action = 'label'

          new(incident, user, note: note, occurred_at: occurred_at, action: action, auto_created: true).execute
        end
      end

      def execute
        return error_no_permissions unless allowed?

        timeline_event_params = {
          project: project,
          incident: incident,
          author: user,
          note: params[:note],
          action: params.fetch(:action, DEFAULT_ACTION),
          note_html: params[:note_html].presence || params[:note],
          occurred_at: params[:occurred_at],
          promoted_from_note: params[:promoted_from_note],
          editable: params.fetch(:editable, DEFAULT_EDITABLE)
        }

        non_existing_tags = validate_tags(project, params[:timeline_event_tag_names])

        return error(""#{_(""Following tags don't exist"")}: #{non_existing_tags}"") unless non_existing_tags.empty?

        timeline_event = IncidentManagement::TimelineEvent.new(timeline_event_params)

        if timeline_event.save(context: validation_context)
          add_system_note(timeline_event)

          create_timeline_event_tag_links(timeline_event, params[:timeline_event_tag_names])

          track_timeline_event(""incident_management_timeline_event_created"", project)

          success(timeline_event)
        else
          error_in_save(timeline_event)
        end
      end

      private

      attr_reader :project, :user, :incident, :params, :auto_created

      def allowed?
        return true if auto_created

        super
      end

      def add_system_note(timeline_event)
        return if auto_created

        SystemNoteService.add_timeline_event(timeline_event)
      end

      def validation_context
        :user_input if !auto_created && params[:promoted_from_note].blank?
      end

      def create_timeline_event_tag_links(timeline_event, tag_names)
        return unless tag_names&.any?

        auto_create_predefined_tags(tag_names)

        # Refetches the tag objects to consider predefined tags as well
        tags = project.incident_management_timeline_event_tags.by_names(tag_names)

        tag_links = tags.select(:id).map do |tag|
          {
            timeline_event_id: timeline_event.id,
            timeline_event_tag_id: tag.id,
            created_at: DateTime.current
          }
        end

        IncidentManagement::TimelineEventTagLink.insert_all(tag_links) if tag_links.any?
      end

      def validate_tags(project, tag_names)
        return [] unless tag_names&.any?

        predefined_tags = TimelineEventTag::PREDEFINED_TAGS.map(&:downcase)

        tag_names_downcased = tag_names.map(&:downcase)

        tags = project.incident_management_timeline_event_tags.by_names(tag_names).pluck_names.map(&:downcase)

        # remove tags from given tag_names and also remove predefined tags which can be auto created
        tag_names_downcased - tags - predefined_tags
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe IncidentManagement::TimelineEvents::CreateService, feature_category: :incident_management do
  let_it_be(:user_with_permissions) { create(:user) }
  let_it_be(:user_without_permissions) { create(:user) }
  let_it_be(:project) { create(:project) }
  let_it_be_with_refind(:incident) { create(:incident, project: project) }
  let_it_be(:comment) { create(:note, project: project, noteable: incident) }
  let_it_be(:timeline_event_tag) do
    create(:incident_management_timeline_event_tag, name: 'Test tag 1', project: project)
  end

  let(:args) do
    {
      note: 'note',
      occurred_at: Time.current,
      action: 'new comment',
      promoted_from_note: comment
    }
  end

  let(:editable) { false }
  let(:current_user) { user_with_permissions }
  let(:service) { described_class.new(incident, current_user, args) }

  before_all do
    project.add_developer(user_with_permissions)
    project.add_reporter(user_without_permissions)
  end

  describe '#execute' do
    shared_examples 'error response' do |message|
      it 'has an informative message' do
        expect(execute).to be_error
        expect(execute.message).to eq(message)
      end

      it_behaves_like 'does not track incident management event', :incident_management_timeline_event_created
    end

    shared_examples 'success response' do
      it 'has timeline event', :aggregate_failures do
        expect(execute).to be_success

        result = execute.payload[:timeline_event]
        expect(result).to be_a(::IncidentManagement::TimelineEvent)
        expect(result.author).to eq(current_user)
        expect(result.incident).to eq(incident)
        expect(result.project).to eq(project)
        expect(result.note).to eq(args[:note])
        expect(result.promoted_from_note).to eq(comment)
        expect(result.editable).to eq(editable)
      end

      it_behaves_like 'an incident management tracked event', :incident_management_timeline_event_created

      it_behaves_like 'Snowplow event tracking with RedisHLL context' do
        let(:namespace) { project.namespace.reload }
        let(:category) { described_class.to_s }
        let(:user) { current_user }
        let(:action) { 'incident_management_timeline_event_created' }
        let(:label) { 'redis_hll_counters.incident_management.incident_management_total_unique_counts_monthly' }
      end
    end

    subject(:execute) { service.execute }

    context 'when current user is blank' do
      let(:current_user) { nil }

      it_behaves_like 'error response', 'You have insufficient permissions to manage timeline events for this incident'
    end

    context 'when user does not have permissions to create timeline events' do
      let(:current_user) { user_without_permissions }

      it_behaves_like 'error response', 'You have insufficient permissions to manage timeline events for this incident'
    end

    context 'when error occurs during creation' do
      let(:args) { {} }

      it_behaves_like 'error response', ""Occurred at can't be blank and Timeline text can't be blank""
    end

    context 'with default action' do
      let(:args) { { note: 'note', occurred_at: Time.current, promoted_from_note: comment } }

      it_behaves_like 'success response'

      it 'matches the default action', :aggregate_failures do
        result = execute.payload[:timeline_event]

        expect(result.action).to eq(IncidentManagement::TimelineEvents::DEFAULT_ACTION)
      end

      it 'creates a system note' do
        expect { execute }.to change { incident.notes.reload.count }.by(1)
      end

      context 'with auto_created param' do
        let(:args) do
          {
            note: 'note',
            occurred_at: Time.current,
            action: 'new comment',
            promoted_from_note: comment,
            auto_created: auto_created
          }
        end

        context 'when auto_created is true' do
          let(:auto_created) { true }

          it 'does not create a system note' do
            expect { execute }.not_to change { incident.notes.reload.count }
          end

          context 'when user does not have permissions' do
            let(:current_user) { user_without_permissions }

            it_behaves_like 'success response'
          end
        end

        context 'when auto_created is false' do
          let(:auto_created) { false }

          it 'creates a system note' do
            expect { execute }.to change { incident.notes.reload.count }.by(1)
          end
        end
      end
    end

    context 'with non_default action' do
      it_behaves_like 'success response'

      it 'matches the action from arguments', :aggregate_failures do
        result = execute.payload[:timeline_event]

        expect(result.action).to eq(args[:action])
      end
    end

    context 'when timeline event tag names are passed' do
      let(:args) do
        {
          note: 'note',
          occurred_at: Time.current,
          action: 'new comment',
          promoted_from_note: comment,
          timeline_event_tag_names: ['Test tag 1']
        }
      end

      it_behaves_like 'success response'

      it 'matches the tag name' do
        result = execute.payload[:timeline_event]
        expect(result.timeline_event_tags.first).to eq(timeline_event_tag)
      end

      context 'when predefined tags are passed' do
        let(:args) do
          {
            note: 'note',
            occurred_at: Time.current,
            action: 'new comment',
            promoted_from_note: comment,
            timeline_event_tag_names: ['start time', 'end time', 'Impact mitigated']
          }
        end

        it_behaves_like 'success response'

        it 'matches the two tags on the event and creates on project' do
          result = execute.payload[:timeline_event]

          expect(result.timeline_event_tags.count).to eq(3)
          expect(result.timeline_event_tags.by_names(['Start time', 'End time', 'Impact mitigated']).pluck_names)
            .to match_array(['Start time', 'End time', 'Impact mitigated'])
          expect(project.incident_management_timeline_event_tags.pluck_names)
            .to include('Start time', 'End time', 'Impact mitigated')
        end
      end

      context 'when invalid tag names are passed' do
        let(:args) do
          {
            note: 'note',
            occurred_at: Time.current,
            action: 'new comment',
            promoted_from_note: comment,
            timeline_event_tag_names: ['some other time']
          }
        end

        it_behaves_like 'error response', ""Following tags don't exist: [\""some other time\""]""

        it 'does not create timeline event' do
          expect { execute }.not_to change(IncidentManagement::TimelineEvent, :count)
        end
      end
    end

    context 'with editable param' do
      let(:args) do
        {
          note: 'note',
          occurred_at: Time.current,
          action: 'new comment',
          promoted_from_note: comment,
          editable: editable
        }
      end

      context 'when editable is true' do
        let(:editable) { true }

        it_behaves_like 'success response'
      end

      context 'when editable is false' do
        let(:editable) { false }

        it_behaves_like 'success response'
      end
    end

    it 'successfully creates a database record', :aggregate_failures do
      expect { execute }.to change { ::IncidentManagement::TimelineEvent.count }.by(1)
    end

    context 'when note is more than 280 characters long' do
      let(:args) do
        {
          note: 'a' * 281,
          occurred_at: Time.current,
          action: 'new comment',
          promoted_from_note: comment,
          auto_created: auto_created
        }
      end

      let(:auto_created) { false }

      context 'when was not promoted from note' do
        let(:comment) { nil }

        context 'when auto_created is true' do
          let(:auto_created) { true }

          it_behaves_like 'success response'
        end

        context 'when auto_created is false' do
          it_behaves_like 'error response', 'Timeline text is too long (maximum is 280 characters)'
        end
      end

      context 'when promoted from note' do
        it_behaves_like 'success response'
      end
    end
  end

  describe 'automatically created timeline events' do
    shared_examples 'successfully created timeline event' do
      it 'creates a timeline event', :aggregate_failures do
        expect(execute).to be_success

        result = execute.payload[:timeline_event]
        expect(result).to be_a(::IncidentManagement::TimelineEvent)
        expect(result.author).to eq(current_user)
        expect(result.incident).to eq(incident)
        expect(result.project).to eq(project)
        expect(result.note).to eq(expected_note)
        expect(result.editable).to eq(false)
        expect(result.action).to eq(expected_action)
      end

      it_behaves_like 'an incident management tracked event', :incident_management_timeline_event_created

      it_behaves_like 'Snowplow event tracking with RedisHLL context' do
        let(:namespace) { project.namespace.reload }
        let(:category) { described_class.to_s }
        let(:user) { current_user }
        let(:action) { 'incident_management_timeline_event_created' }
        let(:label) { 'redis_hll_counters.incident_management.incident_management_total_unique_counts_monthly' }
      end

      it 'successfully creates a database record', :aggregate_failures do
        expect { execute }.to change { ::IncidentManagement::TimelineEvent.count }.by(1)
      end

      it 'does not create a system note' do
        expect { execute }.not_to change { incident.notes.reload.count }
      end
    end

    describe '.create_incident' do
      subject(:execute) { described_class.create_incident(incident, current_user) }

      let(:expected_note) { ""@#{current_user.username} created the incident"" }
      let(:expected_action) { 'issues' }

      it_behaves_like 'successfully created timeline event'
    end

    describe '.reopen_incident' do
      subject(:execute) { described_class.reopen_incident(incident, current_user) }

      let(:expected_note) { ""@#{current_user.username} reopened the incident"" }
      let(:expected_action) { 'issues' }

      it_behaves_like 'successfully created timeline event'
    end

    describe '.resolve_incident' do
      subject(:execute) { described_class.resolve_incident(incident, current_user) }

      let(:expected_note) { ""@#{current_user.username} resolved the incident"" }
      let(:expected_action) { 'status' }

      it_behaves_like 'successfully created timeline event'
    end

    describe '.change_incident_status' do
      subject(:execute) { described_class.change_incident_status(incident, current_user, escalation_status) }

      let(:escalation_status) do
        instance_double('IncidentManagement::IssuableEscalationStatus', status_name: 'acknowledged')
      end

      let(:expected_note) { ""@#{current_user.username} changed the incident status to **Acknowledged**"" }
      let(:expected_action) { 'status' }

      it_behaves_like 'successfully created timeline event'
    end

    describe '.change_severity' do
      subject(:execute) { described_class.change_severity(incident, current_user) }

      let_it_be(:severity) { create(:issuable_severity, severity: :critical, issue: incident) }

      let(:expected_note) { ""@#{current_user.username} changed the incident severity to **Critical - S1**"" }
      let(:expected_action) { 'severity' }

      it_behaves_like 'successfully created timeline event'
    end

    describe '.change_labels' do
      subject(:execute) do
        described_class.change_labels(incident, current_user, added_labels: added, removed_labels: removed)
      end

      let_it_be(:labels) { create_list(:label, 4, project: project) }

      let(:expected_action) { 'label' }

      context 'when there are neither added nor removed labels' do
        let(:added) { [] }
        let(:removed) { [] }

        it 'responds with error', :aggregate_failures do
          expect(execute).to be_error
          expect(execute.message).to eq(_('There are no changed labels'))
        end

        it 'does not create timeline event' do
          expect { execute }.not_to change { incident.incident_management_timeline_events.count }
        end
      end

      context 'when there are only added labels' do
        let(:added) { [labels[0], labels[1]] }
        let(:removed) { [] }

        let(:expected_note) { ""@#{current_user.username} added #{added.map(&:to_reference).join(' ')} labels"" }

        it_behaves_like 'successfully created timeline event'
      end

      context 'when there are only removed labels' do
        let(:added) { [] }
        let(:removed) { [labels[2], labels[3]] }

        let(:expected_note) { ""@#{current_user.username} removed #{removed.map(&:to_reference).join(' ')} labels"" }

        it_behaves_like 'successfully created timeline event'
      end

      context 'when there are both added and removed labels' do
        let(:added) { [labels[0], labels[1]] }
        let(:removed) { [labels[2], labels[3]] }

        let(:expected_note) do
          added_note = ""added #{added.map(&:to_reference).join(' ')} labels""
          removed_note = ""removed #{removed.map(&:to_reference).join(' ')} labels""

          ""@#{current_user.username} #{added_note} and #{removed_note}""
        end

        it_behaves_like 'successfully created timeline event'
      end

      context 'when there is a single added and single removed labels' do
        let(:added) { [labels[0]] }
        let(:removed) { [labels[3]] }

        let(:expected_note) do
          added_note = ""added #{added.first.to_reference} label""
          removed_note = ""removed #{removed.first.to_reference} label""

          ""@#{current_user.username} #{added_note} and #{removed_note}""
        end

        it_behaves_like 'successfully created timeline event'
      end

      context 'when feature flag is disabled' do
        let(:added) { [labels[0], labels[1]] }
        let(:removed) { [labels[2], labels[3]] }

        before do
          stub_feature_flags(incident_timeline_events_from_labels: false)
        end

        it 'does not create timeline event' do
          expect { execute }.not_to change { incident.incident_management_timeline_events.count }
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module IncidentManagement
  module IssuableEscalationStatuses
    class AfterUpdateService < ::BaseProjectService
      def initialize(issuable, current_user, **params)
        @issuable = issuable
        @escalation_status = issuable.escalation_status

        super(project: issuable.project, current_user: current_user, params: params)
      end

      def execute
        after_update

        ServiceResponse.success(payload: { escalation_status: escalation_status })
      end

      private

      attr_reader :issuable, :escalation_status

      def after_update
        add_status_system_note
        add_timeline_event
      end

      def add_status_system_note
        return unless escalation_status.status_previously_changed?

        SystemNoteService.change_incident_status(issuable, current_user, params[:status_change_reason])
      end

      def add_timeline_event
        return unless escalation_status.status_previously_changed?

        IncidentManagement::TimelineEvents::CreateService
          .change_incident_status(issuable, current_user, escalation_status)
      end
    end
  end
end

::IncidentManagement::IssuableEscalationStatuses::AfterUpdateService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe IncidentManagement::IssuableEscalationStatuses::AfterUpdateService,
  feature_category: :incident_management do
  let_it_be(:current_user) { create(:user) }
  let_it_be(:escalation_status, reload: true) { create(:incident_management_issuable_escalation_status, :triggered) }
  let_it_be(:issue, reload: true) { escalation_status.issue }
  let_it_be(:project) { issue.project }

  let(:service) { described_class.new(issue, current_user) }

  subject(:result) do
    issue.update!(incident_management_issuable_escalation_status_attributes: update_params)
    service.execute
  end

  before do
    issue.project.add_developer(current_user)
  end

  context 'with status attributes' do
    let(:status_event) { :acknowledge }
    let(:update_params) { { status_event: status_event } }

    it 'adds a status change system note' do
      expect { result }.to change { issue.reload.notes.count }.by(1)
    end

    it 'adds a status change timeline event' do
      expect(IncidentManagement::TimelineEvents::CreateService)
        .to receive(:change_incident_status)
        .with(issue, current_user, escalation_status)
        .and_call_original

      expect { result }.to change { issue.reload.incident_management_timeline_events.count }.by(1)
    end
  end

  context 'with non-status attributes' do
    let(:update_params) { { updated_at: Time.current } }

    it 'does not add a status change system note or timeline event' do
      expect { result }
        .to not_change { issue.reload.notes.count }
        .and not_change { issue.reload.incident_management_timeline_events.count }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module IncidentManagement
  module IssuableEscalationStatuses
    class BuildService < ::BaseProjectService
      def initialize(issue)
        @issue = issue

        super(project: issue.project)
      end

      def execute
        issue.escalation_status || issue.build_incident_management_issuable_escalation_status
      end

      private

      attr_reader :issue
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe IncidentManagement::IssuableEscalationStatuses::BuildService, feature_category: :incident_management do
  let_it_be(:project) { create(:project) }
  let_it_be(:incident, reload: true) { create(:incident, project: project) }

  let(:service) { described_class.new(incident) }

  subject(:execute) { service.execute }

  it_behaves_like 'initializes new escalation status with expected attributes'
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module IncidentManagement
  module IssuableEscalationStatuses
    class PrepareUpdateService < ::BaseProjectService
      include Gitlab::Utils::StrongMemoize

      SUPPORTED_PARAMS = %i[status].freeze

      def initialize(issuable, current_user, params)
        @issuable = issuable
        @param_errors = []

        super(project: issuable.project, current_user: current_user, params: params)
      end

      def execute
        return availability_error unless available?

        filter_unsupported_params
        filter_attributes
        filter_redundant_params

        return invalid_param_error if param_errors.any?

        ServiceResponse.success(payload: { escalation_status: params })
      end

      private

      attr_reader :issuable, :param_errors

      def available?
        issuable.supports_escalation? && user_has_permissions?
      end

      def user_has_permissions?
        current_user&.can?(:update_escalation_status, issuable)
      end

      def escalation_status
        strong_memoize(:escalation_status) do
          issuable.escalation_status || BuildService.new(issuable).execute
        end
      end

      def filter_unsupported_params
        params.slice!(*supported_params)
      end

      def supported_params
        SUPPORTED_PARAMS
      end

      def filter_attributes
        filter_status
      end

      def filter_status
        status = params.delete(:status)
        return unless status

        status_event = escalation_status.status_event_for(status)
        add_param_error(:status) && return unless status_event

        params[:status_event] = status_event
      end

      def filter_redundant_params
        params.delete_if do |key, value|
          current_params.key?(key) && current_params[key] == value
        end
      end

      def current_params
        strong_memoize(:current_params) do
          {
            status_event: escalation_status.status_event_for(escalation_status.status_name)
          }
        end
      end

      def add_param_error(param)
        param_errors << param
      end

      def availability_error
        ServiceResponse.error(message: 'Escalation status updates are not available for this issue, user, or project.')
      end

      def invalid_param_error
        ServiceResponse.error(message: ""Invalid value was provided for parameters: #{param_errors.join(', ')}"")
      end
    end
  end
end

::IncidentManagement::IssuableEscalationStatuses::PrepareUpdateService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe IncidentManagement::IssuableEscalationStatuses::PrepareUpdateService, factory_default: :keep,
  feature_category: :incident_management do
  let_it_be(:project) { create_default(:project) }
  let_it_be(:escalation_status) { create(:incident_management_issuable_escalation_status, :triggered) }
  let_it_be(:user_with_permissions) { create(:user) }

  let(:current_user) { user_with_permissions }
  let(:issue) { escalation_status.issue }
  let(:status) { :acknowledged }
  let(:params) { { status: status } }
  let(:service) { described_class.new(issue, current_user, params) }

  subject(:result) { service.execute }

  before do
    issue.project.add_developer(user_with_permissions)
  end

  shared_examples 'successful response' do |payload|
    it 'returns valid parameters which can be used to update the issue' do
      expect(result).to be_success
      expect(result.payload).to eq(escalation_status: payload)
    end
  end

  shared_examples 'error response' do |message|
    specify do
      expect(result).to be_error
      expect(result.message).to eq(message)
    end
  end

  shared_examples 'availability error response' do
    include_examples 'error response', 'Escalation status updates are not available for this issue, user, or project.'
  end

  shared_examples 'invalid params error response' do
    include_examples 'error response', 'Invalid value was provided for parameters: status'
  end

  it_behaves_like 'successful response', { status_event: :acknowledge }

  context 'when user is anonymous' do
    let(:current_user) { nil }

    it_behaves_like 'availability error response'
  end

  context 'when user does not have permissions' do
    let(:current_user) { create(:user) }

    it_behaves_like 'availability error response'
  end

  context 'when called with an unsupported issue type' do
    let(:issue) { create(:issue) }

    it_behaves_like 'availability error response'
  end

  context 'when an IssuableEscalationStatus record for the issue does not exist' do
    let(:issue) { create(:incident) }

    it_behaves_like 'successful response', { status_event: :acknowledge }

    it 'initializes an issuable escalation status record' do
      expect { result }.not_to change(::IncidentManagement::IssuableEscalationStatus, :count)
      expect(issue.escalation_status).to be_present
    end
  end

  context 'when called nil params' do
    let(:params) { nil }

    it 'raises an exception' do
      expect { result }.to raise_error NoMethodError
    end
  end

  context 'when called without params' do
    let(:params) { {} }

    it_behaves_like 'successful response', {}
  end

  context 'when called with unsupported params' do
    let(:params) { { escalations_started_at: Time.current } }

    it_behaves_like 'successful response', {}
  end

  context 'with status param' do
    context 'when status matches the current status' do
      let(:params) { { status: :triggered } }

      it_behaves_like 'successful response', {}
    end

    context 'when status is unsupported' do
      let(:params) { { status: :mitigated } }

      it_behaves_like 'invalid params error response'
    end

    context 'when status is a String' do
      let(:params) { { status: 'acknowledged' } }

      it_behaves_like 'successful response', { status_event: :acknowledge }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module IncidentManagement
  module IssuableEscalationStatuses
    class CreateService < ::BaseProjectService
      def initialize(issue)
        @issue = issue

        super(project: issue.project)
      end

      def execute
        escalation_status = BuildService.new(issue).execute

        if escalation_status.save
          ServiceResponse.success(payload: { escalation_status: escalation_status })
        else
          ServiceResponse.error(message: escalation_status.errors&.full_messages)
        end
      end

      private

      attr_reader :issue
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe IncidentManagement::IssuableEscalationStatuses::CreateService, feature_category: :incident_management do
  let_it_be(:project) { create(:project) }

  let(:incident) { create(:incident, project: project) }
  let(:service) { described_class.new(incident) }

  subject(:execute) { service.execute }

  it 'creates an escalation status for the incident with no policy set' do
    expect { execute }.to change { incident.reload.escalation_status }.from(nil)

    status = incident.escalation_status

    expect(status.policy_id).to eq(nil)
    expect(status.escalations_started_at).to eq(nil)
    expect(status.status_name).to eq(:triggered)
  end

  context 'existing escalation status' do
    let!(:existing_status) { create(:incident_management_issuable_escalation_status, issue: incident) }

    it 'exits without changing anything' do
      expect { execute }.not_to change { incident.reload.escalation_status }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module IncidentManagement
  module PagerDuty
    class ProcessWebhookService < ::BaseProjectService
      include Gitlab::Utils::StrongMemoize
      include IncidentManagement::Settings

      # https://developer.pagerduty.com/docs/webhooks/webhook-behavior/#size-limit
      PAGER_DUTY_PAYLOAD_SIZE_LIMIT = 55.kilobytes

      # https://developer.pagerduty.com/docs/db0fa8c8984fc-overview#event-types
      PAGER_DUTY_PROCESSABLE_EVENT_TYPES = %w[incident.triggered].freeze

      def initialize(project, payload)
        super(project: project)

        @payload = payload
      end

      def execute(token)
        return forbidden unless webhook_setting_active?
        return unauthorized unless valid_token?(token)
        return bad_request unless valid_payload_size?

        process_incidents

        accepted
      end

      private

      attr_reader :payload

      def process_incidents
        event = pager_duty_processable_event
        return unless event

        ::IncidentManagement::PagerDuty::ProcessIncidentWorker
          .perform_async(project.id, event['incident'])
      end

      def pager_duty_processable_event
        strong_memoize(:pager_duty_processable_event) do
          event = ::PagerDuty::WebhookPayloadParser.call(payload.to_h)

          event if event['event'].to_s.in?(PAGER_DUTY_PROCESSABLE_EVENT_TYPES)
        end
      end

      def webhook_setting_active?
        incident_management_setting.pagerduty_active?
      end

      def valid_token?(token)
        token && incident_management_setting.pagerduty_token == token
      end

      def valid_payload_size?
        Gitlab::Utils::DeepSize.new(payload, max_size: PAGER_DUTY_PAYLOAD_SIZE_LIMIT).valid?
      end

      def accepted
        ServiceResponse.success(http_status: :accepted)
      end

      def forbidden
        ServiceResponse.error(message: 'Forbidden', http_status: :forbidden)
      end

      def unauthorized
        ServiceResponse.error(message: 'Unauthorized', http_status: :unauthorized)
      end

      def bad_request
        ServiceResponse.error(message: 'Bad Request', http_status: :bad_request)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe IncidentManagement::PagerDuty::ProcessWebhookService, feature_category: :incident_management do
  let_it_be(:project, reload: true) { create(:project) }

  describe '#execute' do
    shared_examples 'does not process incidents' do
      it 'does not process incidents' do
        expect(::IncidentManagement::PagerDuty::ProcessIncidentWorker).not_to receive(:perform_async)

        execute
      end
    end

    let(:webhook_payload) { Gitlab::Json.parse(fixture_file('pager_duty/webhook_incident_trigger.json')) }
    let(:token) { nil }

    subject(:execute) { described_class.new(project, webhook_payload).execute(token) }

    context 'when PagerDuty webhook setting is active' do
      let_it_be(:incident_management_setting) { create(:project_incident_management_setting, project: project, pagerduty_active: true) }

      context 'when token is valid' do
        let(:token) { incident_management_setting.pagerduty_token }

        context 'when webhook payload has acceptable size' do
          it 'responds with Accepted' do
            result = execute

            expect(result).to be_success
            expect(result.http_status).to eq(:accepted)
          end

          it 'processes issues' do
            incident_payload = ::PagerDuty::WebhookPayloadParser.call(webhook_payload)['incident']

            expect(::IncidentManagement::PagerDuty::ProcessIncidentWorker)
              .to receive(:perform_async)
              .with(project.id, incident_payload)
              .once

            execute
          end
        end

        context 'when webhook payload is too big' do
          let(:deep_size) { instance_double(Gitlab::Utils::DeepSize, valid?: false) }

          before do
            allow(Gitlab::Utils::DeepSize)
              .to receive(:new)
              .with(webhook_payload, max_size: described_class::PAGER_DUTY_PAYLOAD_SIZE_LIMIT)
              .and_return(deep_size)
          end

          it 'responds with Bad Request' do
            result = execute

            expect(result).to be_error
            expect(result.http_status).to eq(:bad_request)
          end

          it_behaves_like 'does not process incidents'
        end

        context 'when webhook payload is blank' do
          let(:webhook_payload) { nil }

          it 'responds with Accepted' do
            result = execute

            expect(result).to be_success
            expect(result.http_status).to eq(:accepted)
          end

          it_behaves_like 'does not process incidents'
        end
      end

      context 'when token is invalid' do
        let(:token) { 'invalid-token' }

        it 'responds with Unauthorized' do
          result = execute

          expect(result).to be_error
          expect(result.http_status).to eq(:unauthorized)
        end

        it_behaves_like 'does not process incidents'
      end
    end

    context 'when both tokens are nil' do
      let_it_be(:incident_management_setting) { create(:project_incident_management_setting, project: project, pagerduty_active: false) }

      let(:token) { nil }

      before do
        incident_management_setting.update_column(:pagerduty_active, true)
      end

      it 'responds with Unauthorized' do
        result = execute

        expect(result).to be_error
        expect(result.http_status).to eq(:unauthorized)
      end

      it_behaves_like 'does not process incidents'
    end

    context 'when PagerDuty webhook setting is not active' do
      let_it_be(:incident_management_setting) { create(:project_incident_management_setting, project: project, pagerduty_active: false) }

      it 'responds with Forbidden' do
        result = execute

        expect(result).to be_error
        expect(result.http_status).to eq(:forbidden)
      end

      it_behaves_like 'does not process incidents'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module IncidentManagement
  module PagerDuty
    class CreateIncidentIssueService < BaseService
      include IncidentManagement::Settings

      def initialize(project, incident_payload)
        super(project, Users::Internal.alert_bot, incident_payload)
      end

      def execute
        return forbidden unless webhook_available?

        create_incident
      end

      private

      alias_method :incident_payload, :params

      def create_incident
        ::IncidentManagement::Incidents::CreateService.new(
          project,
          current_user,
          title: issue_title,
          description: issue_description
        ).execute
      end

      def webhook_available?
        incident_management_setting.pagerduty_active?
      end

      def forbidden
        ServiceResponse.error(message: 'Forbidden', http_status: :forbidden)
      end

      def issue_title
        incident_payload['title']
      end

      def issue_description
        Gitlab::IncidentManagement::PagerDuty::IncidentIssueDescription.new(incident_payload).to_s
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe IncidentManagement::PagerDuty::CreateIncidentIssueService, feature_category: :incident_management do
  let_it_be(:project, reload: true) { create(:project) }
  let_it_be(:user) { Users::Internal.alert_bot }

  let(:webhook_payload) { Gitlab::Json.parse(fixture_file('pager_duty/webhook_incident_trigger.json')) }
  let(:parsed_payload) { ::PagerDuty::WebhookPayloadParser.call(webhook_payload) }
  let(:incident_payload) { parsed_payload['incident'] }

  subject(:execute) { described_class.new(project, incident_payload).execute }

  describe '#execute' do
    context 'when PagerDuty webhook setting is active' do
      let_it_be(:incident_management_setting) { create(:project_incident_management_setting, project: project, pagerduty_active: true) }

      context 'when issue can be created' do
        it 'creates a new issue' do
          expect { execute }.to change(Issue, :count).by(1)
        end

        it 'responds with success' do
          response = execute

          expect(response).to be_success
          expect(response.payload[:issue]).to be_kind_of(Issue)
        end

        it 'the issue author is Alert bot' do
          expect(execute.payload[:issue].author).to eq(Users::Internal.alert_bot)
        end

        it 'issue has a correct title' do
          expect(execute.payload[:issue].title).to eq(incident_payload['title'])
        end

        it 'issue has a correct description' do
          markdown_line_break = '  '

          expect(execute.payload[:issue].description).to eq(
            <<~MARKDOWN.chomp
              **Incident:** [[FILTERED]](https://gitlab-1.pagerduty.com/incidents/Q1XZUF87W1HB5A)#{markdown_line_break}
              **Incident number:** 2#{markdown_line_break}
              **Urgency:** high#{markdown_line_break}
              **Status:** triggered#{markdown_line_break}
              **Incident key:** [FILTERED]#{markdown_line_break}
              **Created at:** 30 November 2022, 8:46AM (UTC)#{markdown_line_break}
              **Assignees:** [Rajendra Kadam](https://gitlab-1.pagerduty.com/users/PIN0B5C)#{markdown_line_break}
              **Impacted service:** [Test service](https://gitlab-1.pagerduty.com/services/PK6IKMT)
            MARKDOWN
          )
        end
      end

      context 'when the payload does not contain a title' do
        let(:incident_payload) { {} }

        it 'does not create a GitLab issue' do
          expect { execute }.not_to change(Issue, :count)
        end

        it 'responds with error' do
          expect(execute).to be_error
          expect(execute.errors).to contain_exactly(""Title can't be blank"")
        end
      end
    end

    context 'when PagerDuty webhook setting is not active' do
      let_it_be(:incident_management_setting) { create(:project_incident_management_setting, project: project, pagerduty_active: false) }

      it 'does not create a GitLab issue' do
        expect { execute }.not_to change(Issue, :count)
      end

      it 'responds with forbidden' do
        expect(execute).to be_error
        expect(execute.http_status).to eq(:forbidden)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module IncidentManagement
  module Incidents
    class CreateService < ::BaseProjectService
      ISSUE_TYPE = 'incident'

      def initialize(project, current_user, title:, description:, severity: IssuableSeverity::DEFAULT, alert: nil)
        super(project: project, current_user: current_user)

        @title = title
        @description = description
        @severity = severity
        @alert = alert
      end

      def execute
        create_result = Issues::CreateService.new(
          container: project,
          current_user: current_user,
          params: {
            title: title,
            description: description,
            issue_type: ISSUE_TYPE,
            severity: severity,
            alert_management_alerts: [alert].compact
          },
          perform_spam_check: false
        ).execute

        if alert
          return error(alert.errors.full_messages, create_result[:issue]) unless alert.valid?
        end

        create_result
      end

      private

      attr_reader :title, :description, :severity, :alert

      def error(message, issue = nil)
        ServiceResponse.error(payload: { issue: issue }, message: message)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe IncidentManagement::Incidents::CreateService, feature_category: :incident_management do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { Users::Internal.alert_bot }

  let(:description) { 'Incident description' }

  describe '#execute' do
    subject(:create_incident) { described_class.new(project, user, title: title, description: description).execute }

    context 'when incident has title and description' do
      let(:title) { 'Incident title' }
      let(:new_issue) { Issue.last! }

      it 'responds with success' do
        expect(create_incident).to be_success
      end

      it 'creates an incident issue' do
        expect { create_incident }.to change(Issue, :count).by(1)
      end

      it 'created issue has correct attributes', :aggregate_failures do
        create_incident

        expect(new_issue.title).to eq(title)
        expect(new_issue.description).to eq(description)
        expect(new_issue.author).to eq(user)
      end

      it_behaves_like 'incident issue' do
        before do
          create_incident
        end

        let(:issue) { new_issue }
      end

      context 'with default severity' do
        it 'sets the correct severity level to ""unknown""' do
          create_incident
          expect(new_issue.severity).to eq(IssuableSeverity::DEFAULT)
        end
      end

      context 'with severity' do
        using RSpec::Parameterized::TableSyntax

        subject(:create_incident) { described_class.new(project, user, title: title, description: description, severity: severity).execute }

        where(:severity, :incident_severity) do
          'critical' | 'critical'
          'high'     | 'high'
          'medium'   | 'medium'
          'low'      | 'low'
          'unknown'  | 'unknown'
        end

        with_them do
          it 'sets the correct severity level' do
            create_incident
            expect(new_issue.severity).to eq(incident_severity)
          end
        end
      end

      context 'with an alert' do
        subject(:create_incident) { described_class.new(project, user, title: title, description: description, alert: alert).execute }

        context 'when the alert is valid' do
          let(:alert) { create(:alert_management_alert, project: project) }

          it 'associates the alert with the incident' do
            expect(create_incident[:issue].reload.alert_management_alerts).to match_array([alert])
          end
        end

        context 'when the alert is not valid' do
          let(:alert) { create(:alert_management_alert, :with_validation_errors, project: project) }

          it 'does not associate the alert with the incident' do
            expect(create_incident[:issue].reload.alert_management_alerts).to be_empty
          end
        end
      end
    end

    context 'when incident has no title' do
      let(:title) { '' }

      it 'does not create an issue' do
        expect { create_incident }.not_to change(Issue, :count)
      end

      it 'responds with errors' do
        expect(create_incident).to be_error
        expect(create_incident.errors).to contain_exactly(""Title can't be blank"")
      end

      it 'result payload contains an Issue object' do
        expect(create_incident.payload[:issue]).to be_kind_of(Issue)
      end

      context 'with alert' do
        let(:alert) { create(:alert_management_alert, project: project) }

        subject(:create_incident) { described_class.new(project, user, title: title, description: description, alert: alert).execute }

        context 'the alert prevents the issue from saving' do
          let(:alert) { create(:alert_management_alert, :with_validation_errors, project: project) }

          it 'responds with errors' do
            expect(create_incident).to be_error
            expect(create_incident.errors).to contain_exactly('Hosts hosts array is over 255 chars')
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Labels
  class FindOrCreateService
    def initialize(current_user, parent, params = {})
      @current_user = current_user
      @parent = parent
      @available_labels = params.delete(:available_labels)
      @existing_labels_by_title = params.delete(:existing_labels_by_title)
      @params = params.dup.with_indifferent_access
    end

    def execute(skip_authorization: false, find_only: false)
      @skip_authorization = skip_authorization
      find_or_create_label(find_only: find_only)
    end

    private

    attr_reader :current_user, :parent, :params, :skip_authorization, :existing_labels_by_title

    def available_labels
      @available_labels ||= LabelsFinder.new(
        current_user,
        ""#{parent_type}_id"".to_sym => parent.id,
        include_ancestor_groups: include_ancestor_groups?,
        only_group_labels: parent_is_group?
      ).execute(skip_authorization: skip_authorization)
    end

    # Only creates the label if current_user can do so, if the label does not exist
    # and the user can not create the label, nil is returned
    def find_or_create_label(find_only: false)
      new_label = find_existing_label(title)

      return new_label if find_only

      if new_label.nil? && (skip_authorization || Ability.allowed?(current_user, :admin_label, parent))
        create_params = params.except(:include_ancestor_groups)
        new_label = Labels::CreateService.new(create_params).execute(parent_type.to_sym => parent)
      end

      new_label
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def find_existing_label(title)
      return existing_labels_by_title[title] if existing_labels_by_title

      available_labels.find_by(title: title)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def title
      params[:title] || params[:name]
    end

    def parent_type
      parent.model_name.param_key
    end

    def parent_is_group?
      parent_type == ""group""
    end

    def include_ancestor_groups?
      params[:include_ancestor_groups] == true
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Labels::FindOrCreateService, feature_category: :team_planning do
  describe '#execute' do
    let(:group)   { create(:group) }
    let(:project) { create(:project, namespace: group) }

    let(:params) do
      {
        title: 'Security',
        description: 'Security related stuff.',
        color: '#FF0000'
      }
    end

    context 'when acting on behalf of a specific user' do
      let(:user) { create(:user) }

      context 'when finding labels on project level' do
        subject(:service) { described_class.new(user, project, params) }

        before do
          project.add_developer(user)
        end

        context 'when existing_labels_by_title is provided' do
          let(:preloaded_label) { build(:label, title: 'Security') }

          before do
            params.merge!(
              existing_labels_by_title: {
                'Security' => preloaded_label
              })
          end

          context 'when label exists' do
            it 'returns preloaded label' do
              expect(service.execute).to eq preloaded_label
            end
          end

          context 'when label does not exists' do
            before do
              params[:title] = 'Audit'
            end

            it 'does not generates additional label search' do
              service.execute

              expect(LabelsFinder).not_to receive(:new)
            end
          end
        end

        context 'when label does not exist at group level' do
          it 'creates a new label at project level' do
            expect { service.execute }.to change(project.labels, :count).by(1)
          end
        end

        context 'when label exists at group level' do
          it 'returns the group label' do
            group_label = create(:group_label, group: group, title: 'Security')

            expect(service.execute).to eq group_label
          end
        end

        context 'when label exists at project level' do
          it 'returns the project label' do
            project_label = create(:label, project: project, title: 'Security')

            expect(service.execute).to eq project_label
          end
        end

        context 'when include_ancestor_groups is true' do
          let(:group) { create(:group, :nested) }
          let(:params) do
            {
              title: 'Audit',
              include_ancestor_groups: true
            }
          end

          it 'returns the ancestor group labels' do
            group_label = create(:group_label, group: group.parent, title: 'Audit')

            expect(service.execute).to eq group_label
          end

          it 'creates new labels if labels are not found' do
            expect { service.execute }.to change(project.labels, :count).by(1)
          end
        end
      end

      context 'when finding labels on group level' do
        subject(:service) { described_class.new(user, group, params) }

        before do
          group.add_developer(user)
        end

        context 'when label does not exist at group level' do
          it 'creates a new label at group level' do
            expect { service.execute }.to change(group.labels, :count).by(1)
          end
        end

        context 'when label exists at group level' do
          it 'returns the group label' do
            group_label = create(:group_label, group: group, title: 'Security')

            expect(service.execute).to eq group_label
          end
        end
      end
    end

    context 'when authorization is not required' do
      context 'when finding labels on project level' do
        subject(:service) { described_class.new(nil, project, params) }

        it 'returns the project label' do
          project_label = create(:label, project: project, title: 'Security')

          expect(service.execute(skip_authorization: true)).to eq project_label
        end
      end

      context 'when finding labels on group level' do
        subject(:service) { described_class.new(nil, group, params) }

        it 'returns the group label' do
          group_label = create(:group_label, group: group, title: 'Security')

          expect(service.execute(skip_authorization: true)).to eq group_label
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Labels
  class PromoteService < BaseService
    BATCH_SIZE = 1000

    # rubocop: disable CodeReuse/ActiveRecord
    def execute(label)
      return unless project.group &&
          label.is_a?(ProjectLabel)

      ProjectLabel.transaction do
        # use the existing group label if it exists
        group_label = find_or_create_group_label(label)

        label_ids_for_merge(group_label).find_in_batches(batch_size: BATCH_SIZE) do |batched_ids|
          update_old_label_relations(group_label, batched_ids)
          destroy_project_labels(batched_ids)
        end

        group_label
      end
    end
    # rubocop: enable CodeReuse/ActiveRecord

    private

    def update_old_label_relations(group_label, old_label_ids)
      update_issuables(group_label, old_label_ids)
      update_resource_label_events(group_label, old_label_ids)
      update_issue_board_lists(group_label, old_label_ids)
      update_priorities(group_label, old_label_ids)
      subscribe_users(group_label, old_label_ids)
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def subscribe_users(group_label, label_ids)
      # users can be subscribed to multiple labels that will be merged into the group one
      # we want to keep only one subscription / user
      ids_to_update = Subscription.where(subscribable_id: label_ids, subscribable_type: 'Label')
        .group(:user_id)
        .pluck('MAX(id)')
      Subscription.where(id: ids_to_update).update_all(subscribable_id: group_label.id)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    # rubocop: disable CodeReuse/ActiveRecord
    def label_ids_for_merge(group_label)
      LabelsFinder
        .new(current_user, title: group_label.title, group_id: project.group.id)
        .execute(skip_authorization: true)
        .where.not(id: group_label)
        .select(:id, :project_id, :group_id, :type) # Can't use pluck() to avoid object-creation because of the batching
    end
    # rubocop: enable CodeReuse/ActiveRecord

    # rubocop: disable CodeReuse/ActiveRecord
    def update_issuables(group_label, label_ids)
      LabelLink
        .where(label: label_ids)
        .update_all(label_id: group_label.id)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    # rubocop: disable CodeReuse/ActiveRecord
    def update_resource_label_events(group_label, label_ids)
      ResourceLabelEvent
        .where(label: label_ids)
        .update_all(label_id: group_label.id)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    # rubocop: disable CodeReuse/ActiveRecord
    def update_issue_board_lists(group_label, label_ids)
      List
        .where(label: label_ids)
        .update_all(label_id: group_label.id)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    # rubocop: disable CodeReuse/ActiveRecord
    def update_priorities(group_label, label_ids)
      LabelPriority
        .where(label: label_ids)
        .update_all(label_id: group_label.id)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    # rubocop: disable CodeReuse/ActiveRecord
    def destroy_project_labels(label_ids)
      Label.where(id: label_ids).destroy_all # rubocop: disable Cop/DestroyAll
    end

    def find_or_create_group_label(label)
      params = label.attributes.slice('title', 'description', 'color')
      new_label = GroupLabel.create_with(params).find_or_initialize_by(group_id: project.group.id, title: label.title)

      new_label.save! unless new_label.persisted?
      new_label
    end
  end
end

Labels::PromoteService.prepend_mod_with('Labels::PromoteService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Labels::PromoteService, feature_category: :team_planning do
  describe '#execute' do
    let_it_be(:user) { create(:user) }

    context 'without a group' do
      let!(:project_1) { create(:project) }

      let!(:project_label_1_1) { create(:label, project: project_1) }

      subject(:service) { described_class.new(project_1, user) }

      it 'fails on project without group' do
        expect(service.execute(project_label_1_1)).to be_falsey
      end
    end

    context 'with a group' do
      let_it_be(:promoted_label_name)  { ""Promoted Label"" }
      let_it_be(:untouched_label_name) { ""Untouched Label"" }
      let_it_be(:promoted_description) { ""Promoted Description"" }
      let_it_be(:promoted_color)       { ""#0000FF"" }
      let_it_be(:label_2_1_priority)   { 1 }
      let_it_be(:label_3_1_priority)   { 2 }

      let_it_be(:group_1)  { create(:group) }
      let_it_be(:group_2)  { create(:group) }

      let_it_be(:project_1)  { create(:project, :repository, namespace: group_1) }
      let_it_be(:project_2)  { create(:project, :repository, namespace: group_1) }
      let_it_be(:project_3)  { create(:project, :repository, namespace: group_1) }
      let_it_be(:project_4)  { create(:project, :repository, namespace: group_2) }

      # Labels/issues can't be lazily created so we might as well eager initialize
      # all other objects too since we use them inside
      let_it_be(:project_label_1_1)  { create(:label, project: project_1, name: promoted_label_name, color: promoted_color, description: promoted_description) }
      let_it_be(:project_label_1_2)  { create(:label, project: project_1, name: untouched_label_name) }
      let_it_be(:project_label_2_1)  { create(:label, project: project_2, priority: label_2_1_priority, name: promoted_label_name, color: ""#FF0000"") }
      let_it_be(:project_label_3_1)  { create(:label, project: project_3, priority: label_3_1_priority, name: promoted_label_name) }
      let_it_be(:project_label_3_2)  { create(:label, project: project_3, priority: 1, name: untouched_label_name) }
      let_it_be(:project_label_4_1)  { create(:label, project: project_4, name: promoted_label_name) }

      let_it_be(:issue_1_1)  { create(:labeled_issue, project: project_1, labels: [project_label_1_1, project_label_1_2]) }
      let_it_be(:issue_1_2)  { create(:labeled_issue, project: project_1, labels: [project_label_1_2]) }
      let_it_be(:issue_2_1)  { create(:labeled_issue, project: project_2, labels: [project_label_2_1]) }
      let_it_be(:issue_4_1)  { create(:labeled_issue, project: project_4, labels: [project_label_4_1]) }

      let_it_be(:merge_3_1)  { create(:labeled_merge_request, source_project: project_3, target_project: project_3, labels: [project_label_3_1, project_label_3_2]) }

      let_it_be(:issue_board_2_1)      { create(:board, project: project_2) }
      let_it_be(:issue_board_list_2_1) { create(:list, board: issue_board_2_1, label: project_label_2_1) }

      let(:new_label) { group_1.labels.find_by(title: promoted_label_name) }

      subject(:service) { described_class.new(project_1, user) }

      it 'fails on group label' do
        group_label = create(:group_label, group: group_1)

        expect(service.execute(group_label)).to be_falsey
      end

      shared_examples 'promoting a project label to a group label' do
        it 'is truthy on success' do
          expect(service.execute(project_label_1_1)).to be_truthy
        end

        it 'removes all project labels with that title within the group' do
          expect { service.execute(project_label_1_1) }.to change(project_2.labels, :count).by(-1).and \
            change(project_3.labels, :count).by(-1)
        end

        it 'keeps users\' subscriptions' do
          user2 = create(:user)
          project_label_1_1.subscriptions.create!(user: user, subscribed: true)
          project_label_2_1.subscriptions.create!(user: user, subscribed: true)
          project_label_3_2.subscriptions.create!(user: user, subscribed: true)
          project_label_2_1.subscriptions.create!(user: user2, subscribed: true)

          expect { service.execute(project_label_1_1) }.to change { Subscription.count }.from(4).to(3)

          expect(new_label).to be_subscribed(user)
          expect(new_label).to be_subscribed(user2)
        end

        it 'recreates priorities' do
          service.execute(project_label_1_1)

          expect(new_label.priority(project_1)).to be_nil
          expect(new_label.priority(project_2)).to eq(label_2_1_priority)
          expect(new_label.priority(project_3)).to eq(label_3_1_priority)
        end

        it 'does not touch project out of promoted group' do
          service.execute(project_label_1_1)
          project_4_new_label = project_4.labels.find_by(title: promoted_label_name)

          expect(project_4_new_label).not_to be_nil
          expect(project_4_new_label.id).to eq(project_label_4_1.id)
        end

        it 'does not touch out of group priority' do
          service.execute(project_label_1_1)

          expect(new_label.priority(project_4)).to be_nil
        end

        it 'relinks issue with the promoted label' do
          service.execute(project_label_1_1)
          issue_label = issue_1_1.labels.find_by(title: promoted_label_name)

          expect(issue_label).not_to be_nil
          expect(issue_label.id).to eq(new_label.id)
        end

        it 'does not remove untouched labels from issue' do
          expect { service.execute(project_label_1_1) }.not_to change(issue_1_1.labels, :count)
        end

        it 'does not relink untouched label in issue' do
          service.execute(project_label_1_1)
          issue_label = issue_1_2.labels.find_by(title: untouched_label_name)

          expect(issue_label).not_to be_nil
          expect(issue_label.id).to eq(project_label_1_2.id)
        end

        it 'relinks issues with merged labels' do
          service.execute(project_label_1_1)
          issue_label = issue_2_1.labels.find_by(title: promoted_label_name)

          expect(issue_label).not_to be_nil
          expect(issue_label.id).to eq(new_label.id)
        end

        it 'does not relink issues from other group' do
          service.execute(project_label_1_1)
          issue_label = issue_4_1.labels.find_by(title: promoted_label_name)

          expect(issue_label).not_to be_nil
          expect(issue_label.id).to eq(project_label_4_1.id)
        end

        it 'updates merge request' do
          service.execute(project_label_1_1)
          merge_label = merge_3_1.labels.find_by(title: promoted_label_name)

          expect(merge_label).not_to be_nil
          expect(merge_label.id).to eq(new_label.id)
        end

        it 'updates board lists' do
          service.execute(project_label_1_1)
          list = issue_board_2_1.lists.find_by(label: new_label)

          expect(list).not_to be_nil
        end

        # In case someone adds a new relation to Label.rb and forgets to relink it
        # and the database doesn't have foreign key constraints
        it 'relinks all relations' do
          service.execute(project_label_1_1)

          Label.reflect_on_all_associations.each do |association|
            expect(project_label_1_1.send(association.name).reset).not_to be_any
          end
        end
      end

      context 'when there is an existing identical group label' do
        let!(:existing_group_label) { create(:group_label, group: group_1, title: project_label_1_1.title) }

        it 'uses the existing group label' do
          expect { service.execute(project_label_1_1) }
            .to change(project_1.labels, :count).by(-1)
            .and not_change(group_1.labels, :count)
          expect(new_label).not_to be_nil
        end

        it 'does not create a new group label clone' do
          expect { service.execute(project_label_1_1) }.not_to change { GroupLabel.maximum(:id) }
        end

        it_behaves_like 'promoting a project label to a group label'
      end

      context 'when there is no existing identical group label' do
        let(:existing_group_label) { nil }

        it 'recreates the label as a group label' do
          expect { service.execute(project_label_1_1) }
            .to change(project_1.labels, :count).by(-1)
            .and change(group_1.labels, :count).by(1)
          expect(new_label).not_to be_nil
        end

        it 'copies title, description and color to cloned group label' do
          service.execute(project_label_1_1)

          expect(new_label.title).to eq(promoted_label_name)
          expect(new_label.description).to eq(promoted_description)
          expect(new_label.color).to be_color(promoted_color)
        end

        it_behaves_like 'promoting a project label to a group label'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Labels::TransferService class
#
# User for recreate the missing group labels at project level
#
module Labels
  class TransferService
    def initialize(current_user, old_group, project)
      @current_user = current_user
      @old_group = old_group
      @project = project
    end

    def execute
      return unless old_group.present?

      # rubocop: disable CodeReuse/ActiveRecord
      link_ids = group_labels_applied_to_issues.pluck(""label_links.id"") +
                 group_labels_applied_to_merge_requests.pluck(""label_links.id"")
      # rubocop: disable CodeReuse/ActiveRecord

      Label.transaction do
        labels_to_transfer.find_each do |label|
          new_label_id = find_or_create_label!(label)

          next if new_label_id == label.id

          update_label_links(link_ids, old_label_id: label.id, new_label_id: new_label_id)
          update_label_priorities(old_label_id: label.id, new_label_id: new_label_id)
        end
      end
    end

    private

    attr_reader :current_user, :old_group, :project

    # rubocop: disable CodeReuse/ActiveRecord
    def labels_to_transfer
      Label
        .from_union([
                      group_labels_applied_to_issues,
                      group_labels_applied_to_merge_requests
                    ])
        .reorder(nil)
        .distinct
    end
    # rubocop: enable CodeReuse/ActiveRecord

    # rubocop: disable CodeReuse/ActiveRecord
    def group_labels_applied_to_issues
      @labels_applied_to_issues ||= Label.joins(:issues)
        .joins(""INNER JOIN namespaces on namespaces.id = labels.group_id AND namespaces.type = 'Group'"")
        .where(issues: { project_id: project.id }).reorder(nil)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    # rubocop: disable CodeReuse/ActiveRecord
    def group_labels_applied_to_merge_requests
      @labels_applied_to_mrs ||= Label.joins(:merge_requests)
        .joins(""INNER JOIN namespaces on namespaces.id = labels.group_id AND namespaces.type = 'Group'"")
        .where(merge_requests: { target_project_id: project.id }).reorder(nil)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def find_or_create_label!(label)
      params    = label.attributes.slice('title', 'description', 'color')
      new_label = FindOrCreateService.new(current_user, project, params.merge(include_ancestor_groups: true)).execute

      new_label.id
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def update_label_links(link_ids, old_label_id:, new_label_id:)
      LabelLink.where(id: link_ids, label_id: old_label_id)
        .update_all(label_id: new_label_id)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    # rubocop: disable CodeReuse/ActiveRecord
    def update_label_priorities(old_label_id:, new_label_id:)
      LabelPriority.where(project_id: project.id, label_id: old_label_id)
        .update_all(label_id: new_label_id)
    end
    # rubocop: enable CodeReuse/ActiveRecord
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Labels::TransferService, feature_category: :team_planning do
  shared_examples 'transfer labels' do
    describe '#execute' do
      let_it_be(:user) { create(:user) }

      let_it_be(:old_group_ancestor) { create(:group) }
      let_it_be(:old_group) { create(:group, parent: old_group_ancestor) }

      let_it_be(:new_group) { create(:group) }

      let_it_be(:project) { create(:project, :repository, group: new_group) }

      subject(:service) { described_class.new(user, old_group, project) }

      before do
        old_group_ancestor.add_developer(user)
        new_group.add_developer(user)
      end

      it 'recreates missing group labels at project level and assigns them to the issuables' do
        old_group_label_1 = create(:group_label, group: old_group)
        old_group_label_2 = create(:group_label, group: old_group)

        labeled_issue = create(:labeled_issue, project: project, labels: [old_group_label_1])
        labeled_merge_request = create(:labeled_merge_request, source_project: project, labels: [old_group_label_2])

        expect { service.execute }.to change(project.labels, :count).by(2)
        expect(labeled_issue.reload.labels).to contain_exactly(project.labels.find_by_title(old_group_label_1.title))
        expect(labeled_merge_request.reload.labels).to contain_exactly(project.labels.find_by_title(old_group_label_2.title))
      end

      it 'recreates missing ancestor group labels at project level and assigns them to the issuables' do
        old_group_ancestor_label_1 = create(:group_label, group: old_group_ancestor)
        old_group_ancestor_label_2 = create(:group_label, group: old_group_ancestor)

        labeled_issue = create(:labeled_issue, project: project, labels: [old_group_ancestor_label_1])
        labeled_merge_request = create(:labeled_merge_request, source_project: project, labels: [old_group_ancestor_label_2])

        expect { service.execute }.to change(project.labels, :count).by(2)
        expect(labeled_issue.reload.labels).to contain_exactly(project.labels.find_by_title(old_group_ancestor_label_1.title))
        expect(labeled_merge_request.reload.labels).to contain_exactly(project.labels.find_by_title(old_group_ancestor_label_2.title))
      end

      it 'recreates label priorities related to the missing group labels' do
        old_group_label = create(:group_label, group: old_group)
        create(:labeled_issue, project: project, labels: [old_group_label])
        create(:label_priority, project: project, label: old_group_label, priority: 1)

        service.execute

        new_project_label = project.labels.find_by(title: old_group_label.title)
        expect(new_project_label.id).not_to eq old_group_label.id
        expect(new_project_label.priorities).not_to be_empty
      end

      it 'does not recreate missing group labels that are not applied to issues or merge requests' do
        old_group_label = create(:group_label, group: old_group)

        service.execute

        expect(project.labels.where(title: old_group_label.title)).to be_empty
      end

      it 'does not recreate missing group labels that already exist in the project group' do
        old_group_label = create(:group_label, group: old_group)
        labeled_issue = create(:labeled_issue, project: project, labels: [old_group_label])

        new_group_label = create(:group_label, group: new_group, title: old_group_label.title)

        service.execute

        expect(project.labels.where(title: old_group_label.title)).to be_empty
        expect(labeled_issue.reload.labels).to contain_exactly(new_group_label)
      end

      it 'updates only label links in the given project' do
        old_group_label = create(:group_label, group: old_group)
        other_project = create(:project, group: old_group)

        labeled_issue = create(:labeled_issue, project: project, labels: [old_group_label])
        other_project_labeled_issue = create(:labeled_issue, project: other_project, labels: [old_group_label])

        service.execute

        expect(labeled_issue.reload.labels).not_to include(old_group_label)
        expect(other_project_labeled_issue.reload.labels).to contain_exactly(old_group_label)
      end

      context 'when moving within the same ancestor group' do
        let(:other_subgroup) { create(:group, parent: old_group_ancestor) }
        let(:project) { create(:project, :repository, group: other_subgroup) }

        it 'does not recreate ancestor group labels' do
          old_group_ancestor_label_1 = create(:group_label, group: old_group_ancestor)
          old_group_ancestor_label_2 = create(:group_label, group: old_group_ancestor)

          labeled_issue = create(:labeled_issue, project: project, labels: [old_group_ancestor_label_1])
          labeled_merge_request = create(:labeled_merge_request, source_project: project, labels: [old_group_ancestor_label_2])

          expect { service.execute }.not_to change(project.labels, :count)
          expect(labeled_issue.reload.labels).to contain_exactly(old_group_ancestor_label_1)
          expect(labeled_merge_request.reload.labels).to contain_exactly(old_group_ancestor_label_2)
        end
      end
    end
  end

  it_behaves_like 'transfer labels'
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Labels
  class AvailableLabelsService
    attr_reader :current_user, :parent, :params

    def initialize(current_user, parent, params)
      @current_user = current_user
      @parent = parent
      @params = params
    end

    def find_or_create_by_titles(key = :labels, find_only: false)
      labels = params.delete(key)

      return [] unless labels

      labels = labels.split(',').map(&:strip) if labels.is_a?(String)
      existing_labels = LabelsFinder.new(current_user, finder_params(labels)).execute.index_by(&:title)

      labels.map do |label_name|
        label = Labels::FindOrCreateService.new(
          current_user,
          parent,
          include_ancestor_groups: true,
          title: label_name,
          existing_labels_by_title: existing_labels
        ).execute(find_only: find_only)

        label
      end.compact
    end

    def filter_labels_ids_in_param(key)
      ids = Array.wrap(params[key])
      return [] if ids.empty?

      # rubocop:disable CodeReuse/ActiveRecord
      existing_ids = available_labels.id_in(ids).pluck(:id)
      # rubocop:enable CodeReuse/ActiveRecord
      ids.map(&:to_i) & existing_ids
    end

    def filter_locked_label_ids(ids)
      available_labels.with_lock_on_merge.id_in(ids).pluck(:id) # rubocop:disable CodeReuse/ActiveRecord
    end

    def available_labels
      @available_labels ||= LabelsFinder.new(current_user, finder_params).execute
    end

    private

    def finder_params(titles = nil)
      finder_params = { include_ancestor_groups: true }
      finder_params[:title] = titles if titles

      case parent
      when Group
        finder_params[:group_id] = parent.id
        finder_params[:only_group_labels] = true
      when Project
        finder_params[:project_id] = parent.id
      end

      finder_params
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Labels::AvailableLabelsService, feature_category: :team_planning do
  let_it_be(:user) { create(:user) }
  let(:project) { create(:project, :public, group: group) }
  let(:group) { create(:group) }

  let(:project_label) { create(:label, project: project) }
  let(:project_label_locked) { create(:label, project: project, lock_on_merge: true) }
  let(:other_project_label) { create(:label) }
  let(:other_project_label_locked) { create(:label, lock_on_merge: true) }
  let(:group_label) { create(:group_label, group: group) }
  let(:group_label_locked) { create(:group_label, group: group, lock_on_merge: true) }
  let(:other_group_label) { create(:group_label) }
  let!(:labels) { [project_label, other_project_label, group_label, other_group_label, project_label_locked, other_project_label_locked, group_label_locked] }

  describe '#find_or_create_by_titles' do
    let(:label_titles) { labels.map(&:title).push('non existing title') }

    context 'when parent is a project' do
      context 'when a user is not a project member' do
        it 'returns only relevant label ids' do
          result = described_class.new(user, project, labels: label_titles).find_or_create_by_titles

          expect(result).to match_array([project_label, group_label, project_label_locked, group_label_locked])
        end
      end

      context 'when a user is a project member' do
        before do
          project.add_developer(user)
        end

        it 'creates new labels for not found titles' do
          result = described_class.new(user, project, labels: label_titles).find_or_create_by_titles

          expect(result.count).to eq(8)
          expect(result).to include(project_label, group_label)
          expect(result).not_to include(other_project_label, other_group_label)
        end

        it 'do not cause additional query for finding labels' do
          label_titles = [project_label.title]
          control_count = ActiveRecord::QueryRecorder.new { described_class.new(user, project, labels: label_titles).find_or_create_by_titles }

          new_label = create(:label, project: project)
          label_titles = [project_label.title, new_label.title]
          expect { described_class.new(user, project, labels: label_titles).find_or_create_by_titles }.not_to exceed_query_limit(control_count)
        end
      end
    end

    context 'when parent is a group' do
      context 'when a user is not a group member' do
        it 'returns only relevant label ids' do
          result = described_class.new(user, group, labels: label_titles).find_or_create_by_titles

          expect(result).to match_array([group_label, group_label_locked])
        end
      end

      context 'when a user is a group member' do
        before do
          group.add_developer(user)
        end

        it 'creates new labels for not found titles' do
          result = described_class.new(user, group, labels: label_titles).find_or_create_by_titles

          expect(result.count).to eq(8)
          expect(result).to include(group_label, group_label_locked)
          expect(result).not_to include(project_label, other_project_label, other_group_label, project_label_locked, other_project_label_locked)
        end
      end
    end
  end

  describe '#filter_labels_ids_in_param' do
    let(:label_ids) { labels.map(&:id).push(non_existing_record_id) }

    context 'when parent is a project' do
      it 'returns only relevant label ids' do
        result = described_class.new(user, project, ids: label_ids).filter_labels_ids_in_param(:ids)

        expect(result).to match_array([project_label.id, group_label.id, project_label_locked.id, group_label_locked.id])
      end

      it 'returns labels in preserved order' do
        result = described_class.new(user, project, ids: label_ids.reverse).filter_labels_ids_in_param(:ids)

        expect(result).to eq([group_label_locked.id, project_label_locked.id, group_label.id, project_label.id])
      end
    end

    context 'when parent is a group' do
      it 'returns only relevant label ids' do
        result = described_class.new(user, group, ids: label_ids).filter_labels_ids_in_param(:ids)

        expect(result).to match_array([group_label.id, group_label_locked.id])
      end
    end

    it 'accepts a single id parameter' do
      result = described_class.new(user, project, label_id: project_label.id).filter_labels_ids_in_param(:label_id)

      expect(result).to match_array([project_label.id])
    end
  end

  describe '#filter_locked_label_ids' do
    let(:label_ids) { labels.map(&:id) }

    context 'when parent is a project' do
      it 'returns only relevant label ids' do
        result = described_class.new(user, project, ids: label_ids).filter_locked_label_ids(label_ids)

        expect(result).to match_array([project_label_locked.id, group_label_locked.id])
      end
    end

    context 'when parent is a group' do
      it 'returns only relevant label ids' do
        result = described_class.new(user, group, ids: label_ids).filter_locked_label_ids(label_ids)

        expect(result).to match_array([group_label_locked.id])
      end
    end
  end

  describe '#available_labels' do
    context 'when parent is a project' do
      it 'returns only relevant labels' do
        result = described_class.new(user, project, {}).available_labels

        expect(result.count).to eq(4)
        expect(result).to include(project_label, group_label, project_label_locked, group_label_locked)
        expect(result).not_to include(other_project_label, other_group_label, other_project_label_locked)
      end
    end

    context 'when parent is a group' do
      it 'returns only relevant labels' do
        result = described_class.new(user, group, {}).available_labels

        expect(result.count).to eq(2)
        expect(result).to include(group_label, group_label_locked)
        expect(result).not_to include(project_label, other_project_label, other_group_label, project_label_locked, other_project_label_locked)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Labels
  class UpdateService < Labels::BaseService
    def initialize(params = {})
      @params = params.to_h.dup.with_indifferent_access
    end

    # returns the updated label
    def execute(label)
      params[:name] = params.delete(:new_name) if params.key?(:new_name)
      params[:color] = convert_color_name_to_hex if params[:color].present?
      params.delete(:lock_on_merge) unless allow_lock_on_merge?(label)

      label.update(params)
      label
    end

    private

    def allow_lock_on_merge?(label)
      return if label.template?
      return unless label.respond_to?(:parent_container)
      return unless label.parent_container.supports_lock_on_merge?

      # If we've made it here, then we're allowed to turn it on. However, we do _not_
      # want to allow it to be turned off. So if it's already set, then don't allow the possibility
      # that it could be turned off.
      !label.lock_on_merge
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Labels::UpdateService, feature_category: :team_planning do
  describe '#execute' do
    let(:project) { create(:project) }

    let(:hex_color) { '#FF0000' }
    let(:named_color) { 'red' }
    let(:upcase_color) { 'RED' }
    let(:spaced_color) { ' red ' }
    let(:unknown_color) { 'unknown' }
    let(:no_color) { '' }

    let(:expected_saved_color) { ::Gitlab::Color.of(hex_color) }

    before do
      @label = Labels::CreateService.new(title: 'Initial', color: '#000000').execute(project: project)
      expect(@label).to be_persisted
    end

    context 'with color in hex-code' do
      it 'updates the label' do
        label = described_class.new(params_with(hex_color)).execute(@label)

        expect(label).to be_valid
        expect(label.reload.color).to eq expected_saved_color
      end
    end

    context 'with color in allowed name' do
      it 'updates the label' do
        label = described_class.new(params_with(named_color)).execute(@label)

        expect(label).to be_valid
        expect(label.reload.color).to eq expected_saved_color
      end
    end

    context 'with color in up-case allowed name' do
      it 'updates the label' do
        label = described_class.new(params_with(upcase_color)).execute(@label)

        expect(label).to be_valid
        expect(label.reload.color).to eq expected_saved_color
      end
    end

    context 'with color surrounded by spaces' do
      it 'updates the label' do
        label = described_class.new(params_with(spaced_color)).execute(@label)

        expect(label).to be_valid
        expect(label.reload.color).to eq expected_saved_color
      end
    end

    context 'with unknown color' do
      it 'doesn\'t update the label' do
        label = described_class.new(params_with(unknown_color)).execute(@label)

        expect(label).not_to be_valid
      end
    end

    context 'with no color' do
      it 'doesn\'t update the label' do
        label = described_class.new(params_with(no_color)).execute(@label)

        expect(label).not_to be_valid
      end
    end

    describe 'lock_on_merge' do
      let_it_be(:params) { { lock_on_merge: true } }

      context 'when feature flag is disabled' do
        before do
          stub_feature_flags(enforce_locked_labels_on_merge: false)
        end

        it 'does not allow setting lock_on_merge' do
          label = described_class.new(params).execute(@label)

          expect(label.reload.lock_on_merge).to be_falsey

          template_label = Labels::CreateService.new(title: 'Initial').execute(template: true)
          label = described_class.new(params).execute(template_label)

          expect(label.reload.lock_on_merge).to be_falsey
        end
      end

      context 'when feature flag is enabled' do
        it 'allows setting lock_on_merge' do
          label = described_class.new(params).execute(@label)

          expect(label.reload.lock_on_merge).to be_truthy
        end

        it 'does not allow lock_on_merge to be unset' do
          label_locked = Labels::CreateService.new(title: 'Initial', lock_on_merge: true).execute(project: project)
          label = described_class.new(title: 'test', lock_on_merge: false).execute(label_locked)

          expect(label.reload.lock_on_merge).to be_truthy
          expect(label.reload.title).to eq 'test'
        end

        it 'does not allow setting lock_on_merge for templates' do
          template_label = Labels::CreateService.new(title: 'Initial').execute(template: true)
          label = described_class.new(params).execute(template_label)

          expect(label.reload.lock_on_merge).to be_falsey
        end
      end
    end
  end

  def params_with(color)
    {
      title: 'A Label',
      color: color
    }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Labels
  class CreateService < Labels::BaseService
    def initialize(params = {})
      @params = params.to_h.dup.with_indifferent_access
    end

    # returns the created label
    def execute(target_params)
      params[:color] = convert_color_name_to_hex if params[:color].present?

      project_or_group = target_params[:project] || target_params[:group]

      if project_or_group.present?
        params.delete(:lock_on_merge) unless project_or_group.supports_lock_on_merge?

        project_or_group.labels.create(params)
      elsif target_params[:template]
        label = Label.new(params)
        label.template = true
        label.save
        label
      else
        Gitlab::AppLogger.warn(""target_params should contain :project or :group or :template, actual value: #{target_params}"")
      end
    end
  end
end

Labels::CreateService.prepend_mod_with('Labels::CreateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Labels::CreateService, feature_category: :team_planning do
  describe '#execute' do
    let(:project) { create(:project) }
    let(:group)   { create(:group) }

    let(:hex_color) { '#FF0000' }
    let(:named_color) { 'red' }
    let(:upcase_color) { 'RED' }
    let(:spaced_color) { ' red ' }
    let(:unknown_color) { 'unknown' }
    let(:no_color) { '' }

    let(:expected_saved_color) { ::Gitlab::Color.of(hex_color) }

    context 'in a project' do
      context 'with color in hex-code' do
        it 'creates a label' do
          label = described_class.new(params_with(hex_color)).execute(project: project)

          expect(label).to be_persisted
          expect(label.color).to eq expected_saved_color
        end
      end

      context 'with color in allowed name' do
        it 'creates a label' do
          label = described_class.new(params_with(named_color)).execute(project: project)

          expect(label).to be_persisted
          expect(label.color).to eq expected_saved_color
        end
      end

      context 'with color in up-case allowed name' do
        it 'creates a label' do
          label = described_class.new(params_with(upcase_color)).execute(project: project)

          expect(label).to be_persisted
          expect(label.color).to eq expected_saved_color
        end
      end

      context 'with color surrounded by spaces' do
        it 'creates a label' do
          label = described_class.new(params_with(spaced_color)).execute(project: project)
          expect(label).to be_persisted
          expect(label.color).to eq expected_saved_color
        end
      end

      context 'with unknown color' do
        it 'doesn\'t create a label' do
          label = described_class.new(params_with(unknown_color)).execute(project: project)

          expect(label).not_to be_persisted
        end
      end

      context 'with no color' do
        it 'doesn\'t create a label' do
          label = described_class.new(params_with(no_color)).execute(project: project)

          expect(label).not_to be_persisted
        end
      end
    end

    context 'in a group' do
      context 'with color in hex-code' do
        it 'creates a label' do
          label = described_class.new(params_with(hex_color)).execute(group: group)

          expect(label).to be_persisted
          expect(label.color).to eq expected_saved_color
        end
      end

      context 'with color in allowed name' do
        it 'creates a label' do
          label = described_class.new(params_with(named_color)).execute(group: group)

          expect(label).to be_persisted
          expect(label.color).to eq expected_saved_color
        end
      end

      context 'with color in up-case allowed name' do
        it 'creates a label' do
          label = described_class.new(params_with(upcase_color)).execute(group: group)

          expect(label).to be_persisted
          expect(label.color).to eq expected_saved_color
        end
      end

      context 'with color surrounded by spaces' do
        it 'creates a label' do
          label = described_class.new(params_with(spaced_color)).execute(group: group)

          expect(label).to be_persisted
          expect(label.color).to eq expected_saved_color
        end
      end

      context 'with unknown color' do
        it 'doesn\'t create a label' do
          label = described_class.new(params_with(unknown_color)).execute(group: group)

          expect(label).not_to be_persisted
        end
      end

      context 'with no color' do
        it 'doesn\'t create a label' do
          label = described_class.new(params_with(no_color)).execute(group: group)

          expect(label).not_to be_persisted
        end
      end
    end

    context 'in admin area' do
      context 'with color in hex-code' do
        it 'creates a label' do
          label = described_class.new(params_with(hex_color)).execute(template: true)

          expect(label).to be_persisted
          expect(label.color).to eq expected_saved_color
        end
      end

      context 'with color in allowed name' do
        it 'creates a label' do
          label = described_class.new(params_with(named_color)).execute(template: true)

          expect(label).to be_persisted
          expect(label.color).to eq expected_saved_color
        end
      end

      context 'with color in up-case allowed name' do
        it 'creates a label' do
          label = described_class.new(params_with(upcase_color)).execute(template: true)

          expect(label).to be_persisted
          expect(label.color).to eq expected_saved_color
        end
      end

      context 'with color surrounded by spaces' do
        it 'creates a label' do
          label = described_class.new(params_with(spaced_color)).execute(template: true)

          expect(label).to be_persisted
          expect(label.color).to eq expected_saved_color
        end
      end

      context 'with unknown color' do
        it 'doesn\'t create a label' do
          label = described_class.new(params_with(unknown_color)).execute(template: true)

          expect(label).not_to be_persisted
        end
      end

      context 'with no color' do
        it 'doesn\'t create a label' do
          label = described_class.new(params_with(no_color)).execute(template: true)

          expect(label).not_to be_persisted
        end
      end
    end

    describe 'lock_on_merge' do
      let_it_be(:params) { { title: 'Locked label', lock_on_merge: true } }

      context 'when feature flag is disabled' do
        before do
          stub_feature_flags(enforce_locked_labels_on_merge: false)
        end

        it 'does not allow setting lock_on_merge' do
          label = described_class.new(params).execute(project: project)
          label2 = described_class.new(params).execute(group: group)
          label3 = described_class.new(params).execute(template: true)

          expect(label.lock_on_merge).to be_falsey
          expect(label2.lock_on_merge).to be_falsey
          expect(label3).not_to be_persisted
        end
      end

      context 'when feature flag is enabled' do
        it 'allows setting lock_on_merge' do
          label = described_class.new(params).execute(project: project)
          label2 = described_class.new(params).execute(group: group)

          expect(label.lock_on_merge).to be_truthy
          expect(label2.lock_on_merge).to be_truthy
        end

        it 'does not alow setting lock_on_merge for templates' do
          label = described_class.new(params).execute(template: true)

          expect(label).not_to be_persisted
        end
      end
    end
  end

  def params_with(color)
    {
      title: 'A Label',
      color: color
    }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module IssueEmailParticipants
  class CreateService < ::BaseProjectService
    MAX_NUMBER_OF_EMAILS = 6

    attr_reader :target, :emails

    def initialize(target:, current_user:, emails:)
      super(project: target.project, current_user: current_user)

      @target = target
      @emails = emails
    end

    def execute
      return error_feature_flag unless Feature.enabled?(:issue_email_participants, target.project)
      return error_underprivileged unless current_user.can?(:""admin_#{target.to_ability_name}"", target)
      return error_no_participants unless emails.present?

      added_emails = add_participants(deduplicate_and_limit_emails)

      if added_emails.any?
        message = add_system_note(added_emails)
        ServiceResponse.success(message: message.upcase_first << ""."")
      else
        error_no_participants
      end
    end

    private

    def deduplicate_and_limit_emails
      existing_emails = target.email_participants_emails_downcase
      # Compare downcase versions, but use the original email
      emails.index_by { |email| [email.downcase, email] }.excluding(*existing_emails).each_value
        .first(MAX_NUMBER_OF_EMAILS)
    end

    def add_participants(emails_to_add)
      added_emails = []
      emails_to_add.each do |email|
        new_participant = target.issue_email_participants.create(email: email)
        added_emails << email if new_participant.persisted?
      end

      added_emails
    end

    def add_system_note(added_emails)
      message = format(_(""added %{emails}""), emails: added_emails.to_sentence)
      ::SystemNoteService.add_email_participants(target, project, current_user, message)

      message
    end

    def error(message)
      ServiceResponse.error(message: message)
    end

    def error_feature_flag
      # Don't translate feature flag error because it's temporary.
      error(""Feature flag issue_email_participants is not enabled for this project."")
    end

    def error_underprivileged
      error(_(""You don't have permission to add email participants.""))
    end

    def error_no_participants
      error(_(""No email participants were added. Either none were provided, or they already exist.""))
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe IssueEmailParticipants::CreateService, feature_category: :service_desk do
  shared_examples 'a successful service execution' do
    it 'creates new participants', :aggregate_failures do
      expect(response).to be_success

      issue.reset
      note = issue.notes.last
      expect(note.system?).to be true
      expect(note.author).to eq(user)

      participants_emails = issue.email_participants_emails_downcase

      expected_emails.each do |email|
        expect(participants_emails).to include(email)
        expect(response.message).to include(email)
        expect(note.note).to include(email)
      end
    end
  end

  shared_examples 'a failed service execution' do
    it 'returns error ServiceResponse with message', :aggregate_failures do
      expect(response).to be_error
      expect(response.message).to eq(error_message)
    end
  end

  describe '#execute' do
    let_it_be_with_reload(:project) { create(:project) }
    let_it_be(:user) { create(:user) }
    let_it_be(:issue) { create(:issue, project: project) }

    let(:emails) { nil }
    let(:service) { described_class.new(target: issue, current_user: user, emails: emails) }
    let(:expected_emails) { emails }

    let(:error_feature_flag) { ""Feature flag issue_email_participants is not enabled for this project."" }
    let(:error_underprivileged) { _(""You don't have permission to add email participants."") }
    let(:error_no_participants) do
      _(""No email participants were added. Either none were provided, or they already exist."")
    end

    subject(:response) { service.execute }

    context 'when the user is not a project member' do
      let(:error_message) { error_underprivileged }

      it_behaves_like 'a failed service execution'
    end

    context 'when user has reporter role in project' do
      before_all do
        project.add_reporter(user)
      end

      context 'when no emails are provided' do
        let(:error_message) { error_no_participants }

        it_behaves_like 'a failed service execution'
      end

      context 'when one email is provided' do
        let(:emails) { ['user@example.com'] }

        it_behaves_like 'a successful service execution'

        context 'when email is already a participant of the issue' do
          let(:error_message) { error_no_participants }

          before do
            issue.issue_email_participants.create!(email: emails.first)
          end

          it_behaves_like 'a failed service execution'

          context 'when email is formatted in a different case' do
            let(:emails) { ['USER@example.com'] }

            it_behaves_like 'a failed service execution'
          end
        end
      end

      context 'when multiple emails are provided' do
        let(:emails) { ['user@example.com', 'user2@example.com'] }

        it_behaves_like 'a successful service execution'

        context 'when duplicate email provided' do
          let(:emails) { ['user@example.com', 'user@example.com'] }
          let(:expected_emails) { emails[...-1] }

          it_behaves_like 'a successful service execution'
        end

        context 'when an email is already a participant of the issue' do
          let(:expected_emails) { emails[1...] }

          before do
            issue.issue_email_participants.create!(email: emails.first)
          end

          it_behaves_like 'a successful service execution'
        end
      end

      context 'when more than the allowed number of emails a re provided' do
        let(:emails) { (1..7).map { |i| ""user#{i}@example.com"" } }

        let(:expected_emails) { emails[...-1] }

        it_behaves_like 'a successful service execution'
      end
    end

    context 'when feature flag issue_email_participants is disabled' do
      let(:error_message) { error_feature_flag }

      before do
        stub_feature_flags(issue_email_participants: false)
      end

      it_behaves_like 'a failed service execution'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module DeployKeys
  class CreateService < Keys::BaseService
    def execute(project: nil)
      DeployKey.create(params.merge(user: user))
    end
  end
end

DeployKeys::CreateService.prepend_mod_with('DeployKeys::CreateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe DeployKeys::CreateService, feature_category: :continuous_delivery do
  let(:user) { create(:user) }
  let(:params) { attributes_for(:deploy_key) }

  subject { described_class.new(user, params) }

  it ""creates a deploy key"" do
    expect { subject.execute }.to change { DeployKey.where(params.merge(user: user)).count }.by(1)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Uploads
  class DestroyService < BaseService
    attr_accessor :model, :current_user

    def initialize(model, user = nil)
      @model = model
      @current_user = user
    end

    def execute(secret, filename)
      upload = find_upload(secret, filename)

      unless current_user && upload && current_user.can?(:destroy_upload, upload)
        return error(_(""The resource that you are attempting to access does not ""\
                       ""exist or you don't have permission to perform this action.""))
      end

      if upload.destroy
        success(upload: upload)
      else
        error(_('Upload could not be deleted.'))
      end
    end

    private

    # rubocop: disable CodeReuse/ActiveRecord
    def find_upload(secret, filename)
      uploader = uploader_class.new(model, secret: secret)
      upload_paths = uploader.upload_paths(filename)

      Upload.find_by(model: model, uploader: uploader_class.to_s, path: upload_paths)
    rescue FileUploader::InvalidSecret
      nil
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def uploader_class
      case model
      when Group
        NamespaceFileUploader
      when Project
        FileUploader
      else
        raise ArgumentError, ""unknown uploader for #{model.class.name}""
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Uploads::DestroyService, feature_category: :shared do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }
  let_it_be_with_reload(:upload) { create(:upload, :issuable_upload, model: project) }

  let(:filename) { File.basename(upload.path) }
  let(:secret) { upload.secret }
  let(:model) { project }
  let(:service) { described_class.new(model, user) }

  describe '#execute' do
    subject { service.execute(secret, filename) }

    shared_examples_for 'upload not found' do
      it 'does not delete any upload' do
        expect { subject }.not_to change { Upload.count }
      end

      it 'returns an error' do
        expect(subject[:status]).to eq(:error)
        expect(subject[:message]).to eq(""The resource that you are attempting to access does not ""\
                                        ""exist or you don't have permission to perform this action."")
      end
    end

    context 'when user is nil' do
      let(:user) { nil }

      it_behaves_like 'upload not found'
    end

    context 'when user cannot destroy upload' do
      before do
        project.add_developer(user)
      end

      it_behaves_like 'upload not found'
    end

    context 'when user can destroy upload' do
      before do
        project.add_maintainer(user)
      end

      it 'deletes the upload' do
        expect { subject }.to change { Upload.count }.by(-1)
      end

      it 'returns success response' do
        expect(subject[:status]).to eq(:success)
        expect(subject[:upload]).to eq(upload)
      end

      context 'when upload is not found' do
        let(:filename) { 'not existing filename' }

        it_behaves_like 'upload not found'
      end

      context 'when upload secret is not found' do
        let(:secret) { 'aaaaaaaaaa' }

        it_behaves_like 'upload not found'
      end

      context 'when upload secret has invalid format' do
        let(:secret) { 'invalid' }

        it_behaves_like 'upload not found'
      end

      context 'when unknown model is used' do
        let(:model) { user }

        it 'raises an error' do
          expect { subject }.to raise_exception(ArgumentError)
        end
      end

      context 'when upload belongs to other model' do
        let_it_be(:upload) { create(:upload, :namespace_upload) }

        it_behaves_like 'upload not found'
      end

      context 'when upload destroy fails' do
        before do
          allow(service).to receive(:find_upload).and_return(upload)
          allow(upload).to receive(:destroy).and_return(false)
        end

        it 'returns error' do
          expect(subject[:status]).to eq(:error)
          expect(subject[:message]).to eq('Upload could not be deleted.')
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ResourceAccessTokens
  class RevokeService < BaseService
    include Gitlab::Utils::StrongMemoize

    RevokeAccessTokenError = Class.new(RuntimeError)

    def initialize(current_user, resource, access_token)
      @current_user = current_user
      @access_token = access_token
      @bot_user = access_token.user
      @resource = resource
    end

    def execute
      return error(""#{current_user.name} cannot delete #{bot_user.name}"") unless can_destroy_token?
      return error(""Failed to find bot user"") unless find_member

      access_token.revoke!

      destroy_bot_user

      log_event

      success(""Access token #{access_token.name} has been revoked and the bot user has been scheduled for deletion."")
    rescue StandardError => error
      log_error(""Failed to revoke access token for #{bot_user.name}: #{error.message}"")
      error(error.message)
    end

    private

    attr_reader :current_user, :access_token, :bot_user, :resource

    def destroy_bot_user
      DeleteUserWorker.perform_async(current_user.id, bot_user.id, skip_authorization: true)
    end

    def can_destroy_token?
      %w[project group].include?(resource.class.name.downcase) && can?(current_user, :destroy_resource_access_tokens, resource)
    end

    def find_member
      strong_memoize(:member) do
        next false unless resource.is_a?(Project) || resource.is_a?(Group)

        resource.member(bot_user)
      end
    end

    def log_event
      ::Gitlab::AppLogger.info ""PROJECT ACCESS TOKEN REVOCATION: revoked_by: #{current_user.username}, project_id: #{resource.id}, token_user: #{access_token.user.name}, token_id: #{access_token.id}""
    end

    def error(message)
      ServiceResponse.error(message: message)
    end

    def success(message)
      ServiceResponse.success(message: message)
    end
  end
end

ResourceAccessTokens::RevokeService.prepend_mod_with('ResourceAccessTokens::RevokeService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ResourceAccessTokens::RevokeService, feature_category: :system_access do
  subject { described_class.new(user, resource, access_token).execute }

  let_it_be(:user) { create(:user) }
  let_it_be(:user_non_priviledged) { create(:user) }
  let_it_be(:resource_bot) { create(:user, :project_bot) }

  let(:access_token) { create(:personal_access_token, user: resource_bot) }

  describe '#execute', :sidekiq_inline do
    shared_examples 'revokes access token' do
      it { expect(subject.success?).to be true }

      it { expect(subject.message).to eq(""Access token #{access_token.name} has been revoked and the bot user has been scheduled for deletion."") }

      it 'calls delete user worker' do
        expect(DeleteUserWorker).to receive(:perform_async).with(user.id, resource_bot.id, skip_authorization: true)

        subject
      end

      it 'removes membership of bot user' do
        subject

        expect(resource.reload.users).not_to include(resource_bot)
      end

      it 'initiates user removal' do
        subject

        expect(
          Users::GhostUserMigration.where(user: resource_bot, initiator_user: user)
        ).to be_exists
      end

      it 'logs the event' do
        allow(Gitlab::AppLogger).to receive(:info)

        subject

        expect(Gitlab::AppLogger).to have_received(:info).with(""PROJECT ACCESS TOKEN REVOCATION: revoked_by: #{user.username}, project_id: #{resource.id}, token_user: #{resource_bot.name}, token_id: #{access_token.id}"")
      end
    end

    shared_examples 'rollback revoke steps' do
      it 'does not revoke the access token' do
        subject

        expect(access_token.reload.revoked?).to be false
      end

      it 'does not remove bot from member list' do
        subject

        expect(resource.reload.users).to include(resource_bot)
      end

      it 'does not transfer issuables of bot user to ghost user' do
        issue = create(:issue, author: resource_bot)

        subject

        expect(issue.reload.author.ghost?).to be false
      end

      it 'does not destroy project bot user' do
        subject

        expect(User.exists?(resource_bot.id)).to be_truthy
      end
    end

    shared_examples 'revoke fails' do |resource_type|
      let_it_be(:other_user) { create(:user) }

      context ""when access token does not belong to this #{resource_type}"" do
        it 'does not find the bot' do
          other_access_token = create(:personal_access_token, user: other_user)

          response = described_class.new(user, resource, other_access_token).execute

          expect(response.success?).to be false
          expect(response.message).to eq(""Failed to find bot user"")
          expect(access_token.reload.revoked?).to be false
        end
      end

      context 'when user does not have permission to destroy bot' do
        context ""when non-#{resource_type} member tries to delete project bot"" do
          it 'does not allow other user to delete bot' do
            response = described_class.new(other_user, resource, access_token).execute

            expect(response.success?).to be false
            expect(response.message).to eq(""#{other_user.name} cannot delete #{access_token.user.name}"")
            expect(access_token.reload.revoked?).to be false
          end
        end

        context ""when non-priviledged #{resource_type} member tries to delete project bot"" do
          it 'does not allow developer to delete bot' do
            response = described_class.new(user_non_priviledged, resource, access_token).execute

            expect(response.success?).to be false
            expect(response.message).to eq(""#{user_non_priviledged.name} cannot delete #{access_token.user.name}"")
            expect(access_token.reload.revoked?).to be false
          end
        end
      end

      context 'when deletion of bot user fails' do
        before do
          allow_next_instance_of(::ResourceAccessTokens::RevokeService) do |service|
            allow(service).to receive(:execute).and_return(false)
          end
        end

        it_behaves_like 'rollback revoke steps'
      end
    end

    context 'when resource is a project' do
      let_it_be(:resource) { create(:project, :private) }

      before do
        resource.add_maintainer(user)
        resource.add_developer(user_non_priviledged)
        resource.add_maintainer(resource_bot)
      end

      it_behaves_like 'revokes access token'

      it_behaves_like 'revoke fails', 'project'
    end

    context 'when resource is a group' do
      let_it_be(:resource) { create(:group, :private) }

      before do
        resource.add_owner(user)
        resource.add_maintainer(user_non_priviledged)
        resource.add_maintainer(resource_bot)
      end

      it_behaves_like 'revokes access token'

      it_behaves_like 'revoke fails', 'group'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ResourceAccessTokens
  class CreateService < BaseService
    include Gitlab::Utils::StrongMemoize

    def initialize(current_user, resource, params = {})
      @resource_type = resource.class.name.downcase
      @resource = resource
      @current_user = current_user
      @params = params.dup
    end

    def execute
      return error(""User does not have permission to create #{resource_type} access token"") unless has_permission_to_create?

      access_level = params[:access_level] || Gitlab::Access::MAINTAINER
      return error(""Could not provision owner access to project access token"") if do_not_allow_owner_access_level_for_project_bot?(access_level)

      return error(""Access level of the token can't be greater the access level of the user who created the token"") unless validate_access_level(access_level)

      return error(s_('AccessTokens|Access token limit reached')) if reached_access_token_limit?

      user = create_user

      return error(user.errors.full_messages.to_sentence) unless user.persisted?

      user.update!(external: true) if current_user.external?

      member = create_membership(resource, user, access_level)

      unless member.persisted?
        delete_failed_user(user)
        return error(""Could not provision #{Gitlab::Access.human_access(access_level.to_i).downcase} access to the access token. ERROR: #{member.errors.full_messages.to_sentence}"")
      end

      token_response = create_personal_access_token(user)

      if token_response.success?
        log_event(token_response.payload[:personal_access_token])
        success(token_response.payload[:personal_access_token])
      else
        delete_failed_user(user)
        error(token_response.message)
      end
    end

    private

    attr_reader :resource_type, :resource

    def reached_access_token_limit?
      false
    end

    def username_and_email_generator
      Gitlab::Utils::UsernameAndEmailGenerator.new(
        username_prefix: ""#{resource_type}_#{resource.id}_bot"",
        email_domain: ""noreply.#{Gitlab.config.gitlab.host}""
      )
    end
    strong_memoize_attr :username_and_email_generator

    def has_permission_to_create?
      %w[project group].include?(resource_type) && can?(current_user, :create_resource_access_tokens, resource)
    end

    def create_user
      # Even project maintainers/owners can create project access tokens, which in turn
      # creates a bot user, and so it becomes necessary to  have `skip_authorization: true`
      # since someone like a project maintainer/owner does not inherently have the ability
      # to create a new user in the system.

      ::Users::AuthorizedCreateService.new(current_user, default_user_params).execute
    end

    def delete_failed_user(user)
      DeleteUserWorker.perform_async(current_user.id, user.id, hard_delete: true, skip_authorization: true)
    end

    def default_user_params
      {
        name: params[:name] || ""#{resource.name.to_s.humanize} bot"",
        email: username_and_email_generator.email,
        username: username_and_email_generator.username,
        user_type: :project_bot,
        skip_confirmation: true # Bot users should always have their emails confirmed.
      }
    end

    def create_personal_access_token(user)
      PersonalAccessTokens::CreateService.new(
        current_user: user, target_user: user, params: personal_access_token_params
      ).execute
    end

    def personal_access_token_params
      {
        name: params[:name] || ""#{resource_type}_bot"",
        impersonation: false,
        scopes: params[:scopes] || default_scopes,
        expires_at: pat_expiration
      }
    end

    def default_scopes
      Gitlab::Auth.resource_bot_scopes
    end

    def create_membership(resource, user, access_level)
      resource.add_member(user, access_level, expires_at: pat_expiration)
    end

    def pat_expiration
      params[:expires_at].presence || PersonalAccessToken::MAX_PERSONAL_ACCESS_TOKEN_LIFETIME_IN_DAYS.days.from_now
    end

    def log_event(token)
      ::Gitlab::AppLogger.info ""PROJECT ACCESS TOKEN CREATION: created_by: #{current_user.username}, project_id: #{resource.id}, token_user: #{token.user.name}, token_id: #{token.id}""
    end

    def error(message)
      ServiceResponse.error(message: message)
    end

    def success(access_token)
      ServiceResponse.success(payload: { access_token: access_token })
    end

    def validate_access_level(access_level)
      return true unless resource.is_a?(Project)
      return true if current_user.bot?
      return true if current_user.can?(:manage_owners, resource)

      current_user.authorized_project?(resource, access_level.to_i)
    end

    def do_not_allow_owner_access_level_for_project_bot?(access_level)
      resource.is_a?(Project) &&
        access_level.to_i == Gitlab::Access::OWNER &&
        !current_user.can?(:manage_owners, resource)
    end
  end
end

ResourceAccessTokens::CreateService.prepend_mod_with('ResourceAccessTokens::CreateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ResourceAccessTokens::CreateService, feature_category: :system_access do
  subject { described_class.new(user, resource, params).execute }

  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project, :private) }
  let_it_be(:group) { create(:group, :private) }
  let_it_be(:params) { {} }
  let_it_be(:max_pat_access_token_lifetime) do
    PersonalAccessToken::MAX_PERSONAL_ACCESS_TOKEN_LIFETIME_IN_DAYS.days.from_now.to_date.freeze
  end

  before do
    stub_config_setting(host: 'example.com')
  end

  describe '#execute' do
    shared_examples 'token creation fails' do
      let(:resource) { create(:project) }

      it 'does not add the project bot as a member' do
        expect { subject }.not_to change { resource.members.count }
      end

      it 'immediately destroys the bot user if one was created', :sidekiq_inline do
        expect { subject }.not_to change { User.bots.count }
      end
    end

    shared_examples 'correct error message' do
      it 'returns correct error message' do
        expect(subject.error?).to be true
        expect(subject.errors).to include(error_message)
      end
    end

    shared_examples 'allows creation of bot with valid params' do
      it { expect { subject }.to change { User.count }.by(1) }

      it 'creates resource bot user' do
        response = subject

        access_token = response.payload[:access_token]

        expect(access_token.user.reload.user_type).to eq(""project_bot"")
        expect(access_token.user.created_by_id).to eq(user.id)
      end

      context 'email confirmation status' do
        shared_examples_for 'creates a user that has their email confirmed' do
          it 'creates a user that has their email confirmed' do
            response = subject
            access_token = response.payload[:access_token]

            expect(access_token.user.reload.confirmed?).to eq(true)
          end
        end

        context 'when created by an admin' do
          let(:user) { create(:admin) }

          context 'when admin mode is enabled', :enable_admin_mode do
            it_behaves_like 'creates a user that has their email confirmed'
          end

          context 'when admin mode is disabled' do
            it 'returns error' do
              response = subject

              expect(response.error?).to be true
            end
          end
        end

        context 'when created by a non-admin' do
          it_behaves_like 'creates a user that has their email confirmed'
        end
      end

      context 'bot name' do
        context 'when no name is passed' do
          it 'uses default name' do
            response = subject
            access_token = response.payload[:access_token]

            expect(access_token.user.name).to eq(""#{resource.name.to_s.humanize} bot"")
          end
        end

        context 'when user provides name' do
          let_it_be(:params) { { name: 'Random bot' } }

          it 'overrides the default name value' do
            response = subject
            access_token = response.payload[:access_token]

            expect(access_token.user.name).to eq(params[:name])
          end
        end
      end

      context 'bot username and email' do
        include_examples 'username and email pair is generated by Gitlab::Utils::UsernameAndEmailGenerator' do
          subject do
            response = described_class.new(user, resource, params).execute
            response.payload[:access_token].user
          end

          let(:username_prefix) do
            ""#{resource.class.name.downcase}_#{resource.id}_bot""
          end

          let(:email_domain) do
            ""noreply.#{Gitlab.config.gitlab.host}""
          end
        end
      end

      context 'access level' do
        context 'when user does not specify an access level' do
          it 'adds the bot user as a maintainer in the resource' do
            response = subject
            access_token = response.payload[:access_token]
            bot_user = access_token.user

            expect(resource.members.maintainers.map(&:user_id)).to include(bot_user.id)
          end
        end

        shared_examples 'bot with access level' do
          it 'adds the bot user with the specified access level in the resource' do
            response = subject
            access_token = response.payload[:access_token]
            bot_user = access_token.user

            expect(resource.members.developers.map(&:user_id)).to include(bot_user.id)
          end
        end

        context 'when user specifies an access level' do
          let_it_be(:params) { { access_level: Gitlab::Access::DEVELOPER } }

          it_behaves_like 'bot with access level'
        end

        context 'with DEVELOPER access_level, in string format' do
          let_it_be(:params) { { access_level: Gitlab::Access::DEVELOPER.to_s } }

          it_behaves_like 'bot with access level'
        end

        context 'when user is external' do
          before do
            user.update!(external: true)
          end

          it 'creates resource bot user with external status' do
            expect(subject.payload[:access_token].user.external).to eq true
          end
        end
      end

      context 'personal access token' do
        it { expect { subject }.to change { PersonalAccessToken.count }.by(1) }

        context 'when user does not provide scope' do
          it 'has default scopes' do
            response = subject
            access_token = response.payload[:access_token]

            expect(access_token.scopes).to eq(Gitlab::Auth.resource_bot_scopes)
          end
        end

        context 'when user provides scope explicitly' do
          let_it_be(:params) { { scopes: Gitlab::Auth::REPOSITORY_SCOPES } }

          it 'overrides the default scope value' do
            response = subject
            access_token = response.payload[:access_token]

            expect(access_token.scopes).to eq(Gitlab::Auth::REPOSITORY_SCOPES)
          end
        end

        context 'expires_at' do
          context 'when no expiration value is passed' do
            it 'defaults to PersonalAccessToken::MAX_PERSONAL_ACCESS_TOKEN_LIFETIME_IN_DAYS' do
              freeze_time do
                response = subject
                access_token = response.payload[:access_token]

                expect(access_token.expires_at).to eq(
                  max_pat_access_token_lifetime.to_date
                )
              end
            end

            it 'project bot membership expires when PAT expires' do
              response = subject
              access_token = response.payload[:access_token]
              project_bot = access_token.user

              expect(resource.members.find_by(user_id: project_bot.id).expires_at).to eq(
                max_pat_access_token_lifetime.to_date
              )
            end
          end

          context 'when user provides expiration value' do
            let_it_be(:params) { { expires_at: Date.today + 1.month } }

            it 'overrides the default expiration value' do
              response = subject
              access_token = response.payload[:access_token]

              expect(access_token.expires_at).to eq(params[:expires_at])
            end

            context 'expiry of the project bot member' do
              it 'sets the project bot to expire on the same day as the token' do
                response = subject
                access_token = response.payload[:access_token]
                project_bot = access_token.user

                expect(resource.members.find_by(user_id: project_bot.id).expires_at).to eq(access_token.expires_at)
              end
            end
          end

          context 'when invalid scope is passed' do
            let(:error_message) { 'Scopes can only contain available scopes' }
            let_it_be(:params) { { scopes: [:invalid_scope] } }

            it_behaves_like 'token creation fails'
            it_behaves_like 'correct error message'
          end
        end

        context ""when access provisioning fails"" do
          let_it_be(:bot_user) { create(:user, :project_bot) }

          let(:unpersisted_member) { build(:project_member, source: resource, user: bot_user) }
          let(:error_message) { 'Could not provision maintainer access to the access token. ERROR: error message' }

          before do
            allow_next_instance_of(ResourceAccessTokens::CreateService) do |service|
              allow(service).to receive(:create_user).and_return(bot_user)
              allow(service).to receive(:create_membership).and_return(unpersisted_member)
            end

            allow(unpersisted_member).to receive_message_chain(:errors, :full_messages, :to_sentence)
              .and_return('error message')
          end

          context 'with MAINTAINER access_level, in integer format' do
            let_it_be(:params) { { access_level: Gitlab::Access::MAINTAINER } }

            it_behaves_like 'token creation fails'
            it_behaves_like 'correct error message'
          end

          context 'with MAINTAINER access_level, in string format' do
            let_it_be(:params) { { access_level: Gitlab::Access::MAINTAINER.to_s } }

            it_behaves_like 'token creation fails'
            it_behaves_like 'correct error message'
          end
        end
      end

      it 'logs the event' do
        allow(Gitlab::AppLogger).to receive(:info)

        response = subject

        expect(Gitlab::AppLogger).to have_received(:info).with(/PROJECT ACCESS TOKEN CREATION: created_by: #{user.username}, project_id: #{resource.id}, token_user: #{response.payload[:access_token].user.name}, token_id: \d+/)
      end
    end

    shared_examples 'when user does not have permission to create a resource bot' do
      let(:error_message) { ""User does not have permission to create #{resource_type} access token"" }

      it_behaves_like 'token creation fails'
      it_behaves_like 'correct error message'
    end

    context 'when resource is a project' do
      let_it_be(:resource_type) { 'project' }
      let_it_be(:resource) { project }

      it_behaves_like 'when user does not have permission to create a resource bot'

      context 'user with valid permission' do
        before_all do
          resource.add_maintainer(user)
        end

        it_behaves_like 'allows creation of bot with valid params'

        context 'when user specifies an access level of OWNER for the bot' do
          let_it_be(:params) { { access_level: Gitlab::Access::OWNER } }

          context 'when the executor is a MAINTAINER' do
            let(:error_message) { 'Could not provision owner access to project access token' }

            context 'with OWNER access_level, in integer format' do
              it_behaves_like 'token creation fails'
              it_behaves_like 'correct error message'
            end

            context 'with OWNER access_level, in string format' do
              let(:error_message) { 'Could not provision owner access to project access token' }
              let_it_be(:params) { { access_level: Gitlab::Access::OWNER.to_s } }

              it_behaves_like 'token creation fails'
              it_behaves_like 'correct error message'
            end
          end

          context 'when the executor is an OWNER' do
            let_it_be(:user) { project.first_owner }

            it 'adds the bot user with the specified access level in the resource' do
              response = subject

              access_token = response.payload[:access_token]
              bot_user = access_token.user

              expect(resource.members.owners.map(&:user_id)).to include(bot_user.id)
            end
          end
        end
      end
    end

    context 'when resource is a group' do
      let_it_be(:resource_type) { 'group' }
      let_it_be(:resource) { group }

      it_behaves_like 'when user does not have permission to create a resource bot'

      context 'user with valid permission' do
        before_all do
          resource.add_owner(user)
        end

        it_behaves_like 'allows creation of bot with valid params'

        context 'when user specifies an access level of OWNER for the bot' do
          let_it_be(:params) { { access_level: Gitlab::Access::OWNER } }

          it 'adds the bot user with the specified access level in the resource' do
            response = subject
            access_token = response.payload[:access_token]
            bot_user = access_token.user

            expect(resource.members.owners.map(&:user_id)).to include(bot_user.id)
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Repositories
  class ReplicateService < Repositories::BaseService
    Error = Class.new(StandardError)

    def execute(new_repository, type)
      new_repository.replicate(repository)

      new_checksum = new_repository.checksum
      checksum = repository.checksum

      return if new_checksum == checksum

      raise Error, format(s_(
        'ReplicateService|Failed to verify %{type} repository checksum from %{old} to %{new}'
      ), type: type, old: checksum, new: new_checksum)
    rescue StandardError => e
      new_repository.remove

      raise e
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Repositories::ReplicateService, feature_category: :source_code_management do
  let(:new_checksum) { 'match' }
  let(:repository) { instance_double('Gitlab::Git::Repository', checksum: 'match') }
  let(:new_repository) { instance_double('Gitlab::Git::Repository', checksum: new_checksum) }

  subject { described_class.new(repository) }

  it 'replicates repository' do
    expect(new_repository).to receive(:replicate).with(repository)
    expect(new_repository).not_to receive(:remove)

    expect { subject.execute(new_repository, :project) }.not_to raise_error
  end

  context 'when checksum does not match' do
    let(:new_checksum) { 'does not match' }

    it 'raises an error and removes new repository' do
      expect(new_repository).to receive(:replicate).with(repository)
      expect(new_repository).to receive(:remove)

      expect do
        subject.execute(new_repository, :project)
      end.to raise_error(described_class::Error, /Failed to verify project repository/)
    end
  end

  context 'when an error is raised during checksum calculation' do
    it 'raises the error and removes new repository' do
      error = StandardError.new

      expect(new_repository).to receive(:replicate).with(repository)
      expect(new_repository).to receive(:checksum).and_raise(error)
      expect(new_repository).to receive(:remove)

      expect do
        subject.execute(new_repository, :project)
      end.to raise_error(error)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Used for git housekeeping
#
# Ex.
#   Repositories::HousekeepingService.new(project).execute
#   Repositories::HousekeepingService.new(project.wiki).execute
#
module Repositories
  class HousekeepingService < BaseService
    # Timeout set to 24h
    LEASE_TIMEOUT = 86400
    GC_PERIOD = 200

    class LeaseTaken < StandardError
      def to_s
        ""Somebody already triggered housekeeping for this resource in the past #{LEASE_TIMEOUT / 60} minutes""
      end
    end

    def initialize(resource, task = nil)
      @resource = resource
      @task = task
    end

    def execute
      lease_uuid = try_obtain_lease
      raise LeaseTaken unless lease_uuid.present?

      yield if block_given?

      execute_gitlab_shell_gc(lease_uuid)
    end

    def needed?
      pushes_since_gc > 0 && period_match? && housekeeping_enabled?
    end

    def increment!
      Gitlab::Metrics.measure(:increment_pushes_since_gc) do
        @resource.increment_pushes_since_gc
      end
    end

    private

    def execute_gitlab_shell_gc(lease_uuid)
      @resource.git_garbage_collect_worker_klass.perform_async(@resource.id, task, lease_key, lease_uuid)
    ensure
      if pushes_since_gc >= gc_period
        Gitlab::Metrics.measure(:reset_pushes_since_gc) do
          @resource.reset_pushes_since_gc
        end
      end
    end

    def try_obtain_lease
      Gitlab::Metrics.measure(:obtain_housekeeping_lease) do
        lease = ::Gitlab::ExclusiveLease.new(lease_key, timeout: LEASE_TIMEOUT)
        lease.try_obtain
      end
    end

    def lease_key
      ""#{@resource.class.name.underscore.pluralize}_housekeeping:#{@resource.id}""
    end

    def pushes_since_gc
      @resource.pushes_since_gc
    end

    def task
      return @task if @task

      if pushes_since_gc % gc_period == 0
        :gc
      else
        :incremental_repack
      end
    end

    def period_match?
      [gc_period, repack_period].any? { |period| pushes_since_gc % period == 0 }
    end

    def housekeeping_enabled?
      Gitlab::CurrentSettings.housekeeping_enabled
    end

    def gc_period
      GC_PERIOD
    end

    def repack_period
      Gitlab::CurrentSettings.housekeeping_incremental_repack_period
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Repositories::HousekeepingService, feature_category: :source_code_management do
  it_behaves_like 'housekeeps repository' do
    let_it_be(:resource) { create(:project, :repository) }
  end

  it_behaves_like 'housekeeps repository' do
    let_it_be(:project) { create(:project, :wiki_repo) }
    let_it_be(:resource) { project.wiki }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Repositories
  # A service class for generating a changelog section.
  class ChangelogService
    DEFAULT_TRAILER = 'Changelog'
    DEFAULT_FILE = 'CHANGELOG.md'

    # The maximum number of commits allowed to fetch in `from` and `to` range.
    #
    # This value is arbitrarily chosen. Increasing it means more Gitaly calls
    # and more presure on Gitaly services.
    #
    # This number is 3x of the average number of commits per GitLab releases.
    # Some examples for GitLab's own releases:
    #
    # * 13.6.0: 4636 commits
    # * 13.5.0: 5912 commits
    # * 13.4.0: 5541 commits
    COMMITS_LIMIT = 15_000

    # The `project` specifies the `Project` to generate the changelog section
    # for.
    #
    # The `user` argument specifies a `User` to use for committing the changes
    # to the Git repository.
    #
    # The `version` arguments must be a version `String` using semantic
    # versioning as the format.
    #
    # The arguments `from` and `to` must specify a Git ref or SHA to use for
    # fetching the commits to include in the changelog. The SHA/ref set in the
    # `from` argument isn't included in the list.
    #
    # The `date` argument specifies the date of the release, and defaults to the
    # current time/date.
    #
    # The `branch` argument specifies the branch to commit the changes to. The
    # branch must already exist.
    #
    # The `trailer` argument is the Git trailer to use for determining what
    # commits to include in the changelog.
    #
    # The `config_file` arguments specifies the path to the configuration file as
    # stored in the project's Git repository.
    #
    # The `file` arguments specifies the name/path of the file to commit the
    # changes to. If the file doesn't exist, it's created automatically.
    #
    # The `message` argument specifies the commit message to use when committing
    # the changelog changes.
    #
    # rubocop: disable Metrics/ParameterLists
    def initialize(
      project,
      user,
      version:,
      branch: project.default_branch_or_main,
      from: nil,
      to: branch,
      date: DateTime.now,
      trailer: DEFAULT_TRAILER,
      config_file: Gitlab::Changelog::Config::DEFAULT_FILE_PATH,
      file: DEFAULT_FILE,
      message: ""Add changelog for version #{version}""
    )
      @project = project
      @user = user
      @version = version
      @from = from
      @to = to
      @date = date
      @branch = branch
      @trailer = trailer
      @config_file = config_file
      @file = file
      @message = message
    end
    # rubocop: enable Metrics/ParameterLists

    def execute(commit_to_changelog: true)
      config = Gitlab::Changelog::Config.from_git(@project, @user, @config_file)
      from = start_of_commit_range(config)

      # For every entry we want to only include the merge request that
      # originally introduced the commit, which is the oldest merge request that
      # contains the commit. We fetch there merge requests in batches, reducing
      # the number of SQL queries needed to get this data.
      mrs_finder = MergeRequests::OldestPerCommitFinder.new(@project)
      release = Gitlab::Changelog::Release
        .new(version: @version, date: @date, config: config)

      commits =
        ChangelogCommitsFinder.new(project: @project, from: from, to: @to)

      verify_commit_range!(from, @to)

      commits.each_page(@trailer) do |page|
        mrs = mrs_finder.execute(page)

        # Preload the authors. This ensures we only need a single SQL query per
        # batch of commits, instead of needing a query for every commit.
        page.each(&:lazy_author)

        # Preload author permissions
        @project.team.max_member_access_for_user_ids(page.map(&:author).compact.map(&:id))

        page.each do |commit|
          release.add_entry(
            title: commit.title,
            commit: commit,
            category: commit.trailers.fetch(@trailer),
            author: commit.author,
            merge_request: mrs[commit.id]
          )
        end
      end

      if commit_to_changelog
        Gitlab::Changelog::Committer
          .new(@project, @user)
          .commit(release: release, file: @file, branch: @branch, message: @message)
      else
        Gitlab::Changelog::Generator.new.add(release)
      end
    end

    def start_of_commit_range(config)
      return @from if @from

      finder = ChangelogTagFinder.new(@project, regex: config.tag_regex)

      if (prev_tag = finder.execute(@version))
        return prev_tag.target_commit.id
      end

      raise(
        Gitlab::Changelog::Error,
        'The commit start range is unspecified, and no previous tag ' \
          'could be found to use instead'
      )
    end

    def verify_commit_range!(from, to)
      return unless Feature.enabled?(:changelog_commits_limitation, @project)

      commits = @project.repository.commits_by(oids: [from, to])

      raise Gitlab::Changelog::Error, ""Invalid or not found commit value in the given range"" unless commits.count == 2

      _, commits_count = @project.repository.diverging_commit_count(from, to)

      if commits_count > COMMITS_LIMIT
        raise Gitlab::Changelog::Error, ""The commits range exceeds #{COMMITS_LIMIT} elements.""
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Repositories::ChangelogService, feature_category: :source_code_management do
  describe '#execute' do
    let!(:project) { create(:project, :empty_repo) }
    let!(:creator) { project.creator }
    let!(:author1) { create(:user) }
    let!(:author2) { create(:user) }
    let!(:mr1) { create(:merge_request, :merged, target_project: project) }
    let!(:mr2) { create(:merge_request, :merged, target_project: project) }

    # The range of commits ignores the first commit, but includes the last
    # commit. To ensure both the commits below are included, we must create an
    # extra commit.
    #
    # In the real world, the start commit of the range will be the last commit
    # of the previous release, so ignoring that is expected and desired.
    let!(:sha1) do
      create_commit(
        project,
        creator,
        commit_message: 'Initial commit',
        actions: [{ action: 'create', content: 'test', file_path: 'README.md' }]
      )
    end

    let!(:sha2) do
      project.add_maintainer(author1)

      create_commit(
        project,
        author1,
        commit_message: ""Title 1\n\nChangelog: feature"",
        actions: [{ action: 'create', content: 'foo', file_path: 'a.txt' }]
      )
    end

    let!(:sha3) do
      project.add_maintainer(author2)

      create_commit(
        project,
        author2,
        commit_message: ""Title 2\n\nChangelog: feature"",
        actions: [{ action: 'create', content: 'bar', file_path: 'b.txt' }]
      )
    end

    let!(:sha4) do
      create_commit(
        project,
        author2,
        commit_message: ""Title 3\n\nChangelog: feature"",
        actions: [{ action: 'create', content: 'bar', file_path: 'c.txt' }]
      )
    end

    let!(:commit1) { project.commit(sha2) }
    let!(:commit2) { project.commit(sha3) }
    let!(:commit3) { project.commit(sha4) }

    let(:commit_to_changelog) { true }

    it 'generates and commits a changelog section' do
      allow(MergeRequestDiffCommit)
        .to receive(:oldest_merge_request_id_per_commit)
        .with(project.id, [commit2.id, commit1.id])
        .and_return(
          [
            { sha: sha2, merge_request_id: mr1.id },
            { sha: sha3, merge_request_id: mr2.id }
          ])

      service = described_class
        .new(project, creator, version: '1.0.0', from: sha1, to: sha3)

      recorder = ActiveRecord::QueryRecorder.new { service.execute(commit_to_changelog: commit_to_changelog) }
      changelog = project.repository.blob_at('master', 'CHANGELOG.md')&.data

      expect(recorder.count).to eq(12)
      expect(changelog).to include('Title 1', 'Title 2')
    end

    it ""ignores a commit when it's both added and reverted in the same range"" do
      create_commit(
        project,
        author2,
        commit_message: ""Title 4\n\nThis reverts commit #{sha4}"",
        actions: [{ action: 'create', content: 'bar', file_path: 'd.txt' }]
      )

      described_class
        .new(project, creator, version: '1.0.0', from: sha1)
        .execute(commit_to_changelog: commit_to_changelog)

      changelog = project.repository.blob_at('master', 'CHANGELOG.md')&.data

      expect(changelog).to include('Title 1', 'Title 2')
      expect(changelog).not_to include('Title 3', 'Title 4')
    end

    it 'includes a revert commit when it has a trailer' do
      create_commit(
        project,
        author2,
        commit_message: ""Title 4\n\nThis reverts commit #{sha4}\n\nChangelog: added"",
        actions: [{ action: 'create', content: 'bar', file_path: 'd.txt' }]
      )

      described_class
        .new(project, creator, version: '1.0.0', from: sha1)
        .execute(commit_to_changelog: commit_to_changelog)

      changelog = project.repository.blob_at('master', 'CHANGELOG.md')&.data

      expect(changelog).to include('Title 1', 'Title 2', 'Title 4')
      expect(changelog).not_to include('Title 3')
    end

    it 'uses the target branch when ""to"" is unspecified' do
      described_class
        .new(project, creator, version: '1.0.0', from: sha1)
        .execute(commit_to_changelog: commit_to_changelog)

      changelog = project.repository.blob_at('master', 'CHANGELOG.md')&.data

      expect(changelog).to include('Title 1', 'Title 2', 'Title 3')
    end

    describe 'with commit_to_changelog: false' do
      let(:commit_to_changelog) { false }

      it 'generates changelog section' do
        allow(MergeRequestDiffCommit)
          .to receive(:oldest_merge_request_id_per_commit)
          .with(project.id, [commit2.id, commit1.id])
          .and_return(
            [
              { sha: sha2, merge_request_id: mr1.id },
              { sha: sha3, merge_request_id: mr2.id }
            ])

        service = described_class
          .new(project, creator, version: '1.0.0', from: sha1, to: sha3)

        changelog = service.execute(commit_to_changelog: commit_to_changelog)

        expect(changelog).to include('Title 1', 'Title 2')
      end
    end

    it 'avoids N+1 queries', :request_store do
      RequestStore.clear!

      request = ->(to) do
        described_class
          .new(project, creator, version: '1.0.0', from: sha1, to: to)
          .execute(commit_to_changelog: false)
      end

      control = ActiveRecord::QueryRecorder.new { request.call(sha2) }

      RequestStore.clear!

      expect { request.call(sha3) }.not_to exceed_query_limit(control.count)
    end

    context 'when one of commits does not exist' do
      let(:service) { described_class.new(project, creator, version: '1.0.0', from: 'master', to: '54321') }

      it 'raises an exception' do
        expect { service.execute(commit_to_changelog: false) }.to raise_error(Gitlab::Changelog::Error)
      end
    end

    context 'when commit range exceeds the limit' do
      let(:service) { described_class.new(project, creator, version: '1.0.0', from: sha1) }

      before do
        stub_const(""#{described_class.name}::COMMITS_LIMIT"", 2)
      end

      it 'raises an exception' do
        expect { service.execute(commit_to_changelog: false) }.to raise_error(Gitlab::Changelog::Error)
      end

      context 'when feature flag is off' do
        before do
          stub_feature_flags(changelog_commits_limitation: false)
        end

        it 'returns the changelog' do
          expect(service.execute(commit_to_changelog: false)).to include('Title 1', 'Title 2', 'Title 3')
        end
      end
    end

    context 'with specified changelog config file path' do
      it 'return specified changelog content' do
        config = Gitlab::Changelog::Config.from_hash(project, { 'template' => 'specified_changelog_content' }, creator)

        allow(Gitlab::Changelog::Config)
          .to receive(:from_git)
          .with(project, creator, 'specified_changelog_config.yml')
          .and_return(config)

        described_class
          .new(project, creator, version: '1.0.0', from: sha1, config_file: 'specified_changelog_config.yml')
          .execute(commit_to_changelog: commit_to_changelog)

        changelog = project.repository.blob_at('master', 'CHANGELOG.md')&.data

        expect(changelog).to include('specified_changelog_content')
      end
    end
  end

  describe '#start_of_commit_range' do
    let(:project) { build_stubbed(:project) }
    let(:user) { build_stubbed(:user) }
    let(:config) { Gitlab::Changelog::Config.new(project) }

    context 'when the ""from"" argument is specified' do
      it 'returns the value of the argument' do
        service = described_class
          .new(project, user, version: '1.0.0', from: 'foo', to: 'bar')

        expect(service.start_of_commit_range(config)).to eq('foo')
      end
    end

    context 'when the ""from"" argument is unspecified' do
      it 'returns the tag commit of the previous version' do
        service = described_class
          .new(project, user, version: '1.0.0', to: 'bar')

        finder_spy = instance_spy(Repositories::ChangelogTagFinder)
        tag = double(:tag, target_commit: double(:commit, id: '123'))

        allow(Repositories::ChangelogTagFinder)
          .to receive(:new)
          .with(project, regex: an_instance_of(String))
          .and_return(finder_spy)

        allow(finder_spy)
          .to receive(:execute)
          .with('1.0.0')
          .and_return(tag)

        expect(service.start_of_commit_range(config)).to eq('123')
      end

      it 'raises an error when no tag is found' do
        service = described_class
          .new(project, user, version: '1.0.0', to: 'bar')

        finder_spy = instance_spy(Repositories::ChangelogTagFinder)

        allow(Repositories::ChangelogTagFinder)
          .to receive(:new)
          .with(project, regex: an_instance_of(String))
          .and_return(finder_spy)

        allow(finder_spy)
          .to receive(:execute)
          .with('1.0.0')
          .and_return(nil)

        expect { service.start_of_commit_range(config) }
          .to raise_error(Gitlab::Changelog::Error)
      end
    end
  end

  def create_commit(project, user, params)
    params = { start_branch: 'master', branch_name: 'master' }.merge(params)
    Files::MultiService.new(project, user, params).execute.fetch(:result)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class Repositories::DestroyService < Repositories::BaseService
  def execute
    return success unless repository
    return success unless repo_exists?(disk_path)

    # Flush the cache for both repositories. This has to be done _before_
    # removing the physical repositories as some expiration code depends on
    # Git data (e.g. a list of branch names).
    ignore_git_errors { repository.before_delete }

    # Use variables that aren't methods on Project, because they are used in a callback
    current_storage = repository.shard
    current_path = ""#{disk_path}.git""

    # Because #remove happens inside a run_after_commit callback it will
    # never be triggered on a read-only instance.
    #
    # Issue: https://gitlab.com/gitlab-org/gitlab/-/issues/223272
    if Gitlab::Database.read_only?
      Gitlab::Git::Repository.new(current_storage, current_path, nil, nil).remove
    else
      container.run_after_commit do
        Gitlab::Git::Repository.new(current_storage, current_path, nil, nil).remove
      end
    end

    log_info(""Repository \""#{full_path}\"" was removed"")

    success
  rescue Gitlab::Git::Repository::NoRepository
    success
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Repositories::DestroyService, feature_category: :source_code_management do
  let_it_be(:user) { create(:user) }

  let!(:project) { create(:project, :repository, namespace: user.namespace) }
  let(:repository) { project.repository }
  let(:path) { repository.disk_path }

  subject { described_class.new(repository).execute }

  it 'removes the repository' do
    expect(project.gitlab_shell.repository_exists?(project.repository_storage, path + '.git')).to be_truthy

    subject

    # Because the removal happens inside a run_after_commit callback we need to
    # trigger the callback
    project.touch

    expect(project.gitlab_shell.repository_exists?(project.repository_storage, path + '.git')).to be_falsey
  end

  context 'on a read-only instance' do
    before do
      allow(Gitlab::Database).to receive(:read_only?).and_return(true)
    end

    it 'schedules the repository deletion' do
      expect(project.gitlab_shell.repository_exists?(project.repository_storage, path + '.git')).to be_truthy

      subject

      expect(project.gitlab_shell.repository_exists?(project.repository_storage, path + '.git')).to be_falsey
    end
  end

  it 'flushes the repository cache' do
    expect(repository).to receive(:before_delete)

    subject
  end

  it 'does not perform any action if repository path does not exist and returns success' do
    expect(repository).to receive(:disk_path).and_return('foo')
    expect(repository).not_to receive(:before_delete)

    expect(subject[:status]).to eq :success
  end

  it 'gracefully handles exception if the repository does not exist on disk' do
    expect(repository).to receive(:before_delete).and_raise(Gitlab::Git::Repository::NoRepository)
    expect(subject[:status]).to eq :success
  end

  context 'with a project wiki repository' do
    let(:project) { create(:project, :wiki_repo) }
    let(:repository) { project.wiki.repository }

    it 'schedules the repository deletion' do
      expect(project.gitlab_shell.repository_exists?(project.repository_storage, path + '.git')).to be_truthy

      subject

      # Because the removal happens inside a run_after_commit callback we need to
      # trigger the callback
      project.touch

      expect(project.gitlab_shell.repository_exists?(project.repository_storage, path + '.git')).to be_falsey
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Groups
  # Service class for counting and caching the number of open merge requests of a group.
  class MergeRequestsCountService < Groups::CountService
    private

    def cache_key_name
      'open_merge_requests_count'
    end

    def relation_for_count
      MergeRequestsFinder
      .new(user, group_id: group.id, state: 'opened', non_archived: true, include_subgroups: true)
      .execute
    end

    def issuable_key
      'open_merge_requests'
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Groups::MergeRequestsCountService, :use_clean_rails_memory_store_caching, feature_category: :groups_and_projects do
  let_it_be(:user) { create(:user) }
  let_it_be(:group) { create(:group, :public) }
  let_it_be(:project) { create(:project, :repository, namespace: group) }
  let_it_be(:merge_request) { create(:merge_request, source_project: project, target_project: project) }

  subject { described_class.new(group, user) }

  describe '#relation_for_count' do
    before do
      group.add_reporter(user)
      allow(MergeRequestsFinder).to receive(:new).and_call_original
    end

    it 'uses the MergeRequestsFinder to scope merge requests' do
      expect(MergeRequestsFinder)
        .to receive(:new)
        .with(user, group_id: group.id, state: 'opened', non_archived: true, include_subgroups: true)

      subject.count
    end
  end

  it_behaves_like 'a counter caching service with threshold'
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Groups
  class AutocompleteService < Groups::BaseService
    include LabelsAsHash

    # rubocop: disable CodeReuse/ActiveRecord
    def issues(confidential_only: false, issue_types: nil)
      finder_params = { group_id: group.id, include_subgroups: true, state: 'opened' }
      finder_params[:confidential] = true if confidential_only.present?
      finder_params[:issue_types] = issue_types if issue_types.present?

      IssuesFinder.new(current_user, finder_params)
        .execute
        .preload(project: :namespace)
        .select(:iid, :title, :project_id, :namespace_id)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    # rubocop: disable CodeReuse/ActiveRecord
    def merge_requests
      MergeRequestsFinder.new(current_user, group_id: group.id, include_subgroups: true, state: 'opened')
        .execute
        .preload(target_project: :namespace)
        .select(:iid, :title, :target_project_id)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    # rubocop: disable CodeReuse/ActiveRecord
    def milestones
      group_ids = group.self_and_ancestors.public_or_visible_to_user(current_user).pluck(:id)

      MilestonesFinder.new(group_ids: group_ids).execute.select(:iid, :title, :due_date)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def labels_as_hash(target)
      super(target, group_id: group.id, only_group_labels: true, include_ancestor_groups: true)
    end

    def commands(noteable)
      return [] unless noteable

      QuickActions::InterpretService.new(nil, current_user).available_commands(noteable)
    end
  end
end

Groups::AutocompleteService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Groups::AutocompleteService, feature_category: :groups_and_projects do
  let_it_be(:group, refind: true) { create(:group, :nested, :private, avatar: fixture_file_upload('spec/fixtures/dk.png')) }
  let_it_be(:sub_group) { create(:group, :private, parent: group) }

  let(:user) { create(:user) }

  subject { described_class.new(group, user) }

  before do
    group.add_developer(user)
  end

  def expect_labels_to_equal(labels, expected_labels)
    extract_title = lambda { |label| label['title'] }
    expect(labels.map(&extract_title)).to match_array(expected_labels.map(&extract_title))
  end

  describe '#labels_as_hash' do
    let!(:label1) { create(:group_label, group: group) }
    let!(:label2) { create(:group_label, group: group) }
    let!(:sub_group_label) { create(:group_label, group: sub_group) }
    let!(:parent_group_label) { create(:group_label, group: group.parent) }

    it 'returns labels from own group and ancestor groups' do
      results = subject.labels_as_hash(nil)

      expected_labels = [label1, label2, parent_group_label]

      expect_labels_to_equal(results, expected_labels)
    end
  end

  describe '#issues' do
    let(:project) { create(:project, group: group) }
    let(:sub_group_project) { create(:project, group: sub_group) }

    let!(:project_issue) { create(:issue, project: project) }
    let!(:sub_group_project_issue) { create(:issue, confidential: true, project: sub_group_project) }

    it 'returns issues in group and subgroups' do
      issues = subject.issues

      expect(issues.map(&:iid)).to contain_exactly(project_issue.iid, sub_group_project_issue.iid)
      expect(issues.map(&:title)).to contain_exactly(project_issue.title, sub_group_project_issue.title)
    end

    it 'returns only confidential issues if confidential_only is true' do
      issues = subject.issues(confidential_only: true)

      expect(issues.map(&:iid)).to contain_exactly(sub_group_project_issue.iid)
      expect(issues.map(&:title)).to contain_exactly(sub_group_project_issue.title)
    end
  end

  describe '#merge_requests' do
    let(:project) { create(:project, :repository, group: group) }
    let(:sub_group_project) { create(:project, :repository, group: sub_group) }

    let!(:project_mr) { create(:merge_request, source_project: project) }
    let!(:sub_group_project_mr) { create(:merge_request, source_project: sub_group_project) }

    it 'returns merge requests in group and subgroups' do
      expect(subject.merge_requests.map(&:iid)).to contain_exactly(project_mr.iid, sub_group_project_mr.iid)
      expect(subject.merge_requests.map(&:title)).to contain_exactly(project_mr.title, sub_group_project_mr.title)
    end
  end

  describe '#milestones' do
    let!(:group_milestone) { create(:milestone, group: group) }
    let!(:subgroup_milestone) { create(:milestone, group: sub_group) }

    before do
      sub_group.add_maintainer(user)
    end

    context 'when group is public' do
      let(:public_group) { create(:group, :public) }
      let(:public_subgroup) { create(:group, :public, parent: public_group) }

      before do
        group_milestone.update!(group: public_group)
        subgroup_milestone.update!(group: public_subgroup)
      end

      it 'returns milestones from groups and subgroups' do
        subject = described_class.new(public_subgroup, user)

        expect(subject.milestones.map(&:iid)).to contain_exactly(group_milestone.iid, subgroup_milestone.iid)
        expect(subject.milestones.map(&:title)).to contain_exactly(group_milestone.title, subgroup_milestone.title)
      end
    end

    it 'returns milestones from group' do
      expect(subject.milestones.map(&:iid)).to contain_exactly(group_milestone.iid)
      expect(subject.milestones.map(&:title)).to contain_exactly(group_milestone.title)
    end

    it 'returns milestones from groups and subgroups' do
      milestones = described_class.new(sub_group, user).milestones

      expect(milestones.map(&:iid)).to contain_exactly(group_milestone.iid, subgroup_milestone.iid)
      expect(milestones.map(&:title)).to contain_exactly(group_milestone.title, subgroup_milestone.title)
    end

    it 'returns only milestones that user can read' do
      user = create(:user)
      sub_group.add_guest(user)

      milestones = described_class.new(sub_group, user).milestones

      expect(milestones.map(&:iid)).to contain_exactly(subgroup_milestone.iid)
      expect(milestones.map(&:title)).to contain_exactly(subgroup_milestone.title)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Groups
  class ParticipantsService < Groups::BaseService
    include Gitlab::Utils::StrongMemoize
    include Users::ParticipableService

    def execute(noteable)
      @noteable = noteable

      participants =
        noteable_owner +
        participants_in_noteable +
        all_members +
        groups +
        group_hierarchy_users

      render_participants_as_hash(participants.uniq)
    end

    private

    def all_members
      return [] if group.nil? || Feature.enabled?(:disable_all_mention)

      [{ username: ""all"", name: ""All Group Members"", count: group.users_count }]
    end

    def group_hierarchy_users
      return [] unless group

      sorted(Autocomplete::GroupUsersFinder.new(group: group).execute)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Groups::ParticipantsService, feature_category: :groups_and_projects do
  describe '#execute' do
    let_it_be(:developer) { create(:user) }
    let_it_be(:parent_group) { create(:group) }
    let_it_be(:group) { create(:group, parent: parent_group) }
    let_it_be(:subgroup) { create(:group, parent: group) }
    let_it_be(:subproject) { create(:project, group: subgroup) }

    let(:service) { described_class.new(group, developer) }

    subject(:service_result) { service.execute(nil) }

    before_all do
      parent_group.add_developer(developer)
    end

    before do
      stub_feature_flags(disable_all_mention: false)
    end

    it 'includes `All Group Members`' do
      group.add_developer(create(:user))

      # These should not be included in the count for the @all entry
      subgroup.add_developer(create(:user))
      subproject.add_developer(create(:user))

      expect(service_result).to include(a_hash_including({ username: ""all"", name: ""All Group Members"", count: 1 }))
    end

    context 'when `disable_all_mention` FF is enabled' do
      before do
        stub_feature_flags(disable_all_mention: true)
      end

      it 'does not include `All Group Members`' do
        expect(service_result).not_to include(a_hash_including({ username: ""all"", name: ""All Group Members"" }))
      end
    end

    it 'returns all members in parent groups, sub-groups, and sub-projects' do
      parent_group.add_developer(create(:user))
      subgroup.add_developer(create(:user))
      subproject.add_developer(create(:user))

      expected_users = (group.self_and_hierarchy.flat_map(&:users) + subproject.users)
        .map { |user| user_to_autocompletable(user) }

      expect(expected_users.count).to eq(4)
      expect(service_result).to include(*expected_users)
    end

    context 'when shared with a private group' do
      let_it_be(:private_group_member) { create(:user) }
      let_it_be(:private_group) { create(:group, :private, :nested) }

      before_all do
        private_group.add_owner(private_group_member)

        create(:group_group_link, shared_group: parent_group, shared_with_group: private_group)
      end

      subject(:usernames) { service_result.pluck(:username) }

      it { is_expected.to include(private_group_member.username) }
    end
  end

  def user_to_autocompletable(user)
    {
      type: user.class.name,
      username: user.username,
      name: user.name,
      avatar_url: user.avatar_url,
      availability: user&.status&.availability
    }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Groups
  class TransferService < Groups::BaseService
    TransferError = Class.new(StandardError)

    attr_reader :error, :new_parent_group

    def initialize(group, user, params = {})
      super
      @error = nil
    end

    def log_group_transfer_success(group, new_parent_group)
      log_transfer(group, new_parent_group, nil)
    end

    def log_group_transfer_error(group, new_parent_group, error_message)
      log_transfer(group, new_parent_group, error_message)
    end

    def execute(new_parent_group)
      @new_parent_group = new_parent_group
      ensure_allowed_transfer
      proceed_to_transfer

      log_group_transfer_success(@group, @new_parent_group)

    rescue TransferError, ActiveRecord::RecordInvalid, Gitlab::UpdatePathError => e
      @group.errors.clear
      @error = s_(""TransferGroup|Transfer failed: %{error_message}"") % { error_message: e.message }

      log_group_transfer_error(@group, @new_parent_group, e.message)

      false
    end

    private

    def log_transfer(group, new_namespace, error_message = nil)
      action = error_message.nil? ? ""was"" : ""was not""

      log_payload = {
        message: ""Group #{action} transferred to a new namespace"",
        group_path: group.full_path,
        group_id: group.id,
        new_parent_group_path: new_parent_group&.full_path,
        new_parent_group_id: new_parent_group&.id,
        error_message: error_message
      }

      if error_message.nil?
        ::Gitlab::AppLogger.info(log_payload)
      else
        ::Gitlab::AppLogger.error(log_payload)
      end
    end

    def proceed_to_transfer
      old_root_ancestor_id = @group.root_ancestor.id
      was_root_group = @group.root?

      Gitlab::Database::QueryAnalyzers::PreventCrossDatabaseModification.temporary_ignore_tables_in_transaction(
        %w[routes redirect_routes], url: 'https://gitlab.com/gitlab-org/gitlab/-/issues/424280'
      ) do
        Group.transaction do
          update_group_attributes
          ensure_ownership
          update_integrations
          remove_issue_contacts(old_root_ancestor_id, was_root_group)
          update_crm_objects(was_root_group)
          remove_namespace_commit_emails(was_root_group)
        end
      end

      post_update_hooks(@updated_project_ids, old_root_ancestor_id)
      propagate_integrations
      update_pending_builds

      true
    end

    # Overridden in EE
    def post_update_hooks(updated_project_ids, old_root_ancestor_id)
      refresh_project_authorizations
      refresh_descendant_groups if @new_parent_group
      publish_event(old_root_ancestor_id)
    end

    # Overridden in EE
    def ensure_allowed_transfer
      raise_transfer_error(:group_is_already_root) if group_is_already_root?
      raise_transfer_error(:same_parent_as_current) if same_parent?
      raise_transfer_error(:has_subscription) if has_subscription?
      raise_transfer_error(:invalid_policies) unless valid_policies?
      raise_transfer_error(:namespace_with_same_path) if namespace_with_same_path?
      raise_transfer_error(:group_contains_images) if group_projects_contain_registry_images?
      raise_transfer_error(:cannot_transfer_to_subgroup) if transfer_to_subgroup?
      raise_transfer_error(:group_contains_namespaced_npm_packages) if group_with_namespaced_npm_packages?
      raise_transfer_error(:no_permissions_to_migrate_crm) if no_permissions_to_migrate_crm?
    end

    def no_permissions_to_migrate_crm?
      return false unless group && @new_parent_group
      return false if group.root_ancestor == @new_parent_group.root_ancestor

      return true if group.contacts.exists? && !current_user.can?(:admin_crm_contact, @new_parent_group.root_ancestor)
      return true if group.crm_organizations.exists? && !current_user.can?(:admin_crm_organization, @new_parent_group.root_ancestor)

      false
    end

    def group_with_namespaced_npm_packages?
      return false unless group.packages_feature_enabled?

      npm_packages = ::Packages::GroupPackagesFinder.new(current_user, group, package_type: :npm, preload_pipelines: false).execute
      npm_packages = npm_packages.with_npm_scope(group.root_ancestor.path)

      different_root_ancestor? && npm_packages.exists?
    end

    def different_root_ancestor?
      group.root_ancestor != new_parent_group&.root_ancestor
    end

    def group_is_already_root?
      !@new_parent_group && !@group.has_parent?
    end

    def same_parent?
      @new_parent_group && @new_parent_group.id == @group.parent_id
    end

    def has_subscription?
      @group.paid?
    end

    def transfer_to_subgroup?
      @new_parent_group && \
      @group.self_and_descendants.pluck_primary_key.include?(@new_parent_group.id)
    end

    def valid_policies?
      return false unless can?(current_user, :admin_group, @group)

      if @new_parent_group
        can?(current_user, :create_subgroup, @new_parent_group)
      else
        can?(current_user, :create_group)
      end
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def namespace_with_same_path?
      Namespace.exists?(path: @group.path, parent: @new_parent_group)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def group_projects_contain_registry_images?
      @group.has_container_repository_including_subgroups?
    end

    def update_group_attributes
      if @new_parent_group && @new_parent_group.visibility_level < @group.visibility_level
        update_children_and_projects_visibility
        @group.visibility_level = @new_parent_group.visibility_level
      end

      update_two_factor_authentication if @new_parent_group

      @group.parent = @new_parent_group
      @group.clear_memoization(:self_and_ancestors_ids)
      @group.clear_memoization(:root_ancestor) if different_root_ancestor?

      inherit_group_shared_runners_settings

      @group.save!
      # #reload is called to make sure traversal_ids are reloaded
      @group.reload # rubocop:disable Cop/ActiveRecordAssociationReload
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def update_children_and_projects_visibility
      descendants = @group.descendants.where(""visibility_level > ?"", @new_parent_group.visibility_level)

      Group
        .where(id: descendants.select(:id))
        .update_all(visibility_level: @new_parent_group.visibility_level)

      projects_to_update = @group
        .all_projects
        .where(""visibility_level > ?"", @new_parent_group.visibility_level)

      # Used in post_update_hooks in EE. Must use pluck (and not select)
      # here as after we perform the update below we won't be able to find
      # these records again.
      @updated_project_ids = projects_to_update.pluck(:id)

      Namespaces::ProjectNamespace
        .where(id: projects_to_update.select(:project_namespace_id))
        .update_all(visibility_level: @new_parent_group.visibility_level)

      projects_to_update
        .update_all(visibility_level: @new_parent_group.visibility_level)

      update_project_settings(@updated_project_ids)
    end

    # Overridden in EE
    def update_project_settings(updated_project_ids)
    end

    def update_two_factor_authentication
      return if namespace_parent_allows_two_factor_auth

      @group.require_two_factor_authentication = false
    end

    def refresh_descendant_groups
      return if namespace_parent_allows_two_factor_auth

      if @group.descendants.where(require_two_factor_authentication: true).any?
        DisallowTwoFactorForSubgroupsWorker.perform_async(@group.id)
      end
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def namespace_parent_allows_two_factor_auth
      @new_parent_group.namespace_settings.allow_mfa_for_subgroups
    end

    def ensure_ownership
      return if @new_parent_group
      return unless @group.owners.empty?

      add_owner_on_transferred_group
    end

    # Overridden in EE
    def add_owner_on_transferred_group
      @group.add_owner(current_user)
    end

    def refresh_project_authorizations
      project_ids = Groups::ProjectsRequiringAuthorizationsRefresh::OnTransferFinder.new(@group).execute

      AuthorizedProjectUpdate::ProjectAccessChangedService.new(project_ids).execute
    end

    def raise_transfer_error(message)
      raise TransferError, localized_error_messages[message]
    end

    # Overridden in EE
    def localized_error_messages
      {
        database_not_supported: s_('TransferGroup|Database is not supported.'),
        namespace_with_same_path: s_('TransferGroup|The parent group already has a subgroup or a project with the same path.'),
        group_is_already_root: s_('TransferGroup|Group is already a root group.'),
        same_parent_as_current: s_('TransferGroup|Group is already associated to the parent group.'),
        invalid_policies: s_(""TransferGroup|You don't have enough permissions.""),
        group_contains_images: s_('TransferGroup|Cannot update the path because there are projects under this group that contain Docker images in their Container Registry. Please remove the images from your projects first and try again.'),
        cannot_transfer_to_subgroup: s_('TransferGroup|Cannot transfer group to one of its subgroup.'),
        group_contains_namespaced_npm_packages: s_('TransferGroup|Group contains projects with NPM packages scoped to the current root level group.'),
        no_permissions_to_migrate_crm: s_(""TransferGroup|Group contains contacts/organizations and you don't have enough permissions to move them to the new root group."")
      }.freeze
    end

    def inherit_group_shared_runners_settings
      parent_setting = @group.parent&.shared_runners_setting
      return unless parent_setting

      if @group.shared_runners_setting_higher_than?(parent_setting)
        result = Groups::UpdateSharedRunnersService.new(@group, current_user, shared_runners_setting: parent_setting).execute

        raise TransferError, result[:message] unless result[:status] == :success
      end
    end

    def update_integrations
      @group.integrations.with_default_settings.delete_all
      Integration.create_from_active_default_integrations(@group, :group_id)
    end

    def propagate_integrations
      @group.integrations.with_default_settings.each do |integration|
        PropagateIntegrationWorker.perform_async(integration.id)
      end
    end

    def update_pending_builds
      ::Ci::PendingBuilds::UpdateGroupWorker.perform_async(group.id, pending_builds_params)
    end

    def pending_builds_params
      {
        namespace_traversal_ids: group.traversal_ids,
        namespace_id: group.id
      }
    end

    def update_crm_objects(was_root_group)
      return unless was_root_group

      CustomerRelations::Contact.move_to_root_group(group)
      CustomerRelations::Organization.move_to_root_group(group)
    end

    def remove_issue_contacts(old_root_ancestor_id, was_root_group)
      return if was_root_group
      return if old_root_ancestor_id == @group.root_ancestor.id

      CustomerRelations::IssueContact.delete_for_group(@group)
    end

    def publish_event(old_root_ancestor_id)
      event = ::Groups::GroupTransferedEvent.new(
        data: {
          group_id: group.id,
          old_root_namespace_id: old_root_ancestor_id,
          new_root_namespace_id: group.root_ancestor.id
        }
      )

      Gitlab::EventStore.publish(event)
    end

    def remove_namespace_commit_emails(was_root_group)
      Users::NamespaceCommitEmail.delete_for_namespace(@group) if was_root_group
    end
  end
end

Groups::TransferService.prepend_mod_with('Groups::TransferService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Groups::TransferService, :sidekiq_inline, feature_category: :groups_and_projects do
  shared_examples 'project namespace path is in sync with project path' do
    it 'keeps project and project namespace attributes in sync' do
      projects_with_project_namespace.each do |project|
        project.reload

        expect(project.full_path).to eq(""#{group_full_path}/#{project.path}"")
        expect(project.project_namespace.full_path).to eq(project.full_path)
        expect(project.project_namespace.parent).to eq(project.namespace)
        expect(project.project_namespace.visibility_level).to eq(project.visibility_level)
      end
    end
  end

  let_it_be(:user) { create(:user) }
  let_it_be(:new_parent_group) { create(:group, :public, :crm_enabled) }

  let!(:group_member) { create(:group_member, :owner, group: group, user: user) }
  let(:transfer_service) { described_class.new(group, user) }

  shared_examples 'publishes a GroupTransferedEvent' do
    it do
      expect { transfer_service.execute(target) }
        .to publish_event(Groups::GroupTransferedEvent)
        .with(
          group_id: group.id,
          old_root_namespace_id: group.root_ancestor.id,
          new_root_namespace_id: target.root_ancestor.id
        )
    end
  end

  context 'handling packages' do
    let_it_be(:group) { create(:group) }
    let_it_be(:new_group) { create(:group) }

    let_it_be(:project) { create(:project, namespace: group) }

    before do
      group.add_owner(user)
      new_group&.add_owner(user)
    end

    context 'with an npm package' do
      let_it_be(:npm_package) { create(:npm_package, project: project, name: ""@testscope/test"") }

      shared_examples 'transfer allowed' do
        it 'allows transfer' do
          transfer_service.execute(new_group)

          expect(transfer_service.error).to be nil
          expect(group.parent).to eq(new_group)
        end
      end

      it_behaves_like 'transfer allowed'

      context 'with a project within subgroup' do
        let_it_be(:root_group) { create(:group) }
        let_it_be(:group) { create(:group, parent: root_group) }
        let_it_be(:project) { create(:project, namespace: group) }

        before do
          root_group.add_owner(user)
        end

        it_behaves_like 'transfer allowed'

        context 'without a root namespace change' do
          let_it_be(:new_group) { create(:group, parent: root_group) }

          it_behaves_like 'transfer allowed'
        end

        context 'with namespaced packages present' do
          let_it_be(:package) { create(:npm_package, project: project, name: ""@#{project.root_namespace.path}/test"") }

          it 'does not allow transfer' do
            transfer_service.execute(new_group)

            expect(transfer_service.error).to eq('Transfer failed: Group contains projects with NPM packages scoped to the current root level group.')
            expect(group.parent).not_to eq(new_group)
          end

          context 'namespaced package is pending destruction' do
            let!(:group) { create(:group) }

            before do
              package.pending_destruction!
            end

            it_behaves_like 'transfer allowed'
          end
        end

        context 'when transferring a group into a root group' do
          let_it_be(:root_group) { create(:group) }
          let_it_be(:group) { create(:group, parent: root_group) }
          let_it_be(:new_group) { nil }

          it_behaves_like 'transfer allowed'
        end
      end
    end

    context 'without an npm package' do
      context 'when transferring a group into a root group' do
        let(:group) { create(:group, parent: create(:group)) }

        it 'allows transfer' do
          transfer_service.execute(nil)

          expect(transfer_service.error).to be nil
          expect(group.parent).to be_nil
        end
      end
    end
  end

  shared_examples 'ensuring allowed transfer for a group' do
    context ""when there's an exception on GitLab shell directories"" do
      before do
        allow_next_instance_of(described_class) do |instance|
          allow(instance).to receive(:update_group_attributes).and_raise(Gitlab::UpdatePathError, 'namespace directory cannot be moved')
        end
        create(:group_member, :owner, group: new_parent_group, user: user)
      end

      it 'returns false' do
        expect(transfer_service.execute(new_parent_group)).to be_falsy
      end

      it 'adds an error on group' do
        transfer_service.execute(new_parent_group)
        expect(transfer_service.error).to eq('Transfer failed: namespace directory cannot be moved')
      end
    end
  end

  describe '#execute' do
    context 'when transforming a group into a root group' do
      let_it_be_with_reload(:group) { create(:group, :public, :nested) }

      it_behaves_like 'ensuring allowed transfer for a group'

      context 'when the group is already a root group' do
        let(:group) { create(:group, :public) }

        it 'adds an error on group' do
          transfer_service.execute(nil)
          expect(transfer_service.error).to eq('Transfer failed: Group is already a root group.')
        end
      end

      context 'when the user does not have the right policies' do
        let_it_be(:group_member) { create(:group_member, :guest, group: group, user: user) }

        it ""returns false"" do
          expect(transfer_service.execute(nil)).to be_falsy
        end

        it ""adds an error on group"" do
          transfer_service.execute(new_parent_group)
          expect(transfer_service.error).to eq(""Transfer failed: You don't have enough permissions."")
        end
      end

      context 'when there is a group with the same path' do
        let_it_be(:group) { create(:group, :public, :nested, path: 'not-unique') }

        before do
          create(:group, path: 'not-unique')
        end

        it 'returns false' do
          expect(transfer_service.execute(nil)).to be_falsy
        end

        it 'adds an error on group' do
          transfer_service.execute(nil)
          expect(transfer_service.error).to eq('Transfer failed: The parent group already has a subgroup or a project with the same path.')
        end
      end

      context 'when the group is a subgroup and the transfer is valid' do
        let_it_be(:subgroup1) { create(:group, :private, parent: group) }
        let_it_be(:subgroup2) { create(:group, :internal, parent: group) }
        let_it_be(:project1) { create(:project, :repository, :private, namespace: group) }

        before do
          transfer_service.execute(nil)
          group.reload
        end

        it 'updates group attributes' do
          expect(group.parent).to be_nil
        end

        it 'updates group children path' do
          group.children.each do |subgroup|
            expect(subgroup.full_path).to eq(""#{group.path}/#{subgroup.path}"")
          end
        end

        it 'updates group projects path' do
          group.projects.each do |project|
            expect(project.full_path).to eq(""#{group.path}/#{project.path}"")
          end
        end

        context 'when projects have project namespaces' do
          let_it_be(:project1) { create(:project, :private, namespace: group) }
          let_it_be(:project2) { create(:project, :private, namespace: group) }

          it_behaves_like 'project namespace path is in sync with project path' do
            let(:group_full_path) { group.path.to_s }
            let(:projects_with_project_namespace) { [project1, project2] }
          end
        end
      end
    end

    context 'when transferring a subgroup into another group' do
      let_it_be_with_reload(:group) { create(:group, :public, :nested) }

      it_behaves_like 'ensuring allowed transfer for a group'

      context 'when the new parent group is the same as the previous parent group' do
        let_it_be(:group) { create(:group, :public, :nested, parent: new_parent_group) }

        it 'returns false' do
          expect(transfer_service.execute(new_parent_group)).to be_falsy
        end

        it 'adds an error on group' do
          transfer_service.execute(new_parent_group)
          expect(transfer_service.error).to eq('Transfer failed: Group is already associated to the parent group.')
        end
      end

      context 'when the user does not have the right policies' do
        let_it_be(:group_member) { create(:group_member, :guest, group: group, user: user) }

        it ""returns false"" do
          expect(transfer_service.execute(new_parent_group)).to be_falsy
        end

        it ""adds an error on group"" do
          transfer_service.execute(new_parent_group)
          expect(transfer_service.error).to eq(""Transfer failed: You don't have enough permissions."")
        end
      end

      context 'when the parent has a group with the same path' do
        before do
          create(:group_member, :owner, group: new_parent_group, user: user)
          group.update_attribute(:path, ""not-unique"")
          create(:group, path: ""not-unique"", parent: new_parent_group)
        end

        it 'returns false' do
          expect(transfer_service.execute(new_parent_group)).to be_falsy
        end

        it 'adds an error on group' do
          transfer_service.execute(new_parent_group)
          expect(transfer_service.error).to eq('Transfer failed: The parent group already has a subgroup or a project with the same path.')
        end
      end

      context 'when the parent group has a project with the same path' do
        let_it_be_with_reload(:group) { create(:group, :public, :nested, path: 'foo') }
        let_it_be(:membership) { create(:group_member, :owner, group: new_parent_group, user: user) }
        let_it_be(:project) { create(:project, path: 'foo', namespace: new_parent_group) }

        it 'adds an error on group' do
          expect(transfer_service.execute(new_parent_group)).to be_falsy
          expect(transfer_service.error).to eq('Transfer failed: The parent group already has a subgroup or a project with the same path.')
        end
      end

      context 'when projects have project namespaces' do
        let_it_be(:project) { create(:project, path: 'foo', namespace: new_parent_group) }

        before do
          transfer_service.execute(new_parent_group)
        end

        it_behaves_like 'project namespace path is in sync with project path' do
          let(:group_full_path) { new_parent_group.full_path.to_s }
          let(:projects_with_project_namespace) { [project] }
        end
      end

      context 'when the group is allowed to be transferred' do
        let_it_be(:new_parent_group, reload: true) { create(:group, :public) }
        let_it_be(:new_parent_group_integration) { create(:integrations_slack, :group, group: new_parent_group, webhook: 'http://new-group.slack.com') }

        before do
          allow(PropagateIntegrationWorker).to receive(:perform_async)

          create(:group_member, :owner, group: new_parent_group, user: user)

          transfer_service.execute(new_parent_group)
        end

        context 'when the group has a lower visibility than the parent group' do
          let(:new_parent_group) { create(:group, :public) }
          let(:group) { create(:group, :private, :nested) }

          it 'does not update the visibility for the group' do
            group.reload
            expect(group.private?).to be_truthy
            expect(group.visibility_level).not_to eq(new_parent_group.visibility_level)
          end
        end

        context 'when the group has a higher visibility than the parent group' do
          let(:new_parent_group) { create(:group, :private) }
          let(:group) { create(:group, :public, :nested) }

          it 'updates visibility level based on the parent group' do
            group.reload
            expect(group.private?).to be_truthy
            expect(group.visibility_level).to eq(new_parent_group.visibility_level)
          end
        end

        context 'with a group integration' do
          let(:new_created_integration) { Integration.find_by(group: group) }

          context 'with an inherited integration' do
            let_it_be(:instance_integration) { create(:integrations_slack, :instance, webhook: 'http://project.slack.com') }
            let_it_be(:group_integration) { create(:integrations_slack, :group, group: group, webhook: 'http://group.slack.com', inherit_from_id: instance_integration.id) }

            it 'replaces inherited integrations', :aggregate_failures do
              expect(new_created_integration.webhook).to eq(new_parent_group_integration.webhook)
              expect(PropagateIntegrationWorker).to have_received(:perform_async).with(new_created_integration.id)
              expect(Integration.count).to eq(3)
            end
          end

          context 'with a custom integration' do
            let_it_be(:group_integration) { create(:integrations_slack, :group, group: group, webhook: 'http://group.slack.com') }

            it 'does not updates the integrations', :aggregate_failures do
              expect { transfer_service.execute(new_parent_group) }.not_to change { group_integration.webhook }
              expect(PropagateIntegrationWorker).not_to have_received(:perform_async)
            end
          end
        end

        it 'updates visibility for the group based on the parent group' do
          expect(group.visibility_level).to eq(new_parent_group.visibility_level)
        end

        it 'updates parent group to the new parent' do
          expect(group.parent).to eq(new_parent_group)
        end

        it 'returns the group as children of the new parent' do
          expect(new_parent_group.children.count).to eq(1)
          expect(new_parent_group.children.first).to eq(group)
        end

        it 'creates a redirect for the group' do
          expect(group.redirect_routes.count).to eq(1)
        end
      end

      context 'shared runners configuration' do
        before do
          create(:group_member, :owner, group: new_parent_group, user: user)
        end

        context 'if parent group has disabled shared runners but allows overrides' do
          let(:new_parent_group) { create(:group, shared_runners_enabled: false, allow_descendants_override_disabled_shared_runners: true) }

          it 'calls update service' do
            expect(Groups::UpdateSharedRunnersService).to receive(:new).with(group, user, { shared_runners_setting: Namespace::SR_DISABLED_AND_OVERRIDABLE }).and_call_original

            transfer_service.execute(new_parent_group)
          end
        end

        context 'if parent group does not allow shared runners' do
          let(:new_parent_group) { create(:group, shared_runners_enabled: false, allow_descendants_override_disabled_shared_runners: false) }

          it 'calls update service' do
            expect(Groups::UpdateSharedRunnersService).to receive(:new).with(group, user, { shared_runners_setting: Namespace::SR_DISABLED_AND_UNOVERRIDABLE }).and_call_original

            transfer_service.execute(new_parent_group)
          end
        end

        context 'if parent group allows shared runners' do
          let(:group) { create(:group, :public, :nested, shared_runners_enabled: false) }
          let(:new_parent_group) { create(:group, shared_runners_enabled: true) }

          it 'does not call update service and keeps them disabled on the group' do
            expect(Groups::UpdateSharedRunnersService).not_to receive(:new)

            transfer_service.execute(new_parent_group)
            expect(group.reload.shared_runners_enabled).to be_falsy
          end
        end
      end

      context 'when a group is transferred to its subgroup' do
        let(:new_parent_group) { create(:group, parent: group) }

        it 'does not execute the transfer' do
          expect(transfer_service.execute(new_parent_group)).to be_falsy
          expect(transfer_service.error).to match(/Cannot transfer group to one of its subgroup/)
        end
      end

      context 'when transferring a group with group descendants' do
        let!(:subgroup1) { create(:group, :private, parent: group) }
        let!(:subgroup2) { create(:group, :internal, parent: group) }

        before do
          create(:group_member, :owner, group: new_parent_group, user: user)
          transfer_service.execute(new_parent_group)
        end

        it 'updates subgroups path' do
          new_parent_path = new_parent_group.path
          group.children.each do |subgroup|
            expect(subgroup.full_path).to eq(""#{new_parent_path}/#{group.path}/#{subgroup.path}"")
          end
        end

        it 'creates redirects for the subgroups' do
          expect(group.redirect_routes.count).to eq(1)
          expect(subgroup1.redirect_routes.count).to eq(1)
          expect(subgroup2.redirect_routes.count).to eq(1)
        end

        context 'when the new parent has a higher visibility than the children' do
          it 'does not update the children visibility' do
            expect(subgroup1.private?).to be_truthy
            expect(subgroup2.internal?).to be_truthy
          end
        end

        context 'when the new parent has a lower visibility than the children' do
          let!(:subgroup1) { create(:group, :public, parent: group) }
          let!(:subgroup2) { create(:group, :public, parent: group) }
          let(:new_parent_group) { create(:group, :private) }

          it 'updates children visibility to match the new parent' do
            group.children.each do |subgroup|
              expect(subgroup.private?).to be_truthy
            end
          end
        end
      end

      context 'when transferring a group with project descendants' do
        let!(:project1) { create(:project, :repository, :private, namespace: group) }
        let!(:project2) { create(:project, :repository, :internal, namespace: group) }

        before do
          TestEnv.clean_test_path
          create(:group_member, :owner, group: new_parent_group, user: user)
          allow(transfer_service).to receive(:update_project_settings)
          transfer_service.execute(new_parent_group)
        end

        it 'updates projects path' do
          new_parent_path = new_parent_group.path
          group.projects.each do |project|
            expect(project.full_path).to eq(""#{new_parent_path}/#{group.path}/#{project.path}"")
          end
        end

        it 'creates permanent redirects for the projects' do
          expect(group.redirect_routes.count).to eq(1)
          expect(project1.redirect_routes.count).to eq(1)
          expect(project2.redirect_routes.count).to eq(1)
        end

        context 'when the new parent has a higher visibility than the projects' do
          it 'does not update projects visibility' do
            expect(project1.private?).to be_truthy
            expect(project2.internal?).to be_truthy
          end

          it_behaves_like 'project namespace path is in sync with project path' do
            let(:group_full_path) { ""#{new_parent_group.path}/#{group.path}"" }
            let(:projects_with_project_namespace) { [project1, project2] }
          end
        end

        context 'when the new parent has a lower visibility than the projects' do
          let!(:project1) { create(:project, :repository, :public, namespace: group) }
          let!(:project2) { create(:project, :repository, :public, namespace: group) }
          let!(:new_parent_group) { create(:group, :private) }

          it 'updates projects visibility to match the new parent' do
            group.projects.each do |project|
              expect(project.private?).to be_truthy
            end
          end

          it 'invokes #update_project_settings' do
            expect(transfer_service).to have_received(:update_project_settings)
                                          .with(group.projects.pluck(:id))
          end

          it_behaves_like 'project namespace path is in sync with project path' do
            let(:group_full_path) { ""#{new_parent_group.path}/#{group.path}"" }
            let(:projects_with_project_namespace) { [project1, project2] }
          end
        end
      end

      context 'when transferring a group with subgroups & projects descendants' do
        let!(:project1) { create(:project, :repository, :private, namespace: group) }
        let!(:project2) { create(:project, :repository, :internal, namespace: group) }
        let!(:subgroup1) { create(:group, :private, parent: group) }
        let!(:subgroup2) { create(:group, :internal, parent: group) }

        before do
          TestEnv.clean_test_path
          create(:group_member, :owner, group: new_parent_group, user: user)
          transfer_service.execute(new_parent_group)
        end

        it 'updates subgroups path' do
          new_parent_path = new_parent_group.path
          group.children.each do |subgroup|
            expect(subgroup.full_path).to eq(""#{new_parent_path}/#{group.path}/#{subgroup.path}"")
          end
        end

        it 'updates projects path' do
          new_parent_path = new_parent_group.path
          group.projects.each do |project|
            expect(project.full_path).to eq(""#{new_parent_path}/#{group.path}/#{project.path}"")
          end
        end

        it 'creates redirect for the subgroups and projects' do
          expect(group.redirect_routes.count).to eq(1)
          expect(subgroup1.redirect_routes.count).to eq(1)
          expect(subgroup2.redirect_routes.count).to eq(1)
          expect(project1.redirect_routes.count).to eq(1)
          expect(project2.redirect_routes.count).to eq(1)
        end

        it_behaves_like 'project namespace path is in sync with project path' do
          let(:group_full_path) { ""#{new_parent_group.path}/#{group.path}"" }
          let(:projects_with_project_namespace) { [project1, project2] }
        end
      end

      context 'when transferring a group with nested groups and projects' do
        let(:subgroup1) { create(:group, :private, parent: group) }
        let!(:project1) { create(:project, :repository, :private, namespace: group) }
        let!(:nested_subgroup) { create(:group, :private, parent: subgroup1) }
        let!(:nested_project) { create(:project, :repository, :private, namespace: subgroup1) }

        before do
          TestEnv.clean_test_path
          create(:group_member, :owner, group: new_parent_group, user: user)
        end

        context 'updated paths' do
          let_it_be_with_reload(:group) { create(:group, :public) }

          before do
            transfer_service.execute(new_parent_group)
          end

          it 'updates subgroups path' do
            new_base_path = ""#{new_parent_group.path}/#{group.path}""
            group.children.each do |children|
              expect(children.full_path).to eq(""#{new_base_path}/#{children.path}"")
            end

            new_base_path = ""#{new_parent_group.path}/#{group.path}/#{subgroup1.path}""
            subgroup1.children.each do |children|
              expect(children.full_path).to eq(""#{new_base_path}/#{children.path}"")
            end
          end

          it 'updates projects path' do
            new_parent_path = ""#{new_parent_group.path}/#{group.path}""
            subgroup1.projects.each do |project|
              project_full_path = ""#{new_parent_path}/#{project.namespace.path}/#{project.path}""
              expect(project.full_path).to eq(project_full_path)
            end
          end

          it 'creates redirect for the subgroups and projects' do
            expect(group.redirect_routes.count).to eq(1)
            expect(project1.redirect_routes.count).to eq(1)
            expect(subgroup1.redirect_routes.count).to eq(1)
            expect(nested_subgroup.redirect_routes.count).to eq(1)
            expect(nested_project.redirect_routes.count).to eq(1)
          end
        end

        context 'resets project authorizations' do
          let_it_be(:old_parent_group) { create(:group) }
          let_it_be_with_refind(:group) { create(:group, :private, parent: old_parent_group) }
          let_it_be(:new_group_member) { create(:user) }
          let_it_be(:old_group_member) { create(:user) }
          let_it_be(:unique_subgroup_member) { create(:user) }
          let_it_be(:direct_project_member) { create(:user) }

          before do
            new_parent_group.add_maintainer(new_group_member)
            old_parent_group.add_maintainer(old_group_member)
            subgroup1.add_developer(unique_subgroup_member)
            nested_project.add_developer(direct_project_member)
            group.refresh_members_authorized_projects
            subgroup1.refresh_members_authorized_projects
          end

          it 'removes old project authorizations' do
            expect { transfer_service.execute(new_parent_group) }.to change {
              ProjectAuthorization.where(project_id: project1.id, user_id: old_group_member.id).size
            }.from(1).to(0)
          end

          it 'adds new project authorizations' do
            expect { transfer_service.execute(new_parent_group) }.to change {
              ProjectAuthorization.where(project_id: project1.id, user_id: new_group_member.id).size
            }.from(0).to(1)
          end

          it 'performs authorizations job' do
            expect(AuthorizedProjectUpdate::ProjectRecalculateWorker).to receive(:bulk_perform_async)

            transfer_service.execute(new_parent_group)
          end

          context 'for nested projects' do
            it 'removes old project authorizations' do
              expect { transfer_service.execute(new_parent_group) }.to change {
                ProjectAuthorization.where(project_id: nested_project.id, user_id: old_group_member.id).size
              }.from(1).to(0)
            end

            it 'adds new project authorizations' do
              expect { transfer_service.execute(new_parent_group) }.to change {
                ProjectAuthorization.where(project_id: nested_project.id, user_id: new_group_member.id).size
              }.from(0).to(1)
            end

            it 'preserves existing project authorizations for direct project members' do
              expect { transfer_service.execute(new_parent_group) }.not_to change {
                ProjectAuthorization.where(project_id: nested_project.id, user_id: direct_project_member.id).count
              }
            end
          end

          context 'for nested groups with unique members' do
            it 'preserves existing project authorizations' do
              expect { transfer_service.execute(new_parent_group) }.not_to change {
                ProjectAuthorization.where(project_id: nested_project.id, user_id: unique_subgroup_member.id).count
              }
            end
          end

          context 'for groups with many projects' do
            let_it_be(:project_list) { create_list(:project, 11, :repository, :private, namespace: group) }

            it 'adds new project authorizations for the user which makes a transfer' do
              transfer_service.execute(new_parent_group)

              expect(ProjectAuthorization.where(project_id: project1.id, user_id: user.id).size).to eq(1)
              expect(ProjectAuthorization.where(project_id: nested_project.id, user_id: user.id).size).to eq(1)
            end

            it 'adds project authorizations for users in the new hierarchy' do
              expect { transfer_service.execute(new_parent_group) }.to change {
                ProjectAuthorization.where(project_id: project_list.map { |project| project.id }, user_id: new_group_member.id).size
              }.from(0).to(project_list.count)
            end

            it 'removes project authorizations for users in the old hierarchy' do
              expect { transfer_service.execute(new_parent_group) }.to change {
                ProjectAuthorization.where(project_id: project_list.map { |project| project.id }, user_id: old_group_member.id).size
              }.from(project_list.count).to(0)
            end

            it 'schedules authorizations job' do
              expect(AuthorizedProjectUpdate::ProjectRecalculateWorker).to receive(:bulk_perform_async)
                .with(array_including(group.all_projects.ids.map { |id| [id] }))

              transfer_service.execute(new_parent_group)
            end
          end

          context 'transferring groups with shared_projects' do
            let_it_be_with_reload(:shared_project) { create(:project, :public) }

            shared_examples_for 'drops the authorizations of ancestor members from the old hierarchy' do
              it 'drops the authorizations of ancestor members from the old hierarchy' do
                expect { transfer_service.execute(new_parent_group) }.to change {
                  ProjectAuthorization.where(project: shared_project, user: old_group_member).size
                }.from(1).to(0)
              end
            end

            context 'when the group that has existing project share is transferred' do
              before do
                create(:project_group_link, :maintainer, project: shared_project, group: group)
              end

              it_behaves_like 'drops the authorizations of ancestor members from the old hierarchy'
            end

            context 'when the group whose subgroup has an existing project share is transferred' do
              let_it_be_with_reload(:subgroup) { create(:group, :private, parent: group) }

              before do
                create(:project_group_link, :maintainer, project: shared_project, group: subgroup)
              end

              it_behaves_like 'drops the authorizations of ancestor members from the old hierarchy'
            end
          end

          context 'when a group that has existing group share is transferred' do
            let(:shared_with_group) { group }

            let_it_be(:member_of_shared_with_group) { create(:user) }
            let_it_be(:shared_group) { create(:group, :private) }
            let_it_be(:project_in_shared_group) { create(:project, namespace: shared_group) }

            before do
              shared_with_group.add_developer(member_of_shared_with_group)
              create(:group_group_link, :maintainer, shared_group: shared_group, shared_with_group: shared_with_group)
              shared_with_group.refresh_members_authorized_projects
            end

            it 'retains the authorizations of direct members' do
              expect { transfer_service.execute(new_parent_group) }.not_to change {
                ProjectAuthorization.where(
                  project: project_in_shared_group,
                  user: member_of_shared_with_group,
                  access_level: Gitlab::Access::DEVELOPER).size
              }.from(1)
            end
          end
        end
      end

      context 'when transferring a group with two factor authentication switched on' do
        before do
          TestEnv.clean_test_path
          create(:group_member, :owner, group: new_parent_group, user: user)
          create(:group, :private, parent: group, require_two_factor_authentication: true)
          group.update!(require_two_factor_authentication: true)
          new_parent_group.reload # make sure traversal_ids are reloaded
        end

        it 'does not update group two factor authentication setting' do
          transfer_service.execute(new_parent_group)

          expect(group.require_two_factor_authentication).to eq(true)
        end

        context 'when new parent disallows two factor authentication switched on for descendants' do
          before do
            new_parent_group.namespace_settings.update!(allow_mfa_for_subgroups: false)
          end

          it 'updates group two factor authentication setting' do
            transfer_service.execute(new_parent_group)

            expect(group.require_two_factor_authentication).to eq(false)
          end

          it 'schedules update of group two factor authentication setting for descendants' do
            expect(DisallowTwoFactorForSubgroupsWorker).to receive(:perform_async).with(group.id)

            transfer_service.execute(new_parent_group)
          end
        end
      end

      context 'when updating the group goes wrong' do
        let!(:subgroup1) { create(:group, :public, parent: group) }
        let!(:subgroup2) { create(:group, :public, parent: group) }
        let(:new_parent_group) { create(:group, :private) }
        let!(:project1) { create(:project, :repository, :public, namespace: group) }

        before do
          allow(group).to receive(:save!).and_raise(ActiveRecord::RecordInvalid.new(group))
          TestEnv.clean_test_path
          create(:group_member, :owner, group: new_parent_group, user: user)
          transfer_service.execute(new_parent_group)
        end

        it 'restores group and projects visibility' do
          subgroup1.reload
          project1.reload
          expect(subgroup1.public?).to be_truthy
          expect(project1.public?).to be_truthy
        end
      end

      context 'when group has pending builds', :sidekiq_inline do
        let_it_be(:project) { create(:project, :public, namespace: group.reload) }
        let_it_be(:other_project) { create(:project) }
        let_it_be(:pending_build) { create(:ci_pending_build, project: project) }
        let_it_be(:unrelated_pending_build) { create(:ci_pending_build, project: other_project) }

        before do
          group.add_owner(user)
          new_parent_group.add_owner(user)
        end

        it 'updates pending builds for the group', :aggregate_failures do
          transfer_service.execute(new_parent_group)

          pending_build.reload
          unrelated_pending_build.reload

          expect(pending_build.namespace_id).to eq(group.id)
          expect(pending_build.namespace_traversal_ids).to eq(group.traversal_ids)
          expect(unrelated_pending_build.namespace_id).to eq(other_project.namespace_id)
          expect(unrelated_pending_build.namespace_traversal_ids).to eq(other_project.namespace.traversal_ids)
        end
      end
    end

    context 'when transferring a subgroup into root group' do
      let(:group) { create(:group, :public, :nested) }
      let(:subgroup) { create(:group, :public, parent: group) }
      let(:transfer_service) { described_class.new(subgroup, user) }

      it 'ensures there is still an owner for the transferred group' do
        expect(subgroup.owners).to be_empty

        transfer_service.execute(nil)
        subgroup.reload

        expect(subgroup.owners).to match_array(user)
      end

      context 'when group has explicit owner' do
        let(:another_owner) { create(:user) }
        let!(:another_member) { create(:group_member, :owner, group: subgroup, user: another_owner) }

        it 'does not add additional owner' do
          expect(subgroup.owners).to match_array(another_owner)

          transfer_service.execute(nil)
          subgroup.reload

          expect(subgroup.owners).to match_array(another_owner)
        end
      end
    end

    context 'when a project has container images' do
      let(:group) { create(:group, :public, :nested) }
      let!(:container_repository) { create(:container_repository, project: project) }

      subject { transfer_service.execute(new_parent_group) }

      before do
        group.add_owner(user)
        new_parent_group.add_owner(user)
      end

      context 'within group' do
        let(:project) { create(:project, :repository, :public, namespace: group) }

        it 'does not transfer' do
          expect(subject).to be false
          expect(transfer_service.error).to match(/Docker images in their Container Registry/)
        end
      end

      context 'within subgroup' do
        let(:subgroup) { create(:group, parent: group) }
        let(:project) { create(:project, :repository, :public, namespace: subgroup) }

        it 'does not transfer' do
          expect(subject).to be false
          expect(transfer_service.error).to match(/Docker images in their Container Registry/)
        end
      end
    end

    context 'crm' do
      let(:root_group) { create(:group, :public) }
      let(:subgroup) { create(:group, :public, parent: root_group) }
      let(:another_subgroup) { create(:group, :public, parent: root_group) }
      let(:subsubgroup) { create(:group, :public, parent: subgroup) }

      let(:root_project) { create(:project, group: root_group) }
      let(:sub_project) { create(:project, group: subgroup) }
      let(:another_project) { create(:project, group: another_subgroup) }
      let(:subsub_project) { create(:project, group: subsubgroup) }

      let!(:contacts) { create_list(:contact, 4, group: root_group) }
      let!(:crm_organizations) { create_list(:crm_organization, 2, group: root_group) }

      before do
        create(:issue_customer_relations_contact, contact: contacts[0], issue: create(:issue, project: root_project))
        create(:issue_customer_relations_contact, contact: contacts[1], issue: create(:issue, project: sub_project))
        create(:issue_customer_relations_contact, contact: contacts[2], issue: create(:issue, project: another_project))
        create(:issue_customer_relations_contact, contact: contacts[3], issue: create(:issue, project: subsub_project))
        root_group.add_owner(user)
      end

      context 'moving up' do
        let(:group) { subsubgroup }

        it 'retains issue contacts' do
          expect { transfer_service.execute(root_group) }
            .not_to change { CustomerRelations::IssueContact.count }
        end

        it_behaves_like 'publishes a GroupTransferedEvent' do
          let(:target) { root_group }
        end
      end

      context 'moving down' do
        let(:group) { subgroup }

        it 'retains issue contacts' do
          expect { transfer_service.execute(another_subgroup) }
          .not_to change { CustomerRelations::IssueContact.count }
        end

        it_behaves_like 'publishes a GroupTransferedEvent' do
          let(:target) { another_subgroup }
        end
      end

      context 'moving sideways' do
        let(:group) { subsubgroup }

        it 'retains issue contacts' do
          expect { transfer_service.execute(another_subgroup) }
          .not_to change { CustomerRelations::IssueContact.count }
        end

        it_behaves_like 'publishes a GroupTransferedEvent' do
          let(:target) { another_subgroup }
        end
      end

      context 'moving to new root group' do
        let(:group) { root_group }

        before do
          new_parent_group.add_owner(user)
        end

        it 'moves all crm objects' do
          expect { transfer_service.execute(new_parent_group) }
            .to change { root_group.contacts.count }.by(-4)
            .and change { root_group.crm_organizations.count }.by(-2)
        end

        it 'retains issue contacts' do
          expect { transfer_service.execute(new_parent_group) }
            .not_to change { CustomerRelations::IssueContact.count }
        end

        it_behaves_like 'publishes a GroupTransferedEvent' do
          let(:target) { new_parent_group }
        end
      end

      context 'moving to a subgroup within a new root group' do
        let(:group) { root_group }
        let(:subgroup_in_new_parent_group) { create(:group, parent: new_parent_group) }

        context 'with permission on the root group' do
          before do
            new_parent_group.add_owner(user)
          end

          it 'moves all crm objects' do
            expect { transfer_service.execute(subgroup_in_new_parent_group) }
              .to change { root_group.contacts.count }.by(-4)
              .and change { root_group.crm_organizations.count }.by(-2)
          end

          it 'retains issue contacts' do
            expect { transfer_service.execute(subgroup_in_new_parent_group) }
              .not_to change { CustomerRelations::IssueContact.count }
          end

          it_behaves_like 'publishes a GroupTransferedEvent' do
            let(:target) { subgroup_in_new_parent_group }
          end
        end

        context 'with permission on the subgroup' do
          before do
            subgroup_in_new_parent_group.add_owner(user)
          end

          it 'raises error' do
            transfer_service.execute(subgroup_in_new_parent_group)

            expect(transfer_service.error).to eq(""Transfer failed: Group contains contacts/organizations and you don't have enough permissions to move them to the new root group."")
          end

          it 'does not publish a GroupTransferedEvent' do
            expect { transfer_service.execute(subgroup_in_new_parent_group) }
              .not_to publish_event(Groups::GroupTransferedEvent)
          end
        end
      end
    end

    context 'with namespace_commit_emails concerns' do
      let_it_be(:group, reload: true) { create(:group) }
      let_it_be(:target) { create(:group) }

      before do
        group.add_owner(user)
        target.add_owner(user)
      end

      context 'when origin is a root group' do
        before do
          create_list(:namespace_commit_email, 2, namespace: group)
        end

        it 'deletes all namespace_commit_emails' do
          expect { transfer_service.execute(target) }
            .to change { group.namespace_commit_emails.count }.by(-2)
        end

        it_behaves_like 'publishes a GroupTransferedEvent'
      end

      context 'when origin is not a root group' do
        let(:group) { create(:group, parent: create(:group)) }

        it 'does not attempt to delete namespace_commit_emails' do
          expect(Users::NamespaceCommitEmail).not_to receive(:delete_for_namespace)

          transfer_service.execute(target)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Groups
  class AutoDevopsService < Groups::BaseService
    def execute
      raise Gitlab::Access::AccessDeniedError unless can?(current_user, :admin_group, group)

      group.update(auto_devops_enabled: auto_devops_enabled)
    end

    private

    def auto_devops_enabled
      params[:auto_devops_enabled]
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Groups::AutoDevopsService, '#execute', feature_category: :auto_devops do
  let_it_be(:group) { create(:group) }
  let_it_be(:user) { create(:user) }

  let(:group_params) { { auto_devops_enabled: '0' } }
  let(:service) { described_class.new(group, user, group_params) }

  context 'when user does not have enough privileges' do
    it 'raises exception' do
      group.add_developer(user)

      expect do
        service.execute
      end.to raise_exception(Gitlab::Access::AccessDeniedError)
    end
  end

  context 'when user has enough privileges' do
    before do
      group.add_owner(user)
    end

    it 'updates group auto devops enabled accordingly' do
      service.execute

      expect(group.auto_devops_enabled).to eq(false)
    end

    context 'when group has projects' do
      it 'reflects changes on projects' do
        project_1 = create(:project, namespace: group)

        service.execute

        expect(project_1).not_to have_auto_devops_implicitly_enabled
      end
    end

    context 'when group has subgroups' do
      it 'reflects changes on subgroups' do
        subgroup_1 = create(:group, parent: group)

        service.execute

        expect(subgroup_1.auto_devops_enabled?).to eq(false)
      end

      context 'when subgroups have projects' do
        it 'reflects changes on projects' do
          subgroup_1 = create(:group, parent: group)
          project_1 = create(:project, namespace: subgroup_1)

          service.execute

          expect(project_1).not_to have_auto_devops_implicitly_enabled
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Groups
  class UpdateSharedRunnersService < Groups::BaseService
    def execute
      return error('Operation not allowed', 403) unless can?(current_user, :admin_group, group)

      validate_params

      update_shared_runners
      update_pending_builds_async

      success

    rescue ActiveRecord::RecordInvalid, ArgumentError => error
      error(error.message)
    end

    private

    def validate_params
      unless Namespace::SHARED_RUNNERS_SETTINGS.include?(params[:shared_runners_setting])
        raise ArgumentError, ""state must be one of: #{Namespace::SHARED_RUNNERS_SETTINGS.join(', ')}""
      end
    end

    def update_shared_runners
      case params[:shared_runners_setting]
      when Namespace::SR_DISABLED_AND_UNOVERRIDABLE
        set_shared_runners_enabled!(false)
      when Namespace::SR_DISABLED_WITH_OVERRIDE, Namespace::SR_DISABLED_AND_OVERRIDABLE
        disable_shared_runners_and_allow_override!
      when Namespace::SR_ENABLED
        set_shared_runners_enabled!(true)
      end
    end

    def update_pending_builds?
      group.previous_changes.include?('shared_runners_enabled')
    end

    def update_pending_builds_async
      return unless update_pending_builds?

      group.run_after_commit_or_now do |group|
        pending_builds_params = { instance_runners_enabled: group.shared_runners_enabled }

        ::Ci::UpdatePendingBuildService.new(group, pending_builds_params).execute
      end
    end

    def set_shared_runners_enabled!(enabled)
      group.update!(
        shared_runners_enabled: enabled,
        allow_descendants_override_disabled_shared_runners: false)

      group_ids = group.descendants
      unless group_ids.empty?
        Group.by_id(group_ids).update_all(
          shared_runners_enabled: enabled,
          allow_descendants_override_disabled_shared_runners: false)
      end

      group.all_projects.update_all(shared_runners_enabled: enabled)
    end

    def disable_shared_runners_and_allow_override!
      # enabled -> disabled_and_overridable
      if group.shared_runners_enabled?
        group.update!(
          shared_runners_enabled: false,
          allow_descendants_override_disabled_shared_runners: true)

        group_ids = group.descendants
        Group.by_id(group_ids).update_all(shared_runners_enabled: false) unless group_ids.empty?

        group.all_projects.update_all(shared_runners_enabled: false)

      # disabled_and_unoverridable -> disabled_and_overridable
      else
        group.update!(allow_descendants_override_disabled_shared_runners: true)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Groups::UpdateSharedRunnersService, feature_category: :groups_and_projects do
  include ReloadHelpers

  let(:user) { create(:user) }
  let(:params) { {} }
  let(:service) { described_class.new(group, user, params) }

  describe '#execute' do
    subject { service.execute }

    context 'when current_user is not the group owner' do
      let(:group) { create(:group) }

      let(:params) { { shared_runners_setting: 'enabled' } }

      before do
        group.add_maintainer(user)
      end

      it 'returns error' do
        expect(subject[:status]).to eq(:error)
        expect(subject[:message]).to eq('Operation not allowed')
        expect(subject[:http_status]).to eq(403)
      end
    end

    context 'when current_user is the group owner' do
      before do
        group.add_owner(user)
      end

      context 'enable shared Runners' do
        let(:params) { { shared_runners_setting: 'enabled' } }

        context 'when ancestor disable shared runners' do
          let(:parent) { create(:group, :shared_runners_disabled) }
          let(:group) { create(:group, :shared_runners_disabled, parent: parent) }
          let!(:project) { create(:project, shared_runners_enabled: false, group: group) }

          it 'returns an error and does not enable shared runners' do
            expect do
              expect(subject[:status]).to eq(:error)
              expect(subject[:message]).to eq('Validation failed: Shared runners enabled cannot be enabled because parent group has shared Runners disabled')

              reload_models(parent, group, project)
            end.to not_change { parent.shared_runners_enabled }
              .and not_change { group.shared_runners_enabled }
              .and not_change { project.shared_runners_enabled }
          end
        end

        context 'when updating root group' do
          let(:group) { create(:group, :shared_runners_disabled) }
          let(:sub_group) { create(:group, :shared_runners_disabled, parent: group) }
          let!(:project) { create(:project, shared_runners_enabled: false, group: sub_group) }

          it 'enables shared Runners for itself and descendants' do
            expect do
              expect(subject[:status]).to eq(:success)

              reload_models(group, sub_group, project)
            end.to change { group.shared_runners_enabled }.from(false).to(true)
              .and change { sub_group.shared_runners_enabled }.from(false).to(true)
              .and change { project.shared_runners_enabled }.from(false).to(true)
          end

          context 'when already allowing descendants to override' do
            let(:group) { create(:group, :shared_runners_disabled_and_overridable) }

            it 'enables shared Runners for itself and descendants' do
              expect do
                expect(subject[:status]).to eq(:success)

                reload_models(group, sub_group, project)
              end.to change { group.shared_runners_enabled }.from(false).to(true)
                .and change { group.allow_descendants_override_disabled_shared_runners }.from(true).to(false)
                .and change { sub_group.shared_runners_enabled }.from(false).to(true)
                .and change { project.shared_runners_enabled }.from(false).to(true)
            end
          end
        end

        context 'when group has pending builds' do
          let_it_be(:group) { create(:group, :shared_runners_disabled) }
          let_it_be(:project) { create(:project, namespace: group, shared_runners_enabled: false) }
          let_it_be(:pending_build_1) { create(:ci_pending_build, project: project, instance_runners_enabled: false) }
          let_it_be(:pending_build_2) { create(:ci_pending_build, project: project, instance_runners_enabled: false) }

          it 'updates pending builds for the group' do
            expect(::Ci::UpdatePendingBuildService).to receive(:new).and_call_original

            subject

            expect(pending_build_1.reload.instance_runners_enabled).to be_truthy
            expect(pending_build_2.reload.instance_runners_enabled).to be_truthy
          end

          context 'when shared runners is not toggled' do
            let(:params) { { shared_runners_setting: 'invalid_enabled' } }

            it 'does not update pending builds for the group' do
              expect(::Ci::UpdatePendingBuildService).not_to receive(:new)

              subject

              expect(pending_build_1.reload.instance_runners_enabled).to be_falsey
              expect(pending_build_2.reload.instance_runners_enabled).to be_falsey
            end
          end
        end
      end

      context 'disable shared Runners' do
        let!(:group) { create(:group) }
        let!(:sub_group) { create(:group, :shared_runners_disabled_and_overridable, parent: group) }
        let!(:sub_group2) { create(:group, parent: group) }
        let!(:project) { create(:project, group: group, shared_runners_enabled: true) }
        let!(:project2) { create(:project, group: sub_group2, shared_runners_enabled: true) }

        let(:params) { { shared_runners_setting: Namespace::SR_DISABLED_AND_UNOVERRIDABLE } }

        it 'disables shared Runners for all descendant groups and projects' do
          expect do
            expect(subject[:status]).to eq(:success)

            reload_models(group, sub_group, sub_group2, project, project2)
          end.to change { group.shared_runners_enabled }.from(true).to(false)
            .and not_change { group.allow_descendants_override_disabled_shared_runners }
            .and not_change { sub_group.shared_runners_enabled }
            .and change { sub_group.allow_descendants_override_disabled_shared_runners }.from(true).to(false)
            .and change { sub_group2.shared_runners_enabled }.from(true).to(false)
            .and not_change { sub_group2.allow_descendants_override_disabled_shared_runners }
            .and change { project.shared_runners_enabled }.from(true).to(false)
            .and change { project2.shared_runners_enabled }.from(true).to(false)
        end

        context 'with override on self' do
          let(:group) { create(:group, :shared_runners_disabled_and_overridable) }

          it 'disables it' do
            expect do
              expect(subject[:status]).to eq(:success)

              group.reload
            end
              .to not_change { group.shared_runners_enabled }
              .and change { group.allow_descendants_override_disabled_shared_runners }.from(true).to(false)
          end
        end

        context 'when group has pending builds' do
          let!(:pending_build_1) { create(:ci_pending_build, project: project, instance_runners_enabled: true) }
          let!(:pending_build_2) { create(:ci_pending_build, project: project, instance_runners_enabled: true) }

          it 'updates pending builds for the group' do
            expect(::Ci::UpdatePendingBuildService).to receive(:new).and_call_original

            subject

            expect(pending_build_1.reload.instance_runners_enabled).to be_falsey
            expect(pending_build_2.reload.instance_runners_enabled).to be_falsey
          end
        end
      end

      shared_examples 'allow descendants to override' do
        context 'top level group' do
          let!(:group) { create(:group, :shared_runners_disabled) }
          let!(:sub_group) { create(:group, :shared_runners_disabled, parent: group) }
          let!(:project) { create(:project, shared_runners_enabled: false, group: sub_group) }

          it 'enables allow descendants to override only for itself' do
            expect do
              expect(subject[:status]).to eq(:success)

              reload_models(group, sub_group, project)
            end.to change { group.allow_descendants_override_disabled_shared_runners }.from(false).to(true)
              .and not_change { group.shared_runners_enabled }
              .and not_change { sub_group.allow_descendants_override_disabled_shared_runners }
              .and not_change { sub_group.shared_runners_enabled }
              .and not_change { project.shared_runners_enabled }
          end
        end

        context 'when ancestor disables shared Runners but allows to override' do
          let!(:parent) { create(:group, :shared_runners_disabled_and_overridable) }
          let!(:group) { create(:group, :shared_runners_disabled, parent: parent) }
          let!(:project) { create(:project, shared_runners_enabled: false, group: group) }

          it 'enables allow descendants to override' do
            expect do
              expect(subject[:status]).to eq(:success)

              reload_models(parent, group, project)
            end
              .to not_change { parent.allow_descendants_override_disabled_shared_runners }
              .and not_change { parent.shared_runners_enabled }
              .and change { group.allow_descendants_override_disabled_shared_runners }.from(false).to(true)
              .and not_change { group.shared_runners_enabled }
              .and not_change { project.shared_runners_enabled }
          end
        end

        context 'when ancestor disables shared runners' do
          let(:parent) { create(:group, :shared_runners_disabled) }
          let(:group) { create(:group, :shared_runners_disabled, parent: parent) }
          let!(:project) { create(:project, shared_runners_enabled: false, group: group) }

          it 'returns an error and does not enable shared runners' do
            expect do
              expect(subject[:status]).to eq(:error)
              expect(subject[:message]).to eq('Validation failed: Allow descendants override disabled shared runners cannot be enabled because parent group does not allow it')

              reload_models(parent, group, project)
            end.to not_change { parent.shared_runners_enabled }
              .and not_change { group.shared_runners_enabled }
              .and not_change { project.shared_runners_enabled }
          end
        end

        context 'top level group that has shared Runners enabled' do
          let!(:group) { create(:group, shared_runners_enabled: true) }
          let!(:sub_group) { create(:group, shared_runners_enabled: true, parent: group) }
          let!(:project) { create(:project, shared_runners_enabled: true, group: sub_group) }

          it 'enables allow descendants to override & disables shared runners everywhere' do
            expect do
              expect(subject[:status]).to eq(:success)

              reload_models(group, sub_group, project)
            end
              .to change { group.shared_runners_enabled }.from(true).to(false)
              .and change { group.allow_descendants_override_disabled_shared_runners }.from(false).to(true)
              .and change { sub_group.shared_runners_enabled }.from(true).to(false)
              .and change { project.shared_runners_enabled }.from(true).to(false)
          end
        end
      end

      context ""when using SR_DISABLED_AND_OVERRIDABLE"" do
        let(:params) { { shared_runners_setting: Namespace::SR_DISABLED_AND_OVERRIDABLE } }

        include_examples 'allow descendants to override'
      end

      context ""when using SR_DISABLED_WITH_OVERRIDE"" do
        let(:params) { { shared_runners_setting: Namespace::SR_DISABLED_WITH_OVERRIDE } }

        include_examples 'allow descendants to override'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Groups
  class DestroyService < Groups::BaseService
    DestroyError = Class.new(StandardError)

    def async_execute
      job_id = GroupDestroyWorker.perform_async(group.id, current_user.id)
      Gitlab::AppLogger.info(""User #{current_user.id} scheduled a deletion of group ID #{group.id} with job ID #{job_id}"")
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def execute
      # TODO - add a policy check here https://gitlab.com/gitlab-org/gitlab/-/issues/353082
      raise DestroyError, ""You can't delete this group because you're blocked."" if current_user.blocked?

      group.projects.includes(:project_feature).each do |project|
        # Execute the destruction of the models immediately to ensure atomic cleanup.
        success = ::Projects::DestroyService.new(project, current_user).execute

        raise DestroyError, ""Project #{project.id} can't be deleted"" unless success
      end

      # reload the relation to prevent triggering destroy hooks on the projects again
      group.projects.reset

      group.children.each do |group|
        # This needs to be synchronous since the namespace gets destroyed below
        DestroyService.new(group, current_user).execute
      end

      group.chat_team&.remove_mattermost_team(current_user)

      user_ids_for_project_authorizations_refresh = obtain_user_ids_for_project_authorizations_refresh

      destroy_associated_users

      group.destroy

      if user_ids_for_project_authorizations_refresh.present?
        UserProjectAccessChangedService
          .new(user_ids_for_project_authorizations_refresh)
          .execute
      end

      publish_event

      group
    end
    # rubocop: enable CodeReuse/ActiveRecord

    private

    def any_groups_shared_with_this_group?
      group.shared_group_links.any?
    end

    def any_projects_shared_with_this_group?
      group.project_group_links.any?
    end

    # Destroying a group automatically destroys all project authorizations directly
    # associated with the group and descendents. However, project authorizations
    # for projects and groups this group is shared with are not. Without a manual
    # refresh, the project authorization records of these users to shared projects
    # and projects within the shared groups will never be removed, causing
    # inconsistencies with access permissions.
    #
    # This method retrieves the user IDs that need to be refreshed. If only
    # groups are shared with this group, only direct members need to be refreshed.
    # If projects are also shared with the group, direct members *and* shared
    # members of other groups need to be refreshed.
    # `Group#user_ids_for_project_authorizations` returns both direct and shared
    # members' user IDs.
    def obtain_user_ids_for_project_authorizations_refresh
      return unless any_projects_shared_with_this_group? || any_groups_shared_with_this_group?
      return group.user_ids_for_project_authorizations if any_projects_shared_with_this_group?

      group.users_ids_of_direct_members
    end

    # rubocop:disable CodeReuse/ActiveRecord
    def destroy_associated_users
      current_user_id = current_user.id
      bot_ids = users_to_destroy

      group.run_after_commit do
        bot_ids.each do |user_id|
          DeleteUserWorker.perform_async(current_user_id, user_id, skip_authorization: true)
        end
      end
    end
    # rubocop:enable CodeReuse/ActiveRecord

    # rubocop:disable CodeReuse/ActiveRecord
    def users_to_destroy
      group.members_and_requesters.joins(:user)
        .merge(User.project_bot)
        .allow_cross_joins_across_databases(url: 'https://gitlab.com/gitlab-org/gitlab/-/issues/422405')
        .pluck(:user_id)
    end
    # rubocop:enable CodeReuse/ActiveRecord

    def publish_event
      event = Groups::GroupDeletedEvent.new(
        data: {
          group_id: group.id,
          root_namespace_id: group.root_ancestor.id
        }
      )

      Gitlab::EventStore.publish(event)
    end
  end
end

Groups::DestroyService.prepend_mod_with('Groups::DestroyService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Groups::DestroyService, feature_category: :groups_and_projects do
  let!(:user)         { create(:user) }
  let!(:group)        { create(:group) }
  let!(:nested_group) { create(:group, parent: group) }
  let!(:project)      { create(:project, :repository, :legacy_storage, namespace: group) }
  let!(:notification_setting) { create(:notification_setting, source: group) }
  let(:remove_path)  { group.path + ""+#{group.id}+deleted"" }
  let(:removed_repo) { Gitlab::Git::Repository.new(project.repository_storage, remove_path, nil, nil) }

  before do
    group.add_member(user, Gitlab::Access::OWNER)
  end

  def destroy_group(group, user, async)
    if async
      Groups::DestroyService.new(group, user).async_execute
    else
      Groups::DestroyService.new(group, user).execute
    end
  end

  shared_examples 'group destruction' do |async|
    context 'database records', :sidekiq_might_not_need_inline do
      before do
        destroy_group(group, user, async)
      end

      it { expect(Group.unscoped.all).not_to include(group) }
      it { expect(Group.unscoped.all).not_to include(nested_group) }
      it { expect(Project.unscoped.all).not_to include(project) }
      it { expect(NotificationSetting.unscoped.all).not_to include(notification_setting) }
    end

    context 'bot tokens', :sidekiq_inline do
      it 'initiates group bot removal', :aggregate_failures do
        bot = create(:user, :project_bot)
        group.add_developer(bot)
        create(:personal_access_token, user: bot)

        destroy_group(group, user, async)

        expect(
          Users::GhostUserMigration.where(user: bot, initiator_user: user)
        ).to be_exists
      end
    end

    context 'mattermost team', :sidekiq_might_not_need_inline do
      let!(:chat_team) { create(:chat_team, namespace: group) }

      it 'destroys the team too' do
        expect_next_instance_of(::Mattermost::Team) do |instance|
          expect(instance).to receive(:destroy)
        end

        destroy_group(group, user, async)
      end
    end

    context 'file system', :sidekiq_might_not_need_inline do
      context 'Sidekiq inline' do
        before do
          # Run sidekiq immediately to check that renamed dir will be removed
          perform_enqueued_jobs { destroy_group(group, user, async) }
        end

        it 'verifies that paths have been deleted' do
          expect(removed_repo).not_to exist
        end
      end
    end

    context 'event store', :sidekiq_might_not_need_inline do
      it 'publishes a GroupDeletedEvent' do
        expect { destroy_group(group, user, async) }
          .to publish_event(Groups::GroupDeletedEvent)
          .with(
            group_id: group.id,
            root_namespace_id: group.root_ancestor.id
          )
      end
    end
  end

  describe 'asynchronous delete' do
    it_behaves_like 'group destruction', true

    context 'Sidekiq fake' do
      before do
        # Don't run Sidekiq to verify that group and projects are not actually destroyed
        Sidekiq::Testing.fake! { destroy_group(group, user, true) }
      end

      it 'verifies original paths and projects still exist' do
        expect(removed_repo).not_to exist
        expect(Project.unscoped.count).to eq(1)
        expect(Group.unscoped.count).to eq(2)
      end
    end
  end

  describe 'synchronous delete' do
    it_behaves_like 'group destruction', false
  end

  context 'projects in pending_delete' do
    before do
      project.pending_delete = true
      project.save!
    end

    it_behaves_like 'group destruction', false
  end

  context 'repository removal status is taken into account' do
    it 'raises exception' do
      expect_next_instance_of(::Projects::DestroyService) do |destroy_service|
        expect(destroy_service).to receive(:execute).and_return(false)
      end

      expect { destroy_group(group, user, false) }
        .to raise_error(Groups::DestroyService::DestroyError, ""Project #{project.id} can't be deleted"")
    end
  end

  context 'when group owner is blocked' do
    before do
      user.block!
    end

    it 'returns a more descriptive error message' do
      expect { destroy_group(group, user, false) }
      .to raise_error(Groups::DestroyService::DestroyError, ""You can't delete this group because you're blocked."")
    end
  end

  describe 'repository removal' do
    before do
      destroy_group(group, user, false)
    end

    context 'legacy storage' do
      let!(:project) { create(:project, :legacy_storage, :empty_repo, namespace: group) }

      it 'removes repository' do
        expect(project.repository.raw).not_to exist
      end
    end

    context 'hashed storage' do
      let!(:project) { create(:project, :empty_repo, namespace: group) }

      it 'removes repository' do
        expect(project.repository.raw).not_to exist
      end
    end
  end

  describe 'authorization updates', :sidekiq_inline do
    context 'for solo groups' do
      context 'group is deleted' do
        it 'updates project authorization' do
          expect { destroy_group(group, user, false) }.to(
            change { user.can?(:read_project, project) }.from(true).to(false))
        end

        it 'does not make use of a specific service to update project_authorizations records' do
          expect(UserProjectAccessChangedService)
            .not_to receive(:new).with(group.user_ids_for_project_authorizations)

          destroy_group(group, user, false)
        end
      end
    end

    context 'for shared groups within different hierarchies' do
      let(:group1) { create(:group, :private) }
      let(:group2) { create(:group, :private) }

      let(:group1_user) { create(:user) }
      let(:group2_user) { create(:user) }

      before do
        group1.add_member(group1_user, Gitlab::Access::OWNER)
        group2.add_member(group2_user, Gitlab::Access::OWNER)
      end

      context 'when a project is shared with a group' do
        let!(:group1_project) { create(:project, :private, group: group1) }

        before do
          create(:project_group_link, project: group1_project, group: group2)
        end

        context 'and the shared group is deleted' do
          it 'updates project authorizations so group2 users no longer have access', :aggregate_failures do
            expect(group1_user.can?(:read_project, group1_project)).to eq(true)
            expect(group2_user.can?(:read_project, group1_project)).to eq(true)

            destroy_group(group2, group2_user, false)

            expect(group1_user.can?(:read_project, group1_project)).to eq(true)
            expect(group2_user.can?(:read_project, group1_project)).to eq(false)
          end

          it 'calls the service to update project authorizations only with necessary user ids' do
            expect(UserProjectAccessChangedService)
              .to receive(:new).with(array_including(group2_user.id)).and_call_original

            destroy_group(group2, group2_user, false)
          end
        end

        context 'and the group is shared with another group' do
          let(:group3) { create(:group, :private) }
          let(:group3_user) { create(:user) }

          before do
            group3.add_member(group3_user, Gitlab::Access::OWNER)

            create(:group_group_link, shared_group: group2, shared_with_group: group3)
            group3.refresh_members_authorized_projects
          end

          it 'updates project authorizations so group2 and group3 users no longer have access', :aggregate_failures do
            expect(group1_user.can?(:read_project, group1_project)).to eq(true)
            expect(group2_user.can?(:read_project, group1_project)).to eq(true)
            expect(group3_user.can?(:read_project, group1_project)).to eq(true)

            destroy_group(group2, group2_user, false)

            expect(group1_user.can?(:read_project, group1_project)).to eq(true)
            expect(group2_user.can?(:read_project, group1_project)).to eq(false)
            expect(group3_user.can?(:read_project, group1_project)).to eq(false)
          end

          it 'calls the service to update project authorizations only with necessary user ids' do
            expect(UserProjectAccessChangedService)
              .to receive(:new).with(array_including(group2_user.id, group3_user.id)).and_call_original

            destroy_group(group2, group2_user, false)
          end
        end
      end

      context 'when a group is shared with a group' do
        let!(:group2_project) { create(:project, :private, group: group2) }

        before do
          create(:group_group_link, shared_group: group2, shared_with_group: group1)
          group1.refresh_members_authorized_projects
        end

        context 'and the shared group is deleted' do
          it 'updates project authorizations since the project has been deleted with the group', :aggregate_failures do
            expect(group1_user.can?(:read_project, group2_project)).to eq(true)
            expect(group2_user.can?(:read_project, group2_project)).to eq(true)

            destroy_group(group2, group2_user, false)

            expect(group1_user.can?(:read_project, group2_project)).to eq(false)
            expect(group2_user.can?(:read_project, group2_project)).to eq(false)
          end

          it 'does not call the service to update project authorizations' do
            expect(UserProjectAccessChangedService).not_to receive(:new)

            destroy_group(group2, group2_user, false)
          end
        end

        context 'the shared_with group is deleted' do
          let!(:group2_subgroup) { create(:group, :private, parent: group2) }
          let!(:group2_subgroup_project) { create(:project, :private, group: group2_subgroup) }

          it 'updates project authorizations so users of both groups lose access', :aggregate_failures do
            expect(group1_user.can?(:read_project, group2_project)).to eq(true)
            expect(group2_user.can?(:read_project, group2_project)).to eq(true)
            expect(group1_user.can?(:read_project, group2_subgroup_project)).to eq(true)
            expect(group2_user.can?(:read_project, group2_subgroup_project)).to eq(true)

            destroy_group(group1, group1_user, false)

            expect(group1_user.can?(:read_project, group2_project)).to eq(false)
            expect(group2_user.can?(:read_project, group2_project)).to eq(true)
            expect(group1_user.can?(:read_project, group2_subgroup_project)).to eq(false)
            expect(group2_user.can?(:read_project, group2_subgroup_project)).to eq(true)
          end

          it 'calls the service to update project authorizations only with necessary user ids' do
            expect(UserProjectAccessChangedService)
              .to receive(:new).with([group1_user.id]).and_call_original

            destroy_group(group1, group1_user, false)
          end
        end
      end
    end

    context 'for shared groups in the same group hierarchy' do
      let(:shared_group) { group }
      let(:shared_with_group) { nested_group }
      let!(:shared_with_group_user) { create(:user) }

      before do
        shared_with_group.add_member(shared_with_group_user, Gitlab::Access::MAINTAINER)

        create(:group_group_link, shared_group: shared_group, shared_with_group: shared_with_group)
        shared_with_group.refresh_members_authorized_projects
      end

      context 'the shared group is deleted' do
        it 'updates project authorization' do
          expect { destroy_group(shared_group, user, false) }.to(
            change { shared_with_group_user.can?(:read_project, project) }.from(true).to(false))
        end

        it 'does not make use of a specific service to update project authorizations' do
          # Due to the recursive nature of `Groups::DestroyService`, `UserProjectAccessChangedService`
          # will still be executed for the nested group as they fall under the same hierarchy
          # and hence we need to account for this scenario.
          expect(UserProjectAccessChangedService)
            .to receive(:new).with(shared_with_group.users_ids_of_direct_members).and_call_original

          expect(UserProjectAccessChangedService)
            .not_to receive(:new).with(shared_group.users_ids_of_direct_members)

          destroy_group(shared_group, user, false)
        end
      end

      context 'the shared_with group is deleted' do
        it 'updates project authorization' do
          expect { destroy_group(shared_with_group, user, false) }.to(
            change { shared_with_group_user.can?(:read_project, project) }.from(true).to(false))
        end

        it 'makes use of a specific service to update project authorizations' do
          expect(UserProjectAccessChangedService)
            .to receive(:new).with(shared_with_group.users_ids_of_direct_members).and_call_original

          destroy_group(shared_with_group, user, false)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Groups
  class UpdateService < Groups::BaseService
    include UpdateVisibilityLevel

    SETTINGS_PARAMS = [:allow_mfa_for_subgroups].freeze

    def execute
      reject_parent_id!
      remove_unallowed_params

      before_assignment_hook(group, params)

      if renaming_group_with_container_registry_images?
        group.errors.add(:base, container_images_error)
        return false
      end

      return false unless valid_visibility_level_change?(group, group.visibility_attribute_value(params))

      return false unless valid_share_with_group_lock_change?

      return false unless valid_path_change?

      return false unless update_shared_runners

      handle_changes

      handle_namespace_settings

      group.assign_attributes(params)

      begin
        success = group.save

        after_update if success

        success
      rescue Gitlab::UpdatePathError => e
        group.errors.add(:base, e.message)

        false
      end
    end

    private

    def valid_path_change?
      return true unless group.packages_feature_enabled?
      return true if params[:path].blank?
      return true if group.has_parent?
      return true if !group.has_parent? && group.path == params[:path]

      # we have a path change on a root group:
      # check that we don't have any npm package with a scope set to the group path
      npm_packages = ::Packages::GroupPackagesFinder.new(current_user, group, package_type: :npm, preload_pipelines: false)
                       .execute
                       .with_npm_scope(group.path)

      return true unless npm_packages.exists?

      group.errors.add(:path, s_('GroupSettings|cannot change when group contains projects with NPM packages'))
      false
    end

    def before_assignment_hook(group, params)
      @full_path_before = group.full_path
      @path_before = group.path
    end

    def renaming_group_with_container_registry_images?
      renaming? && group.has_container_repository_including_subgroups?
    end

    def renaming?
      new_path = params[:path]

      new_path && new_path != @path_before
    end

    def container_images_error
      s_(""GroupSettings|Cannot update the path because there are projects under this group that contain Docker images in their Container Registry. Please remove the images from your projects first and try again."")
    end

    def after_update
      if group.previous_changes.include?(group.visibility_level_field) && group.private?
        # don't enqueue immediately to prevent todos removal in case of a mistake
        TodosDestroyer::GroupPrivateWorker.perform_in(Todo::WAIT_FOR_DELETE, group.id)
      end

      update_two_factor_requirement_for_subgroups

      publish_event
    end

    def update_two_factor_requirement_for_subgroups
      settings = group.namespace_settings
      return if settings.allow_mfa_for_subgroups

      if settings.previous_changes.include?(:allow_mfa_for_subgroups)
        # enque in batches members update
        DisallowTwoFactorForSubgroupsWorker.perform_async(group.id)
      end
    end

    def reject_parent_id!
      params.delete(:parent_id)
    end

    # overridden in EE
    def remove_unallowed_params
      params.delete(:emails_disabled) unless can?(current_user, :set_emails_disabled, group)

      unless can?(current_user, :update_default_branch_protection, group)
        params.delete(:default_branch_protection)
        params.delete(:default_branch_protection_defaults)
      end
    end

    def handle_changes
      handle_settings_update
      handle_crm_settings_update unless params[:crm_enabled].nil?
    end

    def handle_settings_update
      settings_params = params.slice(*allowed_settings_params)
      settings_params.merge!({ default_branch_protection: params[:default_branch_protection] }.compact)
      allowed_settings_params.each { |param| params.delete(param) }

      ::NamespaceSettings::UpdateService.new(current_user, group, settings_params).execute
    end

    def handle_crm_settings_update
      crm_enabled = params.delete(:crm_enabled)
      return if group.crm_enabled? == crm_enabled

      crm_settings = group.crm_settings || group.build_crm_settings
      crm_settings.enabled = crm_enabled
      crm_settings.save
    end

    def allowed_settings_params
      SETTINGS_PARAMS
    end

    def valid_share_with_group_lock_change?
      return true unless changing_share_with_group_lock?
      return true if can?(current_user, :change_share_with_group_lock, group)

      group.errors.add(:share_with_group_lock, s_('GroupSettings|cannot be disabled when the parent group ""Share with group lock"" is enabled, except by the owner of the parent group'))
      false
    end

    def changing_share_with_group_lock?
      return false if params[:share_with_group_lock].nil?

      params[:share_with_group_lock] != group.share_with_group_lock
    end

    def update_shared_runners
      return true if params[:shared_runners_setting].nil?

      result = Groups::UpdateSharedRunnersService.new(group, current_user, shared_runners_setting: params.delete(:shared_runners_setting)).execute

      return true if result[:status] == :success

      group.errors.add(:update_shared_runners, result[:message])
      false
    end

    def publish_event
      return unless renaming?

      event = Groups::GroupPathChangedEvent.new(
        data: {
          group_id: group.id,
          root_namespace_id: group.root_ancestor.id,
          old_path: @full_path_before,
          new_path: group.full_path
        }
      )

      Gitlab::EventStore.publish(event)
    end
  end
end

Groups::UpdateService.prepend_mod_with('Groups::UpdateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Groups::UpdateService, feature_category: :groups_and_projects do
  let!(:user) { create(:user) }
  let!(:private_group) { create(:group, :private) }
  let!(:internal_group) { create(:group, :internal) }
  let!(:public_group) { create(:group, :public) }

  describe ""#execute"" do
    context 'with project' do
      let!(:group) { create(:group, :public) }
      let(:project) { create(:project, namespace: group) }

      context 'located in a subgroup' do
        let(:subgroup) { create(:group, parent: group) }
        let!(:project) { create(:project, namespace: subgroup) }

        before do
          subgroup.add_owner(user)
        end

        it 'does allow a path update if there is not a root namespace change' do
          expect(update_group(subgroup, user, path: 'updated')).to be true
          expect(subgroup.errors[:path]).to be_empty
        end
      end
    end

    context ""project visibility_level validation"" do
      context ""public group with public projects"" do
        let!(:service) { described_class.new(public_group, user, visibility_level: Gitlab::VisibilityLevel::INTERNAL) }

        before do
          public_group.add_member(user, Gitlab::Access::OWNER)
          create(:project, :public, group: public_group)

          expect(TodosDestroyer::GroupPrivateWorker).not_to receive(:perform_in)
        end

        it ""does not change permission level"" do
          service.execute
          expect(public_group.errors.count).to eq(1)

          expect(TodosDestroyer::GroupPrivateWorker).not_to receive(:perform_in)
        end

        it ""returns false if save failed"" do
          allow(public_group).to receive(:save).and_return(false)

          expect(service.execute).to be_falsey
        end

        context 'when a project has container images' do
          let(:params) { { path: SecureRandom.hex } }
          let!(:container_repository) { create(:container_repository, project: project) }

          subject { described_class.new(public_group, user, params).execute }

          context 'within group' do
            let(:project) { create(:project, group: public_group) }

            context 'with path updates' do
              it 'does not allow the update' do
                expect(subject).to be false
                expect(public_group.errors[:base].first).to match(/Docker images in their Container Registry/)
              end
            end

            context 'with name updates' do
              let(:params) { { name: 'new-name' } }

              it 'allows the update' do
                expect(subject).to be true
                expect(public_group.reload.name).to eq('new-name')
              end
            end

            context 'when the path does not change' do
              let(:params) { { name: 'new-name', path: public_group.path } }

              it 'allows the update' do
                expect(subject).to be true
                expect(public_group.reload.name).to eq('new-name')
              end
            end
          end

          context 'within subgroup' do
            let(:subgroup) { create(:group, parent: public_group) }
            let(:project) { create(:project, group: subgroup) }

            it 'does not allow path updates' do
              expect(subject).to be false
              expect(public_group.errors[:base].first).to match(/Docker images in their Container Registry/)
            end
          end
        end
      end

      context ""internal group with internal project"" do
        let!(:service) { described_class.new(internal_group, user, visibility_level: Gitlab::VisibilityLevel::PRIVATE) }

        before do
          internal_group.add_member(user, Gitlab::Access::OWNER)
          create(:project, :internal, group: internal_group)

          expect(TodosDestroyer::GroupPrivateWorker).not_to receive(:perform_in)
        end

        it ""does not change permission level"" do
          service.execute
          expect(internal_group.errors.count).to eq(1)
        end
      end

      context ""internal group with private project"" do
        let!(:service) { described_class.new(internal_group, user, visibility_level: Gitlab::VisibilityLevel::PRIVATE) }

        before do
          internal_group.add_member(user, Gitlab::Access::OWNER)
          create(:project, :private, group: internal_group)

          expect(TodosDestroyer::GroupPrivateWorker).to receive(:perform_in)
            .with(Todo::WAIT_FOR_DELETE, internal_group.id)
        end

        it ""changes permission level to private"" do
          service.execute
          expect(internal_group.visibility_level)
            .to eq(Gitlab::VisibilityLevel::PRIVATE)
        end
      end
    end

    context ""with parent_id user doesn't have permissions for"" do
      let(:service) { described_class.new(public_group, user, parent_id: private_group.id) }

      before do
        service.execute
      end

      it 'does not update parent_id' do
        updated_group = public_group.reload

        expect(updated_group.parent_id).to be_nil
      end
    end

    context 'crm_enabled param' do
      context 'when no existing crm_settings' do
        it 'when param not present, leave crm disabled' do
          params = {}

          described_class.new(public_group, user, params).execute
          updated_group = public_group.reload

          expect(updated_group.crm_enabled?).to be_falsey
        end

        it 'when param set true, enables crm' do
          params = { crm_enabled: true }

          described_class.new(public_group, user, params).execute
          updated_group = public_group.reload

          expect(updated_group.crm_enabled?).to be_truthy
        end
      end

      context 'with existing crm_settings' do
        it 'when param set true, enables crm' do
          params = { crm_enabled: true }
          create(:crm_settings, group: public_group)

          described_class.new(public_group, user, params).execute

          updated_group = public_group.reload
          expect(updated_group.crm_enabled?).to be_truthy
        end

        it 'when param set false, disables crm' do
          params = { crm_enabled: false }
          create(:crm_settings, group: public_group, enabled: true)

          described_class.new(public_group, user, params).execute

          updated_group = public_group.reload
          expect(updated_group.crm_enabled?).to be_falsy
        end

        it 'when param not present, crm remains disabled' do
          params = {}
          create(:crm_settings, group: public_group)

          described_class.new(public_group, user, params).execute

          updated_group = public_group.reload
          expect(updated_group.crm_enabled?).to be_falsy
        end

        it 'when param not present, crm remains enabled' do
          params = {}
          create(:crm_settings, group: public_group, enabled: true)

          described_class.new(public_group, user, params).execute

          updated_group = public_group.reload
          expect(updated_group.crm_enabled?).to be_truthy
        end
      end
    end
  end

  context ""unauthorized visibility_level validation"" do
    let!(:service) { described_class.new(internal_group, user, visibility_level: 99) }

    before do
      internal_group.add_member(user, Gitlab::Access::MAINTAINER)
    end

    it ""does not change permission level"" do
      service.execute
      expect(internal_group.errors.count).to eq(1)
    end
  end

  context ""path change validation"" do
    let_it_be(:group) { create(:group) }
    let_it_be(:subgroup) { create(:group, parent: group) }
    let_it_be(:project) { create(:project, namespace: subgroup) }

    subject(:execute_update) { update_group(target_group, user, update_params) }

    shared_examples 'not allowing a path update' do
      let(:update_params) { { path: 'updated' } }

      it 'does not allow a path update' do
        target_group.add_maintainer(user)

        expect(execute_update).to be false
        expect(target_group.errors[:path]).to include('cannot change when group contains projects with NPM packages')
      end
    end

    shared_examples 'allowing an update' do |on:|
      let(:update_params) { { on => 'updated' } }

      it ""allows an update on #{on}"" do
        target_group.reload.add_maintainer(user)

        expect(execute_update).to be true
        expect(target_group.errors).to be_empty
        expect(target_group[on]).to eq('updated')
      end
    end

    context 'with namespaced npm packages' do
      let_it_be(:package) { create(:npm_package, project: project, name: ""@#{group.path}/test"") }

      context 'updating the root group' do
        let_it_be_with_refind(:target_group) { group }

        it_behaves_like 'not allowing a path update'
        it_behaves_like 'allowing an update', on: :name
      end

      context 'updating the subgroup' do
        let_it_be_with_refind(:target_group) { subgroup }

        it_behaves_like 'allowing an update', on: :path
        it_behaves_like 'allowing an update', on: :name
      end
    end

    context 'with scoped npm packages' do
      let_it_be(:package) { create(:npm_package, project: project, name: '@any_scope/test') }

      context 'updating the root group' do
        let_it_be_with_refind(:target_group) { group }

        it_behaves_like 'allowing an update', on: :path
        it_behaves_like 'allowing an update', on: :name
      end

      context 'updating the subgroup' do
        let_it_be_with_refind(:target_group) { subgroup }

        it_behaves_like 'allowing an update', on: :path
        it_behaves_like 'allowing an update', on: :name
      end
    end

    context 'with unscoped npm packages' do
      let_it_be(:package) { create(:npm_package, project: project, name: 'test') }

      context 'updating the root group' do
        let_it_be_with_refind(:target_group) { group }

        it_behaves_like 'allowing an update', on: :path
        it_behaves_like 'allowing an update', on: :name
      end

      context 'updating the subgroup' do
        let_it_be_with_refind(:target_group) { subgroup }

        it_behaves_like 'allowing an update', on: :path
        it_behaves_like 'allowing an update', on: :name
      end
    end
  end

  context 'when user is not group owner' do
    context 'when group is private' do
      before do
        private_group.add_maintainer(user)
      end

      it 'does not update the group to public' do
        result = described_class.new(private_group, user, visibility_level: Gitlab::VisibilityLevel::PUBLIC).execute

        expect(result).to eq(false)
        expect(private_group.errors.count).to eq(1)
        expect(private_group).to be_private
      end

      it 'does not update the group to public with tricky value' do
        result = described_class.new(private_group, user, visibility_level: Gitlab::VisibilityLevel::PUBLIC.to_s + 'r').execute

        expect(result).to eq(false)
        expect(private_group.errors.count).to eq(1)
        expect(private_group).to be_private
      end
    end

    context 'when group is public' do
      before do
        public_group.add_maintainer(user)
      end

      it 'does not update the group to private' do
        result = described_class.new(public_group, user, visibility_level: Gitlab::VisibilityLevel::PRIVATE).execute

        expect(result).to eq(false)
        expect(public_group.errors.count).to eq(1)
        expect(public_group).to be_public
      end

      it 'does not update the group to private with invalid string value' do
        result = described_class.new(public_group, user, visibility_level: 'invalid').execute

        expect(result).to eq(false)
        expect(public_group.errors.count).to eq(1)
        expect(public_group).to be_public
      end

      it 'does not update the group to private with valid string value' do
        result = described_class.new(public_group, user, visibility_level: 'private').execute

        expect(result).to eq(false)
        expect(public_group.errors.count).to eq(1)
        expect(public_group).to be_public
      end

      # See https://gitlab.com/gitlab-org/gitlab/-/issues/359910
      it 'does not update the group to private because of Active Record typecasting' do
        result = described_class.new(public_group, user, visibility_level: 'public').execute

        expect(result).to eq(true)
        expect(public_group.errors.count).to eq(0)
        expect(public_group).to be_public
      end
    end
  end

  context 'when updating #emails_disabled' do
    let(:service) { described_class.new(internal_group, user, emails_disabled: true) }

    it 'updates the attribute' do
      internal_group.add_member(user, Gitlab::Access::OWNER)

      expect { service.execute }.to change { internal_group.emails_disabled }.to(true)
    end

    it 'does not update when not group owner' do
      expect { service.execute }.not_to change { internal_group.emails_disabled }
    end
  end

  context 'updating default_branch_protection' do
    let(:service) do
      described_class.new(internal_group, user, default_branch_protection: Gitlab::Access::PROTECTION_NONE)
    end

    let(:settings) { internal_group.namespace_settings }
    let(:expected_settings) { Gitlab::Access::BranchProtection.protection_none.stringify_keys }

    context 'for users who have the ability to update default_branch_protection' do
      it 'updates default_branch_protection attribute' do
        internal_group.add_owner(user)

        expect { service.execute }.to change { internal_group.default_branch_protection }.from(Gitlab::Access::PROTECTION_FULL).to(Gitlab::Access::PROTECTION_NONE)
      end

      it 'updates default_branch_protection_defaults to match default_branch_protection' do
        internal_group.add_owner(user)

        expect { service.execute }.to change { settings.default_branch_protection_defaults  }.from({}).to(expected_settings)
      end
    end

    context 'for users who do not have the ability to update default_branch_protection' do
      it 'does not update the attribute' do
        expect { service.execute }.not_to change { internal_group.default_branch_protection }
        expect { service.execute }.not_to change { internal_group.namespace_settings.default_branch_protection_defaults }
      end
    end
  end

  context 'updating default_branch_protection_defaults' do
    let(:branch_protection) { ::Gitlab::Access::BranchProtection.protected_against_developer_pushes.stringify_keys }

    let(:service) do
      described_class.new(internal_group, user, default_branch_protection_defaults: branch_protection)
    end

    let(:settings) { internal_group.namespace_settings }
    let(:expected_settings) { branch_protection }

    context 'for users who have the ability to update default_branch_protection_defaults' do
      it 'updates default_branch_protection attribute' do
        internal_group.add_owner(user)

        expect { service.execute }.to change { internal_group.default_branch_protection_defaults }.from({}).to(expected_settings)
      end
    end

    context 'for users who do not have the ability to update default_branch_protection_defaults' do
      it 'does not update the attribute' do
        expect { service.execute }.not_to change { internal_group.default_branch_protection_defaults }
        expect { service.execute }.not_to change { internal_group.namespace_settings.default_branch_protection_defaults }
      end
    end
  end

  context 'EventStore' do
    let(:service) { described_class.new(group, user, **params) }
    let(:root_group) { create(:group, path: 'root') }
    let(:group) do
      create(:group, parent: root_group, path: 'old-path').tap { |g| g.add_owner(user) }
    end

    context 'when changing a group path' do
      let(:new_path) { SecureRandom.hex }
      let(:params) { { path: new_path } }

      it 'publishes a GroupPathChangedEvent' do
        old_path = group.full_path

        expect { service.execute }
          .to publish_event(Groups::GroupPathChangedEvent)
          .with(
            group_id: group.id,
            root_namespace_id: group.root_ancestor.id,
            old_path: old_path,
            new_path: ""root/#{new_path}""
          )
      end
    end

    context 'when not changing a group path' do
      let(:params) { { name: 'very-new-name' } }

      it 'does not publish a GroupPathChangedEvent' do
        expect { service.execute }
          .not_to publish_event(Groups::GroupPathChangedEvent)
      end
    end
  end

  context 'rename group' do
    let(:new_path) { SecureRandom.hex }
    let!(:service) { described_class.new(internal_group, user, path: new_path) }

    before do
      internal_group.add_member(user, Gitlab::Access::MAINTAINER)
      create(:project, :internal, group: internal_group)
    end

    it 'returns true' do
      expect(service.execute).to eq(true)
    end
  end

  context 'for a subgroup' do
    let(:subgroup) { create(:group, :private, parent: private_group) }

    context 'when the parent group share_with_group_lock is enabled' do
      before do
        private_group.update_column(:share_with_group_lock, true)
      end

      context 'for the parent group owner' do
        it 'allows disabling share_with_group_lock' do
          private_group.add_owner(user)

          result = described_class.new(subgroup, user, share_with_group_lock: false).execute

          expect(result).to be_truthy
          expect(subgroup.reload.share_with_group_lock).to be_falsey
        end
      end

      context 'for a subgroup owner (who does not own the parent)' do
        it 'does not allow disabling share_with_group_lock' do
          subgroup_owner = create(:user)
          subgroup.add_owner(subgroup_owner)

          result = described_class.new(subgroup, subgroup_owner, share_with_group_lock: false).execute

          expect(result).to be_falsey
          expect(subgroup.errors.full_messages.first).to match(/cannot be disabled when the parent group ""Share with group lock"" is enabled, except by the owner of the parent group/)
          expect(subgroup.reload.share_with_group_lock).to be_truthy
        end
      end
    end
  end

  context 'change shared Runners config' do
    let(:group) { create(:group) }
    let(:project) { create(:project, shared_runners_enabled: true, group: group) }

    subject { described_class.new(group, user, shared_runners_setting: Namespace::SR_DISABLED_AND_UNOVERRIDABLE).execute }

    before do
      group.add_owner(user)
    end

    it 'calls the shared runners update service' do
      expect_any_instance_of(::Groups::UpdateSharedRunnersService).to receive(:execute).and_return({ status: :success })

      expect(subject).to be_truthy
    end

    it 'handles errors in the shared runners update service' do
      expect_any_instance_of(::Groups::UpdateSharedRunnersService).to receive(:execute).and_return({ status: :error, message: 'something happened' })

      expect(subject).to be_falsy

      expect(group.errors[:update_shared_runners].first).to eq('something happened')
    end
  end

  context 'changes allowing subgroups to establish own 2FA' do
    let(:group) { create(:group) }
    let(:params) { { allow_mfa_for_subgroups: false } }

    subject { described_class.new(group, user, params).execute }

    it 'changes settings' do
      subject

      expect(group.namespace_settings.reload.allow_mfa_for_subgroups).to eq(false)
    end

    it 'enqueues update subgroups and its members' do
      expect(DisallowTwoFactorForSubgroupsWorker).to receive(:perform_async).with(group.id)

      subject
    end
  end

  def update_group(group, user, opts)
    Groups::UpdateService.new(group, user, opts).execute
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Groups
  # Service class for counting and caching the number of open issues of a group.
  class OpenIssuesCountService < Groups::CountService
    PUBLIC_COUNT_KEY = 'group_public_open_issues_count'
    TOTAL_COUNT_KEY = 'group_total_open_issues_count'

    def clear_all_cache_keys
      [cache_key(PUBLIC_COUNT_KEY), cache_key(TOTAL_COUNT_KEY)].each do |key|
        Rails.cache.delete(key)
      end
    end

    private

    def cache_key_name
      public_only? ? PUBLIC_COUNT_KEY : TOTAL_COUNT_KEY
    end

    def public_only?
      !user_is_at_least_reporter?
    end

    def user_is_at_least_reporter?
      strong_memoize(:user_is_at_least_reporter) do
        group.member?(user, Gitlab::Access::REPORTER)
      end
    end

    def relation_for_count
      IssuesFinder.new(
        user,
        group_id: group.id,
        state: 'opened',
        non_archived: true,
        include_subgroups: true,
        public_only: public_only?
      ).execute
    end

    def issuable_key
      'open_issues'
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Groups::OpenIssuesCountService, :use_clean_rails_memory_store_caching, feature_category: :groups_and_projects do
  let_it_be(:group) { create(:group, :public) }
  let_it_be(:project) { create(:project, :public, namespace: group) }
  let_it_be(:user) { create(:user) }
  let_it_be(:issue) { create(:issue, :opened, project: project) }
  let_it_be(:confidential) { create(:issue, :opened, confidential: true, project: project) }
  let_it_be(:closed) { create(:issue, :closed, project: project) }

  subject { described_class.new(group, user) }

  describe '#relation_for_count' do
    before do
      allow(IssuesFinder).to receive(:new).and_call_original
    end

    it 'uses the IssuesFinder to scope issues' do
      expect(IssuesFinder)
        .to receive(:new)
        .with(user, group_id: group.id, state: 'opened', non_archived: true, include_subgroups: true, public_only: true)

      subject.count
    end
  end

  describe '#count' do
    context 'when user is nil' do
      it 'does not include confidential issues in the issue count' do
        expect(described_class.new(group).count).to eq(1)
      end
    end

    context 'when user is provided' do
      context 'when user can read confidential issues' do
        before do
          group.add_reporter(user)
        end

        it 'returns the right count with confidential issues' do
          expect(subject.count).to eq(2)
        end
      end

      context 'when user cannot read confidential issues' do
        before do
          group.add_guest(user)
        end

        it 'does not include confidential issues' do
          expect(subject.count).to eq(1)
        end
      end

      it_behaves_like 'a counter caching service with threshold'
    end
  end

  describe '#clear_all_cache_keys' do
    it 'calls `Rails.cache.delete` with the correct keys' do
      expect(Rails.cache).to receive(:delete)
        .with(['groups', 'open_issues_count_service', 1, group.id, described_class::PUBLIC_COUNT_KEY])
      expect(Rails.cache).to receive(:delete)
        .with(['groups', 'open_issues_count_service', 1, group.id, described_class::TOTAL_COUNT_KEY])

      subject.clear_all_cache_keys
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Groups
  class UpdateStatisticsService
    attr_reader :group, :statistics

    def initialize(group, statistics: [])
      @group = group
      @statistics = statistics
    end

    def execute
      unless group
        return ServiceResponse.error(message: 'Invalid group', http_status: 400)
      end

      namespace_statistics.refresh!(only: statistics.map(&:to_sym))

      ServiceResponse.success(message: 'Group statistics successfully updated.')
    end

    private

    def namespace_statistics
      @namespace_statistics ||= group.namespace_statistics || group.build_namespace_statistics
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Groups::UpdateStatisticsService, feature_category: :groups_and_projects do
  let_it_be(:group, reload: true) { create(:group) }

  let(:statistics) { %w[wiki_size] }

  subject(:service) { described_class.new(group, statistics: statistics) }

  describe '#execute', :aggregate_failures do
    context 'when group is nil' do
      let(:group) { nil }

      it 'does nothing' do
        expect(NamespaceStatistics).not_to receive(:new)

        result = service.execute

        expect(result).to be_error
      end
    end

    context 'with an existing group' do
      context 'when namespace statistics exists for the group' do
        it 'uses the existing statistics and refreshes them' do
          namespace_statistics = create(:namespace_statistics, namespace: group)

          expect(namespace_statistics).to receive(:refresh!).with(only: statistics.map(&:to_sym)).and_call_original

          result = service.execute

          expect(result).to be_success
        end
      end

      context 'when namespace statistics does not exist for the group' do
        it 'creates the statistics and refreshes them' do
          expect_next_instance_of(NamespaceStatistics) do |instance|
            expect(instance).to receive(:refresh!).with(only: statistics.map(&:to_sym)).and_call_original
          end

          result = nil

          expect do
            result = service.execute
          end.to change { NamespaceStatistics.count }.by(1)

          expect(result).to be_success
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Groups
  class CreateService < Groups::BaseService
    def initialize(user, params = {})
      @current_user = user
      @params = params.dup
      @chat_team = @params.delete(:create_chat_team)
      @create_event = @params.delete(:create_event)
    end

    def execute
      remove_unallowed_params
      set_visibility_level

      @group = Group.new(params.except(*::NamespaceSetting.allowed_namespace_settings_params))

      @group.build_namespace_settings
      handle_namespace_settings

      after_build_hook(@group, params)

      inherit_group_shared_runners_settings

      unless can_use_visibility_level? && can_create_group?
        return @group
      end

      @group.name ||= @group.path.dup

      if create_chat_team?
        response = ::Mattermost::CreateTeamService.new(@group, current_user).execute
        return @group if @group.errors.any?

        @group.build_chat_team(name: response['name'], team_id: response['id'])
      end

      Gitlab::Database::QueryAnalyzers::PreventCrossDatabaseModification.temporary_ignore_tables_in_transaction(
        %w[routes redirect_routes], url: 'https://gitlab.com/gitlab-org/gitlab/-/issues/424281'
      ) do
        Group.transaction do
          if @group.save
            @group.add_owner(current_user)
            Integration.create_from_active_default_integrations(@group, :group_id)
          end
        end
      end

      after_create_hook

      @group
    end

    private

    attr_reader :create_event

    def after_build_hook(group, params)
      # overridden in EE
    end

    def after_create_hook
      # overridden in EE
    end

    def remove_unallowed_params
      unless can?(current_user, :create_group_with_default_branch_protection)
        params.delete(:default_branch_protection)
        params.delete(:default_branch_protection_defaults)
      end

      params.delete(:allow_mfa_for_subgroups)
    end

    def create_chat_team?
      Gitlab.config.mattermost.enabled && @chat_team && group.chat_team.nil?
    end

    def can_create_group?
      if @group.subgroup?
        unless can?(current_user, :create_subgroup, @group.parent)
          @group.parent = nil
          @group.errors.add(:parent_id, s_('CreateGroup|You don’t have permission to create a subgroup in this group.'))

          return false
        end
      else
        unless can?(current_user, :create_group)
          @group.errors.add(:base, s_('CreateGroup|You don’t have permission to create groups.'))

          return false
        end
      end

      true
    end

    def can_use_visibility_level?
      unless Gitlab::VisibilityLevel.allowed_for?(current_user, visibility_level)
        deny_visibility_level(@group)
        return false
      end

      true
    end

    def set_visibility_level
      return if visibility_level.present?

      params[:visibility_level] = Gitlab::CurrentSettings.current_application_settings.default_group_visibility
    end

    def inherit_group_shared_runners_settings
      return unless @group.parent

      @group.shared_runners_enabled = @group.parent.shared_runners_enabled
      @group.allow_descendants_override_disabled_shared_runners = @group.parent.allow_descendants_override_disabled_shared_runners
    end
  end
end

Groups::CreateService.prepend_mod_with('Groups::CreateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Groups::CreateService, '#execute', feature_category: :groups_and_projects do
  let!(:user) { create(:user) }
  let!(:group_params) { { path: ""group_path"", visibility_level: Gitlab::VisibilityLevel::PUBLIC } }

  subject { service.execute }

  shared_examples 'has sync-ed traversal_ids' do
    specify { expect(subject.reload.traversal_ids).to eq([subject.parent&.traversal_ids, subject.id].flatten.compact) }
  end

  describe 'visibility level restrictions' do
    let!(:service) { described_class.new(user, group_params) }

    context ""create groups without restricted visibility level"" do
      it { is_expected.to be_persisted }
    end

    context ""cannot create group with restricted visibility level"" do
      before do
        allow_any_instance_of(ApplicationSetting).to receive(:restricted_visibility_levels).and_return([Gitlab::VisibilityLevel::PUBLIC])
      end

      it { is_expected.not_to be_persisted }
    end
  end

  context 'when `setup_for_company:true` is passed' do
    let(:params) { group_params.merge(setup_for_company: true) }
    let(:service) { described_class.new(user, params) }
    let(:created_group) { service.execute }

    it 'creates group with the specified setup_for_company' do
      expect(created_group.setup_for_company).to eq(true)
    end
  end

  context 'creating a group with `default_branch_protection` attribute' do
    let(:params) { group_params.merge(default_branch_protection: Gitlab::Access::PROTECTION_NONE) }
    let(:service) { described_class.new(user, params) }
    let(:created_group) { service.execute }

    context 'for users who have the ability to create a group with `default_branch_protection`' do
      it 'creates group with the specified branch protection level' do
        expect(created_group.default_branch_protection).to eq(Gitlab::Access::PROTECTION_NONE)
      end
    end

    context 'for users who do not have the ability to create a group with `default_branch_protection`' do
      it 'does not create the group with the specified branch protection level' do
        allow(Ability).to receive(:allowed?).and_call_original
        allow(Ability).to receive(:allowed?).with(user, :create_group_with_default_branch_protection) { false }

        expect(created_group.default_branch_protection).not_to eq(Gitlab::Access::PROTECTION_NONE)
      end
    end
  end

  context 'creating a group with `default_branch_protection_defaults` attribute' do
    let(:branch_protection) { ::Gitlab::Access::BranchProtection.protected_against_developer_pushes.stringify_keys }
    let(:params) { group_params.merge(default_branch_protection_defaults: branch_protection) }
    let(:service) { described_class.new(user, params) }
    let(:created_group) { service.execute }

    context 'for users who have the ability to create a group with `default_branch_protection`' do
      before do
        allow(Ability).to receive(:allowed?).and_call_original
        allow(Ability).to receive(:allowed?).with(user, :update_default_branch_protection, an_instance_of(Group)).and_return(true)
      end

      it 'creates group with the specified default branch protection settings' do
        expect(created_group.default_branch_protection_defaults).to eq(branch_protection)
      end
    end

    context 'for users who do not have the ability to create a group with `default_branch_protection_defaults`' do
      it 'does not create the group with the specified default branch protection settings' do
        allow(Ability).to receive(:allowed?).and_call_original
        allow(Ability).to receive(:allowed?).with(user, :create_group_with_default_branch_protection) { false }

        expect(created_group.default_branch_protection_defaults).not_to eq(Gitlab::Access::PROTECTION_NONE)
      end
    end
  end

  context 'creating a group with `allow_mfa_for_subgroups` attribute' do
    let(:params) { group_params.merge(allow_mfa_for_subgroups: false) }
    let(:service) { described_class.new(user, params) }

    it 'creates group without error' do
      expect(service.execute).to be_persisted
    end
  end

  describe 'creating a top level group' do
    let(:service) { described_class.new(user, group_params) }

    context 'when user can create a group' do
      before do
        user.update_attribute(:can_create_group, true)
      end

      it { is_expected.to be_persisted }

      context 'with before_commit callback' do
        it_behaves_like 'has sync-ed traversal_ids'
      end
    end

    context 'when user can not create a group' do
      before do
        user.update_attribute(:can_create_group, false)
      end

      it { is_expected.not_to be_persisted }
    end
  end

  describe 'creating subgroup' do
    let!(:group) { create(:group) }
    let!(:service) { described_class.new(user, group_params.merge(parent_id: group.id)) }

    context 'as group owner' do
      before do
        group.add_owner(user)
      end

      it { is_expected.to be_persisted }

      it_behaves_like 'has sync-ed traversal_ids'
    end

    context 'as guest' do
      it 'does not save group and returns an error' do
        is_expected.not_to be_persisted

        expect(subject.errors[:parent_id].first).to eq(s_('CreateGroup|You don’t have permission to create a subgroup in this group.'))
        expect(subject.parent_id).to be_nil
      end
    end

    context 'as owner' do
      before do
        group.add_owner(user)
      end

      it { is_expected.to be_persisted }
    end

    context 'as maintainer' do
      before do
        group.add_maintainer(user)
      end

      it { is_expected.to be_persisted }
    end
  end

  describe ""when visibility level is passed as a string"" do
    let(:service) { described_class.new(user, group_params) }
    let(:group_params) { { path: 'group_path', visibility: 'public' } }

    it ""assigns the correct visibility level"" do
      group = service.execute

      expect(group.visibility_level).to eq(Gitlab::VisibilityLevel::PUBLIC)
    end
  end

  describe 'creating a mattermost team' do
    let!(:params) { group_params.merge(create_chat_team: ""true"") }
    let!(:service) { described_class.new(user, params) }

    before do
      stub_mattermost_setting(enabled: true)
    end

    it 'create the chat team with the group' do
      allow_any_instance_of(::Mattermost::Team).to receive(:create)
        .and_return({ 'name' => 'tanuki', 'id' => 'lskdjfwlekfjsdifjj' })

      expect { subject }.to change { ChatTeam.count }.from(0).to(1)
    end
  end

  describe 'creating a setting record' do
    let(:service) { described_class.new(user, group_params) }

    it 'create the settings record connected to the group' do
      group = subject
      expect(group.namespace_settings).to be_persisted
    end
  end

  describe 'creating a details record' do
    let(:service) { described_class.new(user, group_params) }

    it 'create the details record connected to the group' do
      group = subject
      expect(group.namespace_details).to be_persisted
    end
  end

  describe 'create service for the group' do
    let(:service) { described_class.new(user, group_params) }
    let(:created_group) { service.execute }

    context 'with an active instance-level integration' do
      let!(:instance_integration) { create(:prometheus_integration, :instance, api_url: 'https://prometheus.instance.com/') }

      it 'creates a service from the instance-level integration' do
        expect(created_group.integrations.count).to eq(1)
        expect(created_group.integrations.first.api_url).to eq(instance_integration.api_url)
        expect(created_group.integrations.first.inherit_from_id).to eq(instance_integration.id)
      end

      context 'with an active group-level integration' do
        let(:service) { described_class.new(user, group_params.merge(parent_id: group.id)) }
        let!(:group_integration) { create(:prometheus_integration, :group, group: group, api_url: 'https://prometheus.group.com/') }
        let(:group) do
          create(:group).tap do |group|
            group.add_owner(user)
          end
        end

        it 'creates a service from the group-level integration' do
          expect(created_group.integrations.count).to eq(1)
          expect(created_group.integrations.first.api_url).to eq(group_integration.api_url)
          expect(created_group.integrations.first.inherit_from_id).to eq(group_integration.id)
        end

        context 'with an active subgroup' do
          let(:service) { described_class.new(user, group_params.merge(parent_id: subgroup.id)) }
          let!(:subgroup_integration) { create(:prometheus_integration, :group, group: subgroup, api_url: 'https://prometheus.subgroup.com/') }
          let(:subgroup) do
            create(:group, parent: group).tap do |subgroup|
              subgroup.add_owner(user)
            end
          end

          it 'creates a service from the subgroup-level integration' do
            expect(created_group.integrations.count).to eq(1)
            expect(created_group.integrations.first.api_url).to eq(subgroup_integration.api_url)
            expect(created_group.integrations.first.inherit_from_id).to eq(subgroup_integration.id)
          end
        end
      end
    end
  end

  context 'shared runners configuration' do
    context 'parent group present' do
      using RSpec::Parameterized::TableSyntax

      where(:shared_runners_config, :descendants_override_disabled_shared_runners_config) do
        true  | false
        false | false
        # true  | true # invalid at the group level, leaving as comment to make explicit
        false | true
      end

      with_them do
        let!(:group) { create(:group, shared_runners_enabled: shared_runners_config, allow_descendants_override_disabled_shared_runners: descendants_override_disabled_shared_runners_config) }
        let!(:service) { described_class.new(user, group_params.merge(parent_id: group.id)) }

        before do
          group.add_owner(user)
        end

        it 'creates group following the parent config' do
          new_group = service.execute

          expect(new_group.shared_runners_enabled).to eq(shared_runners_config)
          expect(new_group.allow_descendants_override_disabled_shared_runners).to eq(descendants_override_disabled_shared_runners_config)
        end
      end
    end

    context 'root group' do
      let!(:service) { described_class.new(user) }

      it 'follows default config' do
        new_group = service.execute

        expect(new_group.shared_runners_enabled).to eq(true)
        expect(new_group.allow_descendants_override_disabled_shared_runners).to eq(false)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Groups
  class NestedCreateService < Groups::BaseService
    attr_reader :group_path, :visibility_level

    def initialize(user, params)
      @current_user = user
      @params = params.dup
      @group_path = @params.delete(:group_path)
      @visibility_level = @params.delete(:visibility_level) ||
        Gitlab::CurrentSettings.current_application_settings.default_group_visibility
    end

    def execute
      return unless group_path

      if namespace = namespace_or_group(group_path)
        return namespace
      end

      create_group_path
    end

    private

    def create_group_path
      group_path_segments = group_path.split('/')

      last_group = nil
      partial_path_segments = []
      while subgroup_name = group_path_segments.shift
        partial_path_segments << subgroup_name
        partial_path = partial_path_segments.join('/')

        new_params = params.reverse_merge(
          path: subgroup_name,
          name: subgroup_name,
          parent: last_group,
          visibility_level: visibility_level
        )

        last_group = namespace_or_group(partial_path) ||
          Groups::CreateService.new(current_user, new_params).execute
      end

      last_group
    end

    def namespace_or_group(group_path)
      Namespace.find_by_full_path(group_path)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Groups::NestedCreateService, feature_category: :groups_and_projects do
  let(:user) { create(:user) }

  subject(:service) { described_class.new(user, params) }

  shared_examples 'with a visibility level' do
    it 'creates the group with correct visibility level' do
      allow(Gitlab::CurrentSettings.current_application_settings)
        .to receive(:default_group_visibility) { Gitlab::VisibilityLevel::INTERNAL }

      group = service.execute

      expect(group.visibility_level).to eq(Gitlab::VisibilityLevel::INTERNAL)
    end

    context 'adding a visibility level ' do
      it 'overwrites the visibility level' do
        service = described_class.new(user, params.merge(visibility_level: Gitlab::VisibilityLevel::PRIVATE))

        group = service.execute

        expect(group.visibility_level).to eq(Gitlab::VisibilityLevel::PRIVATE)
      end
    end
  end

  describe 'with subgroups' do
    let(:params) { { group_path: 'a-group/a-sub-group' } }

    describe ""#execute"" do
      it 'returns the group if it already existed' do
        parent = create(:group, path: 'a-group')
        child = create(:group, path: 'a-sub-group', parent: parent)

        parent.add_owner(user)
        child.add_owner(user)

        expect(service.execute).to eq(child)
      end

      it 'reuses a parent if it already existed' do
        parent = create(:group, path: 'a-group')
        parent.add_owner(user)

        expect(service.execute.parent).to eq(parent)
      end

      it 'creates group and subgroup in the database' do
        service.execute

        parent = Group.find_by_full_path('a-group')
        child = parent.children.find_by(path: 'a-sub-group')

        expect(parent).not_to be_nil
        expect(child).not_to be_nil
      end

      it_behaves_like 'with a visibility level'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Groups
  module GroupLinks
    class DestroyService < ::Groups::BaseService
      def execute(one_or_more_links, skip_authorization: false)
        unless skip_authorization || group && can?(current_user, :admin_group_member, group)
          return error('Not Found', 404)
        end

        links = Array(one_or_more_links)

        if GroupGroupLink.delete(links)
          Gitlab::AppLogger.info(
            ""GroupGroupLinks with ids: #{links.map(&:id)} have been deleted."")

          groups_to_refresh = links.map(&:shared_with_group)
          groups_to_refresh.uniq.each do |group|
            next if Feature.enabled?(:skip_group_share_unlink_auth_refresh, group.root_ancestor)

            group.refresh_members_authorized_projects(direct_members_only: true)
          end
        else
          Gitlab::AppLogger.info(
            ""Failed to delete GroupGroupLinks with ids: #{links.map(&:id)}."")
        end

        links
      end
    end
  end
end

Groups::GroupLinks::DestroyService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Groups::GroupLinks::DestroyService, '#execute', feature_category: :groups_and_projects do
  let_it_be(:user) { create(:user) }
  let_it_be(:group) { create(:group, :private) }
  let_it_be(:shared_group) { create(:group, :private) }
  let_it_be(:project) { create(:project, group: shared_group) }
  let_it_be(:owner) { create(:user) }

  subject { described_class.new(shared_group, owner) }

  context 'when authorizing by user' do
    before do
      group.add_developer(owner)
      shared_group.add_owner(owner)
    end

    context 'single link' do
      let!(:link) { create(:group_group_link, shared_group: shared_group, shared_with_group: group) }

      it 'destroys the link' do
        expect { subject.execute(link) }.to change { shared_group.shared_with_group_links.count }.from(1).to(0)
      end

      context 'with skip_group_share_unlink_auth_refresh feature flag disabled' do
        before do
          stub_feature_flags(skip_group_share_unlink_auth_refresh: false)
        end

        it 'revokes project authorization', :sidekiq_inline do
          group.add_developer(user)

          expect { subject.execute(link) }.to(
            change { Ability.allowed?(user, :read_project, project) }.from(true).to(false))
        end
      end

      context 'with skip_group_share_unlink_auth_refresh feature flag enabled' do
        before do
          stub_feature_flags(skip_group_share_unlink_auth_refresh: true)
        end

        it 'maintains project authorization', :sidekiq_inline do
          group.add_developer(user)

          expect(Ability.allowed?(user, :read_project, project)).to be_truthy
        end
      end
    end

    context 'multiple links' do
      let_it_be(:another_group) { create(:group, :private) }
      let_it_be(:another_shared_group) { create(:group, :private) }

      let!(:links) do
        [
          create(:group_group_link, shared_group: shared_group, shared_with_group: group),
          create(:group_group_link, shared_group: shared_group, shared_with_group: another_group),
          create(:group_group_link, shared_group: another_shared_group, shared_with_group: group),
          create(:group_group_link, shared_group: another_shared_group, shared_with_group: another_group)
        ]
      end

      context 'with skip_group_share_unlink_auth_refresh feature flag disabled' do
        before do
          stub_feature_flags(skip_group_share_unlink_auth_refresh: false)
        end

        it 'updates project authorization once per group' do
          expect(GroupGroupLink).to receive(:delete).and_call_original
          expect(group).to receive(:refresh_members_authorized_projects).with(direct_members_only: true).once
          expect(another_group).to receive(:refresh_members_authorized_projects).with(direct_members_only: true).once

          subject.execute(links)
        end
      end

      context 'with skip_group_share_unlink_auth_refresh feature flag enabled' do
        before do
          stub_feature_flags(skip_group_share_unlink_auth_refresh: true)
        end

        it 'does not update project authorization once per group' do
          expect(GroupGroupLink).to receive(:delete).and_call_original
          expect(group).not_to receive(:refresh_members_authorized_projects)
          expect(another_group).not_to receive(:refresh_members_authorized_projects)

          subject.execute(links)
        end
      end
    end
  end

  context 'when skipping authorization' do
    let!(:link) { create(:group_group_link, shared_group: shared_group, shared_with_group: group) }

    context 'with provided group and owner' do
      it 'destroys the link' do
        expect do
          subject.execute(link, skip_authorization: true)
        end.to change { shared_group.shared_with_group_links.count }.from(1).to(0)
      end
    end

    context 'without providing group or owner' do
      subject { described_class.new(nil, nil) }

      it 'destroys the link' do
        expect do
          subject.execute(link, skip_authorization: true)
        end.to change { shared_group.shared_with_group_links.count }.from(1).to(0)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Groups
  module GroupLinks
    class UpdateService < ::Groups::BaseService
      def initialize(group_link, user = nil)
        super(group_link.shared_group, user)

        @group_link = group_link
      end

      def execute(group_link_params)
        group_link.update!(group_link_params)

        if requires_authorization_refresh?(group_link_params)
          group_link.shared_with_group.refresh_members_authorized_projects(direct_members_only: true)
        end

        group_link
      end

      private

      attr_accessor :group_link

      def requires_authorization_refresh?(params)
        params.include?(:group_access)
      end
    end
  end
end

Groups::GroupLinks::UpdateService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Groups::GroupLinks::UpdateService, '#execute', feature_category: :groups_and_projects do
  let(:user) { create(:user) }

  let_it_be(:group) { create(:group, :private) }
  let_it_be(:shared_group) { create(:group, :private) }
  let_it_be(:project) { create(:project, group: shared_group) }

  let(:group_member_user) { create(:user) }
  let!(:link) { create(:group_group_link, shared_group: shared_group, shared_with_group: group) }

  let(:expiry_date) { 1.month.from_now.to_date }
  let(:group_link_params) do
    { group_access: Gitlab::Access::GUEST,
      expires_at: expiry_date }
  end

  subject { described_class.new(link, user).execute(group_link_params) }

  before do
    group.add_developer(group_member_user)
  end

  it 'updates existing link' do
    expect(link.group_access).to eq(Gitlab::Access::DEVELOPER)
    expect(link.expires_at).to be_nil

    subject

    link.reload

    expect(link.group_access).to eq(Gitlab::Access::GUEST)
    expect(link.expires_at).to eq(expiry_date)
  end

  it 'updates project permissions', :sidekiq_inline do
    expect { subject }.to change { group_member_user.can?(:create_release, project) }.from(true).to(false)
  end

  it 'executes UserProjectAccessChangedService' do
    expect_next_instance_of(UserProjectAccessChangedService, [group_member_user.id]) do |service|
      expect(service).to receive(:execute)
    end

    subject
  end

  context 'with only param not requiring authorization refresh' do
    let(:group_link_params) { { expires_at: Date.tomorrow } }

    it 'does not execute UserProjectAccessChangedService' do
      expect(UserProjectAccessChangedService).not_to receive(:new)

      subject
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Groups
  module GroupLinks
    class CreateService < ::Groups::BaseService
      include GroupLinkable

      def initialize(group, shared_with_group, user, params)
        @shared_with_group = shared_with_group

        super(group, user, params)
      end

      private

      delegate :root_ancestor, to: :group

      def valid_to_create?
        can?(current_user, :admin_group_member, group) &&
          can?(current_user, :read_group, shared_with_group) &&
          sharing_allowed?
      end

      def build_link
        @link = GroupGroupLink.new(
          shared_group: group,
          shared_with_group: shared_with_group,
          group_access: params[:shared_group_access],
          expires_at: params[:expires_at]
        )
      end

      def setup_authorizations
        shared_with_group.refresh_members_authorized_projects(direct_members_only: true)
      end
    end
  end
end

Groups::GroupLinks::CreateService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Groups::GroupLinks::CreateService, '#execute', feature_category: :groups_and_projects do
  let_it_be(:shared_with_group_parent) { create(:group, :private) }
  let_it_be(:shared_with_group) { create(:group, :private, parent: shared_with_group_parent) }
  let_it_be(:shared_with_group_child) { create(:group, :private, parent: shared_with_group) }

  let_it_be(:group_parent) { create(:group, :private) }

  let(:group) { create(:group, :private, parent: group_parent) }

  let(:opts) do
    {
      shared_group_access: Gitlab::Access::DEVELOPER,
      expires_at: nil
    }
  end

  subject { described_class.new(group, shared_with_group, user, opts) }

  shared_examples_for 'not shareable' do
    it 'does not share and returns an error' do
      expect do
        result = subject.execute

        expect(result[:status]).to eq(:error)
        expect(result[:http_status]).to eq(404)
      end.not_to change { group.shared_with_group_links.count }
    end
  end

  shared_examples_for 'shareable' do
    it 'adds group to another group' do
      expect do
        result = subject.execute

        expect(result[:status]).to eq(:success)
      end.to change { group.shared_with_group_links.count }.from(0).to(1)
    end
  end

  context 'when user has proper membership to share a group' do
    let_it_be(:group_user) { create(:user) }

    let(:user) { group_user }

    before do
      shared_with_group.add_guest(group_user)
      group.add_owner(group_user)
    end

    it_behaves_like 'shareable'

    context 'when sharing outside the hierarchy is disabled' do
      let_it_be_with_refind(:group_parent) do
        create(:group, namespace_settings: create(:namespace_settings, prevent_sharing_groups_outside_hierarchy: true))
      end

      it_behaves_like 'not shareable'

      context 'when group is inside hierarchy' do
        let(:shared_with_group) { create(:group, :private, parent: group_parent) }

        it_behaves_like 'shareable'
      end
    end

    context 'project authorizations based on group hierarchies' do
      let_it_be(:child_group_user) { create(:user) }
      let_it_be(:parent_group_user) { create(:user) }

      before do
        shared_with_group_parent.add_owner(parent_group_user)
        shared_with_group.add_owner(group_user)
        shared_with_group_child.add_owner(child_group_user)
      end

      context 'project authorizations refresh' do
        it 'is executed only for the direct members of the group' do
          expect(UserProjectAccessChangedService).to receive(:new).with(contain_exactly(group_user.id))
                                                                  .and_call_original

          subject.execute
        end
      end

      context 'project authorizations' do
        let(:group_child) { create(:group, :private, parent: group) }
        let(:project_parent) { create(:project, group: group_parent) }
        let(:project) { create(:project, group: group) }
        let(:project_child) { create(:project, group: group_child) }

        context 'group user' do
          let(:user) { group_user }

          it 'create proper authorizations' do
            subject.execute

            expect(Ability.allowed?(user, :read_project, project_parent)).to be_falsey
            expect(Ability.allowed?(user, :read_project, project)).to be_truthy
            expect(Ability.allowed?(user, :read_project, project_child)).to be_truthy
          end
        end

        context 'parent group user' do
          let(:user) { parent_group_user }

          it 'create proper authorizations' do
            subject.execute

            expect(Ability.allowed?(user, :read_project, project_parent)).to be_falsey
            expect(Ability.allowed?(user, :read_project, project)).to be_falsey
            expect(Ability.allowed?(user, :read_project, project_child)).to be_falsey
          end
        end

        context 'child group user' do
          let(:user) { child_group_user }

          it 'create proper authorizations' do
            subject.execute

            expect(Ability.allowed?(user, :read_project, project_parent)).to be_falsey
            expect(Ability.allowed?(user, :read_project, project)).to be_falsey
            expect(Ability.allowed?(user, :read_project, project_child)).to be_falsey
          end
        end
      end
    end
  end

  context 'user does not have access to group' do
    let(:user) { create(:user) }

    before do
      group.add_owner(user)
    end

    it_behaves_like 'not shareable'
  end

  context 'user does not have admin access to shared group' do
    let(:user) { create(:user) }

    before do
      shared_with_group.add_guest(user)
      group.add_developer(user)
    end

    it_behaves_like 'not shareable'
  end

  context 'when group is blank' do
    let(:group_user) { create(:user) }
    let(:user) { group_user }
    let(:group) { nil }

    it 'does not share and returns an error' do
      expect do
        result = subject.execute

        expect(result[:status]).to eq(:error)
        expect(result[:http_status]).to eq(404)
      end.not_to change { shared_with_group.shared_group_links.count }
    end
  end

  context 'when shared_with_group is blank' do
    let(:group_user) { create(:user) }
    let(:user) { group_user }
    let(:shared_with_group) { nil }

    it_behaves_like 'not shareable'
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Groups
  module ImportExport
    class ImportService
      attr_reader :current_user, :group, :shared

      def initialize(group:, user:)
        @group = group
        @current_user = user
        @user_role = user_role
        @shared = Gitlab::ImportExport::Shared.new(@group)
        @logger = Gitlab::Import::Logger.build
      end

      def async_execute
        group_import_state = GroupImportState.safe_find_or_create_by!(group: group, user: current_user)
        jid = GroupImportWorker.with_status.perform_async(current_user.id, group.id)

        if jid.present?
          group_import_state.update!(jid: jid)
        else
          group_import_state.fail_op('Failed to schedule import job')

          false
        end
      end

      def execute
        Gitlab::Tracking.event(self.class.name, 'create', label: 'import_group_from_file')

        if valid_user_permissions? && import_file && valid_import_file? && restorers.all?(&:restore)
          notify_success

          Gitlab::Tracking.event(
            self.class.name,
            'create',
            label: 'import_access_level',
            user: current_user,
            extra: { user_role: user_role, import_type: 'import_group_from_file' }
          )

          group
        else
          notify_error!
        end

      ensure
        remove_base_tmp_dir
        remove_import_file
      end

      private

      def user_role
        # rubocop:disable CodeReuse/ActiveRecord, Style/MultilineTernaryOperator
        access_level = group.parent ?
          current_user&.group_members&.find_by(source_id: group.parent&.id)&.access_level :
          Gitlab::Access::OWNER
        Gitlab::Access.human_access(access_level)
        # rubocop:enable CodeReuse/ActiveRecord, Style/MultilineTernaryOperator
      end

      def import_file
        @import_file ||= Gitlab::ImportExport::FileImporter.import(
          importable: group,
          archive_file: nil,
          shared: shared
        )
      end

      def restorers
        [tree_restorer]
      end

      def tree_restorer
        @tree_restorer ||=
          Gitlab::ImportExport::Group::TreeRestorer.new(
            user: current_user,
            shared: shared,
            group: group
          )
      end

      def remove_import_file
        upload = group.import_export_upload

        return unless upload&.import_file&.file

        upload.remove_import_file!
        upload.save!
      end

      def valid_user_permissions?
        if current_user.can?(:admin_group, group)
          true
        else
          shared.error(::Gitlab::ImportExport::Error.permission_error(current_user, group))

          false
        end
      end

      def valid_import_file?
        return true if File.exist?(File.join(shared.export_path, 'tree/groups/_all.ndjson'))

        shared.error(::Gitlab::ImportExport::Error.incompatible_import_file_error)

        false
      end

      def notify_success
        @logger.info(
          group_id: group.id,
          group_name: group.name,
          message: 'Group Import/Export: Import succeeded'
        )
      end

      def notify_error
        @logger.error(
          group_id: group.id,
          group_name: group.name,
          message: ""Group Import/Export: Errors occurred, see '#{Gitlab::ErrorTracking::Logger.file_name}' for details""
        )
      end

      def notify_error!
        notify_error

        raise Gitlab::ImportExport::Error, shared.errors.to_sentence
      end

      def remove_base_tmp_dir
        FileUtils.rm_rf(shared.base_path)
      end
    end
  end
end

Groups::ImportExport::ImportService.prepend_mod_with('Groups::ImportExport::ImportService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Groups::ImportExport::ImportService, feature_category: :importers do
  describe '#async_execute' do
    let_it_be(:user) { create(:user) }
    let_it_be(:group) { create(:group) }

    before do
      allow(GroupImportWorker).to receive(:with_status).and_return(GroupImportWorker)
    end

    context 'when the job can be successfully scheduled' do
      subject(:import_service) { described_class.new(group: group, user: user) }

      it 'creates group import state' do
        import_service.async_execute

        import_state = group.import_state

        expect(import_state.user).to eq(user)
        expect(import_state.group).to eq(group)
      end

      it 'enqueues an import job' do
        allow(GroupImportWorker).to receive(:with_status).and_return(GroupImportWorker)

        expect(GroupImportWorker).to receive(:perform_async).with(user.id, group.id)

        import_service.async_execute
      end

      it 'marks the group import as in progress' do
        import_service.async_execute

        expect(group.import_state.in_progress?).to eq true
      end

      it 'returns truthy' do
        expect(import_service.async_execute).to be_truthy
      end
    end

    context 'when the job cannot be scheduled' do
      subject(:import_service) { described_class.new(group: group, user: user) }

      before do
        allow(GroupImportWorker).to receive(:perform_async).and_return(nil)
      end

      it 'returns falsey' do
        expect(import_service.async_execute).to be_falsey
      end

      it 'does not mark the group import as created' do
        expect { import_service.async_execute }.not_to change { group.import_state }
      end
    end
  end

  context 'when importing a ndjson export' do
    let(:user) { create(:user) }
    let(:group) { create(:group) }
    let(:import_file) { fixture_file_upload('spec/fixtures/group_export.tar.gz') }

    let(:import_logger) { instance_double(Gitlab::Import::Logger) }

    subject(:service) { described_class.new(group: group, user: user) }

    before do
      ImportExportUpload.create!(group: group, import_file: import_file)

      allow(Gitlab::Import::Logger).to receive(:build).and_return(import_logger)
      allow(import_logger).to receive(:error)
      allow(import_logger).to receive(:info)
      allow(import_logger).to receive(:warn)
      allow(FileUtils).to receive(:rm_rf).and_call_original
    end

    context 'when user has correct permissions' do
      before do
        group.add_owner(user)
      end

      it 'imports group structure successfully' do
        expect(service.execute).to be_truthy
      end

      it 'tracks the event' do
        service.execute

        expect_snowplow_event(
          category: 'Groups::ImportExport::ImportService',
          action: 'create',
          label: 'import_group_from_file'
        )

        expect_snowplow_event(
          category: 'Groups::ImportExport::ImportService',
          action: 'create',
          label: 'import_access_level',
          user: user,
          extra: { user_role: 'Owner', import_type: 'import_group_from_file' }
        )
      end

      it 'removes import file' do
        service.execute

        expect(group.import_export_upload.import_file.file).to be_nil
      end

      it 'removes tmp files' do
        shared = Gitlab::ImportExport::Shared.new(group)
        allow(Gitlab::ImportExport::Shared).to receive(:new).and_return(shared)

        service.execute

        expect(FileUtils).to have_received(:rm_rf).with(shared.base_path)
        expect(Dir.exist?(shared.base_path)).to eq(false)
      end

      it 'logs the import success' do
        expect(import_logger).to receive(:info).with(
          group_id: group.id,
          group_name: group.name,
          message: 'Group Import/Export: Import succeeded'
        ).once

        service.execute
      end
    end

    context 'when user does not have correct permissions' do
      it 'logs the error and raises an exception' do
        expect(import_logger).to receive(:error).with(
          group_id: group.id,
          group_name: group.name,
          message: a_string_including('Errors occurred')
        )

        expect { service.execute }.to raise_error(Gitlab::ImportExport::Error)
      end

      it 'tracks the error' do
        shared = Gitlab::ImportExport::Shared.new(group)
        allow(Gitlab::ImportExport::Shared).to receive(:new).and_return(shared)

        expect(shared).to receive(:error) do |param|
          expect(param.message).to include 'does not have required permissions for'
        end

        expect { service.execute }.to raise_error(Gitlab::ImportExport::Error)
      end
    end

    context 'when there are errors with the import file' do
      let(:import_file) { fixture_file_upload('spec/fixtures/symlink_export.tar.gz') }

      it 'logs the error and raises an exception' do
        expect(import_logger).to receive(:error).with(
          group_id: group.id,
          group_name: group.name,
          message: a_string_including('Errors occurred')
        ).once

        expect { service.execute }.to raise_error(Gitlab::ImportExport::Error)
      end
    end

    context 'when there are errors with the sub-relations' do
      let(:import_file) { fixture_file_upload('spec/fixtures/group_export_invalid_subrelations.tar.gz') }

      before do
        group.add_owner(user)
      end

      it 'successfully imports the group' do
        expect(service.execute).to be_truthy
      end

      it 'logs the import success' do
        allow(Gitlab::Import::Logger).to receive(:build).and_return(import_logger)

        expect(import_logger).to receive(:info).with(
          group_id: group.id,
          group_name: group.name,
          message: 'Group Import/Export: Import succeeded'
        )

        service.execute

        expect_snowplow_event(
          category: 'Groups::ImportExport::ImportService',
          action: 'create',
          label: 'import_access_level',
          user: user,
          extra: { user_role: 'Owner', import_type: 'import_group_from_file' }
        )
      end
    end
  end

  context 'when importing a json export' do
    let(:user) { create(:user) }
    let(:group) { create(:group) }
    let(:import_file) { fixture_file_upload('spec/fixtures/legacy_group_export.tar.gz') }

    let(:import_logger) { instance_double(Gitlab::Import::Logger) }

    subject(:service) { described_class.new(group: group, user: user) }

    before do
      group.add_owner(user)
      ImportExportUpload.create!(group: group, import_file: import_file)

      allow(Gitlab::Import::Logger).to receive(:build).and_return(import_logger)
      allow(import_logger).to receive(:error)
      allow(import_logger).to receive(:warn)
      allow(import_logger).to receive(:info)
    end

    it 'logs the error and raises an exception' do
      expect(import_logger).to receive(:error).with(
        group_id: group.id,
        group_name: group.name,
        message: a_string_including('Errors occurred')
      ).once

      expect { service.execute }.to raise_error(Gitlab::ImportExport::Error)
    end

    it 'tracks the error' do
      shared = Gitlab::ImportExport::Shared.new(group)
      allow(Gitlab::ImportExport::Shared).to receive(:new).and_return(shared)

      expect(shared).to receive(:error) do |param|
        expect(param.message).to include 'The import file is incompatible'
      end

      expect { service.execute }.to raise_error(Gitlab::ImportExport::Error)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Groups
  module ImportExport
    class ExportService
      def initialize(group:, user:, params: {})
        @group = group
        @current_user = user
        @params = params
        @shared = @params[:shared] || Gitlab::ImportExport::Shared.new(@group)
        @logger = Gitlab::Export::Logger.build
      end

      def async_execute
        GroupExportWorker.perform_async(current_user.id, group.id, params)
      end

      def execute
        validate_user_permissions

        remove_existing_export! if group.export_file_exists?

        save!
      ensure
        remove_archive_tmp_dir
      end

      private

      attr_reader :group, :current_user, :params
      attr_accessor :shared

      def validate_user_permissions
        unless current_user.can?(:admin_group, group)
          shared.error(::Gitlab::ImportExport::Error.permission_error(current_user, group))

          notify_error!
        end
      end

      def remove_existing_export!
        import_export_upload = group.import_export_upload

        import_export_upload.remove_export_file!
        import_export_upload.save
      end

      def save!
        # We cannot include the file_saver with the other savers because
        # it removes the tmp dir. This means that if we want to add new savers
        # in EE the data won't be available.
        if save_exporters && file_saver.save
          notify_success
        else
          notify_error!
        end
      end

      def save_exporters
        log_info('Group export started')

        savers.all? do |exporter|
          log_info(""#{exporter.class.name} saver started"")

          exporter.save
        end
      end

      def savers
        [version_saver, tree_exporter]
      end

      def tree_exporter
        Gitlab::ImportExport::Group::TreeSaver.new(
          group: group,
          current_user: current_user,
          shared: shared,
          params: params
        )
      end

      def version_saver
        Gitlab::ImportExport::VersionSaver.new(shared: shared)
      end

      def file_saver
        Gitlab::ImportExport::Saver.new(exportable: group, shared: shared)
      end

      def remove_archive_tmp_dir
        FileUtils.rm_rf(shared.archive_path) if shared&.archive_path
      end

      def notify_error!
        notify_error

        raise Gitlab::ImportExport::Error, shared.errors.to_sentence
      end

      def log_info(message)
        @logger.info(
          message: message,
          group_id: group.id,
          group_name: group.name
        )
      end

      def notify_success
        log_info('Group Export succeeded')

        notification_service.group_was_exported(group, current_user)
      end

      def notify_error
        @logger.error(
          message: 'Group Export failed',
          group_id: group.id,
          group_name: group.name,
          errors: shared.errors.join(', ')
        )

        notification_service.group_was_not_exported(group, current_user, shared.errors)
      end

      def notification_service
        @notification_service ||= NotificationService.new
      end
    end
  end
end

Groups::ImportExport::ExportService.prepend_mod_with('Groups::ImportExport::ExportService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Groups::ImportExport::ExportService, feature_category: :importers do
  describe '#async_execute' do
    let(:user) { create(:user) }
    let(:group) { create(:group) }

    context 'when the job can be successfully scheduled' do
      let(:export_service) { described_class.new(group: group, user: user) }

      it 'enqueues an export job' do
        allow(GroupExportWorker).to receive(:perform_async).with(user.id, group.id, {})

        export_service.async_execute
      end

      it 'returns truthy' do
        expect(export_service.async_execute).to be_present
      end
    end

    context 'when the job cannot be scheduled' do
      let(:export_service) { described_class.new(group: group, user: user) }

      before do
        allow(GroupExportWorker).to receive(:perform_async).and_return(nil)
      end

      it 'returns falsey' do
        expect(export_service.async_execute).to be_falsey
      end
    end
  end

  describe '#execute' do
    let!(:user) { create(:user) }
    let(:group) { create(:group) }
    let(:shared) { Gitlab::ImportExport::Shared.new(group) }
    let(:archive_path) { shared.archive_path }
    let(:service) { described_class.new(group: group, user: user, params: { shared: shared }) }

    before do
      group.add_owner(user)
    end

    after do
      FileUtils.rm_rf(archive_path)
    end

    it 'saves the version' do
      expect(Gitlab::ImportExport::VersionSaver).to receive(:new).and_call_original

      service.execute
    end

    it 'saves the models using ndjson tree saver' do
      expect(Gitlab::ImportExport::Group::TreeSaver).to receive(:new).and_call_original

      service.execute
    end

    it 'compresses and removes tmp files' do
      expect(group.import_export_upload).to be_nil
      expect(Gitlab::ImportExport::Saver).to receive(:new).and_call_original

      service.execute

      expect(Dir.exist?(shared.archive_path)).to eq false
      expect(File.exist?(group.import_export_upload.export_file.path)).to eq true
    end

    it 'notifies the user' do
      expect_next_instance_of(NotificationService) do |instance|
        expect(instance).to receive(:group_was_exported)
      end

      service.execute
    end

    context 'when saver succeeds' do
      it 'saves the group in the file system' do
        service.execute

        expect(group.import_export_upload.export_file.file).not_to be_nil
        expect(File.directory?(archive_path)).to eq(false)
        expect(File.exist?(shared.archive_path)).to eq(false)
      end
    end

    context 'when user does not have admin_group permission' do
      let!(:another_user) { create(:user) }
      let(:service) { described_class.new(group: group, user: another_user, params: { shared: shared }) }

      let(:expected_message) do
        ""User with ID: %s does not have required permissions for Group: %s with ID: %s"" %
          [another_user.id, group.name, group.id]
      end

      it 'fails' do
        expect { service.execute }.to raise_error(Gitlab::ImportExport::Error).with_message(expected_message)
      end

      it 'logs the error' do
        expect_next_instance_of(Gitlab::Export::Logger) do |logger|
          expect(logger).to receive(:error).with(
            group_id: group.id,
            group_name: group.name,
            errors: expected_message,
            message: 'Group Export failed'
          )
        end

        expect { service.execute }.to raise_error(Gitlab::ImportExport::Error)
      end

      it 'tracks the error' do
        expect(shared).to receive(:error) { |param| expect(param.message).to eq expected_message }

        expect { service.execute }.to raise_error(Gitlab::ImportExport::Error)
      end
    end

    context 'when export fails' do
      context 'when file saver fails' do
        before do
          allow_next_instance_of(Gitlab::ImportExport::Saver) do |saver|
            allow(saver).to receive(:save).and_return(false)
          end
        end

        it 'removes the remaining exported data' do
          expect { service.execute }.to raise_error(Gitlab::ImportExport::Error)

          expect(group.import_export_upload).to be_nil
          expect(Dir.exist?(shared.archive_path)).to eq(false)
        end

        it 'notifies the user about failed group export' do
          expect_next_instance_of(NotificationService) do |instance|
            expect(instance).to receive(:group_was_not_exported)
          end

          expect { service.execute }.to raise_error(Gitlab::ImportExport::Error)
        end
      end

      context 'when file compression fails' do
        before do
          allow(service).to receive_message_chain(:tree_exporter, :save).and_return(false)
        end

        it 'removes the remaining exported data' do
          allow_next_instance_of(Gitlab::ImportExport::Saver) do |saver|
            allow(saver).to receive(:compress_and_save).and_return(false)
          end

          expect { service.execute }.to raise_error(Gitlab::ImportExport::Error)

          expect(group.import_export_upload).to be_nil
          expect(Dir.exist?(shared.archive_path)).to eq(false)
        end

        it 'notifies logger' do
          allow(service).to receive_message_chain(:tree_exporter, :save).and_return(false)

          expect(service.instance_variable_get(:@logger)).to receive(:error)

          expect { service.execute }.to raise_error(Gitlab::ImportExport::Error)
        end
      end
    end

    context 'when there is an existing export file' do
      subject(:export_service) { described_class.new(group: group, user: user) }

      let(:import_export_upload) do
        create(
          :import_export_upload,
          group: group,
          export_file: fixture_file_upload('spec/fixtures/group_export.tar.gz')
        )
      end

      it 'removes it' do
        existing_file = import_export_upload.export_file

        expect { export_service.execute }.to change { existing_file.file }.to(be_nil)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Groups
  module DeployTokens
    class RevokeService < BaseService
      attr_accessor :token

      def execute
        @token = group.deploy_tokens.find(params[:id])
        @token.revoke!
      end
    end
  end
end

Groups::DeployTokens::RevokeService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Groups::DeployTokens::RevokeService, feature_category: :deployment_management do
  let_it_be(:entity) { create(:group) }
  let_it_be(:deploy_token) { create(:deploy_token, :group, groups: [entity]) }
  let_it_be(:user) { create(:user) }
  let_it_be(:deploy_token_params) { { id: deploy_token.id } }

  describe '#execute' do
    subject { described_class.new(entity, user, deploy_token_params).execute }

    it ""revokes a group deploy token"" do
      expect(deploy_token.revoked).to eq(false)

      expect { subject }.to change { deploy_token.reload.revoked }.to eq(true)
    end

    context 'invalid token id' do
      let(:deploy_token_params) { { token_id: non_existing_record_id } }

      it 'raises an error' do
        expect { subject }.to raise_error(ActiveRecord::RecordNotFound)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Groups
  module DeployTokens
    class DestroyService < BaseService
      include DeployTokenMethods

      def execute
        destroy_deploy_token(@group, params)
      end
    end
  end
end

Groups::DeployTokens::DestroyService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Groups::DeployTokens::DestroyService, feature_category: :deployment_management do
  it_behaves_like 'a deploy token deletion service' do
    let_it_be(:entity) { create(:group) }
    let_it_be(:deploy_token_class) { GroupDeployToken }
    let_it_be(:deploy_token) { create(:deploy_token, :group, groups: [entity]) }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Groups
  module DeployTokens
    class CreateService < BaseService
      include DeployTokenMethods

      def execute
        deploy_token = create_deploy_token_for(@group, current_user, params)

        create_deploy_token_payload_for(deploy_token)
      end
    end
  end
end

Groups::DeployTokens::CreateService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Groups::DeployTokens::CreateService, feature_category: :deployment_management do
  it_behaves_like 'a deploy token creation service' do
    let(:entity) { create(:group) }
    let(:deploy_token_class) { GroupDeployToken }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module PersonalAccessTokens
  class LastUsedService
    def initialize(personal_access_token)
      @personal_access_token = personal_access_token
    end

    def execute
      # Needed to avoid calling service on Oauth tokens
      return unless @personal_access_token.has_attribute?(:last_used_at)

      # We _only_ want to update last_used_at and not also updated_at (which
      # would be updated when using #touch).
      @personal_access_token.update_column(:last_used_at, Time.zone.now) if update?
    end

    private

    def update?
      return false if ::Gitlab::Database.read_only?

      last_used = @personal_access_token.last_used_at

      return true if last_used.nil?

      last_used <= 10.minutes.ago
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe PersonalAccessTokens::LastUsedService, feature_category: :system_access do
  describe '#execute' do
    subject { described_class.new(personal_access_token).execute }

    context 'when the personal access token was used 10 minutes ago', :freeze_time do
      let(:personal_access_token) { create(:personal_access_token, last_used_at: 10.minutes.ago) }

      it 'updates the last_used_at timestamp' do
        expect { subject }.to change { personal_access_token.last_used_at }
      end

      it 'does not run on read-only GitLab instances' do
        allow(::Gitlab::Database).to receive(:read_only?).and_return(true)

        expect { subject }.not_to change { personal_access_token.last_used_at }
      end
    end

    context 'when the personal access token was used less than 10 minutes ago', :freeze_time do
      let(:personal_access_token) { create(:personal_access_token, last_used_at: (10.minutes - 1.second).ago) }

      it 'does not update the last_used_at timestamp' do
        expect { subject }.not_to change { personal_access_token.last_used_at }
      end
    end

    context 'when the last_used_at timestamp is nil' do
      let_it_be(:personal_access_token) { create(:personal_access_token, last_used_at: nil) }

      it 'updates the last_used_at timestamp' do
        expect { subject }.to change { personal_access_token.last_used_at }
      end
    end

    context 'when not a personal access token' do
      let_it_be(:personal_access_token) { create(:oauth_access_token) }

      it 'does not execute' do
        expect(subject).to be_nil
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module PersonalAccessTokens
  class RotateService
    EXPIRATION_PERIOD = 1.week

    def initialize(current_user, token)
      @current_user = current_user
      @token = token
    end

    def execute(params = {})
      return error_response(message: _('token already revoked')) if token.revoked?

      response = ServiceResponse.success

      PersonalAccessToken.transaction do
        unless token.revoke!
          response = error_response
          raise ActiveRecord::Rollback
        end

        target_user = token.user
        new_token = target_user.personal_access_tokens.create(create_token_params(token, params))

        if new_token.persisted?
          response = error_response unless update_bot_membership(target_user, new_token.expires_at)
          response = success_response(new_token)
        else
          response = error_response(message: new_token.errors.full_messages.to_sentence)

          raise ActiveRecord::Rollback
        end
      end

      response
    end

    private

    attr_reader :current_user, :token

    def expires_at(params)
      return params[:expires_at] if params[:expires_at]

      params[:expires_at] || EXPIRATION_PERIOD.from_now.to_date
    end

    def success_response(new_token)
      ServiceResponse.success(payload: { personal_access_token: new_token })
    end

    def error_response(message: _('failed to revoke token'))
      ServiceResponse.error(message: message)
    end

    def create_token_params(token, params)
      {  name: token.name,
         previous_personal_access_token_id: token.id,
         impersonation: token.impersonation,
         scopes: token.scopes,
         expires_at: expires_at(params) }
    end

    def update_bot_membership(target_user, expires_at)
      return unless target_user.project_bot?

      target_user.members.first.update(expires_at: expires_at)
    end
  end
end

PersonalAccessTokens::RotateService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe PersonalAccessTokens::RotateService, feature_category: :system_access do
  describe '#execute' do
    let_it_be(:token, reload: true) { create(:personal_access_token) }

    subject(:response) { described_class.new(token.user, token).execute }

    it ""rotates user's own token"", :freeze_time do
      expect(response).to be_success

      new_token = response.payload[:personal_access_token]

      expect(new_token.token).not_to eq(token.token)
      expect(new_token.expires_at).to eq(Date.today + 1.week)
      expect(new_token.user).to eq(token.user)
    end

    it 'revokes the previous token' do
      expect { response }.to change { token.reload.revoked? }.from(false).to(true)

      new_token = response.payload[:personal_access_token]
      expect(new_token).not_to be_revoked
    end

    it 'saves the previous token as previous PAT attribute' do
      response

      new_token = response.payload[:personal_access_token]
      expect(new_token.previous_personal_access_token).to eql(token)
    end

    context 'when token user has a membership' do
      context 'when its not a bot user' do
        let_it_be(:user_membership) do
          create(:project_member, :developer, user: token.user, project: create(:project))
        end

        it 'does not update membership expires at' do
          expect { response }.not_to change { user_membership.reload.expires_at }
        end
      end

      context 'when its a bot user' do
        let_it_be(:bot_user) { create(:user, :project_bot) }
        let_it_be(:bot_user_membership) do
          create(:project_member, :developer, user: bot_user, project: create(:project))
        end

        let_it_be(:token, reload: true) { create(:personal_access_token, user: bot_user) }

        it 'updates membership expires at' do
          response

          new_token = response.payload[:personal_access_token]
          expect(bot_user_membership.reload.expires_at).to eq(new_token.expires_at)
        end
      end
    end

    context 'when user tries to rotate already revoked token' do
      let_it_be(:token, reload: true) { create(:personal_access_token, :revoked) }

      it 'returns an error' do
        expect { response }.not_to change { token.reload.revoked? }.from(true)
        expect(response).to be_error
        expect(response.message).to eq('token already revoked')
      end
    end

    context 'when revoking previous token fails' do
      it 'returns an error' do
        expect(token).to receive(:revoke!).and_return(false)

        expect(response).to be_error
      end
    end

    context 'when creating the new token fails' do
      let(:error_message) { 'boom!' }

      before do
        allow_next_instance_of(PersonalAccessToken) do |token|
          allow(token).to receive_message_chain(:errors, :full_messages, :to_sentence).and_return(error_message)
          allow(token).to receive_message_chain(:errors, :clear)
          allow(token).to receive_message_chain(:errors, :empty?).and_return(false)
        end
      end

      it 'returns an error' do
        expect(response).to be_error
        expect(response.message).to eq(error_message)
      end

      it 'reverts the changes' do
        expect { response }.not_to change { token.reload.revoked? }.from(false)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module PersonalAccessTokens
  class RevokeService < BaseService
    attr_reader :token, :current_user, :group

    VALID_SOURCES = %i[self secret_detection].freeze

    def initialize(current_user = nil, token: nil, group: nil, source: nil)
      @current_user = current_user
      @token = token
      @group = group
      @source = source

      @source = :self if @current_user && !@source

      raise ArgumentError unless VALID_SOURCES.include?(@source)
    end

    def execute
      return ServiceResponse.error(message: 'Not permitted to revoke') unless revocation_permitted?

      if token.revoke!
        log_event
        notification_service.access_token_revoked(token.user, token.name, @source)
        ServiceResponse.success(message: success_message)
      else
        ServiceResponse.error(message: error_message)
      end
    end

    private

    def error_message
      _(""Could not revoke personal access token %{personal_access_token_name}."") % { personal_access_token_name: token.name }
    end

    def success_message
      _(""Revoked personal access token %{personal_access_token_name}!"") % { personal_access_token_name: token.name }
    end

    def revocation_permitted?
      case @source
      when :self
        Ability.allowed?(current_user, :revoke_token, token)
      when :secret_detection
        true
      else
        false
      end
    end

    def log_event
      Gitlab::AppLogger.info(
        class: self.class.name,
        message: ""PAT Revoked"",
        revoked_by: current_user&.username || @source,
        revoked_for: token.user.username,
        token_id: token.id)
    end
  end
end

PersonalAccessTokens::RevokeService.prepend_mod_with('PersonalAccessTokens::RevokeService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe PersonalAccessTokens::RevokeService, feature_category: :system_access do
  shared_examples_for 'a successfully revoked token' do
    it { expect(subject.success?).to be true }
    it { expect(service.token.revoked?).to be true }

    it 'logs the event' do
      expect(Gitlab::AppLogger).to receive(:info).with(
        class: described_class.to_s,
        message: 'PAT Revoked',
        revoked_by: revoked_by,
        revoked_for: token.user.username,
        token_id: token.id)

      subject
    end
  end

  shared_examples_for 'an unsuccessfully revoked token' do
    it { expect(subject.success?).to be false }
    it { expect(service.token.revoked?).to be false }
  end

  describe '#execute' do
    subject { service.execute }

    let(:service) { described_class.new(current_user, token: token) }

    context 'when current_user is an administrator' do
      context 'when admin mode is enabled', :enable_admin_mode do
        let_it_be(:current_user) { create(:admin) }
        let_it_be(:token) { create(:personal_access_token) }

        it_behaves_like 'a successfully revoked token' do
          let(:revoked_by) { current_user.username }
        end
      end

      context 'when admin mode is disabled' do
        let_it_be(:current_user) { create(:admin) }
        let_it_be(:token) { create(:personal_access_token) }

        it_behaves_like 'an unsuccessfully revoked token'
      end
    end

    context 'when current_user is not an administrator' do
      let_it_be(:current_user) { create(:user) }

      context 'token belongs to a different user' do
        let_it_be(:token) { create(:personal_access_token) }

        it_behaves_like 'an unsuccessfully revoked token'
      end

      context 'token belongs to current_user' do
        let_it_be(:token) { create(:personal_access_token, user: current_user) }

        it_behaves_like 'a successfully revoked token' do
          let(:revoked_by) { current_user.username }
        end
      end
    end

    context 'when source' do
      let(:service) { described_class.new(nil, token: token, source: source) }

      let_it_be(:current_user) { nil }

      context 'when source is valid' do
        let_it_be(:source) { :secret_detection }
        let_it_be(:token) { create(:personal_access_token) }

        it_behaves_like 'a successfully revoked token' do
          let(:revoked_by) { :secret_detection }
        end
      end

      context 'when source is invalid' do
        let_it_be(:source) { :external_request }
        let_it_be(:token) { create(:personal_access_token) }

        it 'raises ArgumentError' do
          expect { subject }.to raise_error ArgumentError
        end
      end

      context 'when source is missing' do
        let_it_be(:source) { nil }
        let_it_be(:token) { create(:personal_access_token) }

        it 'raises ArgumentError' do
          expect { subject }.to raise_error ArgumentError
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module PersonalAccessTokens
  class RevokeTokenFamilyService
    def initialize(token)
      @token = token
    end

    def execute
      # A token family is a chain of rotated tokens. Once rotated, the previous
      # token is revoked. As a result, a single token id should be returned by
      # this query.
      # rubocop: disable CodeReuse/ActiveRecord
      token_ids = pat_family.active.pluck_primary_key

      # We create another query based on the previous if any id exists. An
      # alternative is to use a single query, like
      # `pat_family.active.update_all(...)`). However, #update_all ignores
      # the CTE, and tries to revoke *all* active tokens.
      PersonalAccessToken.where(id: token_ids).update_all(revoked: true) if token_ids.any?
      # rubocop: enable CodeReuse/ActiveRecord

      ServiceResponse.success
    end

    private

    attr_reader :token

    def pat_family
      # rubocop: disable CodeReuse/ActiveRecord
      cte = Gitlab::SQL::RecursiveCTE.new(:personal_access_tokens_cte)
      personal_access_token_table = Arel::Table.new(:personal_access_tokens)

      cte << PersonalAccessToken
               .select(
                 'personal_access_tokens.id',
                 'personal_access_tokens.revoked',
                 'personal_access_tokens.expires_at')
               .where(personal_access_token_table[:previous_personal_access_token_id].eq(token.id))
      cte << PersonalAccessToken
               .select(
                 'personal_access_tokens.id',
                 'personal_access_tokens.revoked',
                 'personal_access_tokens.expires_at')
               .from([personal_access_token_table, cte.table])
               .where(personal_access_token_table[:previous_personal_access_token_id].eq(cte.table[:id]))
      PersonalAccessToken.with.recursive(cte.to_arel).from(cte.alias_to(personal_access_token_table))
      # rubocop: enable CodeReuse/ActiveRecord
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe PersonalAccessTokens::RevokeTokenFamilyService, feature_category: :system_access do
  describe '#execute' do
    let_it_be(:token_3) { create(:personal_access_token, :revoked) }
    let_it_be(:token_2) { create(:personal_access_token, :revoked, previous_personal_access_token_id: token_3.id) }
    let_it_be(:token_1) { create(:personal_access_token, previous_personal_access_token_id: token_2.id) }

    subject(:response) { described_class.new(token_3).execute }

    it 'revokes the latest token from the chain of rotated tokens' do
      expect(response).to be_success
      expect(token_1.reload).to be_revoked
    end

    it 'does not revoke any active token not in the pat family' do
      unrelated_token = create(:personal_access_token)

      expect(response).to be_success
      expect(unrelated_token.reload).to be_active
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module PersonalAccessTokens
  class CreateService < BaseService
    def initialize(current_user:, target_user:, params: {}, concatenate_errors: true)
      @current_user = current_user
      @target_user = target_user
      @params = params.dup
      @ip_address = @params.delete(:ip_address)
      @concatenate_errors = concatenate_errors
    end

    def execute
      return ServiceResponse.error(message: 'Not permitted to create') unless creation_permitted?

      token = target_user.personal_access_tokens.create(personal_access_token_params)

      if token.persisted?
        log_event(token)
        notification_service.access_token_created(target_user, token.name)
        ServiceResponse.success(payload: { personal_access_token: token })
      else
        message = token.errors.full_messages
        message = message.to_sentence if @concatenate_errors

        ServiceResponse.error(message: message, payload: { personal_access_token: token })
      end
    end

    private

    attr_reader :target_user, :ip_address

    def personal_access_token_params
      {
        name: params[:name],
        impersonation: params[:impersonation] || false,
        scopes: params[:scopes],
        expires_at: pat_expiration
      }
    end

    def pat_expiration
      params[:expires_at].presence || PersonalAccessToken::MAX_PERSONAL_ACCESS_TOKEN_LIFETIME_IN_DAYS.days.from_now
    end

    def creation_permitted?
      Ability.allowed?(current_user, :create_user_personal_access_token, target_user)
    end

    def log_event(token)
      log_info(""PAT CREATION: created_by: '#{current_user.username}', created_for: '#{token.user.username}', token_id: '#{token.id}'"")
    end
  end
end

PersonalAccessTokens::CreateService.prepend_mod_with('PersonalAccessTokens::CreateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe PersonalAccessTokens::CreateService, feature_category: :system_access do
  shared_examples_for 'a successfully created token' do
    it 'creates personal access token record' do
      expect(subject.success?).to be true
      expect(token.name).to eq(params[:name])
      expect(token.impersonation).to eq(params[:impersonation])
      expect(token.scopes).to eq(params[:scopes])
      expect(token.expires_at).to eq(params[:expires_at])
      expect(token.user).to eq(user)
    end

    it 'logs the event' do
      expect(Gitlab::AppLogger).to receive(:info).with(/PAT CREATION: created_by: '#{current_user.username}', created_for: '#{user.username}', token_id: '\d+'/)

      subject
    end

    it 'notifies the user' do
      expect_next_instance_of(NotificationService) do |notification_service|
        expect(notification_service).to receive(:access_token_created).with(user, params[:name])
      end

      subject
    end
  end

  shared_examples_for 'an unsuccessfully created token' do
    it { expect(subject.success?).to be false }
    it { expect(subject.message).to eq('Not permitted to create') }
    it { expect(token).to be_nil }
  end

  describe '#execute' do
    subject { service.execute }

    let(:current_user) { create(:user) }
    let(:user) { create(:user) }
    let(:params) { { name: 'Test token', impersonation: false, scopes: [:api], expires_at: Date.today + 1.month } }
    let(:service) { described_class.new(current_user: current_user, target_user: user, params: params, concatenate_errors: false) }
    let(:token) { subject.payload[:personal_access_token] }

    context 'when current_user is an administrator' do
      let(:current_user) { create(:admin) }

      context 'when admin mode is enabled', :enable_admin_mode do
        it_behaves_like 'a successfully created token'
      end

      context 'when admin mode is disabled' do
        it_behaves_like 'an unsuccessfully created token'
      end
    end

    context 'when current_user is not an administrator' do
      context 'target_user is not the same as current_user' do
        it_behaves_like 'an unsuccessfully created token'
      end

      context 'target_user is same as current_user' do
        let(:current_user) { user }

        it_behaves_like 'a successfully created token'
      end
    end

    context 'with no expires_at set', :freeze_time do
      let(:params) { { name: 'Test token', impersonation: false, scopes: [:no_valid] } }
      let(:service) { described_class.new(current_user: user, target_user: user, params: params) }

      it { expect(subject.payload[:personal_access_token].expires_at).to eq PersonalAccessToken::MAX_PERSONAL_ACCESS_TOKEN_LIFETIME_IN_DAYS.days.from_now.to_date }
    end

    context 'when invalid scope' do
      let(:params) { { name: 'Test token', impersonation: false, scopes: [:no_valid], expires_at: Date.today + 1.month } }

      context 'when concatenate_errors: true' do
        let(:service) { described_class.new(current_user: user, target_user: user, params: params) }

        it { expect(subject.message).to be_an_instance_of(String) }
      end

      context 'when concatenate_errors: false' do
        let(:service) { described_class.new(current_user: user, target_user: user, params: params, concatenate_errors: false) }

        it { expect(subject.message).to be_an_instance_of(Array) }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ExportCsv
  class MapExportFieldsService < BaseService
    attr_reader :fields, :data

    def initialize(fields, data)
      @fields = fields
      @data = data
    end

    def execute
      return data if fields.empty?

      selected_fields_to_hash
    end

    def invalid_fields
      fields.reject { |field| permitted_field?(field) }
    end

    private

    def selected_fields_to_hash
      data.select { |key| requested_field?(key) }
    end

    def requested_field?(field)
      field.downcase.in?(fields.map(&:downcase))
    end

    def permitted_field?(field)
      field.downcase.in?(keys.map(&:downcase))
    end

    def keys
      data.keys
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ExportCsv::MapExportFieldsService, feature_category: :team_planning do
  let(:selected_fields) { ['Title', 'Author username', 'state'] }
  let(:invalid_fields) { ['Title', 'Author Username', 'State', 'Invalid Field', 'Other Field'] }
  let(:data) do
    {
      'Requirement ID' => '1',
      'Title' => 'foo',
      'Description' => 'bar',
      'Author' => 'root',
      'Author Username' => 'admin',
      'Created At (UTC)' => '2023-02-01 15:16:35',
      'State' => 'opened',
      'State Updated At (UTC)' => '2023-02-01 15:16:35'
    }
  end

  describe '#execute' do
    it 'returns a hash with selected fields only' do
      result = described_class.new(selected_fields, data).execute

      expect(result).to be_a(Hash)
      expect(result.keys).to match_array(selected_fields.map(&:titleize))
    end

    context 'when the fields collection is empty' do
      it 'returns a hash with all fields' do
        result = described_class.new([], data).execute

        expect(result).to be_a(Hash)
        expect(result.keys).to match_array(data.keys)
      end
    end

    context 'when fields collection includes invalid fields' do
      it 'returns a hash with valid selected fields only' do
        result = described_class.new(invalid_fields, data).execute

        expect(result).to be_a(Hash)
        expect(result.keys).to eq(selected_fields.map(&:titleize))
      end
    end
  end

  describe '#invalid_fields' do
    it 'returns an array containing invalid fields' do
      result = described_class.new(invalid_fields, data).invalid_fields

      expect(result).to match_array(['Invalid Field', 'Other Field'])
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ExportCsv
  class BaseService
    # Target attachment size before base64 encoding
    TARGET_FILESIZE = 15.megabytes

    def initialize(relation, resource_parent, fields = [])
      @objects = relation
      @resource_parent = resource_parent
      @fields = fields
    end

    def csv_data
      csv_builder.render(TARGET_FILESIZE)
    end

    def email(user)
      raise NotImplementedError
    end

    def invalid_fields
      ::ExportCsv::MapExportFieldsService.new(fields, header_to_value_hash).invalid_fields
    end

    private

    attr_reader :resource_parent, :objects, :fields

    # rubocop: disable CodeReuse/ActiveRecord
    def csv_builder
      @csv_builder ||= begin
        data_hash = MapExportFieldsService.new(fields, header_to_value_hash).execute

        if preload_associations_in_batches?
          CsvBuilder.new(objects, data_hash, associations_to_preload)
        else
          CsvBuilder.new(objects.preload(associations_to_preload), data_hash, [])
        end
      end
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def associations_to_preload
      []
    end

    def header_to_value_hash
      raise NotImplementedError
    end

    def preload_associations_in_batches?
      false
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ExportCsv::BaseService, feature_category: :importers do
  let_it_be(:issue) { create(:issue) }
  let_it_be(:relation) { Issue.all }
  let_it_be(:resource_parent) { issue.project }

  subject { described_class.new(relation, resource_parent) }

  describe '#email' do
    it 'raises NotImplementedError' do
      user = create(:user)

      expect { subject.email(user) }.to raise_error(NotImplementedError)
    end
  end

  describe '#header_to_value_hash' do
    it 'raises NotImplementedError' do
      expect { subject.send(:header_to_value_hash) }.to raise_error(NotImplementedError)
    end
  end

  describe '#associations_to_preload' do
    it 'return []' do
      expect(subject.send(:associations_to_preload)).to eq([])
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class PushedBranchesService < MergeRequests::BaseService
    include ::Gitlab::Utils::StrongMemoize

    # Skip moving this logic into models since it's too specific
    # rubocop: disable CodeReuse/ActiveRecord
    def execute
      return [] if branch_names.blank?

      source_branches = project.source_of_merge_requests.open_and_closed
        .from_source_branches(branch_names).pluck(:source_branch)

      target_branches = project.merge_requests.opened
        .by_target_branch(branch_names).distinct.pluck(:target_branch)

      source_branches.concat(target_branches).to_set
    end
    # rubocop: enable CodeReuse/ActiveRecord

    private

    def branch_names
      strong_memoize(:branch_names) do
        params[:changes].map do |change|
          Gitlab::Git.branch_name(change[:ref])
        end.compact
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::PushedBranchesService, feature_category: :source_code_management do
  let(:project) { create(:project) }
  let!(:service) { described_class.new(project: project, current_user: nil, params: { changes: pushed_branches }) }

  context 'when branches pushed' do
    let(:pushed_branches) do
      %w[branch1 branch2 closed-branch1 closed-branch2 extra1 extra2].map do |branch|
        { ref: ""refs/heads/#{branch}"" }
      end
    end

    it 'returns only branches which have a open and closed merge request' do
      create(:merge_request, source_branch: 'branch1', source_project: project)
      create(:merge_request, source_branch: 'branch2', source_project: project)
      create(:merge_request, target_branch: 'branch2', source_project: project)
      create(:merge_request, :closed, target_branch: 'closed-branch1', source_project: project)
      create(:merge_request, :closed, source_branch: 'closed-branch2', source_project: project)
      create(:merge_request, source_branch: 'extra1')

      expect(service.execute).to contain_exactly(
        'branch1',
        'branch2',
        'closed-branch2'
      )
    end
  end

  context 'when tags pushed' do
    let(:pushed_branches) do
      %w[v10.0.0 v11.0.2 v12.1.0].map do |branch|
        { ref: ""refs/tags/#{branch}"" }
      end
    end

    it 'returns empty result without any SQL query performed' do
      control_count = ActiveRecord::QueryRecorder.new do
        expect(service.execute).to be_empty
      end.count

      expect(control_count).to be_zero
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class RebaseService < MergeRequests::BaseService
    REBASE_ERROR = 'Rebase failed: Rebase locally, resolve all conflicts, then push the branch.'

    attr_reader :merge_request, :rebase_error

    def validate(merge_request)
      return error_response(_('Source branch does not exist')) unless
        merge_request.source_branch_exists?

      return error_response(_('Cannot push to source branch')) unless
          user_access.can_push_to_branch?(merge_request.source_branch)

      return error_response(_('Source branch is protected from force push')) unless
          merge_request.permits_force_push?

      ServiceResponse.success
    end

    def execute(merge_request, skip_ci: false)
      @merge_request = merge_request
      @skip_ci = skip_ci

      if rebase
        success
      else
        error(rebase_error)
      end
    end

    def rebase
      repository.rebase(current_user, merge_request, skip_ci: @skip_ci)

      true
    rescue StandardError => e
      set_rebase_error(e)
      log_error(exception: e, message: rebase_error, save_message_on_model: true)

      false
    ensure
      merge_request.update_column(:rebase_jid, nil)
    end

    private

    def set_rebase_error(exception)
      @rebase_error =
        if exception.is_a?(Gitlab::Git::PreReceiveError)
          ""The rebase pre-receive hook failed: #{exception.message}.""
        else
          REBASE_ERROR
        end
    end

    def user_access
      Gitlab::UserAccess.new(current_user, container: project)
    end

    def error_response(message)
      ServiceResponse.error(message: message)
    end
  end
end

::MergeRequests::RebaseService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::RebaseService, feature_category: :source_code_management do
  include ProjectForksHelper

  let(:user) { create(:user) }
  let(:rebase_jid) { 'fake-rebase-jid' }
  let(:merge_request) do
    create(
      :merge_request,
      source_branch: 'feature_conflict',
      target_branch: 'master',
      rebase_jid: rebase_jid
    )
  end

  let(:project) { merge_request.project }
  let(:repository) { project.repository.raw }
  let(:skip_ci) { false }

  subject(:service) { described_class.new(project: project, current_user: user) }

  before do
    project.add_maintainer(user)
  end

  describe '#validate' do
    subject { service.validate(merge_request) }

    it { is_expected.to be_success }

    context 'when source branch does not exist' do
      before do
        merge_request.update!(source_branch: 'does_not_exist')
      end

      it 'returns an error' do
        is_expected.to be_error
        expect(subject.message).to eq('Source branch does not exist')
      end
    end

    context 'when user has no permissions to rebase' do
      before do
        project.add_guest(user)
      end

      it 'returns an error' do
        is_expected.to be_error
        expect(subject.message).to eq('Cannot push to source branch')
      end
    end

    context 'when branch is protected' do
      before do
        create(:protected_branch, project: project, name: merge_request.source_branch, allow_force_push: false)
      end

      it 'returns an error' do
        is_expected.to be_error
        expect(subject.message).to eq('Source branch is protected from force push')
      end
    end
  end

  describe '#execute' do
    shared_examples 'sequence of failure and success' do
      it 'properly clears the error message' do
        allow(repository).to receive(:gitaly_operation_client).and_raise('Something went wrong')

        service.execute(merge_request)
        merge_request.reload

        expect(merge_request.reload.merge_error).to eq(described_class::REBASE_ERROR)
        expect(merge_request.rebase_jid).to eq(nil)

        allow(repository).to receive(:gitaly_operation_client).and_call_original
        merge_request.update!(rebase_jid: rebase_jid)

        service.execute(merge_request)
        merge_request.reload

        expect(merge_request.merge_error).to eq(nil)
        expect(merge_request.rebase_jid).to eq(nil)
      end
    end

    it_behaves_like 'sequence of failure and success'

    context 'when unexpected error occurs' do
      let(:exception) { RuntimeError.new('Something went wrong') }
      let(:merge_request_ref) { merge_request.to_reference(full: true) }

      before do
        allow(repository).to receive(:gitaly_operation_client).and_raise(exception)
      end

      it 'saves a generic error message' do
        service.execute(merge_request)

        expect(merge_request.reload.merge_error).to eq(described_class::REBASE_ERROR)
      end

      it 'returns an error' do
        expect(service.execute(merge_request)).to match(
          status: :error, message: described_class::REBASE_ERROR
        )
      end

      it 'logs the error' do
        expect(service).to receive(:log_error).with(exception: exception, message: described_class::REBASE_ERROR, save_message_on_model: true).and_call_original
        expect(Gitlab::ErrorTracking).to receive(:track_exception).with(exception,
          {
            class: described_class.to_s,
            merge_request: merge_request_ref,
            merge_request_id: merge_request.id,
            message: described_class::REBASE_ERROR,
            save_message_on_model: true
          }).and_call_original

        service.execute(merge_request)
      end
    end

    context 'with a pre-receive failure' do
      let(:pre_receive_error) { ""Commit message does not follow the pattern 'ACME'"" }
      let(:merge_error) { ""The rebase pre-receive hook failed: #{pre_receive_error}."" }

      before do
        allow(repository).to receive(:gitaly_operation_client).and_raise(Gitlab::Git::PreReceiveError, ""GitLab: #{pre_receive_error}"")
      end

      it 'saves a specific message' do
        subject.execute(merge_request)

        expect(merge_request.reload.merge_error).to eq merge_error
      end

      it 'returns an error' do
        expect(service.execute(merge_request)).to match(
          status: :error,
          message: merge_error)
      end
    end

    context 'with git command failure' do
      before do
        allow(repository).to receive(:gitaly_operation_client).and_raise(Gitlab::Git::Repository::GitError, 'Something went wrong')
      end

      it 'saves a generic error message' do
        subject.execute(merge_request)

        expect(merge_request.reload.merge_error).to eq described_class::REBASE_ERROR
      end

      it 'returns an error' do
        expect(service.execute(merge_request)).to match(
          status: :error, message: described_class::REBASE_ERROR
        )
      end
    end

    context 'valid params' do
      shared_examples_for 'a service that can execute a successful rebase' do
        before do
          service.execute(merge_request, skip_ci: skip_ci)
        end

        it 'rebases source branch' do
          parent_sha = merge_request.source_project.repository.commit(merge_request.source_branch).parents.first.sha
          target_branch_sha = merge_request.target_project.repository.commit(merge_request.target_branch).sha
          expect(parent_sha).to eq(target_branch_sha)
        end

        it 'records the new SHA on the merge request' do
          head_sha = merge_request.source_project.repository.commit(merge_request.source_branch).sha
          expect(merge_request.reload.rebase_commit_sha).to eq(head_sha)
        end

        it 'logs correct author and committer' do
          head_commit = merge_request.source_project.repository.commit(merge_request.source_branch)

          expect(head_commit.author_email).to eq('dmitriy.zaporozhets@gmail.com')
          expect(head_commit.author_name).to eq('Dmitriy Zaporozhets')
          expect(head_commit.committer_email).to eq(user.email)
          expect(head_commit.committer_name).to eq(user.name)
        end
      end

      it_behaves_like 'a service that can execute a successful rebase'

      it 'clears rebase_jid' do
        expect { service.execute(merge_request) }
          .to change(merge_request, :rebase_jid)
          .from(rebase_jid)
          .to(nil)
      end

      context 'when skip_ci flag is set' do
        let(:skip_ci) { true }

        it_behaves_like 'a service that can execute a successful rebase'
      end

      context 'fork' do
        describe 'successful fork rebase' do
          let(:forked_project) do
            fork_project(project, user, repository: true)
          end

          let(:merge_request_from_fork) do
            forked_project.repository.create_file(
              user,
              'new-file-to-target',
              '',
              message: 'Add new file to target',
              branch_name: 'master')

            create(
              :merge_request,
              source_branch: 'master', source_project: forked_project,
              target_branch: 'master', target_project: project
            )
          end

          it 'rebases source branch', :sidekiq_might_not_need_inline do
            parent_sha = forked_project.repository.commit(merge_request_from_fork.source_branch).parents.first.sha
            target_branch_sha = project.repository.commit(merge_request_from_fork.target_branch).sha
            expect(parent_sha).to eq(target_branch_sha)
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class ExportCsvService < ExportCsv::BaseService
    include Gitlab::Routing.url_helpers
    include GitlabRoutingHelper

    def email(user)
      Notify.merge_requests_csv_email(user, resource_parent, csv_data, csv_builder.status).deliver_now
    end

    private

    def header_to_value_hash
      {
        'Title' => 'title',
        'Description' => 'description',
        'MR IID' => 'iid',
        'URL' => -> (merge_request) { merge_request_url(merge_request) },
        'State' => 'state',
        'Source Branch' => 'source_branch',
        'Target Branch' => 'target_branch',
        'Source Project ID' => 'source_project_id',
        'Target Project ID' => 'target_project_id',
        'Author' => -> (merge_request) { merge_request.author.name },
        'Author Username' => -> (merge_request) { merge_request.author.username },
        'Assignees' => -> (merge_request) { merge_request.assignees.map(&:name).join(', ') },
        'Assignee Usernames' => -> (merge_request) { merge_request.assignees.map(&:username).join(', ') },
        'Approvers' => -> (merge_request) { merge_request.approved_by_users.map(&:name).join(', ') },
        'Approver Usernames' => -> (merge_request) { merge_request.approved_by_users.map(&:username).join(', ') },
        'Merged User' => -> (merge_request) { merge_request.metrics&.merged_by&.name.to_s },
        'Merged Username' => -> (merge_request) { merge_request.metrics&.merged_by&.username.to_s },
        'Milestone ID' => -> (merge_request) { merge_request&.milestone&.id || '' },
        'Created At (UTC)' => -> (merge_request) { merge_request.created_at.utc },
        'Updated At (UTC)' => -> (merge_request) { merge_request.updated_at.utc }
      }
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::ExportCsvService, feature_category: :importers do
  let_it_be(:merge_request) { create(:merge_request) }

  let(:csv) { CSV.parse(subject.csv_data, headers: true).first }

  subject { described_class.new(MergeRequest.where(id: merge_request.id), merge_request.project) }

  describe 'csv_data' do
    it 'contains the correct information', :aggregate_failures do
      expect(csv['MR IID']).to eq(merge_request.iid.to_s)
      expect(csv['Title']).to eq(merge_request.title)
      expect(csv['State']).to eq(merge_request.state)
      expect(csv['Description']).to eq(merge_request.description)
      expect(csv['Source Branch']).to eq(merge_request.source_branch)
      expect(csv['Target Branch']).to eq(merge_request.target_branch)
      expect(csv['Source Project ID']).to eq(merge_request.source_project_id.to_s)
      expect(csv['Target Project ID']).to eq(merge_request.target_project_id.to_s)
      expect(csv['Author']).to eq(merge_request.author.name)
      expect(csv['Author Username']).to eq(merge_request.author.username)
    end

    describe 'assignees' do
      context 'when assigned' do
        let_it_be(:merge_request) { create(:merge_request, assignees: create_list(:user, 2)) }

        it 'contains the names of assignees' do
          expect(csv['Assignees'].split(', ')).to match_array(merge_request.assignees.map(&:name))
        end

        it 'contains the usernames of assignees' do
          expect(csv['Assignee Usernames'].split(', ')).to match_array(merge_request.assignees.map(&:username))
        end
      end

      context 'when not assigned' do
        it 'returns empty strings' do
          expect(csv['Assignees']).to eq('')
          expect(csv['Assignee Usernames']).to eq('')
        end
      end
    end

    describe 'approvers' do
      context 'when approved' do
        let_it_be(:merge_request) { create(:merge_request) }

        let(:approvers) { create_list(:user, 2) }

        before do
          merge_request.approved_by_users = approvers
        end

        it 'contains the names of approvers separated by a comma' do
          expect(csv['Approvers'].split(', ')).to contain_exactly(approvers[0].name, approvers[1].name)
        end

        it 'contains the usernames of approvers separated by a comma' do
          expect(csv['Approver Usernames'].split(', ')).to contain_exactly(approvers[0].username, approvers[1].username)
        end
      end

      context 'when not approved' do
        it 'returns empty strings' do
          expect(csv['Approvers']).to eq('')
          expect(csv['Approver Usernames']).to eq('')
        end
      end
    end

    describe 'merged user' do
      context 'MR is merged' do
        let_it_be(:merge_request) { create(:merge_request, :merged, :with_merged_metrics) }

        it 'is merged' do
          expect(csv['State']).to eq('merged')
        end

        it 'has a merged user' do
          expect(csv['Merged User']).to eq(merge_request.metrics.merged_by.name)
          expect(csv['Merged Username']).to eq(merge_request.metrics.merged_by.username)
        end
      end

      context 'MR is not merged' do
        it 'returns empty strings' do
          expect(csv['Merged User']).to eq('')
          expect(csv['Merged Username']).to eq('')
        end
      end
    end

    describe 'milestone' do
      context 'milestone is assigned' do
        let_it_be(:merge_request) { create(:merge_request) }
        let_it_be(:milestone) { create(:milestone, :active, project: merge_request.project) }

        before do
          merge_request.update!(milestone_id: milestone.id)
        end

        it 'contains the milestone ID' do
          expect(csv['Milestone ID']).to eq(merge_request.milestone.id.to_s)
        end
      end

      context 'no milestone is assigned' do
        it 'returns an empty string' do
          expect(csv['Milestone ID']).to eq('')
        end
      end
    end

    describe '#email' do
      let_it_be(:user) { create(:user) }

      it 'emails csv' do
        expect { subject.email(user) }.to change { ActionMailer::Base.deliveries.count }
      end

      it 'renders with a target filesize' do
        expect_next_instance_of(CsvBuilder) do |csv_builder|
          expect(csv_builder).to receive(:render).with(described_class::TARGET_FILESIZE).once
        end

        subject.email(user)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class LinkLfsObjectsService < ::BaseProjectService
    def execute(merge_request, oldrev: merge_request.diff_base_sha, newrev: merge_request.diff_head_sha)
      return if merge_request.source_project == project
      return if no_changes?(oldrev, newrev)

      new_lfs_oids = lfs_oids(merge_request.source_project.repository, oldrev, newrev)

      return if new_lfs_oids.empty?

      Projects::LfsPointers::LfsLinkService
        .new(project)
        .execute(new_lfs_oids)
    end

    private

    def no_changes?(oldrev, newrev)
      oldrev == newrev
    end

    def lfs_oids(source_repository, oldrev, newrev)
      Gitlab::Git::LfsChanges
        .new(source_repository, newrev)
        .new_pointers(not_in: [oldrev])
        .map(&:lfs_oid)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::LinkLfsObjectsService, :sidekiq_inline, feature_category: :code_review_workflow do
  include ProjectForksHelper
  include RepoHelpers

  let(:target_project) { create(:project, :public, :repository) }

  let(:merge_request) do
    create(
      :merge_request,
      target_project: target_project,
      target_branch: 'lfs',
      source_project: source_project,
      source_branch: 'link-lfs-objects'
    )
  end

  subject { described_class.new(project: target_project) }

  shared_examples_for 'linking LFS objects' do
    context 'when source project is the same as target project' do
      let(:source_project) { target_project }

      it 'does not call Projects::LfsPointers::LfsLinkService#execute' do
        expect(Projects::LfsPointers::LfsLinkService).not_to receive(:new)

        execute
      end
    end

    context 'when source project is different from target project' do
      let(:user) { create(:user) }
      let(:source_project) { fork_project(target_project, user, namespace: user.namespace, repository: true) }

      before do
        create_branch(source_project, 'link-lfs-objects', 'lfs')
      end

      context 'and there are changes' do
        before do
          allow(source_project).to receive(:lfs_enabled?).and_return(true)
        end

        context 'and there are LFS objects added' do
          before do
            create_file_in_repo(source_project, 'link-lfs-objects', 'link-lfs-objects', 'one.lfs', 'One')
            create_file_in_repo(source_project, 'link-lfs-objects', 'link-lfs-objects', 'two.lfs', 'Two')
          end

          it 'calls Projects::LfsPointers::LfsLinkService#execute with OIDs of LFS objects in merge request' do
            expect_next_instance_of(Projects::LfsPointers::LfsLinkService) do |service|
              expect(service).to receive(:execute).with(
                %w[
                  8b12507783d5becacbf2ebe5b01a60024d8728a8f86dcc818bce699e8b3320bc
                  94a72c074cfe574742c9e99e863322f73feff82981d065ff65a0308f44f19f62
                ])
            end

            execute
          end
        end

        context 'but there are no LFS objects added' do
          before do
            create_file_in_repo(source_project, 'link-lfs-objects', 'link-lfs-objects', 'one.txt', 'One')
          end

          it 'does not call Projects::LfsPointers::LfsLinkService#execute' do
            expect(Projects::LfsPointers::LfsLinkService).not_to receive(:new)

            execute
          end
        end
      end

      context 'and there are no changes' do
        it 'does not call Projects::LfsPointers::LfsLinkService#execute' do
          expect(Projects::LfsPointers::LfsLinkService).not_to receive(:new)

          execute
        end
      end
    end
  end

  context 'when no oldrev and newrev passed' do
    let(:execute) { subject.execute(merge_request) }

    it_behaves_like 'linking LFS objects'
  end

  context 'when oldrev and newrev are passed' do
    let(:execute) { subject.execute(merge_request, oldrev: merge_request.diff_base_sha, newrev: merge_request.diff_head_sha) }

    it_behaves_like 'linking LFS objects'
  end

  def create_branch(project, new_name, branch_name)
    ::Branches::CreateService.new(project, user).execute(new_name, branch_name)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class MergeabilityCheckService < ::BaseService
    include Gitlab::Utils::StrongMemoize
    include Gitlab::ExclusiveLeaseHelpers

    delegate :project, to: :@merge_request
    delegate :repository, to: :project

    def initialize(merge_request)
      @merge_request = merge_request
    end

    def async_execute
      return service_error if service_error

      merge_request.mark_as_checking
      MergeRequestMergeabilityCheckWorker.perform_async(merge_request.id)
    end

    # Updates the MR merge_status. Whenever it switches to a can_be_merged state,
    # the merge-ref is refreshed.
    #
    # recheck - When given, it'll enforce a merge-ref refresh if the current merge_status is
    # can_be_merged or cannot_be_merged and merge-ref is outdated.
    # Given MergeRequests::RefreshService is called async, it might happen that the target
    # branch gets updated, but the MergeRequest#merge_status lags behind. So in scenarios
    # where we need the current state of the merge ref in repository, the `recheck`
    # argument is required.
    #
    # retry_lease - Concurrent calls wait for at least 10 seconds until the
    # lease is granted (other process finishes running). Returns an error
    # ServiceResponse if the lease is not granted during this time.
    #
    # Returns a ServiceResponse indicating merge_status is/became can_be_merged
    # and the merge-ref is synced. Success in case of being/becoming mergeable,
    # error otherwise.
    def execute(recheck: false, retry_lease: true)
      return service_error if service_error

      in_write_lock(retry_lease: retry_lease) do |retried|
        # When multiple calls are waiting for the same lock (retry_lease),
        # it's possible that when granted, the MR status was already updated for
        # that object, therefore we reset if there was a lease retry.
        merge_request.reset if retried

        check_mergeability(recheck)
      end
    rescue FailedToObtainLockError => error
      ServiceResponse.error(message: error.message)
    end

    private

    attr_reader :merge_request

    def check_mergeability(recheck)
      recheck! if recheck
      update_merge_status

      unless merge_request.can_be_merged?
        return ServiceResponse.error(message: 'Merge request is not mergeable')
      end

      unless payload.fetch(:merge_ref_head)
        return ServiceResponse.error(message: 'Merge ref cannot be updated')
      end

      ServiceResponse.success(payload: payload)
    end

    # It's possible for this service to send concurrent requests to Gitaly in order
    # to ""git update-ref"" the same ref. Therefore we handle a light exclusive
    # lease here.
    #
    def in_write_lock(retry_lease:, &block)
      lease_key = ""mergeability_check:#{merge_request.id}""

      lease_opts = {
        ttl: 1.minute,
        retries: retry_lease ? 10 : 0,
        sleep_sec: retry_lease ? 1.second : 0
      }

      in_lock(lease_key, **lease_opts, &block)
    end

    def payload
      strong_memoize(:payload) do
        {
          merge_ref_head: merge_ref_head_payload
        }
      end
    end

    def merge_ref_head_payload
      commit = merge_request.merge_ref_head

      return unless commit

      target_id, source_id = commit.parent_ids

      {
        commit_id: commit.id,
        source_id: source_id,
        target_id: target_id
      }
    end

    def update_merge_status
      return unless merge_request.recheck_merge_status?
      return merge_request.mark_as_unmergeable if merge_request.broken?

      merge_to_ref_success = merge_to_ref

      reload_merge_head_diff
      update_diff_discussion_positions! if merge_to_ref_success

      if merge_to_ref_success && can_git_merge?
        merge_request.mark_as_mergeable
      else
        merge_request.mark_as_unmergeable
      end
    end

    def reload_merge_head_diff
      MergeRequests::ReloadMergeHeadDiffService.new(merge_request).execute
    end

    def update_diff_discussion_positions!
      Discussions::CaptureDiffNotePositionsService.new(merge_request).execute
    end

    def recheck!
      if !merge_request.recheck_merge_status? && outdated_merge_ref?
        merge_request.mark_as_unchecked
      end
    end

    # Checks if the existing merge-ref is synced with the target branch.
    #
    # Returns true if the merge-ref does not exists or is out of sync.
    def outdated_merge_ref?
      return false unless merge_request.open?

      return true unless ref_head = merge_request.merge_ref_head
      return true unless target_sha = merge_request.target_branch_sha
      return true unless source_sha = merge_request.source_branch_sha

      ref_head.parent_ids != [target_sha, source_sha]
    end

    def can_git_merge?
      repository.can_be_merged?(merge_request.diff_head_sha, merge_request.target_branch)
    end

    def merge_to_ref
      result = MergeRequests::MergeToRefService.new(project: project, current_user: merge_request.author, params: {}).execute(merge_request)

      result[:status] == :success
    end

    def service_error
      strong_memoize(:service_error) do
        if !merge_request
          ServiceResponse.error(message: 'Invalid argument')
        elsif Gitlab::Database.read_only?
          ServiceResponse.error(message: 'Unsupported operation')
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::MergeabilityCheckService, :clean_gitlab_redis_shared_state, feature_category: :code_review_workflow do
  shared_examples_for 'unmergeable merge request' do
    it 'updates or keeps merge status as cannot_be_merged' do
      subject

      expect(merge_request.merge_status).to eq('cannot_be_merged')
    end

    it 'does not change the merge ref HEAD' do
      merge_ref_head = merge_request.merge_ref_head

      subject

      expect(merge_request.reload.merge_ref_head).to eq merge_ref_head
    end

    it 'returns ServiceResponse.error' do
      result = subject

      expect(result).to be_a(ServiceResponse)
      expect(result).to be_error
    end
  end

  shared_examples_for 'mergeable merge request' do
    it 'updates or keeps merge status as can_be_merged' do
      subject

      expect(merge_request.merge_status).to eq('can_be_merged')
    end

    it 'reloads merge head diff' do
      expect_next_instance_of(MergeRequests::ReloadMergeHeadDiffService) do |service|
        expect(service).to receive(:execute)
      end

      subject
    end

    it 'update diff discussion positions' do
      expect_next_instance_of(Discussions::CaptureDiffNotePositionsService) do |service|
        expect(service).to receive(:execute)
      end

      subject
    end

    it 'updates the merge ref' do
      expect { subject }.to change(merge_request, :merge_ref_head).from(nil)
    end

    it 'returns ServiceResponse.success' do
      result = subject

      expect(result).to be_a(ServiceResponse)
      expect(result).to be_success
    end

    it 'ServiceResponse has merge_ref_head payload' do
      result = subject

      expect(result.payload.keys).to contain_exactly(:merge_ref_head)
      expect(result.payload[:merge_ref_head].keys)
        .to contain_exactly(:commit_id, :target_id, :source_id)
    end
  end

  let(:project) { create(:project, :repository) }
  let(:merge_request) { create(:merge_request, merge_status: :unchecked, source_project: project, target_project: project) }

  describe '#async_execute' do
    it 'updates merge status to checking' do
      described_class.new(merge_request).async_execute

      expect(merge_request).to be_checking
    end

    it 'enqueues MergeRequestMergeabilityCheckWorker' do
      expect(MergeRequestMergeabilityCheckWorker).to receive(:perform_async)

      described_class.new(merge_request).async_execute
    end

    context 'when read-only DB' do
      before do
        allow(Gitlab::Database).to receive(:read_only?) { true }
      end

      it 'does not enqueue MergeRequestMergeabilityCheckWorker' do
        expect(MergeRequestMergeabilityCheckWorker).not_to receive(:perform_async)

        described_class.new(merge_request).async_execute
      end
    end
  end

  describe '#execute' do
    let(:repo) { project.repository }

    subject { described_class.new(merge_request).execute }

    def execute_within_threads(amount:, retry_lease: true)
      threads = []

      amount.times do
        # Let's use a different object for each thread to get closer
        # to a real world scenario.
        mr = MergeRequest.find(merge_request.id)

        threads << Thread.new do
          described_class.new(mr).execute(retry_lease: retry_lease)
        end
      end

      threads.each(&:join)
      threads
    end

    before do
      project.add_developer(merge_request.author)
    end

    it_behaves_like 'mergeable merge request'

    context 'when concurrent calls' do
      it 'waits first lock and returns ""cached"" result in subsequent calls' do
        threads = execute_within_threads(amount: 3)
        results = threads.map { |t| t.value.status }

        expect(results).to contain_exactly(:success, :success, :success)
      end

      it 'writes the merge-ref once' do
        service = instance_double(MergeRequests::MergeToRefService)

        expect(MergeRequests::MergeToRefService).to receive(:new).once { service }
        expect(service).to receive(:execute).once.and_return(success: true)

        execute_within_threads(amount: 3)
      end

      it 'resets one merge request upon execution' do
        expect_next_instance_of(MergeRequests::ReloadMergeHeadDiffService) do |svc|
          expect(svc).to receive(:execute).and_return(status: :success)
        end

        expect_any_instance_of(MergeRequest).to receive(:reset).once.and_call_original

        execute_within_threads(amount: 2)
      end

      context 'when retry_lease flag is false' do
        it 'the first call succeeds, subsequent concurrent calls get a lock error response' do
          threads = execute_within_threads(amount: 3, retry_lease: false)
          results = threads.map { |t| [t.value.status, t.value.message] }

          expect(results).to contain_exactly(
            [:error, 'Failed to obtain a lock'],
            [:error, 'Failed to obtain a lock'],
            [:success, nil]
          )
        end
      end
    end

    context 'when broken' do
      before do
        expect(merge_request).to receive(:broken?) { true }
      end

      it_behaves_like 'unmergeable merge request'

      it 'returns ServiceResponse.error' do
        result = subject

        expect(result).to be_a(ServiceResponse)
        expect(result.error?).to be(true)
        expect(result.message).to eq('Merge request is not mergeable')
      end
    end

    context 'when it cannot be merged on git' do
      let(:merge_request) do
        create(
          :merge_request,
          merge_status: :unchecked,
          source_branch: 'conflict-resolvable',
          source_project: project,
          target_branch: 'conflict-start'
        )
      end

      it 'returns ServiceResponse.error and keeps merge status as cannot_be_merged' do
        result = subject

        expect(merge_request.merge_status).to eq('cannot_be_merged')
        expect(result).to be_a(ServiceResponse)
        expect(result.error?).to be(true)
        expect(result.message).to eq('Merge request is not mergeable')
      end
    end

    context 'when MR cannot be merged and has no merge ref' do
      before do
        merge_request.mark_as_unmergeable!
      end

      it_behaves_like 'unmergeable merge request'

      it 'returns ServiceResponse.error' do
        result = subject

        expect(result).to be_a(ServiceResponse)
        expect(result.error?).to be(true)
        expect(result.message).to eq('Merge request is not mergeable')
      end
    end

    context 'when MR cannot be merged and has outdated merge ref' do
      before do
        MergeRequests::MergeToRefService.new(project: project, current_user: merge_request.author).execute(merge_request)
        merge_request.mark_as_unmergeable!
      end

      it_behaves_like 'unmergeable merge request'

      it 'returns ServiceResponse.error' do
        result = subject

        expect(result).to be_a(ServiceResponse)
        expect(result.error?).to be(true)
        expect(result.message).to eq('Merge request is not mergeable')
      end
    end

    context 'when merge request is not given' do
      subject { described_class.new(nil).execute }

      it 'returns ServiceResponse.error' do
        result = subject

        expect(result).to be_a(ServiceResponse)
        expect(result.message).to eq('Invalid argument')
      end
    end

    context 'when read-only DB' do
      it 'returns ServiceResponse.error' do
        allow(Gitlab::Database).to receive(:read_only?) { true }

        result = subject

        expect(result).to be_a(ServiceResponse)
        expect(result.message).to eq('Unsupported operation')
      end
    end

    context 'when fails to update the merge-ref' do
      before do
        expect_next_instance_of(MergeRequests::MergeToRefService) do |merge_to_ref|
          expect(merge_to_ref).to receive(:execute).and_return(status: :failed)
        end
      end

      it_behaves_like 'unmergeable merge request'

      it 'reloads merge head diff' do
        expect_next_instance_of(MergeRequests::ReloadMergeHeadDiffService) do |service|
          expect(service).to receive(:execute)
        end

        subject
      end

      it 'returns ServiceResponse.error' do
        result = subject

        expect(result).to be_a(ServiceResponse)
        expect(result.error?).to be(true)
        expect(result.message).to eq('Merge request is not mergeable')
      end
    end

    context 'recheck enforced' do
      subject { described_class.new(merge_request).execute(recheck: true) }

      context 'when MR is marked as mergeable, but repo is not mergeable and MR is not opened' do
        before do
          # Making sure that we don't touch the merge-status after
          # the MR is not opened any longer. Source branch might
          # have been removed, etc.
          allow(merge_request).to receive(:broken?) { true }
          merge_request.mark_as_mergeable!
          merge_request.close!
        end

        it 'returns ServiceResponse.error' do
          result = subject

          expect(result).to be_a(ServiceResponse)
          expect(result.error?).to be(true)
          expect(result.message).to eq('Merge ref cannot be updated')
          expect(result.payload).to be_empty
        end

        it 'does not change the merge status' do
          expect { subject }.not_to change(merge_request, :merge_status).from('can_be_merged')
        end
      end

      context 'when MR is mergeable but merge-ref does not exists' do
        before do
          merge_request.mark_as_mergeable!
        end

        it_behaves_like 'mergeable merge request'
      end

      context 'when MR is mergeable but merge-ref is already updated' do
        before do
          MergeRequests::MergeToRefService.new(project: project, current_user: merge_request.author).execute(merge_request)
          merge_request.mark_as_mergeable!
        end

        it 'returns ServiceResponse.success' do
          result = subject

          expect(result).to be_a(ServiceResponse)
          expect(result).to be_success
          expect(result.payload[:merge_ref_head]).to be_present
        end

        it 'does not recreate the merge-ref' do
          expect(MergeRequests::MergeToRefService).not_to receive(:new)

          subject
        end

        it 'does not reload merge head diff' do
          expect(MergeRequests::ReloadMergeHeadDiffService).not_to receive(:new)

          subject
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class AssignIssuesService < BaseProjectService
    def assignable_issues
      @assignable_issues ||= if current_user == merge_request.author
                               closes_issues.select do |issue|
                                 !issue.is_a?(ExternalIssue) && !issue.assignees.present? && can?(current_user, :admin_issue, issue)
                               end
                             else
                               []
                             end
    end

    def execute
      assignable_issues.each do |issue|
        Issues::UpdateService.new(container: issue.project, current_user: current_user, params: { assignee_ids: [current_user.id] }).execute(issue)
      end

      {
        count: assignable_issues.count
      }
    end

    private

    def merge_request
      params[:merge_request]
    end

    def closes_issues
      @closes_issues ||= params[:closes_issues] || merge_request.closes_issues(current_user)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::AssignIssuesService, feature_category: :code_review_workflow do
  let(:user) { create(:user) }
  let(:project) { create(:project, :public, :repository) }
  let(:issue) { create(:issue, project: project) }
  let(:merge_request) { create(:merge_request, :simple, source_project: project, author: user, description: ""fixes #{issue.to_reference}"") }
  let(:service) { described_class.new(project: project, current_user: user, params: { merge_request: merge_request }) }

  before do
    project.add_developer(user)
  end

  it 'finds unassigned issues fixed in merge request' do
    expect(service.assignable_issues.map(&:id)).to include(issue.id)
  end

  it 'ignores issues the user cannot update assignee on', :sidekiq_inline do
    project.team.truncate

    expect(service.assignable_issues).to be_empty
  end

  it 'ignores issues already assigned to any user' do
    issue.assignees = [create(:user)]

    expect(service.assignable_issues).to be_empty
  end

  it 'ignores all issues unless current_user is merge_request.author' do
    merge_request.update!(author: create(:user))

    expect(service.assignable_issues).to be_empty
  end

  it 'accepts precomputed data for closes_issues' do
    issue2 = create(:issue, project: project)
    service2 = described_class.new(
      project: project,
      current_user: user,
      params: {
        merge_request: merge_request,
        closes_issues: [issue, issue2]
      }
    )

    expect(service2.assignable_issues.count).to eq 2
  end

  it 'assigns these to the merge request owner' do
    expect { service.execute }.to change { issue.assignees.first }.to(user)
  end

  it 'ignores external issues' do
    external_issue = ExternalIssue.new('JIRA-123', project)
    service = described_class.new(
      project: project,
      current_user: user,
      params: {
        merge_request: merge_request,
        closes_issues: [external_issue]
      }
    )

    expect(service.assignable_issues.count).to eq 0
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class ReloadDiffsService
    def initialize(merge_request, current_user)
      @merge_request = merge_request
      @current_user = current_user
    end

    def execute
      old_diff_refs = merge_request.diff_refs
      new_diff = merge_request.create_merge_request_diff

      clear_cache(new_diff)
      update_diff_discussion_positions(old_diff_refs)
    end

    private

    attr_reader :merge_request, :current_user

    def update_diff_discussion_positions(old_diff_refs)
      new_diff_refs = merge_request.diff_refs

      merge_request.update_diff_discussion_positions(
        old_diff_refs: old_diff_refs,
        new_diff_refs: new_diff_refs,
        current_user: current_user
      )
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def clear_cache(new_diff)
      # Remove cache for all diffs on this MR. Do not use the association on the
      # model, as that will interfere with other actions happening when
      # reloading the diff.
      MergeRequestDiff
        .where(merge_request: merge_request)
        .preload(merge_request: :target_project)
        .find_each do |merge_request_diff|
        next if merge_request_diff == new_diff

        cacheable_collection(merge_request_diff).clear_cache
      end
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def cacheable_collection(diff)
      # There are scenarios where we don't need to request Diff Stats.
      # Mainly when clearing / writing diff caches.
      diff.diffs(include_stats: false)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::ReloadDiffsService, :use_clean_rails_memory_store_caching,
  feature_category: :code_review_workflow do
  let(:current_user) { create(:user) }
  let(:merge_request) { create(:merge_request) }
  let(:subject) { described_class.new(merge_request, current_user) }

  describe '#execute' do
    it 'creates new merge request diff' do
      expect { subject.execute }.to change { merge_request.merge_request_diffs.count }.by(1)
    end

    it 'calls update_diff_discussion_positions with correct params' do
      old_diff_refs = merge_request.diff_refs
      new_diff = merge_request.create_merge_request_diff
      new_diff_refs = merge_request.diff_refs

      expect(merge_request).to receive(:create_merge_request_diff).and_return(new_diff)
      expect(merge_request).to receive(:update_diff_discussion_positions).with(
        old_diff_refs: old_diff_refs, new_diff_refs: new_diff_refs, current_user: current_user
      )

      subject.execute
    end

    it 'does not change existing merge request diff' do
      expect(merge_request.merge_request_diff).not_to receive(:save_git_content)

      subject.execute
    end

    context 'cache clearing' do
      it 'clears the cache for older diffs on the merge request' do
        expect_next_instance_of(Gitlab::Diff::FileCollection::MergeRequestDiff) do |instance|
          expect(instance).to receive(:clear_cache).and_call_original
        end

        subject.execute
      end

      it 'avoids N+1 queries', :request_store do
        current_user
        merge_request

        control_count = ActiveRecord::QueryRecorder.new do
          subject.execute
        end.count

        expect { subject.execute }.not_to exceed_query_limit(control_count)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class MigrateExternalDiffsService < ::BaseService
    MAX_JOBS = 1000

    attr_reader :diff

    def self.enqueue!
      ids = MergeRequestDiff.ids_for_external_storage_migration(limit: MAX_JOBS)

      # rubocop:disable Scalability/BulkPerformWithContext
      # https://gitlab.com/gitlab-org/gitlab/issues/202100
      MigrateExternalDiffsWorker.bulk_perform_async(ids.map { |id| [id] })
      # rubocop:enable Scalability/BulkPerformWithContext
    end

    def initialize(merge_request_diff)
      @diff = merge_request_diff
    end

    def execute
      diff.migrate_files_to_external_storage!
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::MigrateExternalDiffsService, feature_category: :code_review_workflow do
  let(:merge_request) { create(:merge_request) }
  let(:diff) { merge_request.merge_request_diff }

  describe '.enqueue!' do
    around do |example|
      Sidekiq::Testing.fake! { example.run }
    end

    it 'enqueues nothing if external diffs are disabled' do
      expect(diff).not_to be_stored_externally

      expect { described_class.enqueue! }
        .not_to change { MigrateExternalDiffsWorker.jobs.count }
    end

    it 'enqueues eligible in-database diffs if external diffs are enabled' do
      expect(diff).not_to be_stored_externally

      stub_external_diffs_setting(enabled: true)

      expect { described_class.enqueue! }
        .to change { MigrateExternalDiffsWorker.jobs.count }
        .by(1)
    end
  end

  describe '#execute' do
    it 'migrates an in-database diff to the external store' do
      expect(diff).not_to be_stored_externally

      stub_external_diffs_setting(enabled: true)

      described_class.new(diff).execute

      expect(diff).to be_stored_externally
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class UpdateReviewerStateService < MergeRequests::BaseService
    def execute(merge_request, state)
      return error(""Invalid permissions"") unless can?(current_user, :update_merge_request, merge_request)

      reviewer = merge_request.find_reviewer(current_user)

      if reviewer
        return error(""Failed to update reviewer"") unless reviewer.update(state: state)

        trigger_merge_request_reviewers_updated(merge_request)

        return success if state != 'requested_changes'

        if merge_request.approved_by?(current_user) && !remove_approval(merge_request)
          return error(""Failed to remove approval"")
        end

        success
      else
        error(""Reviewer not found"")
      end
    end

    private

    def remove_approval(merge_request)
      MergeRequests::RemoveApprovalService.new(project: project, current_user: current_user)
        .execute(merge_request)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::UpdateReviewerStateService, feature_category: :code_review_workflow do
  let_it_be(:current_user) { create(:user) }
  let_it_be(:merge_request) { create(:merge_request, reviewers: [current_user]) }
  let(:reviewer) { merge_request.merge_request_reviewers.find_by(user_id: current_user.id) }
  let(:project) { merge_request.project }
  let(:service) { described_class.new(project: project, current_user: current_user) }
  let(:state) { 'requested_changes' }
  let(:result) { service.execute(merge_request, state) }

  before do
    project.add_developer(current_user)
  end

  describe '#execute' do
    shared_examples_for 'failed service execution' do
      it 'returns an error' do
        expect(result[:status]).to eq :error
      end

      it_behaves_like 'does not trigger GraphQL subscription mergeRequestReviewersUpdated' do
        let(:action) { result }
      end
    end

    describe 'invalid permissions' do
      let(:service) { described_class.new(project: project, current_user: create(:user)) }

      it_behaves_like 'failed service execution'
    end

    describe 'reviewer exists' do
      it 'returns success' do
        expect(result[:status]).to eq :success
      end

      it 'updates reviewers state' do
        expect(result[:status]).to eq :success
        expect(reviewer.state).to eq 'requested_changes'
      end

      it 'does not call MergeRequests::RemoveApprovalService' do
        expect(MergeRequests::RemoveApprovalService).not_to receive(:new)

        expect(result[:status]).to eq :success
      end

      it_behaves_like 'triggers GraphQL subscription mergeRequestReviewersUpdated' do
        let(:action) { result }
      end

      context 'when reviewer has approved' do
        before do
          create(:approval, user: current_user, merge_request: merge_request)
        end

        it 'removes approval when state is requested_changes' do
          expect_next_instance_of(
            MergeRequests::RemoveApprovalService,
            project: project, current_user: current_user
          ) do |service|
            expect(service).to receive(:execute).with(merge_request).and_return({ success: true })
          end

          expect(result[:status]).to eq :success
        end

        it 'renders error when remove approval service fails' do
          expect_next_instance_of(
            MergeRequests::RemoveApprovalService,
            project: project, current_user: current_user
          ) do |service|
            expect(service).to receive(:execute).with(merge_request).and_return(nil)
          end

          expect(result[:status]).to eq :error
          expect(result[:message]).to eq ""Failed to remove approval""
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class RetargetChainService < MergeRequests::BaseService
    MAX_RETARGET_MERGE_REQUESTS = 4

    def execute(merge_request)
      # we can only retarget MRs that are targeting the same project
      return unless merge_request.for_same_project? && merge_request.merged?

      # find another merge requests that
      # - as a target have a current source project and branch
      other_merge_requests = merge_request.source_project
        .merge_requests
        .opened
        .by_target_branch(merge_request.source_branch)
        .preload_source_project
        .limit(MAX_RETARGET_MERGE_REQUESTS)

      other_merge_requests.find_each do |other_merge_request|
        # Update only MRs on projects that we have access to
        next unless can?(current_user, :update_merge_request, other_merge_request.source_project)

        ::MergeRequests::UpdateService.new(
          project: other_merge_request.source_project,
          current_user: current_user,
          params: {
            target_branch: merge_request.target_branch,
            target_branch_was_deleted: true
          }
        ).execute(other_merge_request)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::RetargetChainService, feature_category: :code_review_workflow do
  include ProjectForksHelper

  let_it_be(:user) { create(:user) }
  let_it_be(:merge_request, reload: true) { create(:merge_request, assignees: [user]) }
  let_it_be(:project) { merge_request.project }

  subject { described_class.new(project: project, current_user: user).execute(merge_request) }

  before do
    project.add_maintainer(user)
  end

  describe '#execute' do
    context 'when there is another MR' do
      let!(:another_merge_request) do
        create(:merge_request,
          source_project: source_project,
          source_branch: 'my-awesome-feature',
          target_project: merge_request.source_project,
          target_branch: merge_request.source_branch
        )
      end

      shared_examples 'does not retarget merge request' do
        it 'another merge request is unchanged' do
          expect { subject }.not_to change { another_merge_request.reload.target_branch }
            .from(merge_request.source_branch)
        end
      end

      shared_examples 'retargets merge request' do
        it 'another merge request is retargeted' do
          expect(SystemNoteService)
            .to receive(:change_branch).once
            .with(another_merge_request, another_merge_request.project, user,
              'target', 'delete',
              merge_request.source_branch, merge_request.target_branch)

          expect { subject }.to change { another_merge_request.reload.target_branch }
            .from(merge_request.source_branch)
            .to(merge_request.target_branch)
        end
      end

      context 'in the same project' do
        let(:source_project) { project }

        context 'and current is merged' do
          before do
            merge_request.mark_as_merged
          end

          it_behaves_like 'retargets merge request'
        end

        context 'and current is closed' do
          before do
            merge_request.close
          end

          it_behaves_like 'does not retarget merge request'
        end

        context 'and another is closed' do
          before do
            another_merge_request.close
          end

          it_behaves_like 'does not retarget merge request'
        end

        context 'and another is merged' do
          before do
            another_merge_request.mark_as_merged
          end

          it_behaves_like 'does not retarget merge request'
        end
      end

      context 'in forked project' do
        let!(:source_project) { fork_project(project) }

        context 'when user has access to source project' do
          before do
            source_project.add_developer(user)
            merge_request.mark_as_merged
          end

          it_behaves_like 'retargets merge request'
        end

        context 'when user does not have access to source project' do
          it_behaves_like 'does not retarget merge request'
        end
      end

      context 'and current and another MR is from a fork' do
        let(:project) { create(:project) }
        let(:source_project) { fork_project(project) }

        let(:merge_request) do
          create(:merge_request,
            source_project: source_project,
            target_project: project
          )
        end

        before do
          source_project.add_developer(user)
        end

        it_behaves_like 'does not retarget merge request'
      end
    end

    context 'when many merge requests are to be retargeted' do
      let!(:many_merge_requests) do
        create_list(:merge_request, 10, :unique_branches,
          source_project: merge_request.source_project,
          target_project: merge_request.source_project,
          target_branch: merge_request.source_branch
        )
      end

      before do
        merge_request.mark_as_merged
      end

      it 'retargets only 4 of them' do
        subject

        expect(many_merge_requests.each(&:reload).pluck(:target_branch).tally)
          .to eq(
            merge_request.source_branch => 6,
            merge_request.target_branch => 4
          )
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class CleanupRefsService
    include BaseServiceUtility

    TIME_THRESHOLD = 14.days

    attr_reader :merge_request

    def self.schedule(merge_request)
      merge_request.create_cleanup_schedule(scheduled_at: TIME_THRESHOLD.from_now)
    end

    def initialize(merge_request)
      @merge_request = merge_request
      @repository = merge_request.project.repository
      @ref_path = merge_request.ref_path
      @ref_head_sha = @repository.commit(merge_request.ref_path)&.id
      @merge_ref_sha = merge_request.merge_ref_head&.id
    end

    def execute
      return error(""Merge request is not scheduled to be cleaned up yet."") unless scheduled?
      return error(""Merge request has not been closed nor merged for #{TIME_THRESHOLD.inspect}."") unless eligible?

      # Ensure that commit shas of refs are kept around so we won't lose them when GC runs.
      keep_around

      return error('Failed to create keep around refs.') unless kept_around?
      return error('Failed to cache merge ref sha.') unless cache_merge_ref_sha

      delete_refs if repository.exists?

      return error('Failed to update schedule.') unless update_schedule

      success
    rescue Gitlab::Git::Repository::GitError, Gitlab::Git::CommandError => e
      error(e.message)
    end

    private

    attr_reader :repository, :ref_path, :ref_head_sha, :merge_ref_sha

    def scheduled?
      merge_request.cleanup_schedule.present? && merge_request.cleanup_schedule.scheduled_at <= Time.current
    end

    def eligible?
      return met_time_threshold?(merge_request.metrics&.latest_closed_at) if merge_request.closed?

      merge_request.merged? && met_time_threshold?(merge_request.metrics&.merged_at)
    end

    def met_time_threshold?(attr)
      attr.nil? || attr.to_i <= TIME_THRESHOLD.ago.to_i
    end

    def kept_around?
      service = Gitlab::Git::KeepAround.new(repository)

      [ref_head_sha, merge_ref_sha].compact.all? do |sha|
        service.kept_around?(sha)
      end
    end

    def keep_around
      repository.keep_around(ref_head_sha, merge_ref_sha)
    end

    def cache_merge_ref_sha
      return true if merge_ref_sha.nil?

      # Caching the merge ref sha is needed before we delete the merge ref so
      # we can still show the merge ref diff (via `MergeRequest#merge_ref_head`)
      merge_request.update_column(:merge_ref_sha, merge_ref_sha)
    end

    def delete_refs
      merge_request.schedule_cleanup_refs
    end

    def update_schedule
      merge_request.cleanup_schedule.update(completed_at: Time.current)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::CleanupRefsService, feature_category: :code_review_workflow do
  describe '.schedule' do
    let(:merge_request) { create(:merge_request) }

    it 'creates a merge request cleanup schedule' do
      freeze_time do
        described_class.schedule(merge_request)

        expect(merge_request.reload.cleanup_schedule.scheduled_at)
          .to eq(described_class::TIME_THRESHOLD.from_now)
      end
    end
  end

  describe '#execute' do
    before do
      stub_feature_flags(merge_request_delete_gitaly_refs_in_batches: false)
      stub_feature_flags(merge_request_cleanup_ref_worker_async: false)

      # Need to re-enable this as it's being stubbed in spec_helper for
      # performance reasons but is needed to run for this test.
      allow(Gitlab::Git::KeepAround).to receive(:execute).and_call_original

      merge_request.create_cleanup_schedule(scheduled_at: described_class::TIME_THRESHOLD.ago)
    end

    subject(:result) { described_class.new(merge_request).execute }

    shared_examples_for 'service that cleans up merge request refs' do
      it 'creates keep around ref and deletes merge request refs' do
        old_ref_head = ref_head

        aggregate_failures do
          expect(result[:status]).to eq(:success)
          expect(kept_around?(old_ref_head)).to be_truthy
          expect(ref_head).to be_nil
          expect(merge_request.cleanup_schedule.completed_at).to be_present
        end
      end

      context 'when merge request has no head ref' do
        before do
          # Simulate a merge request with no head ref
          merge_request.project.repository.delete_refs(merge_request.ref_path)
        end

        it 'does not fail' do
          expect(result[:status]).to eq(:success)
          expect(merge_request.cleanup_schedule.completed_at).to be_present
        end
      end

      context 'when merge request has merge ref' do
        before do
          MergeRequests::MergeToRefService
            .new(project: merge_request.project, current_user: merge_request.author)
            .execute(merge_request)
        end

        it 'caches merge ref sha and deletes merge ref' do
          old_merge_ref_head = merge_request.merge_ref_head

          aggregate_failures do
            expect(result[:status]).to eq(:success)
            expect(kept_around?(old_merge_ref_head)).to be_truthy
            expect(merge_request.reload.merge_ref_sha).to eq(old_merge_ref_head.id)
            expect(ref_exists?(merge_request.merge_ref_path)).to be_falsy
          end
        end

        context 'when merge ref sha cannot be cached' do
          before do
            allow(merge_request)
              .to receive(:update_column)
              .with(:merge_ref_sha, merge_request.merge_ref_head.id)
              .and_return(false)
          end

          it_behaves_like 'service that does not clean up merge request refs'
        end
      end

      context 'when keep around ref cannot be created' do
        before do
          allow_next_instance_of(Gitlab::Git::KeepAround) do |keep_around|
            expect(keep_around).to receive(:kept_around?).and_return(false)
          end
        end

        it_behaves_like 'service that does not clean up merge request refs'
      end

      context 'when a git error is raised' do
        context 'Gitlab::Git::Repository::GitError' do
          before do
            allow(merge_request.project.repository).to receive(:delete_refs).and_raise(Gitlab::Git::Repository::GitError)
          end

          it_behaves_like 'service that does not clean up merge request refs'
        end

        context 'Gitlab::Git::CommandError' do
          before do
            allow_next_instance_of(Gitlab::Git::KeepAround) do |keep_around|
              expect(keep_around).to receive(:kept_around?).and_raise(Gitlab::Git::CommandError)
            end
          end

          it_behaves_like 'service that does not clean up merge request refs'
        end
      end

      context 'when cleanup schedule fails to update' do
        before do
          allow(merge_request.cleanup_schedule).to receive(:update).and_return(false)
        end

        it 'creates keep around ref and deletes merge request refs' do
          old_ref_head = ref_head

          aggregate_failures do
            expect(result[:status]).to eq(:error)
            expect(kept_around?(old_ref_head)).to be_truthy
            expect(ref_head).to be_nil
            expect(merge_request.cleanup_schedule.completed_at).not_to be_present
          end
        end
      end

      context 'when merge request is not scheduled to be cleaned up yet' do
        before do
          merge_request.cleanup_schedule.update!(scheduled_at: 1.day.from_now)
        end

        it_behaves_like 'service that does not clean up merge request refs'
      end

      context 'when repository no longer exists' do
        before do
          Repositories::DestroyService.new(merge_request.project.repository).execute
        end

        it 'does not fail and still mark schedule as complete' do
          aggregate_failures do
            expect(result[:status]).to eq(:success)
            expect(merge_request.cleanup_schedule.completed_at).to be_present
          end
        end
      end
    end

    shared_examples_for 'service that does not clean up merge request refs' do
      it 'does not delete merge request refs' do
        aggregate_failures do
          expect(result[:status]).to eq(:error)
          expect(ref_head).to be_present
          expect(merge_request.cleanup_schedule.completed_at).not_to be_present
        end
      end
    end

    context 'when merge request is closed' do
      let(:merge_request) { create(:merge_request, :closed) }

      context ""when closed #{described_class::TIME_THRESHOLD.inspect} ago"" do
        before do
          merge_request.metrics.update!(latest_closed_at: described_class::TIME_THRESHOLD.ago)
        end

        it_behaves_like 'service that cleans up merge request refs'
      end

      context ""when closed later than #{described_class::TIME_THRESHOLD.inspect} ago"" do
        before do
          merge_request.metrics.update!(latest_closed_at: (described_class::TIME_THRESHOLD - 1.day).ago)
        end

        it_behaves_like 'service that does not clean up merge request refs'
      end
    end

    context 'when merge request is merged' do
      let(:merge_request) { create(:merge_request, :merged) }

      context ""when merged #{described_class::TIME_THRESHOLD.inspect} ago"" do
        before do
          merge_request.metrics.update!(merged_at: described_class::TIME_THRESHOLD.ago)
        end

        it_behaves_like 'service that cleans up merge request refs'
      end

      context ""when merged later than #{described_class::TIME_THRESHOLD.inspect} ago"" do
        before do
          merge_request.metrics.update!(merged_at: (described_class::TIME_THRESHOLD - 1.day).ago)
        end

        it_behaves_like 'service that does not clean up merge request refs'
      end
    end

    context 'when merge request is not closed nor merged' do
      let(:merge_request) { create(:merge_request, :opened) }

      it_behaves_like 'service that does not clean up merge request refs'
    end
  end

  def kept_around?(commit)
    Gitlab::Git::KeepAround.new(merge_request.project.repository).kept_around?(commit.id)
  end

  def ref_head
    merge_request.project.repository.commit(merge_request.ref_path)
  end

  def ref_exists?(ref)
    merge_request.project.repository.ref_exists?(ref)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  # Performs the merge between source SHA and the target branch or the specified first parent ref. Instead
  # of writing the result to the MR target branch, it targets the `target_ref`.
  #
  # Ideally this should leave the `target_ref` state with the same state the
  # target branch would have if we used the regular `MergeService`, but without
  # every side-effect that comes with it (MR updates, mails, source branch
  # deletion, etc). This service should be kept idempotent (i.e. can
  # be executed regardless of the `target_ref` current state).
  #
  class MergeToRefService < MergeRequests::MergeBaseService
    extend ::Gitlab::Utils::Override

    def execute(merge_request)
      @merge_request = merge_request

      error_check!

      commit_id = extracted_merge_to_ref
      raise_error('Conflicts detected during merge') unless commit_id

      commit = project.commit(commit_id)
      target_id, source_id = commit.parent_ids

      success(commit_id: commit.id, target_id: target_id, source_id: source_id)
    rescue MergeError, ArgumentError => error
      error(error.message)
    end

    private

    def source
      merge_request.diff_head_sha
    end

    override :error_check!
    def error_check!
      raise_error('No source for merge') unless source
    end

    ##
    # The parameter `target_ref` is where the merge result will be written.
    # Default is the merge ref i.e. `refs/merge-requests/:iid/merge`.
    def target_ref
      params[:target_ref] || merge_request.merge_ref_path
    end

    ##
    # The parameter `first_parent_ref` is the main line of the merge commit.
    # Default is the target branch ref of the merge request.
    def first_parent_ref
      params[:first_parent_ref] || merge_request.target_branch_ref
    end

    def commit_message
      params[:commit_message] ||
        merge_request.default_merge_commit_message(user: current_user)
    end

    def extracted_merge_to_ref
      repository.merge_to_ref(current_user,
        source_sha: source,
        branch: merge_request.target_branch,
        target_ref: target_ref,
        message: commit_message,
        first_parent_ref: first_parent_ref)
    rescue Gitlab::Git::PreReceiveError, Gitlab::Git::CommandError => error
      raise MergeError, error.message
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::MergeToRefService, feature_category: :code_review_workflow do
  shared_examples_for 'MergeService for target ref' do
    it 'target_ref has the same state of target branch' do
      repo = merge_request.target_project.repository

      process_merge_to_ref
      merge_service.execute(merge_request)

      ref_commits = repo.commits(merge_request.merge_ref_path, limit: 3)
      target_branch_commits = repo.commits(merge_request.target_branch, limit: 3)

      ref_commits.zip(target_branch_commits).each do |ref_commit, target_branch_commit|
        expect(ref_commit.parents).to eq(target_branch_commit.parents)
      end
    end
  end

  shared_examples_for 'successfully merges to ref with merge method' do
    it 'writes commit to merge ref' do
      repository = project.repository

      expect(repository.ref_exists?(target_ref)).to be(false)

      result = service.execute(merge_request)

      ref_head = repository.commit(target_ref)

      expect(result[:status]).to eq(:success)
      expect(result[:commit_id]).to be_present
      expect(result[:source_id]).to eq(merge_request.source_branch_sha)
      expect(result[:target_id]).to eq(repository.commit(first_parent_ref).sha)
      expect(repository.ref_exists?(target_ref)).to be(true)
      expect(ref_head.id).to eq(result[:commit_id])
    end
  end

  shared_examples_for 'successfully evaluates pre-condition checks' do
    it 'returns an error when the failing to process the merge' do
      allow(project.repository).to receive(:merge_to_ref).and_return(nil)

      result = service.execute(merge_request)

      expect(result[:status]).to eq(:error)
      expect(result[:message]).to eq('Conflicts detected during merge')
    end

    it 'does not send any mail' do
      expect { process_merge_to_ref }.not_to change { ActionMailer::Base.deliveries.count }
    end

    it 'does not change the MR state' do
      expect { process_merge_to_ref }.not_to change { merge_request.state }
    end

    it 'does not create notes' do
      expect { process_merge_to_ref }.not_to change { merge_request.notes.count }
    end

    it 'does not delete the source branch' do
      expect(::Branches::DeleteService).not_to receive(:new)

      process_merge_to_ref
    end
  end

  let_it_be(:user) { create(:user) }

  let(:merge_request) { create(:merge_request, :simple) }
  let(:project) { merge_request.project }

  describe '#execute' do
    let(:service) do
      described_class.new(project: project, current_user: user, params: params)
    end

    let(:params) { { commit_message: 'Awesome message', should_remove_source_branch: true, sha: merge_request.diff_head_sha } }

    def process_merge_to_ref
      perform_enqueued_jobs do
        service.execute(merge_request)
      end
    end

    it_behaves_like 'successfully merges to ref with merge method' do
      let(:first_parent_ref) { 'refs/heads/master' }
      let(:target_ref) { merge_request.merge_ref_path }
    end

    it_behaves_like 'successfully evaluates pre-condition checks'

    it 'returns an error when Gitlab::Git::CommandError is raised during merge' do
      allow(project.repository).to receive(:merge_to_ref) do
        raise Gitlab::Git::CommandError, 'Failed to create merge commit'
      end

      result = service.execute(merge_request)

      expect(result[:status]).to eq(:error)
      expect(result[:message]).to eq('Failed to create merge commit')
    end

    context 'commit history comparison with regular MergeService' do
      before do
        # The merge service needs an authorized user while merge-to-ref
        # doesn't.
        project.add_maintainer(user)
      end

      let(:merge_ref_service) do
        described_class.new(project: project, current_user: user)
      end

      let(:merge_service) do
        MergeRequests::MergeService.new(project: project, current_user: user, params: { sha: merge_request.diff_head_sha })
      end

      context 'when merge commit' do
        it_behaves_like 'MergeService for target ref'
      end

      context 'when merge commit with squash' do
        before do
          merge_request.update!(squash: true)
        end

        it_behaves_like 'successfully merges to ref with merge method' do
          let(:first_parent_ref) { 'refs/heads/master' }
          let(:target_ref) { merge_request.merge_ref_path }
        end

        it 'does not squash before merging' do
          expect(MergeRequests::SquashService).not_to receive(:new)

          process_merge_to_ref
        end
      end
    end

    context 'merge pre-condition checks' do
      before do
        merge_request.project.update!(merge_method: merge_method)
      end

      context 'when semi-linear merge method' do
        let(:merge_method) { :rebase_merge }

        it_behaves_like 'successfully merges to ref with merge method' do
          let(:first_parent_ref) { 'refs/heads/master' }
          let(:target_ref) { merge_request.merge_ref_path }
        end

        it_behaves_like 'successfully evaluates pre-condition checks'
      end

      context 'when fast-forward merge method' do
        let(:merge_method) { :ff }

        it_behaves_like 'successfully merges to ref with merge method' do
          let(:first_parent_ref) { 'refs/heads/master' }
          let(:target_ref) { merge_request.merge_ref_path }
        end

        it_behaves_like 'successfully evaluates pre-condition checks'
      end

      context 'when MR is not mergeable to ref' do
        let(:merge_method) { :merge }

        it 'returns error' do
          allow(project).to receive_message_chain(:repository, :merge_to_ref) { nil }

          error_message = 'Conflicts detected during merge'

          result = service.execute(merge_request)

          expect(result[:status]).to eq(:error)
          expect(result[:message]).to eq(error_message)
        end
      end
    end

    context 'does not close related todos' do
      let(:merge_request) { create(:merge_request, assignees: [user], author: user) }
      let(:project) { merge_request.project }
      let!(:todo) do
        create(
          :todo,
          :assigned,
          project: project,
          author: user,
          user: user,
          target: merge_request
        )
      end

      before do
        allow(service).to receive(:execute_hooks)

        perform_enqueued_jobs do
          service.execute(merge_request)
          todo.reload
        end
      end

      it { expect(todo).not_to be_done }
    end

    context 'when source is missing' do
      it 'returns error' do
        allow(merge_request).to receive(:diff_head_sha) { nil }

        error_message = 'No source for merge'

        result = service.execute(merge_request)

        expect(result[:status]).to eq(:error)
        expect(result[:message]).to eq(error_message)
      end
    end

    context 'when target ref is passed as a parameter' do
      let(:params) { { commit_message: 'merge train', target_ref: target_ref, sha: merge_request.diff_head_sha } }

      it_behaves_like 'successfully merges to ref with merge method' do
        let(:first_parent_ref) { 'refs/heads/master' }
        let(:target_ref) { 'refs/merge-requests/1/train' }
      end
    end

    describe 'cascading merge refs' do
      let_it_be(:project) { create(:project, :repository) }

      let(:params) { { commit_message: 'Cascading merge', first_parent_ref: first_parent_ref, target_ref: target_ref, sha: merge_request.diff_head_sha } }

      context 'when first merge happens' do
        let(:merge_request) do
          create(
            :merge_request, source_project: project, source_branch: 'feature',
            target_project: project, target_branch: 'master'
          )
        end

        it_behaves_like 'successfully merges to ref with merge method' do
          let(:first_parent_ref) { 'refs/heads/master' }
          let(:target_ref) { 'refs/merge-requests/1/train' }
        end

        context 'when second merge happens' do
          let(:merge_request) do
            create(
              :merge_request,
              source_project: project, source_branch: 'improve/awesome',
              target_project: project, target_branch: 'master'
            )
          end

          it_behaves_like 'successfully merges to ref with merge method' do
            let(:first_parent_ref) { 'refs/merge-requests/1/train' }
            let(:target_ref) { 'refs/merge-requests/2/train' }
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class CreateApprovalEventService < MergeRequests::BaseService
    def execute(merge_request)
      event_service.approve_mr(merge_request, current_user)
    end
  end
end

MergeRequests::CreateApprovalEventService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::CreateApprovalEventService, feature_category: :code_review_workflow do
  let(:user) { create(:user) }
  let(:merge_request) { create(:merge_request) }
  let(:project) { merge_request.project }

  subject(:service) { described_class.new(project: project, current_user: user) }

  describe '#execute' do
    it 'creates approve MR event' do
      expect_next_instance_of(EventCreateService) do |instance|
        expect(instance).to receive(:approve_mr)
          .with(merge_request, user)
      end

      service.execute(merge_request)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class ReopenService < MergeRequests::BaseService
    def execute(merge_request)
      return merge_request unless can?(current_user, :reopen_merge_request, merge_request)

      if merge_request.reopen
        users = merge_request.assignees | merge_request.reviewers

        create_event(merge_request)
        create_note(merge_request, 'reopened')
        merge_request_activity_counter.track_reopen_mr_action(user: current_user)
        notification_service.async.reopen_mr(merge_request, current_user)
        execute_hooks(merge_request, 'reopen')
        merge_request.reload_diff(current_user)
        merge_request.mark_as_unchecked
        invalidate_cache_counts(merge_request, users: users)
        merge_request.update_project_counter_caches
        merge_request.cache_merge_request_closes_issues!(current_user)
        merge_request.cleanup_schedule&.destroy
        merge_request.update_column(:merge_ref_sha, nil)
      end

      merge_request
    end

    private

    def create_event(merge_request)
      # Making sure MergeRequest::Metrics updates are in sync with
      # Event creation.
      Event.transaction do
        event_service.reopen_mr(merge_request, current_user)
        merge_request_metrics_service(merge_request).reopen
      end
    end
  end
end

MergeRequests::ReopenService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::ReopenService, feature_category: :code_review_workflow do
  let(:user) { create(:user) }
  let(:user2) { create(:user) }
  let(:guest) { create(:user) }
  let(:merge_request) { create(:merge_request, :closed, assignees: [user2], author: create(:user)) }
  let(:project) { merge_request.project }

  before do
    project.add_maintainer(user)
    project.add_developer(user2)
    project.add_guest(guest)
  end

  describe '#execute' do
    it_behaves_like 'cache counters invalidator'
    it_behaves_like 'merge request reviewers cache counters invalidator'

    context 'valid params' do
      let(:service) { described_class.new(project: project, current_user: user) }

      before do
        allow(service).to receive(:execute_hooks)
        merge_request.create_cleanup_schedule(scheduled_at: Time.current)
        merge_request.update_column(:merge_ref_sha, 'abc123')

        perform_enqueued_jobs do
          service.execute(merge_request)
        end
      end

      it { expect(merge_request).to be_valid }
      it { expect(merge_request).to be_opened }

      it 'executes hooks with reopen action' do
        expect(service).to have_received(:execute_hooks)
                               .with(merge_request, 'reopen')
      end

      it 'does not call GroupMentionWorker' do
        expect(Integrations::GroupMentionWorker).not_to receive(:perform_async)
      end

      it 'sends email to user2 about reopen of merge_request', :sidekiq_inline do
        email = ActionMailer::Base.deliveries.last
        expect(email.to.first).to eq(user2.email)
        expect(email.subject).to include(merge_request.title)
      end

      it 'destroys cleanup schedule record' do
        expect(merge_request.reload.cleanup_schedule).to be_nil
      end

      it 'clears the cached merge_ref_sha' do
        expect(merge_request.reload.merge_ref_sha).to be_nil
      end

      context 'note creation' do
        it 'creates resource state event about merge_request reopen' do
          event = merge_request.resource_state_events.last
          expect(event.state).to eq('reopened')
        end
      end
    end

    it 'caches merge request closing issues' do
      expect(merge_request).to receive(:cache_merge_request_closes_issues!)

      described_class.new(project: project, current_user: user).execute(merge_request)
    end

    it 'updates metrics' do
      metrics = merge_request.metrics
      service = double(MergeRequestMetricsService)
      allow(MergeRequestMetricsService)
        .to receive(:new)
        .with(metrics)
        .and_return(service)

      expect(service).to receive(:reopen)

      described_class.new(project: project, current_user: user).execute(merge_request)
    end

    it 'calls the merge request activity counter' do
      expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
        .to receive(:track_reopen_mr_action)
        .with(user: user)

      described_class.new(project: project, current_user: user).execute(merge_request)
    end

    it 'refreshes the number of open merge requests for a valid MR' do
      service = described_class.new(project: project, current_user: user)

      expect do
        service.execute(merge_request)

        BatchLoader::Executor.clear_current
      end
        .to change { project.open_merge_requests_count }.from(0).to(1)
    end

    context 'current user is not authorized to reopen merge request' do
      before do
        perform_enqueued_jobs do
          @merge_request = described_class.new(project: project, current_user: guest).execute(merge_request)
        end
      end

      it 'does not reopen the merge request' do
        expect(@merge_request).to be_closed
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class CreateFromIssueService < MergeRequests::CreateService
    # TODO: This constructor does not use the ""params:"" argument from the superclass,
    #   but instead has a custom ""mr_params:"" argument. This is because historically,
    #   prior to named arguments being introduced to the constructor, it never passed
    #   along the third positional argument when calling `super`.
    #   This should be changed, in order to be consistent (all subclasses should pass
    #   along all of the arguments to the superclass, otherwise it is probably not an
    #   ""is a"" relationship). However, we need to be sure that passing the params
    #   argument to `super` (especially target_project_id) will not cause any unexpected
    #   behavior in the superclass. Since the addition of the named arguments is
    #   intended to be a low-risk pure refactor, we will defer this fix
    #   to this follow-on issue:
    #   https://gitlab.com/gitlab-org/gitlab/-/issues/328726
    def initialize(project:, current_user:, mr_params: {})
      # branch - the name of new branch
      # ref    - the source of new branch.

      @branch_name       = mr_params[:branch_name]
      @issue_iid         = mr_params[:issue_iid]
      @ref               = mr_params[:ref]
      @target_project_id = mr_params[:target_project_id]

      super(project: project, current_user: current_user)
    end

    def execute
      return error('Project not found') if target_project.blank?
      return error('Not allowed to create merge request') unless can_create_merge_request?
      return error('Invalid issue iid') unless @issue_iid.present? && issue.present?

      result = ::Branches::CreateService.new(target_project, current_user).execute(branch_name, ref)
      return result if result[:status] == :error

      new_merge_request = create(merge_request)

      if new_merge_request.valid?
        merge_request_activity_counter.track_mr_create_from_issue(user: current_user)
        SystemNoteService.new_merge_request(issue, project, current_user, new_merge_request)

        success(new_merge_request)
      else
        SystemNoteService.new_issue_branch(issue, project, current_user, branch_name, branch_project: target_project)

        error(new_merge_request.errors)
      end
    end

    private

    def can_create_merge_request?
      can?(current_user, :create_merge_request_from, target_project)
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def issue
      @issue ||= IssuesFinder.new(current_user, project_id: project.id).find_by(iid: @issue_iid)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def branch_name
      @branch ||= @branch_name || issue.to_branch_name
    end

    def ref
      if valid_ref?
        @ref
      else
        default_branch
      end
    end

    def valid_ref?
      ref_is_branch? || ref_is_tag?
    end

    def ref_is_branch?
      target_project.repository.branch_exists?(@ref)
    end

    def ref_is_tag?
      target_project.repository.tag_exists?(@ref)
    end

    def default_branch
      target_project.default_branch_or_main
    end

    def merge_request
      MergeRequests::BuildService.new(project: target_project, current_user: current_user, params: merge_request_params).execute
    end

    def merge_request_params
      {
        issue_iid: @issue_iid,
        source_project_id: target_project.id,
        source_branch: branch_name,
        target_project_id: target_project.id,
        target_branch: target_branch,
        assignee_ids: [current_user.id]
      }
    end

    def target_branch
      if ref_is_branch?
        @ref
      else
        default_branch
      end
    end

    def success(merge_request)
      super().merge(merge_request: merge_request)
    end

    def target_project
      @target_project ||=
        if @target_project_id.present?
          project.forks.find_by_id(@target_project_id)
        else
          project
        end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::CreateFromIssueService, feature_category: :code_review_workflow do
  include ProjectForksHelper

  let(:project) { create(:project, :repository) }
  let(:user) { create(:user) }
  let(:label_ids) { create_pair(:label, project: project).map(&:id) }
  let(:milestone_id) { create(:milestone, project: project).id }
  let(:issue) { create(:issue, project: project, milestone_id: milestone_id) }
  let(:custom_source_branch) { 'custom-source-branch' }
  let(:service) { described_class.new(project: project, current_user: user, mr_params: service_params) }
  let(:service_with_custom_source_branch) { described_class.new(project: project, current_user: user, mr_params: { branch_name: custom_source_branch, **service_params }) }

  before do
    project.add_developer(user)
  end

  describe '#execute' do
    shared_examples_for 'a service that creates a merge request from an issue' do
      it 'returns an error when user can not create merge request on target project' do
        result = described_class.new(project: project, current_user: create(:user), mr_params: service_params).execute

        expect(result[:status]).to eq(:error)
        expect(result[:message]).to eq('Not allowed to create merge request')
      end

      it 'returns an error with invalid issue iid' do
        result = described_class.new(project: project, current_user: user, mr_params: { issue_iid: -1 }).execute

        expect(result[:status]).to eq(:error)
        expect(result[:message]).to eq('Invalid issue iid')
      end

      it 'creates a branch based on issue title' do
        service.execute

        expect(target_project.repository.branch_exists?(issue.to_branch_name)).to be_truthy
      end

      it 'creates a branch using passed name' do
        service_with_custom_source_branch.execute

        expect(target_project.repository.branch_exists?(custom_source_branch)).to be_truthy
      end

      it 'creates the new_merge_request system note' do
        expect(SystemNoteService).to receive(:new_merge_request).with(issue, project, user, instance_of(MergeRequest))

        service.execute
      end

      it 'tracks the mr creation when the mr is valid' do
        expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
          .to receive(:track_mr_create_from_issue)
          .with(user: user)

        service.execute
      end

      it 'creates the new_issue_branch system note when the branch could be created but the merge_request cannot be created' do
        expect_next_instance_of(MergeRequest) do |instance|
          expect(instance).to receive(:valid?).at_least(:once).and_return(false)
        end

        expect(SystemNoteService).to receive(:new_issue_branch).with(issue, project, user, issue.to_branch_name, branch_project: target_project)

        service.execute
      end

      it 'does not track the mr creation when the Mr is invalid' do
        expect_next_instance_of(MergeRequest) do |instance|
          expect(instance).to receive(:valid?).at_least(:once).and_return(false)
        end

        expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
          .not_to receive(:track_mr_create_from_issue)

        service.execute
      end

      it 'creates a merge request' do
        expect { service.execute }.to change(target_project.merge_requests, :count).by(1)
      end

      it 'sets the merge request author to current user and assigns them' do
        result = service.execute

        expect(result[:merge_request].author).to eq(user)
        expect(result[:merge_request].assignees).to eq([user])
      end

      it 'sets the merge request source branch to the new issue branch' do
        result = service.execute

        expect(result[:merge_request].source_branch).to eq(issue.to_branch_name)
      end

      it 'sets the merge request source branch to the passed branch name' do
        result = service_with_custom_source_branch.execute

        expect(result[:merge_request].source_branch).to eq(custom_source_branch)
      end

      it 'sets the merge request target branch to the project default branch' do
        result = service.execute

        expect(result[:merge_request].target_branch).to eq(target_project.default_branch)
      end

      it 'executes quick actions if the build service sets them in the description' do
        allow(service).to receive(:merge_request).and_wrap_original do |m, *args|
          m.call(*args).tap do |merge_request|
            merge_request.description = ""/assign #{user.to_reference}""
          end
        end

        result = service.execute

        expect(result[:merge_request].assignees).to eq([user])
      end

      context 'when ref branch is set' do
        subject { described_class.new(project: project, current_user: user, mr_params: { ref: 'feature', **service_params }).execute }

        it 'sets the merge request source branch to the new issue branch' do
          expect(subject[:merge_request].source_branch).to eq(issue.to_branch_name)
        end

        it 'sets the merge request target branch to the ref branch' do
          expect(subject[:merge_request].target_branch).to eq('feature')
        end

        context 'when the ref is a tag' do
          subject { described_class.new(project: project, current_user: user, mr_params: { ref: 'v1.0.0', **service_params }).execute }

          it 'sets the merge request source branch to the new issue branch' do
            expect(subject[:merge_request].source_branch).to eq(issue.to_branch_name)
          end

          it 'creates a merge request' do
            expect { subject }.to change(target_project.merge_requests, :count).by(1)
          end

          it 'sets the merge request target branch to the project default branch' do
            expect(subject[:merge_request].target_branch).to eq(target_project.default_branch)
          end
        end

        context 'when ref branch does not exist' do
          subject { described_class.new(project: project, current_user: user, mr_params: { ref: 'no-such-branch', **service_params }).execute }

          it 'creates a merge request' do
            expect { subject }.to change(target_project.merge_requests, :count).by(1)
          end

          it 'sets the merge request target branch to the project default branch' do
            expect(subject[:merge_request].target_branch).to eq(target_project.default_branch)
          end
        end
      end
    end

    context 'no target_project_id specified' do
      let(:service_params) { { issue_iid: issue.iid } }
      let(:target_project) { project }

      it_behaves_like 'a service that creates a merge request from an issue'

      it ""inherits labels"" do
        issue.assign_attributes(label_ids: label_ids)

        result = service.execute

        expect(result[:merge_request].label_ids).to match_array(label_ids)
      end

      it ""inherits milestones"" do
        result = service.execute

        expect(result[:merge_request].milestone_id).to eq(milestone_id)
      end

      it 'sets the merge request title to: ""Draft: Resolves ""$issue-title""' do
        result = service.execute

        expect(result[:merge_request].title).to eq(""Draft: Resolve \""#{issue.title}\"""")
      end
    end

    context 'target_project_id is specified' do
      let(:service_params) { { issue_iid: issue.iid, target_project_id: target_project.id } }

      context 'target project is not a fork of the project' do
        let(:target_project) { create(:project, :repository) }

        it 'returns an error about not finding the project' do
          result = service.execute

          expect(result[:status]).to eq(:error)
          expect(result[:message]).to eq('Project not found')
        end

        it 'does not create merge request' do
          expect { service.execute }.to change(target_project.merge_requests, :count).by(0)
        end
      end

      context 'target project is a fork of project project' do
        let(:target_project) { fork_project(project, user, repository: true) }

        it_behaves_like 'a service that creates a merge request from an issue'

        it 'sets the merge request title to: ""Draft: $issue-branch-name' do
          result = service.execute

          expect(result[:merge_request].title).to eq(""Draft: #{issue.to_branch_name.titleize.humanize}"")
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class UpdateAssigneesService < UpdateService
    # a stripped down service that only does what it must to update the
    # assignees, and knows that it does not have to check for other updates.
    # This saves a lot of queries for irrelevant things that cannot possibly
    # change in the execution of this service.
    def execute(merge_request)
      return merge_request unless current_user&.can?(:update_merge_request, merge_request)

      old_assignees = merge_request.assignees.to_a
      old_ids = old_assignees.map(&:id)
      new_ids = new_user_ids(merge_request, update_attrs[:assignee_ids], :assignees)

      return merge_request if merge_request.errors.any?
      return merge_request if new_ids.size != update_attrs[:assignee_ids].size
      return merge_request if old_ids.to_set == new_ids.to_set # no-change

      attrs = update_attrs.merge(assignee_ids: new_ids)

      merge_request.update(**attrs)

      return merge_request unless merge_request.valid?

      # Defer the more expensive operations (handle_assignee_changes) to the background
      MergeRequests::HandleAssigneesChangeService
        .new(project: project, current_user: current_user)
        .async_execute(merge_request, old_assignees, execute_hooks: true)

      merge_request
    end

    private

    def assignee_ids
      filter_sentinel_values(params.fetch(:assignee_ids)).first(1)
    end

    def params
      ps = super

      # allow either assignee_id or assignee_ids, preferring assignee_id if passed.
      { assignee_ids: ps.key?(:assignee_id) ? Array.wrap(ps[:assignee_id]) : ps[:assignee_ids] }
    end

    def update_attrs
      @attrs ||= { updated_at: Time.current, updated_by: current_user, assignee_ids: assignee_ids }
    end
  end
end

MergeRequests::UpdateAssigneesService.prepend_mod_with('MergeRequests::UpdateAssigneesService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::UpdateAssigneesService, feature_category: :code_review_workflow do
  include AfterNextHelpers

  let_it_be(:group) { create(:group, :public) }
  let_it_be(:project) { create(:project, :private, :repository, group: group) }
  let_it_be(:user) { create(:user) }
  let_it_be(:user2) { create(:user) }
  let_it_be(:user3) { create(:user) }

  let_it_be_with_reload(:merge_request) do
    create(
      :merge_request,
      :simple,
      :unique_branches,
      title: 'Old title',
      description: ""FYI #{user2.to_reference}"",
      assignee_ids: [user3.id],
      source_project: project,
      target_project: project,
      author: create(:user)
    )
  end

  before do
    project.add_maintainer(user)
    project.add_developer(user2)
    project.add_developer(user3)
    merge_request.errors.clear
  end

  let(:service) { described_class.new(project: project, current_user: user, params: opts) }
  let(:opts) { { assignee_ids: [user2.id] } }

  describe 'execute' do
    def update_merge_request
      service.execute(merge_request)
    end

    shared_examples 'it updates and enqueues the job' do
      it 'correctly updates the MR and enqueues the job' do
        expect_next(MergeRequests::HandleAssigneesChangeService, project: project, current_user: user) do |service|
          expect(service)
            .to receive(:async_execute).with(merge_request, [user3], execute_hooks: true)
        end

        expect { update_merge_request }
          .to change { merge_request.reload.assignees }.from([user3]).to(new_users)
          .and change(merge_request, :updated_at)
          .and change(merge_request, :updated_by).to(user)
      end
    end

    shared_examples 'removing all assignees' do
      it 'removes all assignees' do
        expect(update_merge_request).to have_attributes(assignees: be_empty, errors: be_none)
      end

      it 'enqueues the correct background work' do
        expect_next(MergeRequests::HandleAssigneesChangeService, project: project, current_user: user) do |service|
          expect(service)
            .to receive(:async_execute)
            .with(merge_request, [user3], execute_hooks: true)
        end

        update_merge_request
      end
    end

    context 'when the parameters are valid' do
      context 'when using sentinel values' do
        context 'when using assignee_ids' do
          let(:opts) { { assignee_ids: [0] } }

          it_behaves_like 'removing all assignees'
        end

        context 'when using assignee_id' do
          let(:opts) { { assignee_id: 0 } }

          it_behaves_like 'removing all assignees'
        end
      end

      context 'when the assignee_ids parameter is the empty list' do
        let(:opts) { { assignee_ids: [] } }

        it_behaves_like 'removing all assignees'
      end

      it_behaves_like 'it updates and enqueues the job' do
        let(:new_users) { [user2] }
      end

      it 'does not update the assignees if they do not have access' do
        opts[:assignee_ids] = [create(:user).id]

        expect(update_merge_request).to have_attributes(
          assignees: [user3],
          errors: be_any
        )
      end

      it 'is more efficient than using the full update-service' do
        allow_next(MergeRequests::HandleAssigneesChangeService, project: project, current_user: user) do |service|
          expect(service)
            .to receive(:async_execute)
            .with(merge_request, [user3], execute_hooks: true)
        end

        other_mr = create(
          :merge_request,
          :simple,
          :unique_branches,
          title: merge_request.title,
          description: merge_request.description,
          assignee_ids: merge_request.assignee_ids,
          source_project: merge_request.project,
          author: merge_request.author
        )

        update_service = ::MergeRequests::UpdateService.new(project: project, current_user: user, params: opts)

        expect { service.execute(merge_request) }
          .to issue_fewer_queries_than { update_service.execute(other_mr) }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class ReloadMergeHeadDiffService
    include BaseServiceUtility

    def initialize(merge_request)
      @merge_request = merge_request
    end

    def execute
      return error(""Merge request has no merge ref head."") unless merge_request.merge_ref_head.present?

      error_msg = recreate_merge_head_diff

      return error(error_msg) if error_msg

      success
    end

    private

    attr_reader :merge_request

    def recreate_merge_head_diff
      merge_request.merge_head_diff&.destroy!

      # n+1: https://gitlab.com/gitlab-org/gitlab/-/issues/19377
      Gitlab::GitalyClient.allow_n_plus_1_calls do
        merge_request.create_merge_head_diff!
      end

      # Reset the merge request so it won't load the merge head diff as the
      # MergeRequest#merge_request_diff.
      merge_request.reset

      nil
    rescue StandardError => e
      message = ""Failed to recreate merge head diff: #{e.message}""

      Gitlab::AppLogger.error(message: message, merge_request_id: merge_request.id)
      message
    end
  end
end

MergeRequests::ReloadMergeHeadDiffService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::ReloadMergeHeadDiffService, feature_category: :code_review_workflow do
  let(:merge_request) { create(:merge_request) }

  subject { described_class.new(merge_request).execute }

  describe '#execute' do
    before do
      MergeRequests::MergeToRefService
        .new(project: merge_request.project, current_user: merge_request.author)
        .execute(merge_request)
    end

    it 'creates a merge head diff' do
      expect(subject[:status]).to eq(:success)
      expect(merge_request.reload.merge_head_diff).to be_present
    end

    context 'when merge ref head is not present' do
      before do
        allow(merge_request).to receive(:merge_ref_head).and_return(nil)
      end

      it 'returns error' do
        expect(subject[:status]).to eq(:error)
      end
    end

    context 'when failed to create merge head diff' do
      before do
        allow(merge_request).to receive(:create_merge_head_diff!).and_raise('fail')
      end

      it 'returns error' do
        expect(subject[:status]).to eq(:error)
      end
    end

    context 'when there is existing merge head diff' do
      let!(:existing_merge_head_diff) { create(:merge_request_diff, :merge_head, merge_request: merge_request) }

      it 'recreates merge head diff' do
        expect(subject[:status]).to eq(:success)
        expect(merge_request.reload.merge_head_diff).not_to eq(existing_merge_head_diff)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class SquashService
    include BaseServiceUtility
    include MergeRequests::ErrorLogger

    def initialize(merge_request:, current_user:, commit_message:)
      @merge_request = merge_request
      @target_project = merge_request.target_project
      @current_user = current_user
      @commit_message = commit_message
    end

    def execute
      # If performing a squash would result in no change, then
      # immediately return a success message without performing a squash
      if merge_request.commits_count == 1 && message&.strip == merge_request.first_commit.safe_message&.strip
        return success(squash_sha: merge_request.diff_head_sha)
      end

      return error(s_(""MergeRequests|Squashing not allowed: This project doesn't allow you to squash commits when merging."")) if squash_forbidden?

      squash! || error(s_('MergeRequests|Squashing failed: Squash the commits locally, resolve any conflicts, then push the branch.'))
    end

    private

    attr_reader :merge_request, :target_project, :current_user, :commit_message

    def squash!
      squash_sha = repository.squash(current_user, merge_request, message)

      success(squash_sha: squash_sha)
    rescue StandardError => e
      log_error(exception: e, message: 'Failed to squash merge request')

      false
    end

    def squash_forbidden?
      target_project.squash_never?
    end

    def repository
      target_project.repository
    end

    def message
      commit_message.presence || merge_request.default_squash_commit_message(user: current_user)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::SquashService, feature_category: :source_code_management do
  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:user) { project.first_owner }

  let(:service) { described_class.new(merge_request: merge_request, current_user: user, commit_message: commit_message) }
  let(:commit_message) { nil }
  let(:repository) { project.repository.raw }
  let(:log_error) { ""Failed to squash merge request #{merge_request.to_reference(full: true)}:"" }

  let(:squash_dir_path) do
    File.join(Gitlab.config.shared.path, 'tmp/squash', repository.gl_repository, merge_request.id.to_s)
  end

  let_it_be(:merge_request_with_one_commit) do
    create(
      :merge_request,
      source_branch: 'feature', source_project: project,
      target_branch: 'master', target_project: project
    )
  end

  let_it_be(:merge_request_with_only_new_files) do
    create(
      :merge_request,
      source_branch: 'video', source_project: project,
      target_branch: 'master', target_project: project
    )
  end

  let_it_be(:merge_request_with_large_files) do
    create(
      :merge_request,
      source_branch: 'squash-large-files', source_project: project,
      target_branch: 'master', target_project: project
    )
  end

  shared_examples 'the squash succeeds' do
    it 'returns the squashed commit SHA' do
      result = service.execute

      expect(result).to match(status: :success, squash_sha: a_string_matching(/\h{40}/))
      expect(result[:squash_sha]).not_to eq(merge_request.diff_head_sha)
    end

    it 'cleans up the temporary directory' do
      service.execute

      expect(File.exist?(squash_dir_path)).to be(false)
    end

    it 'does not keep the branch push event' do
      expect { service.execute }.not_to change { Event.count }
    end

    context 'when there is a single commit in the merge request' do
      before do
        expect(merge_request).to receive(:commits_count).at_least(:once).and_return(1)
      end

      it 'will still perform the squash' do
        expect(merge_request.target_project.repository).to receive(:squash).and_return('sha')

        service.execute
      end

      context 'when squash message matches commit message' do
        let(:commit_message) { merge_request.first_commit.safe_message }

        it 'returns that commit SHA' do
          result = service.execute

          expect(result).to match(status: :success, squash_sha: merge_request.diff_head_sha)
        end

        it 'does not perform any git actions' do
          expect(repository).not_to receive(:squash)

          service.execute
        end
      end

      context 'when squash message matches commit message but without trailing new line' do
        let(:commit_message) { merge_request.first_commit.safe_message.strip }

        it 'returns that commit SHA' do
          result = service.execute

          expect(result).to match(status: :success, squash_sha: merge_request.diff_head_sha)
        end

        it 'does not perform any git actions' do
          expect(repository).not_to receive(:squash)

          service.execute
        end
      end
    end

    describe 'the squashed commit' do
      let(:squash_sha) { service.execute[:squash_sha] }
      let(:squash_commit) { project.repository.commit(squash_sha) }

      it 'copies the author info from the merge request' do
        expect(squash_commit.author_name).to eq(merge_request.author.name)
        expect(squash_commit.author_email).to eq(merge_request.author.email)
      end

      it 'sets the current user as the committer' do
        expect(squash_commit.committer_name).to eq(user.name.chomp('.'))
        expect(squash_commit.committer_email).to eq(user.email)
      end

      it 'has the same diff as the merge request, but a different SHA' do
        mr_diff = project.repository.diff(merge_request.diff_base_sha, merge_request.diff_head_sha)
        squash_diff = project.repository.diff(merge_request.diff_start_sha, squash_sha)

        expect(squash_diff.size).to eq(mr_diff.size)
        expect(squash_commit.sha).not_to eq(merge_request.diff_head_sha)
      end

      it 'has a default squash commit message if no message was provided' do
        expect(squash_commit.message.chomp).to eq(merge_request.default_squash_commit_message.chomp)
      end

      context 'if a message was provided' do
        let(:commit_message) { message }
        let(:message) { 'My custom message' }
        let(:squash_sha) { service.execute[:squash_sha] }

        it 'has the same message as the message provided' do
          expect(squash_commit.message.chomp).to eq(message)
        end
      end
    end
  end

  describe '#execute' do
    context 'when there is only one commit in the merge request' do
      let(:merge_request) { merge_request_with_one_commit }

      include_examples 'the squash succeeds'
    end

    context 'when squashing only new files' do
      let(:merge_request) { merge_request_with_only_new_files }

      include_examples 'the squash succeeds'
    end

    context 'when squashing is disabled by default on the project' do
      # Squashing is disabled by default, but it should still allow you
      # to squash-and-merge if selected through the UI
      let(:merge_request) { merge_request_with_only_new_files }

      before do
        merge_request.project.project_setting.squash_default_off!
      end

      include_examples 'the squash succeeds'
    end

    context 'when squashing is forbidden on the project' do
      let(:merge_request) { merge_request_with_only_new_files }

      before do
        merge_request.project.project_setting.squash_never!
      end

      it 'raises a squash error' do
        expect(service.execute).to match(
          status: :error,
          message: a_string_including('allow you to squash commits when merging'))
      end
    end

    context 'when squashing is enabled by default on the project' do
      let(:merge_request) { merge_request_with_only_new_files }

      before do
        merge_request.project.project_setting.squash_always!
      end

      include_examples 'the squash succeeds'
    end

    context 'when squashing with files too large to display' do
      let(:merge_request) { merge_request_with_large_files }

      include_examples 'the squash succeeds'
    end

    describe 'git errors' do
      let(:merge_request) { merge_request_with_only_new_files }
      let(:error) { 'A test error' }

      context 'with an error in Gitaly UserSquash RPC' do
        before do
          allow(repository.gitaly_operation_client).to receive(:user_squash)
            .and_raise(Gitlab::Git::Repository::GitError, error)
        end

        it 'logs the error' do
          expect(service).to receive(:log_error).with(exception: an_instance_of(Gitlab::Git::Repository::GitError), message: 'Failed to squash merge request')

          service.execute
        end

        it 'returns an error' do
          expect(service.execute).to match(status: :error, message: a_string_including('Squash'))
        end
      end
    end

    context 'when any other exception is thrown' do
      let(:merge_request) { merge_request_with_only_new_files }
      let(:merge_request_ref) { merge_request.to_reference(full: true) }
      let(:exception) { RuntimeError.new('A test error') }

      before do
        allow(merge_request.target_project.repository).to receive(:squash).and_raise(exception)
      end

      it 'logs the error' do
        expect(service).to receive(:log_error).with(exception: exception, message: 'Failed to squash merge request').and_call_original
        expect(Gitlab::ErrorTracking).to receive(:track_exception).with(exception,
          {
            class: described_class.to_s,
            merge_request: merge_request_ref,
            merge_request_id: merge_request.id,
            message: 'Failed to squash merge request',
            save_message_on_model: false
          }).and_call_original

        service.execute
      end

      it 'returns an error' do
        expect(service.execute).to match(status: :error, message: a_string_including('Squash'))
      end

      it 'cleans up the temporary directory' do
        service.execute

        expect(File.exist?(squash_dir_path)).to be(false)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class DeleteNonLatestDiffsService
    BATCH_SIZE = 10

    def initialize(merge_request)
      @merge_request = merge_request
    end

    def execute
      diffs = @merge_request.non_latest_diffs.with_files

      diffs.each_batch(of: BATCH_SIZE) do |relation, index|
        ids = relation.pluck_primary_key.map { |id| [id] }
        DeleteDiffFilesWorker.bulk_perform_in(index * 5.minutes, ids) # rubocop:disable Scalability/BulkPerformWithContext
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::DeleteNonLatestDiffsService, :clean_gitlab_redis_shared_state,
  feature_category: :code_review_workflow do
  let(:merge_request) { create(:merge_request) }

  let!(:subject) { described_class.new(merge_request) }

  describe '#execute' do
    before do
      stub_const(""#{described_class.name}::BATCH_SIZE"", 2)

      3.times { merge_request.create_merge_request_diff }
      merge_request.create_merge_head_diff
      merge_request.reset
    end

    it 'schedules non-latest merge request diffs removal',
      quarantine: 'https://gitlab.com/gitlab-org/gitlab/-/issues/426807' do
      diffs = merge_request.merge_request_diffs

      expect(diffs.count).to eq(4)

      freeze_time do
        expect(DeleteDiffFilesWorker)
          .to receive(:bulk_perform_in)
          .with(5.minutes, [[diffs.first.id], [diffs.second.id]])
        expect(DeleteDiffFilesWorker)
          .to receive(:bulk_perform_in)
          .with(10.minutes, [[diffs.third.id]])

        subject.execute
      end
    end

    it 'schedules no removal if it is already cleaned' do
      merge_request.merge_request_diffs.each(&:clean!)

      expect(DeleteDiffFilesWorker).not_to receive(:bulk_perform_in)

      subject.execute
    end

    it 'schedules no removal if it is empty' do
      merge_request.merge_request_diffs.each { |diff| diff.update!(state: :empty) }

      expect(DeleteDiffFilesWorker).not_to receive(:bulk_perform_in)

      subject.execute
    end

    it 'schedules no removal if there is no non-latest diffs' do
      # rubocop: disable Cop/DestroyAll
      merge_request
        .merge_request_diffs
        .where.not(id: merge_request.latest_merge_request_diff_id)
        .destroy_all
      # rubocop: enable Cop/DestroyAll

      expect(DeleteDiffFilesWorker).not_to receive(:bulk_perform_in)

      subject.execute
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class AddSpentTimeService < UpdateService
    def execute(merge_request)
      old_associations = { total_time_spent: merge_request.total_time_spent }

      merge_request.spend_time(params[:spend_time])

      merge_request_saved = merge_request.with_transaction_returning_status do
        merge_request.save
      end

      if merge_request_saved
        create_system_notes(merge_request)

        # track usage
        track_time_spend_edits(merge_request, old_associations[:total_time_spent])

        execute_hooks(merge_request, 'update', old_associations: old_associations)
      end

      merge_request
    end

    private

    def track_time_spend_edits(merge_request, old_total_time_spent)
      if old_total_time_spent != merge_request.total_time_spent
        merge_request_activity_counter.track_time_spent_changed_action(user: current_user)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::AddSpentTimeService, feature_category: :code_review_workflow do
  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project, :public, :repository) }
  let_it_be_with_reload(:merge_request) { create(:merge_request, :simple, :unique_branches, source_project: project) }

  let(:duration) { 1500 }
  let(:params) { { spend_time: { duration: duration, summary: 'summary', user_id: user.id } } }
  let(:service) { described_class.new(project: project, current_user: user, params: params) }

  describe '#execute' do
    before do
      project.add_developer(user)
    end

    it 'creates a new timelog with the specified duration and summary' do
      expect { service.execute(merge_request) }.to change { Timelog.count }.from(0).to(1)

      timelog = merge_request.timelogs.last

      expect(timelog).not_to be_nil
      expect(timelog.time_spent).to eq(1500)
      expect(timelog.summary).to eq('summary')
    end

    it 'creates a system note with the time added' do
      expect { service.execute(merge_request) }.to change { Note.count }.from(0).to(1)

      system_note = merge_request.notes.last

      expect(system_note).not_to be_nil
      expect(system_note.note_html).to include('added 25m of time spent')
    end

    it 'saves usage data' do
      expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
        .to receive(:track_time_spent_changed_action).once.with(user: user)

      service.execute(merge_request)
    end

    it 'is more efficient than using the full update-service' do
      other_mr = create(:merge_request, :simple, :unique_branches, source_project: project)

      update_service = ::MergeRequests::UpdateService.new(project: project, current_user: user, params: params)
      other_mr.reload

      expect { service.execute(merge_request) }
        .to issue_fewer_queries_than { update_service.execute(other_mr) }
    end

    context 'when duration is nil' do
      let(:duration) { nil }

      it 'does not create a timelog with the specified duration' do
        expect { service.execute(merge_request) }.not_to change { Timelog.count }
        expect(merge_request).not_to be_valid
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class UpdateReviewersService < UpdateService
    def execute(merge_request)
      return merge_request unless current_user&.can?(:update_merge_request, merge_request)

      old_reviewers = merge_request.reviewers.to_a
      old_ids = old_reviewers.map(&:id)
      new_ids = new_user_ids(merge_request, update_attrs[:reviewer_ids], :reviewers)

      return merge_request if merge_request.errors.any?
      return merge_request if new_ids.size != update_attrs[:reviewer_ids].size
      return merge_request if old_ids.to_set == new_ids.to_set # no-change

      merge_request.update!(update_attrs.merge(reviewer_ids: new_ids))
      handle_reviewers_change(merge_request, old_reviewers)
      resolve_todos_for(merge_request)
      execute_reviewers_hooks(merge_request, old_reviewers)

      merge_request
    end

    private

    def reviewer_ids
      filter_sentinel_values(params.fetch(:reviewer_ids)).first(1)
    end

    def update_attrs
      @attrs ||= { updated_by: current_user, reviewer_ids: reviewer_ids }
    end

    def execute_reviewers_hooks(merge_request, old_reviewers)
      execute_hooks(
        merge_request,
        'update',
        old_associations: { reviewers: old_reviewers }
      )
    end
  end
end

MergeRequests::UpdateReviewersService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::UpdateReviewersService, feature_category: :code_review_workflow do
  include AfterNextHelpers

  let_it_be(:group) { create(:group, :public) }
  let_it_be(:project) { create(:project, :private, :repository, group: group) }
  let_it_be(:user) { create(:user) }
  let_it_be(:user2) { create(:user) }
  let_it_be(:user3) { create(:user) }

  let_it_be_with_reload(:merge_request) do
    create(
      :merge_request,
      :simple,
      :unique_branches,
      title: 'Old title',
      description: ""FYI #{user2.to_reference}"",
      reviewer_ids: [user3.id],
      source_project: project,
      target_project: project,
      author: create(:user)
    )
  end

  before do
    project.add_maintainer(user)
    project.add_developer(user2)
    project.add_developer(user3)
    merge_request.errors.clear
  end

  let(:service) { described_class.new(project: project, current_user: user, params: opts) }
  let(:opts) { { reviewer_ids: [user2.id] } }

  describe 'execute' do
    def set_reviewers
      service.execute(merge_request)
    end

    def find_note(starting_with)
      merge_request.notes.find do |note|
        note && note.note.start_with?(starting_with)
      end
    end

    shared_examples 'removing all reviewers' do
      it 'removes all reviewers' do
        expect(set_reviewers).to have_attributes(reviewers: be_empty, errors: be_none)
      end
    end

    context 'when the parameters are valid' do
      context 'when using sentinel values' do
        let(:opts) { { reviewer_ids: [0] } }

        it_behaves_like 'removing all reviewers'
      end

      context 'when the reviewer_ids parameter is the empty list' do
        let(:opts) { { reviewer_ids: [] } }

        it_behaves_like 'removing all reviewers'
      end

      it 'updates the MR' do
        expect { set_reviewers }
          .to change { merge_request.reload.reviewers }.from([user3]).to([user2])
          .and change(merge_request, :updated_at)
          .and change(merge_request, :updated_by).to(user)
      end

      it 'creates system note about merge_request review request' do
        set_reviewers

        note = find_note('requested review from')

        expect(note).not_to be_nil
        expect(note.note).to include ""requested review from #{user2.to_reference}""
      end

      it 'creates a pending todo for new review request' do
        set_reviewers

        attributes = {
          project: project,
          author: user,
          user: user2,
          target_id: merge_request.id,
          target_type: merge_request.class.name,
          action: Todo::REVIEW_REQUESTED,
          state: :pending
        }

        expect(Todo.where(attributes).count).to eq 1
      end

      it 'sends email reviewer change notifications to old and new reviewers', :sidekiq_inline, :mailer do
        perform_enqueued_jobs do
          set_reviewers
        end

        should_email(user2)
        should_email(user3)
      end

      it 'updates open merge request counter for reviewers', :use_clean_rails_memory_store_caching do
        # Cache them to ensure the cache gets invalidated on update
        expect(user2.review_requested_open_merge_requests_count).to eq(0)
        expect(user3.review_requested_open_merge_requests_count).to eq(1)

        set_reviewers

        expect(user2.review_requested_open_merge_requests_count).to eq(1)
        expect(user3.review_requested_open_merge_requests_count).to eq(0)
      end

      it 'updates the tracking' do
        expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
          .to receive(:track_users_review_requested)
          .with(users: [user2])

        set_reviewers
      end

      it 'tracks reviewers changed event' do
        expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
          .to receive(:track_reviewers_changed_action).once.with(user: user)

        set_reviewers
      end

      it_behaves_like 'triggers GraphQL subscription mergeRequestReviewersUpdated' do
        let(:action) { set_reviewers }
      end

      it 'calls MergeRequest::ResolveTodosService#async_execute' do
        expect_next_instance_of(MergeRequests::ResolveTodosService, merge_request, user) do |service|
          expect(service).to receive(:async_execute)
        end

        set_reviewers
      end

      it 'executes hooks with update action' do
        expect(service).to receive(:execute_hooks)
          .with(
            merge_request,
            'update',
            old_associations: {
              reviewers: [user3]
            }
          )

        set_reviewers
      end

      context 'when reviewers did not change' do
        let(:opts) { { reviewer_ids: merge_request.reviewer_ids } }

        it_behaves_like 'does not trigger GraphQL subscription mergeRequestReviewersUpdated' do
          let(:action) { set_reviewers }
        end
      end

      it 'does not update the reviewers if they do not have access' do
        opts[:reviewer_ids] = [create(:user).id]

        expect(set_reviewers).to have_attributes(
          reviewers: [user3],
          errors: be_any
        )
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class PushOptionsHandlerService < ::BaseProjectService
    LIMIT = 10

    attr_reader :errors, :changes, :push_options, :target_project

    def initialize(project:, current_user:, changes:, push_options:, params: {})
      super(project: project, current_user: current_user, params: params)

      @target_project = if push_options[:target_project]
                          Project.find_by_full_path(push_options[:target_project])
                        else
                          @project.default_merge_request_target
                        end

      @changes = Gitlab::ChangesList.new(changes)
      @push_options = push_options
      @errors = []
    end

    def execute
      validate_service
      return self if errors.present?

      branches.each do |branch|
        execute_for_branch(branch)
      rescue Gitlab::Access::AccessDeniedError
        errors << 'User access was denied'
      rescue StandardError => e
        Gitlab::AppLogger.error(e)
        errors << 'An unknown error occurred'
      end

      self
    end

    private

    def branches
      changes_by_branch.keys
    end

    def changes_by_branch
      @changes_by_branch ||= changes.each_with_object({}) do |changes, result|
        next unless Gitlab::Git.branch_ref?(changes[:ref])

        # Deleted branch
        next if Gitlab::Git.blank_ref?(changes[:newrev])

        # Default branch
        branch_name = Gitlab::Git.branch_name(changes[:ref])
        next if branch_name == target_project.default_branch

        result[branch_name] = changes
      end
    end

    def validate_service
      if current_user.nil?
        errors << 'User is required'
        return
      end

      unless current_user&.can?(:read_code, target_project)
        errors << 'User access was denied'
        return
      end

      unless project == target_project || project.in_fork_network_of?(target_project)
        errors << ""Projects #{project.full_path} and #{target_project.full_path} are not in the same network""
      end

      unless target_project.merge_requests_enabled?
        errors << ""Merge requests are not enabled for project #{target_project.full_path}""
      end

      if branches.size > LIMIT
        errors << ""Too many branches pushed (#{branches.size} were pushed, limit is #{LIMIT})""
      end

      if push_options[:target] && !target_project.repository.branch_exists?(push_options[:target])
        errors << ""Target branch #{target_project.full_path}:#{push_options[:target]} does not exist""
      end
    end

    # Returns a Hash of branch => MergeRequest
    def merge_requests
      @merge_requests ||= MergeRequest.from_project(target_project)
                                      .opened
                                      .from_source_branches(branches)
                                      .index_by(&:source_branch)
    end

    def execute_for_branch(branch)
      merge_request = merge_requests[branch]

      if merge_request
        update!(merge_request)
      else
        create!(branch)
      end
    end

    def create!(branch)
      unless push_options[:create]
        errors << ""A merge_request.create push option is required to create a merge request for branch #{branch}""
        return
      end

      # Use BuildService to assign the standard attributes of a merge request
      merge_request = ::MergeRequests::BuildService.new(
        project: project,
        current_user: current_user,
        params: create_params(branch)
      ).execute

      unless merge_request.errors.present?
        merge_request = ::MergeRequests::CreateService.new(
          project: project,
          current_user: current_user,
          params: merge_request.attributes.merge(
            assignee_ids: merge_request.assignee_ids,
            label_ids: merge_request.label_ids
          )
        ).execute
      end

      collect_errors_from_merge_request(merge_request) unless merge_request.persisted?
    end

    def update!(merge_request)
      merge_request = ::MergeRequests::UpdateService.new(
        project: target_project,
        current_user: current_user,
        params: update_params(merge_request)
      ).execute(merge_request)

      collect_errors_from_merge_request(merge_request) unless merge_request.valid?
    end

    def base_params
      params = {
        title: push_options[:title],
        description: push_options[:description],
        draft: push_options[:draft],
        target_branch: push_options[:target],
        force_remove_source_branch: push_options[:remove_source_branch],
        label: push_options[:label],
        unlabel: push_options[:unlabel],
        assign: push_options[:assign],
        unassign: push_options[:unassign]
      }

      params.compact!

      params[:add_labels] = params.delete(:label).keys if params.has_key?(:label)
      params[:remove_labels] = params.delete(:unlabel).keys if params.has_key?(:unlabel)

      params[:add_assignee_ids] = convert_to_user_ids(params.delete(:assign).keys) if params.has_key?(:assign)
      params[:remove_assignee_ids] = convert_to_user_ids(params.delete(:unassign).keys) if params.has_key?(:unassign)

      if push_options[:milestone]
        milestone = Milestone.for_projects_and_groups(@project, @project.ancestors_upto)&.find_by_name(push_options[:milestone])
        params[:milestone_id] = milestone.id if milestone
      end

      if params.key?(:description)
        params[:description] = params[:description].gsub('\n', ""\n"")
      end

      params
    end

    def merge_params(branch)
      return {} unless push_options.key?(:merge_when_pipeline_succeeds)

      {
        merge_when_pipeline_succeeds: push_options[:merge_when_pipeline_succeeds],
        merge_user: current_user,
        sha: changes_by_branch.dig(branch, :newrev)
      }
    end

    def create_params(branch)
      params = base_params

      params.merge!(
        assignee_ids: [current_user.id],
        source_branch: branch,
        source_project: project,
        target_project: target_project
      )

      params.merge!(merge_params(branch))

      params[:target_branch] ||= target_project.default_branch

      params
    end

    def update_params(merge_request)
      base_params.merge(merge_params(merge_request.source_branch))
    end

    def convert_to_user_ids(ids_or_usernames)
      ids, usernames = ids_or_usernames.partition { |id_or_username| id_or_username.is_a?(Numeric) || id_or_username.match?(/\A\d+\z/) }
      ids += User.by_username(usernames).pluck(:id) unless usernames.empty? # rubocop:disable CodeReuse/ActiveRecord
      ids
    end

    def collect_errors_from_merge_request(merge_request)
      merge_request.errors.full_messages.each do |error|
        errors << error
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::PushOptionsHandlerService, feature_category: :source_code_management do
  include ProjectForksHelper

  let_it_be(:parent_group) { create(:group, :public) }
  let_it_be(:child_group) { create(:group, :public, parent: parent_group) }
  let_it_be(:project) { create(:project, :public, :repository, group: child_group) }
  let_it_be(:user1) { create(:user, developer_projects: [project]) }
  let_it_be(:user2) { create(:user, developer_projects: [project]) }
  let_it_be(:user3) { create(:user, developer_projects: [project]) }
  let_it_be(:forked_project) { fork_project(project, user1, repository: true) }
  let_it_be(:parent_group_milestone) { create(:milestone, group: parent_group, title: 'ParentGroupMilestone1.0') }
  let_it_be(:child_group_milestone) { create(:milestone, group: child_group, title: 'ChildGroupMilestone1.0') }
  let_it_be(:project_milestone) { create(:milestone, project: project, title: 'ProjectMilestone1.0') }

  let(:service) { described_class.new(project: project, current_user: user1, changes: changes, push_options: push_options) }
  let(:source_branch) { 'fix' }
  let(:target_branch) { 'feature' }
  let(:title) { 'my title' }
  let(:draft_title) { 'Draft: my title' }
  let(:draft) { true }
  let(:description) { 'my description' }
  let(:multiline_description) do
    <<~MD.chomp
      Line 1
      Line 2
      Line 3
    MD
  end

  let(:label1) { 'mylabel1' }
  let(:label2) { 'mylabel2' }
  let(:label3) { 'mylabel3' }
  let(:new_branch_changes) { ""#{Gitlab::Git::BLANK_SHA} 570e7b2abdd848b95f2f578043fc23bd6f6fd24d refs/heads/#{source_branch}"" }
  let(:existing_branch_changes) { ""d14d6c0abdd253381df51a723d58691b2ee1ab08 570e7b2abdd848b95f2f578043fc23bd6f6fd24d refs/heads/#{source_branch}"" }
  let(:deleted_branch_changes) { ""d14d6c0abdd253381df51a723d58691b2ee1ab08 #{Gitlab::Git::BLANK_SHA} refs/heads/#{source_branch}"" }
  let(:default_branch_changes) { ""d14d6c0abdd253381df51a723d58691b2ee1ab08 570e7b2abdd848b95f2f578043fc23bd6f6fd24d refs/heads/#{project.default_branch}"" }
  let(:error_mr_required) { ""A merge_request.create push option is required to create a merge request for branch #{source_branch}"" }

  before do
    stub_licensed_features(multiple_merge_request_assignees: false)
  end

  shared_examples_for 'a service that can set the target of a merge request' do
    subject(:last_mr) { MergeRequest.last }

    it 'sets the target_branch' do
      service.execute

      expect(last_mr.target_branch).to eq(target_branch)
    end
  end

  shared_examples_for 'a service that can set the target project of a merge request' do
    subject(:last_mr) { MergeRequest.last }

    it 'creates a merge request with the correct target project' do
      project_path = push_options[:target_project] || project.default_merge_request_target.full_path

      expect { service.execute }.to change { MergeRequest.count }.by(1)
      expect(last_mr.target_project.full_path).to eq(project_path)
    end
  end

  shared_examples_for 'a service that can set the title of a merge request' do
    subject(:last_mr) { MergeRequest.last }

    it 'sets the title' do
      service.execute

      expect(last_mr.title).to eq(title)
    end
  end

  shared_examples_for 'a service that can set the description of a merge request' do
    subject(:last_mr) { MergeRequest.last }

    it 'sets the description' do
      service.execute

      expect(last_mr.description).to eq(description)
    end
  end

  shared_examples_for 'a service that can set the multiline description of a merge request' do
    subject(:last_mr) { MergeRequest.last }

    it 'sets the multiline description' do
      service.execute

      expect(last_mr.description).to eq(multiline_description)
    end
  end

  shared_examples_for 'a service that can set the draft of a merge request' do
    subject(:last_mr) { MergeRequest.last }

    it 'sets the draft' do
      service.execute

      expect(last_mr.draft).to eq(draft)
    end
  end

  shared_examples_for 'a service that can set the milestone of a merge request' do
    subject(:last_mr) { MergeRequest.last }

    it 'sets the milestone' do
      service.execute

      expect(last_mr.milestone&.title).to eq(expected_milestone)
    end
  end

  shared_examples_for 'a service that can set the merge request to merge when pipeline succeeds' do
    subject(:last_mr) { MergeRequest.last }

    let(:change) { Gitlab::ChangesList.new(changes).changes.first }

    it 'sets auto_merge_enabled' do
      service.execute

      expect(last_mr.auto_merge_enabled).to eq(true)
      expect(last_mr.auto_merge_strategy).to eq(AutoMergeService::STRATEGY_MERGE_WHEN_PIPELINE_SUCCEEDS)
      expect(last_mr.merge_user).to eq(user1)
      expect(last_mr.merge_params['sha']).to eq(change[:newrev])
    end
  end

  shared_examples_for 'a service that can remove the source branch when it is merged' do
    subject(:last_mr) { MergeRequest.last }

    it 'returns true to force_remove_source_branch?' do
      service.execute

      expect(last_mr.force_remove_source_branch?).to eq(true)
    end
  end

  shared_examples_for 'a service that can change labels of a merge request' do |count|
    subject(:last_mr) { MergeRequest.last }

    it 'changes label count' do
      service.execute

      expect(last_mr.label_ids.count).to eq(count)
    end
  end

  shared_examples_for 'a service that does not update a merge request' do
    it do
      expect { service.execute }.not_to change { MergeRequest.maximum(:updated_at) }
    end
  end

  shared_examples_for 'a service that does nothing' do
    include_examples 'a service that does not create a merge request'
    include_examples 'a service that does not update a merge request'
  end

  shared_examples 'with a deleted branch' do
    let(:changes) { deleted_branch_changes }

    it_behaves_like 'a service that does nothing'
  end

  shared_examples 'with the project default branch' do
    let(:changes) { default_branch_changes }

    it_behaves_like 'a service that does nothing'
  end

  describe '`create` push option' do
    let(:push_options) { { create: true } }

    context 'with a new branch' do
      let(:changes) { new_branch_changes }

      it_behaves_like 'a service that can create a merge request'
    end

    context 'with an existing branch but no open MR' do
      let(:changes) { existing_branch_changes }

      it_behaves_like 'a service that can create a merge request'
    end

    context 'with an existing branch that has a merge request open' do
      let(:changes) { existing_branch_changes }
      let!(:merge_request) { create(:merge_request, source_project: project, source_branch: source_branch) }

      it_behaves_like 'a service that does not create a merge request'
    end

    it_behaves_like 'with a deleted branch'
    it_behaves_like 'with the project default branch'
  end

  describe '`merge_when_pipeline_succeeds` push option' do
    let(:push_options) { { merge_when_pipeline_succeeds: true } }

    context 'with a new branch' do
      let(:changes) { new_branch_changes }

      it_behaves_like 'a service that does not create a merge request'

      it 'adds an error to the service' do
        service.execute

        expect(service.errors).to include(error_mr_required)
      end

      context 'when coupled with the `create` push option' do
        let(:push_options) { { create: true, merge_when_pipeline_succeeds: true } }

        it_behaves_like 'a service that can create a merge request'
        it_behaves_like 'a service that can set the merge request to merge when pipeline succeeds'
      end
    end

    context 'with an existing branch but no open MR' do
      let(:changes) { existing_branch_changes }

      it_behaves_like 'a service that does not create a merge request'

      it 'adds an error to the service' do
        service.execute

        expect(service.errors).to include(error_mr_required)
      end

      context 'when coupled with the `create` push option' do
        let(:push_options) { { create: true, merge_when_pipeline_succeeds: true } }

        it_behaves_like 'a service that can create a merge request'
        it_behaves_like 'a service that can set the merge request to merge when pipeline succeeds'
      end
    end

    context 'with an existing branch that has a merge request open' do
      let(:changes) { existing_branch_changes }
      let!(:merge_request) { create(:merge_request, source_project: project, source_branch: source_branch) }

      it_behaves_like 'a service that does not create a merge request'
      it_behaves_like 'a service that can set the merge request to merge when pipeline succeeds'
    end

    it_behaves_like 'with a deleted branch'
    it_behaves_like 'with the project default branch'
  end

  describe '`remove_source_branch` push option' do
    let(:push_options) { { remove_source_branch: true } }

    context 'with a new branch' do
      let(:changes) { new_branch_changes }

      it_behaves_like 'a service that does not create a merge request'

      it 'adds an error to the service' do
        service.execute

        expect(service.errors).to include(error_mr_required)
      end

      context 'when coupled with the `create` push option' do
        let(:push_options) { { create: true, remove_source_branch: true } }

        it_behaves_like 'a service that can create a merge request'
        it_behaves_like 'a service that can remove the source branch when it is merged'
      end
    end

    context 'with an existing branch but no open MR' do
      let(:changes) { existing_branch_changes }

      it_behaves_like 'a service that does not create a merge request'

      it 'adds an error to the service' do
        service.execute

        expect(service.errors).to include(error_mr_required)
      end

      context 'when coupled with the `create` push option' do
        let(:push_options) { { create: true, remove_source_branch: true } }

        it_behaves_like 'a service that can create a merge request'
        it_behaves_like 'a service that can remove the source branch when it is merged'
      end
    end

    context 'with an existing branch that has a merge request open' do
      let(:changes) { existing_branch_changes }
      let!(:merge_request) { create(:merge_request, source_project: project, source_branch: source_branch) }

      it_behaves_like 'a service that does not create a merge request'
      it_behaves_like 'a service that can remove the source branch when it is merged'
    end

    it_behaves_like 'with a deleted branch'
    it_behaves_like 'with the project default branch'
  end

  describe '`target` push option' do
    let(:push_options) { { target: target_branch } }

    context 'with a new branch' do
      let(:changes) { new_branch_changes }

      it_behaves_like 'a service that does not create a merge request'

      it 'adds an error to the service' do
        service.execute

        expect(service.errors).to include(error_mr_required)
      end

      context 'when coupled with the `create` push option' do
        let(:push_options) { { create: true, target: target_branch } }

        it_behaves_like 'a service that can create a merge request'
        it_behaves_like 'a service that can set the target of a merge request'
      end
    end

    context 'with an existing branch but no open MR' do
      let(:changes) { existing_branch_changes }

      it_behaves_like 'a service that does not create a merge request'

      it 'adds an error to the service' do
        service.execute

        expect(service.errors).to include(error_mr_required)
      end

      context 'when coupled with the `create` push option' do
        let(:push_options) { { create: true, target: target_branch } }

        it_behaves_like 'a service that can create a merge request'
        it_behaves_like 'a service that can set the target of a merge request'
      end
    end

    context 'with an existing branch that has a merge request open' do
      let(:changes) { existing_branch_changes }
      let!(:merge_request) { create(:merge_request, source_project: project, source_branch: source_branch) }

      it_behaves_like 'a service that does not create a merge request'
      it_behaves_like 'a service that can set the target of a merge request'
    end

    it_behaves_like 'with a deleted branch'
    it_behaves_like 'with the project default branch'
  end

  describe '`target_project` push option' do
    let(:changes) { new_branch_changes }
    let(:double_forked_project) { fork_project(forked_project, user1, repository: true) }
    let(:service) { described_class.new(project: double_forked_project, current_user: user1, changes: changes, push_options: push_options) }
    let(:push_options) { { create: true, target_project: target_project.full_path } }

    context 'to self' do
      let(:target_project) { double_forked_project }

      it_behaves_like 'a service that can set the target project of a merge request'
    end

    context 'to intermediate project' do
      let(:target_project) { forked_project }

      it_behaves_like 'a service that can set the target project of a merge request'
    end

    context 'to base project' do
      let(:target_project) { project }

      it_behaves_like 'a service that can set the target project of a merge request'
    end
  end

  describe '`title` push option' do
    let(:push_options) { { title: title } }

    context 'with a new branch' do
      let(:changes) { new_branch_changes }

      it_behaves_like 'a service that does not create a merge request'

      it 'adds an error to the service' do
        service.execute

        expect(service.errors).to include(error_mr_required)
      end

      context 'when coupled with the `create` push option' do
        let(:push_options) { { create: true, title: title } }

        it_behaves_like 'a service that can create a merge request'
        it_behaves_like 'a service that can set the title of a merge request'
      end
    end

    context 'with an existing branch but no open MR' do
      let(:changes) { existing_branch_changes }

      it_behaves_like 'a service that does not create a merge request'

      it 'adds an error to the service' do
        service.execute

        expect(service.errors).to include(error_mr_required)
      end

      context 'when coupled with the `create` push option' do
        let(:push_options) { { create: true, title: title } }

        it_behaves_like 'a service that can create a merge request'
        it_behaves_like 'a service that can set the title of a merge request'
      end
    end

    context 'with an existing branch that has a merge request open' do
      let(:changes) { existing_branch_changes }
      let!(:merge_request) { create(:merge_request, source_project: project, source_branch: source_branch) }

      it_behaves_like 'a service that does not create a merge request'
      it_behaves_like 'a service that can set the title of a merge request'
    end

    it_behaves_like 'with a deleted branch'
    it_behaves_like 'with the project default branch'
  end

  describe '`description` push option' do
    let(:push_options) { { description: description } }

    context 'with a new branch' do
      let(:changes) { new_branch_changes }

      it_behaves_like 'a service that does not create a merge request'

      it 'adds an error to the service' do
        service.execute

        expect(service.errors).to include(error_mr_required)
      end

      context 'when coupled with the `create` push option' do
        let(:push_options) { { create: true, description: description } }

        it_behaves_like 'a service that can create a merge request'
        it_behaves_like 'a service that can set the description of a merge request'
      end
    end

    context 'with an existing branch but no open MR' do
      let(:changes) { existing_branch_changes }

      it_behaves_like 'a service that does not create a merge request'

      it 'adds an error to the service' do
        service.execute

        expect(service.errors).to include(error_mr_required)
      end

      context 'when coupled with the `create` push option' do
        let(:push_options) { { create: true, description: description } }

        it_behaves_like 'a service that can create a merge request'
        it_behaves_like 'a service that can set the description of a merge request'
      end
    end

    context 'with an existing branch that has a merge request open' do
      let(:changes) { existing_branch_changes }
      let!(:merge_request) { create(:merge_request, source_project: project, source_branch: source_branch) }

      it_behaves_like 'a service that does not create a merge request'
      it_behaves_like 'a service that can set the description of a merge request'

      context 'with a multiline description' do
        let(:push_options) { { description: ""Line 1\\nLine 2\\nLine 3"" } }

        it_behaves_like 'a service that does not create a merge request'
        it_behaves_like 'a service that can set the multiline description of a merge request'
      end
    end

    it_behaves_like 'with a deleted branch'
    it_behaves_like 'with the project default branch'
  end

  describe '`draft` push option' do
    let(:push_options) { { draft: draft } }

    context 'with a new branch' do
      let(:changes) { new_branch_changes }

      it_behaves_like 'a service that does not create a merge request'

      it 'adds an error to the service' do
        service.execute

        expect(service.errors).to include(error_mr_required)
      end

      context 'when coupled with the `create` push option' do
        let(:push_options) { { create: true, draft: draft } }

        it_behaves_like 'a service that can create a merge request'
        it_behaves_like 'a service that can set the draft of a merge request'
      end
    end

    context 'with an existing branch but no open MR' do
      let(:changes) { existing_branch_changes }

      it_behaves_like 'a service that does not create a merge request'

      it 'adds an error to the service' do
        service.execute

        expect(service.errors).to include(error_mr_required)
      end

      context 'when coupled with the `create` push option' do
        let(:push_options) { { create: true, draft: draft } }

        it_behaves_like 'a service that can create a merge request'
        it_behaves_like 'a service that can set the draft of a merge request'
      end
    end

    context 'with an existing branch that has a merge request open' do
      let(:changes) { existing_branch_changes }
      let!(:merge_request) { create(:merge_request, source_project: project, source_branch: source_branch) }

      it_behaves_like 'a service that does not create a merge request'
      it_behaves_like 'a service that can set the draft of a merge request'
    end

    context 'draft title provided while `draft` push option is set to false' do
      let(:push_options) { { create: true, draft: false, title: draft_title } }
      let(:changes) { new_branch_changes }

      it_behaves_like 'a service that can create a merge request'
      it_behaves_like 'a service that can set the draft of a merge request'
    end

    it_behaves_like 'with a deleted branch'
    it_behaves_like 'with the project default branch'
  end

  describe '`label` push option' do
    let(:push_options) { { label: { label1 => 1, label2 => 1 } } }

    context 'with a new branch' do
      let(:changes) { new_branch_changes }

      it_behaves_like 'a service that does not create a merge request'

      it 'adds an error to the service' do
        service.execute

        expect(service.errors).to include(error_mr_required)
      end

      context 'when coupled with the `create` push option' do
        let(:push_options) { { create: true, label: { label1 => 1, label2 => 1 } } }

        it_behaves_like 'a service that can create a merge request'
        it_behaves_like 'a service that can change labels of a merge request', 2
      end
    end

    context 'with an existing branch but no open MR' do
      let(:changes) { existing_branch_changes }

      it_behaves_like 'a service that does not create a merge request'

      it 'adds an error to the service' do
        service.execute

        expect(service.errors).to include(error_mr_required)
      end

      context 'when coupled with the `create` push option' do
        let(:push_options) { { create: true, label: { label1 => 1, label2 => 1 } } }

        it_behaves_like 'a service that can create a merge request'
        it_behaves_like 'a service that can change labels of a merge request', 2
      end
    end

    context 'with an existing branch that has a merge request open' do
      let(:changes) { existing_branch_changes }
      let!(:merge_request) { create(:merge_request, source_project: project, source_branch: source_branch) }

      it_behaves_like 'a service that does not create a merge request'
      it_behaves_like 'a service that can change labels of a merge request', 2
    end

    it_behaves_like 'with a deleted branch'
    it_behaves_like 'with the project default branch'
  end

  describe '`unlabel` push option' do
    let(:push_options) { { label: { label1 => 1, label2 => 1 }, unlabel: { label1 => 1, label3 => 1 } } }

    context 'with a new branch' do
      let(:changes) { new_branch_changes }

      it_behaves_like 'a service that does not create a merge request'

      it 'adds an error to the service' do
        service.execute

        expect(service.errors).to include(error_mr_required)
      end

      context 'when coupled with the `create` push option' do
        let(:push_options) { { create: true, label: { label1 => 1, label2 => 1 }, unlabel: { label1 => 1, label3 => 1 } } }

        it_behaves_like 'a service that can create a merge request'
        it_behaves_like 'a service that can change labels of a merge request', 1
      end
    end

    context 'with an existing branch but no open MR' do
      let(:changes) { existing_branch_changes }

      it_behaves_like 'a service that does not create a merge request'

      it 'adds an error to the service' do
        service.execute

        expect(service.errors).to include(error_mr_required)
      end

      context 'when coupled with the `create` push option' do
        let(:push_options) { { create: true, label: { label1 => 1, label2 => 1 }, unlabel: { label1 => 1, label3 => 1 } } }

        it_behaves_like 'a service that can create a merge request'
        it_behaves_like 'a service that can change labels of a merge request', 1
      end
    end

    context 'with an existing branch that has a merge request open' do
      let(:changes) { existing_branch_changes }
      let!(:merge_request) { create(:merge_request, source_project: project, source_branch: source_branch) }

      it_behaves_like 'a service that does not create a merge request'
      it_behaves_like 'a service that can change labels of a merge request', 1
    end

    it_behaves_like 'with a deleted branch'
    it_behaves_like 'with the project default branch'
  end

  describe '`milestone` push option' do
    context 'with a valid milestone' do
      let(:expected_milestone) { project_milestone.title }
      let(:push_options) { { milestone: project_milestone.title } }

      context 'with a new branch' do
        let(:changes) { new_branch_changes }

        it_behaves_like 'a service that does not create a merge request'

        it 'adds an error to the service' do
          service.execute

          expect(service.errors).to include(error_mr_required)
        end

        context 'when coupled with the `create` push option' do
          let(:push_options) { { create: true, milestone: project_milestone.title } }

          it_behaves_like 'a service that can create a merge request'
          it_behaves_like 'a service that can set the milestone of a merge request'
        end
      end

      context 'with an existing branch but no open MR' do
        let(:changes) { existing_branch_changes }

        it_behaves_like 'a service that does not create a merge request'

        it 'adds an error to the service' do
          service.execute

          expect(service.errors).to include(error_mr_required)
        end

        context 'when coupled with the `create` push option' do
          let(:push_options) { { create: true, milestone: project_milestone.title } }

          it_behaves_like 'a service that can create a merge request'
          it_behaves_like 'a service that can set the milestone of a merge request'
        end
      end

      context 'with an existing branch that has a merge request open' do
        let(:changes) { existing_branch_changes }
        let!(:merge_request) { create(:merge_request, source_project: project, source_branch: source_branch) }

        it_behaves_like 'a service that does not create a merge request'
        it_behaves_like 'a service that can set the milestone of a merge request'
      end

      it_behaves_like 'with a deleted branch'
      it_behaves_like 'with the project default branch'
    end

    context 'with invalid milestone' do
      let(:expected_milestone) { nil }
      let(:changes) { new_branch_changes }
      let(:push_options) { { create: true, milestone: 'invalid_milestone' } }

      it_behaves_like 'a service that can set the milestone of a merge request'
    end

    context 'with an ancestor milestone' do
      let(:changes) { existing_branch_changes }

      context 'with immediate parent milestone' do
        let(:push_options) { { create: true, milestone: child_group_milestone.title } }
        let(:expected_milestone) { child_group_milestone.title }

        it_behaves_like 'a service that can create a merge request'
        it_behaves_like 'a service that can set the milestone of a merge request'
      end

      context 'with multi-level ancestor milestone' do
        let(:push_options) { { create: true, milestone: parent_group_milestone.title } }
        let(:expected_milestone) { parent_group_milestone.title }

        it_behaves_like 'a service that can create a merge request'
        it_behaves_like 'a service that can set the milestone of a merge request'
      end
    end
  end

  shared_examples 'with an existing branch that has a merge request open in foss' do
    let(:changes) { existing_branch_changes }
    let!(:merge_request) { create(:merge_request, source_project: project, source_branch: source_branch) }

    it_behaves_like 'a service that does not create a merge request'
    it_behaves_like 'a service that can change assignees of a merge request', 1
  end

  describe '`assign` push option' do
    let(:assigned) { { user2.id => 1, user3.id => 1 } }
    let(:unassigned) { nil }
    let(:push_options) { { assign: assigned, unassign: unassigned } }

    it_behaves_like 'with a new branch', 1
    it_behaves_like 'with an existing branch but no open MR', 1
    it_behaves_like 'with an existing branch that has a merge request open in foss'

    it_behaves_like 'with a deleted branch'
    it_behaves_like 'with the project default branch'

    context 'when passing in usernames' do
      # makes sure that usernames starting with numbers aren't treated as IDs
      let(:user2) { create(:user, username: '123user', developer_projects: [project]) }
      let(:user3) { create(:user, username: '999user', developer_projects: [project]) }
      let(:assigned) { { user2.username => 1, user3.username => 1 } }

      it_behaves_like 'with an existing branch that has a merge request open in foss'
    end
  end

  describe '`unassign` push option' do
    let(:assigned) { { user2.id => 1, user3.id => 1 } }
    let(:unassigned) { { user1.id => 1, user3.id => 1 } }
    let(:push_options) { { assign: assigned, unassign: unassigned } }

    it_behaves_like 'with a new branch', 1
    it_behaves_like 'with an existing branch but no open MR', 1
    it_behaves_like 'with an existing branch that has a merge request open in foss'

    it_behaves_like 'with a deleted branch'
    it_behaves_like 'with the project default branch'

    context 'when passing in usernames' do
      let(:assigned) { { user2.username => 1, user3.username => 1 } }
      let(:unassigned) { { user1.username => 1, user3.username => 1 } }

      it_behaves_like 'with an existing branch that has a merge request open in foss'
    end
  end

  describe 'multiple pushed branches' do
    let(:push_options) { { create: true } }
    let(:changes) do
      [
        new_branch_changes,
        ""#{Gitlab::Git::BLANK_SHA} 570e7b2abdd848b95f2f578043fc23bd6f6fd24d refs/heads/feature_conflict""
      ]
    end

    it 'creates a merge request per branch' do
      expect { service.execute }.to change { MergeRequest.count }.by(2)
    end

    context 'when there are too many pushed branches' do
      let(:limit) { MergeRequests::PushOptionsHandlerService::LIMIT }
      let(:changes) do
        TestEnv::BRANCH_SHA.to_a[0..limit].map do |x|
          ""#{Gitlab::Git::BLANK_SHA} #{x.first} refs/heads/#{x.last}""
        end
      end

      it 'records an error' do
        service.execute

        expect(service.errors).to eq([""Too many branches pushed (#{limit + 1} were pushed, limit is #{limit})""])
      end
    end
  end

  describe 'no push options' do
    let(:push_options) { {} }
    let(:changes) { new_branch_changes }

    it_behaves_like 'a service that does nothing'
  end

  describe 'no user' do
    let(:user1) { nil }
    let(:user2) { nil }
    let(:user3) { nil }
    let(:push_options) { { create: true } }
    let(:changes) { new_branch_changes }

    it 'records an error' do
      service.execute

      expect(service.errors).to eq(['User is required'])
    end
  end

  describe 'unauthorized user' do
    let(:push_options) { { create: true } }
    let(:changes) { new_branch_changes }

    it 'records an error', :sidekiq_inline do
      Members::DestroyService.new(user1).execute(ProjectMember.find_by!(user_id: user1.id))

      service.execute

      expect(service.errors).to eq(['User access was denied'])
    end
  end

  describe 'handling unexpected exceptions' do
    let(:push_options) { { create: true } }
    let(:changes) { new_branch_changes }
    let(:exception) { StandardError.new('My standard error') }

    def run_service_with_exception
      allow_next_instance_of(MergeRequests::BuildService) do |instance|
        allow(instance).to receive(:execute).and_raise(exception)
      end

      service.execute
    end

    it 'records an error' do
      run_service_with_exception

      expect(service.errors).to eq(['An unknown error occurred'])
    end

    it 'writes to Gitlab::AppLogger' do
      expect(Gitlab::AppLogger).to receive(:error).with(exception)

      run_service_with_exception
    end
  end

  describe 'when target is not a valid branch name' do
    let(:push_options) { { create: true, target: 'my-branch' } }
    let(:changes) { new_branch_changes }

    it 'records an error' do
      service.execute

      expect(service.errors).to eq([""Target branch #{project.full_path}:my-branch does not exist""])
    end
  end

  describe 'when the target project does not exist' do
    let(:push_options) { { create: true, target: 'my-branch', target_project: 'does-not-exist' } }
    let(:changes) { default_branch_changes }

    it 'records an error', :sidekiq_inline do
      service.execute

      expect(service.errors).to eq([""User access was denied""])
    end
  end

  describe 'when user does not have access to target project' do
    let(:push_options) { { create: true, target: 'my-branch' } }
    let(:changes) { default_branch_changes }

    before do
      allow(user1).to receive(:can?).with(:read_code, project).and_return(false)
    end

    it 'records an error', :sidekiq_inline do
      service.execute

      expect(service.errors).to eq([""User access was denied""])
    end
  end

  describe 'when MRs are not enabled' do
    let(:project) { create(:project, :public, :repository).tap { |pr| pr.add_developer(user1) } }
    let(:push_options) { { create: true } }
    let(:changes) { new_branch_changes }

    it 'records an error' do
      expect(project).to receive(:merge_requests_enabled?).and_return(false)

      service.execute

      expect(service.errors).to eq([""Merge requests are not enabled for project #{project.full_path}""])
    end
  end

  describe 'when projects are unrelated' do
    let(:unrelated_project) { create(:project, :public, :repository, group: child_group) }
    let(:push_options) { { create: true, target_project: unrelated_project.full_path } }
    let(:changes) { new_branch_changes }

    it 'records an error' do
      service.execute

      expect(service.errors).to eq([""Projects #{project.full_path} and #{unrelated_project.full_path} are not in the same network""])
    end
  end

  describe 'when MR has ActiveRecord errors' do
    let(:push_options) { { create: true } }
    let(:changes) { new_branch_changes }

    it 'adds the error to its errors property' do
      invalid_merge_request = MergeRequest.new
      invalid_merge_request.errors.add(:base, 'my error')

      expect_next_instance_of(MergeRequests::CreateService) do |instance|
        expect(instance).to receive(:execute).and_return(invalid_merge_request)
      end

      service.execute

      expect(service.errors).to eq(['my error'])
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class BaseService < ::IssuableBaseService
    extend ::Gitlab::Utils::Override
    include MergeRequests::AssignsMergeParams
    include MergeRequests::ErrorLogger

    delegate :repository, to: :project

    def initialize(project:, current_user: nil, params: {})
      super(container: project, current_user: current_user, params: params)
    end

    def create_note(merge_request, state = merge_request.state)
      SystemNoteService.change_status(merge_request, merge_request.target_project, current_user, state, nil)
    end

    def hook_data(merge_request, action, old_rev: nil, old_associations: {})
      hook_data = merge_request.to_hook_data(current_user, old_associations: old_associations)
      hook_data[:object_attributes][:action] = action
      if old_rev && !Gitlab::Git.blank_ref?(old_rev)
        hook_data[:object_attributes][:oldrev] = old_rev
      end

      hook_data
    end

    def execute_hooks(merge_request, action = 'open', old_rev: nil, old_associations: {})
      # NOTE: Due to the async merge request diffs generation, we need to skip this for CreateService and execute it in
      #   AfterCreateService instead so that the webhook consumers receive the update when diffs are ready.
      return if merge_request.skip_ensure_merge_request_diff

      merge_data = Gitlab::Lazy.new { hook_data(merge_request, action, old_rev: old_rev, old_associations: old_associations) }
      merge_request.project.execute_hooks(merge_data, :merge_request_hooks)
      merge_request.project.execute_integrations(merge_data, :merge_request_hooks)

      execute_external_hooks(merge_request, merge_data)
      execute_group_mention_hooks(merge_request, merge_data) if action == 'open'

      enqueue_jira_connect_messages_for(merge_request)
    end

    def execute_external_hooks(merge_request, merge_data)
      # Implemented in EE
    end

    def execute_group_mention_hooks(merge_request, merge_data)
      return unless merge_request.instance_of?(MergeRequest)

      args = {
        mentionable_type: 'MergeRequest',
        mentionable_id: merge_request.id,
        hook_data: merge_data,
        is_confidential: false
      }

      merge_request.run_after_commit_or_now do
        Integrations::GroupMentionWorker.perform_async(args)
      end
    end

    def handle_changes(merge_request, options)
      old_associations = options.fetch(:old_associations, {})
      old_assignees = old_associations.fetch(:assignees, [])
      old_reviewers = old_associations.fetch(:reviewers, [])

      handle_assignees_change(merge_request, old_assignees) if merge_request.assignees != old_assignees
      handle_reviewers_change(merge_request, old_reviewers) if merge_request.reviewers != old_reviewers
    end

    def handle_assignees_change(merge_request, old_assignees)
      MergeRequests::HandleAssigneesChangeService
        .new(project: project, current_user: current_user)
        .async_execute(merge_request, old_assignees)
    end

    def handle_reviewers_change(merge_request, old_reviewers)
      affected_reviewers = (old_reviewers + merge_request.reviewers) - (old_reviewers & merge_request.reviewers)
      create_reviewer_note(merge_request, old_reviewers)
      notification_service.async.changed_reviewer_of_merge_request(merge_request, current_user, old_reviewers)
      todo_service.reassigned_reviewable(merge_request, current_user, old_reviewers)
      invalidate_cache_counts(merge_request, users: affected_reviewers.compact)

      new_reviewers = merge_request.reviewers - old_reviewers
      merge_request_activity_counter.track_users_review_requested(users: new_reviewers)
      merge_request_activity_counter.track_reviewers_changed_action(user: current_user)
      trigger_merge_request_reviewers_updated(merge_request)

      capture_suggested_reviewers_accepted(merge_request)
    end

    def cleanup_environments(merge_request)
      Environments::StopService.new(merge_request.source_project, current_user)
                               .execute_for_merge_request_pipeline(merge_request)
    end

    def cancel_review_app_jobs!(merge_request)
      environments = merge_request.environments_in_head_pipeline.in_review_folder.available
      environments.each { |environment| environment.cancel_deployment_jobs! }
    end

    def source_project
      @source_project ||= merge_request.source_project
    end

    def target_project
      @target_project ||= merge_request.target_project
    end

    # Don't try to print expensive instance variables.
    def inspect
      return ""#<#{self.class}>"" unless respond_to?(:merge_request) && merge_request

      ""#<#{self.class} #{merge_request.to_reference(full: true)}>""
    end

    def merge_request_activity_counter
      Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter
    end

    def deactivate_pages_deployments(merge_request)
      Pages::DeactivateMrDeploymentsWorker.perform_async(merge_request)
    end

    private

    def self.constructor_container_arg(value)
      { project: value }
    end

    def refresh_pipelines_on_merge_requests(merge_request, allow_duplicate: false)
      create_pipeline_for(merge_request, current_user, async: true, allow_duplicate: allow_duplicate)
    end

    def enqueue_jira_connect_messages_for(merge_request)
      return unless project.jira_subscription_exists?

      if Atlassian::JiraIssueKeyExtractor.has_keys?(merge_request.title, merge_request.description)
        JiraConnect::SyncMergeRequestWorker.perform_async(merge_request.id, Atlassian::JiraConnect::Client.generate_update_sequence_id)
      end
    end

    def create(merge_request)
      self.params = assign_allowed_merge_params(merge_request, params)

      super
    end

    def update(merge_request)
      self.params = assign_allowed_merge_params(merge_request, params)

      super
    end

    override :handle_quick_actions
    def handle_quick_actions(merge_request)
      super
      handle_draft_event(merge_request)
    end

    def handle_draft_event(merge_request)
      if draft_event = params.delete(:wip_event)
        # We update the title that is provided in the params or we use the mr title
        title = params[:title] || merge_request.title
        params[:title] = case draft_event
                         when 'draft' then MergeRequest.draft_title(title)
                         when 'ready' then MergeRequest.draftless_title(title)
                         end
      end
    end

    def filter_params(merge_request)
      super

      unless merge_request.can_allow_collaboration?(current_user)
        params.delete(:allow_collaboration)
      end

      filter_reviewer(merge_request)
      filter_suggested_reviewers
    end

    def filter_reviewer(merge_request)
      return if params[:reviewer_ids].blank?

      unless can_admin_issuable?(merge_request)
        params.delete(:reviewer_ids)

        return
      end

      unless merge_request.allows_multiple_reviewers?
        params[:reviewer_ids] = params[:reviewer_ids].first(1)
      end

      reviewer_ids = params[:reviewer_ids].select { |reviewer_id| user_can_read?(merge_request, reviewer_id) }

      if params[:reviewer_ids].map(&:to_s) == [IssuableFinder::Params::NONE]
        params[:reviewer_ids] = []
      elsif reviewer_ids.any?
        params[:reviewer_ids] = reviewer_ids
      else
        params.delete(:reviewer_ids)
      end
    end

    def filter_suggested_reviewers
      # Implemented in EE
    end

    def merge_request_metrics_service(merge_request)
      MergeRequestMetricsService.new(merge_request.metrics)
    end

    def create_assignee_note(merge_request, old_assignees)
      SystemNoteService.change_issuable_assignees(
        merge_request, merge_request.project, current_user, old_assignees)
    end

    def create_reviewer_note(merge_request, old_reviewers)
      SystemNoteService.change_issuable_reviewers(
        merge_request, merge_request.project, current_user, old_reviewers)
    end

    def create_pipeline_for(merge_request, user, async: false, allow_duplicate: false)
      create_pipeline_params = params.slice(:push_options).merge(allow_duplicate: allow_duplicate)

      if async
        MergeRequests::CreatePipelineWorker.perform_async(
          project.id,
          user.id,
          merge_request.id,
          create_pipeline_params.deep_stringify_keys)
      else
        MergeRequests::CreatePipelineService
          .new(project: project, current_user: user, params: create_pipeline_params)
          .execute(merge_request)
      end
    end

    def abort_auto_merge(merge_request, reason)
      AutoMergeService.new(project, current_user).abort(merge_request, reason)
    end

    # Returns all origin and fork merge requests from `@project` satisfying passed arguments.
    # rubocop: disable CodeReuse/ActiveRecord
    def merge_requests_for(source_branch, mr_states: [:opened])
      @project.source_of_merge_requests
        .with_state(mr_states)
        .where(source_branch: source_branch)
        .preload(:source_project) # we don't need #includes since we're just preloading for the #select
        .select(&:source_project)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def pipeline_merge_requests(pipeline)
      pipeline.all_merge_requests.opened.each do |merge_request|
        next unless pipeline.id == merge_request.head_pipeline_id

        yield merge_request
      end
    end

    def trigger_merge_request_reviewers_updated(merge_request)
      GraphqlTriggers.merge_request_reviewers_updated(merge_request)
    end

    def trigger_merge_request_merge_status_updated(merge_request)
      GraphqlTriggers.merge_request_merge_status_updated(merge_request)
    end

    def trigger_merge_request_approval_state_updated(merge_request)
      GraphqlTriggers.merge_request_approval_state_updated(merge_request)
    end

    def capture_suggested_reviewers_accepted(merge_request)
      # Implemented in EE
    end
  end
end

MergeRequests::BaseService.prepend_mod_with('MergeRequests::BaseService')

```","# frozen_string_literal: true

require 'spec_helper'

module MergeRequests
  class ExampleService < MergeRequests::BaseService
    def execute(merge_request, async: false, allow_duplicate: false)
      create_pipeline_for(merge_request, current_user, async: async, allow_duplicate: allow_duplicate)
    end
  end
end

RSpec.describe MergeRequests::BaseService, feature_category: :code_review_workflow do
  include ProjectForksHelper

  let_it_be(:project) { create(:project, :repository) }

  let(:user) { project.first_owner }
  let(:title) { 'Awesome merge_request' }
  let(:params) do
    {
      title: title,
      description: 'please fix',
      source_branch: 'feature',
      target_branch: 'master'
    }
  end

  describe '#execute_hooks' do
    subject { MergeRequests::CreateService.new(project: project, current_user: user, params: params).execute }

    shared_examples 'enqueues Jira sync worker' do
      specify :aggregate_failures do
        expect(JiraConnect::SyncMergeRequestWorker).to receive(:perform_async).with(kind_of(Numeric), kind_of(Numeric)).and_call_original
        Sidekiq::Testing.fake! do
          expect { subject }.to change(JiraConnect::SyncMergeRequestWorker.jobs, :size).by(1)
        end
      end
    end

    shared_examples 'does not enqueue Jira sync worker' do
      it do
        Sidekiq::Testing.fake! do
          expect { subject }.not_to change(JiraConnect::SyncMergeRequestWorker.jobs, :size)
        end
      end
    end

    context 'with a Jira subscription' do
      before do
        create(:jira_connect_subscription, namespace: project.namespace)
      end

      context 'MR contains Jira issue key' do
        let(:title) { 'Awesome merge_request with issue JIRA-123' }

        it_behaves_like 'does not enqueue Jira sync worker'

        context 'for UpdateService' do
          subject { MergeRequests::UpdateService.new(project: project, current_user: user, params: params).execute(merge_request) }

          let(:merge_request) do
            create(:merge_request, :simple, title: 'Old title',
              assignee_ids: [user.id],
              source_project: project,
              author: user)
          end

          it_behaves_like 'enqueues Jira sync worker'
        end
      end

      context 'MR does not contain Jira issue key' do
        it_behaves_like 'does not enqueue Jira sync worker'
      end
    end

    context 'without a Jira subscription' do
      it_behaves_like 'does not enqueue Jira sync worker'
    end
  end

  describe `#create_pipeline_for` do
    let_it_be(:merge_request) { create(:merge_request) }

    subject { MergeRequests::ExampleService.new(project: project, current_user: user, params: params) }

    context 'async: false' do
      it 'creates a pipeline directly' do
        expect(MergeRequests::CreatePipelineService)
          .to receive(:new)
          .with(hash_including(project: project, current_user: user, params: { allow_duplicate: false }))
          .and_call_original
        expect(MergeRequests::CreatePipelineWorker).not_to receive(:perform_async)

        subject.execute(merge_request, async: false)
      end

      context 'allow_duplicate: true' do
        it 'passes :allow_duplicate as true' do
          expect(MergeRequests::CreatePipelineService)
          .to receive(:new)
          .with(hash_including(project: project, current_user: user, params: { allow_duplicate: true }))
          .and_call_original
          expect(MergeRequests::CreatePipelineWorker).not_to receive(:perform_async)

          subject.execute(merge_request, async: false, allow_duplicate: true)
        end
      end
    end

    context 'async: true' do
      it 'enques a CreatePipelineWorker' do
        expect(MergeRequests::CreatePipelineService).not_to receive(:new)
        expect(MergeRequests::CreatePipelineWorker)
          .to receive(:perform_async)
          .with(project.id, user.id, merge_request.id, { ""allow_duplicate"" => false })
          .and_call_original

        Sidekiq::Testing.fake! do
          expect { subject.execute(merge_request, async: true) }.to change(MergeRequests::CreatePipelineWorker.jobs, :size).by(1)
        end
      end

      context 'allow_duplicate: true' do
        it 'passes :allow_duplicate as true' do
          expect(MergeRequests::CreatePipelineService).not_to receive(:new)
          expect(MergeRequests::CreatePipelineWorker)
            .to receive(:perform_async)
            .with(project.id, user.id, merge_request.id, { ""allow_duplicate"" => true })
            .and_call_original

          Sidekiq::Testing.fake! do
            expect { subject.execute(merge_request, async: true, allow_duplicate: true) }.to change(MergeRequests::CreatePipelineWorker.jobs, :size).by(1)
          end
        end
      end
    end
  end

  describe '#constructor_container_arg' do
    it { expect(described_class.constructor_container_arg(""some-value"")).to eq({ project: ""some-value"" }) }
  end

  describe '#inspect' do
    context 'when #merge_request is defined' do
      let(:klass) do
        Class.new(described_class) do
          def merge_request
            params[:merge_request]
          end
        end
      end

      let(:params) { {} }

      subject do
        klass
          .new(project: nil, current_user: nil, params: params)
          .inspect
      end

      it { is_expected.to eq ""#<#{klass}>"" }

      context 'when merge request is present' do
        let(:params) { { merge_request: build(:merge_request) } }

        it { is_expected.to eq ""#<#{klass} #{params[:merge_request].to_reference(full: true)}>"" }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class RequestReviewService < MergeRequests::BaseService
    def execute(merge_request, user)
      return error(""Invalid permissions"") unless can?(current_user, :update_merge_request, merge_request)

      reviewer = merge_request.find_reviewer(user)

      if reviewer
        return error(""Failed to update reviewer"") unless reviewer.update(state: :unreviewed)

        notify_reviewer(merge_request, user)
        trigger_merge_request_reviewers_updated(merge_request)

        success
      else
        error(""Reviewer not found"")
      end
    end

    private

    def notify_reviewer(merge_request, reviewer)
      notification_service.async.review_requested_of_merge_request(merge_request, current_user, reviewer)
      todo_service.create_request_review_todo(merge_request, current_user, reviewer)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::RequestReviewService, feature_category: :code_review_workflow do
  let(:current_user) { create(:user) }
  let(:user) { create(:user) }
  let(:merge_request) { create(:merge_request, reviewers: [user]) }
  let(:reviewer) { merge_request.find_reviewer(user) }
  let(:project) { merge_request.project }
  let(:service) { described_class.new(project: project, current_user: current_user) }
  let(:result) { service.execute(merge_request, user) }
  let(:todo_service) { spy('todo service') }
  let(:notification_service) { spy('notification service') }

  before do
    allow(NotificationService).to receive(:new) { notification_service }
    allow(service).to receive(:todo_service).and_return(todo_service)
    allow(service).to receive(:notification_service).and_return(notification_service)

    reviewer.update!(state: MergeRequestReviewer.states[:reviewed])

    project.add_developer(current_user)
    project.add_developer(user)
  end

  describe '#execute' do
    shared_examples_for 'failed service execution' do
      it 'returns an error' do
        expect(result[:status]).to eq :error
      end

      it_behaves_like 'does not trigger GraphQL subscription mergeRequestReviewersUpdated' do
        let(:action) { result }
      end
    end

    describe 'invalid permissions' do
      let(:service) { described_class.new(project: project, current_user: create(:user)) }

      it_behaves_like 'failed service execution'
    end

    describe 'reviewer does not exist' do
      let(:result) { service.execute(merge_request, create(:user)) }

      it_behaves_like 'failed service execution'
    end

    describe 'reviewer exists' do
      it 'returns success' do
        expect(result[:status]).to eq :success
      end

      it 'updates reviewers state' do
        service.execute(merge_request, user)
        reviewer.reload

        expect(reviewer.state).to eq 'unreviewed'
      end

      it 'sends email to reviewer' do
        expect(notification_service).to receive_message_chain(:async, :review_requested_of_merge_request).with(merge_request, current_user, user)

        service.execute(merge_request, user)
      end

      it 'creates a new todo for the reviewer' do
        expect(todo_service).to receive(:create_request_review_todo).with(merge_request, current_user, user)

        service.execute(merge_request, user)
      end

      it_behaves_like 'triggers GraphQL subscription mergeRequestReviewersUpdated' do
        let(:action) { result }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class GetUrlsService < BaseProjectService
    def execute(changes)
      return [] unless project&.printing_merge_request_link_enabled

      branches = get_branches(changes)
      merge_requests_map = opened_merge_requests_from_source_branches(branches)
      branches.map do |branch|
        existing_merge_request = merge_requests_map[branch]
        if existing_merge_request
          url_for_existing_merge_request(existing_merge_request)
        else
          url_for_new_merge_request(branch)
        end
      end
    end

    private

    def opened_merge_requests_from_source_branches(branches)
      merge_requests = MergeRequest.from_project(project).opened.from_source_branches(branches)
      merge_requests.index_by(&:source_branch)
    end

    def get_branches(changes)
      return [] if project.empty_repo?
      return [] unless project.merge_requests_enabled?

      changes_list = Gitlab::ChangesList.new(changes)
      changes_list.map do |change|
        next unless Gitlab::Git.branch_ref?(change[:ref])

        # Deleted branch
        next if Gitlab::Git.blank_ref?(change[:newrev])

        # Default branch
        branch_name = Gitlab::Git.branch_name(change[:ref])
        next if branch_name == project.default_branch

        branch_name
      end.compact
    end

    def url_for_new_merge_request(branch_name)
      merge_request_params = { source_branch: branch_name }
      url = Gitlab::Routing.url_helpers.project_new_merge_request_url(project, merge_request: merge_request_params)
      { branch_name: branch_name, url: url, new_merge_request: true }
    end

    def url_for_existing_merge_request(merge_request)
      target_project = merge_request.target_project
      url = Gitlab::Routing.url_helpers.project_merge_request_url(target_project, merge_request)
      { branch_name: merge_request.source_branch, url: url, new_merge_request: false }
    end
  end
end

```","# frozen_string_literal: true

require ""spec_helper""

RSpec.describe MergeRequests::GetUrlsService, feature_category: :code_review_workflow do
  include ProjectForksHelper

  let(:project) { create(:project, :public, :repository) }
  let(:service) { described_class.new(project: project) }
  let(:source_branch) { ""merge-test"" }
  let(:new_merge_request_url) { ""http://#{Gitlab.config.gitlab.host}/#{project.full_path}/-/merge_requests/new?merge_request%5Bsource_branch%5D=#{source_branch}"" }
  let(:show_merge_request_url) { ""http://#{Gitlab.config.gitlab.host}/#{project.full_path}/-/merge_requests/#{merge_request.iid}"" }
  let(:new_branch_changes) { ""#{Gitlab::Git::BLANK_SHA} 570e7b2abdd848b95f2f578043fc23bd6f6fd24d refs/heads/#{source_branch}"" }
  let(:deleted_branch_changes) { ""d14d6c0abdd253381df51a723d58691b2ee1ab08 #{Gitlab::Git::BLANK_SHA} refs/heads/#{source_branch}"" }
  let(:existing_branch_changes) { ""d14d6c0abdd253381df51a723d58691b2ee1ab08 570e7b2abdd848b95f2f578043fc23bd6f6fd24d refs/heads/#{source_branch}"" }
  let(:default_branch_changes) { ""d14d6c0abdd253381df51a723d58691b2ee1ab08 570e7b2abdd848b95f2f578043fc23bd6f6fd24d refs/heads/master"" }

  describe ""#execute"" do
    shared_examples 'new_merge_request_link' do
      it 'returns url to create new merge request' do
        result = service.execute(changes)
        expect(result).to match([{
          branch_name: source_branch,
          url: new_merge_request_url,
          new_merge_request: true
        }])
      end
    end

    shared_examples 'show_merge_request_url' do
      it 'returns url to view merge request' do
        result = service.execute(changes)
        expect(result).to match([{
          branch_name: source_branch,
          url: show_merge_request_url,
          new_merge_request: false
        }])
      end
    end

    shared_examples 'no_merge_request_url' do
      it 'returns no URL' do
        result = service.execute(changes)
        expect(result).to be_empty
      end
    end

    context 'when project is nil' do
      let(:project) { nil }
      let(:changes) { default_branch_changes }

      it_behaves_like 'no_merge_request_url'
    end

    context 'pushing to default branch' do
      let(:changes) { default_branch_changes }

      it_behaves_like 'no_merge_request_url'
    end

    context 'pushing to project with MRs disabled' do
      let(:changes) { new_branch_changes }

      before do
        project.project_feature.update_attribute(:merge_requests_access_level, ProjectFeature::DISABLED)
      end

      it_behaves_like 'no_merge_request_url'
    end

    context 'pushing one completely new branch' do
      let(:changes) { new_branch_changes }

      it_behaves_like 'new_merge_request_link'
    end

    context 'pushing to existing branch but no merge request' do
      let(:changes) { existing_branch_changes }

      it_behaves_like 'new_merge_request_link'
    end

    context 'pushing to deleted branch' do
      let(:changes) { deleted_branch_changes }

      it_behaves_like 'no_merge_request_url'
    end

    context 'pushing to existing branch and merge request opened' do
      let!(:merge_request) { create(:merge_request, source_project: project, source_branch: source_branch) }
      let(:changes) { existing_branch_changes }

      it_behaves_like 'show_merge_request_url'
    end

    context 'pushing to existing branch and merge request is reopened' do
      let!(:merge_request) { create(:merge_request, :opened, source_project: project, source_branch: source_branch) }
      let(:changes) { existing_branch_changes }

      it_behaves_like 'show_merge_request_url'
    end

    context 'pushing to existing branch from forked project' do
      let(:user) { create(:user) }
      let!(:forked_project) { fork_project(project, user, repository: true) }
      let!(:merge_request) { create(:merge_request, source_project: forked_project, target_project: project, source_branch: source_branch) }
      let(:changes) { existing_branch_changes }
      # Source project is now the forked one
      let(:service) { described_class.new(project: forked_project) }

      before do
        allow(forked_project).to receive(:empty_repo?).and_return(false)
      end

      it_behaves_like 'show_merge_request_url'
    end

    context 'pushing to existing branch and merge request is closed' do
      let!(:merge_request) { create(:merge_request, :closed, source_project: project, source_branch: source_branch) }
      let(:changes) { existing_branch_changes }

      it_behaves_like 'new_merge_request_link'
    end

    context 'pushing to existing branch and merge request is merged' do
      let!(:merge_request) { create(:merge_request, :merged, source_project: project, source_branch: source_branch) }
      let(:changes) { existing_branch_changes }

      it_behaves_like 'new_merge_request_link'
    end

    context 'pushing new branch and existing branch (with merge request created) at once' do
      let!(:merge_request) { create(:merge_request, source_project: project, source_branch: ""markdown"") }
      let(:new_branch_changes) { ""#{Gitlab::Git::BLANK_SHA} 570e7b2abdd848b95f2f578043fc23bd6f6fd24d refs/heads/new_branch"" }
      let(:existing_branch_changes) { ""d14d6c0abdd253381df51a723d58691b2ee1ab08 570e7b2abdd848b95f2f578043fc23bd6f6fd24d refs/heads/markdown"" }
      let(:changes) { ""#{new_branch_changes}\n#{existing_branch_changes}"" }
      let(:new_merge_request_url) { ""http://#{Gitlab.config.gitlab.host}/#{project.full_path}/-/merge_requests/new?merge_request%5Bsource_branch%5D=new_branch"" }

      it 'returns 2 urls for both creating new and showing merge request' do
        result = service.execute(changes)
        expect(result).to match([{
          branch_name: ""new_branch"",
          url: new_merge_request_url,
          new_merge_request: true
        }, {
          branch_name: ""markdown"",
          url: show_merge_request_url,
          new_merge_request: false
        }])
      end
    end

    context 'when printing_merge_request_link_enabled is false' do
      it 'returns empty array' do
        project.update!(printing_merge_request_link_enabled: false)

        result = service.execute(existing_branch_changes)

        expect(result).to eq([])
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  # PostMergeService class
  #
  # Mark existing merge request as merged
  # and execute all hooks and notifications
  #
  class PostMergeService < MergeRequests::BaseService
    include RemovesRefs

    MAX_RETARGET_MERGE_REQUESTS = 4

    def execute(merge_request)
      return if merge_request.merged?

      # Mark the merge request as merged, everything that happens afterwards is
      # executed once
      merge_request.mark_as_merged

      create_event(merge_request)
      todo_service.merge_merge_request(merge_request, current_user)

      merge_request_activity_counter.track_merge_mr_action(user: current_user)

      create_note(merge_request)
      close_issues(merge_request)
      notification_service.merge_mr(merge_request, current_user)
      invalidate_cache_counts(merge_request, users: merge_request.assignees | merge_request.reviewers)
      merge_request.update_project_counter_caches
      delete_non_latest_diffs(merge_request)
      cancel_review_app_jobs!(merge_request)
      cleanup_environments(merge_request)
      cleanup_refs(merge_request)
      deactivate_pages_deployments(merge_request)

      execute_hooks(merge_request, 'merge')
    end

    private

    def close_issues(merge_request)
      return unless merge_request.target_branch == project.default_branch

      closed_issues = merge_request.visible_closing_issues_for(current_user)

      closed_issues.each do |issue|
        # We are intentionally only closing Issues asynchronously (excluding ExternalIssues)
        # as the worker only supports finding an Issue. We are also only experiencing
        # SQL timeouts when closing an Issue.
        if issue.is_a?(Issue)
          MergeRequests::CloseIssueWorker.perform_async(
            project.id,
            current_user.id,
            issue.id,
            merge_request.id
          )
        else
          Issues::CloseService.new(container: project, current_user: current_user).execute(issue, commit: merge_request)
        end
      end
    end

    def delete_non_latest_diffs(merge_request)
      DeleteNonLatestDiffsService.new(merge_request).execute
    end

    def create_merge_event(merge_request, current_user)
      EventCreateService.new.merge_mr(merge_request, current_user)
    end

    def create_event(merge_request)
      # Making sure MergeRequest::Metrics updates are in sync with
      # Event creation.
      Event.transaction do
        merge_event = create_merge_event(merge_request, current_user)
        merge_request_metrics_service(merge_request).merge(merge_event)
      end
    end
  end
end

MergeRequests::PostMergeService.prepend_mod_with('MergeRequests::PostMergeService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::PostMergeService, feature_category: :code_review_workflow do
  include ProjectForksHelper

  let_it_be(:user) { create(:user) }
  let_it_be(:merge_request, reload: true) { create(:merge_request, assignees: [user]) }
  let_it_be(:project) { merge_request.project }

  subject { described_class.new(project: project, current_user: user).execute(merge_request) }

  before do
    project.add_maintainer(user)
  end

  describe '#execute' do
    it_behaves_like 'cache counters invalidator'
    it_behaves_like 'merge request reviewers cache counters invalidator'

    it 'refreshes the number of open merge requests for a valid MR', :use_clean_rails_memory_store_caching do
      # Cache the counter before the MR changed state.
      project.open_merge_requests_count

      expect do
        subject

        BatchLoader::Executor.clear_current
      end.to change { project.open_merge_requests_count }.from(1).to(0)
    end

    it 'updates metrics' do
      metrics = merge_request.metrics
      metrics_service = double(MergeRequestMetricsService)
      allow(MergeRequestMetricsService)
        .to receive(:new)
        .with(metrics)
        .and_return(metrics_service)

      expect(metrics_service).to receive(:merge)

      subject
    end

    it 'calls the merge request activity counter' do
      expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
        .to receive(:track_merge_mr_action)
        .with(user: user)

      subject
    end

    it 'deletes non-latest diffs' do
      diff_removal_service = instance_double(MergeRequests::DeleteNonLatestDiffsService, execute: nil)

      expect(MergeRequests::DeleteNonLatestDiffsService)
        .to receive(:new).with(merge_request)
        .and_return(diff_removal_service)

      subject

      expect(diff_removal_service).to have_received(:execute)
    end

    it 'clean up environments for the merge request' do
      expect_next_instance_of(::Environments::StopService) do |stop_environment_service|
        expect(stop_environment_service).to receive(:execute_for_merge_request_pipeline).with(merge_request)
      end

      subject
    end

    it 'schedules CleanupRefsService' do
      expect(MergeRequests::CleanupRefsService).to receive(:schedule).with(merge_request)

      subject
    end

    context 'when there are issues to be closed' do
      let_it_be(:issue) { create(:issue, project: project) }

      before do
        merge_request.update!(target_branch: 'foo')

        allow(project).to receive(:default_branch).and_return('foo')
        allow(merge_request).to receive(:visible_closing_issues_for).and_return([issue])
      end

      it 'performs MergeRequests::CloseIssueWorker asynchronously' do
        expect(MergeRequests::CloseIssueWorker)
          .to receive(:perform_async)
          .with(project.id, user.id, issue.id, merge_request.id)

        subject

        expect(merge_request.reload).to be_merged
      end

      context 'when issue is an external issue' do
        let_it_be(:issue) { ExternalIssue.new('JIRA-123', project) }

        it 'executes Issues::CloseService' do
          expect_next_instance_of(Issues::CloseService) do |close_service|
            expect(close_service).to receive(:execute).with(issue, commit: merge_request)
          end

          subject

          expect(merge_request.reload).to be_merged
        end
      end
    end

    context 'when the merge request has review apps' do
      it 'cancels all review app deployments' do
        pipeline = create(:ci_pipeline,
          source: :merge_request_event,
          merge_request: merge_request,
          project: project,
          sha: merge_request.diff_head_sha,
          merge_requests_as_head_pipeline: [merge_request])

        review_env_a = create(:environment, project: project, state: :available, name: 'review/a')
        review_env_b = create(:environment, project: project, state: :available, name: 'review/b')
        review_env_c = create(:environment, project: project, state: :stopped, name: 'review/c')
        deploy_env = create(:environment, project: project, state: :available, name: 'deploy')

        review_job_a1 = create(:ci_build, :with_deployment, :start_review_app,
          pipeline: pipeline, project: project, environment: review_env_a.name)
        review_job_a2 = create(:ci_build, :with_deployment, :start_review_app,
          pipeline: pipeline, project: project, environment: review_env_a.name)
        finished_review_job_a = create(:ci_build, :with_deployment, :start_review_app,
          pipeline: pipeline, project: project, status: :success, environment: review_env_a.name)
        review_job_b1 = create(:ci_build, :with_deployment, :start_review_app,
          pipeline: pipeline, project: project, environment: review_env_b.name)
        review_job_b2 = create(:ci_build, :start_review_app,
          pipeline: pipeline, project: project, environment: review_env_b.name)
        review_job_c1 = create(:ci_build, :with_deployment, :start_review_app,
          pipeline: pipeline, project: project, environment: review_env_c.name)
        deploy_job = create(:ci_build, :with_deployment, :deploy_to_production,
          pipeline: pipeline, project: project, environment: deploy_env.name)

        subject

        expect(review_job_a1.reload.canceled?).to be true
        expect(review_job_a2.reload.canceled?).to be true
        expect(finished_review_job_a.reload.status).to eq ""success""
        expect(finished_review_job_a.reload.canceled?).to be false
        expect(review_job_b1.reload.canceled?).to be true
        expect(review_job_b2.reload.canceled?).to be false
        expect(review_job_c1.reload.canceled?).to be false
        expect(deploy_job.reload.canceled?).to be false
      end
    end

    context 'when the merge request has a pages deployment' do
      it 'performs Pages::DeactivateMrDeploymentWorker asynchronously' do
        expect(Pages::DeactivateMrDeploymentsWorker)
          .to receive(:perform_async)
          .with(merge_request)

        subject

        expect(merge_request.reload).to be_merged
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class ResolvedDiscussionNotificationService < MergeRequests::BaseService
    def execute(merge_request)
      return unless merge_request.discussions_resolved?

      SystemNoteService.resolve_all_discussions(merge_request, project, current_user)
      execute_hooks(merge_request, 'update')
      notification_service.async.resolve_all_discussions(merge_request, current_user)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::ResolvedDiscussionNotificationService, feature_category: :code_review_workflow do
  let(:merge_request) { create(:merge_request) }
  let(:user) { create(:user) }
  let(:project) { merge_request.project }

  subject { described_class.new(project: project, current_user: user) }

  describe ""#execute"" do
    context ""when not all discussions are resolved"" do
      before do
        allow(merge_request).to receive(:discussions_resolved?).and_return(false)
      end

      it ""doesn't add a system note"" do
        expect(SystemNoteService).not_to receive(:resolve_all_discussions)

        subject.execute(merge_request)
      end

      it ""doesn't send a notification email"" do
        expect_any_instance_of(NotificationService).not_to receive(:resolve_all_discussions)

        subject.execute(merge_request)
      end

      it ""doesn't send a webhook"" do
        expect_any_instance_of(MergeRequests::BaseService).not_to receive(:execute_hooks)

        subject.execute(merge_request)
      end
    end

    context ""when all discussions are resolved"" do
      before do
        allow(merge_request).to receive(:discussions_resolved?).and_return(true)
      end

      it ""adds a system note"" do
        expect(SystemNoteService).to receive(:resolve_all_discussions).with(merge_request, project, user)

        subject.execute(merge_request)
      end

      it ""sends a notification email"", :sidekiq_might_not_need_inline do
        expect_any_instance_of(NotificationService).to receive(:resolve_all_discussions).with(merge_request, user)

        subject.execute(merge_request)
      end

      it ""sends a webhook"" do
        expect_any_instance_of(MergeRequests::BaseService).to receive(:execute_hooks).with(merge_request, 'update')

        subject.execute(merge_request)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class RemoveApprovalService < MergeRequests::BaseService
    # rubocop: disable CodeReuse/ActiveRecord
    def execute(merge_request)
      return unless merge_request.approved_by?(current_user)

      # paranoid protection against running wrong deletes
      return unless merge_request.id && current_user.id

      approval = merge_request.approvals.where(user: current_user)

      trigger_approval_hooks(merge_request) do
        next unless approval.destroy_all # rubocop: disable Cop/DestroyAll

        reset_approvals_cache(merge_request)
        create_note(merge_request)
        merge_request_activity_counter.track_unapprove_mr_action(user: current_user)
        trigger_merge_request_merge_status_updated(merge_request)
        trigger_merge_request_reviewers_updated(merge_request)
        trigger_merge_request_approval_state_updated(merge_request)
      end

      success
    end
    # rubocop: enable CodeReuse/ActiveRecord

    private

    def reset_approvals_cache(merge_request)
      merge_request.approvals.reset
    end

    def trigger_approval_hooks(merge_request)
      yield

      notification_service.async.unapprove_mr(merge_request, current_user)
      execute_hooks(merge_request, 'unapproved')
    end

    def create_note(merge_request)
      SystemNoteService.unapprove_mr(merge_request, current_user)
    end
  end
end

MergeRequests::RemoveApprovalService.prepend_mod_with('MergeRequests::RemoveApprovalService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::RemoveApprovalService, feature_category: :code_review_workflow do
  describe '#execute' do
    let(:user) { create(:user) }
    let(:project) { create(:project) }
    let(:merge_request) { create(:merge_request, source_project: project) }
    let!(:existing_approval) { create(:approval, merge_request: merge_request) }

    subject(:service) { described_class.new(project: project, current_user: user) }

    def execute!
      service.execute(merge_request)
    end

    before do
      project.add_developer(user)
    end

    context 'with a user who has approved' do
      let!(:approval) { create(:approval, user: user, merge_request: merge_request) }
      let(:notification_service) { NotificationService.new }

      before do
        allow(service).to receive(:notification_service).and_return(notification_service)
      end

      it 'removes the approval' do
        expect { execute! }.to change { merge_request.approvals.size }.from(2).to(1)
      end

      it 'creates an unapproval note, triggers a web hook, and sends a notification' do
        expect(service).to receive(:execute_hooks).with(merge_request, 'unapproved')
        expect(SystemNoteService).to receive(:unapprove_mr)
        expect(notification_service).to receive_message_chain(:async, :unapprove_mr).with(merge_request, user)

        execute!
      end

      it 'tracks merge request unapprove action' do
        expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
          .to receive(:track_unapprove_mr_action).with(user: user)

        execute!
      end

      it_behaves_like 'triggers GraphQL subscription mergeRequestMergeStatusUpdated' do
        let(:action) { execute! }
      end

      it_behaves_like 'triggers GraphQL subscription mergeRequestReviewersUpdated' do
        let(:action) { execute! }
      end

      it_behaves_like 'triggers GraphQL subscription mergeRequestApprovalStateUpdated' do
        let(:action) { execute! }
      end
    end

    context 'with a user who has not approved' do
      it 'does not create an unapproval note and triggers web hook' do
        expect(service).not_to receive(:execute_hooks)
        expect(SystemNoteService).not_to receive(:unapprove_mr)

        execute!
      end

      it 'does not track merge request unapprove action' do
        expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
          .not_to receive(:track_unapprove_mr_action).with(user: user)

        execute!
      end

      it_behaves_like 'does not trigger GraphQL subscription mergeRequestMergeStatusUpdated' do
        let(:action) { execute! }
      end

      it_behaves_like 'does not trigger GraphQL subscription mergeRequestReviewersUpdated' do
        let(:action) { execute! }
      end

      it_behaves_like 'does not trigger GraphQL subscription mergeRequestApprovalStateUpdated' do
        let(:action) { execute! }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class ApprovalService < MergeRequests::BaseService
    def execute(merge_request)
      return unless eligible_for_approval?(merge_request)

      approval = merge_request.approvals.new(
        user: current_user,
        patch_id_sha: merge_request.current_patch_id_sha
      )

      return success unless save_approval(approval)

      reset_approvals_cache(merge_request)

      merge_request_activity_counter.track_approve_mr_action(user: current_user, merge_request: merge_request)

      trigger_merge_request_merge_status_updated(merge_request)
      trigger_merge_request_reviewers_updated(merge_request)
      trigger_merge_request_approval_state_updated(merge_request)

      # Approval side effects (things not required to be done immediately but
      # should happen after a successful approval) should be done asynchronously
      # utilizing the `Gitlab::EventStore`.
      #
      # Workers can subscribe to the `MergeRequests::ApprovedEvent`.
      Gitlab::EventStore.publish(
        MergeRequests::ApprovedEvent.new(
          data: { current_user_id: current_user.id, merge_request_id: merge_request.id }
        )
      )

      success
    end

    private

    def eligible_for_approval?(merge_request)
      merge_request.eligible_for_approval_by?(current_user)
    end

    def save_approval(approval)
      Approval.safe_ensure_unique do
        approval.save
      end
    end

    def reset_approvals_cache(merge_request)
      merge_request.approvals.reset
    end
  end
end

MergeRequests::ApprovalService.prepend_mod_with('MergeRequests::ApprovalService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::ApprovalService, feature_category: :code_review_workflow do
  describe '#execute' do
    let(:user)          { create(:user) }
    let(:merge_request) { create(:merge_request, reviewers: [user]) }
    let(:project)       { merge_request.project }
    let!(:todo)         { create(:todo, user: user, project: project, target: merge_request) }

    subject(:service) { described_class.new(project: project, current_user: user) }

    before do
      project.add_developer(user)
      stub_feature_flags ff_require_saml_auth_to_approve: false
    end

    context 'with invalid approval' do
      before do
        allow(merge_request.approvals).to receive(:new).and_return(double(save: false))
      end

      it 'does not reset approvals' do
        expect(merge_request.approvals).not_to receive(:reset)

        service.execute(merge_request)
      end

      it 'does not track merge request approve action' do
        expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
          .not_to receive(:track_approve_mr_action).with(user: user)

        service.execute(merge_request)
      end

      it_behaves_like 'does not trigger GraphQL subscription mergeRequestMergeStatusUpdated' do
        let(:action) { service.execute(merge_request) }
      end

      it 'does not publish MergeRequests::ApprovedEvent' do
        expect { service.execute(merge_request) }.not_to publish_event(MergeRequests::ApprovedEvent)
      end

      it_behaves_like 'does not trigger GraphQL subscription mergeRequestReviewersUpdated' do
        let(:action) { service.execute(merge_request) }
      end
    end

    context 'with an already approved MR' do
      before do
        merge_request.approvals.create!(user: user)
      end

      it 'does not create an approval' do
        expect { service.execute(merge_request) }.not_to change { merge_request.approvals.size }
      end

      it_behaves_like 'does not trigger GraphQL subscription mergeRequestMergeStatusUpdated' do
        let(:action) { service.execute(merge_request) }
      end

      it_behaves_like 'does not trigger GraphQL subscription mergeRequestReviewersUpdated' do
        let(:action) { service.execute(merge_request) }
      end
    end

    context 'with valid approval' do
      it 'resets approvals' do
        expect(merge_request.approvals).to receive(:reset)

        service.execute(merge_request)
      end

      it 'tracks merge request approve action' do
        expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
          .to receive(:track_approve_mr_action).with(user: user, merge_request: merge_request)

        service.execute(merge_request)
      end

      context 'when generating a patch_id_sha' do
        it 'records a value' do
          service.execute(merge_request)

          expect(merge_request.approvals.last.patch_id_sha).to eq(merge_request.current_patch_id_sha)
        end

        context 'when MergeRequest#current_patch_id_sha is nil' do
          it 'records patch_id_sha as nil' do
            expect(merge_request).to receive(:current_patch_id_sha).and_return(nil)

            service.execute(merge_request)

            expect(merge_request.approvals.last.patch_id_sha).to be_nil
          end
        end
      end

      it 'publishes MergeRequests::ApprovedEvent' do
        expect { service.execute(merge_request) }
          .to publish_event(MergeRequests::ApprovedEvent)
          .with(current_user_id: user.id, merge_request_id: merge_request.id)
      end

      it_behaves_like 'triggers GraphQL subscription mergeRequestMergeStatusUpdated' do
        let(:action) { service.execute(merge_request) }
      end

      it_behaves_like 'triggers GraphQL subscription mergeRequestReviewersUpdated' do
        let(:action) { service.execute(merge_request) }
      end

      it_behaves_like 'triggers GraphQL subscription mergeRequestApprovalStateUpdated' do
        let(:action) { service.execute(merge_request) }
      end
    end

    context 'user cannot update the merge request' do
      before do
        project.add_guest(user)
      end

      it 'does not update approvals' do
        expect { service.execute(merge_request) }.not_to change { merge_request.approvals.size }
      end

      it_behaves_like 'does not trigger GraphQL subscription mergeRequestMergeStatusUpdated' do
        let(:action) { service.execute(merge_request) }
      end

      it_behaves_like 'does not trigger GraphQL subscription mergeRequestReviewersUpdated' do
        let(:action) { service.execute(merge_request) }
      end

      it_behaves_like 'does not trigger GraphQL subscription mergeRequestApprovalStateUpdated' do
        let(:action) { service.execute(merge_request) }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class AddTodoWhenBuildFailsService < MergeRequests::BaseService
    # Adds a todo to the parent merge_request when a CI build fails
    #
    def execute(commit_status)
      return if commit_status.allow_failure? || commit_status.retried?

      pipeline_merge_requests(commit_status.pipeline) do |merge_request|
        todo_service.merge_request_build_failed(merge_request)
      end
    end

    # Closes any pending build failed todos for the parent MRs when a
    # build is retried
    #
    def close(commit_status)
      close_all(commit_status.pipeline)
    end

    def close_all(pipeline)
      pipeline_merge_requests(pipeline) do |merge_request|
        todo_service.merge_request_build_retried(merge_request)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::MergeRequests::AddTodoWhenBuildFailsService, feature_category: :code_review_workflow do
  let(:user) { create(:user) }
  let(:project) { create(:project, :repository) }
  let(:sha) { '1234567890abcdef1234567890abcdef12345678' }
  let(:ref) { merge_request.source_branch }

  let(:service) do
    described_class.new(project: project, current_user: user, params: { commit_message: 'Awesome message' })
  end

  let(:todo_service) { spy('todo service') }

  let(:merge_request) do
    create(:merge_request, :with_detached_merge_request_pipeline, :opened, merge_user: user)
  end

  let(:pipeline) do
    merge_request.all_pipelines.take
  end

  before do
    allow_any_instance_of(MergeRequest)
      .to receive(:head_pipeline_id)
      .and_return(pipeline.id)

    allow(service).to receive(:todo_service).and_return(todo_service)
  end

  describe '#execute' do
    context 'commit status with ref' do
      let(:commit_status) do
        create(:generic_commit_status, ref: ref, pipeline: pipeline)
      end

      it 'notifies the todo service' do
        expect(todo_service).to receive(:merge_request_build_failed).with(merge_request)
        service.execute(commit_status)
      end
    end

    context 'commit status with non-HEAD ref' do
      let(:commit_status) { create(:generic_commit_status, ref: ref) }

      it 'does not notify the todo service' do
        expect(todo_service).not_to receive(:merge_request_build_failed)
        service.execute(commit_status)
      end
    end

    context 'commit status without ref' do
      let(:commit_status) { create(:generic_commit_status) }

      it 'does not notify the todo service' do
        expect(todo_service).not_to receive(:merge_request_build_failed)
        service.execute(commit_status)
      end
    end

    context 'when commit status is a build allowed to fail' do
      let(:commit_status) do
        create(:ci_build, :allowed_to_fail, ref: ref, pipeline: pipeline)
      end

      it 'does not create todo' do
        expect(todo_service).not_to receive(:merge_request_build_failed)

        service.execute(commit_status)
      end
    end

    context 'when build belongs to a merge request pipeline' do
      let(:pipeline) do
        create(
          :ci_pipeline,
          source: :merge_request_event,
          ref: merge_request.merge_ref_path,
          merge_request: merge_request,
          merge_requests_as_head_pipeline: [merge_request]
        )
      end

      let(:commit_status) { create(:ci_build, ref: merge_request.merge_ref_path, pipeline: pipeline) }

      it 'notifies the todo service' do
        expect(todo_service).to receive(:merge_request_build_failed).with(merge_request)
        service.execute(commit_status)
      end
    end
  end

  describe '#close' do
    context 'commit status with ref' do
      let(:commit_status) { create(:generic_commit_status, ref: merge_request.source_branch, pipeline: pipeline) }

      it 'notifies the todo service' do
        expect(todo_service).to receive(:merge_request_build_retried).with(merge_request)
        service.close(commit_status)
      end
    end

    context 'commit status with non-HEAD ref' do
      let(:commit_status) { create(:generic_commit_status, ref: merge_request.source_branch) }

      it 'does not notify the todo service' do
        expect(todo_service).not_to receive(:merge_request_build_retried)
        service.close(commit_status)
      end
    end

    context 'commit status without ref' do
      let(:commit_status) { create(:generic_commit_status) }

      it 'does not notify the todo service' do
        expect(todo_service).not_to receive(:merge_request_build_retried)
        service.close(commit_status)
      end
    end

    context 'when build belongs to a merge request pipeline' do
      let(:pipeline) do
        create(
          :ci_pipeline,
          source: :merge_request_event,
          ref: merge_request.merge_ref_path,
          merge_request: merge_request,
          merge_requests_as_head_pipeline: [merge_request]
        )
      end

      let(:commit_status) { create(:ci_build, ref: merge_request.merge_ref_path, pipeline: pipeline) }

      it 'notifies the todo service' do
        expect(todo_service).to receive(:merge_request_build_retried).with(merge_request)
        service.close(commit_status)
      end
    end
  end

  describe '#close_all' do
    context 'when using pipeline that belongs to merge request' do
      it 'resolves todos about failed builds for pipeline' do
        service.close_all(pipeline)

        expect(todo_service)
          .to have_received(:merge_request_build_retried)
          .with(merge_request)
      end
    end

    context 'when pipeline is not related to merge request' do
      let(:pipeline) { create(:ci_empty_pipeline) }

      it 'does not resolve any todos about failed builds' do
        service.close_all(pipeline)

        expect(todo_service)
          .not_to have_received(:merge_request_build_retried)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class BuildService < MergeRequests::BaseService
    include Gitlab::Utils::StrongMemoize

    def execute
      @params_issue_iid = params.delete(:issue_iid)
      self.merge_request = MergeRequest.new
      # TODO: this should handle all quick actions that don't have side effects
      # https://gitlab.com/gitlab-org/gitlab-foss/issues/53658
      merge_quick_actions_into_params!(merge_request, only: [:target_branch])

      # Assign the projects first so we can use policies for `filter_params`
      merge_request.author = current_user
      merge_request.source_project = find_source_project
      merge_request.target_project = find_target_project

      initialize_callbacks!(merge_request)

      process_params

      merge_request.compare_commits = []
      set_merge_request_target_branch

      merge_request.can_be_created = projects_and_branches_valid?

      # compare branches only if branches are valid, otherwise
      # compare_branches may raise an error
      if merge_request.can_be_created
        compare_branches
        assign_title_and_description
        assign_labels
        assign_milestone
      end

      merge_request
    end

    private

    attr_accessor :merge_request

    delegate :target_branch,
      :target_branch_ref,
      :target_project,
      :source_branch,
      :source_branch_ref,
      :source_project,
      :compare_commits,
      :draft_title,
      :description,
      :first_multiline_commit,
      :errors,
      to: :merge_request

    def force_remove_source_branch
      if params.key?(:force_remove_source_branch)
        params.delete(:force_remove_source_branch)
      else
        merge_request.source_project.remove_source_branch_after_merge?
      end
    end

    def filter_id_params
      # merge_request.assign_attributes(...) below is a Rails
      # method that only work if all the params it is passed have
      # corresponding fields in the database. As there are no fields
      # in the database for :add_label_ids, :remove_label_ids,
      # :add_assignee_ids and :remove_assignee_ids, we
      # need to remove them from the params before the call to
      # merge_request.assign_attributes(...)
      #
      # IssuableBaseService#process_label_ids and
      # IssuableBaseService#process_assignee_ids take care
      # of the removal.
      params[:label_ids] = process_label_ids(params, issuable: merge_request, extra_label_ids: merge_request.label_ids.to_a)

      params[:assignee_ids] = process_assignee_ids(params, extra_assignee_ids: merge_request.assignee_ids.to_a)

      merge_request.assign_attributes(params.to_h.compact)
    end

    def process_params
      # Force remove the source branch?
      merge_request.merge_params['force_remove_source_branch'] = force_remove_source_branch

      # Only assign merge requests params that are allowed
      self.params = assign_allowed_merge_params(merge_request, params)

      # Filter out params that are either not allowed or invalid
      filter_params(merge_request)

      # Filter out the following from params:
      #  - :add_label_ids and :remove_label_ids
      #  - :add_assignee_ids and :remove_assignee_ids
      filter_id_params
    end

    def find_source_project
      source_project = project_from_params(:source_project)
      return source_project if source_project.present? && can?(current_user, :create_merge_request_from, source_project)

      project
    end

    def find_target_project
      target_project = project_from_params(:target_project)
      return target_project if target_project.present? && can?(current_user, :create_merge_request_in, target_project)

      target_project = project.default_merge_request_target

      return target_project if target_project.present? && can?(current_user, :create_merge_request_in, target_project)

      project
    end

    def project_from_params(param_name)
      project_from_params = params.delete(param_name)

      id_param_name = :""#{param_name}_id""
      if project_from_params.nil? && params[id_param_name]
        project_from_params = Project.find_by_id(params.delete(id_param_name))
      end

      project_from_params
    end

    def set_merge_request_target_branch
      if source_branch_default? && !target_branch_specified?
        merge_request.target_branch = nil
      else
        merge_request.target_branch ||= get_target_branch
      end
    end

    def get_target_branch
      target_project.default_branch
    end

    def source_branch_specified?
      params[:source_branch].present?
    end

    def target_branch_specified?
      params[:target_branch].present?
    end

    def projects_and_branches_valid?
      return false if source_project.nil? || target_project.nil?
      return false unless source_branch_specified? || target_branch_specified?

      validate_projects_and_branches
      errors.blank?
    end

    def compare_branches
      compare = CompareService.new(
        source_project,
        source_branch_ref
      ).execute(
        target_project,
        target_branch_ref
      )

      if compare
        merge_request.compare_commits = compare.commits
        merge_request.compare = compare
      end
    end

    def validate_projects_and_branches
      merge_request.validate_target_project
      merge_request.validate_fork

      return if errors.any?

      add_error('You must select source and target branch') unless branches_present?
      add_error('You must select different branches') if same_source_and_target?
      add_error(""Source branch \""#{source_branch}\"" does not exist"") unless source_branch_exists?
      add_error(""Target branch \""#{target_branch}\"" does not exist"") unless target_branch_exists?
    end

    def add_error(message)
      errors.add(:base, message)
    end

    def branches_present?
      target_branch.present? && source_branch.present?
    end

    def same_source_and_target?
      same_source_and_target_project? && target_branch == source_branch
    end

    def source_branch_default?
      same_source_and_target_project? && source_branch == target_project.default_branch
    end

    def same_source_and_target_project?
      source_project == target_project
    end

    def source_branch_exists?
      source_branch.blank? || source_project.commit(source_branch)
    end

    def target_branch_exists?
      target_branch.blank? || target_project.commit(target_branch)
    end

    def set_draft_title_if_needed
      return unless compare_commits.empty? || Gitlab::Utils.to_boolean(params[:draft])

      merge_request.title = draft_title
    end

    # When your branch name starts with an iid followed by a dash this pattern will be
    # interpreted as the user wants to close that issue on this project.
    #
    # For example:
    # - Issue 112 exists
    # - title: Emoji don't show up in commit title
    # - Source branch is: 112-fix-mep-mep
    #
    # Will lead to:
    # - Appending `Closes #112` to the description
    # - Setting the title as 'Resolves ""Emoji don't show up in commit title""' if there is
    #   more than one commit in the MR
    #
    def assign_title_and_description
      assign_description_from_repository_template
      replace_variables_in_description
      assign_title_and_description_from_commits
      merge_request.title ||= title_from_issue if target_project.issues_enabled? || target_project.external_issue_tracker
      merge_request.title ||= source_branch.titleize.humanize
      set_draft_title_if_needed

      append_closes_description
    end

    def assign_labels
      return unless target_project.issues_enabled? && issue
      return if merge_request.label_ids&.any?

      merge_request.label_ids = issue.try(:label_ids)
    end

    def assign_milestone
      return unless target_project.issues_enabled? && issue
      return if merge_request.milestone_id.present?

      merge_request.milestone_id = issue.try(:milestone_id)
    end

    def append_closes_description
      return unless issue&.to_reference.present?

      closes_issue = ""#{target_project.autoclose_referenced_issues ? 'Closes' : 'Related to'} #{issue.to_reference}""

      if description.present?
        descr_parts = [merge_request.description, closes_issue]
        merge_request.description = descr_parts.join(""\n\n"")
      else
        merge_request.description = closes_issue
      end
    end

    def assign_title_and_description_from_commits
      commits = compare_commits

      if commits&.count == 1
        commit = commits.first
      else
        commit = first_multiline_commit
        return unless commit
      end

      merge_request.title ||= commit.title
      merge_request.description ||= commit.description.try(:strip)
    end

    def title_from_issue
      return unless issue

      return ""Resolve \""#{issue.title}\"""" if issue.is_a?(Issue)

      return if issue_iid.blank?

      title_parts = [""Resolve #{issue.to_reference}""]
      branch_title = source_branch.downcase.remove(issue_iid.downcase).titleize.humanize

      title_parts << ""\""#{branch_title}\"""" if branch_title.present?
      title_parts.join(' ')
    end

    def assign_description_from_repository_template
      return unless merge_request.description.blank?

      # Use TemplateFinder to load the default template. We need this mainly for
      # the project_id, in case it differs from the target project. Conveniently,
      # since the underlying merge_request_template_names_hash is cached, this
      # should also be relatively cheap and allows us to bail early if the project
      # does not have a default template.
      templates = TemplateFinder.all_template_names(target_project, :merge_requests)
      template = templates.values.flatten.find { |tmpl| tmpl[:name].casecmp?('default') }

      return unless template

      begin
        repository_template = TemplateFinder.build(
          :merge_requests,
          target_project,
          {
            name: template[:name],
            source_template_project_id: template[:project_id]
          }
        ).execute
      rescue ::Gitlab::Template::Finders::RepoTemplateFinder::FileNotFoundError
        return
      end

      return unless repository_template.present?

      merge_request.description = repository_template.content
    end

    def replace_variables_in_description
      return unless merge_request.description.present?

      merge_request.description = ::Gitlab::MergeRequests::MessageGenerator.new(
        merge_request: merge_request,
        current_user: current_user
      ).new_mr_description
    end

    def issue_iid
      strong_memoize(:issue_iid) do
        @params_issue_iid || begin
          id = if target_project.external_issue_tracker
                 target_project.external_issue_reference_pattern.match(source_branch).try(:[], 0)
               end

          id || source_branch.match(/\A(\d+)-/).try(:[], 1)
        end
      end
    end

    def issue
      strong_memoize(:issue) do
        target_project.get_issue(issue_iid, current_user)
      end
    end
  end
end

MergeRequests::BuildService.prepend_mod_with('MergeRequests::BuildService')

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe MergeRequests::BuildService, feature_category: :code_review_workflow do
  using RSpec::Parameterized::TableSyntax
  include RepoHelpers
  include ProjectForksHelper

  let(:project) { create(:project, :repository) }
  let(:source_project) { nil }
  let(:target_project) { nil }
  let(:user) { create(:user) }
  let(:issue_confidential) { false }
  let(:issue) { create(:issue, project: project, title: 'A bug', confidential: issue_confidential) }
  let(:description) { nil }
  let(:source_branch) { 'feature-branch' }
  let(:target_branch) { 'master' }
  let(:milestone_id) { nil }
  let(:label_ids) { [] }
  let(:merge_request) { service.execute }
  let(:compare) { double(:compare, commits: commits) }
  let(:commit_1) do
    double(:commit_1,
      sha: 'f00ba6',
      safe_message: 'Initial commit',
      gitaly_commit?: false,
      id: 'f00ba6',
      parent_ids: ['f00ba5'],
      author_email: 'tom@example.com',
      author_name: 'Tom Example')
  end

  let(:commit_2) do
    double(:commit_2,
      sha: 'f00ba7',
      safe_message: ""Closes #1234 Second commit\n\nCreate the app"",
      gitaly_commit?: false,
      id: 'f00ba7',
      parent_ids: ['f00ba6'],
      author_email: 'alice@example.com',
      author_name: 'Alice Example')
  end

  let(:commit_3) do
    double(:commit_3,
      sha: 'f00ba8',
      safe_message: 'This is a bad commit message!',
      gitaly_commit?: false,
      id: 'f00ba8',
      parent_ids: ['f00ba7'],
      author_email: 'jo@example.com',
      author_name: 'Jo Example')
  end

  let(:commits) { nil }

  let(:params) do
    {
      description: description,
      source_branch: source_branch,
      target_branch: target_branch,
      source_project: source_project,
      target_project: target_project,
      milestone_id: milestone_id,
      label_ids: label_ids
    }
  end

  let(:service) do
    described_class.new(project: project, current_user: user, params: params)
  end

  before do
    project.add_guest(user)
  end

  def stub_compare
    allow(CompareService).to receive_message_chain(:new, :execute).and_return(compare)
    allow(project).to receive(:commit).and_return(commit_1)
    allow(project).to receive(:commit).and_return(commit_2)
    allow(project).to receive(:commit).and_return(commit_3)
  end

  shared_examples 'allows the merge request to be created' do
    it do
      expect(merge_request.can_be_created).to eq(true)
    end
  end

  shared_examples 'forbids the merge request from being created' do
    it 'returns that the merge request cannot be created' do
      expect(merge_request.can_be_created).to eq(false)
    end

    it 'adds an error message to the merge request' do
      expect(merge_request.errors).to contain_exactly(*Array(error_message))
    end
  end

  shared_examples 'with a Default.md template' do
    let(:files) { { '.gitlab/merge_request_templates/Default.md' => 'Default template contents' } }
    let(:project) { create(:project, :custom_repo, files: files) }

    it 'the template description is preferred' do
      expect(merge_request.description).to eq('Default template contents')
    end
  end

  describe '#execute' do
    it 'calls the compare service with the correct arguments' do
      allow_any_instance_of(described_class).to receive(:projects_and_branches_valid?).and_return(true)
      expect(CompareService).to receive(:new)
                                  .with(project, Gitlab::Git::BRANCH_REF_PREFIX + source_branch)
                                  .and_call_original

      expect_any_instance_of(CompareService).to receive(:execute)
                                                  .with(project, Gitlab::Git::BRANCH_REF_PREFIX + target_branch)
                                                  .and_call_original

      merge_request
    end

    it 'does not assign force_remove_source_branch' do
      expect(merge_request.force_remove_source_branch?).to be_truthy
    end

    context 'with force_remove_source_branch parameter when the user is authorized' do
      let(:mr_params) { params.merge(force_remove_source_branch: '1') }
      let(:source_project) { fork_project(project, user) }
      let(:merge_request) { described_class.new(project: project, current_user: user, params: mr_params).execute }

      before do
        project.add_reporter(user)
      end

      it 'assigns force_remove_source_branch' do
        expect(merge_request.force_remove_source_branch?).to be_truthy
      end

      context 'with project setting remove_source_branch_after_merge false' do
        before do
          project.remove_source_branch_after_merge = false
        end

        it 'assigns force_remove_source_branch' do
          expect(merge_request.force_remove_source_branch?).to be_truthy
        end
      end
    end

    context 'with project setting remove_source_branch_after_merge true' do
      before do
        project.remove_source_branch_after_merge = true
      end

      it 'assigns force_remove_source_branch' do
        expect(merge_request.force_remove_source_branch?).to be_truthy
      end

      context 'with force_remove_source_branch parameter false' do
        before do
          params[:force_remove_source_branch] = '0'
        end

        it 'does not assign force_remove_source_branch' do
          expect(merge_request.force_remove_source_branch?).to be(false)
        end
      end
    end

    context 'missing source branch' do
      let(:source_branch) { '' }

      it_behaves_like 'forbids the merge request from being created' do
        let(:error_message) { 'You must select source and target branch' }
      end
    end

    context 'when target branch is missing' do
      let(:target_branch) { nil }
      let(:commits) { Commit.decorate([commit_2], project) }

      before do
        stub_compare
      end

      context 'when source branch' do
        context 'is not the repository default branch' do
          it 'creates compare object with target branch as default branch' do
            expect(merge_request.compare).to be_present
            expect(merge_request.target_branch).to eq(project.default_branch)
          end

          it_behaves_like 'allows the merge request to be created'
        end

        context 'the repository default branch' do
          let(:source_branch) { 'master' }

          it_behaves_like 'forbids the merge request from being created' do
            let(:error_message) { 'You must select source and target branch' }
          end

          context 'when source project is different from the target project' do
            let(:target_project) { create(:project, :public, :repository) }
            let!(:project) { fork_project(target_project, user, namespace: user.namespace, repository: true) }
            let(:source_project) { project }

            it 'creates compare object with target branch as default branch', :sidekiq_might_not_need_inline do
              expect(merge_request.compare).to be_present
              expect(merge_request.target_branch).to eq(project.default_branch)
            end

            it_behaves_like 'allows the merge request to be created'
          end
        end
      end
    end

    context 'same source and target branch' do
      let(:source_branch) { 'master' }

      it_behaves_like 'forbids the merge request from being created' do
        let(:error_message) { 'You must select different branches' }
      end
    end

    context 'no commits in the diff' do
      let(:commits) { [] }

      before do
        stub_compare
      end

      it_behaves_like 'allows the merge request to be created'

      it 'adds a Draft prefix to the merge request title' do
        expect(merge_request.title).to eq('Draft: Feature branch')
      end
    end

    context 'one commit in the diff' do
      let(:commits) { Commit.decorate([commit_2], project) }
      let(:commit_description) { commit_2.safe_message.split(/\n+/, 2).last }

      before do
        stub_compare
      end

      it_behaves_like 'allows the merge request to be created'
      it_behaves_like 'with a Default.md template'

      it 'uses the title of the commit as the title of the merge request' do
        expect(merge_request.title).to eq(commit_2.safe_message.split(""\n"").first)
      end

      it 'uses the description of the commit as the description of the merge request' do
        expect(merge_request.description).to eq(commit_description)
      end

      context 'merge request already has a description set' do
        let(:description) { 'Merge request description' }

        it 'keeps the description from the initial params' do
          expect(merge_request.description).to eq(description)
        end
      end

      context 'commit has no description' do
        let(:commits) { Commit.decorate([commit_3], project) }

        it_behaves_like 'with a Default.md template'

        it 'uses the title of the commit as the title of the merge request' do
          expect(merge_request.title).to eq(commit_3.safe_message)
        end

        it 'sets the description to nil' do
          expect(merge_request.description).to be_nil
        end
      end

      context 'when the source branch matches an issue' do
        where(:factory, :source_branch, :closing_message) do
          :jira_integration | 'FOO-123-fix-issue' | 'Closes FOO-123'
          :jira_integration | 'fix-issue'         | nil
          :custom_issue_tracker_integration | '123-fix-issue'     | 'Closes #123'
          :custom_issue_tracker_integration | 'fix-issue'         | nil
          nil | '123-fix-issue'     | 'Closes #123'
          nil | 'fix-issue'         | nil
        end

        with_them do
          before do
            if factory
              create(factory, project: project)
              project.reload
            else
              issue.update!(iid: 123)
            end
          end

          it 'uses the title of the commit as the title of the merge request' do
            expect(merge_request.title).to eq('Closes #1234 Second commit')
          end

          it 'appends the closing description' do
            expected_description = [commit_description, closing_message].compact.join(""\n\n"")

            expect(merge_request.description).to eq(expected_description)
          end

          context 'a Default.md template is defined' do
            let(:files) { { '.gitlab/merge_request_templates/Default.md' => 'Default template contents' } }
            let(:project) { create(:project, :custom_repo, files: files) }

            it 'appends the closing description to a Default.md template' do
              expected_description = ['Default template contents', closing_message].compact.join(""\n\n"")

              expect(merge_request.description).to eq(expected_description)
            end
          end
        end

        context 'when the source branch matches an internal issue' do
          let(:label) { create(:label, project: project) }
          let(:milestone) { create(:milestone, project: project) }
          let(:source_branch) { '123-fix-issue' }

          before do
            issue.update!(iid: 123, labels: [label], milestone: milestone)
          end

          it 'assigns the issue label and milestone' do
            expect(merge_request.milestone).to eq(milestone)
            expect(merge_request.labels).to match_array([label])
          end

          context 'when milestone_id and label_ids are shared in the params' do
            let(:label2) { create(:label, project: project) }
            let(:milestone2) { create(:milestone, project: project) }
            let(:label_ids) { [label2.id] }
            let(:milestone_id) { milestone2.id }

            before do
              # Guests are not able to assign labels or milestones to an issue
              project.add_developer(user)
            end

            it 'assigns milestone_id and label_ids instead of issue labels and milestone' do
              expect(merge_request.milestone).to eq(milestone2)
              expect(merge_request.labels).to match_array([label2])
            end
          end
        end

        context 'when a milestone is from another project' do
          let(:milestone) { create(:milestone, project: create(:project)) }
          let(:milestone_id) { milestone.id }

          it 'sets milestone to nil' do
            expect(merge_request.milestone).to be_nil
          end
        end
      end
    end

    context 'no multi-line commit messages in the diff' do
      let(:commits) { Commit.decorate([commit_1, commit_3], project) }

      before do
        stub_compare
      end

      it_behaves_like 'allows the merge request to be created'
      it_behaves_like 'with a Default.md template'

      it 'uses the title of the branch as the merge request title' do
        expect(merge_request.title).to eq('Feature branch')
      end

      it 'does not add a description' do
        expect(merge_request.description).to be_nil
      end

      context 'merge request already has a description set' do
        let(:description) { 'Merge request description' }

        it 'keeps the description from the initial params' do
          expect(merge_request.description).to eq(description)
        end

        context 'a Default.md template is defined' do
          let(:files) { { '.gitlab/merge_request_templates/Default.md' => 'Default template contents' } }
          let(:project) { create(:project, :custom_repo, files: files) }

          it 'keeps the description from the initial params' do
            expect(merge_request.description).to eq(description)
          end
        end
      end

      context 'when the source branch matches an issue' do
        where(:factory, :source_branch, :title, :closing_message) do
          :jira_integration | 'FOO-123-fix-issue' | 'Resolve FOO-123 ""Fix issue""' | 'Closes FOO-123'
          :jira_integration | 'fix-issue'         | 'Fix issue'                   | nil
          :custom_issue_tracker_integration | '123-fix-issue'     | 'Resolve #123 ""Fix issue""'    | 'Closes #123'
          :custom_issue_tracker_integration | 'fix-issue'         | 'Fix issue'                   | nil
          nil | '123-fix-issue'     | 'Resolve ""A bug""'             | 'Closes #123'
          nil | 'fix-issue'         | 'Fix issue'                   | nil
          nil | '124-fix-issue'     | '124 fix issue'               | nil
        end

        with_them do
          before do
            if factory
              create(factory, project: project)
              project.reload
            else
              issue.update!(iid: 123)
            end
          end

          it 'sets the correct title' do
            expect(merge_request.title).to eq(title)
          end

          it 'sets the closing description' do
            expect(merge_request.description).to eq(closing_message)
          end

          context 'a Default.md template is defined' do
            let(:files) { { '.gitlab/merge_request_templates/Default.md' => 'Default template contents' } }
            let(:project) { create(:project, :custom_repo, files: files) }

            it 'appends the closing description to a Default.md template' do
              expected_description = ['Default template contents', closing_message].compact.join(""\n\n"")

              expect(merge_request.description).to eq(expected_description)
            end
          end
        end
      end
    end

    context 'a multi-line commit message in the diff' do
      let(:commits) { Commit.decorate([commit_1, commit_2, commit_3], project) }

      before do
        stub_compare
      end

      it_behaves_like 'allows the merge request to be created'
      it_behaves_like 'with a Default.md template'

      it 'uses the first line of the first multi-line commit message as the title' do
        expect(merge_request.title).to eq('Closes #1234 Second commit')
      end

      it 'adds the remaining lines of the first multi-line commit message as the description' do
        expect(merge_request.description).to eq('Create the app')
      end

      context 'when the source branch matches an issue' do
        where(:factory, :source_branch, :title, :closing_message) do
          :jira_integration | 'FOO-123-fix-issue' | 'Resolve FOO-123 ""Fix issue""' | 'Closes FOO-123'
          :jira_integration | 'fix-issue'         | 'Fix issue'                   | nil
          :custom_issue_tracker_integration | '123-fix-issue'     | 'Resolve #123 ""Fix issue""'    | 'Closes #123'
          :custom_issue_tracker_integration | 'fix-issue'         | 'Fix issue'                   | nil
          nil | '123-fix-issue'     | 'Resolve ""A bug""'             | 'Closes #123'
          nil | 'fix-issue'         | 'Fix issue'                   | nil
          nil | '124-fix-issue'     | '124 fix issue'               | nil
        end

        with_them do
          before do
            if factory
              create(factory, project: project)
              project.reload
            else
              issue.update!(iid: 123)
            end
          end

          it 'sets the correct title' do
            expect(merge_request.title).to eq('Closes #1234 Second commit')
          end

          it 'sets the closing description' do
            expect(merge_request.description).to eq(""Create the app#{closing_message ? ""\n\n"" + closing_message : ''}"")
          end

          context 'a Default.md template is defined' do
            let(:files) { { '.gitlab/merge_request_templates/Default.md' => 'Default template contents' } }
            let(:project) { create(:project, :custom_repo, files: files) }

            it 'appends the closing description to a Default.md template' do
              expected_description = ['Default template contents', closing_message].compact.join(""\n\n"")

              expect(merge_request.description).to eq(expected_description)
            end
          end
        end
      end

      context 'when the issue is not accessible to user' do
        let(:source_branch) { ""#{issue.iid}-fix-issue"" }

        before do
          project.team.truncate
        end

        it 'uses the first line of the first multi-line commit message as the title' do
          expect(merge_request.title).to eq('Closes #1234 Second commit')
        end

        it 'adds the remaining lines of the first multi-line commit message as the description', :sidekiq_inline do
          expect(merge_request.description).to eq('Create the app')
        end
      end

      context 'when the issue is confidential' do
        let(:source_branch) { ""#{issue.iid}-fix-issue"" }
        let(:issue_confidential) { true }

        it 'uses the first line of the first multi-line commit message as the title' do
          expect(merge_request.title).to eq('Closes #1234 Second commit')
        end

        it 'adds the remaining lines of the first multi-line commit message as the description' do
          expect(merge_request.description).to eq('Create the app')
        end
      end
    end

    context 'source branch does not exist' do
      before do
        allow(project).to receive(:commit).with(source_branch).and_return(nil)
        allow(project).to receive(:commit).with(target_branch).and_return(commit_2)
      end

      it_behaves_like 'forbids the merge request from being created' do
        let(:error_message) { 'Source branch ""feature-branch"" does not exist' }
      end
    end

    context 'target branch does not exist' do
      before do
        allow(project).to receive(:commit).with(source_branch).and_return(commit_2)
        allow(project).to receive(:commit).with(target_branch).and_return(nil)
      end

      it_behaves_like 'forbids the merge request from being created' do
        let(:error_message) { 'Target branch ""master"" does not exist' }
      end
    end

    context 'both source and target branches do not exist' do
      before do
        allow(project).to receive(:commit).and_return(nil)
      end

      it_behaves_like 'forbids the merge request from being created' do
        let(:error_message) do
          ['Source branch ""feature-branch"" does not exist', 'Target branch ""master"" does not exist']
        end
      end
    end

    context 'upstream project has disabled merge requests' do
      let(:upstream_project) { create(:project, :merge_requests_disabled) }
      let(:project) { create(:project, forked_from_project: upstream_project) }
      let(:commits) { Commit.decorate([commit_2], project) }

      it 'sets target project correctly' do
        expect(merge_request.target_project).to eq(project)
      end
    end

    context 'target_project is set and accessible by current_user' do
      let(:target_project) { create(:project, :public, :repository) }
      let(:commits) { Commit.decorate([commit_2], project) }

      it 'sets target project correctly' do
        expect(merge_request.target_project).to eq(target_project)
      end
    end

    context 'target_project is set but not accessible by current_user' do
      let(:target_project) { create(:project, :private, :repository) }
      let(:commits) { Commit.decorate([commit_2], project) }

      it 'sets target project correctly' do
        expect(merge_request.target_project).to eq(project)
      end
    end

    context 'target_project is set but repo is not accessible by current_user' do
      let(:target_project) do
        create(:project, :public, :repository, repository_access_level: ProjectFeature::PRIVATE)
      end

      it 'sets target project correctly' do
        expect(merge_request.target_project).to eq(project)
      end
    end

    context 'source_project is set and accessible by current_user' do
      let(:source_project) { create(:project, :public, :repository) }
      let(:commits) { Commit.decorate([commit_2], project) }

      before do
        # To create merge requests _from_ a project the user needs at least
        # developer access
        source_project.add_developer(user)
      end

      it 'sets source project correctly' do
        expect(merge_request.source_project).to eq(source_project)
      end
    end

    context 'source_project is set but not accessible by current_user' do
      let(:source_project) { create(:project, :private, :repository) }
      let(:commits) { Commit.decorate([commit_2], project) }

      it 'sets source project correctly' do
        expect(merge_request.source_project).to eq(project)
      end
    end

    context 'source_project is set but the user cannot create merge requests from the project' do
      let(:source_project) do
        create(:project, :public, :repository, merge_requests_access_level: ProjectFeature::PRIVATE)
      end

      it 'sets the source_project correctly' do
        expect(merge_request.source_project).to eq(project)
      end
    end

    context 'target_project is not in the fork network of source_project' do
      let(:target_project) { create(:project, :public, :repository) }

      it 'adds an error to the merge request' do
        expect(merge_request.errors[:validate_fork]).to contain_exactly('Source project is not a fork of the target project')
      end
    end

    context 'target_project is in the fork network of source project but no longer accessible' do
      let!(:project) { fork_project(target_project, user, namespace: user.namespace, repository: true) }
      let(:source_project) { project }
      let(:target_project) { create(:project, :public, :repository) }

      before do
        target_project.update!(visibility_level: Gitlab::VisibilityLevel::PRIVATE)
      end

      it 'sets the target_project correctly' do
        expect(merge_request.target_project).to eq(project)
      end
    end

    context 'when specifying target branch in the description' do
      let(:description) { ""A merge request targeting another branch\n\n/target_branch with-codeowners"" }

      it 'sets the attribute from the quick actions' do
        expect(merge_request.target_branch).to eq('with-codeowners')
      end
    end
  end

  context 'when assigning labels' do
    let(:label_ids) { [create(:label, project: project).id] }

    context 'for members with less than developer access' do
      it 'is not allowed' do
        expect(merge_request.label_ids).to be_empty
      end
    end

    context 'for users allowed to assign labels' do
      before do
        project.add_developer(user)
      end

      context 'for labels in the project' do
        it 'is allowed for developers' do
          expect(merge_request.label_ids).to contain_exactly(*label_ids)
        end
      end

      context 'for unrelated labels' do
        let(:project_label) { create(:label, project: project) }
        let(:label_ids) { [create(:label).id, project_label.id] }

        it 'only assigns related labels' do
          expect(merge_request.label_ids).to contain_exactly(project_label.id)
        end
      end
    end
  end

  describe '#assign_description_from_repository_template' do
    subject { service.send(:assign_description_from_repository_template) }

    it 'performs no action if the merge request description is not blank' do
      merge_request.description = 'foo'
      subject
      expect(merge_request.description).to eq 'foo'
    end

    context 'when a Default template is not found' do
      it 'does not modify the merge request description' do
        merge_request.description = nil
        subject
        expect(merge_request.description).to be_nil
      end
    end

    context 'when a Default template is found' do
      context 'when its contents cannot be retrieved' do
        let(:files) { { '.gitlab/merge_request_templates/OtherTemplate.md' => 'Other template contents' } }
        let(:project) { create(:project, :custom_repo, files: files) }

        it 'does not modify the merge request description' do
          allow(TemplateFinder).to receive(:all_template_names).and_return({
            merge_requests: [
              { name: 'Default', id: 'default', key: 'default', project_id: project.id }
            ]
          })

          merge_request.description = nil
          subject
          expect(merge_request.description).to be_nil
        end
      end

      context 'when its contents can be retrieved' do
        let(:files) { { '.gitlab/merge_request_templates/Default.md' => 'Default template contents' } }
        let(:project) { create(:project, :custom_repo, files: files) }

        it 'modifies the merge request description' do
          merge_request.description = nil
          subject
          expect(merge_request.description).to eq 'Default template contents'
        end
      end
    end
  end

  describe '#replace_variables_in_description' do
    context 'when the merge request description is blank' do
      let(:description) { nil }

      it 'does not update the description' do
        expect(merge_request.description).to eq(nil)
      end
    end

    context 'when the merge request description contains template variables' do
      let(:description) { <<~MSG.rstrip }
        source_branch:%{source_branch}
        target_branch:%{target_branch}
        title:%{title}
        issues:%{issues}
        description:%{description}
        first_commit:%{first_commit}
        first_multiline_commit:%{first_multiline_commit}
        url:%{url}
        approved_by:%{approved_by}
        merged_by:%{merged_by}
        co_authored_by:%{co_authored_by}
        all_commits:%{all_commits}
      MSG

      context 'when there are multiple commits in the diff' do
        let(:commits) { Commit.decorate([commit_1, commit_2, commit_3], project) }

        before do
          stub_compare
        end

        it 'replaces the variables in the description' do
          expect(merge_request.description).to eq <<~MSG.rstrip
            source_branch:feature-branch
            target_branch:master
            title:
            issues:
            description:
            first_commit:Initial commit
            first_multiline_commit:Closes #1234 Second commit

            Create the app
            url:
            approved_by:
            merged_by:
            co_authored_by:Co-authored-by: Jo Example <jo@example.com>
            Co-authored-by: Alice Example <alice@example.com>
            Co-authored-by: Tom Example <tom@example.com>
            all_commits:* This is a bad commit message!

            * Closes #1234 Second commit

            Create the app

            * Initial commit
          MSG
        end
      end

      context 'when there are no commits in the diff' do
        let(:commits) { [] }

        before do
          stub_compare
        end

        it 'replaces the variables in the description' do
          expect(merge_request.description).to eq <<~MSG.rstrip
            source_branch:feature-branch
            target_branch:master
            title:
            issues:
            description:
            first_commit:
            first_multiline_commit:
            url:
            approved_by:
            merged_by:
            co_authored_by:
            all_commits:
          MSG
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class ResolveTodosService
    include BaseServiceUtility

    def initialize(merge_request, user)
      @merge_request = merge_request
      @user = user
    end

    def async_execute
      MergeRequests::ResolveTodosWorker.perform_async(merge_request.id, user.id)
    end

    def execute
      todo_service.resolve_todos_for_target(merge_request, user)
    end

    private

    attr_reader :merge_request, :user
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::ResolveTodosService, feature_category: :code_review_workflow do
  let_it_be(:merge_request) { create(:merge_request) }
  let_it_be(:user) { create(:user) }

  let(:service) { described_class.new(merge_request, user) }

  describe '#async_execute' do
    def async_execute
      service.async_execute
    end

    it 'performs MergeRequests::ResolveTodosWorker asynchronously' do
      expect(MergeRequests::ResolveTodosWorker)
        .to receive(:perform_async)
        .with(
          merge_request.id,
          user.id
        )

      async_execute
    end
  end

  describe '#execute' do
    it 'marks pending todo as done' do
      pending_todo = create(:todo, :pending, user: user, project: merge_request.project, target: merge_request)

      service.execute

      expect(pending_todo.reload).to be_done
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class CloseService < MergeRequests::BaseService
    include RemovesRefs

    def execute(merge_request, commit = nil)
      return merge_request unless can?(current_user, :update_merge_request, merge_request)

      # If we close MergeRequest we want to ignore validation
      # so we can close broken one (Ex. fork project removed)
      merge_request.allow_broken = true

      if merge_request.close
        expire_unapproved_key(merge_request)
        create_event(merge_request)
        merge_request_activity_counter.track_close_mr_action(user: current_user)
        create_note(merge_request)
        notification_service.async.close_mr(merge_request, current_user)
        todo_service.close_merge_request(merge_request, current_user)
        execute_hooks(merge_request, 'close')
        invalidate_cache_counts(merge_request, users: merge_request.assignees | merge_request.reviewers)
        merge_request.update_project_counter_caches
        cleanup_environments(merge_request)
        deactivate_pages_deployments(merge_request)
        abort_auto_merge(merge_request, 'merge request was closed')
        cleanup_refs(merge_request)
        trigger_merge_request_merge_status_updated(merge_request)
      end

      merge_request
    end

    private

    def create_event(merge_request)
      # Making sure MergeRequest::Metrics updates are in sync with
      # Event creation.
      Event.transaction do
        close_event = event_service.close_mr(merge_request, current_user)
        merge_request_metrics_service(merge_request).close(close_event)
      end
    end

    def expire_unapproved_key(merge_request)
      nil
    end

    def trigger_merge_request_merge_status_updated(merge_request)
      GraphqlTriggers.merge_request_merge_status_updated(merge_request)
    end
  end
end

MergeRequests::CloseService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::CloseService, feature_category: :code_review_workflow do
  let(:user) { create(:user) }
  let(:user2) { create(:user) }
  let(:guest) { create(:user) }
  let(:merge_request) { create(:merge_request, assignees: [user2], author: create(:user)) }
  let(:project) { merge_request.project }
  let!(:todo) { create(:todo, :assigned, user: user, project: project, target: merge_request, author: user2) }
  let(:service) { described_class.new(project: project, current_user: user) }

  before do
    project.add_maintainer(user)
    project.add_developer(user2)
    project.add_guest(guest)
  end

  def execute
    service.execute(merge_request)
  end

  describe '#execute' do
    it_behaves_like 'cache counters invalidator'
    it_behaves_like 'merge request reviewers cache counters invalidator'

    context 'valid params' do
      before do
        allow(service).to receive(:execute_hooks)

        perform_enqueued_jobs do
          @merge_request = execute
        end
      end

      it { expect(@merge_request).to be_valid }
      it { expect(@merge_request).to be_closed }

      it 'executes hooks with close action' do
        expect(service).to have_received(:execute_hooks)
                             .with(@merge_request, 'close')
      end

      it 'sends email to user2 about assign of new merge_request', :sidekiq_inline do
        email = ActionMailer::Base.deliveries.last
        expect(email.to.first).to eq(user2.email)
        expect(email.subject).to include(merge_request.title)
      end

      it 'creates a resource event' do
        event = @merge_request.resource_state_events.last
        expect(event.state).to eq('closed')
      end

      it 'marks todos as done' do
        expect(todo.reload).to be_done
      end

      context 'when auto merge is enabled' do
        let(:merge_request) { create(:merge_request, :merge_when_pipeline_succeeds) }

        it 'cancels the auto merge' do
          expect(@merge_request).not_to be_auto_merge_enabled
        end
      end
    end

    it 'updates metrics' do
      metrics = merge_request.metrics
      metrics_service = double(MergeRequestMetricsService)
      allow(MergeRequestMetricsService)
        .to receive(:new)
        .with(metrics)
        .and_return(metrics_service)

      expect(metrics_service).to receive(:close)

      execute
    end

    it 'calls the merge request activity counter' do
      expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
        .to receive(:track_close_mr_action)
        .with(user: user)

      execute
    end

    it 'refreshes the number of open merge requests for a valid MR', :use_clean_rails_memory_store_caching do
      expect do
        execute

        BatchLoader::Executor.clear_current
      end
        .to change { project.open_merge_requests_count }.from(1).to(0)
    end

    it 'clean up environments for the merge request' do
      expect_next_instance_of(::Environments::StopService) do |service|
        expect(service).to receive(:execute_for_merge_request_pipeline).with(merge_request)
      end

      execute
    end

    it 'schedules CleanupRefsService' do
      expect(MergeRequests::CleanupRefsService).to receive(:schedule).with(merge_request)

      execute
    end

    it 'triggers GraphQL subscription mergeRequestMergeStatusUpdated' do
      expect(GraphqlTriggers).to receive(:merge_request_merge_status_updated).with(merge_request)

      execute
    end

    context 'current user is not authorized to close merge request' do
      let(:user) { guest }

      before do
        perform_enqueued_jobs do
          @merge_request = execute
        end
      end

      it 'does not close the merge request' do
        expect(@merge_request).to be_open
      end

      it 'does not trigger GraphQL subscription mergeRequestMergeStatusUpdated' do
        expect(GraphqlTriggers).not_to receive(:merge_request_merge_status_updated)

        execute
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class AfterCreateService < MergeRequests::BaseService
    include Gitlab::Utils::StrongMemoize

    def execute(merge_request)
      merge_request.ensure_merge_request_diff

      logger.info(**log_payload(merge_request, 'Executing hooks'))
      execute_hooks(merge_request)
      logger.info(**log_payload(merge_request, 'Executed hooks'))
      prepare_for_mergeability(merge_request)
      prepare_merge_request(merge_request)

      mark_merge_request_as_prepared(merge_request)
    end

    private

    def prepare_for_mergeability(merge_request)
      logger.info(**log_payload(merge_request, 'Creating pipeline'))
      create_pipeline_for(merge_request, current_user)
      logger.info(**log_payload(merge_request, 'Pipeline created'))
      merge_request.update_head_pipeline
      check_mergeability(merge_request)
    end

    def prepare_merge_request(merge_request)
      event_service.open_mr(merge_request, current_user)

      merge_request_activity_counter.track_create_mr_action(user: current_user, merge_request: merge_request)
      merge_request_activity_counter.track_mr_including_ci_config(user: current_user, merge_request: merge_request)

      notification_service.new_merge_request(merge_request, current_user)

      merge_request.diffs(include_stats: false).write_cache
      merge_request.create_cross_references!(current_user)

      Onboarding::ProgressService.new(merge_request.target_project.namespace).execute(action: :merge_request_created)

      todo_service.new_merge_request(merge_request, current_user)
      merge_request.cache_merge_request_closes_issues!(current_user)

      Gitlab::UsageDataCounters::MergeRequestCounter.count(:create)
      link_lfs_objects(merge_request)
    end

    def link_lfs_objects(merge_request)
      LinkLfsObjectsService.new(project: merge_request.target_project).execute(merge_request)
    end

    def check_mergeability(merge_request)
      return unless merge_request.preparing?

      # Need to set to unchecked to be able to check for mergeability or else
      # it'll be a no-op.
      merge_request.mark_as_unchecked
      merge_request.check_mergeability(async: true)
    end

    def mark_merge_request_as_prepared(merge_request)
      merge_request.update!(prepared_at: Time.current)
    end

    def logger
      @logger ||= Gitlab::AppLogger
    end

    def log_payload(merge_request, message)
      Gitlab::ApplicationContext.current.merge(
        merge_request_id: merge_request.id,
        message: message
      )
    end
  end
end

MergeRequests::AfterCreateService.prepend_mod_with('MergeRequests::AfterCreateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::AfterCreateService, feature_category: :code_review_workflow do
  let_it_be(:merge_request) { create(:merge_request) }
  let(:project) { merge_request.project }

  subject(:after_create_service) do
    described_class.new(project: merge_request.target_project, current_user: merge_request.author)
  end

  describe '#execute' do
    let(:event_service) { instance_double('EventCreateService', open_mr: true) }
    let(:notification_service) { instance_double('NotificationService', new_merge_request: true) }

    before do
      allow(after_create_service).to receive(:event_service).and_return(event_service)
      allow(after_create_service).to receive(:notification_service).and_return(notification_service)
    end

    subject(:execute_service) { after_create_service.execute(merge_request) }

    it 'creates a merge request open event' do
      expect(event_service)
        .to receive(:open_mr).with(merge_request, merge_request.author)

      execute_service
    end

    it 'calls the merge request activity counter' do
      expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
        .to receive(:track_create_mr_action)
        .with(user: merge_request.author, merge_request: merge_request)

      expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
        .to receive(:track_mr_including_ci_config)
        .with(user: merge_request.author, merge_request: merge_request)

      execute_service
    end

    it 'creates a new merge request notification' do
      expect(notification_service)
        .to receive(:new_merge_request).with(merge_request, merge_request.author)

      execute_service
    end

    it 'writes diffs to the cache' do
      expect(merge_request)
        .to receive_message_chain(:diffs, :write_cache)

      execute_service
    end

    it 'creates cross references' do
      expect(merge_request)
        .to receive(:create_cross_references!).with(merge_request.author)

      execute_service
    end

    it 'creates a pipeline and updates the HEAD pipeline' do
      expect(after_create_service)
        .to receive(:create_pipeline_for).with(merge_request, merge_request.author)
      expect(merge_request).to receive(:update_head_pipeline)

      execute_service
    end

    it 'executes hooks with default action' do
      expect(project).to receive(:execute_hooks)

      execute_service
    end

    it 'calls GroupMentionWorker' do
      expect(Integrations::GroupMentionWorker).to receive(:perform_async)

      execute_service
    end

    it_behaves_like 'records an onboarding progress action', :merge_request_created do
      let(:namespace) { merge_request.target_project.namespace }
    end

    context 'when merge request is in unchecked state' do
      before do
        merge_request.mark_as_unchecked!
        execute_service
      end

      it 'does not change its state' do
        expect(merge_request.reload).to be_unchecked
      end
    end

    context 'when merge request is in preparing state' do
      before do
        merge_request.mark_as_unchecked! unless merge_request.unchecked?
        merge_request.mark_as_preparing!
      end

      it 'checks for mergeability' do
        expect(merge_request).to receive(:check_mergeability).with(async: true)

        execute_service
      end

      context 'when preparing for mergeability fails' do
        before do
          # This is only one of the possible cases that can fail. This is to
          # simulate a failure that happens during the service call.
          allow(merge_request)
            .to receive(:update_head_pipeline)
            .and_raise(StandardError)
        end

        it 'does not mark the merge request as unchecked' do
          expect { execute_service }.to raise_error(StandardError)
          expect(merge_request.reload).to be_preparing
        end
      end

      context 'when preparing merge request fails' do
        before do
          # This is only one of the possible cases that can fail. This is to
          # simulate a failure that happens during the service call.
          allow(merge_request)
            .to receive_message_chain(:diffs, :write_cache)
            .and_raise(StandardError)
        end

        it 'still checks for mergeability' do
          expect(merge_request).to receive(:check_mergeability).with(async: true)
          expect { execute_service }.to raise_error(StandardError)
        end
      end
    end

    it 'updates the prepared_at' do
      # Need to reset the `prepared_at` since it can be already set in preceding tests.
      merge_request.update!(prepared_at: nil)

      freeze_time do
        expect { execute_service }.to change { merge_request.prepared_at }
          .from(nil)
          .to(Time.current)
      end
    end

    it 'increments the usage data counter of create event' do
      counter = Gitlab::UsageDataCounters::MergeRequestCounter

      expect { execute_service }.to change { counter.read(:create) }.by(1)
    end

    context 'todos' do
      it 'does not creates todos' do
        attributes = {
          project: merge_request.target_project,
          target_id: merge_request.id,
          target_type: merge_request.class.name
        }

        expect { execute_service }.not_to change { Todo.where(attributes).count }
      end

      context 'when merge request is assigned to someone' do
        let_it_be(:assignee) { create(:user) }
        let_it_be(:merge_request) { create(:merge_request, assignees: [assignee]) }

        it 'creates a todo for new assignee' do
          attributes = {
            project: merge_request.target_project,
            author: merge_request.author,
            user: assignee,
            target_id: merge_request.id,
            target_type: merge_request.class.name,
            action: Todo::ASSIGNED,
            state: :pending
          }

          expect { execute_service }.to change { Todo.where(attributes).count }.by(1)
        end
      end

      context 'when reviewer is assigned' do
        let_it_be(:reviewer) { create(:user) }
        let_it_be(:merge_request) { create(:merge_request, reviewers: [reviewer]) }

        it 'creates a todo for new reviewer' do
          attributes = {
            project: merge_request.target_project,
            author: merge_request.author,
            user: reviewer,
            target_id: merge_request.id,
            target_type: merge_request.class.name,
            action: Todo::REVIEW_REQUESTED,
            state: :pending
          }

          expect { execute_service }.to change { Todo.where(attributes).count }.by(1)
        end
      end
    end

    context 'when saving references to issues that the created merge request closes' do
      let_it_be(:first_issue) { create(:issue, project: merge_request.target_project) }
      let_it_be(:second_issue) { create(:issue, project: merge_request.target_project) }

      it 'creates a `MergeRequestsClosingIssues` record for each issue' do
        merge_request.description = ""Closes #{first_issue.to_reference} and #{second_issue.to_reference}""
        merge_request.source_branch = ""feature""
        merge_request.target_branch = merge_request.target_project.default_branch
        merge_request.save!

        execute_service

        issue_ids = MergeRequestsClosingIssues.where(merge_request: merge_request).pluck(:issue_id)
        expect(issue_ids).to match_array([first_issue.id, second_issue.id])
      end
    end

    it 'tracks merge request creation in usage data' do
      expect(Gitlab::UsageDataCounters::MergeRequestCounter).to receive(:count).with(:create)

      execute_service
    end

    it 'calls MergeRequests::LinkLfsObjectsService#execute' do
      service = instance_spy(MergeRequests::LinkLfsObjectsService)
      allow(MergeRequests::LinkLfsObjectsService).to receive(:new).with(project: merge_request.target_project).and_return(service)

      execute_service

      expect(service).to have_received(:execute).with(merge_request)
    end

    describe 'logging' do
      it 'logs specific events' do
        ::Gitlab::ApplicationContext.push(caller_id: 'NewMergeRequestWorker')

        allow(Gitlab::AppLogger).to receive(:info).and_call_original

        [
          'Executing hooks',
          'Executed hooks',
          'Creating pipeline',
          'Pipeline created'
        ].each do |message|
          expect(Gitlab::AppLogger).to receive(:info).with(
            hash_including(
              'meta.caller_id' => 'NewMergeRequestWorker',
              message: message,
              merge_request_id: merge_request.id
            )
          ).and_call_original
        end

        execute_service
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class CreatePipelineService < MergeRequests::BaseService
    def execute(merge_request)
      return cannot_create_pipeline_error unless can_create_pipeline_for?(merge_request)

      create_detached_merge_request_pipeline(merge_request)
    end

    def create_detached_merge_request_pipeline(merge_request)
      Ci::CreatePipelineService
        .new(pipeline_project(merge_request),
          current_user,
          ref: pipeline_ref_for_detached_merge_request_pipeline(merge_request),
          push_options: params[:push_options])
        .execute(:merge_request_event, merge_request: merge_request)
    end

    def can_create_pipeline_for?(merge_request)
      ##
      # UpdateMergeRequestsWorker could be retried by an exception.
      # pipelines for merge request should not be recreated in such case.
      return false if !allow_duplicate && merge_request.find_actual_head_pipeline&.merge_request?
      return false if merge_request.has_no_commits?

      true
    end

    def allow_duplicate
      params[:allow_duplicate]
    end

    private

    def pipeline_project(merge_request)
      if can_create_pipeline_in_target_project?(merge_request)
        merge_request.target_project
      else
        merge_request.source_project
      end
    end

    def pipeline_ref_for_detached_merge_request_pipeline(merge_request)
      if can_create_pipeline_in_target_project?(merge_request)
        merge_request.ref_path
      else
        merge_request.source_branch
      end
    end

    def can_create_pipeline_in_target_project?(merge_request)
      merge_request.target_project.ci_allow_fork_pipelines_to_run_in_parent_project? &&
        can?(current_user, :create_pipeline, merge_request.target_project) &&
        can_update_source_branch_in_target_project?(merge_request)
    end

    def can_update_source_branch_in_target_project?(merge_request)
      ::Gitlab::UserAccess.new(current_user, container: merge_request.target_project)
        .can_update_branch?(merge_request.source_branch_ref)
    end

    def cannot_create_pipeline_error
      ServiceResponse.error(message: 'Cannot create a pipeline for this merge request.', payload: nil)
    end
  end
end

MergeRequests::CreatePipelineService.prepend_mod_with('MergeRequests::CreatePipelineService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::CreatePipelineService, :clean_gitlab_redis_cache, feature_category: :code_review_workflow do
  include ProjectForksHelper

  let_it_be(:project, refind: true) { create(:project, :repository) }
  let_it_be(:user) { create(:user) }

  let(:service) { described_class.new(project: project, current_user: actor, params: params) }
  let(:actor) { user }
  let(:params) { {} }

  before do
    project.add_developer(user)
  end

  describe '#execute' do
    subject(:response) { service.execute(merge_request) }

    before do
      stub_ci_pipeline_yaml_file(YAML.dump(config))
    end

    let(:config) do
      { rspec: { script: 'echo', only: ['merge_requests'] } }
    end

    let(:merge_request) do
      create(:merge_request,
        source_branch: 'feature',
        source_project: source_project,
        target_branch: 'master',
        target_project: project)
    end

    let(:source_project) { project }

    it 'creates a detached merge request pipeline' do
      expect { response }.to change { Ci::Pipeline.count }.by(1)

      expect(response).to be_success
      expect(response.payload).to be_persisted
      expect(response.payload).to be_detached_merge_request_pipeline
    end

    it 'defaults to merge_request_event' do
      expect(response.payload.source).to eq('merge_request_event')
    end

    context 'when push options contain ci.skip' do
      let(:params) { { push_options: { ci: { skip: true } } } }

      it 'creates a skipped pipeline' do
        expect { response }.to change { Ci::Pipeline.count }.by(1)

        expect(response).to be_success
        expect(response.payload).to be_persisted
        expect(response.payload.builds).to be_empty
        expect(response.payload).to be_skipped
      end
    end

    context 'with fork merge request' do
      let_it_be(:forked_project) { fork_project(project, nil, repository: true, target_project: create(:project, :private, :repository)) }

      let(:source_project) { forked_project }

      context 'when actor has permission to create pipelines in target project' do
        let(:actor) { user }

        it 'creates a pipeline in the target project' do
          expect(response.payload.project).to eq(project)
        end

        context 'when the feature is disabled in CI/CD settings' do
          before do
            project.update!(ci_allow_fork_pipelines_to_run_in_parent_project: false)
          end

          it 'creates a pipeline in the source project' do
            expect(response.payload.project).to eq(source_project)
          end
        end

        context 'when source branch is protected' do
          context 'when actor does not have permission to update the protected branch in target project' do
            let!(:protected_branch) { create(:protected_branch, name: '*', project: project) }

            it 'creates a pipeline in the source project' do
              expect(response.payload.project).to eq(source_project)
            end
          end

          context 'when actor has permission to update the protected branch in target project' do
            let!(:protected_branch) { create(:protected_branch, :developers_can_merge, name: '*', project: project) }

            it 'creates a pipeline in the target project' do
              expect(response.payload.project).to eq(project)
            end
          end
        end
      end

      context 'when actor has permission to create pipelines in forked project' do
        let(:actor) { fork_user }
        let(:fork_user) { create(:user) }

        before do
          source_project.add_developer(fork_user)
        end

        it 'creates a pipeline in the source project' do
          expect(response.payload.project).to eq(source_project)
        end
      end

      context 'when actor does not have permission to create pipelines' do
        let(:actor) { create(:user) }

        it 'responds with error' do
          expect(response).to be_error
          expect(response.message).to include('Insufficient permissions to create a new pipeline')
        end
      end
    end

    context 'when service is called multiple times' do
      it 'creates a pipeline once' do
        expect do
          service.execute(merge_request)
          service.execute(merge_request)
        end.to change { Ci::Pipeline.count }.by(1)
      end

      context 'when allow_duplicate option is true' do
        let(:params) { { allow_duplicate: true } }

        it 'creates pipelines multiple times' do
          expect do
            service.execute(merge_request)
            service.execute(merge_request)
          end.to change { Ci::Pipeline.count }.by(2)
        end
      end
    end

    context 'when .gitlab-ci.yml does not use workflow:rules' do
      context 'without only: [merge_requests] keyword' do
        let(:config) do
          { rspec: { script: 'echo' } }
        end

        it 'does not create a pipeline' do
          expect { response }.not_to change { Ci::Pipeline.count }
        end
      end

      context 'with rules that specify creation on a tag' do
        let(:config) do
          {
            rspec: {
              script: 'echo',
              rules: [{ if: '$CI_COMMIT_TAG' }]
            }
          }
        end

        it 'does not create a pipeline' do
          expect { response }.not_to change { Ci::Pipeline.count }
        end
      end
    end

    context 'when workflow:rules are specified' do
      context 'when rules request creation on merge request' do
        let(:config) do
          {
            workflow: {
              rules: [{ if: '$CI_MERGE_REQUEST_ID' }]
            },
            rspec: { script: 'echo' }
          }
        end

        it 'creates a detached merge request pipeline', :aggregate_failures do
          expect { response }.to change { Ci::Pipeline.count }.by(1)

          expect(response).to be_success
          expect(response.payload).to be_persisted
          expect(response.payload).to be_detached_merge_request_pipeline
        end
      end

      context 'with rules do specify creation on a tag' do
        let(:config) do
          {
            workflow: {
              rules: [{ if: '$CI_COMMIT_TAG' }]
            },
            rspec: { script: 'echo' }
          }
        end

        it 'does not create a pipeline', :aggregate_failures do
          expect { response }.not_to change { Ci::Pipeline.count }
          expect(response).to be_error
        end
      end
    end

    context 'when merge request has no commits' do
      before do
        allow(merge_request).to receive(:has_no_commits?).and_return(true)
      end

      it 'does not create a pipeline', :aggregate_failures do
        expect { response }.not_to change { Ci::Pipeline.count }

        expect(response).to be_error
        expect(response.message).to eq('Cannot create a pipeline for this merge request.')
        expect(response.payload).to be_nil
      end
    end

    context 'when merge request pipeline creates a dynamic environment' do
      let(:config) do
        {
          review_app: {
            script: 'echo',
            only: ['merge_requests'],
            environment: { name: ""review/$CI_COMMIT_REF_NAME"" }
          }
        }
      end

      it 'associates merge request with the environment' do
        expect { response }.to change { Ci::Pipeline.count }.by(1)

        environment = Environment.find_by_name('review/feature')
        expect(response).to be_success
        expect(environment).to be_present
        expect(environment.merge_request).to eq(merge_request)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class MergeOrchestrationService < ::BaseService
    def execute(merge_request)
      return unless can_merge?(merge_request)

      merge_request.update(merge_error: nil)

      if can_merge_automatically?(merge_request)
        auto_merge_service.execute(merge_request)
      else
        merge_request.merge_async(current_user.id, params)
      end
    end

    def can_merge?(merge_request)
      can_merge_automatically?(merge_request) || can_merge_immediately?(merge_request)
    end

    def preferred_auto_merge_strategy(merge_request)
      auto_merge_service.preferred_strategy(merge_request)
    end

    private

    def can_merge_immediately?(merge_request)
      merge_request.can_be_merged_by?(current_user) &&
        merge_request.mergeable?
    end

    def can_merge_automatically?(merge_request)
      auto_merge_service.available_strategies(merge_request).any?
    end

    def auto_merge_service
      @auto_merge_service ||= AutoMergeService.new(project, current_user, params)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::MergeOrchestrationService, feature_category: :code_review_workflow do
  let_it_be(:maintainer) { create(:user) }

  let(:merge_params) { { sha: merge_request.diff_head_sha } }
  let(:user) { maintainer }
  let(:service) { described_class.new(project, user, merge_params) }

  let!(:merge_request) do
    create(
      :merge_request,
      source_project: project, source_branch: 'feature',
      target_project: project, target_branch: 'master'
    )
  end

  shared_context 'fresh repository' do
    let_it_be(:project) { create(:project, :repository) }

    before_all do
      project.add_maintainer(maintainer)
    end
  end

  describe '#execute' do
    subject { service.execute(merge_request) }

    include_context 'fresh repository'

    context 'when merge request is mergeable' do
      context 'when merge request can be merged automatically' do
        before do
          create(:ci_pipeline, :detached_merge_request_pipeline, project: project, merge_request: merge_request)
          merge_request.update_head_pipeline

          stub_licensed_features(merge_request_approvers: true) if Gitlab.ee?
        end

        it 'schedules auto merge' do
          expect_next_instance_of(AutoMergeService, project, user, merge_params) do |service|
            expect(service).to receive(:execute).with(merge_request).and_call_original
          end

          subject

          expect(merge_request).to be_auto_merge_enabled

          if Gitlab.ee?
            expect(merge_request.auto_merge_strategy).to(
              eq(AutoMergeService::STRATEGY_MERGE_WHEN_CHECKS_PASS)
            )
          else
            expect(merge_request.auto_merge_strategy).to(
              eq(AutoMergeService::STRATEGY_MERGE_WHEN_PIPELINE_SUCCEEDS)
            )
          end

          expect(merge_request).not_to be_merged
        end
      end

      context 'when merge request cannot be merged automatically' do
        it 'merges immediately', :sidekiq_inline do
          expect(merge_request)
            .to receive(:merge_async).with(user.id, merge_params)
            .and_call_original

          subject

          merge_request.reset
          expect(merge_request).to be_merged
          expect(merge_request).not_to be_auto_merge_enabled
        end
      end
    end

    context 'when merge request is not mergeable' do
      before do
        allow(merge_request).to receive(:mergeable?) { false }
      end

      it 'does nothing' do
        subject

        expect(merge_request).not_to be_auto_merge_enabled
        expect(merge_request).not_to be_merged
      end
    end
  end

  describe '#can_merge?' do
    subject { service.can_merge?(merge_request) }

    include_context 'fresh repository'

    context 'when merge request is mergeable' do
      it { is_expected.to eq(true) }
    end

    context 'when merge request is not mergeable' do
      before do
        allow(merge_request).to receive(:mergeable?) { false }
      end

      it { is_expected.to eq(false) }
    end
  end

  describe '#preferred_auto_merge_strategy' do
    subject { service.preferred_auto_merge_strategy(merge_request) }

    include_context 'fresh repository'

    context 'when merge request can be merged automatically' do
      before do
        create(:ci_pipeline, :detached_merge_request_pipeline, project: project, merge_request: merge_request)
        merge_request.update_head_pipeline

        stub_licensed_features(merge_request_approvers: true) if Gitlab.ee?
      end

      it 'fetches preferred auto merge strategy', if: Gitlab.ee? do
        is_expected.to eq(AutoMergeService::STRATEGY_MERGE_WHEN_CHECKS_PASS)
      end

      it 'fetches preferred auto merge strategy', unless: Gitlab.ee? do
        is_expected.to eq(AutoMergeService::STRATEGY_MERGE_WHEN_PIPELINE_SUCCEEDS)
      end
    end

    context 'when merge request cannot be merged automatically' do
      it { is_expected.to be_nil }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class UpdateService < MergeRequests::BaseService
    extend ::Gitlab::Utils::Override

    def initialize(project:, current_user: nil, params: {})
      super

      @target_branch_was_deleted = @params.delete(:target_branch_was_deleted)
    end

    def execute(merge_request)
      if Gitlab::Utils.to_boolean(params[:draft])
        merge_request.title = merge_request.draft_title
      end

      update_merge_request_with_specialized_service(merge_request) || general_fallback(merge_request)
    end

    def handle_changes(merge_request, options)
      super
      old_associations = options.fetch(:old_associations, {})
      old_labels = old_associations.fetch(:labels, [])
      old_mentioned_users = old_associations.fetch(:mentioned_users, [])
      old_assignees = old_associations.fetch(:assignees, [])
      old_reviewers = old_associations.fetch(:reviewers, [])
      old_timelogs = old_associations.fetch(:timelogs, [])
      changed_fields = merge_request.previous_changes.keys

      resolve_todos(merge_request, old_labels, old_assignees, old_reviewers)

      if merge_request.previous_changes.include?('title') ||
          merge_request.previous_changes.include?('description')
        todo_service.update_merge_request(merge_request, current_user, old_mentioned_users)
      end

      handle_target_branch_change(merge_request)
      handle_draft_status_change(merge_request, changed_fields)

      track_title_and_desc_edits(changed_fields)
      track_discussion_lock_toggle(merge_request, changed_fields)
      track_time_estimate_and_spend_edits(merge_request, old_timelogs, changed_fields)
      track_labels_change(merge_request, old_labels)

      notify_if_labels_added(merge_request, old_labels)
      notify_if_mentions_added(merge_request, old_mentioned_users)

      # Since #mark_as_unchecked triggers an update action through the MR's
      #   state machine, we want to push this as far down in the process so we
      #   avoid resetting #ActiveModel::Dirty
      #
      if merge_request.previous_changes.include?('target_branch') ||
          merge_request.previous_changes.include?('source_branch')
        merge_request.mark_as_unchecked unless merge_request.unchecked?
      end
    end

    def handle_task_changes(merge_request)
      todo_service.resolve_todos_for_target(merge_request, current_user)
      todo_service.update_merge_request(merge_request, current_user)
    end

    def reopen_service
      MergeRequests::ReopenService
    end

    def close_service
      MergeRequests::CloseService
    end

    def after_update(issuable, old_associations)
      super
      issuable.cache_merge_request_closes_issues!(current_user)
    end

    private

    attr_reader :target_branch_was_deleted

    def general_fallback(merge_request)
      # We don't allow change of source/target projects and source branch
      # after merge request was created
      params.delete(:source_project_id)
      params.delete(:target_project_id)
      params.delete(:source_branch)

      if merge_request.closed_or_merged_without_fork?
        params.delete(:target_branch)
        params.delete(:force_remove_source_branch)
      end

      update_task_event(merge_request) || update(merge_request)
    end

    def track_title_and_desc_edits(changed_fields)
      tracked_fields = %w[title description]

      return unless changed_fields.any? { |field| tracked_fields.include?(field) }

      tracked_fields.each do |action|
        next unless changed_fields.include?(action)

        merge_request_activity_counter
          .public_send(""track_#{action}_edit_action"".to_sym, user: current_user) # rubocop:disable GitlabSecurity/PublicSend
      end
    end

    def track_discussion_lock_toggle(merge_request, changed_fields)
      return unless changed_fields.include?('discussion_locked')

      if merge_request.discussion_locked
        merge_request_activity_counter.track_discussion_locked_action(user: current_user)
      else
        merge_request_activity_counter.track_discussion_unlocked_action(user: current_user)
      end
    end

    def track_time_estimate_and_spend_edits(merge_request, old_timelogs, changed_fields)
      merge_request_activity_counter.track_time_estimate_changed_action(user: current_user) if changed_fields.include?('time_estimate')
      merge_request_activity_counter.track_time_spent_changed_action(user: current_user) if old_timelogs != merge_request.timelogs
    end

    def track_labels_change(merge_request, old_labels)
      return if Set.new(merge_request.labels) == Set.new(old_labels)

      merge_request_activity_counter.track_labels_changed_action(user: current_user)
    end

    def notify_if_labels_added(merge_request, old_labels)
      added_labels = merge_request.labels - old_labels

      return unless added_labels.present?

      notification_service.async.relabeled_merge_request(
        merge_request,
        added_labels,
        current_user
      )
    end

    def notify_if_mentions_added(merge_request, old_mentioned_users)
      added_mentions = merge_request.mentioned_users(current_user) - old_mentioned_users

      return unless added_mentions.present?

      notification_service.async.new_mentions_in_merge_request(
        merge_request,
        added_mentions,
        current_user
      )
    end

    def resolve_todos(merge_request, old_labels, old_assignees, old_reviewers)
      return unless has_changes?(merge_request, old_labels: old_labels, old_assignees: old_assignees, old_reviewers: old_reviewers)

      resolve_todos_for(merge_request)
    end

    def handle_target_branch_change(merge_request)
      return unless merge_request.previous_changes.include?('target_branch')

      create_branch_change_note(
        merge_request,
        'target',
        target_branch_was_deleted ? 'delete' : 'update',
        merge_request.previous_changes['target_branch'].first,
        merge_request.target_branch
      )

      delete_approvals_on_target_branch_change(merge_request)
      refresh_pipelines_on_merge_requests(merge_request, allow_duplicate: true)

      abort_auto_merge(merge_request, 'target branch was changed')
    end

    def handle_draft_status_change(merge_request, changed_fields)
      return unless changed_fields.include?(""title"")

      old_title, new_title = merge_request.previous_changes[""title""]
      old_title_draft = MergeRequest.draft?(old_title)
      new_title_draft = MergeRequest.draft?(new_title)

      if old_title_draft || new_title_draft
        # notify the draft status changed. Added/removed message is handled in the
        # email template itself, see `change_in_merge_request_draft_status_email` template.
        notify_draft_status_changed(merge_request)
        trigger_merge_request_status_updated(merge_request)
        publish_draft_change_event(merge_request) if Feature.enabled?(:additional_merge_when_checks_ready, project)
      end

      if !old_title_draft && new_title_draft
        # Marked as Draft
        merge_request_activity_counter.track_marked_as_draft_action(user: current_user)
      elsif old_title_draft && !new_title_draft
        # Unmarked as Draft
        merge_request_activity_counter.track_unmarked_as_draft_action(user: current_user)
      end
    end

    def publish_draft_change_event(merge_request)
      Gitlab::EventStore.publish(
        MergeRequests::DraftStateChangeEvent.new(
          data: { current_user_id: current_user.id, merge_request_id: merge_request.id }
        )
      )
    end

    def notify_draft_status_changed(merge_request)
      notification_service.async.change_in_merge_request_draft_status(
        merge_request,
        current_user
      )
    end

    def create_branch_change_note(issuable, branch_type, event_type, old_branch, new_branch)
      SystemNoteService.change_branch(
        issuable, issuable.project, current_user, branch_type, event_type,
        old_branch, new_branch)
    end

    override :before_update
    def before_update(merge_request, skip_spam_check: false)
      merge_request.check_for_spam(user: current_user, action: :update) unless skip_spam_check
    end

    override :handle_quick_actions
    def handle_quick_actions(merge_request)
      super

      # Ensure this parameter does not get used as an attribute
      rebase = params.delete(:rebase)

      if rebase
        rebase_from_quick_action(merge_request)
        # Ignore ""/merge"" if ""/rebase"" is used to avoid an unexpected race
        params.delete(:merge)
      end

      merge_from_quick_action(merge_request) if params[:merge]
    end

    def rebase_from_quick_action(merge_request)
      merge_request.rebase_async(current_user.id)
    end

    def merge_from_quick_action(merge_request)
      last_diff_sha = params.delete(:merge)

      ::MergeRequests::MergeOrchestrationService
        .new(project, current_user, { sha: last_diff_sha })
        .execute(merge_request)
    end

    override :quick_action_options
    def quick_action_options
      { merge_request_diff_head_sha: params.delete(:merge_request_diff_head_sha) }
    end

    def update_merge_request_with_specialized_service(merge_request)
      return unless params.delete(:use_specialized_service)

      # If we're attempting to modify only a single attribute, look up whether
      #   we have a specialized, targeted service we should use instead. We may
      #   in the future extend this to include specialized services that operate
      #   on multiple attributes, but for now limit to only single attribute
      #   updates.
      #
      return unless params.one?

      attempt_specialized_update_services(merge_request, params.each_key.first.to_sym)
    end

    def attempt_specialized_update_services(merge_request, attribute)
      case attribute
      when :assignee_ids, :assignee_id
        assignees_service.execute(merge_request)
      when :spend_time
        add_time_spent_service.execute(merge_request)
      end
    end

    def assignees_service
      @assignees_service ||= ::MergeRequests::UpdateAssigneesService
        .new(project: project, current_user: current_user, params: params)
    end

    def add_time_spent_service
      @add_time_spent_service ||= ::MergeRequests::AddSpentTimeService.new(project: project, current_user: current_user, params: params)
    end

    def new_user_ids(merge_request, user_ids, attribute)
      # prime the cache - prevent N+1 lookup during authorization loop.
      return [] if user_ids.empty?

      merge_request.project.team.max_member_access_for_user_ids(user_ids)
      User.id_in(user_ids).map do |user|
        if user.can?(:read_merge_request, merge_request)
          user.id
        else
          merge_request.errors.add(
            attribute,
            ""Cannot assign #{user.to_reference} to #{merge_request.to_reference}""
          )
          nil
        end
      end.compact
    end

    def resolve_todos_for(merge_request)
      service_user = current_user

      merge_request.run_after_commit_or_now do
        ::MergeRequests::ResolveTodosService.new(merge_request, service_user).async_execute
      end
    end

    def filter_sentinel_values(param)
      param.reject { _1 == 0 }
    end

    def trigger_merge_request_status_updated(merge_request)
      GraphqlTriggers.merge_request_merge_status_updated(merge_request)
    end

    def delete_approvals_on_target_branch_change(_merge_request)
      # Overridden in EE. No-op since we only want to delete approvals in EE.
    end
  end
end

MergeRequests::UpdateService.prepend_mod_with('MergeRequests::UpdateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::UpdateService, :mailer, feature_category: :code_review_workflow do
  include ProjectForksHelper

  let(:group) { create(:group, :public) }
  let(:project) { create(:project, :private, :repository, group: group) }
  let(:user) { create(:user) }
  let(:user2) { create(:user) }
  let(:user3) { create(:user) }
  let(:label) { create(:label, title: 'a', project: project) }
  let(:label2) { create(:label) }
  let(:milestone) { create(:milestone, project: project) }

  let(:merge_request) do
    create(
      :merge_request,
      :simple,
      title: 'Old title',
      description: ""FYI #{user2.to_reference}"",
      assignee_ids: [user3.id],
      source_project: project,
      author: create(:user)
    )
  end

  before do
    project.add_maintainer(user)
    project.add_developer(user2)
    project.add_developer(user3)
  end

  describe 'execute' do
    def find_note(starting_with)
      @merge_request.notes.find do |note|
        note && note.note.start_with?(starting_with)
      end
    end

    def find_notes(action)
      @merge_request
        .notes
        .joins(:system_note_metadata)
        .where(system_note_metadata: { action: action })
    end

    def update_merge_request(opts)
      @merge_request = MergeRequests::UpdateService.new(project: project, current_user: user, params: opts).execute(merge_request)
      @merge_request.reload
    end

    it_behaves_like 'issuable update service updating last_edited_at values' do
      let(:issuable) { merge_request }
      subject(:update_issuable) { update_merge_request(update_params) }
    end

    context 'valid params' do
      let(:locked) { true }

      let(:opts) do
        {
          title: 'New title',
          description: 'Also please fix',
          assignee_ids: [user.id],
          reviewer_ids: [],
          state_event: 'close',
          label_ids: [label.id],
          target_branch: 'target',
          force_remove_source_branch: '1',
          discussion_locked: locked
        }
      end

      let(:service) { described_class.new(project: project, current_user: current_user, params: opts) }
      let(:current_user) { user }

      before do
        allow(service).to receive(:execute_hooks)

        perform_enqueued_jobs do
          @merge_request = service.execute(merge_request)
          @merge_request.reload
        end
      end

      it 'matches base expectations' do
        expect(@merge_request).to be_valid
        expect(@merge_request.title).to eq('New title')
        expect(@merge_request.assignees).to match_array([user])
        expect(@merge_request.reviewers).to match_array([])
        expect(@merge_request).to be_closed
        expect(@merge_request.labels.count).to eq(1)
        expect(@merge_request.labels.first.title).to eq(label.name)
        expect(@merge_request.target_branch).to eq('target')
        expect(@merge_request.merge_params['force_remove_source_branch']).to eq('1')
        expect(@merge_request.discussion_locked).to be_truthy
      end

      context 'usage counters' do
        let(:merge_request2) { create(:merge_request) }
        let(:draft_merge_request) { create(:merge_request, :draft_merge_request) }

        it 'update as expected' do
          expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
            .to receive(:track_title_edit_action).once.with(user: user)
          expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
            .to receive(:track_description_edit_action).once.with(user: user)

          described_class.new(project: project, current_user: user, params: opts).execute(merge_request2)
        end

        it 'tracks Draft marking' do
          expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
            .to receive(:track_marked_as_draft_action).once.with(user: user)

          opts[:title] = ""Draft: #{opts[:title]}""

          described_class.new(project: project, current_user: user, params: opts).execute(merge_request2)
        end

        it 'tracks Draft un-marking' do
          expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
            .to receive(:track_unmarked_as_draft_action).once.with(user: user)

          opts[:title] = ""Non-draft/wip title string""

          described_class.new(project: project, current_user: user, params: opts).execute(draft_merge_request)
        end

        context 'when MR is locked' do
          context 'when locked again' do
            it 'does not track discussion locking' do
              expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
                .not_to receive(:track_discussion_locked_action)

              opts[:discussion_locked] = true

              described_class.new(project: project, current_user: user, params: opts).execute(merge_request)
            end
          end

          context 'when unlocked' do
            it 'tracks dicussion unlocking' do
              expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
                .to receive(:track_discussion_unlocked_action).once.with(user: user)

              opts[:discussion_locked] = false

              described_class.new(project: project, current_user: user, params: opts).execute(merge_request)
            end
          end
        end

        context 'when MR is unlocked' do
          let(:locked) { false }

          context 'when unlocked again' do
            it 'does not track discussion unlocking' do
              expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
                .not_to receive(:track_discussion_unlocked_action)

              opts[:discussion_locked] = false

              described_class.new(project: project, current_user: user, params: opts).execute(merge_request)
            end
          end

          context 'when locked' do
            it 'tracks dicussion locking' do
              expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
                .to receive(:track_discussion_locked_action).once.with(user: user)

              opts[:discussion_locked] = true

              described_class.new(project: project, current_user: user, params: opts).execute(merge_request)
            end
          end
        end

        it 'tracks time estimate and spend time changes' do
          expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
            .to receive(:track_time_estimate_changed_action).once.with(user: user)

          expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
            .to receive(:track_time_spent_changed_action).once.with(user: user)

          opts[:time_estimate] = 86400
          opts[:spend_time] = {
            duration: 3600,
            user_id: user.id,
            spent_at: Date.parse('2021-02-24')
          }

          described_class.new(project: project, current_user: user, params: opts).execute(merge_request)
        end

        it 'tracks milestone change' do
          expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
            .to receive(:track_milestone_changed_action).once.with(user: user)

          opts[:milestone_id] = milestone.id

          described_class.new(project: project, current_user: user, params: opts).execute(merge_request)
        end

        it 'track labels change' do
          expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
            .to receive(:track_labels_changed_action).once.with(user: user)

          opts[:label_ids] = [label2.id]

          described_class.new(project: project, current_user: user, params: opts).execute(merge_request)
        end

        context 'reviewers' do
          context 'when reviewers changed' do
            it 'tracks reviewers changed event' do
              expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
                .to receive(:track_reviewers_changed_action).once.with(user: user)

              opts[:reviewers] = [user2]

              described_class.new(project: project, current_user: user, params: opts).execute(merge_request)
            end
          end

          context 'when reviewers did not change' do
            it 'does not track reviewers changed event' do
              expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
                .not_to receive(:track_reviewers_changed_action)

              opts[:reviewers] = merge_request.reviewers

              described_class.new(project: project, current_user: user, params: opts).execute(merge_request)
            end
          end
        end
      end

      context 'updating milestone' do
        context 'with milestone_id param' do
          let(:opts) { { milestone_id: milestone.id } }

          it 'sets milestone' do
            expect(@merge_request.milestone).to eq milestone
          end
        end

        context 'milestone counters cache reset' do
          let(:milestone_old) { create(:milestone, project: project) }
          let(:opts) { { milestone_id: milestone_old.id } }

          it 'deletes milestone counters' do
            expect_next_instance_of(Milestones::MergeRequestsCountService, milestone_old) do |service|
              expect(service).to receive(:delete_cache).and_call_original
            end

            expect_next_instance_of(Milestones::MergeRequestsCountService, milestone) do |service|
              expect(service).to receive(:delete_cache).and_call_original
            end

            update_merge_request(milestone_id: milestone.id)
          end

          it 'deletes milestone counters when the milestone is removed' do
            expect_next_instance_of(Milestones::MergeRequestsCountService, milestone_old) do |service|
              expect(service).to receive(:delete_cache).and_call_original
            end

            update_merge_request(milestone_id: nil)
          end

          it 'deletes milestone counters when the milestone was not set' do
            update_merge_request(milestone_id: nil)

            expect_next_instance_of(Milestones::MergeRequestsCountService, milestone) do |service|
              expect(service).to receive(:delete_cache).and_call_original
            end

            update_merge_request(milestone_id: milestone.id)
          end
        end
      end

      it 'executes hooks with update action' do
        expect(service).to have_received(:execute_hooks)
          .with(
            @merge_request,
            'update',
            old_associations: {
              labels: [],
              mentioned_users: [user2],
              assignees: [user3],
              reviewers: [],
              milestone: nil,
              total_time_spent: 0,
              time_change: 0,
              description: ""FYI #{user2.to_reference}""
            }
          )
      end

      context 'with reviewers' do
        let(:opts) { { reviewer_ids: [user2.id] } }

        it 'creates system note about merge_request review request' do
          note = find_note('requested review from')

          expect(note).not_to be_nil
          expect(note.note).to include ""requested review from #{user2.to_reference}""
        end

        it 'updates the tracking' do
          expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
            .to receive(:track_users_review_requested)
            .with(users: [user])

          update_merge_request(reviewer_ids: [user.id])
        end
      end

      it 'creates a resource label event' do
        event = merge_request.resource_label_events.last

        expect(event).not_to be_nil
        expect(event.label_id).to eq label.id
        expect(event.user_id).to eq user.id
      end

      it 'creates system note about title change' do
        note = find_note('changed title')

        expect(note).not_to be_nil
        expect(note.note).to eq 'changed title from **{-Old-} title** to **{+New+} title**'
      end

      it 'creates system note about description change' do
        note = find_note('changed the description')

        expect(note).not_to be_nil
        expect(note.note).to eq('changed the description')
      end

      it 'creates system note about branch change' do
        note = find_note('changed target')

        expect(note).not_to be_nil
        expect(note.note).to eq 'changed target branch from `master` to `target`'
      end

      it 'creates system note about discussion lock' do
        note = find_note('locked the discussion in this merge request')

        expect(note).not_to be_nil
        expect(note.note).to eq 'locked the discussion in this merge request'
      end

      context 'when current user cannot admin issues in the project' do
        let(:guest) { create(:user) }
        let(:current_user) { guest }

        before do
          project.add_guest(guest)
        end

        it 'filters out params that cannot be set without the :admin_merge_request permission' do
          expect(@merge_request).to be_valid
          expect(@merge_request.title).to eq('New title')
          expect(@merge_request.assignees).to match_array([user3])
          expect(@merge_request).to be_opened
          expect(@merge_request.labels.count).to eq(0)
          expect(@merge_request.target_branch).to eq('target')
          expect(@merge_request.discussion_locked).to be_falsey
          expect(@merge_request.milestone).to be_nil
        end

        context 'updating milestone' do
          RSpec.shared_examples 'does not update milestone' do
            it 'sets milestone' do
              expect(@merge_request.milestone).to be_nil
            end
          end

          context 'when milestone_id param' do
            let(:opts) { { milestone_id: milestone.id } }

            it_behaves_like 'does not update milestone'
          end

          context 'when milestone param' do
            let(:opts) { { milestone: milestone } }

            it_behaves_like 'does not update milestone'
          end
        end
      end

      context 'when not including source branch removal options' do
        before do
          opts.delete(:force_remove_source_branch)
        end

        it 'maintains the original options' do
          update_merge_request(opts)

          expect(@merge_request.merge_params[""force_remove_source_branch""]).to eq(""1"")
        end
      end

      it_behaves_like 'reviewer_ids filter' do
        let(:opts) { {} }
        let(:execute) { update_merge_request(opts) }
      end

      context 'with an existing reviewer' do
        let(:merge_request) do
          create(:merge_request, :simple, source_project: project, reviewer_ids: [user2.id])
        end

        let(:opts) { { reviewer_ids: [IssuableFinder::Params::NONE] } }

        it 'removes reviewers' do
          expect(update_merge_request(opts).reviewers).to eq []
        end
      end

      describe 'checking for spam' do
        it 'checks for spam' do
          expect(merge_request).to receive(:check_for_spam).with(user: user, action: :update)

          update_merge_request(opts)
        end

        it 'marks the merge request invalid' do
          merge_request.spam!

          update_merge_request(title: 'New title')

          expect(merge_request).to be_invalid
        end
      end
    end

    context 'after_save callback to store_mentions' do
      let(:merge_request) { create(:merge_request, title: 'Old title', description: ""simple description"", source_branch: 'test', source_project: project, author: user) }
      let(:labels) { create_pair(:label, project: project) }
      let(:milestone) { create(:milestone, project: project) }
      let(:req_opts) { { source_branch: 'feature', target_branch: 'master' } }

      subject { described_class.new(project: project, current_user: user, params: opts).execute(merge_request) }

      context 'when mentionable attributes change' do
        let(:opts) { { description: ""Description with #{user.to_reference}"" }.merge(req_opts) }

        it 'saves mentions' do
          expect(merge_request).to receive(:store_mentions!).and_call_original

          expect { subject }.to change { MergeRequestUserMention.count }.by(1)

          expect(merge_request.referenced_users).to match_array([user])
        end
      end

      context 'when mentionable attributes do not change' do
        let(:opts) { { label_ids: [label.id, label2.id], milestone_id: milestone.id }.merge(req_opts) }

        it 'does not call store_mentions' do
          expect(merge_request).not_to receive(:store_mentions!).and_call_original

          expect { subject }.not_to change { MergeRequestUserMention.count }

          expect(merge_request.referenced_users).to be_empty
        end
      end

      context 'when save fails' do
        let(:opts) { { title: '', label_ids: labels.map(&:id), milestone_id: milestone.id } }

        it 'does not call store_mentions' do
          expect(merge_request).not_to receive(:store_mentions!).and_call_original

          expect { subject }.not_to change { MergeRequestUserMention.count }

          expect(merge_request.referenced_users).to be_empty
          expect(merge_request.valid?).to be false
        end
      end
    end

    shared_examples_for ""creates a new pipeline"" do
      it ""creates a new pipeline"" do
        expect(MergeRequests::CreatePipelineWorker)
          .to receive(:perform_async)
          .with(project.id, user.id, merge_request.id, { ""allow_duplicate"" => true })

        update_merge_request(target_branch: new_target_branch)
      end
    end

    shared_examples_for 'correct merge behavior' do
      let(:opts) do
        {
          merge: merge_request.diff_head_sha
        }
      end

      let(:service) { described_class.new(project: project, current_user: user, params: opts) }

      context 'without pipeline' do
        before do
          merge_request.merge_error = 'Error'

          service.execute(merge_request)
          @merge_request = MergeRequest.find(merge_request.id)
        end

        it 'merges the MR', :sidekiq_inline do
          expect(@merge_request).to be_valid
          expect(@merge_request.state).to eq('merged')
          expect(@merge_request.merge_error).to be_nil
        end
      end

      context 'with finished pipeline' do
        before do
          create(:ci_pipeline,
            project: project,
            ref: merge_request.source_branch,
            sha: merge_request.diff_head_sha,
            status: :success)

          @merge_request = service.execute(merge_request)
          @merge_request = MergeRequest.find(merge_request.id)
        end

        it 'merges the MR', :sidekiq_inline do
          expect(@merge_request).to be_valid
          expect(@merge_request.state).to eq('merged')
        end
      end

      context 'with active pipeline' do
        before do
          service_mock = double
          create(
            :ci_pipeline,
            project: project,
            ref: merge_request.source_branch,
            sha: merge_request.diff_head_sha,
            head_pipeline_of: merge_request
          )

          strategies_count = Gitlab.ee? ? :twice : :once
          expect(AutoMerge::MergeWhenPipelineSucceedsService).to receive(:new).exactly(strategies_count).with(project, user, { sha: merge_request.diff_head_sha })
            .and_return(service_mock)
          allow(service_mock).to receive(:available_for?) { true }
          expect(service_mock).to receive(:execute).with(merge_request)
        end

        it { service.execute(merge_request) }
      end

      context 'with a non-authorised user' do
        let(:visitor) { create(:user) }
        let(:service) { described_class.new(project: project, current_user: visitor, params: opts) }

        before do
          merge_request.update_attribute(:merge_error, 'Error')

          perform_enqueued_jobs do
            @merge_request = service.execute(merge_request)
            @merge_request = MergeRequest.find(merge_request.id)
          end
        end

        it 'does not merge the MR' do
          expect(@merge_request.state).to eq('opened')
          expect(@merge_request.merge_error).not_to be_nil
        end
      end

      context 'MR can not be merged when note sha != MR sha' do
        let(:opts) do
          {
            merge: 'other_commit'
          }
        end

        before do
          perform_enqueued_jobs do
            @merge_request = service.execute(merge_request)
            @merge_request = MergeRequest.find(merge_request.id)
          end
        end

        it { expect(@merge_request.state).to eq('opened') }
      end
    end

    describe 'merge' do
      it_behaves_like 'correct merge behavior'
    end

    context 'todos' do
      let!(:pending_todo) { create(:todo, :assigned, user: user, project: project, target: merge_request, author: user2) }

      context 'when the title change' do
        it 'calls MergeRequest::ResolveTodosService#async_execute' do
          expect_next_instance_of(MergeRequests::ResolveTodosService, merge_request, user) do |service|
            expect(service).to receive(:async_execute)
          end

          update_merge_request({ title: 'New title' })
        end

        it 'does not create any new todos' do
          update_merge_request({ title: 'New title' })

          expect(Todo.count).to eq(1)
        end
      end

      context 'when the description change' do
        it 'calls MergeRequest::ResolveTodosService#async_execute' do
          expect_next_instance_of(MergeRequests::ResolveTodosService, merge_request, user) do |service|
            expect(service).to receive(:async_execute)
          end

          update_merge_request({ description: ""Also please fix #{user2.to_reference} #{user3.to_reference}"" })
        end

        it 'creates only 1 new todo' do
          update_merge_request({ description: ""Also please fix #{user2.to_reference} #{user3.to_reference}"" })

          expect(Todo.count).to eq(2)
        end

        it 'triggers GraphQL description updated subscription' do
          expect(GraphqlTriggers).to receive(:issuable_description_updated).with(merge_request).and_call_original

          update_merge_request(description: 'updated description')
        end
      end

      context 'when decription is not changed' do
        it 'does not trigger GraphQL description updated subscription' do
          expect(GraphqlTriggers).not_to receive(:issuable_description_updated)

          update_merge_request(title: 'updated title')
        end
      end

      context 'when is reassigned' do
        it 'calls MergeRequest::ResolveTodosService#async_execute' do
          expect_next_instance_of(MergeRequests::ResolveTodosService, merge_request, user) do |service|
            expect(service).to receive(:async_execute)
          end

          update_merge_request({ assignee_ids: [user2.id] })
        end
      end

      context 'when reviewers gets changed' do
        it 'calls MergeRequest::ResolveTodosService#async_execute' do
          expect_next_instance_of(MergeRequests::ResolveTodosService, merge_request, user) do |service|
            expect(service).to receive(:async_execute)
          end

          update_merge_request({ reviewer_ids: [user2.id] })
        end

        it 'creates a pending todo for new review request' do
          update_merge_request({ reviewer_ids: [user2.id] })

          attributes = {
            project: project,
            author: user,
            user: user2,
            target_id: merge_request.id,
            target_type: merge_request.class.name,
            action: Todo::REVIEW_REQUESTED,
            state: :pending
          }

          expect(Todo.where(attributes).count).to eq 1
        end

        it 'sends email reviewer change notifications to old and new reviewers', :sidekiq_inline do
          merge_request.reviewers = [user2]

          perform_enqueued_jobs do
            update_merge_request({ reviewer_ids: [user3.id] })
          end

          should_email(user2)
          should_email(user3)
        end

        it 'updates open merge request counter for reviewers', :use_clean_rails_memory_store_caching do
          merge_request.reviewers = [user3]

          # Cache them to ensure the cache gets invalidated on update
          expect(user2.review_requested_open_merge_requests_count).to eq(0)
          expect(user3.review_requested_open_merge_requests_count).to eq(1)

          update_merge_request(reviewer_ids: [user2.id])

          expect(user2.review_requested_open_merge_requests_count).to eq(1)
          expect(user3.review_requested_open_merge_requests_count).to eq(0)
        end

        it_behaves_like 'triggers GraphQL subscription mergeRequestReviewersUpdated' do
          let(:action) { update_merge_request({ reviewer_ids: [user2.id] }) }
        end
      end

      context 'when reviewers did not change' do
        it_behaves_like 'does not trigger GraphQL subscription mergeRequestReviewersUpdated' do
          let(:action) { update_merge_request({ reviewer_ids: [merge_request.reviewer_ids] }) }
        end
      end

      context 'when the milestone is removed' do
        let!(:non_subscriber) { create(:user) }

        let!(:subscriber) do
          create(:user) do |u|
            merge_request.toggle_subscription(u, project)
            project.add_developer(u)
          end
        end

        it 'sends notifications for subscribers of changed milestone', :sidekiq_inline do
          merge_request.milestone = create(:milestone, project: project)

          merge_request.save!

          perform_enqueued_jobs do
            update_merge_request(milestone_id: """")
          end

          should_email(subscriber)
          should_not_email(non_subscriber)
        end
      end

      context 'when the milestone is changed' do
        let!(:non_subscriber) { create(:user) }

        let!(:subscriber) do
          create(:user) do |u|
            merge_request.toggle_subscription(u, project)
            project.add_developer(u)
          end
        end

        it 'calls MergeRequests::ResolveTodosService#async_execute' do
          expect_next_instance_of(MergeRequests::ResolveTodosService, merge_request, user) do |service|
            expect(service).to receive(:async_execute)
          end

          update_merge_request(milestone_id: create(:milestone, project: project).id)
        end

        it 'sends notifications for subscribers of changed milestone', :sidekiq_inline do
          perform_enqueued_jobs do
            update_merge_request(milestone_id: create(:milestone, project: project).id)
          end

          should_email(subscriber)
          should_not_email(non_subscriber)
        end
      end

      context 'when the labels change' do
        it 'calls MergeRequests::ResolveTodosService#async_execute' do
          expect_next_instance_of(MergeRequests::ResolveTodosService, merge_request, user) do |service|
            expect(service).to receive(:async_execute)
          end

          update_merge_request({ label_ids: [label.id] })
        end

        it 'updates updated_at' do
          travel_to(1.minute.from_now) do
            update_merge_request({ label_ids: [label.id] })
          end

          expect(merge_request.reload.updated_at).to be_future
        end
      end

      context 'when the assignee changes' do
        it 'updates open merge request counter for assignees when merge request is reassigned' do
          update_merge_request(assignee_ids: [user2.id])

          expect(user3.assigned_open_merge_requests_count).to eq 0
          expect(user2.assigned_open_merge_requests_count).to eq 1
        end

        it 'records the assignment history', :sidekiq_inline do
          original_assignee = merge_request.assignees.first!

          update_merge_request(assignee_ids: [user2.id])

          expected_events = [
            have_attributes({
              merge_request_id: merge_request.id,
              user_id: original_assignee.id,
              action: 'remove'
            }),
            have_attributes({
              merge_request_id: merge_request.id,
              user_id: user2.id,
              action: 'add'
            })
          ]

          expect(merge_request.assignment_events).to match_array(expected_events)
        end
      end

      context 'when the target branch changes' do
        it 'calls MergeRequests::ResolveTodosService#async_execute' do
          expect_next_instance_of(MergeRequests::ResolveTodosService, merge_request, user) do |service|
            expect(service).to receive(:async_execute)
          end

          update_merge_request({ target_branch: 'target' })
        end

        it ""does not try to mark as unchecked if it's already unchecked"" do
          allow(merge_request).to receive(:unchecked?).twice.and_return(true)
          expect(merge_request).not_to receive(:mark_as_unchecked)

          update_merge_request({ target_branch: ""target"" })
        end

        it_behaves_like ""creates a new pipeline"" do
          let(:new_target_branch) { ""target"" }
        end
      end

      context 'when auto merge is enabled and target branch changed' do
        before do
          AutoMergeService.new(project, user, { sha: merge_request.diff_head_sha }).execute(merge_request, AutoMergeService::STRATEGY_MERGE_WHEN_PIPELINE_SUCCEEDS)
        end

        it 'calls MergeRequests::ResolveTodosService#async_execute' do
          expect_next_instance_of(MergeRequests::ResolveTodosService, merge_request, user) do |service|
            expect(service).to receive(:async_execute)
          end

          update_merge_request({ target_branch: 'target' })
        end

        it_behaves_like ""creates a new pipeline"" do
          let(:new_target_branch) { ""target"" }
        end
      end
    end

    context 'when the draft status is changed' do
      let(:title) { 'New Title' }
      let(:draft_title) { ""Draft: #{title}"" }
      let!(:non_subscriber) { create(:user) }
      let!(:subscriber) do
        create(:user) { |u| merge_request.toggle_subscription(u, project) }
      end

      before do
        project.add_developer(non_subscriber)
        project.add_developer(subscriber)
      end

      context 'removing draft status' do
        before do
          merge_request.update_attribute(:title, draft_title)
        end

        it 'sends notifications for subscribers', :sidekiq_inline do
          opts = { title: 'New title' }

          perform_enqueued_jobs do
            @merge_request = described_class.new(project: project, current_user: user, params: opts).execute(merge_request)
          end

          should_email(subscriber)
          should_not_email(non_subscriber)
        end

        it 'triggers GraphQL subscription mergeRequestMergeStatusUpdated' do
          expect(GraphqlTriggers).to receive(:merge_request_merge_status_updated).with(merge_request)

          update_merge_request(title: 'New title')
        end

        context 'when additional_merge_when_checks_ready is enabled' do
          it 'publishes a DraftStateChangeEvent' do
            expected_data = {
              current_user_id: user.id,
              merge_request_id: merge_request.id
            }

            expect { update_merge_request(title: 'New title') }.to publish_event(MergeRequests::DraftStateChangeEvent).with(expected_data)
          end
        end

        context 'when additional_merge_when_checks_ready is disabled' do
          before do
            stub_feature_flags(additional_merge_when_checks_ready: false)
          end

          it 'does not publish a DraftStateChangeEvent' do
            expect { update_merge_request(title: 'New title') }.not_to publish_event(MergeRequests::DraftStateChangeEvent)
          end
        end

        context 'when removing through wip_event param' do
          it 'removes Draft from the title' do
            expect { update_merge_request({ wip_event: ""ready"" }) }
              .to change { merge_request.title }
              .from(draft_title)
              .to(title)
          end
        end
      end

      context 'adding draft status' do
        before do
          merge_request.update_attribute(:title, title)
        end

        it 'does not send notifications', :sidekiq_inline do
          opts = { title: 'Draft: New title' }

          perform_enqueued_jobs do
            @merge_request = described_class.new(project: project, current_user: user, params: opts).execute(merge_request)
          end

          should_email(subscriber)
          should_not_email(non_subscriber)
        end

        context 'when additional_merge_when_checks_ready is enabled' do
          it 'publishes a DraftStateChangeEvent' do
            expected_data = {
              current_user_id: user.id,
              merge_request_id: merge_request.id
            }

            expect { update_merge_request(title: 'Draft: New title') }.to publish_event(MergeRequests::DraftStateChangeEvent).with(expected_data)
          end
        end

        context 'when additional_merge_when_checks_ready is disabled' do
          before do
            stub_feature_flags(additional_merge_when_checks_ready: false)
          end

          it 'does not publish a DraftStateChangeEvent' do
            expect { update_merge_request(title: 'Draft: New title') }.not_to publish_event(MergeRequests::DraftStateChangeEvent)
          end
        end

        it 'triggers GraphQL subscription mergeRequestMergeStatusUpdated' do
          expect(GraphqlTriggers).to receive(:merge_request_merge_status_updated).with(merge_request)

          update_merge_request(title: 'Draft: New title')
        end

        context 'when adding through wip_event param' do
          it 'adds Draft to the title' do
            expect { update_merge_request({ wip_event: ""draft"" }) }
              .to change { merge_request.title }
              .from(title)
              .to(draft_title)
          end
        end
      end
    end

    context 'when the merge request is relabeled' do
      let!(:non_subscriber) { create(:user) }
      let!(:subscriber) { create(:user) { |u| label.toggle_subscription(u, project) } }

      before do
        project.add_developer(non_subscriber)
        project.add_developer(subscriber)
      end

      it 'sends notifications for subscribers of newly added labels', :sidekiq_inline do
        opts = { label_ids: [label.id] }

        perform_enqueued_jobs do
          @merge_request = described_class.new(project: project, current_user: user, params: opts).execute(merge_request)
        end

        should_email(subscriber)
        should_not_email(non_subscriber)
      end

      context 'when issue has the `label` label' do
        before do
          merge_request.labels << label
        end

        it 'does not send notifications for existing labels' do
          opts = { label_ids: [label.id, label2.id] }

          perform_enqueued_jobs do
            @merge_request = described_class.new(project: project, current_user: user, params: opts).execute(merge_request)
          end

          should_not_email(subscriber)
          should_not_email(non_subscriber)
        end

        it 'does not send notifications for removed labels' do
          opts = { label_ids: [label2.id] }

          perform_enqueued_jobs do
            @merge_request = described_class.new(project: project, current_user: user, params: opts).execute(merge_request)
          end

          should_not_email(subscriber)
          should_not_email(non_subscriber)
        end
      end
    end

    context 'updating mentions' do
      let(:mentionable) { merge_request }

      include_examples 'updating mentions', described_class
    end

    context 'when MergeRequest has tasks' do
      before do
        update_merge_request({ description: ""- [ ] Task 1\n- [ ] Task 2"" })
      end

      it { expect(@merge_request.tasks?).to eq(true) }

      it_behaves_like 'updating a single task'

      context 'when tasks are marked as completed' do
        before do
          update_merge_request({ description: ""- [x] Task 1\n- [X] Task 2"" })
        end

        it 'creates system note about task status change' do
          note1 = find_note('marked the checklist item **Task 1** as completed')
          note2 = find_note('marked the checklist item **Task 2** as completed')

          expect(note1).not_to be_nil
          expect(note2).not_to be_nil

          description_notes = find_notes('description')
          expect(description_notes.length).to eq(1)
        end
      end

      context 'when tasks are marked as incomplete' do
        before do
          update_merge_request({ description: ""- [x] Task 1\n- [X] Task 2"" })
          update_merge_request({ description: ""- [ ] Task 1\n- [ ] Task 2"" })
        end

        it 'creates system note about task status change' do
          note1 = find_note('marked the checklist item **Task 1** as incomplete')
          note2 = find_note('marked the checklist item **Task 2** as incomplete')

          expect(note1).not_to be_nil
          expect(note2).not_to be_nil

          description_notes = find_notes('description')
          expect(description_notes.length).to eq(1)
        end
      end
    end

    context 'while saving references to issues that the updated merge request closes' do
      let(:first_issue) { create(:issue, project: project) }
      let(:second_issue) { create(:issue, project: project) }

      it 'creates a `MergeRequestsClosingIssues` record for each issue' do
        issue_closing_opts = { description: ""Closes #{first_issue.to_reference} and #{second_issue.to_reference}"" }
        service = described_class.new(project: project, current_user: user, params: issue_closing_opts)
        allow(service).to receive(:execute_hooks)
        service.execute(merge_request)

        issue_ids = MergeRequestsClosingIssues.where(merge_request: merge_request).pluck(:issue_id)
        expect(issue_ids).to match_array([first_issue.id, second_issue.id])
      end

      it 'removes `MergeRequestsClosingIssues` records when issues are not closed anymore' do
        create(:merge_requests_closing_issues, issue: first_issue, merge_request: merge_request)
        create(:merge_requests_closing_issues, issue: second_issue, merge_request: merge_request)

        service = described_class.new(project: project, current_user: user, params: { description: ""not closing any issues"" })
        allow(service).to receive(:execute_hooks)
        service.execute(merge_request.reload)

        issue_ids = MergeRequestsClosingIssues.where(merge_request: merge_request).pluck(:issue_id)
        expect(issue_ids).to be_empty
      end
    end

    context 'updating asssignee_ids' do
      context ':use_specialized_service' do
        context 'when true' do
          it 'passes the update action to ::MergeRequests::UpdateAssigneesService' do
            expect(::MergeRequests::UpdateAssigneesService)
              .to receive(:new).and_call_original

            update_merge_request({
              assignee_ids: [user2.id],
              use_specialized_service: true
            })
          end
        end

        context 'when false or nil' do
          before do
            expect(::MergeRequests::UpdateAssigneesService).not_to receive(:new)
          end

          it 'does not pass the update action to ::MergeRequests::UpdateAssigneesService when false' do
            update_merge_request({
              assignee_ids: [user2.id],
              use_specialized_service: false
            })
          end

          it 'does not pass the update action to ::MergeRequests::UpdateAssigneesService when nil' do
            update_merge_request({
              assignee_ids: [user2.id],
              use_specialized_service: nil
            })
          end
        end
      end

      it 'does not update assignee when assignee_id is invalid' do
        merge_request.update!(assignee_ids: [user.id])

        expect(MergeRequests::HandleAssigneesChangeService).not_to receive(:new)

        update_merge_request(assignee_ids: [-1])

        expect(merge_request.reload.assignees).to eq([user])
      end

      it 'unassigns assignee when user id is 0' do
        merge_request.update!(assignee_ids: [user.id])

        expect_next_instance_of(MergeRequests::HandleAssigneesChangeService, project: project, current_user: user) do |service|
          expect(service)
            .to receive(:async_execute)
            .with(merge_request, [user])
        end

        update_merge_request(assignee_ids: [0])

        expect(merge_request.assignee_ids).to be_empty
      end

      it 'saves assignee when user id is valid' do
        expect_next_instance_of(MergeRequests::HandleAssigneesChangeService, project: project, current_user: user) do |service|
          expect(service)
            .to receive(:async_execute)
            .with(merge_request, [user3])
        end

        update_merge_request(assignee_ids: [user.id])

        expect(merge_request.assignee_ids).to eq([user.id])
      end

      it 'does not update assignee_id when user cannot read issue' do
        non_member = create(:user)
        original_assignees = merge_request.assignees

        expect(MergeRequests::HandleAssigneesChangeService).not_to receive(:new)

        update_merge_request(assignee_ids: [non_member.id])

        expect(merge_request.reload.assignees).to eq(original_assignees)
      end

      context ""when issuable feature is private"" do
        levels = [Gitlab::VisibilityLevel::INTERNAL, Gitlab::VisibilityLevel::PUBLIC]

        levels.each do |level|
          it ""does not update with unauthorized assignee when project is #{Gitlab::VisibilityLevel.level_name(level)}"" do
            assignee = create(:user)
            project.update!(visibility_level: level)
            feature_visibility_attr = :""#{merge_request.model_name.plural}_access_level""
            project.project_feature.update_attribute(feature_visibility_attr, ProjectFeature::PRIVATE)

            expect { update_merge_request(assignee_ids: [assignee]) }.not_to change(merge_request.assignees, :count)
          end
        end
      end
    end

    context 'when adding time spent' do
      let(:spend_time) { { duration: 1800, user_id: user3.id } }

      context ':use_specialized_service' do
        context 'when true' do
          it 'passes the update action to ::MergeRequests::AddSpentTimeService' do
            expect(::MergeRequests::AddSpentTimeService)
              .to receive(:new).and_call_original

            update_merge_request(spend_time: spend_time, use_specialized_service: true)
          end
        end

        context 'when false or nil' do
          before do
            expect(::MergeRequests::AddSpentTimeService).not_to receive(:new)
          end

          it 'does not pass the update action to ::MergeRequests::UpdateAssigneesService when false' do
            update_merge_request(spend_time: spend_time, use_specialized_service: false)
          end

          it 'does not pass the update action to ::MergeRequests::UpdateAssigneesService when nil' do
            update_merge_request(spend_time: spend_time, use_specialized_service: nil)
          end
        end
      end
    end

    it_behaves_like 'issuable update service' do
      let(:open_issuable) { merge_request }
      let(:closed_issuable) { create(:closed_merge_request, source_project: project) }
    end

    context 'setting `allow_collaboration`' do
      let(:target_project) { create(:project, :repository, :public) }
      let(:source_project) { fork_project(target_project, nil, repository: true) }
      let(:user) { create(:user) }
      let(:merge_request) do
        create(
          :merge_request,
          source_project: source_project,
          source_branch: 'fixes',
          target_project: target_project
        )
      end

      before do
        allow(ProtectedBranch).to receive(:protected?).with(source_project, 'fixes') { false }
      end

      it 'does not allow a maintainer of the target project to set `allow_collaboration`' do
        target_project.add_developer(user)

        update_merge_request(allow_collaboration: false, title: 'Updated title')

        expect(merge_request.title).to eq('Updated title')
        expect(merge_request.allow_collaboration).to be_truthy
      end

      it 'is allowed by a user that can push to the source and can update the merge request' do
        merge_request.update!(assignees: [user])
        source_project.add_developer(user)

        update_merge_request(allow_collaboration: false, title: 'Updated title')

        expect(merge_request.title).to eq('Updated title')
        expect(merge_request.allow_collaboration).to be_falsy
      end
    end

    context 'updating `force_remove_source_branch`' do
      let(:target_project) { create(:project, :repository, :public) }
      let(:source_project) { fork_project(target_project, nil, repository: true) }
      let(:user) { target_project.first_owner }
      let(:merge_request) do
        create(
          :merge_request,
          source_project: source_project,
          source_branch: 'fixes',
          target_project: target_project
        )
      end

      it ""cannot be done by members of the target project when they don't have access"" do
        expect { update_merge_request(force_remove_source_branch: true) }
          .not_to change { merge_request.reload.force_remove_source_branch? }.from(nil)
      end

      it 'can be done by members of the target project if they can push to the source project' do
        source_project.add_developer(user)

        expect { update_merge_request(force_remove_source_branch: true) }
          .to change { merge_request.reload.force_remove_source_branch? }.from(nil).to(true)
      end
    end

    context 'updating `target_branch`' do
      let(:merge_request) do
        create(
          :merge_request,
          source_project: project,
          source_branch: 'mr-b',
          target_branch: 'mr-a'
        )
      end

      it 'updates to master' do
        expect(SystemNoteService).to receive(:change_branch).with(
          merge_request, project, user, 'target', 'update', 'mr-a', 'master'
        )

        expect { update_merge_request(target_branch: 'master') }
          .to change { merge_request.reload.target_branch }.from('mr-a').to('master')
      end

      it 'updates to master because of branch deletion' do
        expect(SystemNoteService).to receive(:change_branch).with(
          merge_request, project, user, 'target', 'delete', 'mr-a', 'master'
        )

        expect { update_merge_request(target_branch: 'master', target_branch_was_deleted: true) }
          .to change { merge_request.reload.target_branch }.from('mr-a').to('master')
      end

      it_behaves_like ""creates a new pipeline"" do
        let(:new_target_branch) { ""target"" }
      end
    end

    it_behaves_like 'issuable record that supports quick actions' do
      let(:existing_merge_request) { create(:merge_request, source_project: project) }
      let(:issuable) { described_class.new(project: project, current_user: user, params: params).execute(existing_merge_request) }
    end

    context 'updating labels' do
      context 'when merge request is not merged' do
        let(:label_a) { label }
        let(:label_b) { create(:label, title: 'b', project: project) }
        let(:label_c) { create(:label, title: 'c', project: project) }
        let(:label_locked) { create(:label, title: 'locked', project: project, lock_on_merge: true) }
        let(:issuable) { merge_request }

        it_behaves_like 'updating issuable labels'
        it_behaves_like 'keeps issuable labels sorted after update'
        it_behaves_like 'broadcasting issuable labels updates'
      end

      context 'when merge request has been merged' do
        let(:label_a) { create(:label, title: 'a', project: project, lock_on_merge: true) }
        let(:label_b) { create(:label, title: 'b', project: project, lock_on_merge: true) }
        let(:label_c) { create(:label, title: 'c', project: project, lock_on_merge: true) }
        let(:label_unlocked) { create(:label, title: 'unlocked', project: project) }
        let(:issuable) { merge_request }

        before do
          merge_request.update!(state: 'merged')
        end

        it_behaves_like 'updating merged MR with locked labels'

        context 'when feature flag is disabled' do
          let(:label_locked) { create(:label, title: 'locked', project: project, lock_on_merge: true) }

          before do
            stub_feature_flags(enforce_locked_labels_on_merge: false)
          end

          it_behaves_like 'updating issuable labels'
        end
      end

      def update_issuable(update_params)
        update_merge_request(update_params)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class MergeabilityCheckBatchService
    def initialize(merge_requests, user)
      @merge_requests = merge_requests
      @user = user
    end

    def execute
      return unless merge_requests.present?

      MergeRequests::MergeabilityCheckBatchWorker.perform_async(merge_requests.map(&:id), user&.id)
    end

    private

    attr_reader :merge_requests, :user
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::MergeabilityCheckBatchService, feature_category: :code_review_workflow do
  describe '#execute' do
    subject { described_class.new(merge_requests, user).execute }

    let(:merge_requests) { [] }
    let_it_be(:user) { create(:user) }

    context 'when merge_requests are not empty' do
      let_it_be(:merge_request_1) { create(:merge_request) }
      let_it_be(:merge_request_2) { create(:merge_request) }
      let_it_be(:merge_requests) { [merge_request_1, merge_request_2] }

      it 'triggers batch mergeability checks' do
        expect(MergeRequests::MergeabilityCheckBatchWorker).to receive(:perform_async)
          .with([merge_request_1.id, merge_request_2.id], user.id)

        subject
      end

      context 'when user is nil' do
        let(:user) { nil }

        it 'trigger mergeability checks with nil user_id' do
          expect(MergeRequests::MergeabilityCheckBatchWorker).to receive(:perform_async)
            .with([merge_request_1.id, merge_request_2.id], nil)

          subject
        end
      end
    end

    context 'when merge_requests is empty' do
      let(:merge_requests) { MergeRequest.none }

      it 'does not trigger mergeability checks' do
        expect(MergeRequests::MergeabilityCheckBatchWorker).not_to receive(:perform_async)

        subject
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class RefreshService < MergeRequests::BaseService
    include Gitlab::Utils::StrongMemoize
    attr_reader :push

    def execute(oldrev, newrev, ref)
      @push = Gitlab::Git::Push.new(@project, oldrev, newrev, ref)
      return true unless @push.branch_push?

      refresh_merge_requests!
    end

    private

    def refresh_merge_requests!
      # n + 1: https://gitlab.com/gitlab-org/gitlab-foss/issues/60289
      Gitlab::GitalyClient.allow_n_plus_1_calls { find_new_commits }

      # Be sure to close outstanding MRs before reloading them to avoid generating an
      # empty diff during a manual merge
      close_upon_missing_source_branch_ref
      post_merge_manually_merged
      link_forks_lfs_objects
      reload_merge_requests

      merge_requests_for_source_branch.each do |mr|
        outdate_suggestions(mr)
        abort_auto_merges(mr)
        mark_pending_todos_done(mr)
      end

      abort_ff_merge_requests_with_when_pipeline_succeeds
      cache_merge_requests_closing_issues

      merge_requests_for_source_branch.each do |mr|
        # Leave a system note if a branch was deleted/added
        if branch_added_or_removed?
          comment_mr_branch_presence_changed(mr)
        end

        notify_about_push(mr)
        mark_mr_as_draft_from_commits(mr)
        execute_mr_web_hooks(mr)
        # Run at the end of the loop to avoid any potential contention on the MR object
        refresh_pipelines_on_merge_requests(mr)
        merge_request_activity_counter.track_mr_including_ci_config(user: mr.author, merge_request: mr)
      end

      true
    end

    def branch_added_or_removed?
      strong_memoize(:branch_added_or_removed) do
        @push.branch_added? || @push.branch_removed?
      end
    end

    def close_upon_missing_source_branch_ref
      # MergeRequest#reload_diff ignores not opened MRs. This means it won't
      # create an `empty` diff for `closed` MRs without a source branch, keeping
      # the latest diff state as the last _valid_ one.
      merge_requests_for_source_branch.reject(&:source_branch_exists?).each do |mr|
        MergeRequests::CloseService
          .new(project: mr.target_project, current_user: @current_user)
          .execute(mr)
      end
    end

    # Collect open merge requests that target same branch we push into
    # and close if push to master include last commit from merge request
    # We need this to close(as merged) merge requests that were merged into
    # target branch manually
    # rubocop: disable CodeReuse/ActiveRecord
    def post_merge_manually_merged
      commit_ids = @commits.map(&:id)
      merge_requests = @project.merge_requests.opened
        .preload_project_and_latest_diff
        .preload_latest_diff_commit
        .where(target_branch: @push.branch_name).to_a
        .select(&:diff_head_commit)
        .select do |merge_request|
          commit_ids.include?(merge_request.diff_head_sha) &&
            merge_request.merge_request_diff.state != 'empty'
        end
      merge_requests = filter_merge_requests(merge_requests)

      return if merge_requests.empty?

      analyzer = Gitlab::BranchPushMergeCommitAnalyzer.new(
        @commits.reverse,
        relevant_commit_ids: merge_requests.map(&:diff_head_sha)
      )

      merge_requests.each do |merge_request|
        sha = analyzer.get_merge_commit(merge_request.diff_head_sha)
        merge_request.merge_commit_sha = sha
        merge_request.merged_commit_sha = sha

        MergeRequests::PostMergeService
          .new(project: merge_request.target_project, current_user: @current_user)
          .execute(merge_request)
      end
    end
    # rubocop: enable CodeReuse/ActiveRecord

    # Link LFS objects that exists in forks but does not exists in merge requests
    # target project
    def link_forks_lfs_objects
      return unless @push.branch_updated?

      merge_requests_for_forks.find_each do |mr|
        LinkLfsObjectsService
          .new(project: mr.target_project)
          .execute(mr, oldrev: @push.oldrev, newrev: @push.newrev)
      end
    end

    # Refresh merge request diff if we push to source or target branch of merge request
    # Note: we should update merge requests from forks too
    def reload_merge_requests
      merge_requests = @project.merge_requests.opened
        .by_source_or_target_branch(@push.branch_name)
        .preload_project_and_latest_diff

      merge_requests_from_forks = merge_requests_for_forks
        .preload_project_and_latest_diff

      merge_requests_array = merge_requests.to_a + merge_requests_from_forks.to_a
      filter_merge_requests(merge_requests_array).each do |merge_request|
        skip_merge_status_trigger = true

        if branch_and_project_match?(merge_request) || @push.force_push?
          merge_request.reload_diff(current_user)
          # Clear existing merge error if the push were directed at the
          # source branch. Clearing the error when the target branch
          # changes will hide the error from the user.
          merge_request.merge_error = nil

          # Don't skip trigger since we to update the MR's merge status in real-time
          # when the push if for the MR's source branch and project.
          skip_merge_status_trigger = false
        elsif merge_request.merge_request_diff.includes_any_commits?(push_commit_ids)
          merge_request.reload_diff(current_user)
        end

        merge_request.skip_merge_status_trigger = skip_merge_status_trigger
        merge_request.mark_as_unchecked
      end

      # Upcoming method calls need the refreshed version of
      # @source_merge_requests diffs (for MergeRequest#commit_shas for instance).
      merge_requests_for_source_branch(reload: true)
    end

    def push_commit_ids
      @push_commit_ids ||= @commits.map(&:id)
    end

    def branch_and_project_match?(merge_request)
      merge_request.source_project == @project &&
        merge_request.source_branch == @push.branch_name
    end

    def outdate_suggestions(merge_request)
      outdate_service.execute(merge_request)
    end

    def outdate_service
      @outdate_service ||= Suggestions::OutdateService.new
    end

    def abort_auto_merges?(merge_request)
      merge_request.merge_params.with_indifferent_access[:sha] != @push.newrev
    end

    def abort_auto_merges(merge_request)
      return unless abort_auto_merges?(merge_request)

      abort_auto_merge(merge_request, 'source branch was updated')
    end

    def abort_ff_merge_requests_with_when_pipeline_succeeds
      return unless @project.ff_merge_must_be_possible?

      merge_requests_with_auto_merge_enabled_to(@push.branch_name).each do |merge_request|
        next unless merge_request.auto_merge_strategy == AutoMergeService::STRATEGY_MERGE_WHEN_PIPELINE_SUCCEEDS
        next unless merge_request.should_be_rebased?

        abort_auto_merge_with_todo(merge_request, 'target branch was updated')
      end
    end

    def abort_auto_merge_with_todo(merge_request, reason)
      response = abort_auto_merge(merge_request, reason)
      response = ServiceResponse.new(**response)
      return unless response.success?

      todo_service.merge_request_became_unmergeable(merge_request)
    end

    def merge_requests_with_auto_merge_enabled_to(target_branch)
      @project
        .merge_requests
        .by_target_branch(target_branch)
        .with_auto_merge_enabled
    end

    def mark_pending_todos_done(merge_request)
      todo_service.merge_request_push(merge_request, @current_user)
    end

    def find_new_commits
      if @push.branch_added?
        @commits = []

        merge_request = merge_requests_for_source_branch.first
        return unless merge_request

        begin
          # Since any number of commits could have been made to the restored branch,
          # find the common root to see what has been added.
          common_ref = @project.repository.merge_base(merge_request.diff_head_sha, @push.newrev)
          # If the a commit no longer exists in this repo, gitlab_git throws
          # a Rugged::OdbError. This is fixed in https://gitlab.com/gitlab-org/gitlab_git/merge_requests/52
          @commits = @project.repository.commits_between(common_ref, @push.newrev) if common_ref
        rescue StandardError
        end
      elsif @push.branch_removed?
        # No commits for a deleted branch.
        @commits = []
      else
        @commits = @project.repository.commits_between(@push.oldrev, @push.newrev)
      end
    end

    # Add comment about branches being deleted or added to merge requests
    def comment_mr_branch_presence_changed(merge_request)
      presence = @push.branch_added? ? :add : :delete

      SystemNoteService.change_branch_presence(
        merge_request, merge_request.project, @current_user,
        :source, @push.branch_name, presence)
    end

    # Add comment about pushing new commits to merge requests and send notification emails
    #
    def notify_about_push(merge_request)
      return unless @commits.present?

      mr_commit_ids = Set.new(merge_request.commit_shas)

      new_commits, existing_commits = @commits.partition do |commit|
        mr_commit_ids.include?(commit.id)
      end

      SystemNoteService.add_commits(
        merge_request, merge_request.project,
        @current_user, new_commits,
        existing_commits, @push.oldrev
      )

      notification_service.push_to_merge_request(merge_request, @current_user, new_commits: new_commits, existing_commits: existing_commits)
    end

    def mark_mr_as_draft_from_commits(merge_request)
      return unless @commits.present?

      commit_shas = merge_request.commit_shas

      draft_commit = @commits.detect do |commit|
        commit.draft? && commit_shas.include?(commit.sha)
      end

      if draft_commit && !merge_request.draft?
        merge_request.update(title: merge_request.draft_title)
        SystemNoteService.add_merge_request_draft_from_commit(
          merge_request,
          merge_request.project,
          @current_user,
          draft_commit
        )
      end
    end

    # Call merge request webhook with update branches
    def execute_mr_web_hooks(merge_request)
      execute_hooks(merge_request, 'update', old_rev: @push.oldrev)
    end

    # If the merge requests closes any issues, save this information in the
    # `MergeRequestsClosingIssues` model (as a performance optimization).
    # rubocop: disable CodeReuse/ActiveRecord
    def cache_merge_requests_closing_issues
      @project.merge_requests.where(source_branch: @push.branch_name).each do |merge_request|
        merge_request.cache_merge_request_closes_issues!(@current_user)
      end
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def filter_merge_requests(merge_requests)
      merge_requests.uniq.select(&:source_project)
    end

    def merge_requests_for_source_branch(reload: false)
      @source_merge_requests = nil if reload
      @source_merge_requests ||= merge_requests_for(@push.branch_name)
    end

    def merge_requests_for_forks
      @merge_requests_for_forks ||=
        MergeRequest
          .opened
          .from_project(project)
          .from_source_branches(@push.branch_name)
          .from_fork
    end
  end
end

MergeRequests::RefreshService.prepend_mod_with('MergeRequests::RefreshService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::RefreshService, feature_category: :code_review_workflow do
  include ProjectForksHelper
  include UserHelpers

  let(:project) { create(:project, :repository) }
  let(:user) { create(:user) }
  let(:service) { described_class }

  describe '#execute' do
    before do
      @user = create(:user)
      group = create(:group)
      group.add_owner(@user)

      @project = create(:project, :repository, namespace: group)
      @fork_project = fork_project(@project, @user, repository: true)

      @merge_request = create(
        :merge_request,
        source_project: @project,
        source_branch: 'master',
        target_branch: 'feature',
        target_project: @project,
        auto_merge_enabled: true,
        auto_merge_strategy: AutoMergeService::STRATEGY_MERGE_WHEN_PIPELINE_SUCCEEDS,
        merge_user: @user
      )

      @another_merge_request = create(
        :merge_request,
        source_project: @project,
        source_branch: 'master',
        target_branch: 'test',
        target_project: @project,
        auto_merge_enabled: true,
        auto_merge_strategy: AutoMergeService::STRATEGY_MERGE_WHEN_PIPELINE_SUCCEEDS,
        merge_user: @user
      )

      @fork_merge_request = create(
        :merge_request,
        source_project: @fork_project,
        source_branch: 'master',
        target_branch: 'feature',
        target_project: @project
      )

      @build_failed_todo = create(
        :todo,
        :build_failed,
        user: @user,
        project: @project,
        target: @merge_request,
        author: @user
      )

      @fork_build_failed_todo = create(
        :todo,
        :build_failed,
        user: @user,
        project: @project,
        target: @merge_request,
        author: @user
      )

      @commits = @merge_request.commits

      @oldrev = @commits.last.id
      @newrev = @commits.first.id
    end

    context 'push to origin repo source branch' do
      let(:refresh_service) { service.new(project: @project, current_user: @user) }
      let(:notification_service) { spy('notification_service') }

      before do
        allow(refresh_service).to receive(:execute_hooks)
        allow(NotificationService).to receive(:new) { notification_service }
      end

      context 'query count' do
        it 'does not execute a lot of queries' do
          # Hardcoded the query limit since the queries can also be reduced even
          # if there are the same number of merge requests (e.g. by preloading
          # associations). This should also fail in case additional queries are
          # added elsewhere that affected this service.
          #
          # The limit is based on the number of queries executed at the current
          # state of the service. As we reduce the number of queries executed in
          # this service, the limit should be reduced as well.
          expect { refresh_service.execute(@oldrev, @newrev, 'refs/heads/master') }
            .not_to exceed_query_limit(260)
        end
      end

      it 'executes hooks with update action' do
        refresh_service.execute(@oldrev, @newrev, 'refs/heads/master')
        reload_mrs

        expect(refresh_service).to have_received(:execute_hooks)
          .with(@merge_request, 'update', old_rev: @oldrev)

        expect(notification_service).to have_received(:push_to_merge_request)
          .with(@merge_request, @user, new_commits: anything, existing_commits: anything)
        expect(notification_service).to have_received(:push_to_merge_request)
          .with(@another_merge_request, @user, new_commits: anything, existing_commits: anything)

        expect(@merge_request.notes).not_to be_empty
        expect(@merge_request).to be_open
        expect(@merge_request.auto_merge_enabled).to be_falsey
        expect(@merge_request.diff_head_sha).to eq(@newrev)
        expect(@fork_merge_request).to be_open
        expect(@fork_merge_request.notes).to be_empty
        expect(@build_failed_todo).to be_done
        expect(@fork_build_failed_todo).to be_done
      end

      it 'triggers mergeRequestMergeStatusUpdated GraphQL subscription conditionally' do
        expect(GraphqlTriggers).to receive(:merge_request_merge_status_updated).with(@merge_request)
        expect(GraphqlTriggers).to receive(:merge_request_merge_status_updated).with(@another_merge_request)
        expect(GraphqlTriggers).not_to receive(:merge_request_merge_status_updated).with(@fork_merge_request)

        refresh_service.execute(@oldrev, @newrev, 'refs/heads/master')
      end

      context 'when a merge error exists' do
        let(:error_message) { 'This is a merge error' }

        before do
          @merge_request = create(:merge_request,
            source_project: @project,
            source_branch: 'feature',
            target_branch: 'master',
            target_project: @project,
            merge_error: error_message)
        end

        it 'clears merge errors when pushing to the source branch' do
          expect { refresh_service.execute(@oldrev, @newrev, 'refs/heads/feature') }
            .to change { @merge_request.reload.merge_error }
            .from(error_message)
            .to(nil)
        end

        it 'does not clear merge errors when pushing to the target branch' do
          expect { refresh_service.execute(@oldrev, @newrev, 'refs/heads/master') }
            .not_to change { @merge_request.reload.merge_error }
        end
      end

      it 'reloads source branch MRs memoization' do
        refresh_service.execute(@oldrev, @newrev, 'refs/heads/master')

        expect { refresh_service.execute(@oldrev, @newrev, 'refs/heads/master') }.to change {
          refresh_service.instance_variable_get(:@source_merge_requests).first.merge_request_diff
        }
      end

      it 'outdates MR suggestions' do
        expect_next_instance_of(Suggestions::OutdateService) do |service|
          expect(service).to receive(:execute).with(@merge_request).and_call_original
          expect(service).to receive(:execute).with(@another_merge_request).and_call_original
        end

        refresh_service.execute(@oldrev, @newrev, 'refs/heads/master')
      end

      context 'when source branch ref does not exists' do
        before do
          ::Branches::DeleteService.new(@project, @user).execute(@merge_request.source_branch)
        end

        it 'closes MRs without source branch ref' do
          expect { refresh_service.execute(@oldrev, @newrev, 'refs/heads/master') }
            .to change { @merge_request.reload.state }
            .from('opened')
            .to('closed')

          expect(@fork_merge_request.reload).to be_open
        end

        it 'does not change the merge request diff' do
          expect { refresh_service.execute(@oldrev, @newrev, 'refs/heads/master') }
            .not_to change { @merge_request.reload.merge_request_diff }
        end
      end

      it 'calls the merge request activity counter' do
        expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
          .to receive(:track_mr_including_ci_config)
          .with(user: @merge_request.author, merge_request: @merge_request)

        expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
          .to receive(:track_mr_including_ci_config)
          .with(user: @another_merge_request.author, merge_request: @another_merge_request)

        refresh_service.execute(@oldrev, @newrev, 'refs/heads/master')
      end
    end

    context 'when pipeline exists for the source branch' do
      let!(:pipeline) { create(:ci_empty_pipeline, ref: @merge_request.source_branch, project: @project, sha: @commits.first.sha) }

      subject { service.new(project: @project, current_user: @user).execute(@oldrev, @newrev, 'refs/heads/master') }

      it 'updates the head_pipeline_id for @merge_request', :sidekiq_inline do
        expect { subject }.to change { @merge_request.reload.head_pipeline_id }.from(nil).to(pipeline.id)
      end

      it 'does not update the head_pipeline_id for @fork_merge_request' do
        expect { subject }.not_to change { @fork_merge_request.reload.head_pipeline_id }
      end
    end

    context 'Pipelines for merge requests', :sidekiq_inline do
      before do
        stub_ci_pipeline_yaml_file(config)
      end

      subject { service.new(project: project, current_user: @user).execute(@oldrev, @newrev, ref) }

      let(:ref) { 'refs/heads/master' }
      let(:project) { @project }

      context ""when .gitlab-ci.yml has merge_requests keywords"" do
        let(:config) do
          YAML.dump({
            test: {
              stage: 'test',
              script: 'echo',
              only: ['merge_requests']
            }
          })
        end

        it 'create detached merge request pipeline with commits' do
          expect { subject }
            .to change { @merge_request.pipelines_for_merge_request.count }.by(1)
            .and change { @another_merge_request.pipelines_for_merge_request.count }.by(0)

          expect(@merge_request.has_commits?).to be_truthy
          expect(@another_merge_request.has_commits?).to be_falsy
        end

        context 'when ""push_options: nil"" is passed' do
          let(:service_instance) { service.new(project: project, current_user: @user, params: { push_options: nil }) }

          subject { service_instance.execute(@oldrev, @newrev, ref) }

          it 'creates a detached merge request pipeline with commits' do
            expect { subject }
              .to change { @merge_request.pipelines_for_merge_request.count }.by(1)
              .and change { @another_merge_request.pipelines_for_merge_request.count }.by(0)

            expect(@merge_request.has_commits?).to be_truthy
            expect(@another_merge_request.has_commits?).to be_falsy
          end
        end

        context 'when ci.skip push_options are passed' do
          let(:params) { { push_options: { ci: { skip: true } } } }
          let(:service_instance) { service.new(project: project, current_user: @user, params: params) }

          subject { service_instance.execute(@oldrev, @newrev, ref) }

          it 'creates a skipped detached merge request pipeline with commits' do
            expect { subject }
              .to change { @merge_request.pipelines_for_merge_request.count }.by(1)
              .and change { @another_merge_request.pipelines_for_merge_request.count }.by(0)

            expect(@merge_request.has_commits?).to be_truthy
            expect(@another_merge_request.has_commits?).to be_falsy

            pipeline = @merge_request.pipelines_for_merge_request.last
            expect(pipeline).to be_skipped
          end
        end

        it 'does not create detached merge request pipeline for forked project' do
          expect { subject }
            .not_to change { @fork_merge_request.pipelines_for_merge_request.count }
        end

        it 'create detached merge request pipeline for non-fork merge request' do
          subject

          expect(@merge_request.pipelines_for_merge_request.first)
            .to be_detached_merge_request_pipeline
        end

        context 'when service is hooked by target branch' do
          let(:ref) { 'refs/heads/feature' }

          it 'does not create detached merge request pipeline' do
            expect { subject }
              .not_to change { @merge_request.pipelines_for_merge_request.count }
          end
        end

        context 'when service runs on forked project' do
          let(:project) { @fork_project }

          it 'creates detached merge request pipeline for fork merge request' do
            expect { subject }
              .to change { @fork_merge_request.pipelines_for_merge_request.count }.by(1)

            merge_request_pipeline = @fork_merge_request.pipelines_for_merge_request.first
            expect(merge_request_pipeline).to be_detached_merge_request_pipeline
            expect(merge_request_pipeline.project).to eq(@project)
          end
        end

        context ""when branch pipeline was created before a detaced merge request pipeline has been created"" do
          before do
            create(
              :ci_pipeline,
              project: @merge_request.source_project,
              sha: @merge_request.diff_head_sha,
              ref: @merge_request.source_branch,
              tag: false
            )

            subject
          end

          it 'sets the latest detached merge request pipeline as a head pipeline' do
            @merge_request.reload
            expect(@merge_request.actual_head_pipeline).to be_merge_request_event
          end

          it 'returns pipelines in correct order' do
            @merge_request.reload
            expect(@merge_request.all_pipelines.first).to be_merge_request_event
            expect(@merge_request.all_pipelines.second).to be_push
          end
        end

        context ""when MergeRequestUpdateWorker is retried by an exception"" do
          it 'does not re-create a duplicate detached merge request pipeline' do
            expect do
              service.new(project: @project, current_user: @user).execute(@oldrev, @newrev, 'refs/heads/master')
            end.to change { @merge_request.pipelines_for_merge_request.count }.by(1)

            expect do
              service.new(project: @project, current_user: @user).execute(@oldrev, @newrev, 'refs/heads/master')
            end.not_to change { @merge_request.pipelines_for_merge_request.count }
          end
        end

        context 'when the pipeline should be skipped' do
          it 'saves a skipped detached merge request pipeline' do
            project.repository.create_file(
              @user, 'new-file.txt', 'A new file',
              message: '[skip ci] This is a test',
              branch_name: 'master'
            )

            expect { subject }
              .to change { @merge_request.pipelines_for_merge_request.count }.by(1)
            expect(@merge_request.pipelines_for_merge_request.last).to be_skipped
          end
        end
      end

      context ""when .gitlab-ci.yml does not have merge_requests keywords"" do
        let(:config) do
          YAML.dump({
            test: {
              stage: 'test',
              script: 'echo'
            }
          })
        end

        it 'does not create a detached merge request pipeline' do
          expect { subject }
            .not_to change { @merge_request.pipelines_for_merge_request.count }
        end
      end

      context 'when .gitlab-ci.yml is invalid' do
        let(:config) { 'invalid yaml file' }

        it 'persists a pipeline with config error' do
          expect { subject }
            .to change { @merge_request.pipelines_for_merge_request.count }.by(1)
          expect(@merge_request.pipelines_for_merge_request.last).to be_failed
          expect(@merge_request.pipelines_for_merge_request.last).to be_config_error
        end
      end

      context 'when .gitlab-ci.yml file is valid but has a logical error' do
        let(:config) do
          YAML.dump({
            build: {
              script: 'echo ""Valid yaml syntax, but...""',
              only: ['master']
            },
            test: {
              script: 'echo ""... I depend on build, which does not run.""',
              only: ['merge_request'],
              needs: ['build']
            }
          })
        end

        it 'persists a pipeline with config error' do
          expect { subject }
            .to change { @merge_request.pipelines_for_merge_request.count }.by(1)
          expect(@merge_request.pipelines_for_merge_request.last).to be_failed
          expect(@merge_request.pipelines_for_merge_request.last).to be_config_error
        end
      end
    end

    context 'push to origin repo source branch' do
      let(:refresh_service) { service.new(project: @project, current_user: @user) }
      let(:notification_service) { spy('notification_service') }

      before do
        allow(refresh_service).to receive(:execute_hooks)
        allow(NotificationService).to receive(:new) { notification_service }
        refresh_service.execute(@oldrev, @newrev, 'refs/heads/master')
        reload_mrs
      end

      it 'executes hooks with update action' do
        expect(refresh_service).to have_received(:execute_hooks)
          .with(@merge_request, 'update', old_rev: @oldrev)
        expect(notification_service).to have_received(:push_to_merge_request)
          .with(@merge_request, @user, new_commits: anything, existing_commits: anything)
        expect(notification_service).to have_received(:push_to_merge_request)
          .with(@another_merge_request, @user, new_commits: anything, existing_commits: anything)

        expect(@merge_request.notes).not_to be_empty
        expect(@merge_request).to be_open
        expect(@merge_request.auto_merge_enabled).to be_falsey
        expect(@merge_request.diff_head_sha).to eq(@newrev)
        expect(@fork_merge_request).to be_open
        expect(@fork_merge_request.notes).to be_empty
        expect(@build_failed_todo).to be_done
        expect(@fork_build_failed_todo).to be_done
      end
    end

    context 'push to origin repo target branch' do
      context 'when all MRs to the target branch had diffs' do
        before do
          service.new(project: @project, current_user: @user).execute(@oldrev, @newrev, 'refs/heads/feature')
          reload_mrs
        end

        it 'updates the merge state' do
          expect(@merge_request).to be_merged
          expect(@fork_merge_request).to be_merged
          expect(@build_failed_todo).to be_done
          expect(@fork_build_failed_todo).to be_done

          expect(@merge_request.resource_state_events.last.state).to eq('merged')
          expect(@fork_merge_request.resource_state_events.last.state).to eq('merged')
        end
      end

      context 'when an MR to be closed was empty already' do
        let!(:empty_fork_merge_request) do
          create(
            :merge_request,
            source_project: @fork_project,
            source_branch: 'master',
            target_branch: 'master',
            target_project: @project
          )
        end

        before do
          # This spec already has a fake push, so pretend that we were targeting
          # feature all along.
          empty_fork_merge_request.update_columns(target_branch: 'feature')

          service.new(project: @project, current_user: @user).execute(@oldrev, @newrev, 'refs/heads/feature')
          reload_mrs
          empty_fork_merge_request.reload
        end

        it 'only updates the non-empty MRs' do
          expect(@merge_request).to be_merged
          expect(@fork_merge_request).to be_merged

          expect(empty_fork_merge_request).to be_open
          expect(empty_fork_merge_request.merge_request_diff.state).to eq('empty')
          expect(empty_fork_merge_request.notes).to be_empty

          expect(@merge_request.resource_state_events.last.state).to eq('merged')
          expect(@fork_merge_request.resource_state_events.last.state).to eq('merged')
        end
      end

      context 'manual merge of source branch' do
        before do
          # Merge master -> feature branch
          @project.repository.merge(@user, @merge_request.diff_head_sha, @merge_request, 'Test message')
          commit = @project.repository.commit('feature')
          service.new(project: @project, current_user: @user).execute(@oldrev, commit.id, 'refs/heads/feature')
          reload_mrs
        end

        it 'updates the merge state' do
          expect(@merge_request.resource_state_events.last.state).to eq('merged')
          expect(@fork_merge_request.resource_state_events.last.state).to eq('merged')

          expect(@merge_request).to be_merged
          expect(@merge_request.diffs.size).to be > 0
          expect(@fork_merge_request).to be_merged
          expect(@build_failed_todo).to be_done
          expect(@fork_build_failed_todo).to be_done
        end
      end
    end

    context 'push to fork repo source branch' do
      let(:refresh_service) { service.new(project: @fork_project, current_user: @user) }

      def refresh
        allow(refresh_service).to receive(:execute_hooks)
        refresh_service.execute(@oldrev, @newrev, 'refs/heads/master')
        reload_mrs
      end

      context 'open fork merge request' do
        it 'calls MergeRequests::LinkLfsObjectsService#execute' do
          expect_next_instance_of(MergeRequests::LinkLfsObjectsService) do |svc|
            expect(svc).to receive(:execute).with(@fork_merge_request, oldrev: @oldrev, newrev: @newrev)
          end

          refresh
        end

        it 'executes hooks with update action' do
          refresh

          expect(refresh_service).to have_received(:execute_hooks)
            .with(@fork_merge_request, 'update', old_rev: @oldrev)

          expect(@merge_request.notes).to be_empty
          expect(@merge_request).to be_open
          expect(@fork_merge_request.notes.last.note).to include('added 28 commits')
          expect(@fork_merge_request).to be_open
          expect(@build_failed_todo).to be_pending
          expect(@fork_build_failed_todo).to be_pending
        end

        it 'outdates opened forked MR suggestions' do
          expect_next_instance_of(Suggestions::OutdateService) do |service|
            expect(service).to receive(:execute).with(@fork_merge_request).and_call_original
          end

          refresh
        end
      end

      context 'closed fork merge request' do
        before do
          @fork_merge_request.close!
        end

        it 'do not execute hooks with update action' do
          refresh

          expect(refresh_service).not_to have_received(:execute_hooks)
        end

        it 'updates merge request to closed state' do
          refresh

          expect(@merge_request.notes).to be_empty
          expect(@merge_request).to be_open
          expect(@fork_merge_request.notes).to be_empty
          expect(@fork_merge_request).to be_closed
          expect(@build_failed_todo).to be_pending
          expect(@fork_build_failed_todo).to be_pending
        end
      end
    end

    context 'push to fork repo target branch' do
      describe 'changes to merge requests' do
        before do
          service.new(project: @fork_project, current_user: @user).execute(@oldrev, @newrev, 'refs/heads/feature')
          reload_mrs
        end

        it 'updates the merge request state' do
          expect(@merge_request.notes).to be_empty
          expect(@merge_request).to be_open
          expect(@fork_merge_request.notes).to be_empty
          expect(@fork_merge_request).to be_open
          expect(@build_failed_todo).to be_pending
          expect(@fork_build_failed_todo).to be_pending
        end
      end

      describe 'merge request diff' do
        it 'does not reload the diff of the merge request made from fork' do
          expect do
            service.new(project: @fork_project, current_user: @user).execute(@oldrev, @newrev, 'refs/heads/feature')
          end.not_to change { @fork_merge_request.reload.merge_request_diff }
        end
      end
    end

    context 'forked projects with the same source branch name as target branch' do
      let!(:first_commit) do
        @fork_project.repository.create_file(
          @user,
          'test1.txt',
          'Test data',
          message: 'Test commit',
          branch_name: 'master'
        )
      end

      let!(:second_commit) do
        @fork_project.repository.create_file(
          @user,
          'test2.txt',
          'More test data',
          message: 'Second test commit',
          branch_name: 'master'
        )
      end

      let!(:forked_master_mr) do
        create(
          :merge_request,
          source_project: @fork_project,
          source_branch: 'master',
          target_branch: 'master',
          target_project: @project
        )
      end

      let(:force_push_commit) { @project.commit('feature').id }

      it 'reloads a new diff for a push to the forked project' do
        expect do
          service.new(project: @fork_project, current_user: @user).execute(@oldrev, first_commit, 'refs/heads/master')
          reload_mrs
        end.to change { forked_master_mr.merge_request_diffs.count }.by(1)
      end

      it 'reloads a new diff for a force push to the source branch' do
        expect do
          service.new(project: @fork_project, current_user: @user).execute(@oldrev, force_push_commit, 'refs/heads/master')
          reload_mrs
        end.to change { forked_master_mr.merge_request_diffs.count }.by(1)
      end

      it 'reloads a new diff for a force push to the target branch' do
        expect do
          service.new(project: @project, current_user: @user).execute(@oldrev, force_push_commit, 'refs/heads/master')
          reload_mrs
        end.to change { forked_master_mr.merge_request_diffs.count }.by(1)
      end

      it 'reloads a new diff for a push to the target project that contains a commit in the MR' do
        expect do
          service.new(project: @project, current_user: @user).execute(@oldrev, first_commit, 'refs/heads/master')
          reload_mrs
        end.to change { forked_master_mr.merge_request_diffs.count }.by(1)
      end

      it 'does not increase the diff count for a new push to target branch' do
        new_commit = @project.repository.create_file(
          @user,
          'new-file.txt',
          'A new file',
          message: 'This is a test',
          branch_name: 'master'
        )

        expect do
          service.new(project: @project, current_user: @user).execute(@newrev, new_commit, 'refs/heads/master')
          reload_mrs
        end.not_to change { forked_master_mr.merge_request_diffs.count }
      end
    end

    context 'push to origin repo target branch after fork project was removed' do
      before do
        @fork_project.destroy!
        service.new(project: @project, current_user: @user).execute(@oldrev, @newrev, 'refs/heads/feature')
        reload_mrs
      end

      it 'updates the merge request state' do
        expect(@merge_request.resource_state_events.last.state).to eq('merged')

        expect(@merge_request).to be_merged
        expect(@fork_merge_request).to be_open
        expect(@fork_merge_request.notes).to be_empty
        expect(@build_failed_todo).to be_done
        expect(@fork_build_failed_todo).to be_done
      end
    end

    context 'push new branch that exists in a merge request' do
      let(:refresh_service) { service.new(project: @fork_project, current_user: @user) }

      it 'refreshes the merge request' do
        expect(refresh_service).to receive(:execute_hooks)
                                       .with(@fork_merge_request, 'update', old_rev: Gitlab::Git::BLANK_SHA)
        allow_any_instance_of(Repository).to receive(:merge_base).and_return(@oldrev)

        refresh_service.execute(Gitlab::Git::BLANK_SHA, @newrev, 'refs/heads/master')
        reload_mrs

        expect(@merge_request.notes).to be_empty
        expect(@merge_request).to be_open

        notes = @fork_merge_request.notes.reorder(:created_at).map(&:note)
        expect(notes[0]).to include('restored source branch `master`')
        expect(notes[1]).to include('added 28 commits')
        expect(@fork_merge_request).to be_open
      end
    end

    context 'merge request metrics' do
      let(:user) { create(:user) }
      let(:project) { create(:project, :repository) }
      let(:issue) { create(:issue, project: project) }
      let(:commit) { project.commit }

      before do
        project.add_developer(user)

        allow(commit).to receive_messages(
          safe_message: ""Closes #{issue.to_reference}"",
          references: [issue],
          author_name: user.name,
          author_email: user.email,
          committed_date: Time.current
        )
      end

      context 'when the merge request is sourced from the same project' do
        it 'creates a `MergeRequestsClosingIssues` record for each issue closed by a commit' do
          allow_any_instance_of(MergeRequest).to receive(:commits).and_return(
            CommitCollection.new(project, [commit], 'close-by-commit')
          )

          merge_request = create(
            :merge_request,
            target_branch: 'master',
            source_branch: 'close-by-commit',
            source_project: project
          )

          refresh_service = service.new(project: project, current_user: user)
          allow(refresh_service).to receive(:execute_hooks)
          refresh_service.execute(@oldrev, @newrev, 'refs/heads/close-by-commit')

          issue_ids = MergeRequestsClosingIssues.where(merge_request: merge_request).pluck(:issue_id)
          expect(issue_ids).to eq([issue.id])
        end
      end

      context 'when the merge request is sourced from a different project' do
        it 'creates a `MergeRequestsClosingIssues` record for each issue closed by a commit' do
          forked_project = fork_project(project, user, repository: true)

          allow_any_instance_of(MergeRequest).to receive(:commits).and_return(
            CommitCollection.new(forked_project, [commit], 'close-by-commit')
          )

          merge_request = create(
            :merge_request,
            target_branch: 'master',
            target_project: project,
            source_branch: 'close-by-commit',
            source_project: forked_project
          )

          refresh_service = service.new(project: forked_project, current_user: user)
          allow(refresh_service).to receive(:execute_hooks)
          refresh_service.execute(@oldrev, @newrev, 'refs/heads/close-by-commit')

          issue_ids = MergeRequestsClosingIssues.where(merge_request: merge_request).pluck(:issue_id)
          expect(issue_ids).to eq([issue.id])
        end
      end
    end

    context 'marking the merge request as draft' do
      let(:refresh_service) { service.new(project: @project, current_user: @user) }

      before do
        allow(refresh_service).to receive(:execute_hooks)
      end

      it 'marks the merge request as draft from fixup commits' do
        fixup_merge_request = create(
          :merge_request,
          source_project: @project,
          source_branch: 'wip',
          target_branch: 'master',
          target_project: @project
        )
        commits = fixup_merge_request.commits
        oldrev = commits.last.id
        newrev = commits.first.id

        refresh_service.execute(oldrev, newrev, 'refs/heads/wip')
        fixup_merge_request.reload

        expect(fixup_merge_request.draft?).to eq(true)
        expect(fixup_merge_request.notes.last.note).to match(
          /marked this merge request as \*\*draft\*\* from #{Commit.reference_pattern}/
        )
      end

      it 'references the commit that caused the draft status' do
        draft_merge_request = create(
          :merge_request,
          source_project: @project,
          source_branch: 'wip',
          target_branch: 'master',
          target_project: @project
        )

        commits = draft_merge_request.commits
        oldrev = commits.last.id
        newrev = commits.first.id
        draft_commit = draft_merge_request.commits.find(&:draft?)

        refresh_service.execute(oldrev, newrev, 'refs/heads/wip')

        expect(draft_merge_request.reload.notes.last.note).to eq(
          ""marked this merge request as **draft** from #{draft_commit.id}""
        )
      end

      it 'does not mark as draft based on commits that do not belong to an MR' do
        allow(refresh_service).to receive(:find_new_commits)

        refresh_service.instance_variable_set(:@commits,
          [
            double(
              id: 'aaaaaaa',
              sha: 'aaaaaaa',
              short_id: 'aaaaaaa',
              title: 'Fix issue',
              draft?: false
            ),
            double(
              id: 'bbbbbbb',
              sha: 'bbbbbbbb',
              short_id: 'bbbbbbb',
              title: 'fixup! Fix issue',
              draft?: true,
              to_reference: 'bbbbbbb'
            )
          ])

        refresh_service.execute(@oldrev, @newrev, 'refs/heads/master')
        reload_mrs

        expect(@merge_request.draft?).to be_falsey
      end
    end

    def reload_mrs
      @merge_request.reload
      @fork_merge_request.reload
      @build_failed_todo.reload
      @fork_build_failed_todo.reload
    end
  end

  describe 'updating merge_commit' do
    let(:service) { described_class.new(project: project, current_user: user) }
    let(:user) { create(:user) }
    let(:project) { create(:project, :repository) }

    let(:oldrev) { TestEnv::BRANCH_SHA['merge-commit-analyze-before'] }
    let(:newrev) { TestEnv::BRANCH_SHA['merge-commit-analyze-after'] } # Pretend branch is now updated

    let!(:merge_request) do
      create(
        :merge_request,
        source_project: project,
        source_branch: 'merge-commit-analyze-after',
        target_branch: 'merge-commit-analyze-before',
        target_project: project,
        merge_user: user
      )
    end

    let!(:merge_request_side_branch) do
      create(
        :merge_request,
        source_project: project,
        source_branch: 'merge-commit-analyze-side-branch',
        target_branch: 'merge-commit-analyze-before',
        target_project: project,
        merge_user: user
      )
    end

    subject { service.execute(oldrev, newrev, 'refs/heads/merge-commit-analyze-before') }

    context 'feature enabled' do
      it ""updates merge requests' merge_commit and merged_commit values"", :aggregate_failures do
        expect(Gitlab::BranchPushMergeCommitAnalyzer).to receive(:new).and_wrap_original do |original_method, commits|
          expect(commits.map(&:id)).to eq(%w[646ece5cfed840eca0a4feb21bcd6a81bb19bda3 29284d9bcc350bcae005872d0be6edd016e2efb5 5f82584f0a907f3b30cfce5bb8df371454a90051 8a994512e8c8f0dfcf22bb16df6e876be7a61036 689600b91aabec706e657e38ea706ece1ee8268f db46a1c5a5e474aa169b6cdb7a522d891bc4c5f9])

          original_method.call(commits)
        end

        subject

        merge_request.reload
        merge_request_side_branch.reload

        expect(merge_request.merge_commit.id).to eq('646ece5cfed840eca0a4feb21bcd6a81bb19bda3')
        expect(merge_request_side_branch.merge_commit.id).to eq('29284d9bcc350bcae005872d0be6edd016e2efb5')
        # we need to use read_attribute to bypass the overridden
        # #merged_commit_sha method, which contains a fallback to
        # #merge_commit_sha
        expect(merge_request.read_attribute(:merged_commit_sha)).to eq('646ece5cfed840eca0a4feb21bcd6a81bb19bda3')
        expect(merge_request_side_branch.read_attribute(:merged_commit_sha)).to eq('29284d9bcc350bcae005872d0be6edd016e2efb5')
      end
    end
  end

  describe '#abort_ff_merge_requests_with_when_pipeline_succeeds' do
    let_it_be(:project) { create(:project, :repository) }
    let_it_be(:source_project) { project }
    let_it_be(:target_project) { project }
    let_it_be(:author) { create_user_from_membership(target_project, :developer) }
    let_it_be(:user) { create(:user) }

    let_it_be(:forked_project) do
      fork_project(target_project, author, repository: true)
    end

    let_it_be(:merge_request, refind: true) do
      create(
        :merge_request,
        author: author,
        source_project: source_project,
        source_branch: 'feature',
        target_branch: 'master',
        target_project: target_project,
        auto_merge_enabled: true,
        auto_merge_strategy: AutoMergeService::STRATEGY_MERGE_WHEN_PIPELINE_SUCCEEDS,
        merge_user: user
      )
    end

    let_it_be(:newrev) do
      target_project.repository.create_file(
        user, 'test1.txt', 'Test data', message: 'Test commit', branch_name: 'master'
      )
    end

    let_it_be(:oldrev) do
      target_project
        .repository
        .commit(newrev)
        .parent_id
    end

    let(:auto_merge_strategy) { AutoMergeService::STRATEGY_MERGE_WHEN_PIPELINE_SUCCEEDS }
    let(:refresh_service) { service.new(project: project, current_user: user) }

    before do
      target_project.merge_method = merge_method
      target_project.save!
      merge_request.auto_merge_strategy = auto_merge_strategy
      merge_request.save!

      refresh_service.execute(oldrev, newrev, 'refs/heads/master')
      merge_request.reload
    end

    context 'when Project#merge_method is set to FF' do
      let(:merge_method) { :ff }

      it_behaves_like 'aborted merge requests for MWPS'

      context 'with forked project' do
        let(:source_project) { forked_project }

        it_behaves_like 'aborted merge requests for MWPS'
      end

      context 'with bogus auto merge strategy' do
        let(:auto_merge_strategy) { 'bogus' }

        it_behaves_like 'maintained merge requests for MWPS'
      end
    end

    context 'when Project#merge_method is set to rebase_merge' do
      let(:merge_method) { :rebase_merge }

      it_behaves_like 'aborted merge requests for MWPS'

      context 'with forked project' do
        let(:source_project) { forked_project }

        it_behaves_like 'aborted merge requests for MWPS'
      end
    end

    context 'when Project#merge_method is set to merge' do
      let(:merge_method) { :merge }

      it_behaves_like 'maintained merge requests for MWPS'

      context 'with forked project' do
        let(:source_project) { forked_project }

        it_behaves_like 'maintained merge requests for MWPS'
      end
    end
  end

  describe '#abort_auto_merges' do
    let_it_be(:project) { create(:project, :repository) }
    let_it_be(:user) { create(:user) }
    let_it_be(:author) { user }

    let_it_be(:merge_request, refind: true) do
      create(
        :merge_request,
        source_project: project,
        target_project: project,
        merge_user: user,
        auto_merge_enabled: true,
        auto_merge_strategy: AutoMergeService::STRATEGY_MERGE_WHEN_PIPELINE_SUCCEEDS
      )
    end

    let(:service) { described_class.new(project: project, current_user: user) }
    let(:oldrev) { merge_request.diff_refs.base_sha }
    let(:newrev) { merge_request.diff_refs.head_sha }
    let(:merge_sha) { oldrev }

    before do
      merge_request.merge_params[:sha] = merge_sha
      merge_request.save!

      service.execute(oldrev, newrev, ""refs/heads/#{merge_request.source_branch}"")

      merge_request.reload
    end

    it 'aborts MWPS for merge requests' do
      expect(merge_request.auto_merge_enabled?).to be_falsey
      expect(merge_request.merge_user).to be_nil
    end

    context 'when merge params contains up-to-date sha' do
      let(:merge_sha) { newrev }

      it 'maintains MWPS for merge requests' do
        expect(merge_request.auto_merge_enabled?).to be_truthy
        expect(merge_request.merge_user).to eq(user)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class ExecuteApprovalHooksService < MergeRequests::BaseService
    def execute(merge_request)
      # Only one approval is required for a merge request to be approved
      notification_service.async.approve_mr(merge_request, current_user)
      execute_hooks(merge_request, 'approved')
    end
  end
end

MergeRequests::ExecuteApprovalHooksService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::ExecuteApprovalHooksService, feature_category: :code_review_workflow do
  let(:user) { create(:user) }
  let(:merge_request) { create(:merge_request) }
  let(:project) { merge_request.project }

  subject(:service) { described_class.new(project: project, current_user: user) }

  describe '#execute' do
    let(:notification_service) { NotificationService.new }

    before do
      allow(service).to receive(:notification_service).and_return(notification_service)
    end
    it 'sends a notification when approving' do
      expect(notification_service).to receive_message_chain(:async, :approve_mr)
        .with(merge_request, user)

      service.execute(merge_request)
    end

    context 'with remaining approvals' do
      it 'fires an approval webhook' do
        expect(service).to receive(:execute_hooks).with(merge_request, 'approved')

        service.execute(merge_request)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class CreateService < MergeRequests::BaseService
    def execute
      set_projects!
      set_default_attributes!

      merge_request = MergeRequest.new
      merge_request.target_project = @project
      merge_request.source_project = @source_project
      merge_request.source_branch = params[:source_branch]

      create(merge_request)
    end

    def after_create(issuable)
      current_user_id = current_user.id

      issuable.run_after_commit do
        # Add new items to MergeRequests::AfterCreateService if they can
        # be performed in Sidekiq
        NewMergeRequestWorker.perform_async(issuable.id, current_user_id)
      end

      issuable.mark_as_preparing

      super
    end

    # expose issuable create method so it can be called from email
    # handler CreateMergeRequestHandler
    public :create

    private

    def before_create(merge_request)
      # If the fetching of the source branch occurs in an ActiveRecord
      # callback (e.g. after_create), a database transaction will be
      # open while the Gitaly RPC waits. To avoid an idle in transaction
      # timeout, we do this before we attempt to save the merge request.

      merge_request.skip_ensure_merge_request_diff = true
      merge_request.check_for_spam(user: current_user, action: :create)
    end

    def set_projects!
      # @project is used to determine whether the user can set the merge request's
      # assignee, milestone and labels. Whether they can depends on their
      # permissions on the target project.
      @source_project = @project
      @project = Project.find(params[:target_project_id]) if params[:target_project_id]

      # make sure that source/target project ids are not in
      # params so it can't be overridden later when updating attributes
      # from params when applying quick actions
      params.delete(:source_project_id)
      params.delete(:target_project_id)

      unless can?(current_user, :create_merge_request_from, @source_project) &&
          can?(current_user, :create_merge_request_in, @project)

        raise Gitlab::Access::AccessDeniedError
      end
    end

    def set_default_attributes!
      # Implemented in EE
    end
  end
end

MergeRequests::CreateService.prepend_mod_with('MergeRequests::CreateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::CreateService, :clean_gitlab_redis_shared_state, feature_category: :code_review_workflow do
  include ProjectForksHelper
  include AfterNextHelpers

  let(:project) { create(:project, :repository) }
  let(:user) { create(:user) }
  let(:user2) { create(:user) }

  describe '#execute' do
    context 'valid params' do
      let(:opts) do
        {
          title: 'Awesome merge_request',
          description: 'please fix',
          source_branch: 'feature',
          target_branch: 'master',
          force_remove_source_branch: '1'
        }
      end

      let(:service) { described_class.new(project: project, current_user: user, params: opts) }
      let(:merge_request) { service.execute }

      before do
        project.add_maintainer(user)
        project.add_developer(user2)
      end

      it 'creates an MR' do
        expect(merge_request).to be_valid
        expect(merge_request.draft?).to be(false)
        expect(merge_request.title).to eq('Awesome merge_request')
        expect(merge_request.assignees).to be_empty
        expect(merge_request.merge_params['force_remove_source_branch']).to eq('1')
      end

      it 'does not execute hooks' do
        expect(project).not_to receive(:execute_hooks)

        service.execute
      end

      it 'refreshes the number of open merge requests', :use_clean_rails_memory_store_caching do
        expect do
          service.execute

          BatchLoader::Executor.clear_current
        end.to change { project.open_merge_requests_count }.from(0).to(1)
      end

      it 'creates exactly 1 create MR event', :sidekiq_inline do
        attributes = {
          action: :created,
          target_id: merge_request.id,
          target_type: merge_request.class.name
        }

        expect(Event.where(attributes).count).to eq(1)
      end

      it 'sets the merge_status to preparing' do
        expect(merge_request.reload).to be_preparing
      end

      describe 'checking for spam' do
        it 'checks for spam' do
          expect_next_instance_of(MergeRequest) do |instance|
            expect(instance).to receive(:check_for_spam).with(user: user, action: :create)
          end

          service.execute
        end

        it 'does not persist when spam' do
          allow_next_instance_of(MergeRequest) do |instance|
            allow(instance).to receive(:spam?).and_return(true)
          end

          expect(merge_request).not_to be_persisted
        end
      end

      describe 'when marked with /draft' do
        context 'in title and in description' do
          let(:opts) do
            {
              title: 'Draft: Awesome merge_request',
              description: ""well this is not done yet\n/draft"",
              source_branch: 'feature',
              target_branch: 'master',
              assignees: [user2]
            }
          end

          it 'sets MR to draft' do
            expect(merge_request.draft?).to be(true)
          end
        end

        context 'in description only' do
          let(:opts) do
            {
              title: 'Awesome merge_request',
              description: ""well this is not done yet\n/draft"",
              source_branch: 'feature',
              target_branch: 'master',
              assignees: [user2]
            }
          end

          it 'sets MR to draft' do
            expect(merge_request.draft?).to be(true)
          end
        end
      end

      context 'when merge request is assigned to someone' do
        let(:opts) do
          {
            title: 'Awesome merge_request',
            description: 'please fix',
            source_branch: 'feature',
            target_branch: 'master',
            assignee_ids: [user2.id]
          }
        end

        it { expect(merge_request.assignees).to eq([user2]) }
      end

      context 'when reviewer is assigned' do
        let(:opts) do
          {
            title: 'Awesome merge_request',
            description: 'please fix',
            source_branch: 'feature',
            target_branch: 'master',
            reviewers: [user2]
          }
        end

        it { expect(merge_request.reviewers).to eq([user2]) }

        it 'invalidates counter cache for reviewers', :use_clean_rails_memory_store_caching do
          expect { merge_request }
            .to change { user2.review_requested_open_merge_requests_count }
            .by(1)
        end
      end

      context 'when head pipelines already exist for merge request source branch', :sidekiq_inline do
        let(:shas) { project.repository.commits(opts[:source_branch], limit: 2).map(&:id) }
        let!(:pipeline_1) { create(:ci_pipeline, project: project, ref: opts[:source_branch], project_id: project.id, sha: shas[1]) }
        let!(:pipeline_2) { create(:ci_pipeline, project: project, ref: opts[:source_branch], project_id: project.id, sha: shas[0]) }
        let!(:pipeline_3) { create(:ci_pipeline, project: project, ref: ""other_branch"", project_id: project.id) }

        before do
          # rubocop: disable Cop/DestroyAll
          project.merge_requests
            .where(source_branch: opts[:source_branch], target_branch: opts[:target_branch])
            .destroy_all
          # rubocop: enable Cop/DestroyAll
        end

        it 'sets head pipeline' do
          merge_request = service.execute

          expect(merge_request.reload.head_pipeline).to eq(pipeline_2)
          expect(merge_request).to be_persisted
        end

        context 'when the new pipeline is associated with an old sha' do
          let!(:pipeline_1) { create(:ci_pipeline, project: project, ref: opts[:source_branch], project_id: project.id, sha: shas[0]) }
          let!(:pipeline_2) { create(:ci_pipeline, project: project, ref: opts[:source_branch], project_id: project.id, sha: shas[1]) }

          it 'sets an old pipeline with associated with the latest sha as the head pipeline' do
            merge_request = service.execute

            expect(merge_request.reload.head_pipeline).to eq(pipeline_1)
            expect(merge_request).to be_persisted
          end
        end

        context 'when there are no pipelines with the diff head sha' do
          let!(:pipeline_1) { create(:ci_pipeline, project: project, ref: opts[:source_branch], project_id: project.id, sha: shas[1]) }
          let!(:pipeline_2) { create(:ci_pipeline, project: project, ref: opts[:source_branch], project_id: project.id, sha: shas[1]) }

          it 'does not set the head pipeline' do
            merge_request = service.execute

            expect(merge_request.reload.head_pipeline).to be_nil
            expect(merge_request).to be_persisted
          end
        end
      end

      describe 'Pipelines for merge requests', :sidekiq_inline do
        before do
          stub_ci_pipeline_yaml_file(config)
        end

        context ""when .gitlab-ci.yml has merge_requests keywords"" do
          let(:config) do
            YAML.dump({
              test: {
                stage: 'test',
                script: 'echo',
                only: ['merge_requests']
              }
            })
          end

          it 'creates a detached merge request pipeline and sets it as a head pipeline' do
            expect(merge_request).to be_persisted

            merge_request.reload
            expect(merge_request.pipelines_for_merge_request.count).to eq(1)
            expect(merge_request.actual_head_pipeline).to be_detached_merge_request_pipeline
          end

          context 'when merge request is submitted from forked project' do
            let(:target_project) { fork_project(project, nil, repository: true) }

            let(:opts) do
              {
                title: 'Awesome merge_request',
                source_branch: 'feature',
                target_branch: 'master',
                target_project_id: target_project.id
              }
            end

            before do
              target_project.add_developer(user2)
              target_project.add_maintainer(user)
            end

            it 'create detached merge request pipeline for fork merge request' do
              merge_request.reload

              head_pipeline = merge_request.actual_head_pipeline
              expect(head_pipeline).to be_detached_merge_request_pipeline
              expect(head_pipeline.project).to eq(target_project)
            end
          end

          context 'when there are no commits between source branch and target branch' do
            let(:opts) do
              {
                title: 'Awesome merge_request',
                description: 'please fix',
                source_branch: 'not-merged-branch',
                target_branch: 'master'
              }
            end

            it 'does not create a detached merge request pipeline' do
              expect(merge_request).to be_persisted

              merge_request.reload
              expect(merge_request.pipelines_for_merge_request.count).to eq(0)
            end
          end

          context ""when branch pipeline was created before a merge request pipline has been created"" do
            before do
              create(
                :ci_pipeline,
                project: merge_request.source_project,
                sha: merge_request.diff_head_sha,
                ref: merge_request.source_branch,
                tag: false
              )

              merge_request
            end

            it 'sets the latest detached merge request pipeline as the head pipeline' do
              merge_request.reload

              expect(merge_request.actual_head_pipeline).to be_merge_request_event
            end
          end
        end

        context ""when .gitlab-ci.yml does not have merge_requests keywords"" do
          let(:config) do
            YAML.dump({
              test: {
                stage: 'test',
                script: 'echo'
              }
            })
          end

          it 'does not create a detached merge request pipeline' do
            expect(merge_request).to be_persisted

            merge_request.reload
            expect(merge_request.pipelines_for_merge_request.count).to eq(0)
          end
        end

        context 'when .gitlab-ci.yml is invalid' do
          let(:config) { 'invalid yaml file' }

          it 'persists a pipeline with config error' do
            expect(merge_request).to be_persisted

            merge_request.reload
            expect(merge_request.pipelines_for_merge_request.count).to eq(1)
            expect(merge_request.pipelines_for_merge_request.last).to be_failed
            expect(merge_request.pipelines_for_merge_request.last).to be_config_error
          end
        end
      end

      context 'after_save callback to store_mentions' do
        let(:labels) { create_pair(:label, project: project) }
        let(:milestone) { create(:milestone, project: project) }
        let(:req_opts) { { source_branch: 'feature', target_branch: 'master' } }

        context 'when mentionable attributes change' do
          let(:opts) { { title: 'Title', description: ""Description with #{user.to_reference}"" }.merge(req_opts) }

          it 'saves mentions' do
            expect_next_instance_of(MergeRequest) do |instance|
              expect(instance).to receive(:store_mentions!).and_call_original
            end
            expect(merge_request.user_mentions.count).to eq 1
          end
        end

        context 'when mentionable attributes do not change' do
          let(:opts) { { label_ids: labels.map(&:id), milestone_id: milestone.id }.merge(req_opts) }

          it 'does not call store_mentions' do
            expect_next_instance_of(MergeRequest) do |instance|
              expect(instance).not_to receive(:store_mentions!).and_call_original
            end
            expect(merge_request.valid?).to be false
            expect(merge_request.user_mentions.count).to eq 0
          end
        end

        context 'when save fails' do
          let(:opts) { { label_ids: labels.map(&:id), milestone_id: milestone.id } }

          it 'does not call store_mentions' do
            expect_next_instance_of(MergeRequest) do |instance|
              expect(instance).not_to receive(:store_mentions!).and_call_original
            end
            expect(merge_request.valid?).to be false
          end
        end
      end

      context 'with a milestone' do
        let(:milestone) { create(:milestone, project: project) }

        let(:opts) { { title: 'Awesome merge_request', source_branch: 'feature', target_branch: 'master', milestone_id: milestone.id } }

        it 'deletes the cache key for milestone merge request counter' do
          expect_next(Milestones::MergeRequestsCountService, milestone)
            .to receive(:delete_cache).and_call_original

          expect(merge_request).to be_persisted
        end
      end

      it_behaves_like 'reviewer_ids filter' do
        let(:execute) { service.execute }
      end

      context 'when called in a transaction' do
        it 'does not raise an error' do
          expect { MergeRequest.transaction { described_class.new(project: project, current_user: user, params: opts).execute } }.not_to raise_error
        end
      end
    end

    it_behaves_like 'issuable record that supports quick actions' do
      let(:default_params) do
        {
          source_branch: 'feature',
          target_branch: 'master'
        }
      end

      let(:issuable) { described_class.new(project: project, current_user: user, params: params).execute }
    end

    context 'Quick actions' do
      context 'with assignee and milestone in params and command' do
        let(:merge_request) { described_class.new(project: project, current_user: user, params: opts).execute }
        let(:milestone) { create(:milestone, project: project) }

        let(:opts) do
          {
            assignee_ids: create(:user).id,
            milestone_id: 1,
            title: 'Title',
            description: %(/assign @#{user2.username}\n/milestone %""#{milestone.name}""),
            source_branch: 'feature',
            target_branch: 'master'
          }
        end

        before do
          project.add_maintainer(user)
          project.add_maintainer(user2)
        end

        it 'assigns and sets milestone to issuable from command' do
          expect(merge_request).to be_persisted
          expect(merge_request.assignees).to eq([user2])
          expect(merge_request.milestone).to eq(milestone)
        end
      end
    end

    context 'merge request create service' do
      context 'asssignee_id' do
        let(:user2) { create(:user) }

        before do
          project.add_maintainer(user)
        end

        it 'removes assignee_id when user id is invalid' do
          opts = { title: 'Title', description: 'Description', assignee_ids: [-1] }

          merge_request = described_class.new(project: project, current_user: user, params: opts).execute

          expect(merge_request.assignee_ids).to be_empty
        end

        it 'removes assignee_id when user id is 0' do
          opts = { title: 'Title', description: 'Description', assignee_ids: [0] }

          merge_request = described_class.new(project: project, current_user: user, params: opts).execute

          expect(merge_request.assignee_ids).to be_empty
        end

        it 'saves assignee when user id is valid' do
          project.add_maintainer(user2)
          opts = { title: 'Title', description: 'Description', assignee_ids: [user2.id] }

          merge_request = described_class.new(project: project, current_user: user, params: opts).execute

          expect(merge_request.assignees).to eq([user2])
        end

        context 'when assignee is set' do
          let(:opts) do
            {
              title: 'Title',
              description: 'Description',
              assignee_ids: [user2.id],
              source_branch: 'feature',
              target_branch: 'master'
            }
          end

          before do
            project.add_maintainer(user2)
          end

          it 'invalidates open merge request counter for assignees when merge request is assigned' do
            described_class.new(project: project, current_user: user, params: opts).execute

            expect(user2.assigned_open_merge_requests_count).to eq 1
          end

          it 'records the assignee assignment event', :sidekiq_inline do
            mr = described_class.new(project: project, current_user: user, params: opts).execute.reload

            expect(mr.assignment_events).to match([have_attributes(user_id: user2.id, action: 'add')])
          end
        end

        context ""when issuable feature is private"" do
          before do
            project.project_feature.update!(
              issues_access_level: ProjectFeature::PRIVATE,
              merge_requests_access_level: ProjectFeature::PRIVATE
            )
          end

          levels = [Gitlab::VisibilityLevel::INTERNAL, Gitlab::VisibilityLevel::PUBLIC]

          levels.each do |level|
            it ""removes not authorized assignee when project is #{Gitlab::VisibilityLevel.level_name(level)}"" do
              project.update!(visibility_level: level)
              opts = { title: 'Title', description: 'Description', assignee_ids: [user2.id] }

              merge_request = described_class.new(project: project, current_user: user, params: opts).execute

              expect(merge_request.assignee_id).to be_nil
            end
          end
        end
      end
    end

    shared_examples 'when source and target projects are different' do
      let(:target_project) { fork_project(project, nil, repository: true) }

      let(:opts) do
        {
          title: 'Awesome merge_request',
          source_branch: 'feature',
          target_branch: 'master',
          target_project_id: target_project.id
        }
      end

      context 'when user can not access source project' do
        before do
          target_project.add_developer(user2)
          target_project.add_maintainer(user)
        end

        it 'raises an error' do
          expect { described_class.new(project: project, current_user: user, params: opts).execute }
            .to raise_error Gitlab::Access::AccessDeniedError
        end
      end

      context 'when user can not access target project' do
        before do
          target_project.add_developer(user2)
          target_project.add_maintainer(user)
        end

        it 'raises an error' do
          expect { described_class.new(project: project, current_user: user, params: opts).execute }
            .to raise_error Gitlab::Access::AccessDeniedError
        end
      end

      context 'when the user has access to both projects' do
        before do
          target_project.add_developer(user)
          project.add_developer(user)
        end

        it 'creates the merge request', :sidekiq_inline do
          merge_request = described_class.new(project: project, current_user: user, params: opts).execute

          expect(merge_request).to be_persisted
          expect(merge_request.iid).to be > 0
          expect(merge_request.merge_request_diff).not_to be_empty
        end

        it 'does not create the merge request when the target project is archived' do
          target_project.update!(archived: true)

          expect { described_class.new(project: project, current_user: user, params: opts).execute }
            .to raise_error Gitlab::Access::AccessDeniedError
        end
      end
    end

    it_behaves_like 'when source and target projects are different'

    context 'when user sets source project id' do
      let(:another_project) { create(:project) }

      let(:opts) do
        {
          title: 'Awesome merge_request',
          source_branch: 'feature',
          target_branch: 'master',
          source_project_id: another_project.id
        }
      end

      before do
        project.add_developer(user2)
        project.add_maintainer(user)
      end

      it 'ignores source_project_id' do
        merge_request = described_class.new(project: project, current_user: user, params: opts).execute

        expect(merge_request.source_project_id).to eq(project.id)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class HandleAssigneesChangeService < MergeRequests::BaseService
    def async_execute(merge_request, old_assignees, options = {})
      MergeRequests::HandleAssigneesChangeWorker
        .perform_async(
          merge_request.id,
          current_user.id,
          old_assignees.map(&:id),
          options.stringify_keys # see: https://gitlab.com/gitlab-com/gl-infra/scalability/-/issues/1090
        )
    end

    def execute(merge_request, old_assignees, options = {})
      create_assignee_note(merge_request, old_assignees)
      notification_service.async.reassigned_merge_request(merge_request, current_user, old_assignees.to_a)
      Gitlab::ResourceEvents::AssignmentEventRecorder.new(parent: merge_request, old_assignees: old_assignees).record
      todo_service.reassigned_assignable(merge_request, current_user, old_assignees)

      new_assignees = merge_request.assignees - old_assignees
      merge_request_activity_counter.track_users_assigned_to_mr(users: new_assignees)
      merge_request_activity_counter.track_assignees_changed_action(user: current_user)

      execute_assignees_hooks(merge_request, old_assignees) if options['execute_hooks']
    end

    private

    def execute_assignees_hooks(merge_request, old_assignees)
      execute_hooks(
        merge_request,
        'update',
        old_associations: { assignees: old_assignees }
      )
    end
  end
end

MergeRequests::HandleAssigneesChangeService.prepend_mod_with('MergeRequests::HandleAssigneesChangeService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::HandleAssigneesChangeService, feature_category: :code_review_workflow do
  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:user) { create(:user) }
  let_it_be(:assignee) { create(:user) }
  let_it_be_with_reload(:merge_request) { create(:merge_request, author: user, source_project: project, assignees: [assignee]) }
  let_it_be(:old_assignees) { create_list(:user, 3) }

  let(:options) { {} }
  let(:service) { described_class.new(project: project, current_user: user) }

  before_all do
    project.add_maintainer(user)
    project.add_developer(assignee)

    old_assignees.each do |old_assignee|
      project.add_developer(old_assignee)
    end
  end

  describe '#async_execute' do
    def async_execute
      service.async_execute(merge_request, old_assignees, options)
    end

    it 'performs MergeRequests::HandleAssigneesChangeWorker asynchronously' do
      expect(MergeRequests::HandleAssigneesChangeWorker)
        .to receive(:perform_async)
        .with(
          merge_request.id,
          user.id,
          old_assignees.map(&:id),
          options
        )

      async_execute
    end
  end

  describe '#execute' do
    def execute
      service.execute(merge_request, old_assignees, options)
    end

    let(:note) { merge_request.notes.system.last }
    let(:removed_note) { ""unassigned #{old_assignees.map(&:to_reference).to_sentence}"" }

    context 'when unassigning all users' do
      before do
        merge_request.update!(assignee_ids: [])
      end

      it 'creates assignee note' do
        execute

        expect(note).not_to be_nil
        expect(note.note).to eq removed_note
      end
    end

    it 'creates assignee note' do
      execute

      expect(note).not_to be_nil
      expect(note.note).to include ""assigned to #{assignee.to_reference} and #{removed_note}""
    end

    it 'sends email notifications to old and new assignees', :mailer, :sidekiq_inline do
      perform_enqueued_jobs do
        execute
      end

      should_email(assignee)
      old_assignees.each do |old_assignee|
        should_email(old_assignee)
      end
    end

    it 'creates pending todo for assignee' do
      execute

      todo = assignee.todos.last

      expect(todo).to be_pending
    end

    it 'tracks users assigned event' do
      expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
        .to receive(:track_users_assigned_to_mr).once.with(users: [assignee])

      execute
    end

    it 'tracks assignees changed event' do
      expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
        .to receive(:track_assignees_changed_action).once.with(user: user)

      execute
    end

    context 'when execute_hooks option is set to true' do
      let(:options) { { 'execute_hooks' => true } }

      it 'executes hooks and integrations' do
        expect(merge_request.project).to receive(:execute_hooks).with(anything, :merge_request_hooks)
        expect(merge_request.project).to receive(:execute_integrations).with(anything, :merge_request_hooks)
        expect(service).to receive(:enqueue_jira_connect_messages_for).with(merge_request)

        execute
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  class AddContextService < MergeRequests::BaseService
    def execute
      return error(""You are not allowed to access the requested resource"", 403) unless current_user&.can?(:update_merge_request, merge_request)
      return error(""Context commits: #{duplicates} are already created"", 400) unless duplicates.empty?
      return error(""One or more context commits' sha is not valid."", 400) if commits.size != commit_ids.size

      context_commit_ids = []
      MergeRequestContextCommit.transaction do
        context_commit_ids = MergeRequestContextCommit.bulk_insert(context_commit_rows, return_ids: true)
        MergeRequestContextCommitDiffFile.bulk_insert(diff_rows(context_commit_ids))
      end

      commits
    end

    private

    def raw_repository
      project.repository.raw_repository
    end

    def merge_request
      params[:merge_request]
    end

    def commit_ids
      params[:commits]
    end

    def commits
      project.repository.commits_by(oids: commit_ids)
    end

    def context_commit_rows
      @context_commit_rows ||= build_context_commit_rows(merge_request.id, commits)
    end

    def diff_rows(context_commit_ids)
      @diff_rows ||= build_diff_rows(raw_repository, commits, context_commit_ids)
    end

    def encode_in_base64?(diff_text)
      (diff_text.encoding == Encoding::BINARY && !diff_text.ascii_only?) ||
        diff_text.include?(""\0"")
    end

    def duplicates
      existing_oids = merge_request.merge_request_context_commits.map { |commit| commit.sha.to_s }
      existing_oids.select do |existing_oid|
        commit_ids.count { |commit_id| existing_oid.start_with?(commit_id) } > 0
      end
    end

    def build_context_commit_rows(merge_request_id, commits)
      commits.map.with_index do |commit, index|
        # generate context commit information for given commit
        commit_hash = commit.to_hash.except(:parent_ids, :referenced_by)
        sha = Gitlab::Database::ShaAttribute.serialize(commit_hash.delete(:id))
        commit_hash.merge(
          merge_request_id: merge_request_id,
          relative_order: index,
          sha: sha,
          authored_date: Gitlab::Database.sanitize_timestamp(commit_hash[:authored_date]),
          committed_date: Gitlab::Database.sanitize_timestamp(commit_hash[:committed_date]),
          trailers: Gitlab::Json.dump(commit_hash.fetch(:trailers, {}))
        )
      end
    end

    def build_diff_rows(raw_repository, commits, context_commit_ids)
      diff_rows = []
      diff_order = 0

      commits.flat_map.with_index do |commit, index|
        commit_hash = commit.to_hash.except(:parent_ids, :referenced_by)
        sha = Gitlab::Database::ShaAttribute.serialize(commit_hash.delete(:id))
        # generate context commit diff information for given commit
        diffs = commit.diffs

        compare = Gitlab::Git::Compare.new(
          raw_repository,
          diffs.diff_refs.start_sha,
          diffs.diff_refs.head_sha
        )
        compare.diffs.map do |diff|
          diff_hash = diff.to_hash.merge(
            sha: sha,
            binary: false,
            merge_request_context_commit_id: context_commit_ids[index],
            relative_order: diff_order
          )

          # Compatibility with old diffs created with Psych.
          diff_hash.tap do |hash|
            diff_text = hash[:diff]

            if encode_in_base64?(diff_text)
              hash[:binary] = true
              hash[:diff] = [diff_text].pack('m0')
            end
          end

          # Increase order for commit so when present the diffs we can use it to keep order
          diff_order += 1
          diff_rows << diff_hash
        end
      end

      diff_rows
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::AddContextService, feature_category: :code_review_workflow do
  let(:project) { create(:project, :repository) }
  let(:admin) { create(:admin) }
  let(:merge_request) { create(:merge_request, source_project: project, target_project: project, author: admin) }
  let(:commits) { [""874797c3a73b60d2187ed6e2fcabd289ff75171e""] }
  let(:raw_repository) { project.repository.raw }

  subject(:service) { described_class.new(project: project, current_user: admin, params: { merge_request: merge_request, commits: commits }) }

  describe ""#execute"" do
    context ""when admin mode is enabled"", :enable_admin_mode do
      it ""adds context commit"" do
        service.execute

        expect(merge_request.merge_request_context_commit_diff_files.length).to eq(2)
      end
    end

    context ""when admin mode is disabled"" do
      it ""doesn't add context commit"" do
        subject.execute

        expect(merge_request.merge_request_context_commit_diff_files.length).to eq(0)
      end
    end

    context ""when user doesn't have permission to update merge request"" do
      let(:user) { create(:user) }
      let(:merge_request1) { create(:merge_request, source_project: project, author: user) }

      subject(:service) { described_class.new(project: project, current_user: user, params: { merge_request: merge_request, commits: commits }) }

      it ""doesn't add context commit"" do
        subject.execute

        expect(merge_request.merge_request_context_commit_diff_files.length).to eq(0)
      end
    end

    context ""when the commits array is empty"" do
      subject(:service) { described_class.new(project: project, current_user: admin, params: { merge_request: merge_request, commits: [] }) }

      it ""doesn't add context commit"" do
        subject.execute

        expect(merge_request.merge_request_context_commit_diff_files.length).to eq(0)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  # CreateRefService creates or overwrites a ref under ""refs/merge-requests/""
  # with a commit for the merged result.
  class CreateRefService
    include Gitlab::Utils::StrongMemoize

    CreateRefError = Class.new(StandardError)

    def initialize(
      current_user:, merge_request:, target_ref:, first_parent_ref:, source_sha: nil
    )
      @current_user = current_user
      @merge_request = merge_request
      @source_sha = source_sha
      @target_ref = target_ref
      @first_parent_ref = first_parent_ref
      @first_parent_sha = target_project.commit(first_parent_ref)&.sha
    end

    def execute
      # TODO: Update this message with the removal of FF merge_trains_create_ref_service and update tests
      # This is for compatibility with MergeToRefService during the rollout.
      return ServiceResponse.error(message: '3:Invalid merge source') unless first_parent_sha.present?

      result = {
        commit_sha: source_sha,      # the SHA to be at HEAD of target_ref
        expected_old_oid: """",        # the SHA we expect target_ref to be at prior to an update (an optimistic lock)
        source_sha: source_sha,      # for pipeline.source_sha
        target_sha: first_parent_sha # for pipeline.target_sha
      }

      result = maybe_squash!(**result)
      result = maybe_rebase!(**result)
      result = maybe_merge!(**result)

      update_merge_request!(merge_request, result)

      ServiceResponse.success(payload: result)
    rescue CreateRefError => error
      ServiceResponse.error(message: error.message)
    end

    private

    attr_reader :current_user, :merge_request, :target_ref, :first_parent_ref, :first_parent_sha, :source_sha

    delegate :target_project, to: :merge_request
    delegate :repository, to: :target_project

    def maybe_squash!(commit_sha:, **rest)
      if merge_request.squash_on_merge?
        squash_result = MergeRequests::SquashService.new(
          merge_request: merge_request,
          current_user: current_user,
          commit_message: squash_commit_message
        ).execute

        raise CreateRefError, squash_result[:message] if squash_result[:status] == :error

        commit_sha = squash_result[:squash_sha]
        squash_commit_sha = commit_sha
      end

      # squash does not overwrite target_ref, so expected_old_oid remains the same
      rest.merge(
        commit_sha: commit_sha,
        squash_commit_sha: squash_commit_sha
      ).compact
    end

    def maybe_rebase!(commit_sha:, expected_old_oid:, squash_commit_sha: nil, **rest)
      if target_project.ff_merge_must_be_possible?
        commit_sha = safe_gitaly_operation do
          repository.rebase_to_ref(
            current_user,
            source_sha: commit_sha,
            target_ref: target_ref,
            first_parent_ref: first_parent_sha,
            expected_old_oid: expected_old_oid || """"
          )
        end

        squash_commit_sha = commit_sha if squash_commit_sha # rebase rewrites commit SHAs after first_parent_sha
        expected_old_oid = commit_sha
      end

      rest.merge(
        commit_sha: commit_sha,
        squash_commit_sha: squash_commit_sha,
        expected_old_oid: expected_old_oid
      ).compact
    end

    def maybe_merge!(commit_sha:, expected_old_oid:, **rest)
      unless target_project.merge_requests_ff_only_enabled
        commit_sha = safe_gitaly_operation do
          repository.merge_to_ref(
            current_user,
            source_sha: commit_sha,
            target_ref: target_ref,
            message: merge_commit_message,
            first_parent_ref: first_parent_sha,
            branch: nil,
            expected_old_oid: expected_old_oid || """"
          )
        end

        expected_old_oid = commit_sha
        merge_commit_sha = commit_sha
      end

      rest.merge(
        commit_sha: commit_sha,
        merge_commit_sha: merge_commit_sha,
        expected_old_oid: expected_old_oid
      ).compact
    end

    def update_merge_request!(merge_request, result)
      # overridden in EE
    end

    def safe_gitaly_operation
      yield
    rescue Gitlab::Git::PreReceiveError, Gitlab::Git::CommandError, ArgumentError => error
      raise CreateRefError, error.message
    end

    def squash_commit_message
      merge_request.merge_params['squash_commit_message'].presence ||
        merge_request.default_squash_commit_message(user: current_user)
    end
    strong_memoize_attr :squash_commit_message

    def merge_commit_message
      merge_request.merge_params['commit_message'].presence ||
        merge_request.default_merge_commit_message(user: current_user)
    end
  end
end

MergeRequests::CreateRefService.prepend_mod_with('MergeRequests::CreateRefService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::CreateRefService, feature_category: :merge_trains do
  using RSpec::Parameterized::TableSyntax

  describe '#execute' do
    let_it_be_with_reload(:project) { create(:project, :empty_repo) }
    let_it_be(:user) { project.creator }
    let_it_be(:first_parent_ref) { project.default_branch_or_main }
    let_it_be(:source_branch) { 'branch' }
    let(:target_ref) { ""refs/merge-requests/#{merge_request.iid}/train"" }
    let(:source_sha) { project.commit(source_branch).sha }
    let(:squash) { false }
    let(:default_commit_message) { merge_request.default_merge_commit_message(user: user) }

    let(:merge_request) do
      create(
        :merge_request,
        title: 'Merge request ref test',
        author: user,
        source_project: project,
        target_project: project,
        source_branch: source_branch,
        target_branch: first_parent_ref,
        squash: squash
      )
    end

    subject(:result) do
      described_class.new(
        current_user: user,
        merge_request: merge_request,
        target_ref: target_ref,
        source_sha: source_sha,
        first_parent_ref: first_parent_ref
      ).execute
    end

    context 'when there is a user-caused gitaly error' do
      let(:source_sha) { '123' }

      it 'returns an error response' do
        expect(result[:status]).to eq :error
      end
    end

    context 'with valid inputs' do
      before_all do
        # ensure first_parent_ref is created before source_sha
        project.repository.create_file(
          user,
          'README.md',
          '',
          message: 'Base parent commit 1',
          branch_name: first_parent_ref
        )
        project.repository.create_branch(source_branch, first_parent_ref)

        # create two commits source_branch to test squashing
        project.repository.create_file(
          user,
          '.gitlab-ci.yml',
          '',
          message: 'Feature branch commit 1',
          branch_name: source_branch
        )

        project.repository.create_file(
          user,
          '.gitignore',
          '',
          message: 'Feature branch commit 2',
          branch_name: source_branch
        )

        # create an extra commit not present on source_branch
        project.repository.create_file(
          user,
          'EXTRA',
          '',
          message: 'Base parent commit 2',
          branch_name: first_parent_ref
        )
      end

      shared_examples_for 'writing with a merge commit' do
        it 'merges with a merge commit', :aggregate_failures do
          expect(result[:status]).to eq :success
          expect(result[:commit_sha]).to eq(project.repository.commit(target_ref).sha)
          expect(result[:source_sha]).to eq(project.repository.commit(source_branch).sha)
          expect(result[:target_sha]).to eq(project.repository.commit(first_parent_ref).sha)
          expect(result[:merge_commit_sha]).to be_present
          expect(result[:squash_commit_sha]).not_to be_present
          expect(project.repository.commits(target_ref, limit: 10, order: 'topo').map(&:message)).to(
            match(
              [
                expected_merge_commit,
                'Feature branch commit 2',
                'Feature branch commit 1',
                'Base parent commit 2',
                'Base parent commit 1'
              ]
            )
          )
        end
      end

      shared_examples_for 'writing with a squash and merge commit' do
        it 'writes the squashed result', :aggregate_failures do
          expect(result[:status]).to eq :success
          expect(result[:commit_sha]).to eq(project.repository.commit(target_ref).sha)
          expect(result[:source_sha]).to eq(project.repository.commit(source_branch).sha)
          expect(result[:target_sha]).to eq(project.repository.commit(first_parent_ref).sha)
          expect(result[:merge_commit_sha]).to be_present
          expect(result[:squash_commit_sha]).to be_present
          expect(project.repository.commits(target_ref, limit: 10, order: 'topo').map(&:message)).to(
            match(
              [
                expected_merge_commit,
                ""#{merge_request.title}\n"",
                'Base parent commit 2',
                'Base parent commit 1'
              ]
            )
          )
        end
      end

      shared_examples_for 'writing with a squash and no merge commit' do
        it 'writes the squashed result without a merge commit', :aggregate_failures do
          expect(result[:status]).to eq :success
          expect(result[:commit_sha]).to eq(project.repository.commit(target_ref).sha)
          expect(result[:source_sha]).to eq(project.repository.commit(source_branch).sha)
          expect(result[:target_sha]).to eq(project.repository.commit(first_parent_ref).sha)
          expect(result[:merge_commit_sha]).not_to be_present
          expect(result[:squash_commit_sha]).to be_present
          expect(project.repository.commits(target_ref, limit: 10, order: 'topo').map(&:message)).to(
            match(
              [
                ""#{merge_request.title}\n"",
                'Base parent commit 2',
                'Base parent commit 1'
              ]
            )
          )
        end
      end

      shared_examples_for 'writing without a merge commit' do
        it 'writes the rebased merged result', :aggregate_failures do
          expect(result[:status]).to eq :success
          expect(result[:commit_sha]).to eq(project.repository.commit(target_ref).sha)
          expect(result[:source_sha]).to eq(project.repository.commit(source_branch).sha)
          expect(result[:target_sha]).to eq(project.repository.commit(first_parent_ref).sha)
          expect(result[:merge_commit_sha]).not_to be_present
          expect(result[:squash_commit_sha]).not_to be_present
          expect(project.repository.commits(target_ref, limit: 10, order: 'topo').map(&:message)).to(
            eq(
              [
                'Feature branch commit 2',
                'Feature branch commit 1',
                'Base parent commit 2',
                'Base parent commit 1'
              ]
            )
          )
        end
      end

      shared_examples 'merge commits without squash' do
        context 'with a custom template' do
          let(:expected_merge_commit) { 'This is the merge commit' } # could also be default_commit_message

          before do
            project.project_setting.update!(merge_commit_template: expected_merge_commit)
          end

          it_behaves_like 'writing with a merge commit'
        end

        context 'with no custom template' do
          let(:expected_merge_commit) { default_commit_message }

          before do
            project.project_setting.update!(merge_commit_template: nil)
          end

          it_behaves_like 'writing with a merge commit'
        end
      end

      shared_examples 'merge commits with squash' do
        context 'when squash set' do
          let(:squash) { true }
          let(:expected_merge_commit) { merge_request.default_merge_commit_message(user: user) }

          before do
            project.project_setting.update!(merge_commit_template: 'This is the merge commit')
          end

          it_behaves_like 'writing with a squash and merge commit'
        end
      end

      context 'when the merge commit message is provided at time of merge' do
        let(:expected_merge_commit) { 'something custom' }

        before do
          merge_request.merge_params['commit_message'] = expected_merge_commit
        end

        it 'writes the merged result', :aggregate_failures do
          expect(result[:status]).to eq :success
          expect(project.repository.commits(target_ref, limit: 1, order: 'topo').map(&:message)).to(
            match([expected_merge_commit])
          )
        end

        context 'when squash set' do
          let(:squash) { true }

          it_behaves_like 'writing with a squash and merge commit'
        end
      end

      context 'when merged commit strategy' do
        include_examples 'merge commits without squash'
        include_examples 'merge commits with squash'
      end

      context 'when semi-linear merge strategy' do
        before do
          project.merge_method = :rebase_merge
          project.save!
        end

        include_examples 'merge commits without squash'
        include_examples 'merge commits with squash'

        context 'when the target ref changes between rebase and merge' do
          # this tests internal handling of expected_old_oid

          it 'returns an error', :aggregate_failures do
            expect_next_instance_of(described_class) do |instance|
              original = instance.method(:maybe_merge!)

              expect(instance).to receive(:maybe_merge!) do |*args, **kwargs|
                # Corrupt target_ref before the merge, simulating a race with
                # another instance of the service for the same MR. source_sha is
                # just an arbitrary valid commit that differs from what was just
                # written.
                project.repository.write_ref(target_ref, source_sha)
                original.call(*args, **kwargs)
              end
            end

            expect(result[:status]).to eq :error
            expect(result[:message]).to eq ""9:Could not update #{target_ref}. Please refresh and try again.""
          end
        end
      end

      context 'when fast-forward merge strategy' do
        before do
          project.merge_method = :ff
          project.save!
        end

        it_behaves_like 'writing without a merge commit'

        context 'when squash set' do
          let(:squash) { true }

          it_behaves_like 'writing with a squash and no merge commit'
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  # MergeService class
  #
  # Do git merge and in case of success
  # mark merge request as merged and execute all hooks and notifications
  # Executed when you do merge via GitLab UI
  #
  class MergeService < MergeRequests::MergeBaseService
    include Gitlab::Utils::StrongMemoize

    GENERIC_ERROR_MESSAGE = 'An error occurred while merging'
    LEASE_TIMEOUT = 15.minutes.to_i

    delegate :merge_jid, :state, to: :@merge_request

    def execute(merge_request, options = {})
      return if merge_request.merged?
      return unless exclusive_lease(merge_request.id).try_obtain

      merge_strategy_class = options[:merge_strategy] || MergeRequests::MergeStrategies::FromSourceBranch
      @merge_strategy = merge_strategy_class.new(merge_request, current_user, merge_params: params, options: options)

      @merge_request = merge_request
      @options = options
      jid = merge_jid

      validate!

      merge_request.in_locked_state do
        if commit
          after_merge
          clean_merge_jid
          success
        end
      end

      log_info(""Merge process finished on JID #{jid} with state #{state}"")
    rescue MergeError, MergeRequests::MergeStrategies::StrategyError => e
      handle_merge_error(log_message: e.message, save_message_on_model: true)
    ensure
      exclusive_lease(merge_request.id).cancel
    end

    private

    def validate!
      authorization_check!
      error_check!
      validate_strategy!
      updated_check!
    end

    def authorization_check!
      unless @merge_request.can_be_merged_by?(current_user)
        raise_error('You are not allowed to merge this merge request')
      end
    end

    def validate_strategy!
      @merge_strategy.validate!
    end

    def updated_check!
      unless source_matches?
        raise_error('Branch has been updated since the merge was requested. '\
                    'Please review the changes.')
      end
    end

    def commit
      log_info(""Git merge started on JID #{merge_jid}"")

      merge_result = try_merge { @merge_strategy.execute_git_merge! }

      commit_sha = merge_result[:commit_sha]
      raise_error(GENERIC_ERROR_MESSAGE) unless commit_sha

      log_info(""Git merge finished on JID #{merge_jid} commit #{commit_sha}"")

      new_merge_request_attributes = {
        merged_commit_sha: commit_sha,
        merge_commit_sha: merge_result[:merge_commit_sha],
        squash_commit_sha: merge_result[:squash_commit_sha]
      }.compact
      merge_request.update!(new_merge_request_attributes) if new_merge_request_attributes.present?

      commit_sha
    ensure
      merge_request.update_and_mark_in_progress_merge_commit_sha(nil)
      log_info(""Merge request marked in progress"")
    end

    def try_merge
      yield
    rescue Gitlab::Git::PreReceiveError => e
      raise MergeError, ""Something went wrong during merge pre-receive hook. #{e.message}"".strip
    rescue StandardError => e
      handle_merge_error(log_message: e.message)
      raise_error(GENERIC_ERROR_MESSAGE)
    end

    def after_merge
      log_info(""Post merge started on JID #{merge_jid} with state #{state}"")
      MergeRequests::PostMergeService.new(project: project, current_user: current_user).execute(merge_request)
      log_info(""Post merge finished on JID #{merge_jid} with state #{state}"")

      if delete_source_branch?
        MergeRequests::DeleteSourceBranchWorker.perform_async(@merge_request.id, @merge_request.source_branch_sha, branch_deletion_user.id)
      end

      merge_request_merge_param
    end

    def clean_merge_jid
      merge_request.update_column(:merge_jid, nil)
    end

    def branch_deletion_user
      @merge_request.force_remove_source_branch? ? @merge_request.author : current_user
    end

    # Verify again that the source branch can be removed, since branch may be protected,
    # or the source branch may have been updated, or the user may not have permission
    #
    def delete_source_branch?
      params.fetch('should_remove_source_branch', @merge_request.force_remove_source_branch?) &&
        @merge_request.can_remove_source_branch?(branch_deletion_user)
    end

    def merge_request_merge_param
      if @merge_request.can_remove_source_branch?(branch_deletion_user) && !params.fetch('should_remove_source_branch', nil).nil?
        @merge_request.update(merge_params: @merge_request.merge_params.merge('should_remove_source_branch' => params['should_remove_source_branch']))
      end
    end

    def handle_merge_error(log_message:, save_message_on_model: false)
      log_error(""MergeService ERROR: #{merge_request_info}:#{merge_status} - #{log_message}"")
      @merge_request.update(merge_error: log_message) if save_message_on_model
    end

    def log_info(message)
      payload = log_payload(""#{merge_request_info} - #{message}"")
      logger.info(**payload)
    end

    def log_error(message)
      payload = log_payload(message)
      logger.error(**payload)
    end

    def logger
      @logger ||= Gitlab::AppLogger
    end

    def log_payload(message)
      Gitlab::ApplicationContext.current.merge(merge_request_info: merge_request_info, message: message)
    end

    def merge_request_info
      @merge_request_info ||= merge_request.to_reference(full: true)
    end

    def merge_status
      @merge_status ||= @merge_request.merge_status
    end

    def source_matches?
      # params-keys are symbols coming from the controller, but when they get
      # loaded from the database they're strings
      params.with_indifferent_access[:sha] == merge_request.diff_head_sha
    end

    def exclusive_lease(merge_request_id)
      strong_memoize(:""exclusive_lease_#{merge_request_id}"") do
        lease_key = ['merge_requests_merge_service', merge_request_id].join(':')

        Gitlab::ExclusiveLease.new(lease_key, timeout: LEASE_TIMEOUT)
      end
    end
  end
end

MergeRequests::MergeService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::MergeService, feature_category: :code_review_workflow do
  include ExclusiveLeaseHelpers

  let_it_be(:user) { create(:user) }
  let_it_be(:user2) { create(:user) }

  let(:merge_request) { create(:merge_request, :simple, author: user2, assignees: [user2]) }
  let(:project) { merge_request.project }

  before do
    project.add_maintainer(user)
    project.add_developer(user2)
  end

  describe '#execute' do
    let(:service) { described_class.new(project: project, current_user: user, params: merge_params) }
    let(:merge_params) do
      { commit_message: 'Awesome message', sha: merge_request.diff_head_sha }
    end

    let(:lease_key) { ""merge_requests_merge_service:#{merge_request.id}"" }
    let!(:lease) { stub_exclusive_lease(lease_key) }

    shared_examples 'with valid params' do
      before do
        allow(service).to receive(:execute_hooks)
        expect(merge_request).to receive(:update_and_mark_in_progress_merge_commit_sha).twice.and_call_original

        perform_enqueued_jobs do
          service.execute(merge_request)
        end
      end

      it { expect(merge_request).to be_valid }
      it { expect(merge_request).to be_merged }

      it 'does not update squash_commit_sha if it is not a squash' do
        expect(merge_request.squash_commit_sha).to be_nil
      end

      it 'sends email to user2 about merge of new merge_request' do
        email = ActionMailer::Base.deliveries.last
        expect(email.to.first).to eq(user2.email)
        expect(email.subject).to include(merge_request.title)
      end

      context 'note creation' do
        it 'creates resource state event about merge_request merge' do
          event = merge_request.resource_state_events.last
          expect(event.state).to eq('merged')
        end
      end
    end

    shared_examples 'squashing' do
      # A merge request with 5 commits
      let(:merge_request) do
        create(
          :merge_request,
          :simple,
          author: user2,
          assignees: [user2],
          squash: true,
          source_branch: 'improve/awesome',
          target_branch: 'fix'
        )
      end

      let(:merge_params) do
        { commit_message: 'Merge commit message',
          squash_commit_message: 'Squash commit message',
          sha: merge_request.diff_head_sha }
      end

      before do
        allow(service).to receive(:execute_hooks)
        expect(merge_request).to receive(:update_and_mark_in_progress_merge_commit_sha).twice.and_call_original

        perform_enqueued_jobs do
          service.execute(merge_request)
        end
      end

      it 'merges the merge request with squashed commits' do
        expect(merge_request).to be_merged

        merge_commit = merge_request.merge_commit
        squash_commit = merge_request.merge_commit.parents.last

        expect(merge_commit.message).to eq('Merge commit message')
        expect(squash_commit.message).to eq(""Squash commit message\n"")
      end

      it 'persists squash_commit_sha' do
        squash_commit = merge_request.merge_commit.parents.last

        expect(merge_request.squash_commit_sha).to eq(squash_commit.id)
      end
    end

    context 'when merge strategy is merge commit' do
      it 'persists merge_commit_sha and merged_commit_sha and nullifies in_progress_merge_commit_sha' do
        service.execute(merge_request)

        expect(merge_request.merge_commit_sha).not_to be_nil
        expect(merge_request.merged_commit_sha).to eq merge_request.merge_commit_sha
        expect(merge_request.in_progress_merge_commit_sha).to be_nil
      end

      it_behaves_like 'with valid params'

      it_behaves_like 'squashing'
    end

    context 'when merge strategy is fast forward' do
      before do
        project.update!(merge_requests_ff_only_enabled: true)
      end

      let(:merge_request) do
        create(
          :merge_request,
          source_branch: 'flatten-dir',
          target_branch: 'improve/awesome',
          assignees: [user2],
          author: create(:user)
        )
      end

      it 'does not create merge_commit_sha, but persists merged_commit_sha and nullifies in_progress_merge_commit_sha' do
        service.execute(merge_request)

        expect(merge_request.merge_commit_sha).to be_nil
        expect(merge_request.merged_commit_sha).not_to be_nil
        expect(merge_request.merged_commit_sha).to eq merge_request.diff_head_sha
        expect(merge_request.in_progress_merge_commit_sha).to be_nil
      end

      it_behaves_like 'with valid params'

      it 'updates squash_commit_sha and merged_commit_sha if it is a squash' do
        expect(merge_request).to receive(:update_and_mark_in_progress_merge_commit_sha).twice.and_call_original

        merge_request.update!(squash: true)

        expect { service.execute(merge_request) }
          .to change { merge_request.squash_commit_sha }
                .from(nil)

        expect(merge_request.merge_commit_sha).to be_nil
        expect(merge_request.merged_commit_sha).to eq merge_request.squash_commit_sha
        expect(merge_request.in_progress_merge_commit_sha).to be_nil
      end
    end

    context 'running the service once' do
      let(:ref) { merge_request.to_reference(full: true) }
      let(:jid) { SecureRandom.hex }

      let(:messages) do
        [
          /#{ref} - Git merge started on JID #{jid}/,
          /#{ref} - Git merge finished on JID #{jid}/,
          /#{ref} - Post merge started on JID #{jid}/,
          /#{ref} - Post merge finished on JID #{jid}/,
          /#{ref} - Merge process finished on JID #{jid}/
        ]
      end

      before do
        merge_request.update!(merge_jid: jid)
        ::Gitlab::ApplicationContext.push(caller_id: 'MergeWorker')
      end

      it 'logs status messages' do
        allow(Gitlab::AppLogger).to receive(:info).and_call_original

        messages.each do |message|
          expect(Gitlab::AppLogger).to receive(:info).with(
            hash_including(
              'meta.caller_id' => 'MergeWorker',
              message: message,
              merge_request_info: ref
            )
          ).and_call_original
        end

        service.execute(merge_request)
      end
    end

    context 'running the service multiple time' do
      it 'is idempotent' do
        2.times { service.execute(merge_request) }

        expect(merge_request.merge_error).to be_falsey
        expect(merge_request).to be_valid
        expect(merge_request).to be_merged

        commit_messages = project.repository.commits('master', limit: 2).map(&:message)
        expect(commit_messages.uniq.size).to eq(2)
        expect(merge_request.in_progress_merge_commit_sha).to be_nil
      end
    end

    context 'when an invalid sha is passed' do
      let(:merge_request) do
        create(
          :merge_request,
          :simple,
          author: user2,
          assignees: [user2],
          squash: true,
          source_branch: 'improve/awesome',
          target_branch: 'fix'
        )
      end

      let(:merge_params) do
        { sha: merge_request.commits.second.sha }
      end

      it 'does not merge the MR' do
        service.execute(merge_request)

        expect(merge_request).not_to be_merged
        expect(merge_request.merge_error).to match(/Branch has been updated/)
      end
    end

    context 'when the `sha` param is missing' do
      let(:merge_params) { {} }

      it 'returns the error' do
        merge_error = 'Branch has been updated since the merge was requested. '\
                      'Please review the changes.'

        expect { service.execute(merge_request) }
          .to change { merge_request.merge_error }
                .from(nil).to(merge_error)
      end
    end

    context 'closes related issues' do
      before do
        allow(project).to receive(:default_branch).and_return(merge_request.target_branch)
      end

      it 'closes GitLab issue tracker issues', :sidekiq_inline do
        issue  = create :issue, project: project
        commit = double('commit', safe_message: ""Fixes #{issue.to_reference}"", date: Time.current, authored_date: Time.current)
        allow(merge_request).to receive(:commits).and_return([commit])
        merge_request.cache_merge_request_closes_issues!

        service.execute(merge_request)

        expect(issue.reload.closed?).to be_truthy
      end

      context 'with Jira integration' do
        include JiraIntegrationHelpers

        let(:jira_tracker) { project.create_jira_integration }
        let(:jira_issue)   { ExternalIssue.new('JIRA-123', project) }
        let(:commit)       { double('commit', safe_message: ""Fixes #{jira_issue.to_reference}"") }

        before do
          stub_jira_integration_test
          project.update!(has_external_issue_tracker: true)
          jira_integration_settings
          stub_jira_urls(jira_issue.id)
          allow(merge_request).to receive(:commits).and_return([commit])
        end

        it 'closes issues on Jira issue tracker' do
          jira_issue = ExternalIssue.new('JIRA-123', project)
          stub_jira_urls(jira_issue)
          commit = double('commit', safe_message: ""Fixes #{jira_issue.to_reference}"")
          allow(merge_request).to receive(:commits).and_return([commit])

          expect_any_instance_of(Integrations::Jira).to receive(:close_issue).with(merge_request, jira_issue, user).once

          service.execute(merge_request)
        end

        context 'wrong issue markdown' do
          it 'does not close issues on Jira issue tracker' do
            jira_issue = ExternalIssue.new('#JIRA-123', project)
            stub_jira_urls(jira_issue)
            commit = double('commit', safe_message: ""Fixes #{jira_issue.to_reference}"")
            allow(merge_request).to receive(:commits).and_return([commit])

            expect_any_instance_of(Integrations::Jira).not_to receive(:close_issue)

            service.execute(merge_request)
          end
        end
      end
    end

    context 'closes related todos' do
      let(:merge_request) { create(:merge_request, assignees: [user], author: user) }
      let(:project) { merge_request.project }

      let!(:todo) do
        create(:todo, :assigned,
          project: project,
          author: user,
          user: user,
          target: merge_request)
      end

      before do
        allow(service).to receive(:execute_hooks)

        perform_enqueued_jobs do
          service.execute(merge_request)
          todo.reload
        end
      end

      it { expect(todo).to be_done }
    end

    context 'source branch removal' do
      context 'when the source branch is protected' do
        let(:service) do
          described_class.new(project: project, current_user: user, params: merge_params.merge('should_remove_source_branch' => true))
        end

        before do
          create(:protected_branch, project: project, name: merge_request.source_branch)
        end

        it 'does not delete the source branch' do
          expect(::Branches::DeleteService).not_to receive(:new)

          service.execute(merge_request)
        end
      end

      context 'when the source branch is the default branch' do
        let(:service) do
          described_class.new(project: project, current_user: user, params: merge_params.merge('should_remove_source_branch' => true))
        end

        before do
          allow(project).to receive(:root_ref?).with(merge_request.source_branch).and_return(true)
        end

        it 'does not delete the source branch' do
          expect(::Branches::DeleteService).not_to receive(:new)
          service.execute(merge_request)
        end
      end

      context 'when the source branch can be removed' do
        context 'when MR author set the source branch to be removed' do
          before do
            merge_request.update_attribute(:merge_params, { 'force_remove_source_branch' => '1' })
          end

          # Not a real use case. When a merger merges a MR , merge param 'should_remove_source_branch' is defined
          it 'removes the source branch using the author user' do
            expect(::MergeRequests::DeleteSourceBranchWorker).to receive(:perform_async).with(merge_request.id, merge_request.source_branch_sha, merge_request.author.id)

            service.execute(merge_request)

            expect(merge_request.reload.should_remove_source_branch?).to be nil
          end

          context 'when the merger set the source branch not to be removed' do
            let(:service) { described_class.new(project: project, current_user: user, params: merge_params.merge('should_remove_source_branch' => false)) }

            it 'does not delete the source branch' do
              expect(::MergeRequests::DeleteSourceBranchWorker).not_to receive(:perform_async)

              service.execute(merge_request)

              expect(merge_request.reload.should_remove_source_branch?).to be false
            end
          end
        end

        context 'when MR merger set the source branch to be removed' do
          let(:service) do
            described_class.new(project: project, current_user: user, params: merge_params.merge('should_remove_source_branch' => true))
          end

          it 'removes the source branch using the current user' do
            expect(::MergeRequests::DeleteSourceBranchWorker).to receive(:perform_async).with(merge_request.id, merge_request.source_branch_sha, user.id)

            service.execute(merge_request)

            expect(merge_request.reload.should_remove_source_branch?).to be true
          end
        end
      end
    end

    context 'error handling' do
      before do
        allow(Gitlab::AppLogger).to receive(:error)
      end

      context 'when source is missing' do
        it 'logs and saves error' do
          allow(merge_request).to receive(:diff_head_sha) { nil }

          error_message = 'No source for merge'

          service.execute(merge_request)

          expect(merge_request.merge_error).to eq(error_message)
          expect(Gitlab::AppLogger).to have_received(:error).with(
            hash_including(
              merge_request_info: merge_request.to_reference(full: true),
              message: a_string_matching(error_message)
            )
          )
        end
      end

      it 'logs and saves error if there is an exception' do
        error_message = 'error message'

        allow_next_instance_of(MergeRequests::MergeStrategies::FromSourceBranch) do |strategy|
          allow(strategy).to receive(:execute_git_merge!).and_raise(error_message)
        end

        service.execute(merge_request)

        expect(merge_request.merge_error).to eq(described_class::GENERIC_ERROR_MESSAGE)
        expect(Gitlab::AppLogger).to have_received(:error).with(
          hash_including(
            merge_request_info: merge_request.to_reference(full: true),
            message: a_string_matching(error_message)
          )
        )
      end

      it 'logs and saves error if user is not authorized' do
        stub_exclusive_lease

        unauthorized_user = create(:user)
        project.add_reporter(unauthorized_user)

        service = described_class.new(project: project, current_user: unauthorized_user)

        service.execute(merge_request)

        expect(merge_request.merge_error)
          .to eq('You are not allowed to merge this merge request')
      end

      it 'logs and saves error if there is an PreReceiveError exception' do
        error_message = 'error message'

        allow_next_instance_of(MergeRequests::MergeStrategies::FromSourceBranch) do |strategy|
          allow(strategy).to receive(:execute_git_merge!).and_raise(Gitlab::Git::PreReceiveError, ""GitLab: #{error_message}"")
        end

        service.execute(merge_request)

        expect(merge_request.merge_error).to include('Something went wrong during merge pre-receive hook')
        expect(Gitlab::AppLogger).to have_received(:error).with(
          hash_including(
            merge_request_info: merge_request.to_reference(full: true),
            message: a_string_matching(error_message)
          )
        )
      end

      it 'logs and saves error if commit is not created' do
        allow_any_instance_of(Repository).to receive(:merge).and_return(false)
        allow(service).to receive(:execute_hooks)

        service.execute(merge_request)

        expect(merge_request).to be_open
        expect(merge_request.merge_commit_sha).to be_nil
        expect(merge_request.merge_error).to include(described_class::GENERIC_ERROR_MESSAGE)
        expect(Gitlab::AppLogger).to have_received(:error).with(
          hash_including(
            merge_request_info: merge_request.to_reference(full: true),
            message: a_string_matching(described_class::GENERIC_ERROR_MESSAGE)
          )
        )
      end

      context 'when squashing is required' do
        before do
          merge_request.update!(source_branch: 'master', target_branch: 'feature')
          merge_request.target_project.project_setting.squash_always!
        end

        it 'raises an error if squashing is not done' do
          error_message = 'requires squashing commits'

          service.execute(merge_request)

          expect(merge_request).to be_open

          expect(merge_request.merge_commit_sha).to be_nil
          expect(merge_request.squash_commit_sha).to be_nil
          expect(merge_request.merge_error).to include(error_message)
          expect(Gitlab::AppLogger).to have_received(:error).with(
            hash_including(
              merge_request_info: merge_request.to_reference(full: true),
              message: a_string_matching(error_message)
            )
          )
        end
      end

      context 'when squashing' do
        before do
          merge_request.update!(source_branch: 'master', target_branch: 'feature')
        end

        it 'logs and saves error if there is an error when squashing' do
          error_message = 'Squashing failed: Squash the commits locally, resolve any conflicts, then push the branch.'

          allow_any_instance_of(MergeRequests::SquashService).to receive(:squash!).and_return(nil)
          merge_request.update!(squash: true)

          service.execute(merge_request)

          expect(merge_request).to be_open
          expect(merge_request.merge_commit_sha).to be_nil
          expect(merge_request.squash_commit_sha).to be_nil
          expect(merge_request.merge_error).to include(error_message)
          expect(Gitlab::AppLogger).to have_received(:error).with(
            hash_including(
              merge_request_info: merge_request.to_reference(full: true),
              message: a_string_matching(error_message)
            )
          )
        end

        it 'logs and saves error if there is an PreReceiveError exception' do
          error_message = 'error message'

          allow_next_instance_of(MergeRequests::MergeStrategies::FromSourceBranch) do |strategy|
            allow(strategy).to receive(:execute_git_merge!).and_raise(Gitlab::Git::PreReceiveError, ""GitLab: #{error_message}"")
          end
          merge_request.update!(squash: true)

          service.execute(merge_request)

          expect(merge_request).to be_open
          expect(merge_request.merge_commit_sha).to be_nil
          expect(merge_request.squash_commit_sha).to be_nil
          expect(merge_request.merge_error).to include('Something went wrong during merge pre-receive hook')
          expect(Gitlab::AppLogger).to have_received(:error).with(
            hash_including(
              merge_request_info: merge_request.to_reference(full: true),
              message: a_string_matching(error_message)
            )
          )
        end

        context 'when fast-forward merge is not allowed' do
          before do
            allow_any_instance_of(Repository).to receive(:ancestor?).and_return(nil)
          end

          %w[semi-linear ff].each do |merge_method|
            it ""logs and saves error if merge is #{merge_method} only"" do
              merge_method = 'rebase_merge' if merge_method == 'semi-linear'
              merge_request.project.update!(merge_method: merge_method)
              error_message = 'Only fast-forward merge is allowed for your project. Please update your source branch'
              allow(service).to receive(:execute_hooks)
              expect(lease).to receive(:cancel)

              service.execute(merge_request)

              expect(merge_request).to be_open
              expect(merge_request.merge_commit_sha).to be_nil
              expect(merge_request.squash_commit_sha).to be_nil
              expect(merge_request.merge_error).to include(error_message)
              expect(Gitlab::AppLogger).to have_received(:error).with(
                hash_including(
                  merge_request_info: merge_request.to_reference(full: true),
                  message: a_string_matching(error_message)
                )
              )
            end
          end
        end
      end

      context 'when not mergeable' do
        let!(:error_message) { 'Merge request is not mergeable' }

        context 'with failing CI' do
          before do
            allow(merge_request.project).to receive(:only_allow_merge_if_pipeline_succeeds) { true }
            allow(merge_request).to receive(:mergeable_ci_state?) { false }
          end

          it 'logs and saves error' do
            service.execute(merge_request)

            expect(Gitlab::AppLogger).to have_received(:error).with(
              hash_including(
                merge_request_info: merge_request.to_reference(full: true),
                message: a_string_matching(error_message)
              )
            )
          end
        end

        context 'with unresolved discussions' do
          before do
            allow(merge_request.project).to receive(:only_allow_merge_if_all_discussions_are_resolved) { true }
            allow(merge_request).to receive(:mergeable_discussions_state?) { false }
          end

          it 'logs and saves error' do
            service.execute(merge_request)

            expect(Gitlab::AppLogger).to have_received(:error).with(
              hash_including(
                merge_request_info: merge_request.to_reference(full: true),
                message: a_string_matching(error_message)
              )
            )
          end

          context 'when passing `skip_discussions_check: true` as `options` parameter' do
            it 'merges the merge request' do
              service.execute(merge_request, skip_discussions_check: true)

              expect(merge_request).to be_valid
              expect(merge_request).to be_merged
            end
          end
        end
      end

      context 'when passing `check_mergeability_retry_lease: true` as `options` parameter' do
        it 'call mergeable? with check_mergeability_retry_lease' do
          expect(merge_request).to receive(:mergeable?).with(hash_including(check_mergeability_retry_lease: true)).and_call_original

          service.execute(merge_request, check_mergeability_retry_lease: true)
        end
      end
    end

    context 'when the other sidekiq worker has already been running' do
      before do
        stub_exclusive_lease_taken(lease_key)
      end

      it 'does not execute service' do
        expect(service).not_to receive(:commit)

        service.execute(merge_request)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
  module Mergeability
    class RunChecksService
      include Gitlab::Utils::StrongMemoize

      def initialize(merge_request:, params:)
        @merge_request = merge_request
        @params = params
      end

      def execute(checks, execute_all: false)
        @results = checks.each_with_object([]) do |check_class, result_hash|
          check = check_class.new(merge_request: merge_request, params: params)

          next if check.skip?

          check_result = logger.instrument(mergeability_name: check_class.to_s.demodulize.underscore) do
            run_check(check)
          end

          result_hash << check_result

          break result_hash if check_result.failed? && !execute_all
        end

        logger.commit

        return ServiceResponse.success(payload: { results: results }) if all_results_success?

        ServiceResponse.error(
          message: 'Checks failed.',
          payload: {
            results: results,
            failed_check: failed_check
          }
        )
      end

      private

      attr_reader :merge_request, :params, :results

      def run_check(check)
        return check.execute unless check.cacheable?

        cached_result = cached_results.read(merge_check: check)
        return cached_result if cached_result.respond_to?(:status)

        check.execute.tap do |result|
          cached_results.write(merge_check: check, result_hash: result.to_hash)
        end
      end

      def cached_results
        strong_memoize(:cached_results) do
          Gitlab::MergeRequests::Mergeability::ResultsStore.new(merge_request: merge_request)
        end
      end

      def logger
        strong_memoize(:logger) do
          MergeRequests::Mergeability::Logger.new(merge_request: merge_request)
        end
      end

      def all_results_success?
        results.none?(&:failed?)
      end

      def failed_check
        # NOTE: the identifier could be string when we retrieve it from the cache
        # so let's make sure we always return symbols here.
        results.find(&:failed?)&.payload&.fetch(:identifier)&.to_sym
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::Mergeability::RunChecksService, :clean_gitlab_redis_cache, feature_category: :code_review_workflow do
  let(:checks) { MergeRequest.all_mergeability_checks }
  let(:execute_all) { false }

  subject(:run_checks) { described_class.new(merge_request: merge_request, params: {}) }

  describe '#execute' do
    subject(:execute) { run_checks.execute(checks, execute_all: execute_all) }

    let_it_be(:merge_request) { create(:merge_request) }

    let(:params) { {} }
    let(:success_result) { Gitlab::MergeRequests::Mergeability::CheckResult.success }

    shared_examples 'checks are all executed' do
      context 'when all checks are set to be executed' do
        let(:execute_all) { true }

        specify do
          result = execute

          expect(result.success?).to eq(success?)
          expect(result.payload[:results].count).to eq(expected_count)
        end
      end
    end

    context 'when every check is skipped', :eager_load do
      before do
        MergeRequests::Mergeability::CheckBaseService.subclasses.each do |subclass|
          allow_next_instance_of(subclass) do |service|
            allow(service).to receive(:skip?).and_return(true)
          end
        end
      end

      it 'is still a success' do
        expect(execute.success?).to eq(true)
      end

      it_behaves_like 'checks are all executed' do
        let(:success?) { true }
        let(:expected_count) { 0 }
      end
    end

    context 'when a check is skipped' do
      before do
        checks.each do |check|
          allow_next_instance_of(check) do |service|
            allow(service).to receive(:skip?).and_return(false)
            allow(service).to receive(:execute).and_return(success_result)
          end
        end

        allow_next_instance_of(MergeRequests::Mergeability::CheckCiStatusService) do |service|
          allow(service).to receive(:skip?).and_return(true)
        end
      end

      it 'does not execute the check' do
        expect_next_instance_of(MergeRequests::Mergeability::CheckCiStatusService) do |service|
          expect(service).to receive(:skip?).and_return(true)
          expect(service).not_to receive(:execute)
        end

        expect(execute.success?).to eq(true)
      end

      it_behaves_like 'checks are all executed' do
        let(:success?) { true }
        let(:expected_count) { checks.count - 1 }
      end

      context 'when one check fails' do
        let(:failed_result) { Gitlab::MergeRequests::Mergeability::CheckResult.failed(payload: { identifier: 'failed' }) }

        before do
          allow_next_instance_of(MergeRequests::Mergeability::CheckOpenStatusService) do |service|
            allow(service).to receive(:skip?).and_return(false)
            allow(service).to receive(:execute).and_return(failed_result)
          end
        end

        it 'returns the failed check' do
          result = execute

          expect(result.success?).to eq(false)
          expect(execute.payload[:failed_check]).to eq(:failed)
        end

        it_behaves_like 'checks are all executed' do
          let(:success?) { false }
          let(:expected_count) { checks.count - 1 }
        end
      end

      context 'when one check is inactive' do
        let(:inactive_result) { Gitlab::MergeRequests::Mergeability::CheckResult.inactive }

        before do
          allow_next_instance_of(MergeRequests::Mergeability::CheckOpenStatusService) do |service|
            allow(service).to receive(:skip?).and_return(false)
            allow(service).to receive(:execute).and_return(inactive_result)
          end
        end

        it 'is still a success' do
          expect(execute.success?).to eq(true)
        end

        it_behaves_like 'checks are all executed' do
          let(:success?) { true }
          let(:expected_count) { checks.count - 1 }
        end
      end
    end

    context 'when a check is not skipped' do
      let(:cacheable) { true }
      let(:merge_check) { instance_double(MergeRequests::Mergeability::CheckCiStatusService) }

      before do
        checks.each do |check|
          allow_next_instance_of(check) do |service|
            allow(service).to receive(:skip?).and_return(true)
          end
        end

        expect(MergeRequests::Mergeability::CheckCiStatusService).to receive(:new).and_return(merge_check)
        expect(merge_check).to receive(:skip?).and_return(false)
        allow(merge_check).to receive(:cacheable?).and_return(cacheable)
        allow(merge_check).to receive(:execute).and_return(success_result)
      end

      context 'when the check is cacheable' do
        context 'when the check is cached' do
          before do
            expect_next_instance_of(Gitlab::MergeRequests::Mergeability::ResultsStore) do |service|
              expect(service).to receive(:read).with(merge_check: merge_check).and_return(success_result)
            end
          end

          it 'returns the cached result' do
            expect_next_instance_of(MergeRequests::Mergeability::Logger, merge_request: merge_request) do |logger|
              expect(logger).to receive(:instrument).with(mergeability_name: 'check_ci_status_service').and_call_original
              expect(logger).to receive(:commit)
            end

            expect(execute.success?).to eq(true)
          end

          it_behaves_like 'checks are all executed' do
            let(:success?) { true }
            let(:expected_count) { 1 }
          end
        end

        context 'when the check is not cached' do
          before do
            expect_next_instance_of(Gitlab::MergeRequests::Mergeability::ResultsStore) do |service|
              expect(service).to receive(:read).with(merge_check: merge_check).and_return(nil)
              expect(service).to receive(:write).with(merge_check: merge_check, result_hash: success_result.to_hash).and_return(true)
            end
          end

          it 'writes and returns the result' do
            expect_next_instance_of(MergeRequests::Mergeability::Logger, merge_request: merge_request) do |logger|
              expect(logger).to receive(:instrument).with(mergeability_name: 'check_ci_status_service').and_call_original
              expect(logger).to receive(:commit)
            end

            expect(execute.success?).to eq(true)
          end

          it_behaves_like 'checks are all executed' do
            let(:success?) { true }
            let(:expected_count) { 1 }
          end
        end
      end

      context 'when check is not cacheable' do
        let(:cacheable) { false }

        it 'does not call the results store' do
          expect(Gitlab::MergeRequests::Mergeability::ResultsStore).not_to receive(:new)

          expect(execute.success?).to eq(true)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  module Mergeability
    class DetailedMergeStatusService
      include ::Gitlab::Utils::StrongMemoize

      def initialize(merge_request:)
        @merge_request = merge_request
      end

      def execute
        return :preparing if preparing?
        return :checking if checking?
        return :unchecked if unchecked?

        if check_results.success?

          # If everything else is mergeable, but CI is not, the frontend expects two potential states to be returned
          # See discussion: gitlab.com/gitlab-org/gitlab/-/merge_requests/96778#note_1093063523
          if check_ci_results.failed?
            ci_check_failed_check
          else
            :mergeable
          end
        else
          check_results.payload[:failed_check]
        end
      end

      private

      attr_reader :merge_request, :checks, :ci_check

      def preparing?
        merge_request.preparing? && !merge_request.merge_request_diff.persisted?
      end

      def checking?
        merge_request.cannot_be_merged_rechecking? || merge_request.checking?
      end

      def unchecked?
        merge_request.unchecked?
      end

      def check_results
        strong_memoize(:check_results) do
          merge_request
            .execute_merge_checks(
              MergeRequest.mergeable_state_checks,
              params: { skip_ci_check: true }
            )
        end
      end

      def check_ci_results
        strong_memoize(:check_ci_results) do
          ::MergeRequests::Mergeability::CheckCiStatusService.new(merge_request: merge_request, params: {}).execute
        end
      end

      def ci_check_failed_check
        if merge_request.actual_head_pipeline&.active?
          :ci_still_running
        else
          check_ci_results.payload.fetch(:identifier)
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::MergeRequests::Mergeability::DetailedMergeStatusService, feature_category: :code_review_workflow do
  subject(:detailed_merge_status) { described_class.new(merge_request: merge_request).execute }

  context 'when merge status is cannot_be_merged_rechecking' do
    let(:merge_request) { create(:merge_request, merge_status: :cannot_be_merged_rechecking) }

    it 'returns :checking' do
      expect(detailed_merge_status).to eq(:checking)
    end
  end

  context 'when merge status is preparing' do
    let(:merge_request) { create(:merge_request, merge_status: :preparing) }

    it 'returns :checking' do
      allow(merge_request.merge_request_diff).to receive(:persisted?).and_return(false)

      expect(detailed_merge_status).to eq(:preparing)
    end
  end

  context 'when merge status is preparing and merge request diff is persisted' do
    let(:merge_request) { create(:merge_request, merge_status: :preparing) }

    it 'returns :checking' do
      allow(merge_request.merge_request_diff).to receive(:persisted?).and_return(true)

      expect(detailed_merge_status).to eq(:mergeable)
    end
  end

  context 'when merge status is checking' do
    let(:merge_request) { create(:merge_request, merge_status: :checking) }

    it 'returns :checking' do
      expect(detailed_merge_status).to eq(:checking)
    end
  end

  context 'when merge status is unchecked' do
    let(:merge_request) { create(:merge_request, merge_status: :unchecked) }

    it 'returns :unchecked' do
      expect(detailed_merge_status).to eq(:unchecked)
    end
  end

  context 'when merge checks are a success' do
    let(:merge_request) { create(:merge_request) }

    it 'returns :mergeable' do
      expect(detailed_merge_status).to eq(:mergeable)
    end
  end

  context 'when merge status have a failure' do
    let(:merge_request) { create(:merge_request) }

    before do
      merge_request.close!
    end

    it 'returns the failed check' do
      expect(detailed_merge_status).to eq(:not_open)
    end
  end

  context 'when all but the ci check fails' do
    let(:merge_request) { create(:merge_request) }

    before do
      merge_request.project.update!(only_allow_merge_if_pipeline_succeeds: true)
    end

    context 'when pipeline does not exist' do
      it 'returns the failed check' do
        expect(detailed_merge_status).to eq(:ci_must_pass)
      end
    end

    context 'when pipeline exists' do
      before do
        create(
          :ci_pipeline,
          ci_status,
          merge_request: merge_request,
          project: merge_request.project,
          sha: merge_request.source_branch_sha,
          head_pipeline_of: merge_request
        )
      end

      context 'when the pipeline is running' do
        let(:ci_status) { :running }

        it 'returns the failed check' do
          expect(detailed_merge_status).to eq(:ci_still_running)
        end
      end

      context 'when the pipeline is pending' do
        let(:ci_status) { :pending }

        it { expect(detailed_merge_status).to eq(:ci_still_running) }
      end

      context 'when the pipeline is not running' do
        let(:ci_status) { :failed }

        it 'returns the failed check' do
          expect(detailed_merge_status).to eq(:ci_must_pass)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  module Mergeability
    class CheckDraftStatusService < CheckBaseService
      identifier :draft_status
      description 'Checks whether the merge request is draft'

      def execute
        if merge_request.draft?
          failure
        else
          success
        end
      end

      def skip?
        params[:skip_draft_check].present?
      end

      def cacheable?
        false
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::Mergeability::CheckDraftStatusService, feature_category: :code_review_workflow do
  subject(:check_draft_status) { described_class.new(merge_request: merge_request, params: params) }

  let_it_be(:merge_request) { build(:merge_request) }

  let(:params) { { skip_draft_check: skip_check } }
  let(:skip_check) { false }

  it_behaves_like 'mergeability check service', :draft_status, 'Checks whether the merge request is draft'

  describe '#execute' do
    let(:result) { check_draft_status.execute }

    before do
      expect(merge_request).to receive(:draft?).and_return(draft)
    end

    context 'when the merge request is a draft' do
      let(:draft) { true }

      it 'returns a check result with status failed' do
        expect(result.status).to eq Gitlab::MergeRequests::Mergeability::CheckResult::FAILED_STATUS
        expect(result.payload[:identifier]).to eq(:draft_status)
      end
    end

    context 'when the merge request is not a draft' do
      let(:draft) { false }

      it 'returns a check result with status success' do
        expect(result.status).to eq Gitlab::MergeRequests::Mergeability::CheckResult::SUCCESS_STATUS
      end
    end
  end

  describe '#skip?' do
    context 'when skip check param is true' do
      let(:skip_check) { true }

      it 'returns true' do
        expect(check_draft_status.skip?).to eq true
      end
    end

    context 'when skip check param is false' do
      let(:skip_check) { false }

      it 'returns false' do
        expect(check_draft_status.skip?).to eq false
      end
    end
  end

  describe '#cacheable?' do
    it 'returns false' do
      expect(check_draft_status.cacheable?).to eq false
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  module Mergeability
    class CheckRebaseStatusService < CheckBaseService
      identifier :need_rebase
      description 'Checks whether the merge request needs to be rebased'

      def execute
        return inactive unless merge_request.project.ff_merge_must_be_possible?

        if merge_request.should_be_rebased?
          failure
        else
          success
        end
      end

      def skip?
        params[:skip_rebase_check].present?
      end

      def cacheable?
        false
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::Mergeability::CheckRebaseStatusService, feature_category: :code_review_workflow do
  subject(:check_rebase_status) { described_class.new(merge_request: merge_request, params: params) }

  let_it_be(:project) { build(:project) }
  let_it_be(:merge_request) { build(:merge_request, source_project: project) }
  let(:params) { { skip_rebase_check: skip_check } }
  let(:skip_check) { false }

  it_behaves_like 'mergeability check service', :need_rebase, 'Checks whether the merge request needs to be rebased'

  describe '#execute' do
    let(:result) { check_rebase_status.execute }

    before do
      allow(project)
        .to receive(:ff_merge_must_be_possible?)
        .and_return(ff_merge_must_be_possible?)
    end

    context 'when ff_merge_must_be_possible is true' do
      let(:ff_merge_must_be_possible?) { true }

      before do
        allow(merge_request).to receive(:should_be_rebased?).and_return(should_be_rebased)
      end

      context 'when the merge request should be rebased' do
        let(:should_be_rebased) { true }

        it 'returns a check result with status failed' do
          expect(result.status).to eq Gitlab::MergeRequests::Mergeability::CheckResult::FAILED_STATUS
          expect(result.payload[:identifier]).to eq(:need_rebase)
        end
      end

      context 'when the merge request should not be rebased' do
        let(:should_be_rebased) { false }

        it 'returns a check result with status success' do
          expect(result.status).to eq Gitlab::MergeRequests::Mergeability::CheckResult::SUCCESS_STATUS
        end
      end
    end

    context 'when ff_merge_must_be_possible is false' do
      let(:ff_merge_must_be_possible?) { false }

      it 'returns a check result with inactive status' do
        expect(result.status).to eq Gitlab::MergeRequests::Mergeability::CheckResult::INACTIVE_STATUS
      end
    end
  end

  describe '#skip?' do
    context 'when skip check is true' do
      let(:skip_check) { true }

      it 'returns true' do
        expect(check_rebase_status.skip?).to eq true
      end
    end

    context 'when skip check is false' do
      let(:skip_check) { false }

      it 'returns false' do
        expect(check_rebase_status.skip?).to eq false
      end
    end
  end

  describe '#cacheable?' do
    it 'returns false' do
      expect(check_rebase_status.cacheable?).to eq false
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  module Mergeability
    class Logger
      include Gitlab::Utils::StrongMemoize

      def initialize(merge_request:, destination: Gitlab::AppJsonLogger)
        @destination = destination
        @merge_request = merge_request
      end

      def commit
        commit_logs
      end

      def instrument(mergeability_name:)
        raise ArgumentError, 'block not given' unless block_given?

        op_start_db_counters = current_db_counter_payload
        op_started_at = current_monotonic_time

        result = yield

        observe_result(mergeability_name, result)
        observe(""mergeability.#{mergeability_name}.duration_s"", current_monotonic_time - op_started_at)
        observe_sql_counters(mergeability_name, op_start_db_counters, current_db_counter_payload)

        result
      end

      private

      attr_reader :destination, :merge_request, :stored_result

      def observe_result(name, result)
        return unless result.respond_to?(:success?)

        observe(""mergeability.#{name}.successful"", result.success?)
      end

      def observe(name, value)
        observations[name.to_s].push(value)
      end

      def commit_logs
        attributes = Gitlab::ApplicationContext.current.merge({ mergeability_project_id: merge_request.project.id })

        attributes[:mergeability_merge_request_id] = merge_request.id
        attributes.merge!(observations_hash)
        attributes.compact!
        attributes.stringify_keys!

        destination.info(attributes)
      end

      def observations_hash
        transformed = observations.transform_values do |values|
          next if values.empty?

          {
            'values' => values
          }
        end.compact

        transformed.each_with_object({}) do |key, hash|
          key[1].each { |k, v| hash[""#{key[0]}.#{k}""] = v }
        end
      end

      def observations
        strong_memoize(:observations) do
          Hash.new { |hash, key| hash[key] = [] }
        end
      end

      def observe_sql_counters(name, start_db_counters, end_db_counters)
        end_db_counters.each do |key, value|
          result = value - start_db_counters.fetch(key, 0)
          next if result == 0

          observe(""mergeability.#{name}.#{key}"", result)
        end
      end

      def current_db_counter_payload
        ::Gitlab::Metrics::Subscribers::ActiveRecord.db_counter_payload
      end

      def current_monotonic_time
        ::Gitlab::Metrics::System.monotonic_time
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::Mergeability::Logger, :request_store, feature_category: :code_review_workflow do
  let_it_be(:merge_request) { create(:merge_request) }

  subject(:logger) { described_class.new(merge_request: merge_request) }

  let(:caller_id) { 'a' }

  before do
    allow(Gitlab::ApplicationContext).to receive(:current_context_attribute).with(:caller_id).and_return(caller_id)
  end

  def loggable_data(**extras)
    {
      'mergeability.expensive_operation.duration_s.values' => a_kind_of(Array),
      ""mergeability_merge_request_id"" => merge_request.id,
      ""correlation_id"" => a_kind_of(String),
      ""mergeability_project_id"" => merge_request.project.id
    }.merge(extras)
  end

  describe '#instrument' do
    let(:operation_count) { 1 }

    context 'when enabled' do
      it ""returns the block's value"" do
        expect(logger.instrument(mergeability_name: :expensive_operation) { 123 }).to eq(123)
      end

      it 'records durations of instrumented operations' do
        expect_next_instance_of(Gitlab::AppJsonLogger) do |app_logger|
          expect(app_logger).to receive(:info).with(match(a_hash_including(loggable_data)))
        end

        expect(logger.instrument(mergeability_name: :expensive_operation) { 123 }).to eq(123)

        logger.commit
      end

      context 'when block value responds to #success?' do
        let(:success?) { true }
        let(:check_result) { instance_double(Gitlab::MergeRequests::Mergeability::CheckResult, success?: success?) }

        let(:extra_data) do
          {
            'mergeability.expensive_operation.successful.values' => [success?]
          }
        end

        shared_examples_for 'success state logger' do
          it 'records operation success state' do
            expect_next_instance_of(Gitlab::AppJsonLogger) do |app_logger|
              expect(app_logger).to receive(:info).with(match(a_hash_including(loggable_data(**extra_data))))
            end

            expect(logger.instrument(mergeability_name: :expensive_operation) { check_result }).to eq(check_result)

            logger.commit
          end
        end

        it_behaves_like 'success state logger'

        context 'when not successful' do
          let(:success?) { false }

          it_behaves_like 'success state logger'
        end
      end

      context 'with multiple observations' do
        let(:operation_count) { 2 }

        it 'records durations of instrumented operations' do
          expect_next_instance_of(Gitlab::AppJsonLogger) do |app_logger|
            expect(app_logger).to receive(:info).with(match(a_hash_including(loggable_data)))
          end

          2.times do
            expect(logger.instrument(mergeability_name: :expensive_operation) { 123 }).to eq(123)
          end

          logger.commit
        end
      end

      context 'when its a query' do
        let(:extra_data) do
          {
            'mergeability.expensive_operation.db_count.values' => a_kind_of(Array),
            'mergeability.expensive_operation.db_main_count.values' => a_kind_of(Array),
            'mergeability.expensive_operation.db_main_duration_s.values' => a_kind_of(Array),
            'mergeability.expensive_operation.db_primary_count.values' => a_kind_of(Array),
            'mergeability.expensive_operation.db_primary_duration_s.values' => a_kind_of(Array)
          }
        end

        context 'with a single query' do
          it 'includes SQL metrics' do
            expect_next_instance_of(Gitlab::AppJsonLogger) do |app_logger|
              expect(app_logger).to receive(:info).with(match(a_hash_including(loggable_data(**extra_data))))
            end

            expect(logger.instrument(mergeability_name: :expensive_operation) { MergeRequest.count }).to eq(1)

            logger.commit
          end
        end

        context 'with multiple queries' do
          it 'includes SQL metrics' do
            expect_next_instance_of(Gitlab::AppJsonLogger) do |app_logger|
              expect(app_logger).to receive(:info).with(match(a_hash_including(loggable_data(**extra_data))))
            end

            expect(logger.instrument(mergeability_name: :expensive_operation) { Project.count + MergeRequest.count })
              .to eq(2)

            logger.commit
          end
        end
      end
    end

    it 'raises an error when block is not provided' do
      expect { logger.instrument(mergeability_name: :expensive_operation) }
        .to raise_error(ArgumentError, 'block not given')
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  module Mergeability
    class CheckCiStatusService < CheckBaseService
      identifier :ci_must_pass
      description 'Checks whether CI has passed'

      def execute
        return inactive unless merge_request.only_allow_merge_if_pipeline_succeeds?

        if merge_request.mergeable_ci_state?
          success
        else
          failure
        end
      end

      def skip?
        params[:skip_ci_check].present?
      end

      def cacheable?
        false
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::Mergeability::CheckCiStatusService, feature_category: :code_review_workflow do
  subject(:check_ci_status) { described_class.new(merge_request: merge_request, params: params) }

  let_it_be(:project) { build(:project) }
  let_it_be(:merge_request) { build(:merge_request, source_project: project) }
  let(:params) { { skip_ci_check: skip_check } }
  let(:skip_check) { false }

  it_behaves_like 'mergeability check service', :ci_must_pass, 'Checks whether CI has passed'

  describe '#execute' do
    let(:result) { check_ci_status.execute }

    before do
      allow(merge_request)
        .to receive(:only_allow_merge_if_pipeline_succeeds?)
        .and_return(only_allow_merge_if_pipeline_succeeds?)
    end

    context 'when only_allow_merge_if_pipeline_succeeds is true' do
      let(:only_allow_merge_if_pipeline_succeeds?) { true }

      before do
        expect(merge_request).to receive(:mergeable_ci_state?).and_return(mergeable)
      end

      context 'when the merge request is in a mergeable state' do
        let(:mergeable) { true }

        it 'returns a check result with status success' do
          expect(result.status).to eq Gitlab::MergeRequests::Mergeability::CheckResult::SUCCESS_STATUS
        end
      end

      context 'when the merge request is not in a mergeable state' do
        let(:mergeable) { false }

        it 'returns a check result with status failed' do
          expect(result.status).to eq Gitlab::MergeRequests::Mergeability::CheckResult::FAILED_STATUS
          expect(result.payload[:identifier]).to eq :ci_must_pass
        end
      end
    end

    context 'when only_allow_merge_if_pipeline_succeeds is false' do
      let(:only_allow_merge_if_pipeline_succeeds?) { false }

      it 'returns a check result with inactive status' do
        expect(result.status).to eq Gitlab::MergeRequests::Mergeability::CheckResult::INACTIVE_STATUS
      end
    end
  end

  describe '#skip?' do
    context 'when skip check is true' do
      let(:skip_check) { true }

      it 'returns true' do
        expect(check_ci_status.skip?).to eq true
      end
    end

    context 'when skip check is false' do
      let(:skip_check) { false }

      it 'returns false' do
        expect(check_ci_status.skip?).to eq false
      end
    end
  end

  describe '#cacheable?' do
    it 'returns false' do
      expect(check_ci_status.cacheable?).to eq false
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  module Mergeability
    class CheckOpenStatusService < CheckBaseService
      identifier :not_open
      description 'Checks whether the merge request is open'

      def execute
        if merge_request.open?
          success
        else
          failure
        end
      end

      def skip?
        false
      end

      def cacheable?
        false
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::Mergeability::CheckOpenStatusService, feature_category: :code_review_workflow do
  subject(:check_open_status) { described_class.new(merge_request: merge_request, params: {}) }

  let(:merge_request) { build(:merge_request) }

  it_behaves_like 'mergeability check service', :not_open, 'Checks whether the merge request is open'

  describe '#execute' do
    let(:result) { check_open_status.execute }

    before do
      expect(merge_request).to receive(:open?).and_return(open)
    end

    context 'when the merge request is open' do
      let(:open) { true }

      it 'returns a check result with status success' do
        expect(result.status).to eq Gitlab::MergeRequests::Mergeability::CheckResult::SUCCESS_STATUS
      end
    end

    context 'when the merge request is not open' do
      let(:open) { false }

      it 'returns a check result with status failed' do
        expect(result.status).to eq Gitlab::MergeRequests::Mergeability::CheckResult::FAILED_STATUS
        expect(result.payload[:identifier]).to eq(:not_open)
      end
    end
  end

  describe '#skip?' do
    it 'returns false' do
      expect(check_open_status.skip?).to eq false
    end
  end

  describe '#cacheable?' do
    it 'returns false' do
      expect(check_open_status.cacheable?).to eq false
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
  module Mergeability
    class CheckBrokenStatusService < CheckBaseService
      identifier :broken_status
      description 'Checks whether the merge request is broken'

      def execute
        if merge_request.broken?
          failure
        else
          success
        end
      end

      def skip?
        false
      end

      def cacheable?
        false
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::Mergeability::CheckBrokenStatusService, feature_category: :code_review_workflow do
  subject(:check_broken_status) { described_class.new(merge_request: merge_request, params: {}) }

  let(:merge_request) { build(:merge_request) }

  it_behaves_like 'mergeability check service', :broken_status, 'Checks whether the merge request is broken'

  describe '#execute' do
    let(:result) { check_broken_status.execute }

    before do
      expect(merge_request).to receive(:broken?).and_return(broken)
    end

    context 'when the merge request is broken' do
      let(:broken) { true }

      it 'returns a check result with status failed' do
        expect(result.status).to eq Gitlab::MergeRequests::Mergeability::CheckResult::FAILED_STATUS
        expect(result.payload[:identifier]).to eq(:broken_status)
      end
    end

    context 'when the merge request is not broken' do
      let(:broken) { false }

      it 'returns a check result with status success' do
        expect(result.status).to eq Gitlab::MergeRequests::Mergeability::CheckResult::SUCCESS_STATUS
      end
    end
  end

  describe '#skip?' do
    it 'returns false' do
      expect(check_broken_status.skip?).to eq false
    end
  end

  describe '#cacheable?' do
    it 'returns false' do
      expect(check_broken_status.cacheable?).to eq false
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  module Mergeability
    class CheckConflictStatusService < CheckBaseService
      identifier :conflict
      description 'Checks whether the merge request has a conflict'

      def execute
        if merge_request.can_be_merged?
          success
        else
          failure
        end
      end

      def skip?
        false
      end

      def cacheable?
        false
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::Mergeability::CheckConflictStatusService, feature_category: :code_review_workflow do
  subject(:check_conflict_status) { described_class.new(merge_request: merge_request, params: {}) }

  let(:merge_request) { build(:merge_request) }

  it_behaves_like 'mergeability check service', :conflict, 'Checks whether the merge request has a conflict'

  describe '#execute' do
    let(:result) { check_conflict_status.execute }

    before do
      allow(merge_request).to receive(:can_be_merged?).and_return(can_be_merged)
    end

    context 'when MergeRequest#can_be_merged is true' do
      let(:can_be_merged) { true }

      it 'returns a check result with status success' do
        expect(result.status).to eq Gitlab::MergeRequests::Mergeability::CheckResult::SUCCESS_STATUS
      end
    end

    context 'when MergeRequest#can_be_merged is false' do
      let(:can_be_merged) { false }

      it 'returns a check result with status failed' do
        expect(result.status).to eq Gitlab::MergeRequests::Mergeability::CheckResult::FAILED_STATUS
        expect(result.payload[:identifier]).to eq(:conflict)
      end
    end
  end

  describe '#skip?' do
    it 'returns false' do
      expect(check_conflict_status.skip?).to eq false
    end
  end

  describe '#cacheable?' do
    it 'returns false' do
      expect(check_conflict_status.cacheable?).to eq false
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
  module Mergeability
    class CheckDiscussionsStatusService < CheckBaseService
      identifier :discussions_not_resolved
      description 'Checks whether the merge request has open discussions'

      def execute
        return inactive unless merge_request.only_allow_merge_if_all_discussions_are_resolved?

        if merge_request.mergeable_discussions_state?
          success
        else
          failure
        end
      end

      def skip?
        params[:skip_discussions_check].present?
      end

      def cacheable?
        false
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::Mergeability::CheckDiscussionsStatusService, feature_category: :code_review_workflow do
  subject(:check_discussions_status) { described_class.new(merge_request: merge_request, params: params) }

  let_it_be(:project) { build(:project) }
  let_it_be(:merge_request) { build(:merge_request, source_project: project) }
  let(:params) { { skip_discussions_check: skip_check } }
  let(:skip_check) { false }

  it_behaves_like 'mergeability check service', :discussions_not_resolved,
    'Checks whether the merge request has open discussions'

  describe '#execute' do
    let(:result) { check_discussions_status.execute }

    before do
      allow(merge_request)
        .to receive(:only_allow_merge_if_all_discussions_are_resolved?)
        .and_return(only_allow_merge_if_all_discussions_are_resolved?)
    end

    context 'when only_allow_merge_if_all_discussions_are_resolved is true' do
      let(:only_allow_merge_if_all_discussions_are_resolved?) { true }

      before do
        allow(merge_request).to receive(:mergeable_discussions_state?).and_return(mergeable)
      end

      context 'when the merge request is in a mergable state' do
        let(:mergeable) { true }

        it 'returns a check result with status success' do
          expect(result.status).to eq Gitlab::MergeRequests::Mergeability::CheckResult::SUCCESS_STATUS
        end
      end

      context 'when the merge request is not in a mergeable state' do
        let(:mergeable) { false }

        it 'returns a check result with status failed' do
          expect(result.status).to eq Gitlab::MergeRequests::Mergeability::CheckResult::FAILED_STATUS
          expect(result.payload[:identifier]).to eq(:discussions_not_resolved)
        end
      end
    end

    context 'when only_allow_merge_if_all_discussions_are_resolved is false' do
      let(:only_allow_merge_if_all_discussions_are_resolved?) { false }

      it 'returns a check result with inactive status' do
        expect(result.status).to eq Gitlab::MergeRequests::Mergeability::CheckResult::INACTIVE_STATUS
      end
    end
  end

  describe '#skip?' do
    context 'when skip check is true' do
      let(:skip_check) { true }

      it 'returns true' do
        expect(check_discussions_status.skip?).to eq true
      end
    end

    context 'when skip check is false' do
      let(:skip_check) { false }

      it 'returns false' do
        expect(check_discussions_status.skip?).to eq false
      end
    end
  end

  describe '#cacheable?' do
    it 'returns false' do
      expect(check_discussions_status.cacheable?).to eq false
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module MergeRequests
  module Mergeability
    class CheckBaseService
      attr_reader :merge_request, :params

      class_attribute :identifier, :description

      def self.identifier(new_identifier)
        self.identifier = new_identifier
      end

      def self.description(new_description)
        self.description = new_description
      end

      def initialize(merge_request:, params:)
        @merge_request = merge_request
        @params = params
      end

      def skip?
        raise NotImplementedError
      end

      # When this method is true, we need to implement a cache_key
      def cacheable?
        raise NotImplementedError
      end

      def cache_key
        raise NotImplementedError
      end

      private

      def success(**args)
        Gitlab::MergeRequests::Mergeability::CheckResult
          .success(payload: default_payload(args))
      end

      def failure(**args)
        Gitlab::MergeRequests::Mergeability::CheckResult
          .failed(payload: default_payload(args))
      end

      def inactive(**args)
        Gitlab::MergeRequests::Mergeability::CheckResult
          .inactive(payload: default_payload(args))
      end

      def default_payload(args)
        args.merge(identifier: self.class.identifier)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::Mergeability::CheckBaseService, feature_category: :code_review_workflow do
  subject(:check_base_service) { described_class.new(merge_request: merge_request, params: params) }

  let(:merge_request) { double }
  let(:params) { double }

  describe '.identifier' do
    it 'sets the identifier' do
      described_class.identifier(""test"")

      expect(described_class.identifier).to eq(""test"")
    end
  end

  describe '.description' do
    it 'sets the description' do
      described_class.description(""test"")

      expect(described_class.description).to eq(""test"")
    end
  end

  describe '#merge_request' do
    it 'returns the merge_request' do
      expect(check_base_service.merge_request).to eq merge_request
    end
  end

  describe '#params' do
    it 'returns the params' do
      expect(check_base_service.params).to eq params
    end
  end

  describe '#skip?' do
    it 'raises NotImplementedError' do
      expect { check_base_service.skip? }.to raise_error(NotImplementedError)
    end
  end

  describe '#cacheable?' do
    it 'raises NotImplementedError' do
      expect { check_base_service.skip? }.to raise_error(NotImplementedError)
    end
  end

  describe '#cache_key?' do
    it 'raises NotImplementedError' do
      expect { check_base_service.skip? }.to raise_error(NotImplementedError)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  module MergeStrategies
    # FromSourceBranch performs a git merge from a merge request's source branch
    # to the target branch, including a squash if needed.
    class FromSourceBranch
      include Gitlab::Utils::StrongMemoize

      delegate :repository, to: :project

      def initialize(merge_request, current_user, merge_params: {}, options: {})
        @merge_request = merge_request
        @current_user = current_user
        @project = merge_request.project
        @merge_params = merge_params
        @options = options
      end

      def validate!
        error_message =
          if source_sha.blank?
            'No source for merge'
          elsif merge_request.should_be_rebased?
            'Only fast-forward merge is allowed for your project. Please update your source branch'
          elsif !merge_request.mergeable?(
            skip_discussions_check: @options[:skip_discussions_check],
            check_mergeability_retry_lease: @options[:check_mergeability_retry_lease]
          )
            'Merge request is not mergeable'
          elsif merge_request.missing_required_squash?
            'This project requires squashing commits when merge requests are accepted.'
          end

        raise_error(error_message) if error_message
      end

      def execute_git_merge!
        result =
          if project.merge_requests_ff_only_enabled
            fast_forward!
          else
            merge_commit!
          end

        result[:squash_commit_sha] = source_sha if merge_request.squash_on_merge?

        result
      end

      private

      attr_reader :merge_request, :current_user, :merge_params, :options, :project

      def source_sha
        if merge_request.squash_on_merge?
          squash_sha!
        else
          merge_request.diff_head_sha
        end
      end
      strong_memoize_attr :source_sha

      def squash_sha!
        squash_result = ::MergeRequests::SquashService
          .new(
            merge_request: merge_request,
            current_user: current_user,
            commit_message: merge_params[:squash_commit_message]
          ).execute

        case squash_result[:status]
        when :success
          squash_result[:squash_sha]
        when :error
          raise_error(squash_result[:message])
        end
      end

      def fast_forward!
        commit_sha = repository.ff_merge(
          current_user,
          source_sha,
          merge_request.target_branch,
          merge_request: merge_request
        )

        { commit_sha: commit_sha }
      end

      def merge_commit!
        commit_sha = repository.merge(
          current_user,
          source_sha,
          merge_request,
          merge_commit_message
        )

        { commit_sha: commit_sha, merge_commit_sha: commit_sha }
      end

      def merge_commit_message
        merge_params[:commit_message] ||
          merge_request.default_merge_commit_message(user: current_user)
      end

      def raise_error(message)
        raise ::MergeRequests::MergeStrategies::StrategyError, message
      end
    end
  end
end

::MergeRequests::MergeStrategies::FromSourceBranch.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::MergeStrategies::FromSourceBranch, feature_category: :code_review_workflow do
  let_it_be(:user) { create(:user) }
  let_it_be(:user2) { create(:user) }

  let(:merge_request) { create(:merge_request, :simple, author: user2, assignees: [user2]) }
  let(:project) { merge_request.project }

  subject(:strategy) { described_class.new(merge_request, user) }

  before do
    project.add_maintainer(user)
  end

  describe '#validate!' do
    context 'when source is missing' do
      before do
        allow(merge_request).to receive(:diff_head_sha).and_return(nil)
      end

      it 'raises source error when source is missing' do
        error_message = 'No source for merge'

        expect { strategy.validate! }
          .to raise_exception(MergeRequests::MergeStrategies::StrategyError, error_message)
      end
    end

    context 'when merge request should be rebased' do
      before do
        allow(merge_request).to receive(:should_be_rebased?).and_return(true)
      end

      it 'raises needs rebase error' do
        error_message = 'Only fast-forward merge is allowed for your project. Please update your source branch'

        expect { strategy.validate! }
          .to raise_exception(MergeRequests::MergeStrategies::StrategyError, error_message)
      end
    end

    context 'when merge request should be squashed but is not' do
      before do
        merge_request.target_project.project_setting.squash_always!
        merge_request.update!(squash: false)
      end

      it 'raises squashing error' do
        error_message = 'This project requires squashing commits when merge requests are accepted.'

        expect { strategy.validate! }
          .to raise_exception(MergeRequests::MergeStrategies::StrategyError, error_message)
      end
    end
  end

  describe '#execute_git_merge!' do
    context 'when fast-forward is required' do
      before do
        project.merge_method = :ff
        project.save!
      end

      it 'performs a fast-forward merge' do
        expect(merge_request.target_project.repository).to receive(:ff_merge).and_return('1234')

        strategy.execute_git_merge!
      end
    end

    context 'when a merge commit is required' do
      before do
        project.merge_method = :merge
        project.save!
      end

      it 'performs standard merge' do
        expect(merge_request.target_project.repository).to receive(:merge).and_return('1234')

        strategy.execute_git_merge!
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  module Conflicts
    class ResolveService < MergeRequests::Conflicts::BaseService
      def execute(current_user, params)
        conflicts = Gitlab::Conflict::FileCollection.new(merge_request)

        conflicts.resolve(current_user, params[:commit_message], params[:files])
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::Conflicts::ResolveService, feature_category: :code_review_workflow do
  include ProjectForksHelper
  let(:user) { create(:user) }
  let(:project) { create(:project, :public, :repository) }

  let(:forked_project) do
    fork_project_with_submodules(project, user)
  end

  let(:merge_request) do
    create(
      :merge_request,
      source_branch: 'conflict-resolvable',
      source_project: project,
      target_branch: 'conflict-start'
    )
  end

  let(:merge_request_from_fork) do
    create(
      :merge_request,
      source_branch: 'conflict-resolvable-fork',
      source_project: forked_project,
      target_branch: 'conflict-start',
      target_project: project
    )
  end

  describe '#execute' do
    let(:service) { described_class.new(merge_request) }

    def blob_content(project, ref, path)
      project.repository.blob_at(ref, path).data
    end

    context 'with section params' do
      let(:params) do
        {
          files: [
            {
              old_path: 'files/ruby/popen.rb',
              new_path: 'files/ruby/popen.rb',
              sections: {
                '2f6fcd96b88b36ce98c38da085c795a27d92a3dd_14_14' => 'head'
              }
            }, {
              old_path: 'files/ruby/regex.rb',
              new_path: 'files/ruby/regex.rb',
              sections: {
                '6eb14e00385d2fb284765eb1cd8d420d33d63fc9_9_9' => 'head',
                '6eb14e00385d2fb284765eb1cd8d420d33d63fc9_21_21' => 'origin',
                '6eb14e00385d2fb284765eb1cd8d420d33d63fc9_49_49' => 'origin'
              }
            }
          ],
          commit_message: 'This is a commit message!'
        }
      end

      context 'when the source and target project are the same' do
        before do
          service.execute(user, params)
        end

        it 'creates a commit with the message' do
          expect(merge_request.source_branch_head.message).to eq(params[:commit_message])
        end

        it 'creates a commit with the correct parents' do
          expect(merge_request.source_branch_head.parents.map(&:id))
            .to eq(%w[1450cd639e0bc6721eb02800169e464f212cde06
                      824be604a34828eb682305f0d963056cfac87b2d])
        end
      end

      context 'when some files have trailing newlines' do
        let!(:source_head) do
          branch = 'conflict-resolvable'
          path = 'files/ruby/popen.rb'
          popen_content = blob_content(project, branch, path)

          project.repository.update_file(
            user,
            path,
            popen_content.chomp(""\n""),
            message: 'Remove trailing newline from popen.rb',
            branch_name: branch
          )
        end

        before do
          service.execute(user, params)
        end

        it 'preserves trailing newlines from our side of the conflicts' do
          head_sha = merge_request.source_branch_head.sha
          popen_content = blob_content(project, head_sha, 'files/ruby/popen.rb')
          regex_content = blob_content(project, head_sha, 'files/ruby/regex.rb')

          expect(popen_content).not_to end_with(""\n"")
          expect(regex_content).to end_with(""\n"")
        end
      end

      context 'when the source project is a fork and does not contain the HEAD of the target branch' do
        let!(:target_head) do
          project.repository.create_file(
            user,
            'new-file-in-target',
            '',
            message: 'Add new file in target',
            branch_name: 'conflict-start')
        end

        subject do
          described_class.new(merge_request_from_fork).execute(user, params)
        end

        it 'creates a commit with the message' do
          subject

          expect(merge_request_from_fork.source_branch_head.message).to eq(params[:commit_message])
        end

        it 'creates a commit with the correct parents' do
          subject

          expect(merge_request_from_fork.source_branch_head.parents.map(&:id))
            .to eq(['404fa3fc7c2c9b5dacff102f353bdf55b1be2813', target_head])
        end
      end
    end

    context 'with content and sections params' do
      let(:popen_content) { ""class Popen\nend"" }

      let(:params) do
        {
          files: [
            {
              old_path: 'files/ruby/popen.rb',
              new_path: 'files/ruby/popen.rb',
              content: popen_content
            }, {
              old_path: 'files/ruby/regex.rb',
              new_path: 'files/ruby/regex.rb',
              sections: {
                '6eb14e00385d2fb284765eb1cd8d420d33d63fc9_9_9' => 'head',
                '6eb14e00385d2fb284765eb1cd8d420d33d63fc9_21_21' => 'origin',
                '6eb14e00385d2fb284765eb1cd8d420d33d63fc9_49_49' => 'origin'
              }
            }
          ],
          commit_message: 'This is a commit message!'
        }
      end

      before do
        service.execute(user, params)
      end

      it 'creates a commit with the message' do
        expect(merge_request.source_branch_head.message).to eq(params[:commit_message])
      end

      it 'creates a commit with the correct parents' do
        expect(merge_request.source_branch_head.parents.map(&:id))
          .to eq(%w[1450cd639e0bc6721eb02800169e464f212cde06
                    824be604a34828eb682305f0d963056cfac87b2d])
      end

      it 'sets the content to the content given' do
        blob = blob_content(
          merge_request.source_project,
          merge_request.source_branch_head.sha,
          'files/ruby/popen.rb'
        )

        expect(blob).to eq(popen_content)
      end
    end

    context 'when a resolution section is missing' do
      let(:invalid_params) do
        {
          files: [
            {
              old_path: 'files/ruby/popen.rb',
              new_path: 'files/ruby/popen.rb',
              content: ''
            }, {
              old_path: 'files/ruby/regex.rb',
              new_path: 'files/ruby/regex.rb',
              sections: { '6eb14e00385d2fb284765eb1cd8d420d33d63fc9_9_9' => 'head' }
            }
          ],
          commit_message: 'This is a commit message!'
        }
      end

      it 'raises a ResolutionError error' do
        expect { service.execute(user, invalid_params) }
          .to raise_error(Gitlab::Git::Conflict::Resolver::ResolutionError)
      end
    end

    context 'when the content of a file is unchanged' do
      let(:resolver) do
        MergeRequests::Conflicts::ListService.new(merge_request).conflicts.resolver
      end

      let(:regex_conflict) do
        resolver.conflict_for_path(resolver.conflicts, 'files/ruby/regex.rb', 'files/ruby/regex.rb')
      end

      let(:invalid_params) do
        {
          files: [
            {
              old_path: 'files/ruby/popen.rb',
              new_path: 'files/ruby/popen.rb',
              content: ''
            }, {
              old_path: 'files/ruby/regex.rb',
              new_path: 'files/ruby/regex.rb',
              content: regex_conflict.content
            }
          ],
          commit_message: 'This is a commit message!'
        }
      end

      it 'raises a ResolutionError error' do
        expect { service.execute(user, invalid_params) }
          .to raise_error(Gitlab::Git::Conflict::Resolver::ResolutionError)
      end
    end

    context 'when a file is missing' do
      let(:invalid_params) do
        {
          files: [
            {
              old_path: 'files/ruby/popen.rb',
              new_path: 'files/ruby/popen.rb',
              content: ''
            }
          ],
          commit_message: 'This is a commit message!'
        }
      end

      it 'raises a ResolutionError error' do
        expect { service.execute(user, invalid_params) }
          .to raise_error(Gitlab::Git::Conflict::Resolver::ResolutionError)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  module Conflicts
    class ListService < MergeRequests::Conflicts::BaseService
      delegate :file_for_path, :to_json, to: :conflicts

      def can_be_resolved_by?(user)
        return false unless merge_request.source_project

        access = ::Gitlab::UserAccess.new(user, container: merge_request.source_project)
        access.can_push_to_branch?(merge_request.source_branch)
      end

      def can_be_resolved_in_ui?
        return @conflicts_can_be_resolved_in_ui if defined?(@conflicts_can_be_resolved_in_ui)

        return @conflicts_can_be_resolved_in_ui = false unless merge_request.cannot_be_merged?
        return @conflicts_can_be_resolved_in_ui = false unless merge_request.has_complete_diff_refs?
        return @conflicts_can_be_resolved_in_ui = false if merge_request.branch_missing?

        @conflicts_can_be_resolved_in_ui = conflicts.can_be_resolved_in_ui?
      end

      def conflicts
        @conflicts ||=
          Gitlab::Conflict::FileCollection.new(
            merge_request,
            allow_tree_conflicts: params[:allow_tree_conflicts]
          )
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::Conflicts::ListService, feature_category: :code_review_workflow do
  describe '#can_be_resolved_in_ui?' do
    def create_merge_request(source_branch, target_branch = 'conflict-start')
      create(:merge_request, source_branch: source_branch, target_branch: target_branch, merge_status: :unchecked) do |mr|
        mr.mark_as_unmergeable
      end
    end

    def conflicts_service(merge_request)
      described_class.new(merge_request)
    end

    it 'returns a falsey value when the MR can be merged without conflicts' do
      merge_request = create_merge_request('master')
      merge_request.mark_as_mergeable

      expect(conflicts_service(merge_request).can_be_resolved_in_ui?).to be_falsey
    end

    it 'returns a falsey value when the MR is marked as having conflicts, but has none' do
      merge_request = create_merge_request('master')

      expect(conflicts_service(merge_request).can_be_resolved_in_ui?).to be_falsey
    end

    it 'returns a falsey value when one of the MR branches is missing' do
      merge_request = create_merge_request('conflict-resolvable')
      merge_request.project.repository.rm_branch(merge_request.author, 'conflict-resolvable')

      expect(conflicts_service(merge_request).can_be_resolved_in_ui?).to be_falsey
    end

    it 'returns a falsey value when the MR does not support new diff notes' do
      merge_request = create_merge_request('conflict-resolvable')
      merge_request.merge_request_diff.update!(start_commit_sha: nil)

      expect(conflicts_service(merge_request).can_be_resolved_in_ui?).to be_falsey
    end

    it 'returns a falsey value when the conflicts contain a large file' do
      merge_request = create_merge_request('conflict-too-large')

      expect(conflicts_service(merge_request).can_be_resolved_in_ui?).to be_falsey
    end

    it 'returns a falsey value when the conflicts contain a binary file' do
      merge_request = create_merge_request('conflict-binary-file')

      expect(conflicts_service(merge_request).can_be_resolved_in_ui?).to be_falsey
    end

    it 'returns a falsey value when the conflicts contain a file edited in one branch and deleted in another' do
      merge_request = create_merge_request('conflict-missing-side')

      expect(conflicts_service(merge_request).can_be_resolved_in_ui?).to be_falsey
    end

    it 'returns a truthy value when the conflicts are resolvable in the UI' do
      merge_request = create_merge_request('conflict-resolvable')

      expect(conflicts_service(merge_request).can_be_resolved_in_ui?).to be_truthy
    end

    it 'returns a truthy value when the conflicts have to be resolved in an editor' do
      merge_request = create_merge_request('conflict-contains-conflict-markers')

      expect(conflicts_service(merge_request).can_be_resolved_in_ui?).to be_truthy
    end

    it 'returns a falsey value when the MR has a missing ref after a force push' do
      merge_request = create_merge_request('conflict-resolvable')
      service = conflicts_service(merge_request)
      allow_next_instance_of(Gitlab::GitalyClient::ConflictsService) do |instance|
        allow(instance).to receive(:list_conflict_files).and_raise(GRPC::Unknown)
      end

      expect(service.can_be_resolved_in_ui?).to be_falsey
    end

    it 'returns a falsey value when the MR has a missing revision after a force push' do
      merge_request = create_merge_request('conflict-resolvable')
      service = conflicts_service(merge_request)
      allow(merge_request).to receive_message_chain(:target_branch_head, :raw, :id).and_return(Gitlab::Git::BLANK_SHA)

      expect(service.can_be_resolved_in_ui?).to be_falsey
    end

    it 'returns a falsey value when the conflict is in a submodule revision' do
      merge_request = create_merge_request('update-gitlab-shell-v-6-0-3', 'update-gitlab-shell-v-6-0-1')

      expect(conflicts_service(merge_request).can_be_resolved_in_ui?).to be_falsey
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Captcha
  ##
  # Encapsulates logic of checking captchas.
  #
  class CaptchaVerificationService
    include Recaptcha::Adapters::ControllerMethods

    # Currently the only value that is used out of the request by the reCAPTCHA library
    # is 'remote_ip'. Therefore, we just create a struct to avoid passing the full request
    # object through all the service layer objects, and instead just rely on passing only
    # the required remote_ip value. This eliminates the need to couple the service layer
    # to the HTTP request (for the purpose of this service, at least).
    RequestStruct = Struct.new(:remote_ip)

    def initialize(spam_params:)
      @spam_params = spam_params
    end

    ##
    # Performs verification of a captcha response.
    #
    # NOTE: Currently only supports reCAPTCHA, and is not yet used in all places of the app in which
    # captchas are verified, but these can be addressed in future MRs.  See:
    # https://gitlab.com/gitlab-org/gitlab/-/issues/273480
    def execute
      return false unless spam_params.captcha_response

      @request = RequestStruct.new(spam_params.ip_address)

      Gitlab::Recaptcha.load_configurations!

      # NOTE: We could pass the model and let the recaptcha gem automatically add errors to it,
      # but we do not, for two reasons:
      #
      # 1. We want control over when the errors are added
      # 2. We want control over the wording and i18n of the message
      # 3. We want a consistent interface and behavior when adding support for other captcha
      #    libraries which may not support automatically adding errors to the model.
      verify_recaptcha(response: spam_params.captcha_response)
    end

    private

    attr_reader :spam_params

    # The recaptcha library's Recaptcha::Adapters::ControllerMethods#verify_recaptcha method requires that
    # 'request' be a readable attribute - it doesn't support passing it as an options argument.
    attr_reader :request
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Captcha::CaptchaVerificationService, feature_category: :team_planning do
  describe '#execute' do
    let(:captcha_response) { 'abc123' }
    let(:fake_ip) { '1.2.3.4' }
    let(:spam_params) do
      ::Spam::SpamParams.new(
        captcha_response: captcha_response,
        spam_log_id: double,
        ip_address: fake_ip,
        user_agent: double,
        referer: double
      )
    end

    let(:service) { described_class.new(spam_params: spam_params) }

    subject { service.execute }

    context 'when there is no captcha_response' do
      let(:captcha_response) { nil }

      it 'returns false' do
        expect(subject).to eq(false)
      end
    end

    context 'when there is a captcha_response' do
      before do
        expect(Gitlab::Recaptcha).to receive(:load_configurations!)
      end

      it 'returns false' do
        expect(service).to receive(:verify_recaptcha).with(response: captcha_response) { true }

        expect(subject).to eq(true)
      end

      it 'has a request method which returns an object with the ip address #remote_ip' do
        subject

        request_struct = service.send(:request)
        expect(request_struct).to respond_to(:remote_ip)
        expect(request_struct.remote_ip).to eq(fake_ip)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module JiraImport
  class ServerUsersMapperService < UsersMapperService
    private

    def url
      ""/rest/api/2/user/search?username=''&maxResults=#{MAX_USERS}&startAt=#{start_at.to_i}""
    end

    def jira_user_id(jira_user)
      jira_user['key']
    end

    def jira_user_name(jira_user)
      jira_user['name']
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe JiraImport::ServerUsersMapperService, feature_category: :integrations do
  let(:start_at) { 7 }
  let(:url) { ""/rest/api/2/user/search?username=''&maxResults=50&startAt=#{start_at}"" }

  let_it_be(:user_1) { create(:user, username: 'randomuser', name: 'USER-name1', email: 'uji@example.com') }
  let_it_be(:user_2) { create(:user, username: 'username-2') }
  let_it_be(:user_5) { create(:user, username: 'username-5') }
  let_it_be(:user_4) { create(:user, email: 'user-4@example.com') }
  let_it_be(:user_6) { create(:user, email: 'user-6@example.com') }
  let_it_be(:user_7) { create(:user, username: 'username-7') }
  let_it_be(:user_8) do
    create(:user).tap { |user| create(:email, user: user, email: 'user8_email@example.com') }
  end

  let_it_be(:current_user) { create(:user) }
  let_it_be(:group)        { create(:group) }
  let_it_be(:project)      { create(:project, group: group) }

  let(:jira_users) do
    [
      { 'key' => 'abcd', 'name' => 'User-Name1' }, # matched by name
      { 'key' => 'efg', 'name' => 'username-2' }, # matcher by username
      { 'key' => 'hij' }, # no match
      { 'key' => '123', 'name' => 'user-4', 'emailAddress' => 'user-4@example.com' }, # matched by email
      { 'key' => '456', 'name' => 'username5foo', 'emailAddress' => 'user-5@example.com' }, # no match
      { 'key' => '789', 'name' => 'user-6', 'emailAddress' => 'user-6@example.com' }, # matched by email, no project member
      { 'key' => 'xyz', 'name' => 'username-7', 'emailAddress' => 'user-7@example.com' }, # matched by username, no project member
      { 'key' => 'vhk', 'name' => 'user-8', 'emailAddress' => 'user8_email@example.com' }, # matched by secondary email
      { 'key' => 'uji', 'name' => 'user-9', 'emailAddress' => 'uji@example.com' } # matched by email, same as user_1
    ]
  end

  describe '#execute' do
    before do
      project.add_developer(current_user)
      project.add_developer(user_1)
      project.add_developer(user_2)
      group.add_developer(user_4)
      group.add_guest(user_8)
    end

    it_behaves_like 'mapping jira users'
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module JiraImport
  class CloudUsersMapperService < UsersMapperService
    private

    def url
      ""/rest/api/2/users?maxResults=#{MAX_USERS}&startAt=#{start_at.to_i}""
    end

    def jira_user_id(jira_user)
      jira_user['accountId']
    end

    def jira_user_name(jira_user)
      jira_user['displayName']
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe JiraImport::CloudUsersMapperService, feature_category: :integrations do
  let(:start_at) { 7 }
  let(:url) { ""/rest/api/2/users?maxResults=50&startAt=#{start_at}"" }

  let_it_be(:user_1) { create(:user, username: 'randomuser', name: 'USER-name1', email: 'uji@example.com') }
  let_it_be(:user_2) { create(:user, username: 'username-2') }
  let_it_be(:user_5) { create(:user, username: 'username-5') }
  let_it_be(:user_4) { create(:user, email: 'user-4@example.com') }
  let_it_be(:user_6) { create(:user, email: 'user-6@example.com') }
  let_it_be(:user_7) { create(:user, username: 'username-7') }
  let_it_be(:user_8) do
    create(:user).tap { |user| create(:email, user: user, email: 'user8_email@example.com') }
  end

  let_it_be(:current_user) { create(:user) }
  let_it_be(:group)        { create(:group) }
  let_it_be(:project)      { create(:project, group: group) }

  let(:jira_users) do
    [
      { 'accountId' => 'abcd', 'displayName' => 'User-Name1' }, # matched by name
      { 'accountId' => 'efg', 'displayName' => 'username-2' }, # matcher by username
      { 'accountId' => 'hij' }, # no match
      { 'accountId' => '123', 'displayName' => 'user-4', 'emailAddress' => 'user-4@example.com' }, # matched by email
      { 'accountId' => '456', 'displayName' => 'username5foo', 'emailAddress' => 'user-5@example.com' }, # no match
      { 'accountId' => '789', 'displayName' => 'user-6', 'emailAddress' => 'user-6@example.com' }, # matched by email, no project member
      { 'accountId' => 'xyz', 'displayName' => 'username-7', 'emailAddress' => 'user-7@example.com' }, # matched by username, no project member
      { 'accountId' => 'vhk', 'displayName' => 'user-8', 'emailAddress' => 'user8_email@example.com' }, # matched by secondary email
      { 'accountId' => 'uji', 'displayName' => 'user-9', 'emailAddress' => 'uji@example.com' } # matched by email, same as user_1
    ]
  end

  describe '#execute' do
    before do
      project.add_developer(current_user)
      project.add_developer(user_1)
      project.add_developer(user_2)
      group.add_developer(user_4)
      group.add_guest(user_8)
    end

    it_behaves_like 'mapping jira users'
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module JiraImport
  class UsersImporter
    def initialize(user, project, start_at)
      @project = project
      @start_at = start_at
      @user = user
    end

    def execute
      Gitlab::JiraImport.validate_project_settings!(project, user: user)

      ServiceResponse.success(payload: mapped_users)
    rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, Errno::ECONNREFUSED, URI::InvalidURIError, JIRA::HTTPError, OpenSSL::SSL::SSLError => error
      Gitlab::ErrorTracking.log_exception(error, project_id: project.id)
      ServiceResponse.error(message: ""There was an error when communicating to Jira"")
    rescue Projects::ImportService::Error => error
      ServiceResponse.error(message: error.message)
    end

    private

    attr_reader :user, :project, :start_at

    def mapped_users
      users_mapper_service.execute
    end

    def users_mapper_service
      @users_mapper_service ||= user_mapper_service_factory
    end

    def user_mapper_service_factory
      if project.jira_integration.data_fields.deployment_server?
        ServerUsersMapperService.new(user, project, start_at)
      elsif project.jira_integration.data_fields.deployment_cloud?
        CloudUsersMapperService.new(user, project, start_at)
      else
        raise ArgumentError
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe JiraImport::UsersImporter, feature_category: :integrations do
  include JiraIntegrationHelpers

  let_it_be(:user) { create(:user) }
  let_it_be(:group) { create(:group) }
  let_it_be(:project, reload: true) { create(:project, group: group) }
  let_it_be(:start_at) { 7 }

  let(:importer) { described_class.new(user, project, start_at) }

  subject { importer.execute }

  describe '#execute' do
    let(:mapped_users) do
      [
        {
          jira_account_id: 'acc1',
          jira_display_name: 'user-name1',
          jira_email: 'sample@jira.com',
          gitlab_id: project_member.id
        },
        {
          jira_account_id: 'acc2',
          jira_display_name: 'user-name2',
          jira_email: nil,
          gitlab_id: group_member.id
        }
      ]
    end

    before do
      stub_jira_integration_test
      project.add_maintainer(user)
    end

    context 'when Jira import is not configured properly' do
      it 'returns an error' do
        expect(subject.errors).to eq(['Jira integration not configured.'])
      end
    end

    RSpec.shared_examples 'maps Jira users to GitLab users' do |users_mapper_service:|
      context 'when Jira import is configured correctly' do
        let_it_be(:jira_integration) { create(:jira_integration, project: project, active: true, url: ""http://jira.example.net"") }

        context 'when users mapper service raises an error' do
          let(:error) { Timeout::Error.new }

          it 'returns an error response' do
            expect_next_instance_of(users_mapper_service) do |instance|
              expect(instance).to receive(:execute).and_raise(error)
            end

            expect(Gitlab::ErrorTracking).to receive(:log_exception).with(error, project_id: project.id)
            expect(subject.error?).to be_truthy
            expect(subject.message).to include('There was an error when communicating to Jira')
          end
        end

        context 'when users mapper service returns result' do
          context 'when users mapper service returns an empty array' do
            it 'returns nil payload' do
              expect_next_instance_of(users_mapper_service) do |instance|
                expect(instance).to receive(:execute).and_return([])
              end

              expect(subject.success?).to be_truthy
              expect(subject.payload).to be_empty
            end
          end

          context 'when Jira client returns any users' do
            let_it_be(:project_member) { create(:user, email: 'sample@jira.com') }
            let_it_be(:group_member) { create(:user, name: 'user-name2') }
            let_it_be(:other_user) { create(:user) }

            before do
              project.add_developer(project_member)
              group.add_developer(group_member)
            end

            it 'returns the mapped users' do
              expect_next_instance_of(users_mapper_service) do |instance|
                expect(instance).to receive(:execute).and_return(mapped_users)
              end

              expect(subject.success?).to be_truthy
              expect(subject.payload).to eq(mapped_users)
            end
          end
        end
      end
    end

    context 'when Jira instance is of Server deployment type' do
      before do
        allow(project).to receive(:jira_integration).and_return(jira_integration)

        jira_integration.data_fields.deployment_server!
      end

      it_behaves_like 'maps Jira users to GitLab users', users_mapper_service: JiraImport::ServerUsersMapperService
    end

    context 'when Jira instance is of Cloud deployment type' do
      before do
        allow(project).to receive(:jira_integration).and_return(jira_integration)

        jira_integration.data_fields.deployment_cloud!
      end

      it_behaves_like 'maps Jira users to GitLab users', users_mapper_service: JiraImport::CloudUsersMapperService
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module JiraImport
  class StartImportService
    attr_reader :user, :project, :jira_project_key, :users_mapping

    def initialize(user, project, jira_project_key, users_mapping)
      @user = user
      @project = project
      @jira_project_key = jira_project_key
      @users_mapping = users_mapping
    end

    def execute
      validation_response = validate
      return validation_response if validation_response&.error?

      store_users_mapping
      create_and_schedule_import
    end

    private

    def store_users_mapping
      return if users_mapping.blank?

      mapping = users_mapping.map do |map|
        next if !map[:jira_account_id] || !map[:gitlab_id]

        [map[:jira_account_id], map[:gitlab_id]]
      end.compact.to_h

      return if mapping.blank?

      Gitlab::JiraImport.cache_users_mapping(project.id, mapping)
    end

    def create_and_schedule_import
      jira_import = build_jira_import
      project.import_type = 'jira'
      project.save! && jira_import.schedule!

      ServiceResponse.success(payload: { import_data: jira_import })
    rescue StandardError => ex
      # in case project.save! raises an error
      Gitlab::ErrorTracking.track_exception(ex, project_id: project.id)
      jira_import&.do_fail!(error_message: ex.message)
      build_error_response(ex.message)
    end

    def build_jira_import
      label = create_import_label(project)
      project.jira_imports.build(
        user: user,
        label: label,
        jira_project_key: jira_project_key,
        # we do not have the jira_project_name or jira_project_xid yet so just set a mock value,
        # we will once https://gitlab.com/gitlab-org/gitlab/-/merge_requests/28190
        jira_project_name: jira_project_key,
        jira_project_xid: 0
      )
    end

    def create_import_label(project)
      label = ::Labels::CreateService.new(build_label_attrs(project)).execute(project: project)
      raise Projects::ImportService::Error, _('Failed to create import label for jira import.') if label.blank?

      label
    end

    def build_label_attrs(project)
      import_start_time = Time.zone.now
      jira_imports_for_project = project.jira_imports.by_jira_project_key(jira_project_key).size + 1
      title = ""jira-import::#{jira_project_key}-#{jira_imports_for_project}""
      description = ""Label for issues that were imported from Jira on #{import_start_time.strftime('%Y-%m-%d %H:%M:%S')}""
      color = ::Gitlab::Color.color_for(title).to_s
      { title: title, description: description, color: color }
    end

    def validate
      Gitlab::JiraImport.validate_project_settings!(project, user: user)

      return build_error_response(_('Unable to find Jira project to import data from.')) if jira_project_key.blank?
      return build_error_response(_('Jira import is already running.')) if import_in_progress?
    rescue Projects::ImportService::Error => e
      build_error_response(e.message)
    end

    def build_error_response(message)
      ServiceResponse.error(message: message, http_status: 400)
    end

    def import_in_progress?
      project.latest_jira_import&.in_progress?
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe JiraImport::StartImportService, feature_category: :integrations do
  include JiraIntegrationHelpers

  let_it_be(:user) { create(:user) }
  let_it_be(:project, reload: true) { create(:project) }

  let(:key) { 'KEY' }
  let(:mapping) do
    [
      { jira_account_id: 'abc', gitlab_id: 12 },
      { jira_account_id: 'def', gitlab_id: nil },
      { jira_account_id: nil, gitlab_id: 1 }
    ]
  end

  subject { described_class.new(user, project, key, mapping).execute }

  context 'when an error is returned from the project validation' do
    before do
      allow(Gitlab::JiraImport).to receive(:validate_project_settings!)
        .and_raise(Projects::ImportService::Error, 'Jira import feature is disabled.')
    end

    it_behaves_like 'responds with error', 'Jira import feature is disabled.'
  end

  context 'when project validation is ok' do
    let!(:jira_integration) { create(:jira_integration, project: project, active: true) }

    before do
      stub_jira_integration_test
      allow(Gitlab::JiraImport).to receive(:validate_project_settings!)
    end

    context 'when Jira project key is not provided' do
      let(:key) { '' }

      it_behaves_like 'responds with error', 'Unable to find Jira project to import data from.'
    end

    context 'when correct data provided' do
      let(:fake_key)  { 'some-key' }

      subject { described_class.new(user, project, fake_key, mapping).execute }

      context 'when import is already running' do
        let_it_be(:jira_import_state) { create(:jira_import_state, :started, project: project) }

        it_behaves_like 'responds with error', 'Jira import is already running.'
      end

      context 'when an error is raised while scheduling import' do
        before do
          expect_next_instance_of(JiraImportState) do |jira_impport|
            expect(jira_impport).to receive(:schedule!).and_raise(Projects::ImportService::Error, 'Unexpected failure.')
          end
        end

        it_behaves_like 'responds with error', 'Unexpected failure.'

        it 'saves the error message' do
          subject

          expect(JiraImportState.last.error_message).to eq('Unexpected failure.')
        end
      end

      context 'when everything is ok' do
        context 'with complete mapping' do
          before do
            expect(Gitlab::JiraImport).to receive(:cache_users_mapping).with(project.id, { 'abc' => 12 })
          end

          it 'returns success response' do
            expect(subject).to be_a(ServiceResponse)
            expect(subject).to be_success
          end

          it 'schedules Jira import' do
            subject

            expect(project.latest_jira_import).to be_scheduled
          end

          it 'creates Jira import data', :aggregate_failures do
            jira_import = subject.payload[:import_data]

            expect(jira_import.jira_project_xid).to eq(0)
            expect(jira_import.jira_project_name).to eq(fake_key)
            expect(jira_import.jira_project_key).to eq(fake_key)
            expect(jira_import.user).to eq(user)
          end

          it 'creates Jira import label' do
            expect { subject }.to change { Label.count }.by(1)
          end

          it 'creates Jira label title with correct number' do
            jira_import = subject.payload[:import_data]
            label_title = ""jira-import::#{jira_import.jira_project_key}-1""

            expect(jira_import.label.title).to eq(label_title)
          end
        end

        context 'when mapping is nil' do
          let(:mapping) { nil }

          it 'returns success response' do
            expect(Gitlab::JiraImport).not_to receive(:cache_users_mapping)

            expect(subject).to be_a(ServiceResponse)
            expect(subject).to be_success
          end
        end

        context 'when no mapping value is complete' do
          let(:mapping) do
            [
              { jira_account_id: 'def', gitlab_id: nil },
              { jira_account_id: nil, gitlab_id: 1 }
            ]
          end

          it 'returns success response' do
            expect(Gitlab::JiraImport).not_to receive(:cache_users_mapping)

            expect(subject).to be_a(ServiceResponse)
            expect(subject).to be_success
          end
        end
      end

      context 'when multiple Jira imports for same Jira project' do
        let!(:jira_imports) { create_list(:jira_import_state, 3, :finished, project: project, jira_project_key: fake_key) }

        it 'creates Jira label title with correct number' do
          jira_import = subject.payload[:import_data]
          label_title = ""jira-import::#{jira_import.jira_project_key}-4""

          expect(jira_import.label.title).to eq(label_title)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Tags
  class DestroyService < BaseService
    def execute(tag_name)
      repository = project.repository
      tag = repository.find_tag(tag_name)

      unless tag
        return error('No such tag', 404)
      end

      if repository.rm_tag(current_user, tag_name)
        ##
        # When a tag in a repository is destroyed,
        # release assets will be destroyed too.
        Releases::DestroyService
          .new(project, current_user, tag: tag_name)
          .execute

        unlock_artifacts(tag_name)

        success('Tag was removed')
      else
        error('Failed to remove tag')
      end
    rescue Gitlab::Git::PreReceiveError => ex
      error(ex.message)
    end

    def error(message, return_code = 400)
      super(message).merge(return_code: return_code)
    end

    def success(message)
      super().merge(message: message)
    end

    private

    def unlock_artifacts(tag_name)
      Ci::RefDeleteUnlockArtifactsWorker.perform_async(project.id, current_user.id, ""#{::Gitlab::Git::TAG_REF_PREFIX}#{tag_name}"")
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Tags::DestroyService, feature_category: :source_code_management do
  let(:project) { create(:project, :repository) }
  let(:repository) { project.repository }
  let(:user) { create(:user) }
  let(:service) { described_class.new(project, user) }

  describe '#execute' do
    subject { service.execute(tag_name) }

    before do
      allow(Ci::RefDeleteUnlockArtifactsWorker).to receive(:perform_async)
    end

    it 'removes the tag' do
      expect(repository).to receive(:before_remove_tag)
      expect(service).to receive(:success)

      service.execute('v1.1.0')
    end

    it 'calls the RefDeleteUnlockArtifactsWorker' do
      expect(Ci::RefDeleteUnlockArtifactsWorker).to receive(:perform_async).with(project.id, user.id, 'refs/tags/v1.1.0')

      service.execute('v1.1.0')
    end

    context 'when there is an associated release on the tag' do
      let(:tag) { repository.tags.first }
      let(:tag_name) { tag.name }

      before do
        project.add_maintainer(user)
        create(:release, tag: tag_name, project: project)
      end

      it 'destroys the release' do
        expect { subject }.to change { project.releases.count }.by(-1)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Tags
  class CreateService < BaseService
    def execute(tag_name, target, message)
      return error('Target is empty', 400) if target.blank?

      valid_tag = Gitlab::GitRefValidator.validate(tag_name)
      return error('Tag name invalid', 400) unless valid_tag

      repository = project.repository
      message = message&.strip

      new_tag = nil

      begin
        new_tag = repository.add_tag(current_user, tag_name, target, message)
      rescue Gitlab::Git::Repository::TagExistsError
        return error(""Tag #{tag_name} already exists"", 409)
      rescue Gitlab::Git::PreReceiveError => ex
        return error(ex.message)
      end

      if new_tag
        repository.expire_tags_cache

        success.merge(tag: new_tag)
      else
        error(""Target #{target} is invalid"", 400)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Tags::CreateService, feature_category: :source_code_management do
  let(:project) { create(:project, :repository) }
  let(:repository) { project.repository }
  let(:user) { create(:user) }
  let(:service) { described_class.new(project, user) }

  describe '#execute' do
    it 'creates the tag and returns success' do
      response = service.execute('v42.42.42', 'master', 'Foo')

      expect(response[:status]).to eq(:success)
      expect(response[:tag]).to be_a Gitlab::Git::Tag
      expect(response[:tag].name).to eq('v42.42.42')
    end

    context 'when target is invalid' do
      it 'returns an error' do
        response = service.execute('v1.1.0', 'foo', 'Foo')

        expect(response[:status]).to eq(:error)
        expect(response[:http_status]).to eq(400)
        expect(response[:message]).to eq('Target foo is invalid')
      end
    end

    context 'when tag_name is empty' do
      it 'returns an error' do
        response = service.execute('', 'foo', 'Foo')

        expect(response[:status]).to eq(:error)
        expect(response[:http_status]).to eq(400)
        expect(response[:message]).to eq('Tag name invalid')
      end
    end

    context 'when target is empty' do
      it 'returns an error' do
        response = service.execute('v1.1.0', '', 'Foo')

        expect(response[:status]).to eq(:error)
        expect(response[:http_status]).to eq(400)
        expect(response[:message]).to eq('Target is empty')
      end
    end

    context 'when tag already exists' do
      it 'returns an error' do
        expect(repository).to receive(:add_tag)
          .with(user, 'v1.1.0', 'master', 'Foo')
          .and_raise(Gitlab::Git::Repository::TagExistsError)

        response = service.execute('v1.1.0', 'master', 'Foo')

        expect(response[:status]).to eq(:error)
        expect(response[:http_status]).to eq(409)
        expect(response[:message]).to eq('Tag v1.1.0 already exists')
      end
    end

    context 'when tag name is invalid' do
      it 'returns an error' do
        response = service.execute('HEAD', 'master', 'Foo')

        expect(response[:status]).to eq(:error)
        expect(response[:http_status]).to eq(400)
        expect(response[:message]).to eq('Tag name invalid')
      end
    end

    context 'when pre-receive hook fails' do
      it 'returns an error' do
        expect(repository).to receive(:add_tag)
          .with(user, 'v1.1.0', 'master', 'Foo')
          .and_raise(Gitlab::Git::PreReceiveError, 'GitLab: something went wrong')

        response = service.execute('v1.1.0', 'master', 'Foo')

        expect(response[:status]).to eq(:error)
        expect(response[:message]).to eq('something went wrong')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Search
  class GlobalService
    include Search::Filter
    include Gitlab::Utils::StrongMemoize

    DEFAULT_SCOPE = 'projects'
    ALLOWED_SCOPES = %w[projects issues merge_requests milestones users].freeze

    attr_accessor :current_user, :params

    def initialize(user, params)
      @current_user = user
      @params = params.dup
    end

    def execute
      Gitlab::SearchResults.new(current_user,
                                params[:search],
                                projects,
                                order_by: params[:order_by],
                                sort: params[:sort],
                                filters: filters)
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def projects
      @projects ||= ProjectsFinder.new(current_user: current_user).execute.preload(:topics, :project_topics)
    end

    def allowed_scopes
      ALLOWED_SCOPES
    end

    def scope
      strong_memoize(:scope) do
        allowed_scopes.include?(params[:scope]) ? params[:scope] : DEFAULT_SCOPE
      end
    end
  end
end

Search::GlobalService.prepend_mod_with('Search::GlobalService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Search::GlobalService, feature_category: :global_search do
  let_it_be(:user) { create(:user) }
  let_it_be(:internal_user) { create(:user) }

  let_it_be(:found_project)    { create(:project, :private, name: 'searchable_project') }
  let_it_be(:unfound_project)  { create(:project, :private, name: 'unfound_project') }
  let_it_be(:internal_project) { create(:project, :internal, name: 'searchable_internal_project') }
  let_it_be(:public_project)   { create(:project, :public, name: 'searchable_public_project') }
  let_it_be(:archived_project) { create(:project, :public, archived: true, name: 'archived_project') }

  before do
    found_project.add_maintainer(user)
  end

  describe '#execute' do
    context 'unauthenticated' do
      it 'returns public projects only' do
        results = described_class.new(nil, search: ""searchable"").execute

        expect(results.objects('projects')).to match_array [public_project]
      end
    end

    context 'authenticated' do
      it 'returns public, internal and private projects' do
        results = described_class.new(user, search: ""searchable"").execute

        expect(results.objects('projects')).to match_array [public_project, found_project, internal_project]
      end

      it 'returns only public & internal projects' do
        results = described_class.new(internal_user, search: ""searchable"").execute

        expect(results.objects('projects')).to match_array [internal_project, public_project]
      end

      it 'project name is searchable' do
        results = described_class.new(user, search: found_project.name).execute

        expect(results.objects('projects')).to match_array [found_project]
      end

      it 'does not return archived projects' do
        results = described_class.new(user, search: ""archived"").execute

        expect(results.objects('projects')).not_to include(archived_project)
      end

      it 'returns archived projects if the include_archived option is passed' do
        results = described_class.new(user, { include_archived: true, search: ""archived"" }).execute

        expect(results.objects('projects')).to include(archived_project)
      end
    end
  end

  context 'issues' do
    let(:scope) { 'issues' }

    context 'sorting' do
      let_it_be(:project) { create(:project, :public) }

      let!(:old_result) { create(:issue, project: project, title: 'sorted old', created_at: 1.month.ago) }
      let!(:new_result) { create(:issue, project: project, title: 'sorted recent', created_at: 1.day.ago) }
      let!(:very_old_result) { create(:issue, project: project, title: 'sorted very old', created_at: 1.year.ago) }

      let!(:old_updated) { create(:issue, project: project, title: 'updated old', updated_at: 1.month.ago) }
      let!(:new_updated) { create(:issue, project: project, title: 'updated recent', updated_at: 1.day.ago) }
      let!(:very_old_updated) { create(:issue, project: project, title: 'updated very old', updated_at: 1.year.ago) }

      include_examples 'search results sorted' do
        let(:results_created) { described_class.new(nil, search: 'sorted', sort: sort).execute }
        let(:results_updated) { described_class.new(nil, search: 'updated', sort: sort).execute }
      end
    end
  end

  context 'merge_request' do
    let(:scope) { 'merge_requests' }

    context 'sorting' do
      let!(:project) { create(:project, :public) }

      let!(:old_result) { create(:merge_request, :opened, source_project: project, source_branch: 'old-1', title: 'sorted old', created_at: 1.month.ago) }
      let!(:new_result) { create(:merge_request, :opened, source_project: project, source_branch: 'new-1', title: 'sorted recent', created_at: 1.day.ago) }
      let!(:very_old_result) { create(:merge_request, :opened, source_project: project, source_branch: 'very-old-1', title: 'sorted very old', created_at: 1.year.ago) }

      let!(:old_updated) { create(:merge_request, :opened, source_project: project, source_branch: 'updated-old-1', title: 'updated old', updated_at: 1.month.ago) }
      let!(:new_updated) { create(:merge_request, :opened, source_project: project, source_branch: 'updated-new-1', title: 'updated recent', updated_at: 1.day.ago) }
      let!(:very_old_updated) { create(:merge_request, :opened, source_project: project, source_branch: 'updated-very-old-1', title: 'updated very old', updated_at: 1.year.ago) }

      include_examples 'search results sorted' do
        let(:results_created) { described_class.new(nil, search: 'sorted', sort: sort).execute }
        let(:results_updated) { described_class.new(nil, search: 'updated', sort: sort).execute }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Search
  class SnippetService < Search::GlobalService
    def execute
      Gitlab::SnippetSearchResults.new(current_user, params[:search])
    end

    def scope
      @scope ||= 'snippet_titles'
    end
  end
end

Search::SnippetService.prepend_mod_with('Search::SnippetService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Search::SnippetService, feature_category: :global_search do
  let_it_be(:author) { create(:author) }
  let_it_be(:project) { create(:project, :public) }

  let_it_be(:public_snippet)   { create(:snippet, :public, title: 'Foo Bar Title') }
  let_it_be(:internal_snippet) { create(:snippet, :internal, title: 'Foo Bar Title') }
  let_it_be(:private_snippet)  { create(:snippet, :private, title: 'Foo Bar Title', author: author) }

  let_it_be(:project_public_snippet)   { create(:snippet, :public, project: project, title: 'Foo Bar Title') }
  let_it_be(:project_internal_snippet) { create(:snippet, :internal, project: project, title: 'Foo Bar Title') }
  let_it_be(:project_private_snippet)  { create(:snippet, :private, project: project, title: 'Foo Bar Title') }

  let_it_be(:user) { create(:user) }

  describe '#execute' do
    context 'unauthenticated' do
      it 'returns public snippets only' do
        search = described_class.new(nil, search: 'bar')
        results = search.execute

        expect(results.objects('snippet_titles')).to match_array [public_snippet, project_public_snippet]
      end
    end

    context 'authenticated' do
      it 'returns only public & internal snippets for regular users' do
        search = described_class.new(user, search: 'bar')
        results = search.execute

        expect(results.objects('snippet_titles')).to match_array [public_snippet, internal_snippet, project_public_snippet, project_internal_snippet]
      end

      it 'returns public, internal snippets and project private snippets for project members' do
        project.add_developer(user)
        search = described_class.new(user, search: 'bar')
        results = search.execute

        expect(results.objects('snippet_titles')).to match_array [public_snippet, internal_snippet, project_public_snippet, project_internal_snippet, project_private_snippet]
      end

      it 'returns public, internal and private snippets where user is the author' do
        search = described_class.new(author, search: 'bar')
        results = search.execute

        expect(results.objects('snippet_titles')).to match_array [public_snippet, internal_snippet, private_snippet, project_public_snippet, project_internal_snippet]
      end

      context 'when admin mode is enabled', :enable_admin_mode do
        it 'returns all snippets when user is admin' do
          admin = create(:admin)
          search = described_class.new(admin, search: 'bar')
          results = search.execute

          expect(results.objects('snippet_titles')).to match_array [public_snippet, internal_snippet, private_snippet, project_public_snippet, project_internal_snippet, project_private_snippet]
        end
      end

      context 'when admin mode is disabled' do
        it 'returns only public & internal snippets when user is admin' do
          admin = create(:admin)
          search = described_class.new(admin, search: 'bar')
          results = search.execute

          expect(results.objects('snippet_titles')).to match_array [public_snippet, internal_snippet, project_public_snippet, project_internal_snippet]
        end
      end
    end
  end

  describe '#scope' do
    it 'always scopes to snippet_titles' do
      search = described_class.new(user, search: 'bar')

      expect(search.scope).to eq 'snippet_titles'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Search
  class GroupService < Search::GlobalService
    attr_accessor :group

    def initialize(user, group, params)
      super(user, params)

      @group = group
    end

    def execute
      Gitlab::GroupSearchResults.new(
        current_user,
        params[:search],
        projects,
        group: group,
        order_by: params[:order_by],
        sort: params[:sort],
        filters: filters
      )
    end

    def projects
      return Project.none unless group
      return @projects if defined? @projects

      @projects = super.inside_path(group.full_path)
    end
  end
end

Search::GroupService.prepend_mod_with('Search::GroupService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Search::GroupService, feature_category: :global_search do
  shared_examples_for 'group search' do
    context 'finding projects by name' do
      let(:user) { create(:user) }
      let(:term) { ""Project Name"" }
      let(:nested_group) { create(:group, :nested) }

      # These projects shouldn't be found
      let!(:outside_project) { create(:project, :public, name: ""Outside #{term}"") }
      let!(:private_project) { create(:project, :private, namespace: nested_group, name: ""Private #{term}"") }
      let!(:other_project)   { create(:project, :public, namespace: nested_group, name: term.reverse) }

      # These projects should be found
      let!(:project1) { create(:project, :internal, namespace: nested_group, name: ""Inner #{term} 1"") }
      let!(:project2) { create(:project, :internal, namespace: nested_group, name: ""Inner #{term} 2"") }
      let!(:project3) { create(:project, :internal, namespace: nested_group.parent, name: ""Outer #{term}"") }

      let(:results) { described_class.new(user, search_group, search: term).execute }

      subject { results.objects('projects') }

      context 'in parent group' do
        let(:search_group) { nested_group.parent }

        it { is_expected.to match_array([project1, project2, project3]) }
      end

      context 'in subgroup' do
        let(:search_group) { nested_group }

        it { is_expected.to match_array([project1, project2]) }
      end
    end
  end

  describe 'basic search' do
    include_examples 'group search'
  end

  context 'issues' do
    let(:scope) { 'issues' }

    context 'sorting' do
      let_it_be(:group) { create(:group) }
      let_it_be(:project) { create(:project, :public, group: group) }

      let!(:old_result) { create(:issue, project: project, title: 'sorted old', created_at: 1.month.ago) }
      let!(:new_result) { create(:issue, project: project, title: 'sorted recent', created_at: 1.day.ago) }
      let!(:very_old_result) { create(:issue, project: project, title: 'sorted very old', created_at: 1.year.ago) }

      let!(:old_updated) { create(:issue, project: project, title: 'updated old', updated_at: 1.month.ago) }
      let!(:new_updated) { create(:issue, project: project, title: 'updated recent', updated_at: 1.day.ago) }
      let!(:very_old_updated) { create(:issue, project: project, title: 'updated very old', updated_at: 1.year.ago) }

      include_examples 'search results sorted' do
        let(:results_created) { described_class.new(nil, group, search: 'sorted', sort: sort).execute }
        let(:results_updated) { described_class.new(nil, group, search: 'updated', sort: sort).execute }
      end
    end
  end

  context 'merge requests' do
    let(:scope) { 'merge_requests' }

    context 'sorting' do
      let!(:group) { create(:group) }
      let!(:project) { create(:project, :public, group: group) }

      let!(:old_result) { create(:merge_request, :opened, source_project: project, source_branch: 'old-1', title: 'sorted old', created_at: 1.month.ago) }
      let!(:new_result) { create(:merge_request, :opened, source_project: project, source_branch: 'new-1', title: 'sorted recent', created_at: 1.day.ago) }
      let!(:very_old_result) { create(:merge_request, :opened, source_project: project, source_branch: 'very-old-1', title: 'sorted very old', created_at: 1.year.ago) }

      let!(:old_updated) { create(:merge_request, :opened, source_project: project, source_branch: 'updated-old-1', title: 'updated old', updated_at: 1.month.ago) }
      let!(:new_updated) { create(:merge_request, :opened, source_project: project, source_branch: 'updated-new-1', title: 'updated recent', updated_at: 1.day.ago) }
      let!(:very_old_updated) { create(:merge_request, :opened, source_project: project, source_branch: 'updated-very-old-1', title: 'updated very old', updated_at: 1.year.ago) }

      include_examples 'search results sorted' do
        let(:results_created) { described_class.new(nil, group, search: 'sorted', sort: sort).execute }
        let(:results_updated) { described_class.new(nil, group, search: 'updated', sort: sort).execute }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Issuable
  class DestroyLabelLinksService
    BATCH_SIZE = 100

    def initialize(target_id, target_type)
      @target_id = target_id
      @target_type = target_type
    end

    def execute
      inner_query =
        LabelLink
          .select(:id)
          .for_target(target_id, target_type)
          .limit(BATCH_SIZE)

      delete_query = <<~SQL
      DELETE FROM ""#{LabelLink.table_name}""
      WHERE id IN (#{inner_query.to_sql})
      SQL

      loop do
        result = LabelLink.connection.execute(delete_query)

        break if result.cmd_tuples == 0
      end
    end

    private

    attr_reader :target_id, :target_type
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issuable::DestroyLabelLinksService, feature_category: :team_planning do
  describe '#execute' do
    context 'when target is an Issue' do
      let_it_be(:target) { create(:issue) }

      it_behaves_like 'service deleting label links of an issuable'
    end

    context 'when target is a MergeRequest' do
      let_it_be(:target) { create(:merge_request) }

      it_behaves_like 'service deleting label links of an issuable'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Issuable
  class CommonSystemNotesService < ::BaseProjectService
    attr_reader :issuable

    def execute(issuable, old_labels: [], old_milestone: nil, is_update: true)
      @issuable = issuable

      # We disable touch so that created system notes do not update
      # the noteable's updated_at field
      ApplicationRecord.no_touching do
        if is_update
          if issuable.previous_changes.include?('title')
            create_title_change_note(issuable.previous_changes['title'].first)
          end

          handle_description_change_note

          handle_time_tracking_note if issuable.is_a?(TimeTrackable)
          create_discussion_lock_note if issuable.previous_changes.include?('discussion_locked')
        end

        handle_start_date_or_due_date_change_note
        create_milestone_change_event(old_milestone) if issuable.previous_changes.include?('milestone_id')
        create_labels_note(old_labels) if old_labels && issuable.labels != old_labels
      end
    end

    private

    def handle_start_date_or_due_date_change_note
      # Type check needed as some issuables do their own date change handling for date fields other than due_date
      change_date_fields = issuable.is_a?(Issue) ? %w[due_date start_date] : %w[due_date]
      changed_dates = issuable.previous_changes.slice(*change_date_fields)
      create_start_date_or_due_date_note(changed_dates)
    end

    def handle_time_tracking_note
      if issuable.previous_changes.include?('time_estimate')
        create_time_estimate_note
      end

      if issuable.time_spent?
        create_time_spent_note
      end
    end

    def handle_description_change_note
      if issuable.previous_changes.include?('description')
        if issuable.tasks? && issuable.updated_tasks.any?
          create_task_status_note
        else
          # TODO: Show this note if non-task content was modified.
          # https://gitlab.com/gitlab-org/gitlab-foss/issues/33577
          create_description_change_note
        end
      end
    end

    def create_draft_note(old_title)
      return unless issuable.is_a?(MergeRequest)

      if MergeRequest.draft?(old_title) != issuable.draft?
        SystemNoteService.handle_merge_request_draft(issuable, issuable.project, current_user)
      end
    end

    def create_labels_note(old_labels)
      added_labels = issuable.labels - old_labels
      removed_labels = old_labels - issuable.labels

      ResourceEvents::ChangeLabelsService
        .new(issuable, current_user)
        .execute(added_labels: added_labels, removed_labels: removed_labels)
    end

    def create_title_change_note(old_title)
      create_draft_note(old_title)

      if issuable.draftless_title_changed(old_title)
        SystemNoteService.change_title(issuable, issuable.project, current_user, old_title)
      end
    end

    def create_description_change_note
      SystemNoteService.change_description(issuable, issuable.project, current_user)
    end

    def create_task_status_note
      issuable.updated_tasks.each do |task|
        SystemNoteService.change_task_status(issuable, issuable.project, current_user, task)
      end
    end

    def create_time_estimate_note
      SystemNoteService.change_time_estimate(issuable, issuable.project, current_user)
    end

    def create_time_spent_note
      SystemNoteService.change_time_spent(issuable, issuable.project, issuable.time_spent_user)
    end

    def create_milestone_change_event(old_milestone)
      ResourceEvents::ChangeMilestoneService.new(issuable, current_user, old_milestone: old_milestone)
        .execute
    end

    def create_start_date_or_due_date_note(changed_dates)
      return if changed_dates.blank?

      SystemNoteService.change_start_date_or_due_date(issuable, issuable.project, current_user, changed_dates)
    end

    def create_discussion_lock_note
      SystemNoteService.discussion_lock(issuable, current_user)
    end
  end
end

Issuable::CommonSystemNotesService.prepend_mod_with('Issuable::CommonSystemNotesService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issuable::CommonSystemNotesService, feature_category: :team_planning do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }

  let(:issuable) { create(:issue, project: project) }

  shared_examples 'system note for issuable date changes' do
    it 'creates a system note for due_date set' do
      issuable.update!(due_date: Date.today)

      expect { subject }.to change(issuable.notes, :count).from(0).to(1)
      expect(issuable.notes.last.note).to match('changed due date to')
    end

    it 'creates a system note for start_date set' do
      issuable.update!(start_date: Date.today)

      expect { subject }.to change(issuable.notes, :count).from(0).to(1)
      expect(issuable.notes.last.note).to match('changed start date to')
    end

    it 'creates a note when both start and due date are changed' do
      issuable.update!(start_date: Date.today, due_date: 1.week.from_now)

      expect { subject }.to change { issuable.notes.count }.from(0).to(1)
      expect(issuable.notes.last.note).to match(/changed start date to.+and changed due date to/)
    end

    it 'does not call SystemNoteService if no dates are changed' do
      issuable.update!(title: 'new title')

      expect(SystemNoteService).not_to receive(:change_start_date_or_due_date)

      subject
    end
  end

  context 'on issuable update' do
    it_behaves_like 'system note creation', { title: 'New title' }, 'changed title'
    it_behaves_like 'system note creation', { description: 'New description' }, 'changed the description'
    it_behaves_like 'system note creation', { discussion_locked: true }, 'locked the discussion in this issue'
    it_behaves_like 'system note creation', { time_estimate: 5 }, 'changed time estimate'

    context 'when new label is added' do
      let(:label) { create(:label, project: project) }

      before do
        issuable.labels << label
        issuable.save!
      end

      it 'creates a resource label event' do
        described_class.new(project: project, current_user: user).execute(issuable, old_labels: [])
        event = issuable.reload.resource_label_events.last

        expect(event).not_to be_nil
        expect(event.label_id).to eq label.id
        expect(event.user_id).to eq user.id
      end
    end

    context 'with merge requests Draft note' do
      context 'adding Draft note' do
        let(:issuable) { create(:merge_request, title: ""merge request"") }

        it_behaves_like 'system note creation', { title: ""Draft: merge request"" }, 'marked this merge request as **draft**'

        context 'and changing title' do
          before do
            issuable.update_attribute(:title, ""Draft: changed title"")
          end

          it_behaves_like 'draft notes creation', 'draft'
        end
      end

      context 'removing Draft note' do
        let(:issuable) { create(:merge_request, title: ""Draft: merge request"") }

        it_behaves_like 'system note creation', { title: ""merge request"" }, 'marked this merge request as **ready**'

        context 'and changing title' do
          before do
            issuable.update_attribute(:title, ""changed title"")
          end

          it_behaves_like 'draft notes creation', 'ready'
        end
      end
    end

    context 'when changing dates' do
      it_behaves_like 'system note for issuable date changes' do
        subject { described_class.new(project: project, current_user: user).execute(issuable) }
      end
    end
  end

  context 'on issuable create' do
    let(:issuable) { build(:issue, project: project) }

    subject { described_class.new(project: project, current_user: user).execute(issuable, old_labels: [], is_update: false) }

    it 'does not create system note for title and description' do
      issuable.save!

      expect { subject }.not_to change { issuable.notes.count }
    end

    it 'creates a resource label event for labels added' do
      label = create(:label, project: project)

      issuable.labels << label
      issuable.save!

      expect { subject }.to change { issuable.resource_label_events.count }.from(0).to(1)

      event = issuable.reload.resource_label_events.last

      expect(event).not_to be_nil
      expect(event.label_id).to eq label.id
      expect(event.user_id).to eq user.id
    end

    context 'when changing milestones' do
      let_it_be(:milestone) { create(:milestone, project: project) }
      let_it_be(:issuable) { create(:issue, project: project, milestone: milestone) }

      it 'does not create a system note for milestone set' do
        expect { subject }.not_to change { issuable.notes.count }
      end

      it 'creates a milestone change event' do
        expect { subject }.to change { ResourceMilestoneEvent.count }.from(0).to(1)
      end
    end

    context 'when changing dates' do
      it_behaves_like 'system note for issuable date changes'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Issuable
  class DestroyService < IssuableBaseService
    # TODO: this is to be removed once we get to rename the IssuableBaseService project param to container
    def initialize(container:, current_user: nil, params: {})
      super(container: container, current_user: current_user, params: params)
    end

    def execute(issuable)
      before_destroy(issuable)
      after_destroy(issuable) if issuable.destroy
    end

    private

    # overriden in EE
    def before_destroy(issuable); end

    def after_destroy(issuable)
      delete_associated_records(issuable)
      issuable.update_project_counter_caches
      issuable.assignees.each(&:invalidate_cache_counts)
    end

    def group_for(issuable)
      issuable.resource_parent.group
    end

    def delete_associated_records(issuable)
      actor = group_for(issuable)

      delete_todos(actor, issuable)
      delete_label_links(actor, issuable)
    end

    def delete_todos(actor, issuable)
      issuable.run_after_commit_or_now do
        TodosDestroyer::DestroyedIssuableWorker.perform_async(issuable.id, issuable.class.name)
      end
    end

    def delete_label_links(actor, issuable)
      issuable.run_after_commit_or_now do
        Issuable::LabelLinksDestroyWorker.perform_async(issuable.id, issuable.class.name)
      end
    end
  end
end

Issuable::DestroyService.prepend_mod_with('Issuable::DestroyService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issuable::DestroyService, feature_category: :team_planning do
  let(:user) { create(:user) }
  let(:group) { create(:group, :public) }
  let(:project) { create(:project, :public, group: group) }

  subject(:service) { described_class.new(container: project, current_user: user) }

  describe '#execute' do
    context 'when issuable is an issue' do
      let!(:issue) { create(:issue, project: project, author: user, assignees: [user]) }

      it 'destroys the issue' do
        expect { service.execute(issue) }.to change { project.issues.count }.by(-1)
      end

      it 'updates open issues count cache' do
        expect_any_instance_of(Projects::OpenIssuesCountService).to receive(:refresh_cache)

        service.execute(issue)
      end

      it 'invalidates the issues count cache for the assignees' do
        expect_any_instance_of(User).to receive(:invalidate_cache_counts).once
        service.execute(issue)
      end

      it_behaves_like 'service deleting todos' do
        let(:issuable) { issue }
      end

      it_behaves_like 'service deleting label links' do
        let(:issuable) { issue }
      end
    end

    context 'when issuable is a merge request' do
      let!(:merge_request) { create(:merge_request, target_project: project, source_project: project, author: user, assignees: [user]) }

      it 'destroys the merge request' do
        expect { service.execute(merge_request) }.to change { project.merge_requests.count }.by(-1)
      end

      it 'updates open merge requests count cache' do
        expect_any_instance_of(Projects::OpenMergeRequestsCountService).to receive(:refresh_cache)

        service.execute(merge_request)
      end

      it 'invalidates the merge request caches for the MR assignee' do
        expect_any_instance_of(User).to receive(:invalidate_cache_counts).once
        service.execute(merge_request)
      end

      it_behaves_like 'service deleting todos' do
        let(:issuable) { merge_request }
      end

      it_behaves_like 'service deleting label links' do
        let(:issuable) { merge_request }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# This service return notes grouped by discussion ID and paginated per discussion.
# System notes also have a discussion ID assigned including Synthetic system notes.
module Issuable
  class DiscussionsListService
    include Gitlab::Utils::StrongMemoize

    attr_reader :current_user, :issuable, :params

    def initialize(current_user, issuable, params = {})
      @current_user = current_user
      @issuable = issuable
      @params = params.dup
    end

    def execute
      return Note.none unless can_read_issuable_notes?

      notes = NotesFinder.new(current_user, params.merge({ target: issuable, project: issuable.project }))
                .execute.with_web_entity_associations.inc_relations_for_view(issuable).fresh

      if paginator
        paginated_discussions_by_type = paginator.records.group_by(&:table_name)

        notes = if paginated_discussions_by_type['notes'].present?
                  notes.id_in(paginated_discussions_by_type['notes'].flat_map(&:ids))
                else
                  notes.none
                end
      end

      if params[:notes_filter] != UserPreference::NOTES_FILTERS[:only_comments]
        notes = ResourceEvents::MergeIntoNotesService.new(
          issuable, current_user, paginated_notes: paginated_discussions_by_type
        ).execute(notes)
      end

      # Here we assume all notes belong to the same project as the work item
      project = notes.first&.project
      notes = ::Preloaders::Projects::NotesPreloader.new(project, current_user).call(notes)

      # we need to check the permission on every note, because some system notes for instance can have references to
      # resources that some user do not have read access, so those notes are filtered out from the list of notes.
      # see Note#all_referenced_mentionables_allowed?
      notes = notes.select { |n| n.readable_by?(current_user) }

      Discussion.build_collection(notes, issuable)
    end

    def paginator
      return if params[:per_page].blank?

      strong_memoize(:paginator) do
        issuable
          .discussion_root_note_ids(notes_filter: params[:notes_filter])
          .keyset_paginate(cursor: params[:cursor], per_page: params[:per_page].to_i)
      end
    end

    def can_read_issuable_notes?
      return Ability.allowed?(current_user, :read_security_resource, issuable) if issuable.is_a?(Vulnerability)

      Ability.allowed?(current_user, :""read_#{issuable.to_ability_name}"", issuable) &&
        Ability.allowed?(current_user, :read_note, issuable)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issuable::DiscussionsListService, feature_category: :team_planning do
  let_it_be(:current_user) { create(:user) }
  let_it_be(:group) { create(:group, :private) }
  let_it_be(:project) { create(:project, :repository, :private, group: group) }
  let_it_be(:milestone) { create(:milestone, project: project) }
  let_it_be(:label) { create(:label, project: project) }
  let_it_be(:label_2) { create(:label, project: project) }

  let(:finder_params_for_issuable) { {} }

  subject(:discussions_service) { described_class.new(current_user, issuable, finder_params_for_issuable) }

  describe 'fetching notes for issue' do
    let_it_be(:issuable) { create(:issue, project: project) }

    it_behaves_like 'listing issuable discussions', :guest, 1, 7

    context 'without notes widget' do
      let_it_be(:issuable) { create(:work_item, project: project) }

      before do
        WorkItems::Type.default_by_type(:issue).widget_definitions.find_by_widget_type(:notes).update!(disabled: true)
      end

      it ""returns no notes"" do
        expect(discussions_service.execute).to be_empty
      end
    end

    context 'when issue exists at the group level' do
      let_it_be(:issuable) { create(:issue, :group_level, namespace: group) }

      it_behaves_like 'listing issuable discussions', :guest, 1, 7
    end
  end

  describe 'fetching notes for merge requests' do
    let_it_be(:issuable) { create(:merge_request, source_project: project, target_project: project) }

    it_behaves_like 'listing issuable discussions', :reporter, 0, 6
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# This follows the rules specified in the specs.
# See spec/requests/api/graphql/mutations/merge_requests/set_assignees_spec.rb

module Issuable
  class ProcessAssignees
    def initialize(assignee_ids:, add_assignee_ids:, remove_assignee_ids:, existing_assignee_ids: nil, extra_assignee_ids: nil)
      @assignee_ids = assignee_ids&.map(&:to_i)
      @add_assignee_ids = add_assignee_ids&.map(&:to_i)
      @remove_assignee_ids = remove_assignee_ids&.map(&:to_i)
      @existing_assignee_ids = existing_assignee_ids&.map(&:to_i) || []
      @extra_assignee_ids = extra_assignee_ids&.map(&:to_i) || []
    end

    def execute
      updated_new_assignees = new_assignee_ids

      if add_assignee_ids.blank? && remove_assignee_ids.blank?
        updated_new_assignees = assignee_ids if assignee_ids
      else
        updated_new_assignees |= add_assignee_ids if add_assignee_ids
        updated_new_assignees -= remove_assignee_ids if remove_assignee_ids
      end

      updated_new_assignees.uniq
    end

    private

    attr_accessor :assignee_ids, :add_assignee_ids, :remove_assignee_ids, :existing_assignee_ids, :extra_assignee_ids

    def new_assignee_ids
      existing_assignee_ids | extra_assignee_ids
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issuable::ProcessAssignees, feature_category: :team_planning do
  describe '#execute' do
    it 'returns assignee_ids when add_assignee_ids and remove_assignee_ids are not specified' do
      process = described_class.new(
        assignee_ids: %w[5 7 9],
        add_assignee_ids: nil,
        remove_assignee_ids: nil,
        existing_assignee_ids: %w[1 3 9],
        extra_assignee_ids: %w[2 5 12]
      )
      result = process.execute

      expect(result).to contain_exactly(5, 7, 9)
    end

    it 'combines other ids when assignee_ids is nil' do
      process = described_class.new(
        assignee_ids: nil,
        add_assignee_ids: nil,
        remove_assignee_ids: nil,
        existing_assignee_ids: %w[1 3 11],
        extra_assignee_ids: %w[2 5 12]
      )
      result = process.execute

      expect(result).to contain_exactly(1, 2, 3, 5, 11, 12)
    end

    it 'combines other ids when both add_assignee_ids and remove_assignee_ids are not empty' do
      process = described_class.new(
        assignee_ids: %w[5 7 9],
        add_assignee_ids: %w[2 4 6],
        remove_assignee_ids: %w[4 7 11],
        existing_assignee_ids: %w[1 3 11],
        extra_assignee_ids: %w[2 5 12]
      )
      result = process.execute

      expect(result).to contain_exactly(1, 2, 3, 5, 6, 12)
    end

    it 'combines other ids when remove_assignee_ids is not empty' do
      process = described_class.new(
        assignee_ids: %w[5 7 9],
        add_assignee_ids: nil,
        remove_assignee_ids: %w[4 7 11],
        existing_assignee_ids: %w[1 3 11],
        extra_assignee_ids: %w[2 5 12]
      )
      result = process.execute

      expect(result).to contain_exactly(1, 2, 3, 5, 12)
    end

    it 'combines other ids when add_assignee_ids is not empty' do
      process = described_class.new(
        assignee_ids: %w[5 7 9],
        add_assignee_ids: %w[2 4 6],
        remove_assignee_ids: nil,
        existing_assignee_ids: %w[1 3 11],
        extra_assignee_ids: %w[2 5 12]
      )
      result = process.execute

      expect(result).to contain_exactly(1, 2, 4, 3, 5, 6, 11, 12)
    end

    it 'combines ids when existing_assignee_ids and extra_assignee_ids are omitted' do
      process = described_class.new(
        assignee_ids: %w[5 7 9],
        add_assignee_ids: %w[2 4 6],
        remove_assignee_ids: %w[4 7 11]
      )
      result = process.execute

      expect(result.sort).to eq([2, 6].sort)
    end

    it 'handles mixed string and integer arrays' do
      process = described_class.new(
        assignee_ids: %w[5 7 9],
        add_assignee_ids: [2, 4, 6],
        remove_assignee_ids: %w[4 7 11],
        existing_assignee_ids: [1, 3, 11],
        extra_assignee_ids: %w[2 5 12]
      )
      result = process.execute

      expect(result).to contain_exactly(1, 2, 3, 5, 6, 12)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Issuable
  class BulkUpdateService
    include Gitlab::Allowable

    attr_accessor :parent, :current_user, :params

    def initialize(parent, user = nil, params = {})
      @parent = parent
      @current_user = user
      @params = params.dup
    end

    def execute(type)
      model_ids = ids_from_params(params.delete(:issuable_ids))
      set_update_params(type)
      updated_issuables = update_issuables(type, model_ids)

      if updated_issuables.present? && requires_count_cache_reset?(type)
        schedule_group_issues_count_reset(updated_issuables)
      end

      response_success(payload: { count: updated_issuables.size })
    rescue ArgumentError => e
      response_error(e.message, 422)
    end

    private

    def ids_from_params(issuable_ids)
      return issuable_ids if issuable_ids.is_a?(Array)

      issuable_ids.split(',')
    end

    def set_update_params(type)
      params.slice!(*permitted_attrs(type))

      if params[:assignee_ids] == [IssuableFinder::Params::NONE.to_s]
        params[:assignee_ids] = []
      end
    end

    def permitted_attrs(type)
      attrs = %i[state_event milestone_id add_label_ids remove_label_ids subscription_event]

      if type == 'issue'
        attrs.push(:assignee_ids, :confidential)
      elsif type == 'merge_request'
        attrs.push(:assignee_ids)
      else
        attrs.push(:assignee_id)
      end
    end

    def update_issuables(type, ids)
      model_class = type.classify.constantize
      update_class = type.classify.pluralize.constantize::UpdateService
      items = find_issuables(parent, model_class, ids)
      authorized_issuables = []

      items.each do |issuable|
        next unless can?(current_user, :""update_#{type}"", issuable)

        authorized_issuables << issuable
        update_class.new(
          **update_class.constructor_container_arg(issuable.issuing_parent),
          current_user: current_user,
          params: dup_params
        ).execute(issuable)
      end

      authorized_issuables
    end

    def find_issuables(parent, model_class, ids)
      issuables = model_class.id_in(ids)

      case parent
      when Project
        issuables = issuables.of_projects(parent)
      when Group
        issuables = issuables.of_projects(parent.all_projects)
      else
        raise ArgumentError, _('A parent must be provided when bulk updating issuables')
      end

      issuables.includes_for_bulk_update
    end

    # Duplicates params and its top-level values
    # We cannot use deep_dup because ActiveRecord objects will result
    # to new records with no id assigned
    def dup_params
      dup = HashWithIndifferentAccess.new

      params.each do |key, value|
        dup[key] = value.is_a?(ActiveRecord::Base) ? value : value.dup
      end

      dup
    end

    def response_success(message: nil, payload: nil)
      ServiceResponse.success(message: message, payload: payload)
    end

    def response_error(message, http_status)
      ServiceResponse.error(message: message, http_status: http_status)
    end

    def requires_count_cache_reset?(type)
      type.to_sym == :issue && params.include?(:state_event)
    end

    def schedule_group_issues_count_reset(updated_issuables)
      group_ids = updated_issuables.map(&:project).map(&:namespace_id)
      return if group_ids.empty?

      Issuables::ClearGroupsIssueCounterWorker.perform_async(group_ids)
    end
  end
end

Issuable::BulkUpdateService.prepend_mod_with('Issuable::BulkUpdateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issuable::BulkUpdateService, feature_category: :team_planning do
  let_it_be(:user)    { create(:user) }
  let_it_be(:project) { create(:project, :repository, namespace: user.namespace) }

  def bulk_update(issuables, extra_params = {})
    bulk_update_params = extra_params
      .reverse_merge(issuable_ids: Array(issuables).map(&:id).join(','))

    type = Array(issuables).first.model_name.param_key
    Issuable::BulkUpdateService.new(parent, user, bulk_update_params).execute(type)
  end

  shared_examples 'updates milestones' do
    it 'succeeds' do
      result = bulk_update(issuables, milestone_id: milestone.id)

      expect(result.success?).to be_truthy
      expect(result.payload[:count]).to eq(issuables.count)
    end

    it 'updates the issuables milestone' do
      bulk_update(issuables, milestone_id: milestone.id)

      issuables.each do |issuable|
        expect(issuable.reload.milestone).to eq(milestone)
      end
    end
  end

  shared_examples 'updates confidentiality' do
    it 'succeeds' do
      result = bulk_update(issuables, confidential: true)

      expect(result.success?).to be_truthy
      expect(result.payload[:count]).to eq(issuables.count)
    end

    it 'updates the issuables confidentiality' do
      bulk_update(issuables, confidential: true)

      issuables.each do |issuable|
        expect(issuable.reload.confidential).to be(true)
      end
    end
  end

  shared_examples 'updating labels' do
    def create_issue_with_labels(labels)
      create(:labeled_issue, project: project, labels: labels)
    end

    let(:issue_all_labels) { create_issue_with_labels([bug, regression, merge_requests]) }
    let(:issue_bug_and_regression) { create_issue_with_labels([bug, regression]) }
    let(:issue_bug_and_merge_requests) { create_issue_with_labels([bug, merge_requests]) }
    let(:issue_no_labels) { create(:issue, project: project) }
    let(:issues) { [issue_all_labels, issue_bug_and_regression, issue_bug_and_merge_requests, issue_no_labels] }

    let(:add_labels) { [] }
    let(:remove_labels) { [] }

    let(:bulk_update_params) do
      {
        add_label_ids: add_labels.map(&:id),
        remove_label_ids: remove_labels.map(&:id)
      }
    end

    before do
      bulk_update(issues, bulk_update_params)
    end

    context 'when add_label_ids are passed' do
      let(:issues) { [issue_all_labels, issue_bug_and_merge_requests, issue_no_labels] }
      let(:add_labels) { [bug, regression, merge_requests] }

      it 'adds those label IDs to all issues passed' do
        expect(issues.map(&:reload).map(&:label_ids)).to all(include(*add_labels.map(&:id)))
      end

      it 'does not update issues not passed in' do
        expect(issue_bug_and_regression.label_ids).to contain_exactly(bug.id, regression.id)
      end
    end

    context 'when remove_label_ids are passed' do
      let(:issues) { [issue_all_labels, issue_bug_and_merge_requests, issue_no_labels] }
      let(:remove_labels) { [bug, regression, merge_requests] }

      it 'removes those label IDs from all issues passed' do
        expect(issues.map(&:reload).map(&:label_ids)).to all(be_empty)
      end

      it 'does not update issues not passed in' do
        expect(issue_bug_and_regression.label_ids).to contain_exactly(bug.id, regression.id)
      end
    end

    context 'when add_label_ids and remove_label_ids are passed' do
      let(:issues) { [issue_all_labels, issue_bug_and_merge_requests, issue_no_labels] }
      let(:add_labels) { [bug] }
      let(:remove_labels) { [merge_requests] }

      it 'adds the label IDs to all issues passed' do
        expect(issues.map(&:reload).map(&:label_ids)).to all(include(bug.id))
      end

      it 'removes the label IDs from all issues passed' do
        expect(issues.map(&:reload).flat_map(&:label_ids)).not_to include(merge_requests.id)
      end

      it 'does not update issues not passed in' do
        expect(issue_bug_and_regression.label_ids).to contain_exactly(bug.id, regression.id)
      end
    end
  end

  shared_examples 'scheduling cached group count clear' do
    it 'schedules worker' do
      expect(Issuables::ClearGroupsIssueCounterWorker).to receive(:perform_async)

      bulk_update(issuables, params)
    end
  end

  shared_examples 'not scheduling cached group count clear' do
    it 'does not schedule worker' do
      expect(Issuables::ClearGroupsIssueCounterWorker).not_to receive(:perform_async)

      bulk_update(issuables, params)
    end
  end

  shared_examples 'bulk update service' do
    it 'result count only includes authorized issuables' do
      all_issues = issues + [create(:issue, project: create(:project, :private))]
      result = bulk_update(all_issues, { assignee_ids: [user.id] })

      expect(result[:count]).to eq(issues.count)
    end

    context 'when issuable_ids are passed as an array' do
      it 'updates assignees' do
        expect do
          described_class.new(
            parent,
            user,
            { issuable_ids: issues.map(&:id), assignee_ids: [user.id] }
          ).execute('issue')

          issues.each(&:reset)
        end.to change { issues.flat_map(&:assignee_ids) }.from([]).to([user.id] * 2)
      end
    end
  end

  context 'with issuables at a project level' do
    let_it_be_with_reload(:issues) { create_list(:issue, 2, project: project) }

    let(:parent) { project }

    it_behaves_like 'bulk update service'

    context 'with unpermitted attributes' do
      let(:label) { create(:label, project: project) }

      it 'does not update the issues' do
        bulk_update(issues, label_ids: [label.id])

        expect(issues.map(&:reload).map(&:label_ids)).not_to include(label.id)
      end
    end

    context 'when issuable update service raises an ArgumentError' do
      before do
        allow_next_instance_of(Issues::UpdateService) do |update_service|
          allow(update_service).to receive(:execute).and_raise(ArgumentError, 'update error')
        end
      end

      it 'returns an error response' do
        result = bulk_update(issues, add_label_ids: [])

        expect(result).to be_error
        expect(result.errors).to contain_exactly('update error')
        expect(result.http_status).to eq(422)
      end
    end

    describe 'close issues' do
      it 'succeeds and returns the correct number of issues updated' do
        result = bulk_update(issues, state_event: 'close')

        expect(result.success?).to be_truthy
        expect(result.payload[:count]).to eq(issues.count)
      end

      it 'closes all the issues passed' do
        bulk_update(issues, state_event: 'close')

        expect(project.issues.opened).to be_empty
        expect(project.issues.closed).not_to be_empty
      end

      it_behaves_like 'scheduling cached group count clear' do
        let(:issuables) { issues }
        let(:params) { { state_event: 'close' } }
      end
    end

    describe 'reopen issues' do
      let_it_be_with_reload(:closed_issues) { create_list(:closed_issue, 2, project: project) }

      it 'succeeds and returns the correct number of issues updated' do
        result = bulk_update(closed_issues, state_event: 'reopen')

        expect(result.success?).to be_truthy
        expect(result.payload[:count]).to eq(closed_issues.count)
      end

      it 'reopens all the issues passed' do
        bulk_update(closed_issues, state_event: 'reopen')

        expect(project.issues.closed).to be_empty
        expect(project.issues.opened).not_to be_empty
      end

      it_behaves_like 'scheduling cached group count clear' do
        let(:issuables) { closed_issues }
        let(:params) { { state_event: 'reopen' } }
      end
    end

    describe 'updating merge request assignee' do
      let(:merge_request) { create(:merge_request, target_project: project, source_project: project, assignees: [user]) }

      context 'when the new assignee ID is a valid user' do
        it 'succeeds' do
          new_assignee = create(:user)
          project.add_developer(new_assignee)

          result = bulk_update(merge_request, assignee_ids: [user.id, new_assignee.id])

          expect(result.success?).to be_truthy
          expect(result.payload[:count]).to eq(1)
        end

        it 'updates the assignee to the user ID passed' do
          assignee = create(:user)
          project.add_developer(assignee)

          expect { bulk_update(merge_request, assignee_ids: [assignee.id]) }
            .to change { merge_request.reload.assignee_ids }.from([user.id]).to([assignee.id])
        end
      end

      context ""when the new assignee ID is #{IssuableFinder::Params::NONE}"" do
        it 'unassigns the issues' do
          expect { bulk_update(merge_request, assignee_ids: [IssuableFinder::Params::NONE]) }
            .to change { merge_request.reload.assignee_ids }.to([])
        end
      end

      context 'when the new assignee IDs array is empty' do
        it 'removes all assignees' do
          expect { bulk_update(merge_request, assignee_ids: []) }
            .to change(merge_request.assignees, :count).by(-1)
        end
      end
    end

    describe 'updating issue assignee' do
      let(:issue) { create(:issue, project: project, assignees: [user]) }

      context 'when the new assignee ID is a valid user' do
        it 'succeeds' do
          new_assignee = create(:user)
          project.add_developer(new_assignee)

          result = bulk_update(issue, assignee_ids: [new_assignee.id])

          expect(result.success?).to be_truthy
          expect(result.payload[:count]).to eq(1)
        end

        it 'updates the assignee to the user ID passed' do
          assignee = create(:user)
          project.add_developer(assignee)
          expect { bulk_update(issue, assignee_ids: [assignee.id]) }
            .to change { issue.reload.assignees.first }.from(user).to(assignee)
        end
      end

      context ""when the new assignee ID is #{IssuableFinder::Params::NONE}"" do
        it ""unassigns the issues"" do
          expect { bulk_update(issue, assignee_ids: [IssuableFinder::Params::NONE.to_s]) }
            .to change { issue.reload.assignees.count }.from(1).to(0)
        end
      end

      context 'when the new assignee IDs array is empty' do
        it 'removes all assignees' do
          expect { bulk_update(issue, assignee_ids: []) }
            .to change(issue.assignees, :count).by(-1)
        end
      end
    end

    describe 'updating milestones' do
      let(:issuables) { [create(:issue, project: project)] }
      let(:milestone) { create(:milestone, project: project) }

      it_behaves_like 'updates milestones'

      it_behaves_like 'not scheduling cached group count clear' do
        let(:params) { { milestone_id: milestone.id } }
      end
    end

    describe 'updating confidentiality' do
      let(:issuables) { create_list(:issue, 2, project: project) }

      it_behaves_like 'updates confidentiality'

      it_behaves_like 'not scheduling cached group count clear' do
        let(:params) { { confidential: true } }
      end
    end

    describe 'updating labels' do
      let(:bug) { create(:label, project: project) }
      let(:regression) { create(:label, project: project) }
      let(:merge_requests) { create(:label, project: project) }

      it_behaves_like 'updating labels'
    end

    describe 'subscribe to issues' do
      let(:issues) { create_list(:issue, 2, project: project) }

      it 'subscribes the given user' do
        bulk_update(issues, subscription_event: 'subscribe')

        expect(issues).to all(be_subscribed(user, project))
      end
    end

    describe 'unsubscribe from issues' do
      let(:issues) do
        create_list(:closed_issue, 2, project: project) do |issue|
          issue.subscriptions.create!(user: user, project: project, subscribed: true)
        end
      end

      it 'unsubscribes the given user' do
        bulk_update(issues, subscription_event: 'unsubscribe')

        issues.each do |issue|
          expect(issue).not_to be_subscribed(user, project)
        end
      end
    end

    describe 'updating issues from external project' do
      it 'updates only issues that belong to the parent project' do
        issue1 = create(:issue, project: project)
        issue2 = create(:issue, project: create(:project))
        result = bulk_update([issue1, issue2], assignee_ids: [user.id])

        expect(result.success?).to be_truthy
        expect(result.payload[:count]).to eq(1)

        expect(issue1.reload.assignees).to eq([user])
        expect(issue2.reload.assignees).to be_empty
      end
    end
  end

  context 'with issuables at a group level' do
    let_it_be(:group) { create(:group) }

    let(:parent) { group }

    before do
      group.add_reporter(user)
    end

    it_behaves_like 'bulk update service' do
      let_it_be_with_reload(:issues) { create_list(:issue, 2, project: create(:project, group: group)) }
    end

    describe 'updating milestones' do
      let(:milestone) { create(:milestone, group: group) }
      let(:project)   { create(:project, :repository, group: group) }

      before do
        group.add_maintainer(user)
      end

      context 'when issues' do
        let(:issue1)    { create(:issue, project: project) }
        let(:issue2)    { create(:issue, project: project) }
        let(:issuables) { [issue1, issue2] }

        it_behaves_like 'updates milestones'
      end

      context 'when merge requests' do
        let(:merge_request1) { create(:merge_request, source_project: project, source_branch: 'branch-1') }
        let(:merge_request2) { create(:merge_request, source_project: project, source_branch: 'branch-2') }
        let(:issuables)      { [merge_request1, merge_request2] }

        it_behaves_like 'updates milestones'
      end
    end

    describe 'updating confidentiality' do
      let_it_be(:project) { create(:project, :repository, group: group) }

      before do
        group.add_maintainer(user)
      end

      context 'with issues' do
        let(:issuables) { create_list(:issue, 2, project: project) }

        it_behaves_like 'updates confidentiality'
      end

      context 'with merge requests' do
        let(:issuables) { [create(:merge_request, source_project: project, target_project: project)] }

        it 'does not throw an error' do
          result = bulk_update(issuables, confidential: true)

          expect(result.success?).to be_truthy
        end
      end
    end

    describe 'updating labels' do
      let(:project)        { create(:project, :repository, group: group) }
      let(:bug)            { create(:group_label, group: group) }
      let(:regression)     { create(:group_label, group: group) }
      let(:merge_requests) { create(:group_label, group: group) }

      it_behaves_like 'updating labels'
    end

    describe 'with issues from external group' do
      it 'updates issues that belong to the parent group or descendants' do
        issue1 = create(:issue, project: create(:project, group: group))
        issue2 = create(:issue, project: create(:project, group: create(:group)))
        issue3 = create(:issue, project: create(:project, group: create(:group, parent: group)))
        milestone = create(:milestone, group: group)
        result = bulk_update([issue1, issue2, issue3], milestone_id: milestone.id)

        expect(result.success?).to be_truthy
        expect(result.payload[:count]).to eq(2)

        expect(issue1.reload.milestone).to eq(milestone)
        expect(issue2.reload.milestone).to be_nil
        expect(issue3.reload.milestone).to eq(milestone)
      end
    end
  end

  context 'when no parent is provided' do
    it 'returns an unscoped update error' do
      result = described_class.new(nil, user, { assignee_ids: [user.id], issuable_ids: [] }).execute('issue')

      expect(result).to be_error
      expect(result.errors).to contain_exactly(_('A parent must be provided when bulk updating issuables'))
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Issuable
  module ImportCsv
    class BaseService < ::ImportCsv::BaseService
      extend ::Gitlab::Utils::Override

      private

      override :attributes_for
      def attributes_for(row)
        {
          title: row[:title],
          description: row[:description],
          due_date: row[:due_date],
          milestone_id: find_milestone_by_title(row[:milestone])
        }
      end

      override :validate_headers_presence!
      def validate_headers_presence!(headers)
        headers.downcase! if headers
        return if headers && headers.include?('title') && headers.include?('description')

        raise CSV::MalformedCSVError.new('Invalid CSV format - missing required headers.', 1)
      end

      def preprocess!
        preprocess_milestones!

        raise PreprocessError if results[:preprocess_errors].any?
      end

      def preprocess_milestones!
        # Pre-Process Milestone if header is present
        return unless csv_data.lines.first.downcase.include?('milestone')

        provided_titles = with_csv_lines.filter_map { |row| row[:milestone]&.strip }.uniq
        result = ::ImportCsv::PreprocessMilestonesService.new(user, project, provided_titles).execute
        @available_milestones = result.payload
        return if result.success?

        # collate errors here and throw errors
        results[:preprocess_errors][:milestone_errors] = result.payload
      end

      def find_milestone_by_title(title)
        return unless title

        @available_milestones.find { |milestone| milestone.title == title.to_s.strip } if @available_milestones
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issuable::ImportCsv::BaseService, feature_category: :importers do
  let_it_be(:user) { create(:user) }
  let_it_be(:group) { create(:group) }
  let_it_be(:project) { create(:project, group: group) }
  let_it_be(:csv_io) { double }

  let(:importer_klass) do
    Class.new(described_class) do
      def email_results_to_user
        # no-op
      end
    end
  end

  let(:service) do
    uploader = FileUploader.new(project)
    uploader.store!(file)

    importer_klass.new(user, project, uploader)
  end

  subject { service.execute }

  describe '#preprocess_milestones' do
    let(:utility_class) { ImportCsv::PreprocessMilestonesService }
    let(:file) { fixture_file_upload('spec/fixtures/csv_missing_milestones.csv') }
    let(:mocked_object) { double }

    before do
      allow(service).to receive(:create_object).and_return(mocked_object)
      allow(mocked_object).to receive(:persisted?).and_return(true)
    end

    context 'with csv that has milestone heading' do
      before do
        allow(utility_class).to receive(:new).and_return(utility_class)
        allow(utility_class).to receive(:execute).and_return(ServiceResponse.success)
      end

      it 'calls PreprocessMilestonesService' do
        subject
        expect(utility_class).to have_received(:new)
      end

      it 'calls PreprocessMilestonesService with unique milestone titles' do
        subject
        expect(utility_class).to have_received(:new).with(user, project, %w[15.10 10.1])
        expect(utility_class).to have_received(:execute)
      end
    end

    context 'with csv that does not have milestone heading' do
      let(:file) { fixture_file_upload('spec/fixtures/work_items_valid_types.csv') }

      before do
        allow(utility_class).to receive(:new).and_return(utility_class)
      end

      it 'does not call PreprocessMilestonesService' do
        subject
        expect(utility_class).not_to have_received(:new)
      end
    end

    context 'when one or more milestones do not exist' do
      it 'returns the expected error in results payload' do
        results = subject

        expect(results[:success]).to eq(0)
        expect(results[:preprocess_errors]).to match({
          milestone_errors: { missing: { header: 'Milestone', titles: %w[15.10 10.1] } }
        })
      end
    end

    context 'when all milestones exist' do
      let!(:group_milestone) { create(:milestone, group: group, title: '10.1') }
      let!(:project_milestone) { create(:milestone, project: project, title: '15.10') }

      it 'returns a successful response' do
        results = subject

        expect(results[:preprocess_errors]).to be_empty
        expect(results[:success]).to eq(4)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Issuable
  module Callbacks
    class Milestone < Base
      ALLOWED_PARAMS = %i[milestone milestone_id skip_milestone_email].freeze

      def after_initialize
        params[:milestone_id] = nil if excluded_in_new_type?
        return unless params.key?(:milestone_id) && has_permission?(:""set_#{issuable.to_ability_name}_metadata"")

        @old_milestone = issuable.milestone

        if params[:milestone_id].blank? || params[:milestone_id].to_s == IssuableFinder::Params::NONE
          issuable.milestone = nil

          return
        end

        resource_group = issuable.project&.group || issuable.try(:namespace)
        project_ids = [issuable.project&.id].compact

        milestone = MilestonesFinder.new({
          project_ids: project_ids,
          group_ids: resource_group&.self_and_ancestors&.select(:id),
          ids: [params[:milestone_id]]
        }).execute.first

        issuable.milestone = milestone if milestone
      end

      def after_update_commit
        return unless issuable.previous_changes.include?('milestone_id')

        update_usage_data_counters
        send_milestone_change_notification

        GraphqlTriggers.issuable_milestone_updated(issuable)
      end

      def after_save_commit
        return unless issuable.previous_changes.include?('milestone_id')

        invalidate_milestone_counters
      end

      private

      def invalidate_milestone_counters
        [@old_milestone, issuable.milestone].compact.each do |milestone|
          case issuable
          when Issue
            ::Milestones::ClosedIssuesCountService.new(milestone).delete_cache
            ::Milestones::IssuesCountService.new(milestone).delete_cache
          when MergeRequest
            ::Milestones::MergeRequestsCountService.new(milestone).delete_cache
          end
        end
      end

      def update_usage_data_counters
        return unless issuable.is_a?(MergeRequest)

        Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter
          .track_milestone_changed_action(user: current_user)
      end

      def send_milestone_change_notification
        return if params[:skip_milestone_email]

        notification_service = NotificationService.new.async

        if issuable.milestone.nil?
          notification_service.removed_milestone(issuable, current_user)
        else
          notification_service.changed_milestone(issuable, issuable.milestone, current_user)
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issuable::Callbacks::Milestone, feature_category: :team_planning do
  let_it_be(:group) { create(:group) }
  let_it_be(:project) { create(:project, :private, group: group) }
  let_it_be(:project_milestone) { create(:milestone, project: project) }
  let_it_be(:group_milestone) { create(:milestone, group: group) }
  let_it_be(:reporter) do
    create(:user).tap { |u| project.add_reporter(u) }
  end

  let(:issuable) { build(:issue, project: project) }
  let(:current_user) { reporter }
  let(:params) { { milestone_id: project_milestone.id } }
  let(:callback) { described_class.new(issuable: issuable, current_user: current_user, params: params) }

  describe '#after_initialize' do
    it ""sets the issuable's milestone"" do
      expect { callback.after_initialize }.to change { issuable.milestone }.from(nil).to(project_milestone)
    end

    context 'when assigning a group milestone' do
      let(:params) { { milestone_id: group_milestone.id } }

      it ""sets the issuable's milestone"" do
        expect { callback.after_initialize }.to change { issuable.milestone }.from(nil).to(group_milestone)
      end
    end

    context 'when assigning a group milestone outside the project ancestors' do
      let(:another_group_milestone) { create(:milestone, group: create(:group)) }
      let(:params) { { milestone_id: another_group_milestone.id } }

      it ""does not change the issuable's milestone"" do
        expect { callback.after_initialize }.not_to change { issuable.milestone }
      end
    end

    context 'when user is not allowed to set issuable metadata' do
      let(:current_user) { create(:user) }

      it ""does not change the issuable's milestone"" do
        expect { callback.after_initialize }.not_to change { issuable.milestone }
      end
    end

    context 'when unsetting a milestone' do
      let(:issuable) { create(:issue, project: project, milestone: project_milestone) }

      context 'when milestone_id is nil' do
        let(:params) { { milestone_id: nil } }

        it ""unsets the issuable's milestone"" do
          expect { callback.after_initialize }.to change { issuable.milestone }.from(project_milestone).to(nil)
        end
      end

      context 'when milestone_id is an empty string' do
        let(:params) { { milestone_id: '' } }

        it ""unsets the issuable's milestone"" do
          expect { callback.after_initialize }.to change { issuable.milestone }.from(project_milestone).to(nil)
        end
      end

      context 'when milestone_id is 0' do
        let(:params) { { milestone_id: '0' } }

        it ""unsets the issuable's milestone"" do
          expect { callback.after_initialize }.to change { issuable.milestone }.from(project_milestone).to(nil)
        end
      end

      context ""when milestone_id is '0'"" do
        let(:params) { { milestone_id: 0 } }

        it ""unsets the issuable's milestone"" do
          expect { callback.after_initialize }.to change { issuable.milestone }.from(project_milestone).to(nil)
        end
      end

      context 'when milestone_id is not given' do
        let(:params) { {} }

        it ""does not unset the issuable's milestone"" do
          expect { callback.after_initialize }.not_to change { issuable.milestone }
        end
      end

      context 'when new type does not support milestones' do
        let(:params) { { excluded_in_new_type: true } }

        it ""unsets the issuable's milestone"" do
          expect { callback.after_initialize }.to change { issuable.milestone }.from(project_milestone).to(nil)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Namespaces
  class StatisticsRefresherService
    RefresherError = Class.new(StandardError)

    def execute(root_namespace)
      root_namespace = root_namespace.root_ancestor # just in case the true root isn't passed
      root_storage_statistics = find_or_create_root_storage_statistics(root_namespace.id)

      root_storage_statistics.recalculate!
    rescue ActiveRecord::ActiveRecordError => e
      raise RefresherError, e.message
    end

    private

    def find_or_create_root_storage_statistics(root_namespace_id)
      Namespace::RootStorageStatistics
        .safe_find_or_create_by!(namespace_id: root_namespace_id)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Namespaces::StatisticsRefresherService, '#execute', feature_category: :groups_and_projects do
  let(:group) { create(:group) }
  let(:subgroup) { create(:group, parent: group) }
  let(:projects) { create_list(:project, 5, namespace: group) }
  let(:service) { described_class.new }

  context 'without a root storage statistics relation' do
    it 'creates one' do
      expect do
        service.execute(group)
      end.to change(Namespace::RootStorageStatistics, :count).by(1)

      expect(group.reload.root_storage_statistics).to be_present
    end

    it 'recalculate the namespace statistics' do
      expect_next_instance_of(Namespace::RootStorageStatistics) do |instance|
        expect(instance).to receive(:recalculate!).once
      end

      service.execute(group)
    end

    context 'when given a subgroup' do
      it 'does not create statistics for the subgroup' do
        service.execute(subgroup)

        expect(subgroup.reload.root_storage_statistics).not_to be_present
      end
    end
  end

  context 'with a root storage statistics relation', :sidekiq_might_not_need_inline do
    before do
      Namespace::AggregationSchedule.safe_find_or_create_by!(namespace_id: group.id)
    end

    it 'does not create one' do
      expect do
        service.execute(group)
      end.not_to change(Namespace::RootStorageStatistics, :count)
    end

    it 'recalculate the namespace statistics' do
      expect(Namespace::RootStorageStatistics)
        .to receive(:safe_find_or_create_by!).with({ namespace_id: group.id })
        .and_return(group.root_storage_statistics)

      service.execute(group)
    end

    context 'when given a subgroup' do
      it ""recalculates the root namespace's statistics"" do
        expect(Namespace::RootStorageStatistics)
          .to receive(:safe_find_or_create_by!).with({ namespace_id: group.id })
          .and_return(group.root_storage_statistics)

        service.execute(subgroup)
      end
    end
  end

  context 'when something goes wrong' do
    before do
      allow_next_instance_of(Namespace::RootStorageStatistics) do |instance|
        allow(instance).to receive(:recalculate!).and_raise(ActiveRecord::ActiveRecordError)
      end
    end

    it 'raises RefreshError' do
      expect do
        service.execute(group)
      end.to raise_error(Namespaces::StatisticsRefresherService::RefresherError)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Namespaces
  module PackageSettings
    class UpdateService < BaseContainerService
      include Gitlab::Utils::StrongMemoize

      ALLOWED_ATTRIBUTES = %i[maven_duplicates_allowed
                              maven_duplicate_exception_regex
                              generic_duplicates_allowed
                              generic_duplicate_exception_regex
                              maven_package_requests_forwarding
                              nuget_duplicates_allowed
                              nuget_duplicate_exception_regex
                              npm_package_requests_forwarding
                              pypi_package_requests_forwarding
                              lock_maven_package_requests_forwarding
                              lock_npm_package_requests_forwarding
                              lock_pypi_package_requests_forwarding].freeze

      def execute
        return ServiceResponse.error(message: 'Access Denied', http_status: 403) unless allowed?

        if package_settings.update(package_settings_params)
          ServiceResponse.success(payload: { package_settings: package_settings })
        else
          ServiceResponse.error(
            message: package_settings.errors.full_messages.to_sentence || 'Bad request',
            http_status: 400
          )
        end
      end

      private

      def package_settings
        strong_memoize(:package_settings) do
          @container.package_settings
        end
      end

      def allowed?
        Ability.allowed?(current_user, :admin_package, @container)
      end

      def package_settings_params
        @params.slice(*ALLOWED_ATTRIBUTES)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Namespaces::PackageSettings::UpdateService, feature_category: :package_registry do
  using RSpec::Parameterized::TableSyntax

  let_it_be_with_reload(:namespace) { create(:group) }
  let_it_be(:user) { create(:user) }
  let_it_be(:params) { {} }

  describe '#execute' do
    subject { described_class.new(container: namespace, current_user: user, params: params).execute }

    shared_examples 'returning a success' do
      it 'returns a success' do
        result = subject

        expect(result.payload[:package_settings]).to be_present
        expect(result.success?).to be_truthy
      end
    end

    shared_examples 'returning an error' do |message, http_status|
      it 'returns an error' do
        result = subject

        expect(result.message).to eq(message)
        expect(result.status).to eq(:error)
        expect(result.http_status).to eq(http_status)
      end
    end

    shared_examples 'updating the namespace package setting' do
      it_behaves_like 'updating the namespace package setting attributes',
        from: {
          maven_duplicates_allowed: true,
          maven_duplicate_exception_regex: 'SNAPSHOT',
          generic_duplicates_allowed: true,
          generic_duplicate_exception_regex: 'foo',
          nuget_duplicates_allowed: true,
          nuget_duplicate_exception_regex: 'foo',
          maven_package_requests_forwarding: true,
          lock_maven_package_requests_forwarding: false,
          npm_package_requests_forwarding: nil,
          lock_npm_package_requests_forwarding: false,
          pypi_package_requests_forwarding: nil,
          lock_pypi_package_requests_forwarding: false
        }, to: {
          maven_duplicates_allowed: false,
          maven_duplicate_exception_regex: 'RELEASE',
          generic_duplicates_allowed: false,
          generic_duplicate_exception_regex: 'bar',
          nuget_duplicates_allowed: false,
          nuget_duplicate_exception_regex: 'bar',
          maven_package_requests_forwarding: true,
          lock_maven_package_requests_forwarding: true,
          npm_package_requests_forwarding: true,
          lock_npm_package_requests_forwarding: true,
          pypi_package_requests_forwarding: true,
          lock_pypi_package_requests_forwarding: true
        }

      it_behaves_like 'returning a success'

      context 'with invalid params' do
        let_it_be(:params) { { maven_duplicates_allowed: nil } }

        it_behaves_like 'not creating the namespace package setting'

        it ""doesn't update the maven_duplicates_allowed"" do
          expect { subject }
            .not_to change { package_settings.reload.maven_duplicates_allowed }
        end

        it_behaves_like 'returning an error', 'Maven duplicates allowed is not included in the list', 400
      end
    end

    shared_examples 'denying access to namespace package setting' do
      context 'with existing namespace package setting' do
        it_behaves_like 'not creating the namespace package setting'

        it_behaves_like 'returning an error', 'Access Denied', 403
      end
    end

    # To be removed when raise_group_admin_package_permission_to_owner FF is removed
    shared_examples 'disabling admin_package feature flag' do |action:|
      before do
        stub_feature_flags(raise_group_admin_package_permission_to_owner: false)
      end

      it_behaves_like ""#{action} the namespace package setting""
    end

    context 'with existing namespace package setting' do
      let_it_be(:package_settings) { create(:namespace_package_setting, namespace: namespace) }
      let_it_be(:params) do
        {
          maven_duplicates_allowed: false,
          maven_duplicate_exception_regex: 'RELEASE',
          generic_duplicates_allowed: false,
          generic_duplicate_exception_regex: 'bar',
          nuget_duplicates_allowed: false,
          nuget_duplicate_exception_regex: 'bar',
          maven_package_requests_forwarding: true,
          lock_maven_package_requests_forwarding: true,
          npm_package_requests_forwarding: true,
          lock_npm_package_requests_forwarding: true,
          pypi_package_requests_forwarding: true,
          lock_pypi_package_requests_forwarding: true
        }
      end

      where(:user_role, :shared_examples_name) do
        :owner      | 'updating the namespace package setting'
        :maintainer | 'denying access to namespace package setting'
        :developer  | 'denying access to namespace package setting'
        :reporter   | 'denying access to namespace package setting'
        :guest      | 'denying access to namespace package setting'
        :anonymous  | 'denying access to namespace package setting'
      end

      with_them do
        before do
          namespace.send(""add_#{user_role}"", user) unless user_role == :anonymous
        end

        it_behaves_like params[:shared_examples_name]
        it_behaves_like 'disabling admin_package feature flag', action: :updating if params[:user_role] == :maintainer
      end
    end

    context 'without existing namespace package setting' do
      let_it_be(:package_settings) { namespace.package_settings }

      where(:user_role, :shared_examples_name) do
        :owner      | 'creating the namespace package setting'
        :maintainer | 'denying access to namespace package setting'
        :developer  | 'denying access to namespace package setting'
        :reporter   | 'denying access to namespace package setting'
        :guest      | 'denying access to namespace package setting'
        :anonymous  | 'denying access to namespace package setting'
      end

      with_them do
        before do
          namespace.send(""add_#{user_role}"", user) unless user_role == :anonymous
        end

        it_behaves_like params[:shared_examples_name]
        it_behaves_like 'disabling admin_package feature flag', action: :creating if params[:user_role] == :maintainer
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module TestHooks
  class ProjectService < TestHooks::BaseService
    include Integrations::ProjectTestData
    include Gitlab::Utils::StrongMemoize

    attr_writer :project

    def project
      @project ||= hook.project
    end

    private

    def data
      strong_memoize(:data) do
        case trigger
        when 'push_events', 'tag_push_events'
          push_events_data
        when 'note_events'
          note_events_data
        when 'issues_events', 'confidential_issues_events'
          issues_events_data
        when 'merge_requests_events'
          merge_requests_events_data
        when 'job_events'
          job_events_data
        when 'pipeline_events'
          pipeline_events_data
        when 'wiki_page_events'
          wiki_page_events_data
        when 'releases_events'
          releases_events_data
        when 'emoji_events'
          emoji_events_data
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe TestHooks::ProjectService, feature_category: :code_testing do
  include AfterNextHelpers

  let(:current_user) { create(:user) }

  describe '#execute' do
    let_it_be(:project) { create(:project, :repository) }

    let(:hook) { create(:project_hook, project: project) }
    let(:trigger) { 'not_implemented_events' }
    let(:service) { described_class.new(hook, current_user, trigger) }
    let(:sample_data) { { data: 'sample' } }
    let(:success_result) { { status: :success, http_status: 200, message: 'ok' } }

    it 'allows to set a custom project' do
      project = double
      service.project = project

      expect(service.project).to eq(project)
    end

    context 'hook with not implemented test' do
      it 'returns error message' do
        expect(hook).not_to receive(:execute)
        expect(service.execute).to have_attributes(status: :error, message: 'Testing not available for this hook')
      end
    end

    context 'push_events' do
      let(:trigger) { 'push_events' }
      let(:trigger_key) { :push_hooks }

      it 'executes hook' do
        allow(Gitlab::DataBuilder::Push).to receive(:build_sample).and_return(sample_data)

        expect(hook).to receive(:execute).with(sample_data, trigger_key, force: true).and_return(success_result)
        expect(service.execute).to include(success_result)
      end
    end

    context 'tag_push_events' do
      let(:trigger) { 'tag_push_events' }
      let(:trigger_key) { :tag_push_hooks }

      it 'executes hook' do
        allow(Gitlab::DataBuilder::Push).to receive(:build_sample).and_return(sample_data)

        expect(hook).to receive(:execute).with(sample_data, trigger_key, force: true).and_return(success_result)
        expect(service.execute).to include(success_result)
      end
    end

    context 'note_events' do
      let(:trigger) { 'note_events' }
      let(:trigger_key) { :note_hooks }

      it 'returns error message if not enough data' do
        expect(hook).not_to receive(:execute)
        expect(service.execute).to have_attributes(status: :error, message: 'Ensure the project has notes.')
      end

      it 'executes hook' do
        create(:note, project: project)

        allow(Gitlab::DataBuilder::Note).to receive(:build).and_return(sample_data)
        allow_next(NotesFinder).to receive(:execute).and_return(Note.all)

        expect(hook).to receive(:execute).with(sample_data, trigger_key, force: true).and_return(success_result)
        expect(service.execute).to include(success_result)
      end
    end

    shared_examples_for 'a test webhook that operates on issues' do
      let(:issue) { build(:issue) }

      it 'returns error message if not enough data' do
        expect(hook).not_to receive(:execute)
        expect(service.execute).to have_attributes(status: :error, message: 'Ensure the project has issues.')
      end

      it 'executes hook' do
        allow(issue).to receive(:to_hook_data).and_return(sample_data)
        allow_next(IssuesFinder).to receive(:execute).and_return([issue])

        expect(hook).to receive(:execute).with(sample_data, trigger_key, force: true).and_return(success_result)
        expect(service.execute).to include(success_result)
      end
    end

    context 'issues_events' do
      let(:trigger) { 'issues_events' }
      let(:trigger_key) { :issue_hooks }

      it_behaves_like 'a test webhook that operates on issues'
    end

    context 'confidential_issues_events' do
      let(:trigger) { 'confidential_issues_events' }
      let(:trigger_key) { :confidential_issue_hooks }

      it_behaves_like 'a test webhook that operates on issues'
    end

    context 'merge_requests_events' do
      let(:trigger) { 'merge_requests_events' }
      let(:trigger_key) { :merge_request_hooks }
      let(:merge_request) { build(:merge_request) }

      it 'returns error message if not enough data' do
        expect(hook).not_to receive(:execute)
        expect(service.execute).to have_attributes(status: :error, message: 'Ensure the project has merge requests.')
      end

      it 'executes hook' do
        allow(merge_request).to receive(:to_hook_data).and_return(sample_data)
        allow_next(MergeRequestsFinder).to receive(:execute).and_return([merge_request])

        expect(hook).to receive(:execute).with(sample_data, trigger_key, force: true).and_return(success_result)
        expect(service.execute).to include(success_result)
      end
    end

    context 'job_events' do
      let(:trigger) { 'job_events' }
      let(:trigger_key) { :job_hooks }
      let(:ci_job) { build(:ci_build) }

      it 'returns error message if not enough data' do
        expect(hook).not_to receive(:execute)
        expect(service.execute).to have_attributes(status: :error, message: 'Ensure the project has CI jobs.')
      end

      it 'executes hook' do
        allow(Gitlab::DataBuilder::Build).to receive(:build).and_return(sample_data)
        allow_next(Ci::JobsFinder).to receive(:execute).and_return([ci_job])

        expect(hook).to receive(:execute).with(sample_data, trigger_key, force: true).and_return(success_result)
        expect(service.execute).to include(success_result)
      end
    end

    context 'pipeline_events' do
      let(:trigger) { 'pipeline_events' }
      let(:trigger_key) { :pipeline_hooks }
      let(:pipeline) { build(:ci_empty_pipeline) }

      it 'returns error message if not enough data' do
        expect(hook).not_to receive(:execute)
        expect(service.execute).to have_attributes(status: :error, message: 'Ensure the project has CI pipelines.')
      end

      it 'executes hook' do
        allow(Gitlab::DataBuilder::Pipeline).to receive(:build).and_return(sample_data)
        allow_next(Ci::PipelinesFinder).to receive(:execute).and_return([pipeline])

        expect(hook).to receive(:execute).with(sample_data, trigger_key, force: true).and_return(success_result)
        expect(service.execute).to include(success_result)
      end
    end

    context 'wiki_page_events' do
      let_it_be(:project) { create(:project, :wiki_repo) }

      let(:trigger) { 'wiki_page_events' }
      let(:trigger_key) { :wiki_page_hooks }

      it 'returns error message if wiki disabled' do
        allow(project).to receive(:wiki_enabled?).and_return(false)

        expect(hook).not_to receive(:execute)
        expect(service.execute).to have_attributes(status: :error, message: 'Ensure the wiki is enabled and has pages.')
      end

      it 'returns error message if not enough data' do
        expect(hook).not_to receive(:execute)
        expect(service.execute).to have_attributes(status: :error, message: 'Ensure the wiki is enabled and has pages.')
      end

      it 'executes hook' do
        create(:wiki_page, wiki: project.wiki)
        allow(Gitlab::DataBuilder::WikiPage).to receive(:build).and_return(sample_data)

        expect(hook).to receive(:execute).with(sample_data, trigger_key, force: true).and_return(success_result)
        expect(service.execute).to include(success_result)
      end
    end

    context 'releases_events' do
      let(:trigger) { 'releases_events' }
      let(:trigger_key) { :release_hooks }
      let(:release) { build(:release) }

      it 'returns error message if not enough data' do
        expect(hook).not_to receive(:execute)
        expect(service.execute).to have_attributes(status: :error, message: 'Ensure the project has releases.')
      end

      it 'executes hook' do
        allow(release).to receive(:to_hook_data).and_return(sample_data)
        allow_next(ReleasesFinder).to receive(:execute).and_return([release])

        expect(hook).to receive(:execute).with(sample_data, trigger_key, force: true).and_return(success_result)
        expect(service.execute).to include(success_result)
      end
    end

    context 'emoji' do
      let(:trigger) { 'emoji_events' }
      let(:trigger_key) { :emoji_hooks }

      it 'returns error message if not enough data' do
        expect(hook).not_to receive(:execute)
        expect(service.execute).to have_attributes(status: :error, message: 'Ensure the project has notes.')
      end

      it 'executes hook' do
        note = create(:note)
        allow(project).to receive_message_chain(:notes, :any?).and_return(true)
        allow(project).to receive_message_chain(:notes, :last).and_return(note)
        allow(Gitlab::DataBuilder::Emoji).to receive(:build).with(anything, current_user, 'award')
          .and_return(sample_data)

        expect(hook).to receive(:execute).with(sample_data, trigger_key, force: true).and_return(success_result)
        expect(service.execute).to include(success_result)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module TestHooks
  class SystemService < TestHooks::BaseService
    include Gitlab::Utils::StrongMemoize

    private

    def data
      strong_memoize(:data) do
        case trigger
        when 'push_events', 'tag_push_events'
          Gitlab::DataBuilder::Push.sample_data
        when 'repository_update_events'
          Gitlab::DataBuilder::Repository.sample_data
        when 'merge_requests_events'
          merge_requests_events_data
        end
      end
    end

    def merge_requests_events_data
      merge_request = MergeRequest.of_projects(current_user.projects.select(:id)).last

      return { error: s_('TestHooks|Ensure one of your projects has merge requests.') } unless merge_request.present?

      merge_request.to_hook_data(current_user)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe TestHooks::SystemService, feature_category: :code_testing do
  include AfterNextHelpers

  describe '#execute' do
    let_it_be(:project) { create(:project, :repository) }

    let(:hook)    { create(:system_hook) }
    let(:service) { described_class.new(hook, project.first_owner, trigger) }
    let(:success_result) { { status: :success, http_status: 200, message: 'ok' } }

    before do
      allow(Project).to receive(:first).and_return(project)
    end

    context 'hook with not implemented test' do
      let(:trigger) { 'not_implemented_events' }

      it 'returns error message' do
        expect(hook).not_to receive(:execute)
        expect(service.execute).to have_attributes(status: :error, message: 'Testing not available for this hook')
      end
    end

    context 'push_events' do
      let(:trigger) { 'push_events' }
      let(:trigger_key) { :push_hooks }

      it 'executes hook' do
        expect(Gitlab::DataBuilder::Push).to receive(:sample_data).and_call_original

        expect(hook).to receive(:execute).with(Gitlab::DataBuilder::Push::SAMPLE_DATA, trigger_key, force: true).and_return(success_result)
        expect(service.execute).to include(success_result)
      end
    end

    context 'tag_push_events' do
      let(:trigger) { 'tag_push_events' }
      let(:trigger_key) { :tag_push_hooks }

      it 'executes hook' do
        allow(project.repository).to receive(:tags).and_return(['tag'])
        expect(Gitlab::DataBuilder::Push).to receive(:sample_data).and_call_original

        expect(hook).to receive(:execute).with(Gitlab::DataBuilder::Push::SAMPLE_DATA, trigger_key, force: true).and_return(success_result)
        expect(service.execute).to include(success_result)
      end
    end

    context 'repository_update_events' do
      let(:trigger) { 'repository_update_events' }
      let(:trigger_key) { :repository_update_hooks }

      it 'executes hook' do
        expect(Gitlab::DataBuilder::Repository).to receive(:sample_data).and_call_original

        expect(hook).to receive(:execute).with(Gitlab::DataBuilder::Repository::SAMPLE_DATA, trigger_key, force: true).and_return(success_result)
        expect(service.execute).to include(success_result)
      end
    end

    context 'merge_requests_events' do
      let(:trigger) { 'merge_requests_events' }
      let(:trigger_key) { :merge_request_hooks }
      let(:merge_request) { build(:merge_request) }
      let(:sample_data) { { data: 'sample' } }

      it 'returns error message if the user does not have any repository with a merge request' do
        expect(hook).not_to receive(:execute)
        expect(service.execute).to have_attributes(status: :error, message: 'Ensure one of your projects has merge requests.')
      end

      it 'executes hook' do
        expect(MergeRequest).to receive(:of_projects).and_return([merge_request])
        expect(merge_request).to receive(:to_hook_data).and_return(sample_data)
        expect(hook).to receive(:execute).with(sample_data, trigger_key, force: true).and_return(success_result)
        expect(service.execute).to include(success_result)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# GroupMentionService class
#
# Used for sending group mention notifications
#
# Ex.
#   Integrations::GroupMentionService.new(mentionable, hook_data: data, is_confidential: true).execute
#
module Integrations
  class GroupMentionService
    def initialize(mentionable, hook_data:, is_confidential:)
      @mentionable = mentionable
      @hook_data = hook_data
      @is_confidential = is_confidential
    end

    def execute
      return ServiceResponse.success if mentionable.nil? || hook_data.nil?

      @hook_data = hook_data.clone
      # Fake a ""group_mention"" object kind so integrations can handle this as a separate class of event
      hook_data[:object_attributes][:object_kind] = hook_data[:object_kind]
      hook_data[:object_kind] = 'group_mention'

      if confidential?
        hook_data[:event_type] = 'group_confidential_mention'
        hook_scope = :group_confidential_mention_hooks
      else
        hook_data[:event_type] = 'group_mention'
        hook_scope = :group_mention_hooks
      end

      groups = mentionable.referenced_groups(mentionable.author)
      groups.each do |group|
        group_hook_data = hook_data.merge(
          mentioned: {
            object_kind: 'group',
            name: group.full_path,
            url: group.web_url
          }
        )
        group.execute_integrations(group_hook_data, hook_scope)
      end

      ServiceResponse.success
    end

    private

    attr_reader :mentionable, :hook_data, :is_confidential

    def confidential?
      return is_confidential if is_confidential.present?

      mentionable.project.visibility_level != Gitlab::VisibilityLevel::PUBLIC
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Integrations::GroupMentionService, feature_category: :integrations do
  subject(:execute) { described_class.new(mentionable, hook_data: hook_data, is_confidential: is_confidential).execute }

  let_it_be(:user) { create(:user) }
  let_it_be(:group) { create(:group) }

  before do
    allow(mentionable).to receive(:referenced_groups).with(user).and_return([group])
  end

  shared_examples 'group_mention_hooks' do
    specify do
      expect(group).to receive(:execute_integrations).with(anything, :group_mention_hooks)
      expect(execute).to be_success
    end
  end

  shared_examples 'group_confidential_mention_hooks' do
    specify do
      expect(group).to receive(:execute_integrations).with(anything, :group_confidential_mention_hooks)
      expect(execute).to be_success
    end
  end

  context 'for issue descriptions' do
    let(:hook_data) { mentionable.to_hook_data(user) }
    let(:is_confidential) { mentionable.confidential? }

    context 'in public projects' do
      let_it_be(:project) { create(:project, :public) }

      context 'in public issues' do
        let(:mentionable) do
          create(:issue, confidential: false, project: project, author: user, description: ""@#{group.full_path}"")
        end

        it_behaves_like 'group_mention_hooks'
      end

      context 'in confidential issues' do
        let(:mentionable) do
          create(:issue, confidential: true, project: project, author: user, description: ""@#{group.full_path}"")
        end

        it_behaves_like 'group_confidential_mention_hooks'
      end
    end

    context 'in private projects' do
      let_it_be(:project) { create(:project, :private) }

      context 'in public issues' do
        let(:mentionable) do
          create(:issue, confidential: false, project: project, author: user, description: ""@#{group.full_path}"")
        end

        it_behaves_like 'group_confidential_mention_hooks'
      end

      context 'in confidential issues' do
        let(:mentionable) do
          create(:issue, confidential: true, project: project, author: user, description: ""@#{group.full_path}"")
        end

        it_behaves_like 'group_confidential_mention_hooks'
      end
    end
  end

  context 'for merge request descriptions' do
    let(:hook_data) { mentionable.to_hook_data(user) }
    let(:is_confidential) { false }
    let(:mentionable) do
      create(:merge_request, source_project: project, target_project: project, author: user,
        description: ""@#{group.full_path}"")
    end

    context 'in public projects' do
      let_it_be(:project) { create(:project, :public) }

      it_behaves_like 'group_mention_hooks'
    end

    context 'in private projects' do
      let_it_be(:project) { create(:project, :private) }

      it_behaves_like 'group_confidential_mention_hooks'
    end
  end

  context 'for issue notes' do
    let(:hook_data) { Gitlab::DataBuilder::Note.build(mentionable, mentionable.author) }
    let(:is_confidential) { mentionable.confidential?(include_noteable: true) }

    context 'in public projects' do
      let_it_be(:project) { create(:project, :public) }

      context 'in public issues' do
        let(:issue) do
          create(:issue, confidential: false, project: project, author: user, description: ""@#{group.full_path}"")
        end

        context 'for public notes' do
          let(:mentionable) { create(:note_on_issue, noteable: issue, project: project, author: user) }

          it_behaves_like 'group_mention_hooks'
        end

        context 'for internal notes' do
          let(:mentionable) { create(:note_on_issue, :confidential, noteable: issue, project: project, author: user) }

          it_behaves_like 'group_confidential_mention_hooks'
        end
      end
    end

    context 'in private projects' do
      let_it_be(:project) { create(:project, :private) }

      context 'in public issues' do
        let(:issue) do
          create(:issue, confidential: false, project: project, author: user, description: ""@#{group.full_path}"")
        end

        context 'for public notes' do
          let(:mentionable) { create(:note_on_issue, noteable: issue, project: project, author: user) }

          it_behaves_like 'group_confidential_mention_hooks'
        end

        context 'for internal notes' do
          let(:mentionable) { create(:note_on_issue, :confidential, noteable: issue, project: project, author: user) }

          it_behaves_like 'group_confidential_mention_hooks'
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Integrations
  class SlackOptionService
    UnknownOptionError = Class.new(StandardError)

    OPTIONS = {
      'assignee' => SlackOptions::UserSearchHandler,
      'labels' => SlackOptions::LabelSearchHandler
    }.freeze

    def initialize(params)
      @params = params
      @search_type = params.delete(:action_id)
      @selected_value = params.delete(:value)
      @view_id = params.dig(:view, :id)
    end

    def execute
      raise UnknownOptionError, ""Unable to handle option: '#{search_type}'"" \
        unless option?(search_type)

      handler_class = OPTIONS[search_type]
      handler_class.new(current_user, selected_value, view_id).execute
    end

    private

    def current_user
      ChatNames::FindUserService.new(
        params.dig(:team, :id),
        params.dig(:user, :id)
      ).execute
    end

    def option?(option)
      OPTIONS.key?(option)
    end

    attr_reader :params, :search_type, :selected_value, :view_id
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Integrations::SlackOptionService, feature_category: :integrations do
  describe '#execute' do
    subject(:execute) { described_class.new(params).execute }

    let_it_be(:slack_installation) { create(:slack_integration) }
    let_it_be(:user) { create(:user) }

    let_it_be(:chat_name) do
      create(:chat_name,
        user: user,
        team_id: slack_installation.team_id,
        chat_id: slack_installation.user_id
      )
    end

    let(:params) do
      {
        action_id: action_id,
        view: {
          id: 'VHDFR54DSA'
        },
        value: 'Search value',
        team: {
          id: slack_installation.team_id
        },
        user: {
          id: slack_installation.user_id
        }
      }
    end

    context 'when action_id is assignee' do
      let(:action_id) { 'assignee' }

      it 'executes the user search handler' do
        user_search_handler = described_class::OPTIONS['assignee']

        expect_next_instance_of(user_search_handler, chat_name, 'Search value', 'VHDFR54DSA') do |service|
          expect(service).to receive(:execute).and_return(ServiceResponse.success)
        end

        execute
      end
    end

    context 'when action_id is labels' do
      let(:action_id) { 'labels' }

      it 'executes the label search handler' do
        label_search_handler = described_class::OPTIONS['labels']

        expect_next_instance_of(label_search_handler, chat_name, 'Search value', 'VHDFR54DSA') do |service|
          expect(service).to receive(:execute).and_return(ServiceResponse.success)
        end

        execute
      end
    end

    context 'when action_id is unknown' do
      let(:action_id) { 'foo' }

      it 'raises an error and does not execute a service class' do
        described_class::OPTIONS.each_value do |service_class|
          expect(service_class).not_to receive(:new)
        end

        expect { execute }.to raise_error(described_class::UnknownOptionError)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Performs the initial handling of event payloads sent from Slack to GitLab.
# See `API::Integrations::Slack::Events` which calls this service.
module Integrations
  class SlackEventService
    URL_VERIFICATION_EVENT = 'url_verification'

    UnknownEventError = Class.new(StandardError)

    def initialize(params)
      # When receiving URL verification events, params[:type] is 'url_verification'.
      # For all other events we subscribe to, params[:type] is 'event_callback' and
      # the specific type of the event will be in params[:event][:type].
      # Remove both of these from the params before they are passed to the services.
      type = params.delete(:type)
      type = params[:event].delete(:type) if type == 'event_callback'

      @slack_event = type
      @params = params
    end

    def execute
      raise UnknownEventError, ""Unable to handle event type: '#{slack_event}'"" unless routable_event?

      payload = route_event

      ServiceResponse.success(payload: payload)
    end

    private

    # The `url_verification` slack_event response must be returned to Slack in-request,
    # so for this event we call the service directly instead of through a worker.
    #
    # All other events must be handled asynchronously in order to return a 2xx response
    # immediately to Slack in the request. See https://api.slack.com/apis/connections/events-api.
    def route_in_request?
      slack_event == URL_VERIFICATION_EVENT
    end

    def routable_event?
      route_in_request? || route_to_event_worker?
    end

    def route_to_event_worker?
      SlackEventWorker.event?(slack_event)
    end

    # Returns a payload for the service response.
    def route_event
      return SlackEvents::UrlVerificationService.new(params).execute if route_in_request?

      SlackEventWorker.perform_async(slack_event: slack_event, params: params)

      {}
    end

    attr_reader :slack_event, :params
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Integrations::SlackEventService, feature_category: :integrations do
  describe '#execute' do
    subject(:execute) { described_class.new(params).execute }

    let(:params) do
      {
        type: 'event_callback',
        event: {
          type: 'app_home_opened',
          foo: 'bar'
        }
      }
    end

    it 'queues a worker and returns success response' do
      expect(Integrations::SlackEventWorker).to receive(:perform_async)
        .with(
          {
            slack_event: 'app_home_opened',
            params: {
              event: {
                foo: 'bar'
              }
            }
          }
        )
      expect(execute.payload).to eq({})
      is_expected.to be_success
    end

    context 'when event a url verification request' do
      let(:params) { { type: 'url_verification', foo: 'bar' } }

      it 'executes the service instead of queueing a worker and returns success response' do
        expect(Integrations::SlackEventWorker).not_to receive(:perform_async)
        expect_next_instance_of(Integrations::SlackEvents::UrlVerificationService, { foo: 'bar' }) do |service|
          expect(service).to receive(:execute).and_return({ baz: 'qux' })
        end
        expect(execute.payload).to eq({ baz: 'qux' })
        is_expected.to be_success
      end
    end

    context 'when event is unknown' do
      let(:params) { super().merge(event: { type: 'foo' }) }

      it 'raises an error' do
        expect { execute }.to raise_error(described_class::UnknownEventError)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Integrations
  class PropagateService
    BATCH_SIZE = 10_000

    def initialize(integration)
      @integration = integration
    end

    def propagate
      if integration.instance_level?
        update_inherited_integrations
        create_integration_for_groups_without_integration
        create_integration_for_projects_without_integration
      else
        update_inherited_descendant_integrations
        create_integration_for_groups_without_integration_belonging_to_group
        create_integration_for_projects_without_integration_belonging_to_group
      end
    end

    def self.propagate(integration)
      new(integration).propagate
    end

    private

    attr_reader :integration

    def create_integration_for_projects_without_integration
      propagate_integrations(
        Project.without_integration(integration),
        PropagateIntegrationProjectWorker
      )
    end

    def update_inherited_integrations
      propagate_integrations(
        Integration.by_type(integration.type).inherit_from_id(integration.id),
        PropagateIntegrationInheritWorker
      )
    end

    def update_inherited_descendant_integrations
      propagate_integrations(
        Integration.inherited_descendants_from_self_or_ancestors_from(integration),
        PropagateIntegrationInheritDescendantWorker
      )
    end

    def create_integration_for_groups_without_integration
      propagate_integrations(
        Group.without_integration(integration),
        PropagateIntegrationGroupWorker
      )
    end

    def create_integration_for_groups_without_integration_belonging_to_group
      propagate_integrations(
        integration.group.descendants.without_integration(integration),
        PropagateIntegrationGroupWorker
      )
    end

    def create_integration_for_projects_without_integration_belonging_to_group
      propagate_integrations(
        Project.without_integration(integration).in_namespace(integration.group.self_and_descendants),
        PropagateIntegrationProjectWorker
      )
    end

    def propagate_integrations(relation, worker_class)
      relation.each_batch(of: BATCH_SIZE) do |records|
        min_id, max_id = records.pick(""MIN(#{relation.table_name}.id), MAX(#{relation.table_name}.id)"")
        worker_class.perform_async(integration.id, min_id, max_id)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Integrations::PropagateService, feature_category: :integrations do
  describe '.propagate' do
    include JiraIntegrationHelpers

    before do
      stub_jira_integration_test
    end

    let(:group) { create(:group) }

    let_it_be(:project) { create(:project) }
    let_it_be(:instance_integration) { create(:jira_integration, :instance) }
    let_it_be(:not_inherited_integration) { create(:jira_integration, project: project) }
    let_it_be(:inherited_integration) do
      create(:jira_integration, project: create(:project), inherit_from_id: instance_integration.id)
    end

    let_it_be(:different_type_inherited_integration) do
      create(:redmine_integration, project: project, inherit_from_id: instance_integration.id)
    end

    context 'with inherited integration' do
      let(:integration) { inherited_integration }

      it 'calls to PropagateIntegrationProjectWorker' do
        expect(PropagateIntegrationInheritWorker).to receive(:perform_async)
          .with(instance_integration.id, inherited_integration.id, inherited_integration.id)

        described_class.propagate(instance_integration)
      end
    end

    context 'with a project without integration' do
      let(:another_project) { create(:project) }

      it 'calls to PropagateIntegrationProjectWorker' do
        expect(PropagateIntegrationProjectWorker).to receive(:perform_async)
          .with(instance_integration.id, another_project.id, another_project.id)

        described_class.propagate(instance_integration)
      end
    end

    context 'with a group without integration' do
      it 'calls to PropagateIntegrationProjectWorker' do
        expect(PropagateIntegrationGroupWorker).to receive(:perform_async)
          .with(instance_integration.id, group.id, group.id)

        described_class.propagate(instance_integration)
      end
    end

    context 'for a group-level integration' do
      let(:group_integration) { create(:jira_integration, :group, group: group) }

      context 'with a project without integration' do
        let(:another_project) { create(:project, group: group) }

        it 'calls to PropagateIntegrationProjectWorker' do
          expect(PropagateIntegrationProjectWorker).to receive(:perform_async)
            .with(group_integration.id, another_project.id, another_project.id)

          described_class.propagate(group_integration)
        end
      end

      context 'with a subgroup without integration' do
        let(:subgroup) { create(:group, parent: group) }

        it 'calls to PropagateIntegrationGroupWorker' do
          expect(PropagateIntegrationGroupWorker).to receive(:perform_async)
            .with(group_integration.id, subgroup.id, subgroup.id)

          described_class.propagate(group_integration)
        end
      end

      context 'with a subgroup with integration' do
        let(:subgroup) { create(:group, parent: group) }
        let(:subgroup_integration) { create(:jira_integration, :group, group: subgroup, inherit_from_id: group_integration.id) }

        it 'calls to PropagateIntegrationInheritDescendantWorker' do
          expect(PropagateIntegrationInheritDescendantWorker).to receive(:perform_async)
            .with(group_integration.id, subgroup_integration.id, subgroup_integration.id)

          described_class.propagate(group_integration)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Integrations
  class SlackInteractionService
    UnknownInteractionError = Class.new(StandardError)

    INTERACTIONS = {
      'view_closed' => SlackInteractions::IncidentManagement::IncidentModalClosedService,
      'view_submission' => SlackInteractions::IncidentManagement::IncidentModalSubmitService,
      'block_actions' => SlackInteractions::BlockActionService
    }.freeze

    def initialize(params)
      @interaction_type = params.delete(:type)
      @params = params
    end

    def execute
      raise UnknownInteractionError, ""Unable to handle interaction type: '#{interaction_type}'"" \
        unless interaction?(interaction_type)

      service_class = INTERACTIONS[interaction_type]
      service_class.new(params).execute

      ServiceResponse.success
    end

    private

    attr_reader :interaction_type, :params

    def interaction?(type)
      INTERACTIONS.key?(type)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Integrations::SlackInteractionService, feature_category: :integrations do
  describe '#execute' do
    subject(:execute) { described_class.new(params).execute }

    let(:params) do
      {
        type: slack_interaction,
        foo: 'bar'
      }
    end

    context 'when view is closed' do
      let(:slack_interaction) { 'view_closed' }

      it 'executes the correct service' do
        view_closed_service = described_class::INTERACTIONS['view_closed']

        expect_next_instance_of(view_closed_service, { foo: 'bar' }) do |service|
          expect(service).to receive(:execute).and_return(ServiceResponse.success)
        end

        execute
      end
    end

    context 'when view is submitted' do
      let(:slack_interaction) { 'view_submission' }

      it 'executes the submission service' do
        view_submission_service = described_class::INTERACTIONS['view_submission']

        expect_next_instance_of(view_submission_service, { foo: 'bar' }) do |service|
          expect(service).to receive(:execute).and_return(ServiceResponse.success)
        end

        execute
      end
    end

    context 'when block action service is submitted' do
      let(:slack_interaction) { 'block_actions' }

      it 'executes the block actions service' do
        block_action_service = described_class::INTERACTIONS['block_actions']

        expect_next_instance_of(block_action_service, { foo: 'bar' }) do |service|
          expect(service).to receive(:execute).and_return(ServiceResponse.success)
        end

        execute
      end
    end

    context 'when slack_interaction is not known' do
      let(:slack_interaction) { 'foo' }

      it 'raises an error and does not execute a service class' do
        described_class::INTERACTIONS.each_value do |service_class|
          expect(service_class).not_to receive(:new)
        end

        expect { execute }.to raise_error(described_class::UnknownInteractionError)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Integrations
  module SlackOptions
    class UserSearchHandler # rubocop:disable Search/NamespacedClass
      include Gitlab::Utils::StrongMemoize

      def initialize(current_user, search_value, view_id)
        @current_user = current_user.user
        @search_value = search_value
        @view_id = view_id
      end

      def execute
        return ServiceResponse.success(payload: []) unless current_user.can?(:read_project_member, project)

        members = MembersFinder.new(project, current_user, params: { search: search_value }).execute

        ServiceResponse.success(payload: build_user_list(members))
      end

      private

      def project
        project_id = SlackInteractions::IncidentManagement::IncidentModalOpenedService
              .cache_read(view_id)

        return unless project_id

        Project.find(project_id)
      end
      strong_memoize_attr :project

      def build_user_list(members)
        return [] unless members

        user_list = members.map do |member|
          {
            text: {
              type: ""plain_text"",
              text: ""#{member.user.name} - #{member.user.username}""
            },
            value: member.user.id.to_s
          }
        end

        {
          options: user_list
        }
      end

      attr_reader :current_user, :search_value, :view_id
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Integrations::SlackOptions::UserSearchHandler, feature_category: :integrations do
  describe '#execute' do
    let_it_be(:project) { create(:project, :private) }
    let_it_be(:current_user) { create(:user) }
    let_it_be(:chat_name) { create(:chat_name, user: current_user) }
    let_it_be(:user1) { create(:user, name: 'Rajendra Kadam') }
    let_it_be(:user2) { create(:user, name: 'Rajesh K') }
    let_it_be(:user3) { create(:user) }
    let_it_be(:view_id) { 'VXHD54DR' }

    let(:search_value) { 'Raj' }

    subject(:execute) { described_class.new(chat_name, search_value, view_id).execute }

    context 'when user has permissions to read project members' do
      before do
        project.add_developer(current_user)
        project.add_guest(user1)
        project.add_reporter(user2)
        project.add_maintainer(user3)
      end

      it 'returns the user matching the search term' do
        expect(Rails.cache).to receive(:read).and_return(project.id)

        members = execute.payload[:options]
        user_names = members.map { |member| member.dig(:text, :text) }

        expect(members.count).to eq(2)
        expect(user_names).to contain_exactly(
          ""#{user1.name} - #{user1.username}"",
          ""#{user2.name} - #{user2.username}""
        )
      end
    end

    context 'when user does not have permissions to read project members' do
      it 'returns empty array' do
        expect(Rails.cache).to receive(:read).and_return(project.id)
        expect(MembersFinder).not_to receive(:execute)

        members = execute.payload

        expect(members).to be_empty
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Integrations
  module SlackOptions
    class LabelSearchHandler # rubocop:disable Search/NamespacedClass
      include Gitlab::Utils::StrongMemoize

      def initialize(current_user, search_value, view_id)
        @current_user = current_user.user
        @search_value = search_value
        @view_id = view_id
      end

      def execute
        return ServiceResponse.success(payload: []) unless current_user.can?(:read_label, project)

        labels = LabelsFinder.new(
          current_user,
          {
            project: project,
            search: search_value
          }
        ).execute

        ServiceResponse.success(payload: build_label_list(labels))
      end

      private

      def project
        project_id = Integrations::SlackInteractions::IncidentManagement::IncidentModalOpenedService
              .cache_read(view_id)

        return unless project_id

        Project.find(project_id)
      end
      strong_memoize_attr :project

      def build_label_list(labels)
        return [] unless labels

        label_list = labels.map do |label|
          {
            text: {
              type: ""plain_text"",
              text: label.name
            },
            value: label.id.to_s
          }
        end

        {
          options: label_list
        }
      end

      attr_accessor :current_user, :search_value, :view_id
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Integrations::SlackOptions::LabelSearchHandler, feature_category: :integrations do
  describe '#execute' do
    let_it_be(:group) { create(:group) }
    let_it_be(:project) { create(:project, :private, namespace: group) }
    let_it_be(:current_user) { create(:user) }
    let_it_be(:chat_name) { create(:chat_name, user: current_user) }
    let_it_be(:project_label1) { create(:label, project: project, title: 'Label 1') }
    let_it_be(:project_label2) { create(:label, project: project, title: 'Label 2') }
    let_it_be(:group_label1) { create(:group_label, group: group, title: 'LabelG 1') }
    let_it_be(:group_label2) { create(:group_label, group: group, title: 'glb 2') }
    let_it_be(:view_id) { 'VXHD54DR' }

    let(:search_value) { 'Lab' }

    subject(:execute) { described_class.new(chat_name, search_value, view_id).execute }

    context 'when user has permission to read project and group labels' do
      before do
        allow(Rails.cache).to receive(:read).and_return(project.id)
        project.add_developer(current_user)
      end

      it 'returns the labels matching the search term' do
        labels = execute.payload[:options]
        label_names = labels.map { |label| label.dig(:text, :text) }

        expect(label_names).to contain_exactly(
          project_label1.name,
          project_label2.name,
          group_label1.name
        )
      end
    end

    context 'when user does not have permissions to read project/group labels' do
      it 'returns empty array' do
        expect(LabelsFinder).not_to receive(:execute)

        expect(execute.payload).to be_empty
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Integrations
  module Test
    class ProjectService < Integrations::Test::BaseService
      include Integrations::ProjectTestData
      include Gitlab::Utils::StrongMemoize

      def project
        strong_memoize(:project) do
          integration.project
        end
      end

      private

      def data
        strong_memoize(:data) do
          case event || integration.default_test_event
          when 'push', 'tag_push'
            push_events_data
          when 'note', 'confidential_note'
            note_events_data
          when 'issue', 'confidential_issue'
            issues_events_data
          when 'merge_request'
            merge_requests_events_data
          when 'job'
            job_events_data
          when 'pipeline'
            pipeline_events_data
          when 'wiki_page'
            wiki_page_events_data
          when 'deployment'
            deployment_events_data
          when 'release'
            releases_events_data
          when 'award_emoji'
            emoji_events_data
          end
        end
      end
    end
  end
end

Integrations::Test::ProjectService.prepend_mod_with('Integrations::Test::ProjectService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Integrations::Test::ProjectService, feature_category: :integrations do
  include AfterNextHelpers

  describe '#execute' do
    let_it_be(:project) { create(:project) }

    let(:integration) { create(:integrations_slack, project: project) }
    let(:user) { project.first_owner }
    let(:event) { nil }
    let(:sample_data) { { data: 'sample' } }
    let(:success_result) { { success: true, result: {} } }

    subject { described_class.new(integration, user, event).execute }

    context 'without event specified' do
      it 'tests the integration with default data' do
        allow(Gitlab::DataBuilder::Push).to receive(:build_sample).and_return(sample_data)

        expect(integration).to receive(:test).with(sample_data).and_return(success_result)
        expect(subject).to eq(success_result)
      end

      context 'with Integrations::PipelinesEmail' do
        let(:integration) { create(:pipelines_email_integration, project: project) }

        it_behaves_like 'tests for integration with pipeline data'
      end
    end

    context 'with event specified' do
      context 'event not supported by integration' do
        let(:integration) { create(:jira_integration, project: project) }
        let(:event) { 'push' }

        it 'returns error message' do
          expect(subject).to include({ status: :error, message: 'Testing not available for this event' })
        end
      end

      context 'push' do
        let(:event) { 'push' }

        it 'executes integration' do
          allow(Gitlab::DataBuilder::Push).to receive(:build_sample).and_return(sample_data)

          expect(integration).to receive(:test).with(sample_data).and_return(success_result)
          expect(subject).to eq(success_result)
        end
      end

      context 'tag_push' do
        let(:event) { 'tag_push' }

        it 'executes integration' do
          allow(Gitlab::DataBuilder::Push).to receive(:build_sample).and_return(sample_data)

          expect(integration).to receive(:test).with(sample_data).and_return(success_result)
          expect(subject).to eq(success_result)
        end
      end

      context 'note' do
        let(:event) { 'note' }

        it 'returns error message if not enough data' do
          expect(integration).not_to receive(:test)
          expect(subject).to include({ status: :error, message: 'Ensure the project has notes.' })
        end

        it 'executes integration' do
          create(:note, project: project)

          allow(Gitlab::DataBuilder::Note).to receive(:build).and_return(sample_data)
          allow_next(NotesFinder).to receive(:execute).and_return(Note.all)

          expect(integration).to receive(:test).with(sample_data).and_return(success_result)
          expect(subject).to eq(success_result)
        end
      end

      shared_examples_for 'a test of an integration that operates on issues' do
        let(:issue) { build(:issue) }

        it 'returns error message if not enough data' do
          expect(integration).not_to receive(:test)
          expect(subject).to include({ status: :error, message: 'Ensure the project has issues.' })
        end

        it 'executes integration' do
          allow(project).to receive(:issues).and_return([issue])
          allow(issue).to receive(:to_hook_data).and_return(sample_data)
          allow_next(IssuesFinder).to receive(:execute).and_return([issue])

          expect(integration).to receive(:test).with(sample_data).and_return(success_result)
          expect(subject).to eq(success_result)
        end
      end

      context 'issue' do
        let(:event) { 'issue' }

        it_behaves_like 'a test of an integration that operates on issues'
      end

      context 'confidential_issue' do
        let(:event) { 'confidential_issue' }

        it_behaves_like 'a test of an integration that operates on issues'
      end

      context 'merge_request' do
        let(:event) { 'merge_request' }
        let(:merge_request) { build(:merge_request) }

        it 'returns error message if not enough data' do
          expect(integration).not_to receive(:test)
          expect(subject).to include({ status: :error, message: 'Ensure the project has merge requests.' })
        end

        it 'executes integration' do
          allow(merge_request).to receive(:to_hook_data).and_return(sample_data)
          allow_next(MergeRequestsFinder).to receive(:execute).and_return([merge_request])

          expect(integration).to receive(:test).with(sample_data).and_return(success_result)
          expect(subject).to include(success_result)
        end
      end

      context 'deployment' do
        let_it_be(:project) { create(:project, :test_repo) }

        let(:deployment) { build(:deployment) }
        let(:event) { 'deployment' }

        it 'returns error message if not enough data' do
          expect(integration).not_to receive(:test)
          expect(subject).to include({ status: :error, message: 'Ensure the project has deployments.' })
        end

        it 'executes integration' do
          allow(Gitlab::DataBuilder::Deployment).to receive(:build).and_return(sample_data)
          allow_next(DeploymentsFinder).to receive(:execute).and_return([deployment])

          expect(integration).to receive(:test).with(sample_data).and_return(success_result)
          expect(subject).to eq(success_result)
        end
      end

      context 'pipeline' do
        let(:event) { 'pipeline' }
        let(:pipeline) { build(:ci_pipeline) }

        it 'returns error message if not enough data' do
          expect(integration).not_to receive(:test)
          expect(subject).to include({ status: :error, message: 'Ensure the project has CI pipelines.' })
        end

        it 'executes integration' do
          allow(Gitlab::DataBuilder::Pipeline).to receive(:build).and_return(sample_data)
          allow_next(Ci::PipelinesFinder).to receive(:execute).and_return([pipeline])

          expect(integration).to receive(:test).with(sample_data).and_return(success_result)
          expect(subject).to eq(success_result)
        end
      end

      context 'wiki_page' do
        let_it_be(:project) { create(:project, :wiki_repo) }

        let(:event) { 'wiki_page' }

        it 'returns error message if wiki disabled' do
          allow(project).to receive(:wiki_enabled?).and_return(false)

          expect(integration).not_to receive(:test)
          expect(subject).to include({ status: :error, message: 'Ensure the wiki is enabled and has pages.' })
        end

        it 'returns error message if not enough data' do
          expect(integration).not_to receive(:test)
          expect(subject).to include({ status: :error, message: 'Ensure the wiki is enabled and has pages.' })
        end

        it 'executes integration' do
          create(:wiki_page, wiki: project.wiki)
          allow(Gitlab::DataBuilder::WikiPage).to receive(:build).and_return(sample_data)

          expect(integration).to receive(:test).with(sample_data).and_return(success_result)
          expect(subject).to eq(success_result)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Handles the Slack `app_home_opened` event sent from Slack to GitLab.
# Responds with a POST to the Slack API 'views.publish' method.
#
# See:
# - https://api.slack.com/methods/views.publish
# - https://api.slack.com/events/app_home_opened
module Integrations
  module SlackEvents
    class AppHomeOpenedService
      include Gitlab::Utils::StrongMemoize

      def initialize(params)
        @slack_user_id = params.dig(:event, :user)
        @slack_workspace_id = params[:team_id]
      end

      def execute
        # Legacy Slack App integrations will not yet have a token we can use
        # to call the Slack API. Do nothing, and consider the service successful.
        unless slack_installation
          logger.info(
            slack_user_id: slack_user_id,
            slack_workspace_id: slack_workspace_id,
            message: 'SlackInstallation record has no bot token'
          )

          return ServiceResponse.success
        end

        begin
          response = ::Slack::API.new(slack_installation).post(
            'views.publish',
            payload
          )
        rescue *Gitlab::HTTP::HTTP_ERRORS => e
          return ServiceResponse
            .error(message: 'HTTP exception when calling Slack API')
            .track_exception(
              as: e.class,
              slack_user_id: slack_user_id,
              slack_workspace_id: slack_workspace_id
            )
        end

        return ServiceResponse.success if response['ok']

        # For a list of errors, see:
        # https://api.slack.com/methods/views.publish#errors
        ServiceResponse.error(
          message: 'Slack API returned an error',
          payload: response
        ).track_exception(
          slack_user_id: slack_user_id,
          slack_workspace_id: slack_workspace_id,
          response: response.to_h
        )
      end

      private

      def slack_installation
        SlackIntegration.with_bot.find_by_team_id(slack_workspace_id)
      end
      strong_memoize_attr :slack_installation

      def slack_gitlab_user_connection
        ChatNames::FindUserService.new(slack_workspace_id, slack_user_id).execute
      end
      strong_memoize_attr :slack_gitlab_user_connection

      def payload
        {
          user_id: slack_user_id,
          view: ::Slack::BlockKit::AppHomeOpened.new(
            slack_user_id,
            slack_workspace_id,
            slack_gitlab_user_connection,
            slack_installation
          ).build
        }
      end

      def logger
        Gitlab::IntegrationsLogger
      end

      attr_reader :slack_user_id, :slack_workspace_id
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Integrations::SlackEvents::AppHomeOpenedService, feature_category: :integrations do
  describe '#execute' do
    let_it_be(:slack_installation) { create(:slack_integration) }

    let(:slack_workspace_id) { slack_installation.team_id }
    let(:slack_user_id) { 'U0123ABCDEF' }
    let(:api_url) { ""#{Slack::API::BASE_URL}/views.publish"" }
    let(:api_response) { { ok: true } }
    let(:params) do
      {
        team_id: slack_workspace_id,
        event: { user: slack_user_id },
        event_id: 'Ev03SA75UJKB'
      }
    end

    subject(:execute) { described_class.new(params).execute }

    before do
      stub_request(:post, api_url)
        .to_return(
          status: 200,
          body: api_response.to_json,
          headers: { 'Content-Type' => 'application/json' }
        )
    end

    shared_examples 'there is no bot token' do
      it 'does not call the Slack API, logs info, and returns a success response' do
        expect(Gitlab::IntegrationsLogger).to receive(:info).with(
          {
            slack_user_id: slack_user_id,
            slack_workspace_id: slack_workspace_id,
            message: 'SlackInstallation record has no bot token'
          }
        )

        is_expected.to be_success
      end
    end

    it 'calls the Slack API correctly and returns a success response' do
      mock_view = { type: 'home', blocks: [] }

      expect_next_instance_of(Slack::BlockKit::AppHomeOpened) do |ui|
        expect(ui).to receive(:build).and_return(mock_view)
      end

      is_expected.to be_success

      expect(WebMock).to have_requested(:post, api_url).with(
        body: {
          user_id: slack_user_id,
          view: mock_view
        },
        headers: {
          'Authorization' => ""Bearer #{slack_installation.bot_access_token}"",
          'Content-Type' => 'application/json; charset=utf-8'
        })
    end

    context 'when the slack installation is a legacy record' do
      let_it_be(:slack_installation) { create(:slack_integration, :legacy) }

      it_behaves_like 'there is no bot token'
    end

    context 'when the slack installation cannot be found' do
      let(:slack_workspace_id) { non_existing_record_id }

      it_behaves_like 'there is no bot token'
    end

    context 'when the Slack API call raises an HTTP exception' do
      before do
        allow(Gitlab::HTTP).to receive(:post).and_raise(Errno::ECONNREFUSED, 'error message')
      end

      it 'tracks the exception and returns an error response' do
        expect(::Gitlab::ErrorTracking).to receive(:track_exception)
          .with(
            Errno::ECONNREFUSED.new('HTTP exception when calling Slack API'),
            {
              slack_user_id: slack_user_id,
              slack_workspace_id: slack_workspace_id
            }
          )
        is_expected.to be_error
      end
    end

    context 'when the Slack API returns an error' do
      let(:api_response) { { ok: false, foo: 'bar' } }

      it 'tracks the exception and returns an error response' do
        expect(::Gitlab::ErrorTracking).to receive(:track_exception)
          .with(
            StandardError.new('Slack API returned an error'),
            {
              slack_user_id: slack_user_id,
              slack_workspace_id: slack_workspace_id,
              response: api_response.with_indifferent_access
            }
          )
        is_expected.to be_error
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Returns the special URL verification response expected by Slack when the
# GitLab Slack app is first configured to receive Slack events.
#
# Slack will issue the challenge request to the endpoint that receives events
# and expect it to respond with same the `challenge` param back.
#
# See https://api.slack.com/apis/connections/events-api.
module Integrations
  module SlackEvents
    class UrlVerificationService
      def initialize(params)
        @challenge = params[:challenge]
      end

      def execute
        { challenge: challenge }
      end

      private

      attr_reader :challenge
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Integrations::SlackEvents::UrlVerificationService, feature_category: :integrations do
  describe '#execute' do
    it 'returns the challenge' do
      expect(described_class.new({ challenge: 'foo' }).execute).to eq({ challenge: 'foo' })
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Integrations
  module SlackInteractions
    class BlockActionService
      ALLOWED_UPDATES_HANDLERS = {
        'incident_management_project' => SlackInteractions::SlackBlockActions::IncidentManagement::ProjectUpdateHandler
      }.freeze

      def initialize(params)
        @params = params
      end

      def execute
        actions.each do |action|
          action_id = action[:action_id]

          action_handler_class = ALLOWED_UPDATES_HANDLERS[action_id]
          action_handler_class.new(params, action).execute
        end
      end

      private

      def actions
        params[:actions].select { |action| ALLOWED_UPDATES_HANDLERS[action[:action_id]] }
      end

      attr_accessor :params
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Integrations::SlackInteractions::BlockActionService, feature_category: :integrations do
  describe '#execute' do
    let_it_be(:slack_installation) { create(:slack_integration) }

    let(:params) do
      {
        view: {
          team_id: slack_installation.team_id
        },
        actions: [{
          action_id: action_id
        }]
      }
    end

    subject(:execute) { described_class.new(params).execute }

    context 'when action_id is incident_management_project' do
      let(:action_id) { 'incident_management_project' }

      it 'executes the correct handler' do
        project_handler = described_class::ALLOWED_UPDATES_HANDLERS['incident_management_project']

        expect_next_instance_of(project_handler, params, params[:actions].first) do |handler|
          expect(handler).to receive(:execute).and_return(ServiceResponse.success)
        end

        execute
      end
    end

    context 'when action_id is not known' do
      let(:action_id) { 'random' }

      it 'does not execute the handlers' do
        described_class::ALLOWED_UPDATES_HANDLERS.each_value do |handler_class|
          expect(handler_class).not_to receive(:new)
        end

        execute
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Integrations
  module SlackInteractions
    module IncidentManagement
      class IncidentModalSubmitService
        include GitlabRoutingHelper
        include Gitlab::Routing

        IssueCreateError = Class.new(StandardError)

        def initialize(params)
          @params = params
          @values = params.dig(:view, :state, :values)
          @team_id = params.dig(:team, :id)
          @user_id = params.dig(:user, :id)
          @additional_message = ''
        end

        def execute
          create_response = Issues::CreateService.new(
            container: project,
            current_user: find_user.user,
            params: incident_params,
            perform_spam_check: false
          ).execute

          raise IssueCreateError, create_response.errors.to_sentence if create_response.error?

          incident = create_response.payload[:issue]
          incident_link = incident_link_text(incident)
          response = send_to_slack(incident_link)

          return ServiceResponse.success(payload: { incident: incident }) if response['ok']

          ServiceResponse.error(
            message: _('Something went wrong when sending the incident link to Slack.'),
            payload: response
          ).track_exception(
            response: response.to_h,
            slack_workspace_id: team_id,
            slack_user_id: user_id
          )
        rescue StandardError => e
          send_to_slack(_('There was a problem creating the incident. Please try again.'))

          ServiceResponse
            .error(
              message: e.message
            ).track_exception(
              slack_workspace_id: team_id,
              slack_user_id: user_id,
              as: e.class
            )
        end

        private

        attr_accessor :params, :values, :team_id, :user_id, :additional_message

        def incident_params
          {
            title: values.dig(:title_input, :title, :value),
            severity: severity,
            confidential: confidential?,
            description: description,
            escalation_status: { status: status },
            issue_type: ""incident"",
            assignee_ids: [assignee],
            label_ids: labels
          }
        end

        def strip_markup(string)
          SlackMarkdownSanitizer.sanitize(string)
        end

        def send_to_slack(text)
          response_url = params.dig(:view, :private_metadata)

          body = {
            replace_original: 'true',
            text: text
          }

          Gitlab::HTTP.post(
            response_url,
            body: Gitlab::Json.dump(body),
            headers: { 'Content-Type' => 'application/json' }
          )
        end

        def incident_link_text(incident)
          ""#{_('New incident has been created')}: "" \
            ""<#{issue_url(incident)}|#{incident.to_reference} "" \
            ""- #{strip_markup(incident.title)}>. #{@additional_message}""
        end

        def project
          project_id = values.dig(
            :project_and_severity_selector,
            :incident_management_project,
            :selected_option,
            :value)

          Project.find(project_id)
        end

        def find_user
          ChatNames::FindUserService.new(team_id, user_id).execute
        end

        def description
          description =
            values.dig(:incident_description, :description, :value) ||
            values.dig(project.id.to_s.to_sym, :description, :value)

          zoom_link = values.dig(:zoom, :link, :value)

          return description if zoom_link.blank?

          ""#{description} \n/zoom #{zoom_link}""
        end

        def confidential?
          values.dig(:confidentiality, :confidential, :selected_options).present?
        end

        def severity
          values.dig(:project_and_severity_selector, :severity, :selected_option, :value) || 'unknown'
        end

        def status
          values.dig(:status_and_assignee_selector, :status, :selected_option, :value)
        end

        def assignee
          assignee_id = values.dig(:status_and_assignee_selector, :assignee, :selected_option, :value)

          return unless assignee_id

          user = User.find_by_id(assignee_id)
          member = project.member(user)

          unless member
            @additional_message =
              ""However, "" \
              ""#{user.name} was not assigned to the incident as they are not a member in #{project.name}.""

            return
          end

          member.user_id
        end

        def labels
          values.dig(:label_selector, :labels, :selected_options)&.pluck(:value)
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Integrations::SlackInteractions::IncidentManagement::IncidentModalSubmitService,
  feature_category: :incident_management do
  include Gitlab::Routing

  describe '#execute' do
    let_it_be(:slack_installation) { create(:slack_integration) }
    let_it_be(:project) { create(:project) }
    let_it_be(:user) { create(:user) }
    let_it_be(:api_url) { 'https://api.slack.com/id/1234' }

    let_it_be(:chat_name) do
      create(:chat_name,
        user: user,
        team_id: slack_installation.team_id,
        chat_id: slack_installation.user_id
      )
    end

    # Setting below params as they are optional, have added values wherever required in specs
    let(:zoom_link) { '' }
    let(:severity) { {} }
    let(:status) { '' }
    let(:assignee_id) { nil }
    let(:selected_label_ids) { [] }
    let(:label_ids) { { selected_options: selected_label_ids } }
    let(:confidential_selected_options) { [] }
    let(:confidential) { { selected_options: confidential_selected_options } }
    let(:title) { 'Incident title' }

    let(:zoom) do
      {
        link: {
          value: zoom_link
        }
      }
    end

    let(:params) do
      {
        team: {
          id: slack_installation.team_id
        },
        user: {
          id: slack_installation.user_id
        },
        view: {
          private_metadata: api_url,
          state: {
            values: {
              title_input: {
                title: {
                  value: title
                }
              },
              incident_description: {
                description: {
                  value: 'Incident description'
                }
              },
              project_and_severity_selector: {
                incident_management_project: {
                  selected_option: {
                    value: project.id.to_s
                  }
                },
                severity: severity
              },
              confidentiality: {
                confidential: confidential
              },
              zoom: zoom,
              status_and_assignee_selector: {
                status: {
                  selected_option: {
                    value: status
                  }
                },
                assignee: {
                  selected_option: {
                    value: assignee_id
                  }
                }
              },
              label_selector: {
                labels: label_ids
              }
            }
          }
        }
      }
    end

    subject(:execute_service) { described_class.new(params).execute }

    shared_examples 'error in creation' do |error_message|
      it 'returns error and raises exception' do
        expect(::Gitlab::ErrorTracking).to receive(:track_exception)
          .with(
            described_class::IssueCreateError.new(error_message),
            {
              slack_workspace_id: slack_installation.team_id,
              slack_user_id: slack_installation.user_id
            }
          )

        expect(Gitlab::HTTP).to receive(:post)
          .with(
            api_url,
            body: Gitlab::Json.dump(
              {
                replace_original: 'true',
                text: 'There was a problem creating the incident. Please try again.'
              }
            ),
            headers: { 'Content-Type' => 'application/json' }
          )

        response = execute_service

        expect(response).to be_error
        expect(response.message).to eq(error_message)
      end
    end

    context 'when user has permissions to create incidents' do
      let(:api_response) { '{""ok"":true}' }

      before do
        project.add_developer(user)
        stub_request(:post, api_url)
          .to_return(body: api_response, headers: { 'Content-Type' => 'application/json' })
      end

      context 'with markup string in title' do
        let(:title) { '<a href=""url"">incident title</a>' }
        let(:incident) { create(:incident, title: title, project: project) }

        before do
          allow_next_instance_of(Issues::CreateService) do |service|
            allow(service).to receive(:execute).and_return(
              ServiceResponse.success(payload: { issue: incident, error: [] })
            )
          end
        end

        it 'strips the markup and saves sends the title' do
          expect(Gitlab::HTTP).to receive(:post)
            .with(
              api_url,
              body: Gitlab::Json.dump(
                {
                  replace_original: 'true',
                  text: ""New incident has been created: "" \
                        ""<#{issue_url(incident)}|#{incident.to_reference} - a href=\""url\""incident title/a>. ""
                }
              ),
              headers: { 'Content-Type' => 'application/json' }
            ).and_return(api_response)

          execute_service
        end
      end

      context 'with non-optional params' do
        it 'creates incident' do
          response = execute_service
          incident = response[:incident]

          expect(response).to be_success
          expect(incident).not_to be_nil
          expect(incident.description).to eq('Incident description')
          expect(incident.author).to eq(user)
          expect(incident.severity).to eq('unknown')
          expect(incident.confidential).to be_falsey
          expect(incident.escalation_status).to be_triggered
        end

        it 'sends incident link to slack' do
          execute_service

          expect(WebMock).to have_requested(:post, api_url)
        end
      end

      context 'with zoom_link' do
        let(:zoom_link) { 'https://gitlab.zoom.us/j/1234' }

        it 'sets zoom link as quick action' do
          incident = execute_service[:incident]
          zoom_meeting = ZoomMeeting.find_by_issue_id(incident.id)

          expect(incident.description).to eq(""Incident description"")
          expect(zoom_meeting.url).to eq(zoom_link)
        end
      end

      context 'with confidential and severity' do
        let(:confidential_selected_options) { ['confidential'] }
        let(:severity) do
          {
            selected_option: {
              value: 'high'
            }
          }
        end

        it 'sets confidential and severity' do
          incident = execute_service[:incident]

          expect(incident.confidential).to be_truthy
          expect(incident.severity).to eq('high')
        end
      end

      context 'with incident status' do
        let(:status) { 'resolved' }

        it 'sets the incident status' do
          incident = execute_service[:incident]

          expect(incident.escalation_status).to be_resolved
        end
      end

      context 'with assignee id' do
        let(:assignee_id) { user.id.to_s }

        it 'assigns the incident to user' do
          incident = execute_service[:incident]

          expect(incident.assignees).to contain_exactly(user)
        end

        context 'when user is not a member of the project' do
          let(:assignee_id) { create(:user).id.to_s }

          it 'does not assign the user' do
            incident = execute_service[:incident]

            expect(incident.assignees).to be_empty
          end
        end
      end

      context 'with label ids' do
        let_it_be(:project_label1) { create(:label, project: project, title: 'Label 1') }
        let_it_be(:project_label2) { create(:label, project: project, title: 'Label 2') }

        let(:selected_label_ids) do
          [
            { value: project_label1.id.to_s },
            { value: project_label2.id.to_s }
          ]
        end

        it 'assigns the label to the incident' do
          incident = execute_service[:incident]

          expect(incident.labels).to contain_exactly(project_label1, project_label2)
        end
      end

      context 'when response is not ok' do
        let(:api_response) { '{""ok"":false}' }

        it 'returns error response and tracks the exception' do
          expect(::Gitlab::ErrorTracking).to receive(:track_exception)
            .with(
              StandardError.new('Something went wrong when sending the incident link to Slack.'),
              {
                response: { 'ok' => false },
                slack_workspace_id: slack_installation.team_id,
                slack_user_id: slack_installation.user_id
              }
            )

          execute_service
        end
      end

      context 'when incident creation fails' do
        let(:title) { '' }

        it_behaves_like 'error in creation', ""Title can't be blank""
      end
    end

    context 'when user does not have permission to create incidents' do
      it_behaves_like 'error in creation', 'Operation not allowed'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Integrations
  module SlackInteractions
    module IncidentManagement
      class IncidentModalOpenedService
        MAX_PROJECTS = 100
        CACHE_EXPIRES_IN = 5.minutes

        def initialize(slack_installation, current_user, params)
          @slack_installation = slack_installation
          @current_user = current_user
          @team_id = params[:team_id]
          @response_url = params[:response_url]
          @trigger_id = params[:trigger_id]
        end

        def execute
          if user_projects.empty?
            return ServiceResponse.error(message: _('You do not have access to any projects for creating incidents.'))
          end

          post_modal
        end

        def self.cache_write(view_id, project_id)
          Rails.cache.write(cache_build_key(view_id), project_id, expires_in: CACHE_EXPIRES_IN)
        end

        def self.cache_read(view_id)
          Rails.cache.read(cache_build_key(view_id))
        end

        private

        attr_reader :slack_installation, :current_user, :team_id, :response_url, :trigger_id

        def self.cache_build_key(view_id)
          ""slack:incident_modal_opened:#{view_id}""
        end

        def user_projects
          current_user.projects_where_can_admin_issues.limit(MAX_PROJECTS)
        end

        def post_modal
          begin
            response = ::Slack::API.new(slack_installation).post(
              'views.open',
              modal_view
            )
          rescue *Gitlab::HTTP::HTTP_ERRORS => e
            return ServiceResponse
              .error(message: 'HTTP exception when calling Slack API')
              .track_exception(
                as: e.class,
                slack_workspace_id: team_id
              )
          end

          if response['ok']
            self.class.cache_write(view_id(response), project_id(response))

            return ServiceResponse.success(message: _('Please complete the incident creation form.'))
          end

          ServiceResponse.error(
            message: _('Something went wrong while opening the incident form.'),
            payload: response
          ).track_exception(
            response: response.to_h,
            slack_workspace_id: team_id,
            slack_user_id: slack_installation.user_id
          )
        end

        def modal_view
          {
            trigger_id: trigger_id,
            view: modal_payload
          }
        end

        def modal_payload
          ::Slack::BlockKit::IncidentManagement::IncidentModalOpened.new(
            user_projects,
            response_url
          ).build
        end

        def project_id(response)
          response.dig(
            'view', 'state', 'values',
            'project_and_severity_selector',
            'incident_management_project', 'selected_option',
            'value')
        end

        def view_id(response)
          response.dig('view', 'id')
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Integrations::SlackInteractions::IncidentManagement::IncidentModalOpenedService,
  feature_category: :incident_management do
  describe '#execute' do
    let_it_be(:slack_installation) { create(:slack_integration) }
    let_it_be(:project) { create(:project) }
    let_it_be(:user) { create(:user, developer_projects: [project]) }
    let_it_be(:trigger_id) { '12345.98765.abcd2358fdea' }

    let(:slack_workspace_id) { slack_installation.team_id }
    let(:response_url) { 'https://api.slack.com/id/123' }
    let(:api_url) { ""#{Slack::API::BASE_URL}/views.open"" }
    let(:mock_modal) { { type: 'modal', blocks: [] } }
    let(:params) do
      {
        team_id: slack_workspace_id,
        response_url: response_url,
        trigger_id: trigger_id
      }
    end

    before do
      response = {
        id: '123',
        state: {
          values: {
            project_and_severity_selector: {
              incident_management_project: {
                selected_option: {
                  value: project.id.to_s
                }
              }
            }
          }
        }
      }
      stub_request(:post, api_url)
        .to_return(
          status: 200,
          body: Gitlab::Json.dump({ ok: true, view: response }),
          headers: { 'Content-Type' => 'application/json' }
        )
    end

    subject { described_class.new(slack_installation, user, params) }

    context 'when triggered' do
      it 'opens the modal' do
        expect_next_instance_of(Slack::BlockKit::IncidentManagement::IncidentModalOpened) do |ui|
          expect(ui).to receive(:build).and_return(mock_modal)
        end

        expect(Rails.cache).to receive(:write).with(
          'slack:incident_modal_opened:123', project.id.to_s, { expires_in: 5.minutes })

        response = subject.execute

        expect(WebMock).to have_requested(:post, api_url).with(
          body: {
            trigger_id: trigger_id,
            view: mock_modal
          },
          headers: {
            'Authorization' => ""Bearer #{slack_installation.bot_access_token}"",
            'Content-Type' => 'application/json; charset=utf-8'
          })

        expect(response.message).to eq('Please complete the incident creation form.')
      end
    end

    context 'when there are no projects with slack integration' do
      let(:params) do
        {
          team_id: 'some_random_id',
          response_url: response_url,
          trigger_id: trigger_id
        }
      end

      let(:user) { create(:user) }

      it 'does not open the modal' do
        response = subject.execute

        expect(Rails.cache).not_to receive(:write)
        expect(response.message).to be('You do not have access to any projects for creating incidents.')
      end
    end

    context 'when Slack API call raises an HTTP exception' do
      before do
        allow(Gitlab::HTTP).to receive(:post).and_raise(Errno::ECONNREFUSED, 'error message')
      end

      it 'tracks the exception and returns an error response' do
        expect(::Gitlab::ErrorTracking).to receive(:track_exception)
          .with(
            Errno::ECONNREFUSED.new('HTTP exception when calling Slack API'),
            {
              slack_workspace_id: slack_workspace_id
            }
          )

        expect(Rails.cache).not_to receive(:write)
        expect(subject.execute).to be_error
      end
    end

    context 'when api returns an error' do
      before do
        stub_request(:post, api_url)
          .to_return(
            status: 404,
            body: Gitlab::Json.dump({ ok: false }),
            headers: { 'Content-Type' => 'application/json' }
          )
      end

      it 'returns error when called' do
        expect(::Gitlab::ErrorTracking).to receive(:track_exception)
          .with(
            StandardError.new('Something went wrong while opening the incident form.'),
            {
              response: { ""ok"" => false },
              slack_workspace_id: slack_workspace_id,
              slack_user_id: slack_installation.user_id
            }
          )

        expect(Rails.cache).not_to receive(:write)
        response = subject.execute

        expect(response.message).to eq('Something went wrong while opening the incident form.')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Integrations
  module SlackInteractions
    module IncidentManagement
      class IncidentModalClosedService
        def initialize(params)
          @params = params
        end

        def execute
          begin
            response = close_modal
          rescue *Gitlab::HTTP::HTTP_ERRORS => e
            return ServiceResponse
              .error(message: 'HTTP exception when calling Slack API')
              .track_exception(
                params: params,
                as: e.class
              )
          end

          return ServiceResponse.success if response['ok']

          ServiceResponse.error(
            message: _('Something went wrong while closing the incident form.'),
            payload: response
          ).track_exception(
            response: response.to_h,
            params: params
          )
        end

        private

        attr_accessor :params

        def close_modal
          request_body = Gitlab::Json.dump(close_request_body)
          response_url = params.dig(:view, :private_metadata)

          Gitlab::HTTP.post(response_url, body: request_body, headers: headers)
        end

        def close_request_body
          {
            replace_original: 'true',
            text: _('Incident creation cancelled.')
          }
        end

        def headers
          { 'Content-Type' => 'application/json' }
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Integrations::SlackInteractions::IncidentManagement::IncidentModalClosedService,
  feature_category: :integrations do
  describe '#execute' do
    let_it_be(:request_body) do
      {
        replace_original: 'true',
        text: 'Incident creation cancelled.'
      }
    end

    let(:params) do
      {
        view: {
          private_metadata: 'https://api.slack.com/id/1234'
        }
      }
    end

    let(:service) { described_class.new(params) }

    before do
      allow(Gitlab::HTTP).to receive(:post).and_return({ ok: true })
    end

    context 'when executed' do
      it 'makes the POST call and closes the modal' do
        expect(Gitlab::HTTP).to receive(:post).with(
          'https://api.slack.com/id/1234',
          body: Gitlab::Json.dump(request_body),
          headers: { 'Content-Type' => 'application/json' }
        )

        service.execute
      end
    end

    context 'when the POST call raises an HTTP exception' do
      before do
        allow(Gitlab::HTTP).to receive(:post).and_raise(Errno::ECONNREFUSED, 'error message')
      end

      it 'tracks the exception and returns an error response' do
        expect(::Gitlab::ErrorTracking).to receive(:track_exception)
          .with(
            Errno::ECONNREFUSED.new('HTTP exception when calling Slack API'),
            {
              params: params
            }
          )

        service.execute
      end
    end

    context 'when response is not ok' do
      before do
        allow(Gitlab::HTTP).to receive(:post).and_return({ ok: false })
      end

      it 'returns error response and tracks the exception' do
        expect(::Gitlab::ErrorTracking).to receive(:track_exception)
          .with(
            StandardError.new('Something went wrong while closing the incident form.'),
            {
              response: { ok: false },
              params: params
            }
          )

        service.execute
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Integrations
  module SlackInteractions
    module SlackBlockActions
      module IncidentManagement
        class ProjectUpdateHandler
          include Gitlab::Utils::StrongMemoize

          def initialize(params, action)
            @view = params[:view]
            @action = action
            @team_id = params.dig(:view, :team_id)
            @user_id = params.dig(:user, :id)
          end

          def execute
            return if project_unchanged?
            return unless allowed?

            post_updated_modal
          end

          private

          def allowed?
            return false unless current_user

            current_user.can?(:read_project, old_project) &&
              current_user.can?(:read_project, new_project)
          end

          def current_user
            ChatNames::FindUserService.new(team_id, user_id).execute&.user
          end
          strong_memoize_attr :current_user

          def slack_installation
            SlackIntegration.with_bot.find_by_team_id(team_id)
          end
          strong_memoize_attr :slack_installation

          def post_updated_modal
            modal = update_modal

            begin
              response = ::Slack::API.new(slack_installation).post(
                'views.update',
                {
                  view_id: view[:id],
                  view: modal
                }
              )
            rescue *::Gitlab::HTTP::HTTP_ERRORS => e
              return ServiceResponse
                .error(message: 'HTTP exception when calling Slack API')
                .track_exception(
                  as: e.class,
                  slack_workspace_id: view[:team_id]
                )
            end

            return ServiceResponse.success(message: _('Modal updated')) if response['ok']

            ServiceResponse.error(
              message: _('Something went wrong while updating the modal.'),
              payload: response
            ).track_exception(
              response: response.to_h,
              slack_workspace_id: view[:team_id],
              slack_user_id: slack_installation.user_id
            )
          end

          def update_modal
            updated_view = update_incident_template
            cleanup(updated_view)
          end

          def update_incident_template
            updated_view = view.dup

            incident_description_blocks = updated_view[:blocks].select do |block|
              block[:block_id] == 'incident_description' || block[:block_id] == old_project.id.to_s
            end

            incident_description_blocks.first[:element][:initial_value] = read_template_content
            incident_description_blocks.first[:block_id] = new_project.id.to_s

            Integrations::SlackInteractions::IncidentManagement::IncidentModalOpenedService
              .cache_write(view[:id], new_project.id.to_s)

            updated_view
          end

          def new_project
            Project.find(action.dig(:selected_option, :value))
          end
          strong_memoize_attr :new_project

          def old_project
            old_project_id = Integrations::SlackInteractions::IncidentManagement::IncidentModalOpenedService
              .cache_read(view[:id])

            Project.find(old_project_id) if old_project_id
          end
          strong_memoize_attr :old_project

          def project_unchanged?
            old_project == new_project
          end

          def read_template_content
            new_project.incident_management_setting&.issue_template_content.to_s
          end

          def cleanup(view)
            view.except!(
              :id, :team_id, :state,
              :hash, :previous_view_id,
              :root_view_id, :app_id,
              :app_installed_team_id,
              :bot_id)
          end

          attr_accessor :view, :action, :team_id, :user_id
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Integrations::SlackInteractions::SlackBlockActions::IncidentManagement::ProjectUpdateHandler,
  feature_category: :incident_management do
  describe '#execute' do
    let_it_be(:slack_installation) { create(:slack_integration) }
    let_it_be(:old_project) { create(:project) }
    let_it_be(:new_project) { create(:project) }
    let_it_be(:user) { create(:user, developer_projects: [old_project, new_project]) }
    let_it_be(:chat_name) { create(:chat_name, user: user) }
    let_it_be(:api_url) { ""#{Slack::API::BASE_URL}/views.update"" }

    let(:block) do
      {
        block_id: 'incident_description',
        element: {
          initial_value: ''
        }
      }
    end

    let(:view) do
      {
        id: 'V04EQH1SP27',
        team_id: slack_installation.team_id,
        blocks: [block]
      }
    end

    let(:action) do
      {
        selected_option: {
          value: new_project.id.to_s
        }
      }
    end

    let(:params) do
      {
        view: view,
        user: {
          id: slack_installation.user_id
        }
      }
    end

    before do
      allow_next_instance_of(ChatNames::FindUserService) do |user_service|
        allow(user_service).to receive(:execute).and_return(chat_name)
      end

      stub_request(:post, api_url)
        .to_return(
          status: 200,
          body: Gitlab::Json.dump({ ok: true }),
          headers: { 'Content-Type' => 'application/json' }
        )
    end

    shared_examples 'does not make api call' do
      it 'does not make the api call and returns nil' do
        expect(Rails.cache).to receive(:read).and_return(project.id.to_s)
        expect(Rails.cache).not_to receive(:write)

        expect(execute).to be_nil
        expect(WebMock).not_to have_requested(:post, api_url)
      end
    end

    subject(:execute) { described_class.new(params, action).execute }

    context 'when project is updated' do
      it 'returns success response and updates cache' do
        expect(Rails.cache).to receive(:read).and_return(old_project.id.to_s)
        expect(Rails.cache).to receive(:write).with(
          ""slack:incident_modal_opened:#{view[:id]}"",
          new_project.id.to_s,
          expires_in: 5.minutes
        )

        expect(execute.message).to eq('Modal updated')

        updated_block = block.dup
        updated_block[:block_id] = new_project.id.to_s
        view[:blocks] = [updated_block]

        expect(WebMock).to have_requested(:post, api_url).with(
          body: {
            view_id: view[:id],
            view: view.except!(:team_id, :id)
          },
          headers: {
            'Authorization' => ""Bearer #{slack_installation.bot_access_token}"",
            'Content-Type' => 'application/json; charset=utf-8'
          })
      end
    end

    context 'when project is unchanged' do
      it_behaves_like 'does not make api call' do
        let(:project) { new_project }
      end
    end

    context 'when user does not have permission to read a project' do
      it_behaves_like 'does not make api call' do
        let(:project) { create(:project) }
      end
    end

    context 'when api response is not ok' do
      before do
        stub_request(:post, api_url)
          .to_return(
            status: 404,
            body: Gitlab::Json.dump({ ok: false }),
            headers: { 'Content-Type' => 'application/json' }
          )
      end

      it 'returns error response' do
        expect(Rails.cache).to receive(:read).and_return(old_project.id.to_s)
        expect(::Gitlab::ErrorTracking).to receive(:track_exception)
          .with(
            StandardError.new('Something went wrong while updating the modal.'),
            {
              response: { ""ok"" => false },
              slack_workspace_id: slack_installation.team_id,
              slack_user_id: slack_installation.user_id
            }
          )

        expect(execute.message).to eq('Something went wrong while updating the modal.')
      end
    end

    context 'when Slack API call raises an HTTP exception' do
      before do
        allow(Gitlab::HTTP).to receive(:post).and_raise(Errno::ECONNREFUSED, 'error message')
      end

      it 'tracks the exception and returns an error message' do
        expect(Rails.cache).to receive(:read).and_return(old_project.id.to_s)
        expect(::Gitlab::ErrorTracking).to receive(:track_exception)
          .with(
            Errno::ECONNREFUSED.new('HTTP exception when calling Slack API'),
            {
              slack_workspace_id: slack_installation.team_id
            }
          )

        expect(execute).to be_error
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module GpgKeys
  class DestroyService < Keys::BaseService
    BATCH_SIZE = 1000

    def execute(key)
      nullify_signatures(key)
      key.destroy
    end

    private

    # When a GPG key is deleted, the related signatures have their gpg_key_id column nullified
    # However, when the number of signatures is large, then a timeout may happen
    # The signatures are processed in batches before GPG key delete is attempted in order to
    # avoid timeouts
    def nullify_signatures(key)
      key.gpg_signatures.each_batch(of: BATCH_SIZE) do |batch|
        batch.update_all(gpg_key_id: nil)
      end
    end
  end
end

GpgKeys::DestroyService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe GpgKeys::DestroyService, feature_category: :source_code_management do
  let_it_be(:user) { create(:user) }
  let_it_be(:gpg_key) { create(:gpg_key) }

  subject { described_class.new(user) }

  it 'destroys the GPG key' do
    expect { subject.execute(gpg_key) }.to change(GpgKey, :count).by(-1)
  end

  it 'nullifies the related signatures in batches' do
    stub_const(""#{described_class}::BATCH_SIZE"", 1)

    first_signature = create(:gpg_signature, gpg_key: gpg_key)
    second_signature = create(:gpg_signature, gpg_key: gpg_key)
    third_signature = create(:gpg_signature, gpg_key: create(:another_gpg_key))

    control = ActiveRecord::QueryRecorder.new { subject.execute(gpg_key) }
    expect(control.count).to eq(5)

    expect(first_signature.reload.gpg_key).to be_nil
    expect(second_signature.reload.gpg_key).to be_nil
    expect(third_signature.reload.gpg_key).not_to be_nil
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module GpgKeys
  class CreateService < Keys::BaseService
    def execute
      key = create(params)
      notification_service.new_gpg_key(key) if key.persisted?
      key
    end

    private

    def create(params)
      user.gpg_keys.create(params)
    end
  end
end

GpgKeys::CreateService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe GpgKeys::CreateService, feature_category: :source_code_management do
  let(:user) { create(:user) }
  let(:params) { attributes_for(:gpg_key) }

  subject { described_class.new(user, params) }

  context 'notification', :mailer do
    it 'sends a notification' do
      perform_enqueued_jobs do
        subject.execute
      end
      should_email(user)
    end
  end

  it 'creates a gpg key' do
    expect { subject.execute }.to change { user.gpg_keys.where(params).count }.by(1)
  end

  context 'when the public key contains subkeys' do
    let(:params) { attributes_for(:gpg_key_with_subkeys) }

    it 'generates the gpg subkeys' do
      gpg_key = subject.execute

      expect(gpg_key.subkeys.count).to eq(2)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module GoogleCloud
  class EnableVisionAiService < ::GoogleCloud::BaseService
    def execute
      gcp_project_ids = unique_gcp_project_ids

      if gcp_project_ids.empty?
        error(""No GCP projects found. Configure a service account or GCP_PROJECT_ID ci variable."")
      else
        gcp_project_ids.each do |gcp_project_id|
          google_api_client.enable_vision_api(gcp_project_id)
        end

        success({ gcp_project_ids: gcp_project_ids })
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe GoogleCloud::EnableVisionAiService, feature_category: :deployment_management do
  describe 'when a project does not have any gcp projects' do
    let_it_be(:project) { create(:project) }

    it 'returns error' do
      result = described_class.new(project).execute
      message = 'No GCP projects found. Configure a service account or GCP_PROJECT_ID ci variable.'

      expect(result[:status]).to eq(:error)
      expect(result[:message]).to eq(message)
    end
  end

  describe 'when a project has 3 gcp projects' do
    let_it_be(:project) { create(:project) }

    before do
      project.variables.build(environment_scope: 'production', key: 'GCP_PROJECT_ID', value: 'prj-prod')
      project.variables.build(environment_scope: 'staging', key: 'GCP_PROJECT_ID', value: 'prj-staging')
      project.save!
    end

    it 'enables cloud run, artifacts registry and cloud build', :aggregate_failures do
      expect_next_instance_of(GoogleApi::CloudPlatform::Client) do |instance|
        expect(instance).to receive(:enable_vision_api).with('prj-prod')
        expect(instance).to receive(:enable_vision_api).with('prj-staging')
      end

      result = described_class.new(project).execute

      expect(result[:status]).to eq(:success)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module GoogleCloud
  class GcpRegionAddOrReplaceService < ::GoogleCloud::BaseService
    def execute(environment, region)
      gcp_region_key = Projects::GoogleCloud::GcpRegionsController::GCP_REGION_CI_VAR_KEY

      change_params = { variable_params: { key: gcp_region_key, value: region, environment_scope: environment } }
      filter_params = { key: gcp_region_key, filter: { environment_scope: environment } }

      existing_variable = ::Ci::VariablesFinder.new(project, filter_params).execute.first

      if existing_variable
        change_params[:action] = :update
        change_params[:variable] = existing_variable
      else
        change_params[:action] = :create
      end

      ::Ci::ChangeVariableService.new(container: project, current_user: current_user, params: change_params).execute
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe GoogleCloud::GcpRegionAddOrReplaceService, feature_category: :deployment_management do
  it 'adds and replaces GCP region vars' do
    project = create(:project, :public)
    service = described_class.new(project)

    service.execute('env_1', 'loc_1')
    service.execute('env_2', 'loc_2')
    service.execute('env_1', 'loc_3')

    list = project.variables.reload.filter { |variable| variable.key == Projects::GoogleCloud::GcpRegionsController::GCP_REGION_CI_VAR_KEY }
    list = list.sort_by(&:environment_scope)

    aggregate_failures 'testing list of gcp regions' do
      expect(list.length).to eq(2)

      # asserting that the first region is replaced
      expect(list.first.environment_scope).to eq('env_1')
      expect(list.first.value).to eq('loc_3')

      expect(list.second.environment_scope).to eq('env_2')
      expect(list.second.value).to eq('loc_2')
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module GoogleCloud
  class SetupCloudsqlInstanceService < ::GoogleCloud::BaseService
    INSTANCE_STATE_RUNNABLE = 'RUNNABLE'
    OPERATION_STATE_DONE = 'DONE'
    DEFAULT_DATABASE_NAME = 'main_db'
    DEFAULT_DATABASE_USER = 'main_user'

    def execute
      return error('Unauthorized user') unless Ability.allowed?(current_user, :admin_project_google_cloud, project)

      get_instance_response = google_api_client.get_cloudsql_instance(gcp_project_id, instance_name)

      if get_instance_response.state != INSTANCE_STATE_RUNNABLE
        return error(""CloudSQL instance not RUNNABLE: #{Gitlab::Json.dump(get_instance_response)}"")
      end

      save_instance_ci_vars(get_instance_response)

      list_database_response = google_api_client.list_cloudsql_databases(gcp_project_id, instance_name)
      list_user_response = google_api_client.list_cloudsql_users(gcp_project_id, instance_name)

      existing_database = list_database_response.items.find { |database| database.name == database_name }
      existing_user = list_user_response.items.find { |user| user.name == username }

      if existing_database && existing_user
        save_database_ci_vars
        save_user_ci_vars(existing_user)
        return success
      end

      database_response = execute_database_setup(existing_database)
      return database_response if database_response[:status] == :error

      save_database_ci_vars

      user_response = execute_user_setup(existing_user)
      return user_response if user_response[:status] == :error

      save_user_ci_vars(existing_user)

      success
    rescue Google::Apis::Error => err
      error(message: Gitlab::Json.dump(err))
    end

    private

    def instance_name
      @params[:instance_name]
    end

    def database_version
      @params[:database_version]
    end

    def database_name
      @params.fetch(:database_name, DEFAULT_DATABASE_NAME)
    end

    def username
      @params.fetch(:username, DEFAULT_DATABASE_USER)
    end

    def password
      @password ||= SecureRandom.hex(16)
    end

    def save_ci_var(key, value, is_masked = false)
      create_or_replace_project_vars(environment_name, key, value, @params[:is_protected], is_masked)
    end

    def save_instance_ci_vars(cloudsql_instance)
      primary_ip_address = cloudsql_instance.ip_addresses.first.ip_address
      connection_name = cloudsql_instance.connection_name

      save_ci_var('GCP_PROJECT_ID', gcp_project_id)
      save_ci_var('GCP_CLOUDSQL_INSTANCE_NAME', instance_name)
      save_ci_var('GCP_CLOUDSQL_CONNECTION_NAME', connection_name)
      save_ci_var('GCP_CLOUDSQL_PRIMARY_IP_ADDRESS', primary_ip_address)
      save_ci_var('GCP_CLOUDSQL_VERSION', database_version)
    end

    def save_database_ci_vars
      save_ci_var('GCP_CLOUDSQL_DATABASE_NAME', database_name)
    end

    def save_user_ci_vars(user_exists)
      save_ci_var('GCP_CLOUDSQL_DATABASE_USER', username)
      save_ci_var('GCP_CLOUDSQL_DATABASE_PASS', user_exists ? user_exists.password : password, true)
    end

    def execute_database_setup(database_exists)
      return success if database_exists

      database_response = google_api_client.create_cloudsql_database(gcp_project_id, instance_name, database_name)

      if database_response.status != OPERATION_STATE_DONE
        return error(""Database creation failed: #{Gitlab::Json.dump(database_response)}"")
      end

      success
    end

    def execute_user_setup(existing_user)
      return success if existing_user

      user_response = google_api_client.create_cloudsql_user(gcp_project_id, instance_name, username, password)

      if user_response.status != OPERATION_STATE_DONE
        return error(""User creation failed: #{Gitlab::Json.dump(user_response)}"")
      end

      success
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe GoogleCloud::SetupCloudsqlInstanceService, feature_category: :deployment_management do
  let(:random_user) { create(:user) }
  let(:project) { create(:project) }
  let(:list_databases_empty) { Google::Apis::SqladminV1beta4::ListDatabasesResponse.new(items: []) }
  let(:list_users_empty) { Google::Apis::SqladminV1beta4::ListUsersResponse.new(items: []) }
  let(:list_databases) do
    Google::Apis::SqladminV1beta4::ListDatabasesResponse.new(
      items: [
        Google::Apis::SqladminV1beta4::Database.new(name: 'postgres'),
        Google::Apis::SqladminV1beta4::Database.new(name: 'main_db')
      ])
  end

  let(:list_users) do
    Google::Apis::SqladminV1beta4::ListUsersResponse.new(
      items: [
        Google::Apis::SqladminV1beta4::User.new(name: 'postgres'),
        Google::Apis::SqladminV1beta4::User.new(name: 'main_user')
      ])
  end

  context 'when unauthorized user triggers worker' do
    subject do
      params = {
        gcp_project_id: :gcp_project_id,
        instance_name: :instance_name,
        database_version: :database_version,
        environment_name: :environment_name,
        is_protected: :is_protected
      }
      described_class.new(project, random_user, params).execute
    end

    it 'raises unauthorized error' do
      message = subject[:message]
      status = subject[:status]

      expect(status).to eq(:error)
      expect(message).to eq('Unauthorized user')
    end
  end

  context 'when authorized user triggers worker' do
    subject do
      user = project.creator
      params = {
        gcp_project_id: :gcp_project_id,
        instance_name: :instance_name,
        database_version: :database_version,
        environment_name: :environment_name,
        is_protected: :is_protected
      }
      described_class.new(project, user, params).execute
    end

    context 'when instance is not RUNNABLE' do
      let(:get_instance_response_pending) do
        Google::Apis::SqladminV1beta4::DatabaseInstance.new(state: 'PENDING')
      end

      it 'raises error' do
        allow_next_instance_of(GoogleApi::CloudPlatform::Client) do |google_api_client|
          expect(google_api_client).to receive(:get_cloudsql_instance).and_return(get_instance_response_pending)
        end

        message = subject[:message]
        status = subject[:status]

        expect(status).to eq(:error)
        expect(message).to eq('CloudSQL instance not RUNNABLE: {""state"":""PENDING""}')
      end
    end

    context 'when instance is RUNNABLE' do
      let(:get_instance_response_runnable) do
        Google::Apis::SqladminV1beta4::DatabaseInstance.new(
          connection_name: 'mock-connection-name',
          ip_addresses: [Struct.new(:ip_address).new('1.2.3.4')],
          state: 'RUNNABLE'
        )
      end

      let(:operation_fail) { Google::Apis::SqladminV1beta4::Operation.new(status: 'FAILED') }

      let(:operation_done) { Google::Apis::SqladminV1beta4::Operation.new(status: 'DONE') }

      context 'when database creation fails' do
        it 'raises error' do
          allow_next_instance_of(GoogleApi::CloudPlatform::Client) do |google_api_client|
            expect(google_api_client).to receive(:get_cloudsql_instance).and_return(get_instance_response_runnable)
            expect(google_api_client).to receive(:create_cloudsql_database).and_return(operation_fail)
            expect(google_api_client).to receive(:list_cloudsql_databases).and_return(list_databases_empty)
            expect(google_api_client).to receive(:list_cloudsql_users).and_return(list_users_empty)
          end

          message = subject[:message]
          status = subject[:status]

          expect(status).to eq(:error)
          expect(message).to eq('Database creation failed: {""status"":""FAILED""}')
        end
      end

      context 'when user creation fails' do
        it 'raises error' do
          allow_next_instance_of(GoogleApi::CloudPlatform::Client) do |google_api_client|
            expect(google_api_client).to receive(:get_cloudsql_instance).and_return(get_instance_response_runnable)
            expect(google_api_client).to receive(:create_cloudsql_database).and_return(operation_done)
            expect(google_api_client).to receive(:create_cloudsql_user).and_return(operation_fail)
            expect(google_api_client).to receive(:list_cloudsql_databases).and_return(list_databases_empty)
            expect(google_api_client).to receive(:list_cloudsql_users).and_return(list_users_empty)
          end

          message = subject[:message]
          status = subject[:status]

          expect(status).to eq(:error)
          expect(message).to eq('User creation failed: {""status"":""FAILED""}')
        end
      end

      context 'when database and user already exist' do
        it 'does not try to create a database or user' do
          allow_next_instance_of(GoogleApi::CloudPlatform::Client) do |google_api_client|
            expect(google_api_client).to receive(:get_cloudsql_instance).and_return(get_instance_response_runnable)
            expect(google_api_client).not_to receive(:create_cloudsql_database)
            expect(google_api_client).not_to receive(:create_cloudsql_user)
            expect(google_api_client).to receive(:list_cloudsql_databases).and_return(list_databases)
            expect(google_api_client).to receive(:list_cloudsql_users).and_return(list_users)
          end

          status = subject[:status]
          expect(status).to eq(:success)
        end
      end

      context 'when database already exists' do
        it 'does not try to create a database' do
          allow_next_instance_of(GoogleApi::CloudPlatform::Client) do |google_api_client|
            expect(google_api_client).to receive(:get_cloudsql_instance).and_return(get_instance_response_runnable)
            expect(google_api_client).not_to receive(:create_cloudsql_database)
            expect(google_api_client).to receive(:create_cloudsql_user).and_return(operation_done)
            expect(google_api_client).to receive(:list_cloudsql_databases).and_return(list_databases)
            expect(google_api_client).to receive(:list_cloudsql_users).and_return(list_users_empty)
          end

          status = subject[:status]
          expect(status).to eq(:success)
        end
      end

      context 'when user already exists' do
        it 'does not try to create a user' do
          allow_next_instance_of(GoogleApi::CloudPlatform::Client) do |google_api_client|
            expect(google_api_client).to receive(:get_cloudsql_instance).and_return(get_instance_response_runnable)
            expect(google_api_client).to receive(:create_cloudsql_database).and_return(operation_done)
            expect(google_api_client).not_to receive(:create_cloudsql_user)
            expect(google_api_client).to receive(:list_cloudsql_databases).and_return(list_databases_empty)
            expect(google_api_client).to receive(:list_cloudsql_users).and_return(list_users)
          end

          status = subject[:status]
          expect(status).to eq(:success)
        end
      end

      context 'when database and user creation succeeds' do
        it 'stores project CI vars' do
          allow_next_instance_of(GoogleApi::CloudPlatform::Client) do |google_api_client|
            expect(google_api_client).to receive(:get_cloudsql_instance).and_return(get_instance_response_runnable)
            expect(google_api_client).to receive(:create_cloudsql_database).and_return(operation_done)
            expect(google_api_client).to receive(:create_cloudsql_user).and_return(operation_done)
            expect(google_api_client).to receive(:list_cloudsql_databases).and_return(list_databases_empty)
            expect(google_api_client).to receive(:list_cloudsql_users).and_return(list_users_empty)
          end

          subject

          aggregate_failures 'test generated vars' do
            variables = project.reload.variables

            expect(variables.count).to eq(8)
            expect(variables.find_by(key: 'GCP_PROJECT_ID').value).to eq(""gcp_project_id"")
            expect(variables.find_by(key: 'GCP_CLOUDSQL_INSTANCE_NAME').value).to eq(""instance_name"")
            expect(variables.find_by(key: 'GCP_CLOUDSQL_CONNECTION_NAME').value).to eq(""mock-connection-name"")
            expect(variables.find_by(key: 'GCP_CLOUDSQL_PRIMARY_IP_ADDRESS').value).to eq(""1.2.3.4"")
            expect(variables.find_by(key: 'GCP_CLOUDSQL_VERSION').value).to eq(""database_version"")
            expect(variables.find_by(key: 'GCP_CLOUDSQL_DATABASE_NAME').value).to eq(""main_db"")
            expect(variables.find_by(key: 'GCP_CLOUDSQL_DATABASE_USER').value).to eq(""main_user"")
            expect(variables.find_by(key: 'GCP_CLOUDSQL_DATABASE_PASS').value).to be_present
          end
        end

        context 'when the ci variable already exists' do
          before do
            create(
              :ci_variable,
              project: project,
              key: 'GCP_PROJECT_ID',
              value: 'previous_gcp_project_id',
              environment_scope: :environment_name
            )
          end

          it 'overwrites existing GCP_PROJECT_ID var' do
            allow_next_instance_of(GoogleApi::CloudPlatform::Client) do |google_api_client|
              expect(google_api_client).to receive(:get_cloudsql_instance).and_return(get_instance_response_runnable)
              expect(google_api_client).to receive(:create_cloudsql_database).and_return(operation_done)
              expect(google_api_client).to receive(:create_cloudsql_user).and_return(operation_done)
              expect(google_api_client).to receive(:list_cloudsql_databases).and_return(list_databases_empty)
              expect(google_api_client).to receive(:list_cloudsql_users).and_return(list_users_empty)
            end

            subject

            variables = project.reload.variables
            value = variables.find_by(key: 'GCP_PROJECT_ID', environment_scope: :environment_name).value
            expect(value).to eq(""gcp_project_id"")
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module GoogleCloud
  class GetCloudsqlInstancesService < ::GoogleCloud::BaseService
    CLOUDSQL_KEYS = %w[GCP_PROJECT_ID GCP_CLOUDSQL_INSTANCE_NAME GCP_CLOUDSQL_VERSION].freeze

    def execute
      group_vars_by_environment(CLOUDSQL_KEYS).map do |environment_scope, value|
        {
          ref: environment_scope,
          gcp_project: value['GCP_PROJECT_ID'],
          instance_name: value['GCP_CLOUDSQL_INSTANCE_NAME'],
          version: value['GCP_CLOUDSQL_VERSION']
        }
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe GoogleCloud::GetCloudsqlInstancesService, feature_category: :deployment_management do
  let(:service) { described_class.new(project) }
  let(:project) { create(:project) }

  context 'when project has no registered cloud sql instances' do
    it 'result is empty' do
      expect(service.execute.length).to eq(0)
    end
  end

  context 'when project has registered cloud sql instance' do
    before do
      keys = %w[
        GCP_PROJECT_ID
        GCP_CLOUDSQL_INSTANCE_NAME
        GCP_CLOUDSQL_CONNECTION_NAME
        GCP_CLOUDSQL_PRIMARY_IP_ADDRESS
        GCP_CLOUDSQL_VERSION
        GCP_CLOUDSQL_DATABASE_NAME
        GCP_CLOUDSQL_DATABASE_USER
        GCP_CLOUDSQL_DATABASE_PASS
      ]

      envs = %w[
        *
        STG
        PRD
      ]

      keys.each do |key|
        envs.each do |env|
          project.variables.build(protected: false, environment_scope: env, key: key, value: ""value-#{key}-#{env}"")
        end
      end
    end

    it 'result is grouped by environment', :aggregate_failures do
      expect(service.execute).to contain_exactly(
        {
          ref: '*',
          gcp_project: 'value-GCP_PROJECT_ID-*',
          instance_name: 'value-GCP_CLOUDSQL_INSTANCE_NAME-*',
          version: 'value-GCP_CLOUDSQL_VERSION-*'
        },
        {
          ref: 'STG',
          gcp_project: 'value-GCP_PROJECT_ID-STG',
          instance_name: 'value-GCP_CLOUDSQL_INSTANCE_NAME-STG',
          version: 'value-GCP_CLOUDSQL_VERSION-STG'
        },
        {
          ref: 'PRD',
          gcp_project: 'value-GCP_PROJECT_ID-PRD',
          instance_name: 'value-GCP_CLOUDSQL_INSTANCE_NAME-PRD',
          version: 'value-GCP_CLOUDSQL_VERSION-PRD'
        }
      )
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module GoogleCloud
  class FetchGoogleIpListService
    include BaseServiceUtility

    GOOGLE_IP_RANGES_URL = 'https://www.gstatic.com/ipranges/cloud.json'
    RESPONSE_BODY_LIMIT = 1.megabyte
    EXPECTED_CONTENT_TYPE = 'application/json'

    IpListNotRetrievedError = Class.new(StandardError)

    def execute
      # Prevent too many workers from hitting the same HTTP endpoint
      if ::Gitlab::ApplicationRateLimiter.throttled?(:fetch_google_ip_list, scope: nil)
        return error(""#{self.class} was rate limited"")
      end

      subnets = fetch_and_update_cache!

      Gitlab::AppJsonLogger.info(
        class: self.class.name,
        message: 'Successfully retrieved Google IP list',
        subnet_count: subnets.count
      )

      success({ subnets: subnets })
    rescue IpListNotRetrievedError => err
      Gitlab::ErrorTracking.log_exception(err)
      error('Google IP list not retrieved')
    end

    private

    # Attempts to retrieve and parse the list of IPs from Google. Updates
    # the internal cache so that the data is accessible.
    #
    # Returns an array of IPAddr objects consisting of subnets.
    def fetch_and_update_cache!
      parsed_response = fetch_google_ip_list

      parse_google_prefixes(parsed_response).tap do |subnets|
        ::ObjectStorage::CDN::GoogleIpCache.update!(subnets)
      end
    end

    def fetch_google_ip_list
      response = Gitlab::HTTP.get(GOOGLE_IP_RANGES_URL, follow_redirects: false, allow_local_requests: false)

      validate_response!(response)

      response.parsed_response
    end

    def validate_response!(response)
      raise IpListNotRetrievedError, ""response was #{response.code}"" unless response.code == 200
      raise IpListNotRetrievedError, ""response was nil"" unless response.body

      parsed_response = response.parsed_response

      unless response.content_type == EXPECTED_CONTENT_TYPE && parsed_response.is_a?(Hash)
        raise IpListNotRetrievedError, ""response was not JSON""
      end

      if response.body&.bytesize.to_i > RESPONSE_BODY_LIMIT
        raise IpListNotRetrievedError, ""response was too large: #{response.body.bytesize}""
      end

      prefixes = parsed_response['prefixes']

      raise IpListNotRetrievedError, ""JSON was type #{prefixes.class}, expected Array"" unless prefixes.is_a?(Array)
      raise IpListNotRetrievedError, ""#{GOOGLE_IP_RANGES_URL} did not return any IP ranges"" if prefixes.empty?

      response.parsed_response
    end

    def parse_google_prefixes(parsed_response)
      ranges = parsed_response['prefixes'].map do |prefix|
        ip_range = prefix['ipv4Prefix'] || prefix['ipv6Prefix']

        next unless ip_range

        IPAddr.new(ip_range)
      end.compact

      raise IpListNotRetrievedError, ""#{GOOGLE_IP_RANGES_URL} did not return any IP ranges"" if ranges.empty?

      ranges
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe GoogleCloud::FetchGoogleIpListService, :use_clean_rails_memory_store_caching,
  :clean_gitlab_redis_rate_limiting, feature_category: :build_artifacts do
  include StubRequests

  let(:google_cloud_ips) { File.read(Rails.root.join('spec/fixtures/cdn/google_cloud.json')) }
  let(:headers) { { 'Content-Type' => 'application/json' } }

  subject { described_class.new.execute }

  before do
    WebMock.stub_request(:get, described_class::GOOGLE_IP_RANGES_URL)
      .to_return(status: 200, body: google_cloud_ips, headers: headers)
  end

  describe '#execute' do
    it 'returns a list of IPAddr subnets and caches the result' do
      expect(::ObjectStorage::CDN::GoogleIpCache).to receive(:update!).and_call_original
      expect(subject[:subnets]).to be_an(Array)
      expect(subject[:subnets]).to all(be_an(IPAddr))
    end

    shared_examples 'IP range retrieval failure' do
      it 'does not cache the result and logs an error' do
        expect(Gitlab::ErrorTracking).to receive(:log_exception).and_call_original
        expect(::ObjectStorage::CDN::GoogleIpCache).not_to receive(:update!)
        expect(subject[:subnets]).to be_nil
      end
    end

    context 'with rate limit in effect' do
      before do
        10.times { described_class.new.execute }
      end

      it 'returns rate limit error' do
        expect(subject[:status]).to eq(:error)
        expect(subject[:message]).to eq(""#{described_class} was rate limited"")
      end
    end

    context 'when the URL returns a 404' do
      before do
        WebMock.stub_request(:get, described_class::GOOGLE_IP_RANGES_URL).to_return(status: 404)
      end

      it_behaves_like 'IP range retrieval failure'
    end

    context 'when the URL returns too large of a payload' do
      before do
        stub_const(""#{described_class}::RESPONSE_BODY_LIMIT"", 300)
      end

      it_behaves_like 'IP range retrieval failure'
    end

    context 'when the URL returns HTML' do
      let(:headers) { { 'Content-Type' => 'text/html' } }

      it_behaves_like 'IP range retrieval failure'
    end

    context 'when the URL returns empty results' do
      let(:google_cloud_ips) { '{}' }

      it_behaves_like 'IP range retrieval failure'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module GoogleCloud
  class GeneratePipelineService < ::GoogleCloud::BaseService
    ACTION_DEPLOY_TO_CLOUD_RUN = 'DEPLOY_TO_CLOUD_RUN'
    ACTION_DEPLOY_TO_CLOUD_STORAGE = 'DEPLOY_TO_CLOUD_STORAGE'
    ACTION_VISION_AI_PIPELINE = 'VISION_AI_PIPELINE'

    def execute
      commit_attributes = generate_commit_attributes
      create_branch_response = ::Branches::CreateService.new(project, current_user)
                                                        .execute(commit_attributes[:branch_name], project.default_branch)

      if create_branch_response[:status] == :error
        return create_branch_response
      end

      branch = create_branch_response[:branch]

      service = default_branch_gitlab_ci_yml.present? ? ::Files::UpdateService : ::Files::CreateService

      commit_response = service.new(project, current_user, commit_attributes).execute

      if commit_response[:status] == :error
        return commit_response
      end

      success({ branch_name: branch.name, commit: commit_response })
    end

    private

    def action
      @params[:action]
    end

    def generate_commit_attributes
      case action
      when ACTION_DEPLOY_TO_CLOUD_RUN
        branch_name = ""deploy-to-cloud-run-#{SecureRandom.hex(8)}""
        {
          commit_message: 'Enable Cloud Run deployments',
          file_path: '.gitlab-ci.yml',
          file_content: pipeline_content('gcp/cloud-run.gitlab-ci.yml'),
          branch_name: branch_name,
          start_branch: branch_name
        }
      when ACTION_DEPLOY_TO_CLOUD_STORAGE
        branch_name = ""deploy-to-cloud-storage-#{SecureRandom.hex(8)}""
        {
          commit_message: 'Enable Cloud Storage deployments',
          file_path: '.gitlab-ci.yml',
          file_content: pipeline_content('gcp/cloud-storage.gitlab-ci.yml'),
          branch_name: branch_name,
          start_branch: branch_name
        }
      when ACTION_VISION_AI_PIPELINE
        branch_name = ""vision-ai-pipeline-#{SecureRandom.hex(8)}""
        {
          commit_message: 'Enable Vision AI Pipeline',
          file_path: '.gitlab-ci.yml',
          file_content: pipeline_content('gcp/vision-ai.gitlab-ci.yml'),
          branch_name: branch_name,
          start_branch: branch_name
        }
      end
    end

    def default_branch_gitlab_ci_yml
      @default_branch_gitlab_ci_yml ||= project.ci_config_for(project.default_branch)
    end

    def pipeline_content(include_path)
      gitlab_ci_yml = ::Gitlab::Ci::Config::Yaml::Loader.new(default_branch_gitlab_ci_yml || '{}').load

      append_remote_include(
        gitlab_ci_yml.content,
        ""https://gitlab.com/gitlab-org/incubation-engineering/five-minute-production/library/-/raw/main/#{include_path}""
      )
    end

    def append_remote_include(gitlab_ci_yml, include_url)
      stages = gitlab_ci_yml['stages'] || []
      gitlab_ci_yml['stages'] = if action == ACTION_VISION_AI_PIPELINE
                                  (stages + %w[validate detect render]).uniq
                                else
                                  (stages + %w[build test deploy]).uniq
                                end

      includes = gitlab_ci_yml['include'] || []
      includes = Array.wrap(includes)
      includes << { 'remote' => include_url }
      gitlab_ci_yml['include'] = includes.uniq

      gitlab_ci_yml.deep_stringify_keys.to_yaml
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe GoogleCloud::GeneratePipelineService, feature_category: :deployment_management do
  describe 'for cloud-run' do
    describe 'when there is no existing pipeline' do
      let_it_be(:project) { create(:project, :repository) }
      let_it_be(:maintainer) { create(:user) }
      let_it_be(:service_params) { { action: described_class::ACTION_DEPLOY_TO_CLOUD_RUN } }
      let_it_be(:service) { described_class.new(project, maintainer, service_params) }

      before do
        project.add_maintainer(maintainer)
      end

      it 'creates a new branch with commit for cloud-run deployment' do
        response = service.execute

        branch_name = response[:branch_name]
        commit = response[:commit]
        local_branches = project.repository.local_branches
        created_branch = local_branches.find { |branch| branch.name == branch_name }

        expect(response[:status]).to eq(:success)
        expect(branch_name).to start_with('deploy-to-cloud-run-')
        expect(created_branch).to be_present
        expect(created_branch.target).to eq(commit[:result])
      end

      it 'generated pipeline includes cloud-run deployment' do
        response = service.execute

        ref = response[:commit][:result]
        gitlab_ci_yml = project.ci_config_for(ref)

        expect(response[:status]).to eq(:success)
        expect(gitlab_ci_yml).to include('https://gitlab.com/gitlab-org/incubation-engineering/five-minute-production/library/-/raw/main/gcp/cloud-run.gitlab-ci.yml')
      end

      context 'simulate errors' do
        it 'fails to create branch' do
          allow_next_instance_of(Branches::CreateService) do |create_service|
            allow(create_service).to receive(:execute)
                                       .and_return({ status: :error })
          end

          response = service.execute
          expect(response[:status]).to eq(:error)
        end

        it 'fails to commit changes' do
          allow_next_instance_of(Files::CreateService) do |create_service|
            allow(create_service).to receive(:execute)
                                       .and_return({ status: :error })
          end

          response = service.execute
          expect(response[:status]).to eq(:error)
        end
      end
    end

    describe 'when there is an existing pipeline without `deploy` stage' do
      let_it_be(:project) { create(:project, :repository) }
      let_it_be(:maintainer) { create(:user) }
      let_it_be(:service_params) { { action: GoogleCloud::GeneratePipelineService::ACTION_DEPLOY_TO_CLOUD_RUN } }
      let_it_be(:service) { described_class.new(project, maintainer, service_params) }

      before_all do
        project.add_maintainer(maintainer)

        file_name = '.gitlab-ci.yml'
        file_content = <<EOF
stages:
  - build
  - test

build-java:
  stage: build
  script: mvn clean install

test-java:
  stage: test
  script: mvn clean test
EOF
        project.repository.create_file(
          maintainer,
          file_name,
          file_content,
          message: 'Pipeline with three stages and two jobs',
          branch_name: project.default_branch
        )
      end

      it 'introduces a `deploy` stage and includes the deploy-to-cloud-run job' do
        response = service.execute

        branch_name = response[:branch_name]
        gitlab_ci_yml = project.ci_config_for(branch_name)
        pipeline = Gitlab::Config::Loader::Yaml.new(gitlab_ci_yml).load!

        expect(response[:status]).to eq(:success)
        expect(pipeline[:stages]).to eq(%w[build test deploy])
        expect(pipeline[:include]).to be_present
        expect(gitlab_ci_yml).to include('https://gitlab.com/gitlab-org/incubation-engineering/five-minute-production/library/-/raw/main/gcp/cloud-run.gitlab-ci.yml')
      end

      it 'stringifies keys from the existing pipelines' do
        response = service.execute

        branch_name = response[:branch_name]
        gitlab_ci_yml = project.ci_config_for(branch_name)

        expect(YAML.safe_load(gitlab_ci_yml).keys).to eq(%w[stages build-java test-java include])
      end
    end

    describe 'when there is an existing pipeline with `deploy` stage' do
      let_it_be(:project) { create(:project, :repository) }
      let_it_be(:maintainer) { create(:user) }
      let_it_be(:service_params) { { action: GoogleCloud::GeneratePipelineService::ACTION_DEPLOY_TO_CLOUD_RUN } }
      let_it_be(:service) { described_class.new(project, maintainer, service_params) }

      before do
        project.add_maintainer(maintainer)

        file_name = '.gitlab-ci.yml'
        file_content = <<EOF
stages:
  - build
  - test
  - deploy

build-java:
  stage: build
  script: mvn clean install

test-java:
  stage: test
  script: mvn clean test
EOF
        project.repository.create_file(
          maintainer,
          file_name,
          file_content,
          message: 'Pipeline with three stages and two jobs',
          branch_name: project.default_branch
        )
      end

      it 'includes the deploy-to-cloud-run job' do
        response = service.execute

        branch_name = response[:branch_name]
        gitlab_ci_yml = project.ci_config_for(branch_name)
        pipeline = Gitlab::Config::Loader::Yaml.new(gitlab_ci_yml).load!

        expect(response[:status]).to eq(:success)
        expect(pipeline[:stages]).to eq(%w[build test deploy])
        expect(pipeline[:include]).to be_present
        expect(gitlab_ci_yml).to include('https://gitlab.com/gitlab-org/incubation-engineering/five-minute-production/library/-/raw/main/gcp/cloud-run.gitlab-ci.yml')
      end
    end

    describe 'when there is an existing pipeline with `includes`' do
      let_it_be(:project) { create(:project, :repository) }
      let_it_be(:maintainer) { create(:user) }
      let_it_be(:service_params) { { action: GoogleCloud::GeneratePipelineService::ACTION_DEPLOY_TO_CLOUD_RUN } }
      let_it_be(:service) { described_class.new(project, maintainer, service_params) }

      before do
        project.add_maintainer(maintainer)

        file_name = '.gitlab-ci.yml'
        file_content = <<EOF
stages:
  - build
  - test
  - deploy

include:
  local: 'some-pipeline.yml'
EOF
        project.repository.create_file(
          maintainer,
          file_name,
          file_content,
          message: 'Pipeline with three stages and two jobs',
          branch_name: project.default_branch
        )
      end

      it 'includes the deploy-to-cloud-run job' do
        response = service.execute

        branch_name = response[:branch_name]
        gitlab_ci_yml = project.ci_config_for(branch_name)
        pipeline = Gitlab::Config::Loader::Yaml.new(gitlab_ci_yml).load!

        expect(response[:status]).to eq(:success)
        expect(pipeline[:stages]).to eq(%w[build test deploy])
        expect(pipeline[:include]).to be_present
        expect(gitlab_ci_yml).to include('https://gitlab.com/gitlab-org/incubation-engineering/five-minute-production/library/-/raw/main/gcp/cloud-run.gitlab-ci.yml')
      end
    end
  end

  describe 'for cloud-storage' do
    describe 'when there is no existing pipeline' do
      let_it_be(:project) { create(:project, :repository) }
      let_it_be(:maintainer) { create(:user) }
      let_it_be(:service_params) { { action: GoogleCloud::GeneratePipelineService::ACTION_DEPLOY_TO_CLOUD_STORAGE } }
      let_it_be(:service) { described_class.new(project, maintainer, service_params) }

      before do
        project.add_maintainer(maintainer)
      end

      it 'creates a new branch with commit for cloud-storage deployment' do
        response = service.execute

        branch_name = response[:branch_name]
        commit = response[:commit]
        local_branches = project.repository.local_branches
        search_for_created_branch = local_branches.find { |branch| branch.name == branch_name }

        expect(response[:status]).to eq(:success)
        expect(branch_name).to start_with('deploy-to-cloud-storage-')
        expect(search_for_created_branch).to be_present
        expect(search_for_created_branch.target).to eq(commit[:result])
      end

      it 'generated pipeline includes cloud-storage deployment' do
        response = service.execute

        ref = response[:commit][:result]
        gitlab_ci_yml = project.ci_config_for(ref)

        expect(response[:status]).to eq(:success)
        expect(gitlab_ci_yml).to include('https://gitlab.com/gitlab-org/incubation-engineering/five-minute-production/library/-/raw/main/gcp/cloud-storage.gitlab-ci.yml')
      end
    end
  end

  describe 'for vision ai' do
    let_it_be(:project) { create(:project, :repository) }
    let_it_be(:maintainer) { create(:user) }
    let_it_be(:service_params) { { action: described_class::ACTION_VISION_AI_PIPELINE } }
    let_it_be(:service) { described_class.new(project, maintainer, service_params) }

    describe 'when there is no existing pipeline' do
      before do
        project.add_maintainer(maintainer)
      end

      it 'creates a new branch with commit for cloud-run deployment' do
        response = service.execute

        branch_name = response[:branch_name]
        commit = response[:commit]
        local_branches = project.repository.local_branches
        created_branch = local_branches.find { |branch| branch.name == branch_name }

        expect(response[:status]).to eq(:success)
        expect(branch_name).to start_with('vision-ai-pipeline-')
        expect(created_branch).to be_present
        expect(created_branch.target).to eq(commit[:result])
      end

      it 'generated pipeline includes vision ai deployment' do
        response = service.execute

        ref = response[:commit][:result]
        gitlab_ci_yml = project.ci_config_for(ref)

        expect(response[:status]).to eq(:success)
        expect(gitlab_ci_yml).to include('https://gitlab.com/gitlab-org/incubation-engineering/five-minute-production/library/-/raw/main/gcp/vision-ai.gitlab-ci.yml')
      end

      context 'simulate errors' do
        it 'fails to create branch' do
          allow_next_instance_of(Branches::CreateService) do |create_service|
            allow(create_service).to receive(:execute)
                                       .and_return({ status: :error })
          end

          response = service.execute
          expect(response[:status]).to eq(:error)
        end

        it 'fails to commit changes' do
          allow_next_instance_of(Files::CreateService) do |create_service|
            allow(create_service).to receive(:execute)
                                       .and_return({ status: :error })
          end

          response = service.execute
          expect(response[:status]).to eq(:error)
        end
      end
    end

    describe 'when there is an existing pipeline with `includes`' do
      before do
        project.add_maintainer(maintainer)

        file_name = '.gitlab-ci.yml'
        file_content = <<EOF
stages:
  - validate
  - detect
  - render

include:
  local: 'some-pipeline.yml'
EOF
        project.repository.create_file(
          maintainer,
          file_name,
          file_content,
          message: 'Pipeline with three stages and two jobs',
          branch_name: project.default_branch
        )
      end

      it 'includes the vision ai pipeline' do
        response = service.execute

        branch_name = response[:branch_name]
        gitlab_ci_yml = project.ci_config_for(branch_name)
        pipeline = Gitlab::Config::Loader::Yaml.new(gitlab_ci_yml).load!

        expect(response[:status]).to eq(:success)
        expect(pipeline[:stages]).to eq(%w[validate detect render])
        expect(pipeline[:include]).to be_present
        expect(gitlab_ci_yml).to include('https://gitlab.com/gitlab-org/incubation-engineering/five-minute-production/library/-/raw/main/gcp/vision-ai.gitlab-ci.yml')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module GoogleCloud
  class EnableCloudRunService < ::GoogleCloud::BaseService
    def execute
      gcp_project_ids = unique_gcp_project_ids

      if gcp_project_ids.empty?
        error(""No GCP projects found. Configure a service account or GCP_PROJECT_ID ci variable."")
      else
        gcp_project_ids.each do |gcp_project_id|
          google_api_client.enable_cloud_run(gcp_project_id)
          google_api_client.enable_artifacts_registry(gcp_project_id)
          google_api_client.enable_cloud_build(gcp_project_id)
        end

        success({ gcp_project_ids: gcp_project_ids })
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe GoogleCloud::EnableCloudRunService, feature_category: :deployment_management do
  describe 'when a project does not have any gcp projects' do
    let_it_be(:project) { create(:project) }

    it 'returns error' do
      result = described_class.new(project).execute

      expect(result[:status]).to eq(:error)
      expect(result[:message]).to eq('No GCP projects found. Configure a service account or GCP_PROJECT_ID ci variable.')
    end
  end

  describe 'when a project has 3 gcp projects' do
    let_it_be(:project) { create(:project) }

    before do
      project.variables.build(environment_scope: 'production', key: 'GCP_PROJECT_ID', value: 'prj-prod')
      project.variables.build(environment_scope: 'staging', key: 'GCP_PROJECT_ID', value: 'prj-staging')
      project.save!
    end

    it 'enables cloud run, artifacts registry and cloud build', :aggregate_failures do
      expect_next_instance_of(GoogleApi::CloudPlatform::Client) do |instance|
        expect(instance).to receive(:enable_cloud_run).with('prj-prod')
        expect(instance).to receive(:enable_artifacts_registry).with('prj-prod')
        expect(instance).to receive(:enable_cloud_build).with('prj-prod')
        expect(instance).to receive(:enable_cloud_run).with('prj-staging')
        expect(instance).to receive(:enable_artifacts_registry).with('prj-staging')
        expect(instance).to receive(:enable_cloud_build).with('prj-staging')
      end

      result = described_class.new(project).execute

      expect(result[:status]).to eq(:success)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module GoogleCloud
  class EnableCloudsqlService < ::GoogleCloud::BaseService
    def execute
      create_or_replace_project_vars(environment_name, 'GCP_PROJECT_ID', gcp_project_id, ci_var_protected?)

      unique_gcp_project_ids.each do |gcp_project_id|
        google_api_client.enable_cloud_sql_admin(gcp_project_id)
        google_api_client.enable_compute(gcp_project_id)
        google_api_client.enable_service_networking(gcp_project_id)
      end

      success({ gcp_project_ids: unique_gcp_project_ids })
    rescue Google::Apis::Error => err
      error(err.message)
    end

    private

    def ci_var_protected?
      ProtectedBranch.protected?(project, environment_name) || ProtectedTag.protected?(project, environment_name)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe GoogleCloud::EnableCloudsqlService, feature_category: :deployment_management do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }
  let_it_be(:params) do
    {
      google_oauth2_token: 'mock-token',
      gcp_project_id: 'mock-gcp-project-id',
      environment_name: 'main'
    }
  end

  subject(:result) { described_class.new(project, user, params).execute }

  context 'when a project does not have any GCP_PROJECT_IDs configured' do
    it 'creates GCP_PROJECT_ID project var' do
      expect_next_instance_of(GoogleApi::CloudPlatform::Client) do |instance|
        expect(instance).to receive(:enable_cloud_sql_admin).with('mock-gcp-project-id')
        expect(instance).to receive(:enable_compute).with('mock-gcp-project-id')
        expect(instance).to receive(:enable_service_networking).with('mock-gcp-project-id')
      end

      expect(result[:status]).to eq(:success)
      expect(project.variables.count).to eq(1)
      expect(project.variables.first.key).to eq('GCP_PROJECT_ID')
      expect(project.variables.first.value).to eq('mock-gcp-project-id')
    end
  end

  context 'when a project has GCP_PROJECT_IDs configured' do
    before do
      project.variables.build(environment_scope: 'production', key: 'GCP_PROJECT_ID', value: 'prj-prod')
      project.variables.build(environment_scope: 'staging', key: 'GCP_PROJECT_ID', value: 'prj-staging')
      project.save!
    end

    after do
      project.variables.destroy_all # rubocop:disable Cop/DestroyAll
      project.save!
    end

    it 'enables cloudsql, compute and service networking Google APIs', :aggregate_failures do
      expect_next_instance_of(GoogleApi::CloudPlatform::Client) do |instance|
        expect(instance).to receive(:enable_cloud_sql_admin).with('mock-gcp-project-id')
        expect(instance).to receive(:enable_compute).with('mock-gcp-project-id')
        expect(instance).to receive(:enable_service_networking).with('mock-gcp-project-id')
        expect(instance).to receive(:enable_cloud_sql_admin).with('prj-prod')
        expect(instance).to receive(:enable_compute).with('prj-prod')
        expect(instance).to receive(:enable_service_networking).with('prj-prod')
        expect(instance).to receive(:enable_cloud_sql_admin).with('prj-staging')
        expect(instance).to receive(:enable_compute).with('prj-staging')
        expect(instance).to receive(:enable_service_networking).with('prj-staging')
      end

      expect(result[:status]).to eq(:success)
    end

    context 'when Google APIs raise an error' do
      it 'returns error result' do
        allow_next_instance_of(GoogleApi::CloudPlatform::Client) do |instance|
          allow(instance).to receive(:enable_cloud_sql_admin).with('mock-gcp-project-id')
          allow(instance).to receive(:enable_compute).with('mock-gcp-project-id')
          allow(instance).to receive(:enable_service_networking).with('mock-gcp-project-id')
          allow(instance).to receive(:enable_cloud_sql_admin).with('prj-prod')
          allow(instance).to receive(:enable_compute).with('prj-prod')
          allow(instance).to receive(:enable_service_networking).with('prj-prod')
          allow(instance).to receive(:enable_cloud_sql_admin).with('prj-staging')
          allow(instance).to receive(:enable_compute).with('prj-staging')
          allow(instance).to receive(:enable_service_networking).with('prj-staging')
                                                                .and_raise(Google::Apis::Error.new('error'))
        end

        expect(result[:status]).to eq(:error)
        expect(result[:message]).to eq('error')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module GoogleCloud
  class CreateServiceAccountsService < ::GoogleCloud::BaseService
    def execute
      service_account = google_api_client.create_service_account(gcp_project_id, service_account_name, service_account_desc)
      service_account_key = google_api_client.create_service_account_key(gcp_project_id, service_account.unique_id)
      google_api_client.grant_service_account_roles(gcp_project_id, service_account.email)

      service_accounts_service.add_for_project(
        environment_name,
        service_account.project_id,
        Gitlab::Json.dump(service_account),
        Gitlab::Json.dump(service_account_key),
        ProtectedBranch.protected?(project, environment_name) || ProtectedTag.protected?(project, environment_name)
      )

      ServiceResponse.success(message: _('Service account generated successfully'), payload: {
        service_account: service_account,
        service_account_key: service_account_key
      })
    end

    private

    def service_accounts_service
      GoogleCloud::ServiceAccountsService.new(project)
    end

    def service_account_name
      ""GitLab :: #{project.name} :: #{environment_name}""
    end

    def service_account_desc
      ""GitLab generated service account for project '#{project.name}' and environment '#{environment_name}'""
    end
  end
end

GoogleCloud::CreateServiceAccountsService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe GoogleCloud::CreateServiceAccountsService, feature_category: :deployment_management do
  describe '#execute' do
    before do
      mock_google_oauth2_creds = Struct.new(:app_id, :app_secret)
                                      .new('mock-app-id', 'mock-app-secret')
      allow(Gitlab::Auth::OAuth::Provider).to receive(:config_for)
                                                .with('google_oauth2')
                                                .and_return(mock_google_oauth2_creds)

      allow_next_instance_of(GoogleApi::CloudPlatform::Client) do |client|
        mock_service_account = Struct.new(:project_id, :unique_id, :email)
                                     .new('mock-project-id', 'mock-unique-id', 'mock-email')
        allow(client).to receive(:create_service_account)
                           .and_return(mock_service_account)

        allow(client).to receive(:create_service_account_key)
                           .and_return('mock-key')

        allow(client)
          .to receive(:grant_service_account_roles)
      end
    end

    it 'creates unprotected vars', :aggregate_failures do
      allow(ProtectedBranch).to receive(:protected?).and_return(false)

      project = create(:project)

      service = described_class.new(
        project,
        nil,
        google_oauth2_token: 'mock-token',
        gcp_project_id: 'mock-gcp-project-id',
        environment_name: '*'
      )

      response = service.execute

      expect(response.status).to eq(:success)
      expect(response.message).to eq('Service account generated successfully')
      expect(project.variables.count).to eq(3)
      expect(project.variables.first.protected).to eq(false)
      expect(project.variables.second.protected).to eq(false)
      expect(project.variables.third.protected).to eq(false)
    end

    it 'creates protected vars', :aggregate_failures do
      allow(ProtectedBranch).to receive(:protected?).and_return(true)

      project = create(:project)

      service = described_class.new(
        project,
        nil,
        google_oauth2_token: 'mock-token',
        gcp_project_id: 'mock-gcp-project-id',
        environment_name: '*'
      )

      response = service.execute

      expect(response.status).to eq(:success)
      expect(response.message).to eq('Service account generated successfully')
      expect(project.variables.count).to eq(3)
      expect(project.variables.first.protected).to eq(true)
      expect(project.variables.second.protected).to eq(true)
      expect(project.variables.third.protected).to eq(true)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module GoogleCloud
  DEFAULT_REGION = 'us-east1'

  class CreateCloudsqlInstanceService < ::GoogleCloud::BaseService
    WORKER_INTERVAL = 30.seconds

    def execute
      create_cloud_instance
      trigger_instance_setup_worker
      success
    rescue Google::Apis::Error => err
      error(err.message)
    end

    private

    def create_cloud_instance
      google_api_client.create_cloudsql_instance(
        gcp_project_id,
        instance_name,
        root_password,
        database_version,
        region,
        tier
      )
    end

    def trigger_instance_setup_worker
      GoogleCloud::CreateCloudsqlInstanceWorker.perform_in(
        WORKER_INTERVAL,
        current_user.id,
        project.id,
        {
          'google_oauth2_token': google_oauth2_token,
          'gcp_project_id': gcp_project_id,
          'instance_name': instance_name,
          'database_version': database_version,
          'environment_name': environment_name,
          'is_protected': protected?
        }
      )
    end

    def protected?
      project.protected_for?(environment_name)
    end

    def instance_name
      # Generates an `instance_name` for the to-be-created Cloud SQL instance
      # Example: `gitlab-34647-postgres-14-staging`
      environment_alias = environment_name == '*' ? 'ALL' : environment_name
      name = ""gitlab-#{project.id}-#{database_version}-#{environment_alias}""
      name.tr(""_"", ""-"").downcase
    end

    def root_password
      SecureRandom.hex(16)
    end

    def database_version
      params[:database_version]
    end

    def region
      region = ::Ci::VariablesFinder
                 .new(project, { key: Projects::GoogleCloud::GcpRegionsController::GCP_REGION_CI_VAR_KEY,
                                 environment_scope: environment_name })
                 .execute.first
      region&.value || DEFAULT_REGION
    end

    def tier
      params[:tier]
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe GoogleCloud::CreateCloudsqlInstanceService, feature_category: :deployment_management do
  let(:project) { create(:project) }
  let(:user) { create(:user) }
  let(:gcp_project_id) { 'gcp_project_120' }
  let(:environment_name) { 'test_env_42' }
  let(:database_version) { 'POSTGRES_8000' }
  let(:tier) { 'REIT_TIER' }
  let(:service) do
    described_class.new(project, user, {
      gcp_project_id: gcp_project_id,
      environment_name: environment_name,
      database_version: database_version,
      tier: tier
    })
  end

  describe '#execute' do
    before do
      allow_next_instance_of(::Ci::VariablesFinder) do |variable_finder|
        allow(variable_finder).to receive(:execute).and_return([])
      end
    end

    it 'triggers creation of a cloudsql instance' do
      expect_next_instance_of(GoogleApi::CloudPlatform::Client) do |client|
        expected_instance_name = ""gitlab-#{project.id}-postgres-8000-test-env-42""
        expect(client).to receive(:create_cloudsql_instance).with(
          gcp_project_id,
          expected_instance_name,
          String,
          database_version,
          'us-east1',
          tier
        )
      end

      result = service.execute
      expect(result[:status]).to be(:success)
    end

    it 'triggers worker to manage cloudsql instance creation operation results' do
      expect_next_instance_of(GoogleApi::CloudPlatform::Client) do |client|
        expect(client).to receive(:create_cloudsql_instance)
      end

      expect(GoogleCloud::CreateCloudsqlInstanceWorker).to receive(:perform_in)

      result = service.execute
      expect(result[:status]).to be(:success)
    end

    context 'when google APIs fail' do
      it 'returns error' do
        expect_next_instance_of(GoogleApi::CloudPlatform::Client) do |client|
          expect(client).to receive(:create_cloudsql_instance).and_raise(Google::Apis::Error.new('mock-error'))
        end

        result = service.execute
        expect(result[:status]).to eq(:error)
      end
    end

    context 'when project has GCP_REGION defined' do
      let(:gcp_region) { instance_double(::Ci::Variable, key: 'GCP_REGION', value: 'user-defined-region') }

      before do
        allow_next_instance_of(::Ci::VariablesFinder) do |variable_finder|
          allow(variable_finder).to receive(:execute).and_return([gcp_region])
        end
      end

      it 'uses defined region' do
        expect_next_instance_of(GoogleApi::CloudPlatform::Client) do |client|
          expect(client).to receive(:create_cloudsql_instance).with(
            gcp_project_id,
            String,
            String,
            database_version,
            'user-defined-region',
            tier
          )
        end

        service.execute
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module GoogleCloud
  ##
  # GCP keys used to store Google Cloud Service Accounts
  GCP_KEYS = %w[GCP_PROJECT_ID GCP_SERVICE_ACCOUNT GCP_SERVICE_ACCOUNT_KEY].freeze

  ##
  # This service deals with GCP Service Accounts in GitLab

  class ServiceAccountsService < ::GoogleCloud::BaseService
    ##
    # Find GCP Service Accounts in a GitLab project
    #
    # This method looks up GitLab project's CI vars
    # and returns Google Cloud Service Accounts combinations
    # aligning GitLab project and ref to GCP projects

    def find_for_project
      group_vars_by_environment(GCP_KEYS).map do |environment_scope, value|
        {
          ref: environment_scope,
          gcp_project: value['GCP_PROJECT_ID'],
          service_account_exists: value['GCP_SERVICE_ACCOUNT'].present?,
          service_account_key_exists: value['GCP_SERVICE_ACCOUNT_KEY'].present?
        }
      end
    end

    def add_for_project(ref, gcp_project_id, service_account, service_account_key, is_protected)
      create_or_replace_project_vars(
        ref,
        'GCP_PROJECT_ID',
        gcp_project_id,
        is_protected
      )
      create_or_replace_project_vars(
        ref,
        'GCP_SERVICE_ACCOUNT',
        service_account,
        is_protected
      )
      create_or_replace_project_vars(
        ref,
        'GCP_SERVICE_ACCOUNT_KEY',
        service_account_key,
        is_protected
      )
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe GoogleCloud::ServiceAccountsService, feature_category: :deployment_management do
  let(:service) { described_class.new(project) }

  describe 'find_for_project' do
    let_it_be(:project) { create(:project) }

    context 'when a project does not have GCP service account vars' do
      before do
        project.variables.build(key: 'blah', value: 'foo', environment_scope: 'world')
        project.save!
      end

      it 'returns an empty list' do
        expect(service.find_for_project.length).to eq(0)
      end
    end

    context 'when a project has GCP service account ci vars' do
      before do
        project.variables.build(protected: true, environment_scope: '*', key: 'GCP_PROJECT_ID', value: 'prj1')
        project.variables.build(protected: true, environment_scope: '*', key: 'GCP_SERVICE_ACCOUNT_KEY', value: 'mock')
        project.variables.build(protected: true, environment_scope: 'staging', key: 'GCP_PROJECT_ID', value: 'prj2')
        project.variables.build(protected: true, environment_scope: 'staging', key: 'GCP_SERVICE_ACCOUNT', value: 'mock')
        project.variables.build(protected: true, environment_scope: 'production', key: 'GCP_PROJECT_ID', value: 'prj3')
        project.variables.build(protected: true, environment_scope: 'production', key: 'GCP_SERVICE_ACCOUNT', value: 'mock')
        project.variables.build(protected: true, environment_scope: 'production', key: 'GCP_SERVICE_ACCOUNT_KEY', value: 'mock')
        project.save!
      end

      it 'returns a list of service accounts' do
        list = service.find_for_project

        aggregate_failures 'testing list of service accounts' do
          expect(list.length).to eq(3)

          expect(list.first[:ref]).to eq('*')
          expect(list.first[:gcp_project]).to eq('prj1')
          expect(list.first[:service_account_exists]).to eq(false)
          expect(list.first[:service_account_key_exists]).to eq(true)

          expect(list.second[:ref]).to eq('staging')
          expect(list.second[:gcp_project]).to eq('prj2')
          expect(list.second[:service_account_exists]).to eq(true)
          expect(list.second[:service_account_key_exists]).to eq(false)

          expect(list.third[:ref]).to eq('production')
          expect(list.third[:gcp_project]).to eq('prj3')
          expect(list.third[:service_account_exists]).to eq(true)
          expect(list.third[:service_account_key_exists]).to eq(true)
        end
      end
    end
  end

  describe 'add_for_project' do
    let_it_be(:project) { create(:project) }

    it 'saves GCP creds as project CI vars' do
      service.add_for_project('env_1', 'gcp_prj_id_1', 'srv_acc_1', 'srv_acc_key_1', true)
      service.add_for_project('env_2', 'gcp_prj_id_2', 'srv_acc_2', 'srv_acc_key_2', false)

      list = service.find_for_project

      aggregate_failures 'testing list of service accounts' do
        expect(list.length).to eq(2)

        expect(list.first[:ref]).to eq('env_1')
        expect(list.first[:gcp_project]).to eq('gcp_prj_id_1')
        expect(list.first[:service_account_exists]).to eq(true)
        expect(list.first[:service_account_key_exists]).to eq(true)

        expect(list.second[:ref]).to eq('env_2')
        expect(list.second[:gcp_project]).to eq('gcp_prj_id_2')
        expect(list.second[:service_account_exists]).to eq(true)
        expect(list.second[:service_account_key_exists]).to eq(true)
      end
    end

    it 'replaces previously stored CI vars with new CI vars' do
      service.add_for_project('env_1', 'new_project', 'srv_acc_1', 'srv_acc_key_1', false)

      list = service.find_for_project

      aggregate_failures 'testing list of service accounts' do
        expect(list.length).to eq(2)

        # asserting that the first service account is replaced
        expect(list.first[:ref]).to eq('env_1')
        expect(list.first[:gcp_project]).to eq('new_project')
        expect(list.first[:service_account_exists]).to eq(true)
        expect(list.first[:service_account_key_exists]).to eq(true)

        expect(list.second[:ref]).to eq('env_2')
        expect(list.second[:gcp_project]).to eq('gcp_prj_id_2')
        expect(list.second[:service_account_exists]).to eq(true)
        expect(list.second[:service_account_key_exists]).to eq(true)
      end
    end

    it 'underlying project CI vars must be protected as per value' do
      service.add_for_project('env_1', 'gcp_prj_id_1', 'srv_acc_1', 'srv_acc_key_1', true)
      service.add_for_project('env_2', 'gcp_prj_id_2', 'srv_acc_2', 'srv_acc_key_2', false)

      expect(project.variables[0].protected).to eq(true)
      expect(project.variables[1].protected).to eq(true)
      expect(project.variables[2].protected).to eq(true)
      expect(project.variables[3].protected).to eq(false)
      expect(project.variables[4].protected).to eq(false)
      expect(project.variables[5].protected).to eq(false)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ResourceEvents
  class ChangeMilestoneService < BaseChangeTimeboxService
    attr_reader :milestone, :old_milestone

    def initialize(resource, user, old_milestone:)
      super(resource, user)

      @milestone = resource&.milestone
      @old_milestone = old_milestone
    end

    private

    def track_event
      return unless resource.is_a?(WorkItem)

      Gitlab::UsageDataCounters::WorkItemActivityUniqueCounter.track_work_item_milestone_changed_action(author: user)
    end

    def create_event
      ResourceMilestoneEvent.create(build_resource_args)
    end

    def build_resource_args
      action = milestone.blank? ? :remove : :add

      super.merge({
        state: ResourceMilestoneEvent.states[resource.state],
        action: ResourceTimeboxEvent.actions[action],
        milestone_id: milestone.blank? ? old_milestone&.id : milestone&.id
      })
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ResourceEvents::ChangeMilestoneService, feature_category: :team_planning do
  let_it_be(:timebox) { create(:milestone) }

  let(:created_at_time) { Time.utc(2019, 12, 30) }
  let(:add_timebox_args) { { old_milestone: nil } }
  let(:remove_timebox_args) { { old_milestone: timebox } }

  [:issue, :merge_request].each do |issuable|
    it_behaves_like 'timebox(milestone or iteration) resource events creator', ResourceMilestoneEvent do
      let_it_be(:resource) { create(issuable) } # rubocop:disable Rails/SaveBang
    end
  end

  describe 'events tracking' do
    let_it_be(:user) { create(:user) }

    let(:resource) { create(resource_type, milestone: timebox, project: timebox.project) }

    subject(:service_instance) { described_class.new(resource, user, old_milestone: nil) }

    context 'when the resource is a work item' do
      let(:resource_type) { :work_item }

      it 'tracks work item usage data counters' do
        expect(Gitlab::UsageDataCounters::WorkItemActivityUniqueCounter)
          .to receive(:track_work_item_milestone_changed_action)
          .with(author: user)

        service_instance.execute
      end
    end

    context 'when the resource is not a work item' do
      let(:resource_type) { :issue }

      it 'does not track work item usage data counters' do
        expect(Gitlab::UsageDataCounters::WorkItemActivityUniqueCounter)
          .not_to receive(:track_work_item_milestone_changed_action)

        service_instance.execute
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# We store events about issuable label changes and weight changes in separate tables (not as
# other system notes), but we still want to display notes about label and weight changes
# as classic system notes in UI.  This service merges synthetic label and weight notes
# with classic notes and sorts them by creation time.

module ResourceEvents
  class MergeIntoNotesService
    include Gitlab::Utils::StrongMemoize

    SYNTHETIC_NOTE_BUILDER_SERVICES = [
      SyntheticLabelNotesBuilderService,
      SyntheticMilestoneNotesBuilderService,
      SyntheticStateNotesBuilderService
    ].freeze

    attr_reader :resource, :current_user, :params

    def initialize(resource, current_user, params = {})
      @resource = resource
      @current_user = current_user
      @params = params
    end

    def execute(notes = [])
      (notes + synthetic_notes).sort_by(&:created_at)
    end

    private

    def synthetic_notes
      SYNTHETIC_NOTE_BUILDER_SERVICES.flat_map do |service|
        service.new(resource, current_user, params).execute
      end
    end
  end
end

ResourceEvents::MergeIntoNotesService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ResourceEvents::MergeIntoNotesService, feature_category: :team_planning do
  def create_event(params)
    event_params = { action: :add, label: label, issue: resource,
                     user: user }

    create(:resource_label_event, event_params.merge(params))
  end

  def create_note(params)
    opts = { noteable: resource, project: project }

    create(:note_on_issue, opts.merge(params))
  end

  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }
  let_it_be(:resource) { create(:issue, project: project) }
  let_it_be(:label) { create(:label, project: project) }
  let_it_be(:label2) { create(:label, project: project) }

  let(:time) { Time.current }

  describe '#execute' do
    it 'merges label events into notes in order of created_at' do
      note1 = create_note(created_at: 4.days.ago)
      note2 = create_note(created_at: 2.days.ago)
      event1 = create_event(created_at: 3.days.ago)
      event2 = create_event(created_at: 1.day.ago)

      notes = described_class.new(resource, user).execute([note1, note2])

      expected = [note1, event1, note2, event2].map(&:reload).map(&:discussion_id)
      expect(notes.map(&:discussion_id)).to eq expected
    end

    it 'squashes events with same time and author into single note' do
      user2 = create(:user)

      create_event(created_at: time)
      create_event(created_at: time, label: label2, action: :remove)
      create_event(created_at: time, user: user2)
      create_event(created_at: 1.day.ago, label: label2)

      notes = described_class.new(resource, user).execute

      expected = [
        ""added #{label.to_reference} label and removed #{label2.to_reference} label"",
        ""added #{label.to_reference} label"",
        ""added #{label2.to_reference} label""
      ]

      expect(notes.count).to eq 3
      expect(notes.map(&:note)).to match_array expected
    end

    it 'fetches only notes created after last_fetched_at' do
      create_event(created_at: 4.days.ago)
      event = create_event(created_at: 1.day.ago)

      notes = described_class.new(resource, user, last_fetched_at: 2.days.ago).execute

      expect(notes.count).to eq 1
      expect(notes.first.discussion_id).to eq event.reload.discussion_id
    end

    it ""preloads the note author's status"" do
      event = create_event(created_at: time)
      create(:user_status, user: event.user)

      notes = described_class.new(resource, user).execute

      expect(notes.first.author.association(:status)).to be_loaded
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ResourceEvents
  class ChangeLabelsService
    attr_reader :resource, :user

    def initialize(resource, user)
      @resource = resource
      @user = user
    end

    def execute(added_labels: [], removed_labels: [])
      label_hash = {
        resource_column(resource) => resource.id,
        user_id: user.id,
        created_at: resource.system_note_timestamp
      }

      labels = added_labels.map do |label|
        label_hash.merge(label_id: label.id, action: ResourceLabelEvent.actions['add'])
      end
      labels += removed_labels.map do |label|
        label_hash.merge(label_id: label.id, action: ResourceLabelEvent.actions['remove'])
      end

      ids = ApplicationRecord.legacy_bulk_insert(ResourceLabelEvent.table_name, labels, return_ids: true) # rubocop:disable Gitlab/BulkInsert

      if resource.is_a?(Issue)
        events = ResourceLabelEvent.id_in(ids)
        events.first.trigger_note_subscription_create(events: events.to_a) if events.any?
      end

      create_timeline_events_from(added_labels: added_labels, removed_labels: removed_labels)
      resource.broadcast_notes_changed

      return unless resource.is_a?(Issue)

      Gitlab::UsageDataCounters::IssueActivityUniqueCounter.track_issue_label_changed_action(
        author: user, project: resource.project)

      events
    end

    private

    def resource_column(resource)
      case resource
      when Issue
        :issue_id
      when MergeRequest
        :merge_request_id
      else
        raise ArgumentError, ""Unknown resource type #{resource.class.name}""
      end
    end

    def create_timeline_events_from(added_labels: [], removed_labels: [])
      return unless resource.incident_type_issue?

      IncidentManagement::TimelineEvents::CreateService.change_labels(
        resource,
        user,
        added_labels: added_labels,
        removed_labels: removed_labels
      )
    end
  end
end

ResourceEvents::ChangeLabelsService.prepend_mod_with('ResourceEvents::ChangeLabelsService')

```","# frozen_string_literal: true

require 'spec_helper'

# feature category is shared among plan(issues, epics), monitor(incidents), create(merge request) stages
RSpec.describe ResourceEvents::ChangeLabelsService, feature_category: :team_planning do
  let_it_be(:project) { create(:project) }
  let_it_be(:author)  { create(:user) }
  let_it_be(:issue) { create(:issue, project: project) }
  let_it_be(:incident) { create(:incident, project: project) }

  let(:resource) { issue }

  describe '#execute' do
    shared_examples 'creating timeline events' do
      context 'when resource is not an incident' do
        let(:resource) { issue }

        it 'does not call create timeline events service' do
          expect(IncidentManagement::TimelineEvents::CreateService).not_to receive(:change_labels)

          change_labels
        end
      end

      context 'when resource is an incident' do
        let(:resource) { incident }

        it 'calls create timeline events service with correct attributes' do
          expect(IncidentManagement::TimelineEvents::CreateService)
            .to receive(:change_labels)
            .with(resource, author, added_labels: added, removed_labels: removed)
            .and_call_original

          change_labels
        end
      end
    end

    subject(:change_labels) do
      described_class.new(resource, author).execute(added_labels: added, removed_labels: removed)
    end

    let_it_be(:labels) { create_list(:label, 2, project: project) }

    def expect_label_event(event, label, action)
      expect(event.user).to eq(author)
      expect(event.label).to eq(label)
      expect(event.action).to eq(action)
    end

    it 'broadcasts resource note change' do
      expect(resource).to receive(:broadcast_notes_changed)

      described_class.new(resource, author).execute(added_labels: [labels[0]])
    end

    context 'when adding a label' do
      let(:added)   { [labels[0]] }
      let(:removed) { [] }

      it 'creates new label event' do
        expect { change_labels }.to change { resource.resource_label_events.count }.from(0).to(1)

        expect_label_event(resource.resource_label_events.first, labels[0], 'add')
      end

      it_behaves_like 'creating timeline events'
    end

    context 'when removing a label' do
      let(:added)   { [] }
      let(:removed) { [labels[1]] }

      it 'creates new label event' do
        expect { change_labels }.to change { resource.resource_label_events.count }.from(0).to(1)

        expect_label_event(resource.resource_label_events.first, labels[1], 'remove')
      end

      it_behaves_like 'creating timeline events'
    end

    context 'when both adding and removing labels' do
      let(:added)   { [labels[0]] }
      let(:removed) { [labels[1]] }

      it_behaves_like 'creating timeline events'

      it 'creates all label events in a single query' do
        expect(ApplicationRecord).to receive(:legacy_bulk_insert).once.and_call_original
        expect { change_labels }.to change { resource.resource_label_events.count }.from(0).to(2)
      end

      context 'when resource is a work item' do
        it 'triggers note created subscription' do
          expect(GraphqlTriggers).to receive(:work_item_note_created)

          change_labels
        end
      end

      context 'when resource is an MR' do
        let(:resource) { create(:merge_request, source_project: project) }

        it 'does not trigger note created subscription' do
          expect(GraphqlTriggers).not_to receive(:work_item_note_created)

          change_labels
        end
      end
    end

    describe 'usage data' do
      let(:added)   { [labels[0]] }
      let(:removed) { [labels[1]] }

      subject(:counter_class) { Gitlab::UsageDataCounters::IssueActivityUniqueCounter }

      context 'when resource is an issue' do
        it 'tracks changed labels' do
          expect(counter_class).to receive(:track_issue_label_changed_action)

          change_labels
        end

        it_behaves_like 'internal event tracking' do
          let(:event) { Gitlab::UsageDataCounters::IssueActivityUniqueCounter::ISSUE_LABEL_CHANGED }
          let(:user) { author }
          let(:namespace) { project.namespace }

          subject(:service_action) { change_labels }
        end
      end

      context 'when resource is a merge request' do
        let(:resource) { create(:merge_request, source_project: project) }

        it 'does not track changed labels' do
          expect(counter_class).not_to receive(:track_issue_label_changed_action)

          change_labels
        end

        it 'does not emit snowplow event', :snowplow do
          expect_no_snowplow_event

          change_labels
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ResourceEvents
  class ChangeStateService
    attr_reader :resource, :user

    def initialize(user:, resource:)
      @user = user
      @resource = resource
    end

    def execute(params)
      @params = params

      ResourceStateEvent.create(
        user: user,
        resource.noteable_target_type_name => resource,
        source_commit: commit_id_of(mentionable_source),
        source_merge_request_id: merge_request_id_of(mentionable_source),
        state: ResourceStateEvent.states[state],
        close_after_error_tracking_resolve: close_after_error_tracking_resolve,
        close_auto_resolve_prometheus_alert: close_auto_resolve_prometheus_alert,
        created_at: resource.system_note_timestamp
      )

      resource.broadcast_notes_changed
    end

    private

    attr_reader :params

    def close_auto_resolve_prometheus_alert
      params[:close_auto_resolve_prometheus_alert] || false
    end

    def close_after_error_tracking_resolve
      params[:close_after_error_tracking_resolve] || false
    end

    def state
      params[:status]
    end

    def mentionable_source
      params[:mentionable_source]
    end

    def commit_id_of(mentionable_source)
      return unless mentionable_source.is_a?(Commit)

      mentionable_source.id[0...40]
    end

    def merge_request_id_of(mentionable_source)
      return unless mentionable_source.is_a?(MergeRequest)

      mentionable_source.id
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ResourceEvents::ChangeStateService, feature_category: :team_planning do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }

  let(:issue) { create(:issue, project: project) }
  let(:merge_request) { create(:merge_request, source_project: project) }
  let(:source_commit) { create(:commit, project: project) }
  let(:source_merge_request) { create(:merge_request, source_project: project, target_project: project, target_branch: 'foo') }

  shared_examples 'a state event' do
    %w[opened reopened closed locked].each do |state|
      it ""creates the expected event if resource has #{state} state"" do
        described_class.new(user: user, resource: resource).execute(status: state, mentionable_source: source)

        event = resource.resource_state_events.last

        case resource
        when Issue
          expect(event.issue).to eq(resource)
          expect(event.merge_request).to be_nil
        when MergeRequest
          expect(event.issue).to be_nil
          expect(event.merge_request).to eq(resource)
        end

        expect(event.state).to eq(state)

        expect_event_source(event, source)
      end

      it ""sets the created_at timestamp from the system_note_timestamp"" do
        resource.system_note_timestamp = Time.at(43).utc

        described_class.new(user: user, resource: resource).execute(status: state, mentionable_source: source)
        event = resource.resource_state_events.last

        expect(event.created_at).to eq(Time.at(43).utc)
      end
    end
  end

  describe '#execute' do
    context 'when resource is an Issue' do
      context 'when no source is given' do
        it_behaves_like 'a state event' do
          let(:resource) { issue }
          let(:source) { nil }
        end
      end

      context 'when source commit is given' do
        it_behaves_like 'a state event' do
          let(:resource) { issue }
          let(:source) { source_commit }
        end
      end

      context 'when source merge request is given' do
        it_behaves_like 'a state event' do
          let(:resource) { issue }
          let(:source) { source_merge_request }
        end
      end
    end

    context 'when resource is a MergeRequest' do
      context 'when no source is given' do
        it_behaves_like 'a state event' do
          let(:resource) { merge_request }
          let(:source) { nil }
        end
      end

      context 'when source commit is given' do
        it_behaves_like 'a state event' do
          let(:resource) { merge_request }
          let(:source) { source_commit }
        end
      end

      context 'when source merge request is given' do
        it_behaves_like 'a state event' do
          let(:resource) { merge_request }
          let(:source) { source_merge_request }
        end
      end
    end
  end

  def expect_event_source(event, source)
    case source
    when MergeRequest
      expect(event.source_commit).to be_nil
      expect(event.source_merge_request).to eq(source)
    when Commit
      expect(event.source_commit).to eq(source.id)
      expect(event.source_merge_request).to be_nil
    else
      expect(event.source_merge_request).to be_nil
      expect(event.source_commit).to be_nil
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# We store events about resource milestone changes in a separate table,
# but we still want to display notes about milestone changes
# as classic system notes in UI. This service generates ""synthetic"" notes for
# milestone event changes.

module ResourceEvents
  class SyntheticMilestoneNotesBuilderService < BaseSyntheticNotesBuilderService
    private

    def synthetic_notes
      milestone_change_events.map do |event|
        MilestoneNote.from_event(event, resource: resource, resource_parent: resource_parent)
      end
    end

    def milestone_change_events
      return [] unless resource.respond_to?(:resource_milestone_events)

      events = resource.resource_milestone_events.includes(:milestone, user: :status) # rubocop: disable CodeReuse/ActiveRecord
      apply_common_filters(events)
    end

    def table_name
      'resource_milestone_events'
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ResourceEvents::SyntheticMilestoneNotesBuilderService, feature_category: :team_planning do
  describe '#execute' do
    let_it_be(:user) { create(:user) }
    let_it_be(:issue) { create(:issue, author: user) }
    let_it_be(:milestone) { create(:milestone, project: issue.project) }

    let_it_be(:events) do
      [
        create(:resource_milestone_event, issue: issue, milestone: milestone, action: :add, created_at: '2020-01-01 04:00'),
        create(:resource_milestone_event, issue: issue, milestone: milestone, action: :remove, created_at: '2020-01-02 08:00'),
        create(:resource_milestone_event, issue: issue, milestone: nil, action: :remove, created_at: '2020-01-02 08:00')
      ]
    end

    it 'builds milestone notes for resource milestone events' do
      notes = described_class.new(issue, user).execute

      expect(notes.map(&:created_at)).to eq(events.map(&:created_at))
      expect(notes.map(&:note)).to eq(
        [
          ""changed milestone to %#{milestone.iid}"",
          ""removed milestone %#{milestone.iid}"",
          ""removed milestone ""
        ])
    end

    it_behaves_like 'filters by paginated notes', :resource_milestone_event
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# We store events about issuable label changes in a separate table (not as
# other system notes), but we still want to display notes about label changes
# as classic system notes in UI.  This service generates ""synthetic"" notes for
# label event changes.

module ResourceEvents
  class SyntheticLabelNotesBuilderService < BaseSyntheticNotesBuilderService
    private

    def synthetic_notes
      label_events_by_discussion_id.map do |discussion_id, events|
        LabelNote.from_events(events, resource: resource, resource_parent: resource_parent)
      end
    end

    def label_events_by_discussion_id
      return [] unless resource.respond_to?(:resource_label_events)

      events = resource.resource_label_events.includes(:label, user: :status) # rubocop: disable CodeReuse/ActiveRecord
      events = apply_common_filters(events)

      events.group_by { |event| event.discussion_id }
    end

    def table_name
      'resource_label_events'
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ResourceEvents::SyntheticLabelNotesBuilderService, feature_category: :team_planning do
  describe '#execute' do
    let_it_be(:user) { create(:user) }

    let_it_be(:issue) { create(:issue, author: user) }

    let_it_be(:event1) { create(:resource_label_event, issue: issue) }
    let_it_be(:event2) { create(:resource_label_event, issue: issue) }
    let_it_be(:event3) { create(:resource_label_event, issue: issue) }

    it 'returns the expected synthetic notes' do
      notes = described_class.new(issue, user).execute

      expect(notes.size).to eq(3)
    end

    it_behaves_like 'filters by paginated notes', :resource_label_event
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ResourceEvents
  class SyntheticStateNotesBuilderService < BaseSyntheticNotesBuilderService
    private

    def synthetic_notes
      state_change_events.map do |event|
        StateNote.from_event(event, resource: resource, resource_parent: resource_parent)
      end
    end

    def state_change_events
      return [] unless resource.respond_to?(:resource_state_events)

      events = resource.resource_state_events.includes(user: :status) # rubocop: disable CodeReuse/ActiveRecord
      apply_common_filters(events)
    end

    def table_name
      'resource_state_events'
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ResourceEvents::SyntheticStateNotesBuilderService, feature_category: :team_planning do
  describe '#execute' do
    let_it_be(:user) { create(:user) }

    it_behaves_like 'filters by paginated notes', :resource_state_event
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module DraftNotes
  class PublishService < DraftNotes::BaseService
    def execute(draft = nil)
      return error('Not allowed to create notes') unless can?(current_user, :create_note, merge_request)

      if draft
        publish_draft_note(draft)
      else
        publish_draft_notes
        merge_request_activity_counter.track_publish_review_action(user: current_user)
      end

      success
    rescue ActiveRecord::RecordInvalid => e
      message = ""Unable to save #{e.record.class.name}: #{e.record.errors.full_messages.join("", "")} ""
      error(message)
    end

    private

    def publish_draft_note(draft)
      create_note_from_draft(draft)
      draft.delete

      MergeRequests::ResolvedDiscussionNotificationService.new(project: project, current_user: current_user).execute(merge_request)
    end

    def publish_draft_notes
      return if draft_notes.empty?

      review = Review.create!(author: current_user, merge_request: merge_request, project: project)

      created_notes = draft_notes.map do |draft_note|
        draft_note.review = review
        create_note_from_draft(
          draft_note,
          skip_capture_diff_note_position: true,
          skip_keep_around_commits: true,
          skip_merge_status_trigger: true
        )
      end

      capture_diff_note_positions(created_notes)
      keep_around_commits(created_notes)
      draft_notes.delete_all
      set_reviewed
      notification_service.async.new_review(review)
      MergeRequests::ResolvedDiscussionNotificationService.new(project: project, current_user: current_user).execute(merge_request)
      GraphqlTriggers.merge_request_merge_status_updated(merge_request)
      after_publish(review)
    end

    def create_note_from_draft(draft, skip_capture_diff_note_position: false, skip_keep_around_commits: false, skip_merge_status_trigger: false)
      # Make sure the diff file is unfolded in order to find the correct line
      # codes.
      draft.diff_file&.unfold_diff_lines(draft.original_position)

      note_params = draft.publish_params.merge(skip_keep_around_commits: skip_keep_around_commits)
      note = Notes::CreateService.new(draft.project, draft.author, note_params).execute(
        skip_capture_diff_note_position: skip_capture_diff_note_position,
        skip_merge_status_trigger: skip_merge_status_trigger,
        skip_set_reviewed: true
      )

      set_discussion_resolve_status(note, draft)
      note
    end

    def set_discussion_resolve_status(note, draft_note)
      return unless draft_note.discussion_id.present?

      discussion = note.discussion

      if draft_note.resolve_discussion && discussion.can_resolve?(current_user)
        discussion.resolve!(current_user)
      else
        discussion.unresolve!
      end
    end

    def set_reviewed
      return if Feature.enabled?(:mr_request_changes, current_user)

      ::MergeRequests::UpdateReviewerStateService.new(project: project, current_user: current_user).execute(merge_request, ""reviewed"")
    end

    def capture_diff_note_positions(notes)
      paths = notes.flat_map do |note|
        note.diff_file&.paths if note.diff_note?
      end

      return if paths.empty?

      capture_service = Discussions::CaptureDiffNotePositionService.new(merge_request, paths.compact)

      notes.each do |note|
        capture_service.execute(note.discussion) if note.diff_note? && note.start_of_discussion?
      end
    end

    def keep_around_commits(notes)
      shas = notes.flat_map do |note|
        note.shas if note.diff_note?
      end.uniq

      # We are allowing this since gitaly call will be created for each sha and
      # even though they're unique, there will still be multiple Gitaly calls.
      Gitlab::GitalyClient.allow_n_plus_1_calls do
        project.repository.keep_around(*shas)
      end
    end

    def after_publish(review)
      # Overridden in EE
    end
  end
end

DraftNotes::PublishService.prepend_mod

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe DraftNotes::PublishService, feature_category: :code_review_workflow do
  include RepoHelpers

  let_it_be(:merge_request) { create(:merge_request, reviewers: create_list(:user, 1)) }
  let(:project) { merge_request.target_project }
  let(:user) { merge_request.author }
  let(:commit) { project.commit(sample_commit.id) }

  let(:position) do
    Gitlab::Diff::Position.new(
      old_path: ""files/ruby/popen.rb"",
      new_path: ""files/ruby/popen.rb"",
      old_line: nil,
      new_line: 14,
      diff_refs: commit.diff_refs
    )
  end

  def publish(draft: nil)
    DraftNotes::PublishService.new(merge_request, user).execute(draft)
  end

  context 'single draft note' do
    let(:commit_id) { nil }
    let!(:drafts) { create_list(:draft_note, 2, merge_request: merge_request, author: user, commit_id: commit_id, position: position) }

    it 'publishes' do
      expect { publish(draft: drafts.first) }.to change { DraftNote.count }.by(-1).and change { Note.count }.by(1)
      expect(DraftNote.count).to eq(1)
    end

    it 'does not skip notification', :sidekiq_might_not_need_inline do
      note_params = drafts.first.publish_params.merge(skip_keep_around_commits: false)
      expect(Notes::CreateService).to receive(:new).with(project, user, note_params).and_call_original
      expect_next_instance_of(NotificationService) do |notification_service|
        expect(notification_service).to receive(:new_note)
      end

      result = publish(draft: drafts.first)

      expect(result[:status]).to eq(:success)
    end

    it 'does not track the publish event' do
      expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
        .not_to receive(:track_publish_review_action)

      publish(draft: drafts.first)
    end

    context 'commit_id is set' do
      let(:commit_id) { commit.id }

      it 'creates note from draft with commit_id' do
        result = publish(draft: drafts.first)

        expect(result[:status]).to eq(:success)
        expect(merge_request.notes.first.commit_id).to eq(commit_id)
      end
    end
  end

  context 'multiple draft notes' do
    let(:commit_id) { nil }

    before do
      create(:draft_note_on_text_diff, merge_request: merge_request, author: user, note: 'first note', commit_id: commit_id, position: position)
      create(:draft_note_on_text_diff, merge_request: merge_request, author: user, note: 'second note', commit_id: commit_id, position: position)
    end

    context 'when review fails to create' do
      before do
        expect_next_instance_of(Review) do |review|
          allow(review).to receive(:save!).and_raise(ActiveRecord::RecordInvalid.new(review))
        end
      end

      it_behaves_like 'does not trigger GraphQL subscription mergeRequestMergeStatusUpdated' do
        let(:action) { publish }
      end

      it 'does not publish any draft note' do
        expect { publish }.not_to change { DraftNote.count }
      end

      it 'does not track the publish event' do
        expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
          .not_to receive(:track_publish_review_action)

        publish
      end

      it 'returns an error' do
        result = publish

        expect(result[:status]).to eq(:error)
        expect(result[:message]).to match(/Unable to save Review/)
      end
    end

    it_behaves_like 'triggers GraphQL subscription mergeRequestMergeStatusUpdated' do
      let(:action) { publish }
    end

    it 'returns success' do
      result = publish

      expect(result[:status]).to eq(:success)
    end

    it 'publishes all draft notes for a user in a merge request' do
      expect { publish }.to change { DraftNote.count }.by(-2).and change { Note.count }.by(2).and change { Review.count }.by(1)
      expect(DraftNote.count).to eq(0)

      notes = merge_request.notes.order(id: :asc)
      expect(notes.first.note).to eq('first note')
      expect(notes.last.note).to eq('second note')
    end

    it 'sends batch notification' do
      expect_next_instance_of(NotificationService) do |notification_service|
        expect(notification_service).to receive_message_chain(:async, :new_review).with(kind_of(Review))
      end

      publish
    end

    it 'tracks the publish event' do
      expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
        .to receive(:track_publish_review_action)
        .with(user: user)

      publish
    end

    context 'capturing diff notes positions and keeping around commits' do
      before do
        # Need to execute this to ensure that we'll be able to test creation of
        # DiffNotePosition records as that only happens when the `MergeRequest#merge_ref_head`
        # is present. This service creates that for the specified merge request.
        MergeRequests::MergeToRefService.new(project: project, current_user: user).execute(merge_request)

        # Need to re-stub this and call original as we are stubbing
        # `Gitlab::Git::KeepAround#execute` in spec_helper for performance reason.
        # Enabling it here so we can test the Gitaly calls it makes.
        allow(Gitlab::Git::KeepAround).to receive(:execute).and_call_original
      end

      it 'creates diff_note_positions for diff notes' do
        publish

        notes = merge_request.notes.order(id: :asc)
        expect(notes.first.diff_note_positions).to be_any
        expect(notes.last.diff_note_positions).to be_any
      end

      it 'keeps around the commits of each published note' do
        publish

        repository = project.repository
        notes = merge_request.notes.order(id: :asc)

        notes.first.shas.each do |sha|
          expect(repository.ref_exists?(""refs/keep-around/#{sha}"")).to be_truthy
        end

        notes.last.shas.each do |sha|
          expect(repository.ref_exists?(""refs/keep-around/#{sha}"")).to be_truthy
        end
      end

      it 'does not request a lot from Gitaly', :request_store, :clean_gitlab_redis_cache do
        merge_request
        position

        Gitlab::GitalyClient.reset_counts

        # NOTE: This should be reduced as we work on reducing Gitaly calls.
        # Gitaly requests shouldn't go above this threshold as much as possible
        # as it may add more to the Gitaly N+1 issue we are experiencing.
        expect { publish }.to change { Gitlab::GitalyClient.get_request_count }.by(19)
      end
    end

    context 'commit_id is set' do
      let(:commit_id) { commit.id }

      it 'creates note from draft with commit_id' do
        result = publish

        expect(result[:status]).to eq(:success)

        merge_request.notes.each do |note|
          expect(note.commit_id).to eq(commit_id)
        end
      end
    end

    it 'does not call UpdateReviewerStateService' do
      publish

      expect(MergeRequests::UpdateReviewerStateService).not_to receive(:new)
    end

    context 'when `mr_request_changes` feature flag is disabled' do
      before do
        stub_feature_flags(mr_request_changes: false)
      end

      it 'calls UpdateReviewerStateService' do
        expect_next_instance_of(
          MergeRequests::UpdateReviewerStateService,
          project: project, current_user: user
        ) do |service|
          expect(service).to receive(:execute).with(merge_request, ""reviewed"")
        end

        publish
      end
    end
  end

  context 'draft notes with suggestions' do
    let(:project) { create(:project, :repository) }
    let(:merge_request) { create(:merge_request, source_project: project, target_project: project) }

    let(:suggestion_note) do
      <<-MARKDOWN.strip_heredoc
        ```suggestion
          foo
        ```
      MARKDOWN
    end

    let!(:draft) { create(:draft_note_on_text_diff, note: suggestion_note, merge_request: merge_request, author: user) }

    it 'creates a suggestion with correct content' do
      expect { publish(draft: draft) }.to change { Suggestion.count }.by(1)
        .and change { DiffNote.count }.from(0).to(1)

      suggestion = Suggestion.last

      expect(suggestion.from_line).to eq(14)
      expect(suggestion.to_line).to eq(14)
      expect(suggestion.from_content).to eq(""    vars = {\n"")
      expect(suggestion.to_content).to eq(""  foo\n"")
    end

    context 'when the diff is changed' do
      let(:file_path) { 'files/ruby/popen.rb' }
      let(:branch_name) { project.default_branch }
      let(:commit) { project.repository.commit }

      def update_file(file_path, new_content)
        params = {
          file_path: file_path,
          commit_message: ""Update File"",
          file_content: new_content,
          start_project: project,
          start_branch: project.default_branch,
          branch_name: branch_name
        }

        Files::UpdateService.new(project, user, params).execute
      end

      before do
        project.add_developer(user)
      end

      it 'creates a suggestion based on the latest diff content and positions' do
        diff_file = merge_request.diffs(paths: [file_path]).diff_files.first
        raw_data = diff_file.new_blob.data

        # Add a line break to the beginning of the file
        result = update_file(file_path, raw_data.prepend(""\n""))
        oldrev = merge_request.diff_head_sha
        newrev = result[:result]

        expect(newrev).to be_present

        # Generates new MR revision at DB level
        refresh = MergeRequests::RefreshService.new(project: project, current_user: user)
        refresh.execute(oldrev, newrev, merge_request.source_branch_ref)

        expect { publish(draft: draft) }.to change { Suggestion.count }.by(1)
          .and change { DiffNote.count }.from(0).to(1)

        suggestion = Suggestion.last

        expect(suggestion.from_line).to eq(15)
        expect(suggestion.to_line).to eq(15)
        expect(suggestion.from_content).to eq(""    vars = {\n"")
        expect(suggestion.to_content).to eq(""  foo\n"")
      end
    end
  end

  it 'only publishes the draft notes belonging to the current user' do
    other_user = create(:user)
    project.add_maintainer(other_user)

    create_list(:draft_note, 2, merge_request: merge_request, author: user)
    create_list(:draft_note, 2, merge_request: merge_request, author: other_user)

    expect { publish }.to change { DraftNote.count }.by(-2).and change { Note.count }.by(2)
    expect(DraftNote.count).to eq(2)
  end

  context 'with quick actions', :sidekiq_inline do
    it 'performs quick actions' do
      other_user = create(:user)
      project.add_developer(other_user)

      create(
        :draft_note,
        merge_request: merge_request,
        author: user,
        note: ""thanks\n/assign #{other_user.to_reference}""
      )

      expect { publish }.to change { DraftNote.count }.by(-1).and change { Note.count }.by(2)
      expect(merge_request.reload.assignees).to match_array([other_user])
      expect(merge_request.notes.last).to be_system
    end

    it 'does not create a note if it only contains quick actions' do
      create(:draft_note, merge_request: merge_request, author: user, note: ""/assign #{user.to_reference}"")

      expect { publish }.to change { DraftNote.count }.by(-1).and change { Note.count }.by(1)
      expect(merge_request.reload.assignees).to eq([user])
      expect(merge_request.notes.last).to be_system
    end
  end

  context 'with drafts that resolve threads' do
    let!(:note) { create(:discussion_note_on_merge_request, noteable: merge_request, project: project) }
    let!(:draft_note) { create(:draft_note, merge_request: merge_request, author: user, resolve_discussion: true, discussion_id: note.discussion.reply_id) }

    it 'resolves the thread' do
      publish(draft: draft_note)

      # discussion is memoized and reload doesn't clear the memoization
      expect(Note.find(note.id).discussion.resolved?).to be true
    end

    it 'sends notifications if all threads are resolved' do
      expect_next_instance_of(MergeRequests::ResolvedDiscussionNotificationService) do |instance|
        expect(instance).to receive(:execute).with(merge_request)
      end

      publish
    end
  end

  context 'user cannot create notes' do
    before do
      allow(Ability).to receive(:allowed?).with(user, :create_note, merge_request).and_return(false)
    end

    it 'returns an error' do
      expect(publish[:status]).to eq(:error)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module DraftNotes
  class DestroyService < DraftNotes::BaseService
    # If no `draft` is given it fallsback to all
    # draft notes of the given merge request and user.
    def execute(draft = nil)
      drafts = draft || draft_notes

      clear_highlight_diffs_cache(Array.wrap(drafts))

      drafts.is_a?(DraftNote) ? drafts.destroy! : drafts.delete_all
    end

    private

    def clear_highlight_diffs_cache(drafts)
      if drafts.any? { |draft| draft.diff_file&.unfolded? }
        merge_request.diffs.clear_cache
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe DraftNotes::DestroyService, feature_category: :code_review_workflow do
  let(:merge_request) { create(:merge_request) }
  let(:project) { merge_request.target_project }
  let(:user) { merge_request.author }

  def destroy(draft_note = nil)
    DraftNotes::DestroyService.new(merge_request, user).execute(draft_note)
  end

  it 'destroys a single draft note' do
    drafts = create_list(:draft_note, 2, merge_request: merge_request, author: user)

    expect { destroy(drafts.first) }
      .to change { DraftNote.count }.by(-1)

    expect(DraftNote.count).to eq(1)
  end

  it 'destroys all draft notes for a user in a merge request' do
    create_list(:draft_note, 2, merge_request: merge_request, author: user)

    expect { destroy }.to change { DraftNote.count }.by(-2) # rubocop:disable Rails/SaveBang
    expect(DraftNote.count).to eq(0)
  end

  context 'diff highlight cache clearing' do
    context 'when destroying all draft notes of a user' do
      it 'clears highlighting cache if unfold required for any' do
        drafts = create_list(:draft_note, 2, merge_request: merge_request, author: user)

        allow_any_instance_of(DraftNote).to receive_message_chain(:diff_file, :unfolded?) { true }
        expect(merge_request).to receive_message_chain(:diffs, :clear_cache)

        destroy(drafts.first)
      end
    end

    context 'when destroying one draft note' do
      it 'clears highlighting cache if unfold required' do
        create_list(:draft_note, 2, merge_request: merge_request, author: user)

        allow_any_instance_of(DraftNote).to receive_message_chain(:diff_file, :unfolded?) { true }
        expect(merge_request).to receive_message_chain(:diffs, :clear_cache)

        destroy # rubocop:disable Rails/SaveBang
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module DraftNotes
  class CreateService < DraftNotes::BaseService
    attr_accessor :in_draft_mode, :in_reply_to_discussion_id

    def initialize(merge_request, current_user, params = nil)
      @in_reply_to_discussion_id = params.delete(:in_reply_to_discussion_id)
      super
    end

    def execute
      if in_reply_to_discussion_id.present?
        unless discussion
          return base_error(_('Thread to reply to cannot be found'))
        end

        params[:discussion_id] = discussion.reply_id
      end

      if params[:resolve_discussion] && !can_resolve_discussion?
        return base_error(_('User is not allowed to resolve thread'))
      end

      draft_note = DraftNote.new(params)
      draft_note.merge_request = merge_request
      draft_note.author = current_user

      return draft_note unless draft_note.save

      if in_reply_to_discussion_id.blank? && draft_note.diff_file&.unfolded?
        merge_request.diffs.clear_cache
      end

      if draft_note.persisted?
        merge_request_activity_counter.track_create_review_note_action(user: current_user)
      end

      draft_note
    end

    private

    def base_error(text)
      DraftNote.new.tap do |draft|
        draft.errors.add(:base, text)
      end
    end

    def discussion
      @discussion ||= merge_request.notes.find_discussion(in_reply_to_discussion_id)
    end

    def can_resolve_discussion?
      note = discussion&.notes&.first
      return false unless note

      current_user && Ability.allowed?(current_user, :resolve_note, note)
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe DraftNotes::CreateService, feature_category: :code_review_workflow do
  let(:merge_request) { create(:merge_request) }
  let(:project) { merge_request.target_project }
  let(:user) { merge_request.author }

  def create_draft(params)
    described_class.new(merge_request, user, params).execute
  end

  it 'creates a simple draft note' do
    draft = create_draft(note: 'This is a test')

    expect(draft).to be_an_instance_of(DraftNote)
    expect(draft.note).to eq('This is a test')
    expect(draft.author).to eq(user)
    expect(draft.project).to eq(merge_request.target_project)
    expect(draft.discussion_id).to be_nil
  end

  it 'tracks the start event when the draft is persisted' do
    expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
      .to receive(:track_create_review_note_action)
      .with(user: user)

    draft = create_draft(note: 'This is a test')
    expect(draft).to be_persisted
  end

  it 'does not track the start event when the draft is not persisted' do
    expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
      .not_to receive(:track_create_review_note_action)

    draft = create_draft(note: 'Not a reply!', resolve_discussion: true)
    expect(draft).not_to be_persisted
  end

  it 'cannot resolve when there is nothing to resolve' do
    draft = create_draft(note: 'Not a reply!', resolve_discussion: true)

    expect(draft.errors[:base]).to include('User is not allowed to resolve thread')
    expect(draft).not_to be_persisted
  end

  context 'in a thread' do
    it 'creates a draft note with discussion_id' do
      discussion = create(:discussion_note_on_merge_request, noteable: merge_request, project: project).discussion

      draft = create_draft(note: 'A reply!', in_reply_to_discussion_id: discussion.reply_id)

      expect(draft.note).to eq('A reply!')
      expect(draft.discussion_id).to eq(discussion.reply_id)
      expect(draft.resolve_discussion).to be_falsey
    end

    it 'creates a draft that resolves the thread' do
      discussion = create(:discussion_note_on_merge_request, noteable: merge_request, project: project).discussion

      draft = create_draft(note: 'A reply!', in_reply_to_discussion_id: discussion.reply_id, resolve_discussion: true)

      expect(draft.note).to eq('A reply!')
      expect(draft.discussion_id).to eq(discussion.reply_id)
      expect(draft.resolve_discussion).to be true
    end
  end

  it 'creates a draft note with a position in a diff' do
    diff_refs = project.commit(RepoHelpers.sample_commit.id).try(:diff_refs)

    position = Gitlab::Diff::Position.new(
      old_path: ""files/ruby/popen.rb"",
      new_path: ""files/ruby/popen.rb"",
      old_line: nil,
      new_line: 14,
      diff_refs: diff_refs
    )

    draft = create_draft(note: 'Comment on diff', position: position.to_json)

    expect(draft.note).to eq('Comment on diff')
    expect(draft.original_position.to_json).to eq(position.to_json)
  end

  context 'diff highlight cache clearing' do
    context 'when diff file is unfolded and it is not a reply' do
      it 'clears diff highlighting cache' do
        expect_next_instance_of(DraftNote) do |draft|
          allow(draft).to receive_message_chain(:diff_file, :unfolded?) { true }
        end

        expect(merge_request).to receive_message_chain(:diffs, :clear_cache)

        create_draft(note: 'This is a test', line_code: '123')
      end
    end

    context 'when diff file is not unfolded and it is not a reply' do
      it 'clears diff highlighting cache' do
        expect_next_instance_of(DraftNote) do |draft|
          allow(draft).to receive_message_chain(:diff_file, :unfolded?) { false }
        end

        expect(merge_request).not_to receive(:diffs)

        create_draft(note: 'This is a test', line_code: '123')
      end
    end
  end

  context 'when the draft note is invalid' do
    before do
      allow_next_instance_of(DraftNote) do |draft|
        allow(draft).to receive(:valid?).and_return(false)
      end
    end

    it 'does not create the note' do
      draft_note = create_draft(note: 'invalid note')

      expect(draft_note).not_to be_persisted
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Markup
  class RenderingService
    def initialize(text, file_name: nil, context: {}, postprocess_context: {})
      @text = text
      @file_name = file_name
      @context = context
      @postprocess_context = postprocess_context
    end

    def execute
      return '' unless text.present?
      return context.delete(:rendered) if context.has_key?(:rendered)

      html = markup_unsafe

      return '' unless html.present?

      postprocess_context ? postprocess(html) : html
    end

    private

    def markup_unsafe
      return markdown_unsafe unless file_name

      if Gitlab::MarkupHelper.gitlab_markdown?(file_name)
        markdown_unsafe
      elsif Gitlab::MarkupHelper.asciidoc?(file_name)
        asciidoc_unsafe
      elsif Gitlab::MarkupHelper.plain?(file_name)
        plain_unsafe
      else
        other_markup_unsafe
      end
    end

    def markdown_unsafe
      Banzai.render(text, context)
    end

    def asciidoc_unsafe
      Gitlab::Asciidoc.render(text, context)
    end

    def plain_unsafe
      ActionController::Base.helpers.content_tag :pre, class: 'plain-readme' do
        text
      end
    end

    def other_markup_unsafe
      Gitlab::OtherMarkup.render(file_name, text, context)
    rescue GitHub::Markup::CommandError
      ActionController::Base.helpers.simple_format(text)
    end

    def postprocess(html)
      Banzai.post_process(html, context.reverse_merge(postprocess_context))
    end

    attr_reader :text, :file_name, :context, :postprocess_context
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Markup::RenderingService, feature_category: :groups_and_projects do
  describe '#execute' do
    let_it_be(:project) { create(:project, :repository) }
    let_it_be(:user) do
      user = create(:user, username: 'gfm')
      project.add_maintainer(user)
      user
    end

    let_it_be(:context) { { project: project } }
    let_it_be(:postprocess_context) { { current_user: user } }

    let(:file_name) { nil }
    let(:text) { 'Noël' }

    subject do
      described_class
        .new(text, file_name: file_name, context: context, postprocess_context: postprocess_context)
        .execute
    end

    context 'when text is missing' do
      let(:text) { nil }

      it 'returns an empty string' do
        is_expected.to eq('')
      end
    end

    context 'when file_name is missing' do
      it 'returns html (rendered by Banzai)' do
        expected_html = '<p data-sourcepos=""1:1-1:5"" dir=""auto"">Noël</p>'

        expect(Banzai).to receive(:render).with(text, context) { expected_html }

        is_expected.to eq(expected_html)
      end
    end

    context 'when postprocess_context is missing' do
      let(:file_name) { 'foo.txt' }
      let(:postprocess_context) { nil }

      it 'returns html (rendered by Banzai)' do
        expected_html = '<pre class=""plain-readme"">Noël</pre>'

        expect(Banzai).not_to receive(:post_process) { expected_html }

        is_expected.to eq(expected_html)
      end
    end

    context 'when rendered context is present' do
      let(:rendered) { 'rendered text' }
      let(:file_name) { 'foo.md' }

      it 'returns an empty string' do
        context[:rendered] = rendered

        is_expected.to eq(rendered)
      end
    end

    context 'when file is a markdown file' do
      let(:file_name) { 'foo.md' }

      it 'returns html (rendered by Banzai)' do
        expected_html = '<p data-sourcepos=""1:1-1:5"" dir=""auto"">Noël</p>'

        expect(Banzai).to receive(:render).with(text, context) { expected_html }

        is_expected.to eq(expected_html)
      end
    end

    context 'when file is asciidoc file' do
      let(:file_name) { 'foo.adoc' }

      it 'returns html (rendered by Gitlab::Asciidoc)' do
        expected_html = ""<div>\n<p>Noël</p>\n</div>""

        expect(Gitlab::Asciidoc).to receive(:render).with(text, context) { expected_html }

        is_expected.to eq(expected_html)
      end
    end

    context 'when file is a regular text file' do
      let(:file_name) { 'foo.txt' }
      let(:text) { 'Noël <form>' }

      it 'returns html (rendered by ActionView::TagHelper)' do
        expect(ActionController::Base.helpers).to receive(:content_tag).and_call_original

        is_expected.to eq('<pre class=""plain-readme"">Noël &lt;form&gt;</pre>')
      end
    end

    context 'when file has an unknown type' do
      let(:file_name) { 'foo.tex' }

      it 'returns html (rendered by Gitlab::OtherMarkup)' do
        expected_html = 'Noël'

        expect(Gitlab::OtherMarkup).to receive(:render).with(file_name, text, context) { expected_html }

        is_expected.to eq(expected_html)
      end
    end

    context 'with reStructuredText' do
      let(:file_name) { 'foo.rst' }
      let(:text) { ""####\nPART\n####"" }

      it 'returns rendered html' do
        is_expected.to eq(""<h1>PART</h1>\n\n"")
      end

      context 'when input has an invalid syntax' do
        let(:text) { ""####\nPART\n##"" }

        it 'uses a simple formatter for html' do
          is_expected.to eq(""<p>####\n<br>PART\n<br>##</p>"")
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ServiceDesk
  module CustomEmailVerifications
    class UpdateService < BaseService
      EMAIL_TOKEN_REGEXP = /Verification token: ([A-Za-z0-9_-]{12})/

      def execute
        return error_parameter_missing if settings.blank? || verification.blank?
        return error_already_finished if verification.finished?
        return error_already_failed if already_failed_and_no_mail?

        verification_error = verify

        settings.update!(custom_email_enabled: false) if settings.custom_email_enabled?

        notify_project_owners_and_user_about_result(user: verification.triggerer)

        if verification_error.present?
          verification.mark_as_failed!(verification_error)

          error_not_verified(verification_error)
        else
          verification.mark_as_finished!

          log_info
          ServiceResponse.success
        end
      end

      private

      def mail
        params[:mail]
      end

      def verification
        @verification ||= settings.custom_email_verification
      end

      def already_failed_and_no_mail?
        verification.failed? && mail.blank?
      end

      def verify
        return :mail_not_received_within_timeframe if mail_not_received_within_timeframe?
        return :incorrect_from if incorrect_from?
        return :incorrect_token if incorrect_token?

        nil
      end

      def mail_not_received_within_timeframe?
        # (For completeness) also raise if no email provided
        mail.blank? || !verification.in_timeframe?
      end

      def incorrect_from?
        # Does the email forwarder preserve the FROM header?
        mail.from.first != settings.custom_email
      end

      def incorrect_token?
        message, _stripped_text = Gitlab::Email::ReplyParser.new(mail).execute

        scan_result = message.scan(EMAIL_TOKEN_REGEXP)

        return true if scan_result.empty?

        scan_result.first.first != verification.token
      end

      def error_parameter_missing
        error_response(s_('ServiceDesk|Service Desk setting or verification object missing'))
      end

      def error_already_finished
        error_response(s_('ServiceDesk|Custom email address has already been verified.'))
      end

      def error_already_failed
        error_response(s_('ServiceDesk|Custom email address verification has already been processed and failed.'))
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ServiceDesk::CustomEmailVerifications::UpdateService, feature_category: :service_desk do
  describe '#execute' do
    let_it_be_with_reload(:project) { create(:project) }
    let_it_be(:user) { create(:user) }

    let!(:credential) { create(:service_desk_custom_email_credential, project: project) }
    let(:settings) { create(:service_desk_setting, project: project, custom_email: 'custom-support-email@example.com') }

    let(:mail_object) { nil }
    let(:message_delivery) { instance_double(ActionMailer::MessageDelivery) }
    let(:service) { described_class.new(project: settings.project, params: { mail: mail_object }) }

    let(:error_parameter_missing) { s_('ServiceDesk|Service Desk setting or verification object missing') }
    let(:error_already_finished) { s_('ServiceDesk|Custom email address has already been verified.') }
    let(:error_already_failed) do
      s_('ServiceDesk|Custom email address verification has already been processed and failed.')
    end

    let(:expected_error_message) { error_parameter_missing }
    let(:expected_custom_email_enabled) { false }
    let(:logger_params) { { category: 'custom_email_verification' } }

    before do
      allow(message_delivery).to receive(:deliver_later)
      allow(Notify).to receive(:service_desk_verification_result_email).and_return(message_delivery)
    end

    shared_examples 'a failing verification process' do |expected_error_identifier|
      it 'refuses to verify and sends result emails', :aggregate_failures do
        expect(Notify).to receive(:service_desk_verification_result_email).twice

        expect(Gitlab::AppLogger).to receive(:info).with(logger_params.merge(
          error_message: expected_error_identifier.to_s
        )).once

        response = described_class.new(project: settings.project, params: { mail: mail_object }).execute

        settings.reset
        verification.reset

        expect(response).to be_error
        expect(settings).not_to be_custom_email_enabled
        expect(verification).to be_failed

        expect(response.reason).to eq expected_error_identifier
        expect(verification.error).to eq expected_error_identifier
      end
    end

    shared_examples 'an early exit from the verification process' do |expected_state|
      it 'exits early', :aggregate_failures do
        expect(Notify).to receive(:service_desk_verification_result_email).exactly(0).times

        expect(Gitlab::AppLogger).to receive(:warn).with(logger_params.merge(
          error_message: expected_error_message
        )).once

        response = service.execute

        settings.reset
        verification.reset

        expect(response).to be_error
        expect(settings.custom_email_enabled).to eq expected_custom_email_enabled
        expect(verification.state).to eq expected_state
      end
    end

    it 'exits early' do
      expect(Notify).to receive(:service_desk_verification_result_email).exactly(0).times

      expect(Gitlab::AppLogger).to receive(:warn).with(logger_params.merge(
        error_message: expected_error_message
      )).once

      response = service.execute

      settings.reset

      expect(response).to be_error
      expect(settings).not_to be_custom_email_enabled
    end

    context 'when verification exists' do
      let!(:verification) { create(:service_desk_custom_email_verification, project: project) }

      context 'when we do not have a verification email' do
        # Raise if verification started but no email provided
        it_behaves_like 'a failing verification process', 'mail_not_received_within_timeframe'

        context 'when already verified' do
          let(:expected_error_message) { error_already_finished }

          before do
            verification.mark_as_finished!
          end

          it_behaves_like 'an early exit from the verification process', 'finished'
        end

        context 'when we already have an error' do
          let(:expected_error_message) { error_already_failed }

          before do
            verification.mark_as_failed!(:smtp_host_issue)
          end

          it_behaves_like 'an early exit from the verification process', 'failed'
        end
      end

      context 'when we have a verification email' do
        before do
          verification.update!(token: 'ZROT4ZZXA-Y6') # token from email fixture
        end

        let(:email_raw) { email_fixture('emails/service_desk_custom_email_address_verification.eml') }
        let(:mail_object) { Mail::Message.new(email_raw) }

        it 'verifies and sends result emails' do
          expect(Notify).to receive(:service_desk_verification_result_email).twice

          expect(Gitlab::AppLogger).to receive(:info).with(logger_params).once

          response = service.execute

          settings.reset
          verification.reset

          expect(response).to be_success
          expect(settings).not_to be_custom_email_enabled
          expect(verification).to be_finished
        end

        context 'and verification tokens do not match' do
          before do
            verification.update!(token: 'XXXXXXZXA-XX')
          end

          it_behaves_like 'a failing verification process', 'incorrect_token'
        end

        context 'and from address does not match with custom email' do
          before do
            settings.update!(custom_email: 'some-other@example.com')
          end

          it_behaves_like 'a failing verification process', 'incorrect_from'
        end

        context 'and timeframe for receiving the email is over' do
          before do
            verification.update!(triggered_at: 40.minutes.ago)
          end

          it_behaves_like 'a failing verification process', 'mail_not_received_within_timeframe'
        end

        context 'when already verified' do
          let(:expected_error_message) { error_already_finished }

          before do
            verification.mark_as_finished!
          end

          it_behaves_like 'an early exit from the verification process', 'finished'

          context 'when enabled' do
            let(:expected_custom_email_enabled) { true }

            before do
              settings.update!(custom_email_enabled: true)
            end

            it_behaves_like 'an early exit from the verification process', 'finished'
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ServiceDesk
  module CustomEmailVerifications
    class CreateService < BaseService
      attr_reader :ramp_up_error

      def execute
        return error_settings_missing unless settings.present?
        return error_user_not_authorized unless can?(current_user, :admin_project, project)

        update_settings
        notify_project_owners_and_user_about_verification_start
        send_verification_email_and_catch_delivery_errors

        if ramp_up_error
          handle_error_case
        else
          log_info
          ServiceResponse.success
        end
      end

      private

      def verification
        @verification ||= settings.custom_email_verification ||
          ServiceDesk::CustomEmailVerification.new(project_id: settings.project_id)
      end

      def update_settings
        settings.update!(custom_email_enabled: false) if settings.custom_email_enabled?

        verification.mark_as_started!(current_user)
        # We use verification association from project, to use it in email, we need to reset it here.
        project.reset
      end

      def notify_project_owners_and_user_about_verification_start
        notify_project_owners_and_user_with_email(
          email_method_name: :service_desk_verification_triggered_email,
          user: current_user
        )
      end

      def send_verification_email_and_catch_delivery_errors
        # Send this synchronously as we need to get direct feedback on delivery errors.
        Notify.service_desk_custom_email_verification_email(settings).deliver
      rescue SocketError, OpenSSL::SSL::SSLError
        # e.g. host not found or host certificate issues
        @ramp_up_error = :smtp_host_issue
      rescue Net::SMTPAuthenticationError
        # incorrect username or password
        @ramp_up_error = :invalid_credentials
      rescue Net::ReadTimeout
        # Server is slow to respond
        @ramp_up_error = :read_timeout
      end

      def handle_error_case
        notify_project_owners_and_user_about_result(user: current_user)

        verification.mark_as_failed!(ramp_up_error)

        error_not_verified(ramp_up_error)
      end

      def error_settings_missing
        error_response(s_('ServiceDesk|Service Desk setting missing'))
      end

      def error_user_not_authorized
        error_response(s_('ServiceDesk|User cannot manage project.'))
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ServiceDesk::CustomEmailVerifications::CreateService, feature_category: :service_desk do
  describe '#execute' do
    let_it_be_with_reload(:project) { create(:project) }
    let_it_be(:user) { create(:user) }

    let!(:credential) { create(:service_desk_custom_email_credential, project: project) }

    let(:message_delivery) { instance_double(ActionMailer::MessageDelivery) }
    let(:message) { instance_double(Mail::Message) }

    let(:service) { described_class.new(project: project, current_user: user) }

    let(:error_user_not_authorized) { s_('ServiceDesk|User cannot manage project.') }
    let(:error_settings_missing) { s_('ServiceDesk|Service Desk setting missing') }
    let(:expected_error_message) { error_settings_missing }
    let(:logger_params) { { category: 'custom_email_verification' } }

    before do
      allow(message_delivery).to receive(:deliver_later)
      allow(Notify).to receive(:service_desk_verification_triggered_email).and_return(message_delivery)

      # We send verification email directly
      allow(message).to receive(:deliver)
      allow(Notify).to receive(:service_desk_custom_email_verification_email).and_return(message)
    end

    shared_examples 'a verification process that exits early' do
      it 'aborts verification process and exits early', :aggregate_failures do
        # Because we exit early it should not send any verification or notification emails
        expect(service).to receive(:setup_and_deliver_verification_email).exactly(0).times
        expect(Notify).to receive(:service_desk_verification_triggered_email).exactly(0).times

        expect(Gitlab::AppLogger).to receive(:warn).with(logger_params.merge(
          error_message: expected_error_message
        )).once

        response = service.execute

        expect(response).to be_error
      end
    end

    shared_examples 'a verification process with ramp up error' do
      it 'aborts verification process', :aggregate_failures do
        allow(message).to receive(:deliver).and_raise(error)

        # Creates one verification email
        expect(Notify).to receive(:service_desk_custom_email_verification_email).once

        # Correct amount of notification emails were sent
        expect(Notify).to receive(:service_desk_verification_triggered_email).exactly(project.owners.size + 1).times

        # Correct amount of result notification emails were sent
        expect(Notify).to receive(:service_desk_verification_result_email).exactly(project.owners.size + 1).times

        expect(Gitlab::AppLogger).to receive(:info).with(logger_params.merge(
          error_message: error_identifier.to_s
        )).once

        response = service.execute

        expect(response).to be_error
        expect(response.reason).to eq error_identifier

        expect(settings).not_to be_custom_email_enabled
        expect(settings.custom_email_verification.triggered_at).not_to be_nil
        expect(settings.custom_email_verification).to have_attributes(
          token: nil,
          triggerer: user,
          error: error_identifier,
          state: 'failed'
        )
      end
    end

    it_behaves_like 'a verification process that exits early'

    context 'when service desk setting exists' do
      let(:settings) { create(:service_desk_setting, project: project, custom_email: 'user@example.com') }
      let(:service) { described_class.new(project: settings.project, current_user: user) }
      let(:expected_error_message) { error_user_not_authorized }

      it 'aborts verification process and exits early', :aggregate_failures do
        # Because we exit early it should not send any verification or notification emails
        expect(service).to receive(:setup_and_deliver_verification_email).exactly(0).times
        expect(Notify).to receive(:service_desk_verification_triggered_email).exactly(0).times

        expect(Gitlab::AppLogger).to receive(:warn).with(logger_params.merge(
          error_message: expected_error_message
        )).once

        response = service.execute
        settings.reload

        expect(response).to be_error

        expect(settings.custom_email_enabled).to be false
        # Because service should normally add initial verification object
        expect(settings.custom_email_verification).to be nil
      end

      context 'when user has maintainer role in project' do
        before_all do
          project.add_maintainer(user)
        end

        it 'initiates verification process successfully', :aggregate_failures do
          # Creates one verification email
          expect(Notify).to receive(:service_desk_custom_email_verification_email).once

          # Check whether the correct amount of notification emails were sent
          expect(Notify).to receive(:service_desk_verification_triggered_email).exactly(project.owners.size + 1).times

          expect(Gitlab::AppLogger).to receive(:info).with(logger_params).once

          response = service.execute

          settings.reload
          verification = settings.custom_email_verification

          expect(response).to be_success

          expect(settings.custom_email_enabled).to be false

          expect(verification).to be_started
          expect(verification.token).not_to be_nil
          expect(verification.triggered_at).not_to be_nil
          expect(verification).to have_attributes(
            triggerer: user,
            error: nil
          )
        end

        context 'when providing invalid SMTP credentials' do
          before do
            allow(Notify).to receive(:service_desk_verification_result_email).and_return(message_delivery)
          end

          it_behaves_like 'a verification process with ramp up error' do
            let(:error) { SocketError }
            let(:error_identifier) { 'smtp_host_issue' }
          end

          it_behaves_like 'a verification process with ramp up error' do
            let(:error) { OpenSSL::SSL::SSLError }
            let(:error_identifier) { 'smtp_host_issue' }
          end

          it_behaves_like 'a verification process with ramp up error' do
            let(:error) { Net::SMTPAuthenticationError.new('Invalid username or password') }
            let(:error_identifier) { 'invalid_credentials' }
          end

          it_behaves_like 'a verification process with ramp up error' do
            let(:error) { Net::ReadTimeout }
            let(:error_identifier) { 'read_timeout' }
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ServiceDesk
  module CustomEmails
    class DestroyService < BaseService
      def execute
        return error_user_not_authorized unless legitimate_user?
        return error_does_not_exist unless verification? || credential? || setting?

        project.service_desk_custom_email_verification&.destroy
        project.service_desk_custom_email_credential&.destroy
        project.reset
        project.service_desk_setting&.update!(custom_email: nil, custom_email_enabled: false)

        log_info
        ServiceResponse.success
      end

      private

      def error_does_not_exist
        error_response(s_('ServiceDesk|Custom email does not exist'))
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ServiceDesk::CustomEmails::DestroyService, feature_category: :service_desk do
  describe '#execute' do
    let_it_be_with_reload(:project) { create(:project) }

    let(:user) { build_stubbed(:user) }
    let(:service) { described_class.new(project: project, current_user: user) }
    let(:error_user_not_authorized) { s_('ServiceDesk|User cannot manage project.') }
    let(:error_does_not_exist) { s_('ServiceDesk|Custom email does not exist') }
    let(:expected_error_message) { nil }
    let(:logger_params) { { category: 'custom_email' } }

    shared_examples 'a service that exits with error' do
      it 'exits early' do
        expect(Gitlab::AppLogger).to receive(:warn).with(logger_params.merge(
          error_message: expected_error_message
        )).once

        response = service.execute

        expect(response).to be_error
        expect(response.message).to eq(expected_error_message)
      end
    end

    shared_examples 'a successful service that destroys all custom email records' do
      it 'ensures no custom email records exist' do
        expect(Gitlab::AppLogger).to receive(:info).with(logger_params).once

        project.reset

        response = service.execute

        expect(response).to be_success
        expect(project.service_desk_custom_email_verification).to be nil
        expect(project.service_desk_custom_email_credential).to be nil
        expect(project.service_desk_setting).to have_attributes(
          custom_email: nil,
          custom_email_enabled: false
        )
      end
    end

    context 'with illegitimate user' do
      let(:expected_error_message) { error_user_not_authorized }

      before do
        stub_member_access_level(project, developer: user)
      end

      it_behaves_like 'a service that exits with error'
    end

    context 'with legitimate user' do
      let(:expected_error_message) { error_does_not_exist }

      before do
        stub_member_access_level(project, maintainer: user)
      end

      it_behaves_like 'a service that exits with error'

      context 'when service desk setting exists' do
        let!(:settings) { create(:service_desk_setting, project: project) }

        it_behaves_like 'a successful service that destroys all custom email records'

        context 'when custom email is present' do
          let!(:settings) { create(:service_desk_setting, project: project, custom_email: 'user@example.com') }

          it_behaves_like 'a successful service that destroys all custom email records'

          context 'when credential exists' do
            let!(:credential) { create(:service_desk_custom_email_credential, project: project) }

            it_behaves_like 'a successful service that destroys all custom email records'

            context 'when verification exists' do
              let!(:verification) { create(:service_desk_custom_email_verification, project: project) }

              it_behaves_like 'a successful service that destroys all custom email records'
            end
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ServiceDesk
  module CustomEmails
    class CreateService < BaseService
      def execute
        return error_user_not_authorized unless legitimate_user?
        return error_params_missing unless has_required_params?
        return error_custom_email_exists if credential? || verification?

        return error_cannot_create_custom_email unless create_credential

        if update_settings.error?
          # We don't warp everything in a single transaction here and roll it back
          # because ServiceDeskSettings::UpdateService uses safe_find_or_create_by!
          rollback_credential
          return error_cannot_create_custom_email
        end

        project.reset

        # The create service may return an error response if the verification fails early.
        # Here We want to indicate whether adding a custom email address was successful, so
        # we don't use its response here.
        create_verification

        log_info
        ServiceResponse.success
      end

      private

      def update_settings
        ServiceDeskSettings::UpdateService.new(project, current_user, create_setting_params).execute
      end

      def rollback_credential
        ::ServiceDesk::CustomEmailCredential.find_by_project_id(project.id)&.destroy
      end

      def create_credential
        credential = ::ServiceDesk::CustomEmailCredential.new(create_credential_params.merge(project: project))
        credential.save
      rescue ArgumentError
        false
      end

      def create_verification
        ::ServiceDesk::CustomEmailVerifications::CreateService.new(project: project, current_user: current_user).execute
      end

      def create_setting_params
        ensure_params.permit(:custom_email)
      end

      def create_credential_params
        ensure_params.permit(:smtp_address, :smtp_port, :smtp_username, :smtp_password, :smtp_authentication)
      end

      def ensure_params
        return params if params.is_a?(ActionController::Parameters)

        ActionController::Parameters.new(params)
      end

      def has_required_params?
        required_keys.all? { |key| params.key?(key) && params[key].present? }
      end

      def required_keys
        %i[custom_email smtp_address smtp_port smtp_username smtp_password]
      end

      def error_custom_email_exists
        error_response(s_('ServiceDesk|Custom email already exists'))
      end

      def error_params_missing
        error_response(s_('ServiceDesk|Parameters missing'))
      end

      def error_cannot_create_custom_email
        error_response(s_('ServiceDesk|Cannot create custom email'))
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ServiceDesk::CustomEmails::CreateService, feature_category: :service_desk do
  describe '#execute' do
    let_it_be_with_reload(:project) { create(:project) }
    let_it_be(:user) { create(:user) }

    let(:service) { described_class.new(project: project, current_user: user, params: params) }
    let(:error_user_not_authorized) { s_('ServiceDesk|User cannot manage project.') }
    let(:error_cannot_create_custom_email) { s_('ServiceDesk|Cannot create custom email') }
    let(:error_custom_email_exists) { s_('ServiceDesk|Custom email already exists') }
    let(:error_params_missing) { s_('ServiceDesk|Parameters missing') }
    let(:expected_error_message) { nil }
    let(:params) { {} }
    let(:message_delivery) { instance_double(ActionMailer::MessageDelivery) }
    let(:message) { instance_double(Mail::Message) }
    let(:logger_params) { { category: 'custom_email' } }

    shared_examples 'a service that exits with error' do
      it 'exits early' do
        expect(Gitlab::AppLogger).to receive(:warn).with(logger_params.merge(
          error_message: expected_error_message
        )).once

        response = service.execute

        expect(response).to be_error
        expect(response.message).to eq(expected_error_message)
      end
    end

    shared_examples 'a failing service that does not create records' do
      it 'exits with error and does not create records' do
        expect(Gitlab::AppLogger).to receive(:warn).with(logger_params.merge(
          error_message: expected_error_message
        )).once

        response = service.execute
        project.reset

        expect(response).to be_error
        expect(response.message).to eq(expected_error_message)
        expect(project.service_desk_custom_email_verification).to be nil
        expect(project.service_desk_custom_email_credential).to be nil
        expect(project.service_desk_setting).to have_attributes(
          custom_email: nil,
          custom_email_enabled: false
        )
      end
    end

    context 'with illegitimate user' do
      let(:expected_error_message) { error_user_not_authorized }

      before do
        stub_member_access_level(project, developer: user)
      end

      it_behaves_like 'a service that exits with error'
    end

    context 'with legitimate user' do
      let!(:settings) { create(:service_desk_setting, project: project) }

      let(:expected_error_message) { error_params_missing }

      before do
        stub_member_access_level(project, maintainer: user)

        # We send verification email directly and it will fail with
        # smtp.example.com because it expects a valid DNS record
        allow(message).to receive(:deliver)
        allow(Notify).to receive(:service_desk_custom_email_verification_email).and_return(message)
      end

      it_behaves_like 'a service that exits with error'

      context 'with params but custom_email missing' do
        let(:params) do
          {
            smtp_address: 'smtp.example.com',
            smtp_port: '587',
            smtp_username: 'user@example.com',
            smtp_password: 'supersecret'
          }
        end

        it_behaves_like 'a failing service that does not create records'
      end

      context 'with params but smtp username empty' do
        let(:params) do
          {
            custom_email: 'user@example.com',
            smtp_address: 'smtp.example.com',
            smtp_port: '587',
            smtp_username: nil,
            smtp_password: 'supersecret'
          }
        end

        it_behaves_like 'a failing service that does not create records'
      end

      context 'with params but smtp password is too short' do
        let(:expected_error_message) { error_cannot_create_custom_email }
        let(:params) do
          {
            custom_email: 'user@example.com',
            smtp_address: 'smtp.example.com',
            smtp_port: '587',
            smtp_username: 'user@example.com',
            smtp_password: '2short'
          }
        end

        it_behaves_like 'a failing service that does not create records'
      end

      context 'with params but custom_email is invalid' do
        let(:expected_error_message) { error_cannot_create_custom_email }
        let(:params) do
          {
            custom_email: 'useratexampledotcom',
            smtp_address: 'smtp.example.com',
            smtp_port: '587',
            smtp_username: 'user@example.com',
            smtp_password: 'supersecret'
          }
        end

        it_behaves_like 'a failing service that does not create records'
      end

      context 'with full set of params' do
        let(:params) do
          {
            custom_email: 'user@example.com',
            smtp_address: 'smtp.example.com',
            smtp_port: '587',
            smtp_username: 'user@example.com',
            smtp_password: 'supersecret'
          }
        end

        it 'creates all records and returns a successful response' do
          # Because we also log in ServiceDesk::CustomEmailVerifications::CreateService
          expect(Gitlab::AppLogger).to receive(:info).with({ category: 'custom_email_verification' }).once
          expect(Gitlab::AppLogger).to receive(:info).with(logger_params).once

          response = service.execute
          project.reset

          expect(response).to be_success

          expect(project.service_desk_setting).to have_attributes(
            custom_email: params[:custom_email],
            custom_email_enabled: false
          )
          expect(project.service_desk_custom_email_credential).to have_attributes(
            smtp_address: params[:smtp_address],
            smtp_port: params[:smtp_port].to_i,
            smtp_username: params[:smtp_username],
            smtp_password: params[:smtp_password],
            smtp_authentication: nil
          )
          expect(project.service_desk_custom_email_verification).to have_attributes(
            state: 'started',
            triggerer: user,
            error: nil
          )
        end

        context 'with optional smtp_authentication parameter' do
          before do
            params[:smtp_authentication] = 'login'
          end

          it 'sets authentication and returns a successful response' do
            response = service.execute
            project.reset

            expect(response).to be_success
            expect(project.service_desk_custom_email_credential.smtp_authentication).to eq 'login'
          end

          context 'with unsupported value' do
            let(:expected_error_message) { error_cannot_create_custom_email }

            before do
              params[:smtp_authentication] = 'unsupported'
            end

            it_behaves_like 'a failing service that does not create records'
          end
        end

        context 'when custom email aready exists' do
          let!(:settings) { create(:service_desk_setting, project: project, custom_email: 'user@example.com') }
          let!(:credential) { create(:service_desk_custom_email_credential, project: project) }
          let!(:verification) { create(:service_desk_custom_email_verification, project: project) }

          let(:expected_error_message) { error_custom_email_exists }

          it_behaves_like 'a service that exits with error'
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module DependencyProxy
  class AuthTokenService < DependencyProxy::BaseService
    attr_reader :token

    def initialize(token)
      @token = token
    end

    def execute
      JSONWebToken::HMACToken.decode(token, ::Auth::DependencyProxyAuthenticationService.secret).first
    end

    def self.user_or_deploy_token_from_jwt(raw_jwt)
      token_payload = self.new(raw_jwt).execute

      if token_payload['user_id']
        User.find(token_payload['user_id'])
      elsif token_payload['deploy_token']
        DeployToken.active.find_by_token(token_payload['deploy_token'])
      end
    rescue JWT::DecodeError, JWT::ExpiredSignature, JWT::ImmatureSignature
      nil
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe DependencyProxy::AuthTokenService, feature_category: :dependency_proxy do
  include DependencyProxyHelpers

  let_it_be(:user) { create(:user) }
  let_it_be(:deploy_token) { create(:deploy_token) }

  describe '.user_or_deploy_token_from_jwt' do
    subject { described_class.user_or_deploy_token_from_jwt(token.encoded) }

    shared_examples 'handling token errors' do
      context 'with a decoding error' do
        before do
          allow(JWT).to receive(:decode).and_raise(JWT::DecodeError)
        end

        it { is_expected.to eq(nil) }
      end

      context 'with an immature signature error' do
        before do
          allow(JWT).to receive(:decode).and_raise(JWT::ImmatureSignature)
        end

        it { is_expected.to eq(nil) }
      end

      context 'with an expired signature error' do
        it 'returns nil' do
          travel_to(Time.zone.now + Auth::DependencyProxyAuthenticationService.token_expire_at + 1.minute) do
            expect(subject).to eq(nil)
          end
        end
      end
    end

    context 'with a user' do
      let_it_be(:token) { build_jwt(user) }

      it { is_expected.to eq(user) }

      context 'with an invalid user id' do
        let_it_be(:token) { build_jwt { |jwt| jwt['user_id'] = 'this_is_not_a_user_id' } }

        it 'raises an not found error' do
          expect { subject }.to raise_error(ActiveRecord::RecordNotFound)
        end
      end

      it_behaves_like 'handling token errors'
    end

    context 'with a deploy token' do
      let_it_be(:token) { build_jwt(deploy_token) }

      it { is_expected.to eq(deploy_token) }

      context 'with an invalid token' do
        let_it_be(:token) { build_jwt { |jwt| jwt['deploy_token'] = 'this_is_not_a_token' } }

        it { is_expected.to eq(nil) }
      end

      it_behaves_like 'handling token errors'
    end

    context 'with an empty token payload' do
      let_it_be(:token) { build_jwt(nil) }

      it { is_expected.to eq(nil) }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module DependencyProxy
  class RequestTokenService < DependencyProxy::BaseService
    def initialize(image)
      @image = image
    end

    def execute
      response = Gitlab::HTTP.get(auth_url)

      if response.success?
        success(token: Gitlab::Json.parse(response.body)['token'])
      else
        error('Expected 200 response code for an access token', response.code)
      end
    rescue Timeout::Error => exception
      error(exception.message, 599)
    rescue JSON::ParserError
      error('Failed to parse a response body for an access token', 500)
    end

    private

    def auth_url
      registry.auth_url(@image)
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe DependencyProxy::RequestTokenService, feature_category: :dependency_proxy do
  include DependencyProxyHelpers

  let(:image) { 'alpine:3.9' }
  let(:token) { Digest::SHA256.hexdigest('123') }

  subject { described_class.new(image).execute }

  context 'remote request is successful' do
    before do
      stub_registry_auth(image, token)
    end

    it { expect(subject[:status]).to eq(:success) }
    it { expect(subject[:token]).to eq(token) }
  end

  context 'remote request is not found' do
    before do
      stub_registry_auth(image, token, 404)
    end

    it { expect(subject[:status]).to eq(:error) }
    it { expect(subject[:http_status]).to eq(404) }
    it { expect(subject[:message]).to eq('Expected 200 response code for an access token') }
  end

  context 'failed to parse response body' do
    before do
      stub_registry_auth(image, token, 200, 'dasd1321: wow')
    end

    it { expect(subject[:status]).to eq(:error) }
    it { expect(subject[:http_status]).to eq(500) }
    it { expect(subject[:message]).to eq('Failed to parse a response body for an access token') }
  end

  context 'net timeout exception' do
    before do
      auth_link = DependencyProxy::Registry.auth_url(image)

      stub_full_request(auth_link, method: :any).to_timeout
    end

    it { expect(subject[:status]).to eq(:error) }
    it { expect(subject[:http_status]).to eq(599) }
    it { expect(subject[:message]).to eq('execution expired') }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module DependencyProxy
  class HeadManifestService < DependencyProxy::BaseService
    ACCEPT_HEADERS = DependencyProxy::Manifest::ACCEPTED_TYPES.join(',')

    def initialize(image, tag, token)
      @image = image
      @tag = tag
      @token = token
    end

    def execute
      response = Gitlab::HTTP.head(manifest_url, headers: auth_headers.merge(Accept: ACCEPT_HEADERS))

      if response.success?
        success(
          digest: response.headers[DependencyProxy::Manifest::DIGEST_HEADER],
          content_type: response.headers['content-type']
        )
      else
        error(response.body, response.code)
      end
    rescue Timeout::Error => exception
      error(exception.message, 599)
    end

    private

    def manifest_url
      registry.manifest_url(@image, @tag)
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe DependencyProxy::HeadManifestService, feature_category: :dependency_proxy do
  include DependencyProxyHelpers

  let(:image) { 'alpine' }
  let(:tag) { 'latest' }
  let(:token) { Digest::SHA256.hexdigest('123') }
  let(:digest) { '12345' }
  let(:content_type) { 'foo' }
  let(:headers) do
    {
      DependencyProxy::Manifest::DIGEST_HEADER => digest,
      'content-type' => content_type
    }
  end

  subject { described_class.new(image, tag, token).execute }

  context 'remote request is successful' do
    before do
      stub_manifest_head(image, tag, headers: headers)
    end

    it { expect(subject[:status]).to eq(:success) }
    it { expect(subject[:digest]).to eq(digest) }
  end

  context 'remote request is not found' do
    before do
      stub_manifest_head(image, tag, status: 404, body: 'Not found')
    end

    it { expect(subject[:status]).to eq(:error) }
    it { expect(subject[:http_status]).to eq(404) }
    it { expect(subject[:message]).to eq('Not found') }
  end

  context 'net timeout exception' do
    before do
      manifest_link = DependencyProxy::Registry.manifest_url(image, tag)

      stub_full_request(manifest_link, method: :head).to_timeout
    end

    it { expect(subject[:status]).to eq(:error) }
    it { expect(subject[:http_status]).to eq(599) }
    it { expect(subject[:message]).to eq('execution expired') }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module DependencyProxy
  class FindCachedManifestService < DependencyProxy::BaseService
    def initialize(group, image, tag, token)
      @group = group
      @image = image
      @tag = tag
      @token = token
      @file_name = ""#{@image}:#{@tag}.json""
      @manifest = nil
    end

    def execute
      @manifest = @group.dependency_proxy_manifests
                        .active
                        .find_by_file_name_or_digest(file_name: @file_name, digest: @tag)

      head_result = DependencyProxy::HeadManifestService.new(@image, @tag, @token).execute

      return respond if cached_manifest_matches?(head_result)
      return respond if @manifest && head_result[:status] == :error

      success(manifest: nil, from_cache: false)
    rescue Timeout::Error, *Gitlab::HTTP::HTTP_ERRORS
      respond
    end

    private

    def cached_manifest_matches?(head_result)
      return false if head_result[:status] == :error

      @manifest && @manifest.digest == head_result[:digest] && @manifest.content_type == head_result[:content_type]
    end

    def respond(from_cache: true)
      if @manifest
        @manifest.read!

        success(manifest: @manifest, from_cache: from_cache)
      else
        error('Failed to download the manifest from the external registry', 503)
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe DependencyProxy::FindCachedManifestService, feature_category: :dependency_proxy do
  include DependencyProxyHelpers

  let_it_be(:image) { 'alpine' }
  let_it_be(:tag) { 'latest' }
  let_it_be(:dependency_proxy_manifest) { create(:dependency_proxy_manifest, file_name: ""#{image}:#{tag}.json"") }

  let(:manifest) { dependency_proxy_manifest.file.read }
  let(:group) { dependency_proxy_manifest.group }
  let(:token) { Digest::SHA256.hexdigest('123') }
  let(:headers) do
    {
      DependencyProxy::Manifest::DIGEST_HEADER => dependency_proxy_manifest.digest,
      'content-type' => dependency_proxy_manifest.content_type
    }
  end

  describe '#execute' do
    subject { described_class.new(group, image, tag, token).execute }

    shared_examples 'downloading the manifest' do
      it 'downloads manifest from remote registry if there is no cached one', :aggregate_failures do
        expect { subject }.to change { group.dependency_proxy_manifests.count }.by(1)
        expect(subject[:status]).to eq(:success)
        expect(subject[:manifest]).to be_a(DependencyProxy::Manifest)
        expect(subject[:manifest]).to be_persisted
        expect(subject[:from_cache]).to eq false
      end
    end

    shared_examples 'returning no manifest' do
      it 'returns a nil manifest' do
        expect(subject[:status]).to eq(:success)
        expect(subject[:from_cache]).to eq false
        expect(subject[:manifest]).to be_nil
      end
    end

    shared_examples 'returning an error' do
      it 'returns an error', :aggregate_failures do
        expect(subject[:status]).to eq(:error)
        expect(subject[:http_status]).to eq(503)
        expect(subject[:message]).to eq('Failed to download the manifest from the external registry')
      end
    end

    context 'when no manifest exists' do
      let_it_be(:image) { 'new-image' }

      context 'successful head request' do
        before do
          stub_manifest_head(image, tag, headers: headers)
          stub_manifest_download(image, tag, headers: headers)
        end

        it_behaves_like 'returning no manifest'
      end

      context 'failed head request' do
        before do
          stub_manifest_head(image, tag, status: :error)
          stub_manifest_download(image, tag, headers: headers)
        end

        it_behaves_like 'returning no manifest'
      end
    end

    context 'when manifest exists' do
      before do
        stub_manifest_head(image, tag, headers: headers)
      end

      shared_examples 'using the cached manifest' do
        it 'uses cached manifest instead of downloading one', :aggregate_failures do
          expect { subject }.to change { dependency_proxy_manifest.reload.read_at }

          expect(subject[:status]).to eq(:success)
          expect(subject[:manifest]).to be_a(DependencyProxy::Manifest)
          expect(subject[:manifest]).to eq(dependency_proxy_manifest)
          expect(subject[:from_cache]).to eq true
        end
      end

      it_behaves_like 'using the cached manifest'

      context 'when digest is stale' do
        let(:digest) { 'new-digest' }
        let(:content_type) { 'new-content-type' }

        before do
          stub_manifest_head(image, tag, headers: { DependencyProxy::Manifest::DIGEST_HEADER => digest, 'content-type' => content_type })
          stub_manifest_download(image, tag, headers: { DependencyProxy::Manifest::DIGEST_HEADER => digest, 'content-type' => content_type })
        end

        it_behaves_like 'returning no manifest'
      end

      context 'when the cached manifest is pending destruction' do
        before do
          dependency_proxy_manifest.update_column(:status, DependencyProxy::Manifest.statuses[:pending_destruction])
          stub_manifest_head(image, tag, headers: headers)
          stub_manifest_download(image, tag, headers: headers)
        end

        it_behaves_like 'returning no manifest'
      end

      context 'when the connection fails' do
        before do
          expect(DependencyProxy::HeadManifestService).to receive(:new).and_raise(Net::OpenTimeout)
        end

        it_behaves_like 'using the cached manifest'

        context 'and no manifest is cached' do
          let_it_be(:image) { 'new-image' }

          it_behaves_like 'returning an error'
        end
      end

      context 'when the connection is successful but with error in result' do
        before do
          allow_next_instance_of(DependencyProxy::HeadManifestService) do |service|
            allow(service).to receive(:execute).and_return(status: :error, http_status: 401, message: ""Not found"")
          end
        end

        it_behaves_like 'using the cached manifest'

        context 'and no manifest is cached' do
          let_it_be(:image) { 'new-image' }

          it_behaves_like 'returning no manifest'
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module DependencyProxy
  module ImageTtlGroupPolicies
    class UpdateService < BaseContainerService
      include Gitlab::Utils::StrongMemoize

      ALLOWED_ATTRIBUTES = %i[enabled ttl].freeze

      def execute
        return ServiceResponse.error(message: 'Access Denied', http_status: 403) unless allowed?
        return ServiceResponse.error(message: 'Dependency proxy image TTL Policy not found', http_status: 404) unless dependency_proxy_image_ttl_policy

        if dependency_proxy_image_ttl_policy.update(dependency_proxy_image_ttl_policy_params)
          ServiceResponse.success(payload: { dependency_proxy_image_ttl_policy: dependency_proxy_image_ttl_policy })
        else
          ServiceResponse.error(
            message: dependency_proxy_image_ttl_policy.errors.full_messages.to_sentence || 'Bad request',
            http_status: 400
          )
        end
      end

      private

      def dependency_proxy_image_ttl_policy
        strong_memoize(:dependency_proxy_image_ttl_policy) do
          container.dependency_proxy_image_ttl_policy
        end
      end

      def allowed?
        Ability.allowed?(current_user, :admin_dependency_proxy, container)
      end

      def dependency_proxy_image_ttl_policy_params
        params.slice(*ALLOWED_ATTRIBUTES)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::DependencyProxy::ImageTtlGroupPolicies::UpdateService, feature_category: :dependency_proxy do
  using RSpec::Parameterized::TableSyntax

  let_it_be_with_reload(:group) { create(:group) }
  let_it_be(:user) { create(:user) }
  let_it_be(:params) { {} }

  describe '#execute' do
    subject { described_class.new(container: group, current_user: user, params: params).execute }

    shared_examples 'returning a success' do
      it 'returns a success' do
        result = subject

        expect(result.payload[:dependency_proxy_image_ttl_policy]).to be_present
        expect(result).to be_success
      end
    end

    shared_examples 'returning an error' do |message, http_status|
      it 'returns an error' do
        result = subject

        expect(result).to have_attributes(
          message: message,
          status: :error,
          http_status: http_status
        )
      end
    end

    shared_examples 'updating the dependency proxy image ttl policy' do
      it_behaves_like 'updating the dependency proxy image ttl policy attributes',
        from: { enabled: true, ttl: 90 },
        to: { enabled: false, ttl: 2 }

      it_behaves_like 'returning a success'

      context 'with invalid params' do
        let_it_be(:params) { { enabled: nil } }

        it_behaves_like 'not creating the dependency proxy image ttl policy'

        it ""doesn't update"" do
          expect { subject }
            .not_to change { ttl_policy.reload.enabled }
        end

        it_behaves_like 'returning an error', 'Enabled is not included in the list', 400
      end
    end

    shared_examples 'denying access to dependency proxy image ttl policy' do
      context 'with existing dependency proxy image ttl policy' do
        it_behaves_like 'not creating the dependency proxy image ttl policy'

        it_behaves_like 'returning an error', 'Access Denied', 403
      end
    end

    # To be removed when raise_group_admin_package_permission_to_owner FF is removed
    shared_examples 'disabling admin_package feature flag' do |action:|
      before do
        stub_feature_flags(raise_group_admin_package_permission_to_owner: false)
      end

      it_behaves_like ""#{action} the dependency proxy image ttl policy""
    end

    before do
      stub_config(dependency_proxy: { enabled: true })
    end

    context 'with existing dependency proxy image ttl policy' do
      let_it_be(:ttl_policy) { create(:image_ttl_group_policy, group: group) }
      let_it_be(:params) { { enabled: false, ttl: 2 } }

      where(:user_role, :shared_examples_name) do
        :owner      | 'updating the dependency proxy image ttl policy'
        :maintainer | 'denying access to dependency proxy image ttl policy'
        :developer  | 'denying access to dependency proxy image ttl policy'
        :reporter   | 'denying access to dependency proxy image ttl policy'
        :guest      | 'denying access to dependency proxy image ttl policy'
        :anonymous  | 'denying access to dependency proxy image ttl policy'
      end

      with_them do
        before do
          group.send(""add_#{user_role}"", user) unless user_role == :anonymous
        end

        it_behaves_like params[:shared_examples_name]
        it_behaves_like 'disabling admin_package feature flag', action: :updating if params[:user_role] == :maintainer
      end
    end

    context 'without existing dependency proxy image ttl policy' do
      let_it_be(:ttl_policy) { group.dependency_proxy_image_ttl_policy }

      where(:user_role, :shared_examples_name) do
        :owner      | 'creating the dependency proxy image ttl policy'
        :maintainer | 'denying access to dependency proxy image ttl policy'
        :developer  | 'denying access to dependency proxy image ttl policy'
        :reporter   | 'denying access to dependency proxy image ttl policy'
        :guest      | 'denying access to dependency proxy image ttl policy'
        :anonymous  | 'denying access to dependency proxy image ttl policy'
      end

      with_them do
        before do
          group.send(""add_#{user_role}"", user) unless user_role == :anonymous
        end

        it_behaves_like params[:shared_examples_name]
        it_behaves_like 'disabling admin_package feature flag', action: :creating if params[:user_role] == :maintainer
      end

      context 'when the policy is not found' do
        %i[owner maintainer].each do |role|
          context ""when user is #{role}"" do
            before do
              group.send(""add_#{role}"", user)
              stub_feature_flags(raise_group_admin_package_permission_to_owner: false)
              expect(group).to receive(:dependency_proxy_image_ttl_policy).and_return nil
            end

            it_behaves_like 'returning an error', 'Dependency proxy image TTL Policy not found', 404
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module DependencyProxy
  module GroupSettings
    class UpdateService < BaseContainerService
      ALLOWED_ATTRIBUTES = %i[enabled].freeze

      def execute
        return ServiceResponse.error(message: 'Access Denied', http_status: 403) unless allowed?
        return ServiceResponse.error(message: 'Dependency proxy setting not found', http_status: 404) unless dependency_proxy_setting

        if dependency_proxy_setting.update(dependency_proxy_setting_params)
          ServiceResponse.success(payload: { dependency_proxy_setting: dependency_proxy_setting })
        else
          ServiceResponse.error(
            message: dependency_proxy_setting.errors.full_messages.to_sentence || 'Bad request',
            http_status: 400
          )
        end
      end

      private

      def dependency_proxy_setting
        container.dependency_proxy_setting
      end

      def allowed?
        Ability.allowed?(current_user, :admin_dependency_proxy, container)
      end

      def dependency_proxy_setting_params
        params.slice(*ALLOWED_ATTRIBUTES)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::DependencyProxy::GroupSettings::UpdateService, feature_category: :dependency_proxy do
  using RSpec::Parameterized::TableSyntax

  let_it_be_with_reload(:group) { create(:group) }
  let_it_be_with_reload(:group_settings) { create(:dependency_proxy_group_setting, group: group) }
  let_it_be(:user) { create(:user) }
  let_it_be(:params) { { enabled: false } }

  describe '#execute' do
    subject { described_class.new(container: group, current_user: user, params: params).execute }

    shared_examples 'updating the dependency proxy group settings' do
      it_behaves_like 'updating the dependency proxy group settings attributes',
        from: { enabled: true },
        to: { enabled: false }

      it 'returns a success' do
        result = subject

        expect(result.payload[:dependency_proxy_setting]).to be_present
        expect(result).to be_success
      end
    end

    shared_examples 'denying access to dependency proxy group settings' do
      context 'with existing dependency proxy group settings' do
        it 'returns an error' do
          result = subject

          expect(result).to have_attributes(
            message: 'Access Denied',
            status: :error,
            http_status: 403
          )
        end
      end
    end

    where(:user_role, :shared_examples_name) do
      :owner      | 'updating the dependency proxy group settings'
      :maintainer | 'denying access to dependency proxy group settings'
      :developer  | 'denying access to dependency proxy group settings'
      :reporter   | 'denying access to dependency proxy group settings'
      :guest      | 'denying access to dependency proxy group settings'
      :anonymous  | 'denying access to dependency proxy group settings'
    end

    with_them do
      before do
        stub_config(dependency_proxy: { enabled: true })
        group.send(""add_#{user_role}"", user) unless user_role == :anonymous
      end

      it_behaves_like params[:shared_examples_name]

      context 'with disabled admin_package feature flag' do
        before do
          stub_feature_flags(raise_group_admin_package_permission_to_owner: false)
        end

        it_behaves_like 'updating the dependency proxy group settings' if params[:user_role] == :maintainer
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Jira
  module Requests
    module Projects
      class ListService < Base
        extend ::Gitlab::Utils::Override

        def initialize(jira_integration, params = {})
          super(jira_integration, params)

          @query = params[:query]
        end

        private

        attr_reader :query

        override :url
        def url
          ""#{base_api_url}/project""
        end

        override :build_service_response
        def build_service_response(response)
          return ServiceResponse.success(payload: empty_payload) unless response.present?

          ServiceResponse.success(payload: { projects: map_projects(response), is_last: true })
        end

        def map_projects(response)
          response
            .map { |v| JIRA::Resource::Project.build(client, v) }
            .select { |jira_project| match_query?(jira_project) }
        end

        def match_query?(jira_project)
          downcase_query = query.to_s.downcase

          jira_project&.key&.downcase&.include?(downcase_query) || jira_project&.name&.downcase&.include?(downcase_query)
        end

        def empty_payload
          { projects: [], is_last: true }
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Jira::Requests::Projects::ListService, feature_category: :groups_and_projects do
  include AfterNextHelpers

  let(:jira_integration) { create(:jira_integration) }
  let(:params) { {} }

  describe '#execute' do
    let(:service) { described_class.new(jira_integration, params) }

    subject { service.execute }

    context 'without jira_integration' do
      before do
        jira_integration.update!(active: false)
      end

      it 'returns an error response' do
        expect(subject.error?).to be_truthy
        expect(subject.message).to eq('Jira service not configured.')
      end
    end

    context 'when jira_integration is nil' do
      let(:jira_integration) { nil }

      it 'returns an error response' do
        expect(subject.error?).to be_truthy
        expect(subject.message).to eq('Jira service not configured.')
      end
    end

    context 'with jira_integration' do
      context 'when validations and params are ok' do
        let(:response_headers) { { 'content-type' => 'application/json' } }
        let(:response_body) { [].to_json }
        let(:expected_url_pattern) { %r{.*jira.example.com/rest/api/2/project} }

        before do
          stub_request(:get, expected_url_pattern).to_return(status: 200, body: response_body, headers: response_headers)
        end

        it_behaves_like 'a service that handles Jira API errors'

        context 'when jira runs on a subpath' do
          let(:jira_integration) { create(:jira_integration, url: 'http://jira.example.com/jira') }
          let(:expected_url_pattern) { %r{.*jira.example.com/jira/rest/api/2/project} }

          it 'takes the subpath into account' do
            expect(subject.success?).to be_truthy
          end
        end

        context 'when the request does not return any values' do
          let(:response_body) { [].to_json }

          it 'returns a paylod with no projects returned' do
            payload = subject.payload

            expect(subject.success?).to be_truthy
            expect(payload[:projects]).to be_empty
            expect(payload[:is_last]).to be_truthy
          end
        end

        context 'when the request returns values' do
          let(:response_body) { [{ 'key' => 'pr1', 'name' => 'First Project' }, { 'key' => 'pr2', 'name' => 'Second Project' }].to_json }

          it 'returns a paylod with Jira projects' do
            payload = subject.payload

            expect(subject.success?).to be_truthy
            expect(payload[:projects].map(&:key)).to eq(%w[pr1 pr2])
            expect(payload[:is_last]).to be_truthy
          end

          context 'when filtering projects by name' do
            let(:params) { { query: 'first' } }

            it 'returns a paylod with Jira procjets' do
              payload = subject.payload

              expect(subject.success?).to be_truthy
              expect(payload[:projects].map(&:key)).to eq(%w[pr1])
              expect(payload[:is_last]).to be_truthy
            end
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ContainerExpirationPolicies
  class CleanupService
    attr_reader :repository

    SERVICE_RESULT_FIELDS = %i[original_size before_truncate_size after_truncate_size before_delete_size deleted_size cached_tags_count].freeze

    def initialize(repository)
      @repository = repository
    end

    def execute
      return ServiceResponse.error(message: 'no repository') unless repository

      unless policy.valid?
        disable_policy!

        return ServiceResponse.error(message: 'invalid policy')
      end

      schedule_next_run_if_needed

      begin
        service_result = Projects::ContainerRepository::CleanupTagsService
                           .new(container_repository: repository, params: policy_params.merge('container_expiration_policy' => true))
                           .execute
      rescue StandardError
        repository.cleanup_unfinished!

        raise
      end

      if service_result[:status] == :success
        repository.update!(
          expiration_policy_cleanup_status: :cleanup_unscheduled,
          expiration_policy_completed_at: Time.zone.now,
          last_cleanup_deleted_tags_count: service_result[:deleted_size]
        )

        success(:finished, service_result)
      else
        repository.cleanup_unfinished!

        success(:unfinished, service_result)
      end
    end

    private

    def schedule_next_run_if_needed
      return if policy.next_run_at.future?

      repos_before_next_run = ::ContainerRepository.for_project_id(policy.project_id)
                                                   .expiration_policy_started_at_nil_or_before(policy.next_run_at)
      return if repos_before_next_run.exists?

      policy.schedule_next_run!
    end

    def disable_policy!
      policy.disable!
      repository.cleanup_unscheduled!

      Gitlab::ErrorTracking.log_exception(
        ::ContainerExpirationPolicyWorker::InvalidPolicyError.new,
        container_expiration_policy_id: policy.id
      )
    end

    def success(cleanup_status, service_result)
      payload = {
        cleanup_status: cleanup_status,
        container_repository_id: repository.id
      }

      SERVICE_RESULT_FIELDS.each do |field|
        payload[""cleanup_tags_service_#{field}"".to_sym] = service_result[field]
      end

      ServiceResponse.success(message: ""cleanup #{cleanup_status}"", payload: payload)
    end

    def policy_params
      return {} unless policy

      policy.policy_params
    end

    def policy
      project.container_expiration_policy
    end

    def project
      repository&.project
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ContainerExpirationPolicies::CleanupService, feature_category: :container_registry do
  let_it_be(:repository, reload: true) { create(:container_repository, expiration_policy_started_at: 30.minutes.ago) }
  let_it_be(:project) { repository.project }

  let(:service) { described_class.new(repository) }

  describe '#execute' do
    let(:policy) { repository.project.container_expiration_policy }

    subject { service.execute }

    before do
      policy.update!(enabled: true)
      policy.update_column(:next_run_at, 5.minutes.ago)
    end

    context 'with a successful cleanup tags service execution' do
      let(:cleanup_tags_service_params) { project.container_expiration_policy.policy_params.merge('container_expiration_policy' => true) }
      let(:cleanup_tags_service) { instance_double(Projects::ContainerRepository::CleanupTagsService) }

      it 'completely clean up the repository' do
        expect(Projects::ContainerRepository::CleanupTagsService)
          .to receive(:new).with(container_repository: repository, params: cleanup_tags_service_params).and_return(cleanup_tags_service)
        expect(cleanup_tags_service).to receive(:execute).and_return(status: :success, deleted_size: 1)

        response = subject

        aggregate_failures ""checking the response and container repositories"" do
          expect(response.success?).to eq(true)
          expect(response.payload).to include(cleanup_status: :finished, container_repository_id: repository.id)
          expect(ContainerRepository.waiting_for_cleanup.count).to eq(0)
          expect(repository.reload.cleanup_unscheduled?).to be_truthy
          expect(repository.expiration_policy_completed_at).not_to eq(nil)
          expect(repository.expiration_policy_started_at).not_to eq(nil)
          expect(repository.last_cleanup_deleted_tags_count).to eq(1)
        end
      end
    end

    context 'without a successful cleanup tags service execution' do
      let(:cleanup_tags_service_response) { { status: :error, message: 'timeout' } }

      before do
        expect(Projects::ContainerRepository::CleanupTagsService)
          .to receive(:new).and_return(double(execute: cleanup_tags_service_response))
      end

      it 'partially clean up the repository' do
        response = subject

        aggregate_failures ""checking the response and container repositories"" do
          expect(response.success?).to eq(true)
          expect(response.payload).to include(cleanup_status: :unfinished, container_repository_id: repository.id)
          expect(ContainerRepository.waiting_for_cleanup.count).to eq(1)
          expect(repository.reload.cleanup_unfinished?).to be_truthy
          expect(repository.expiration_policy_started_at).not_to eq(nil)
          expect(repository.expiration_policy_completed_at).to eq(nil)
          expect(repository.last_cleanup_deleted_tags_count).to eq(nil)
        end
      end

      context 'with a truncated cleanup tags service response' do
        let(:cleanup_tags_service_response) do
          {
            status: :error,
            original_size: 1000,
            before_truncate_size: 800,
            after_truncate_size: 200,
            before_delete_size: 100,
            cached_tags_count: 0,
            deleted_size: 100
          }
        end

        it 'partially clean up the repository' do
          response = subject

          aggregate_failures ""checking the response and container repositories"" do
            expect(response.success?).to eq(true)
            expect(response.payload)
              .to include(
                cleanup_status: :unfinished,
                container_repository_id: repository.id,
                cleanup_tags_service_original_size: 1000,
                cleanup_tags_service_before_truncate_size: 800,
                cleanup_tags_service_after_truncate_size: 200,
                cleanup_tags_service_before_delete_size: 100,
                cleanup_tags_service_cached_tags_count: 0,
                cleanup_tags_service_deleted_size: 100
              )
            expect(ContainerRepository.waiting_for_cleanup.count).to eq(1)
            expect(repository.reload.cleanup_unfinished?).to be_truthy
            expect(repository.expiration_policy_started_at).not_to eq(nil)
            expect(repository.expiration_policy_completed_at).to eq(nil)
            expect(repository.last_cleanup_deleted_tags_count).to eq(nil)
          end
        end
      end
    end

    context 'with no repository' do
      let(:service) { described_class.new(nil) }

      it 'returns an error response' do
        expect(subject.success?).to eq(false)
        expect(subject.message).to eq('no repository')
      end
    end

    context 'with an invalid policy' do
      let(:policy) { repository.project.container_expiration_policy }

      before do
        policy.name_regex = nil
        policy.enabled = true
        repository.expiration_policy_cleanup_status = :cleanup_ongoing
      end

      it 'returns an error response' do
        expect { subject }.to change { repository.expiration_policy_cleanup_status }.from('cleanup_ongoing').to('cleanup_unscheduled')
        expect(subject.success?).to eq(false)
        expect(subject.message).to eq('invalid policy')
        expect(policy).not_to be_enabled
      end
    end

    context 'with a network error' do
      before do
        expect(Projects::ContainerRepository::CleanupTagsService)
          .to receive(:new).and_raise(Faraday::TimeoutError)
      end

      it 'raises an error' do
        expect { subject }.to raise_error(Faraday::TimeoutError)

        expect(ContainerRepository.waiting_for_cleanup.count).to eq(1)
        expect(repository.reload.cleanup_unfinished?).to be_truthy
        expect(repository.expiration_policy_started_at).not_to eq(nil)
        expect(repository.expiration_policy_completed_at).to eq(nil)
        expect(repository.last_cleanup_deleted_tags_count).to eq(nil)
      end
    end

    context 'next run scheduling' do
      let_it_be_with_reload(:repository2) { create(:container_repository, project: project) }
      let_it_be_with_reload(:repository3) { create(:container_repository, project: project) }

      before do
        cleanup_tags_service = instance_double(Projects::ContainerRepository::CleanupTagsService)
        allow(Projects::ContainerRepository::CleanupTagsService)
          .to receive(:new).and_return(cleanup_tags_service)
        allow(cleanup_tags_service).to receive(:execute).and_return(status: :success)
      end

      shared_examples 'not scheduling the next run' do
        it 'does not scheduled the next run' do
          expect(policy).not_to receive(:schedule_next_run!)

          expect { subject }.not_to change { policy.reload.next_run_at }
        end
      end

      shared_examples 'scheduling the next run' do
        it 'schedules the next run' do
          expect(policy).to receive(:schedule_next_run!).and_call_original

          expect { subject }.to change { policy.reload.next_run_at }
        end
      end

      context 'with cleanups started_at before policy next_run_at' do
        before do
          ContainerRepository.update_all(expiration_policy_started_at: 10.minutes.ago)
        end

        it_behaves_like 'not scheduling the next run'
      end

      context 'with cleanups started_at around policy next_run_at' do
        before do
          repository3.update!(expiration_policy_started_at: policy.next_run_at + 10.minutes.ago)
        end

        it_behaves_like 'not scheduling the next run'
      end

      context 'with only the current repository started_at before the policy next_run_at' do
        before do
          repository.update!(expiration_policy_started_at: policy.next_run_at + 9.minutes)
          repository2.update!(expiration_policy_started_at: policy.next_run_at + 10.minutes)
          repository3.update!(expiration_policy_started_at: policy.next_run_at + 12.minutes)
        end

        it_behaves_like 'scheduling the next run'
      end

      context 'with cleanups started_at after policy next_run_at' do
        before do
          ContainerRepository.update_all(expiration_policy_started_at: policy.next_run_at + 10.minutes)
        end

        it_behaves_like 'scheduling the next run'
      end

      context 'with a future policy next_run_at' do
        before do
          policy.update_column(:next_run_at, 5.minutes.from_now)
        end

        it_behaves_like 'not scheduling the next run'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ContainerExpirationPolicies
  class UpdateService < BaseContainerService
    include Gitlab::Utils::StrongMemoize

    ALLOWED_ATTRIBUTES = %i[enabled cadence older_than keep_n name_regex name_regex_keep].freeze

    def execute
      return ServiceResponse.error(message: 'Access Denied', http_status: 403) unless allowed?

      if container_expiration_policy.update(container_expiration_policy_params)
        ServiceResponse.success(payload: { container_expiration_policy: container_expiration_policy })
      else
        ServiceResponse.error(
          message: container_expiration_policy.errors.full_messages.to_sentence || 'Bad request',
          http_status: 400
        )
      end
    end

    private

    def container_expiration_policy
      strong_memoize(:container_expiration_policy) do
        @container.container_expiration_policy || @container.build_container_expiration_policy
      end
    end

    def allowed?
      Ability.allowed?(current_user, :admin_container_image, @container)
    end

    def container_expiration_policy_params
      @params.slice(*ALLOWED_ATTRIBUTES)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ContainerExpirationPolicies::UpdateService, feature_category: :container_registry do
  using RSpec::Parameterized::TableSyntax

  let_it_be(:project, reload: true) { create(:project) }
  let_it_be(:user) { create(:user) }
  let_it_be(:params) { { cadence: '3month', keep_n: 100, older_than: '14d', extra_key: 'will_not_be_processed' } }

  let(:container_expiration_policy) { project.container_expiration_policy }

  describe '#execute' do
    subject { described_class.new(container: project, current_user: user, params: params).execute }

    RSpec.shared_examples 'returning a success' do
      it 'returns a success' do
        result = subject

        expect(result.payload[:container_expiration_policy]).to be_present
        expect(result.success?).to be_truthy
      end
    end

    RSpec.shared_examples 'returning an error' do |message, http_status|
      it 'returns an error' do
        result = subject

        expect(result.message).to eq(message)
        expect(result.status).to eq(:error)
        expect(result.http_status).to eq(http_status)
      end
    end

    RSpec.shared_examples 'updating the container expiration policy' do
      it_behaves_like 'updating the container expiration policy attributes', mode: :update, from: { cadence: '1d', keep_n: 10, older_than: '90d' }, to: { cadence: '3month', keep_n: 100, older_than: '14d' }

      it_behaves_like 'returning a success'

      context 'with invalid params' do
        let_it_be(:params) { { cadence: '20d' } }

        it_behaves_like 'not creating the container expiration policy'

        it ""doesn't update the cadence"" do
          expect { subject }
            .not_to change { container_expiration_policy.reload.cadence }
        end

        it_behaves_like 'returning an error', 'Cadence is not included in the list', 400
      end
    end

    RSpec.shared_examples 'denying access to container expiration policy' do
      context 'with existing container expiration policy' do
        it_behaves_like 'not creating the container expiration policy'

        it_behaves_like 'returning an error', 'Access Denied', 403
      end
    end

    context 'with existing container expiration policy' do
      where(:user_role, :shared_examples_name) do
        :maintainer | 'updating the container expiration policy'
        :developer  | 'denying access to container expiration policy'
        :reporter   | 'denying access to container expiration policy'
        :guest      | 'denying access to container expiration policy'
        :anonymous  | 'denying access to container expiration policy'
      end

      with_them do
        before do
          project.send(""add_#{user_role}"", user) unless user_role == :anonymous
        end

        it_behaves_like params[:shared_examples_name]
      end
    end

    context 'without existing container expiration policy' do
      let_it_be(:project, reload: true) { create(:project, :without_container_expiration_policy) }

      where(:user_role, :shared_examples_name) do
        :maintainer | 'creating the container expiration policy'
        :developer  | 'denying access to container expiration policy'
        :reporter   | 'denying access to container expiration policy'
        :guest      | 'denying access to container expiration policy'
        :anonymous  | 'denying access to container expiration policy'
      end

      with_them do
        before do
          project.send(""add_#{user_role}"", user) unless user_role == :anonymous
        end

        it_behaves_like params[:shared_examples_name]
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Notes
  class ResolveService < ::BaseService
    def execute(note)
      note.resolve!(current_user)

      ::MergeRequests::ResolvedDiscussionNotificationService.new(project: project, current_user: current_user).execute(note.noteable)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Notes::ResolveService, feature_category: :team_planning do
  let(:merge_request) { create(:merge_request) }
  let(:note) { create(:diff_note_on_merge_request, noteable: merge_request, project: merge_request.project) }
  let(:user) { merge_request.author }

  describe '#execute' do
    it ""resolves the note"" do
      described_class.new(merge_request.project, user).execute(note)
      note.reload

      expect(note.resolved?).to be true
      expect(note.resolved_by).to eq(user)
    end

    it ""sends notifications if all discussions are resolved"" do
      expect_next_instance_of(MergeRequests::ResolvedDiscussionNotificationService) do |instance|
        expect(instance).to receive(:execute).with(merge_request)
      end

      described_class.new(merge_request.project, user).execute(note)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# This service copies Notes from one Noteable to another.
#
# It expects the calling code to have performed the necessary authorization
# checks in order to allow the copy to happen.
module Notes
  class CopyService
    def initialize(current_user, from_noteable, to_noteable)
      raise ArgumentError, 'Noteables must be different' if from_noteable == to_noteable

      @current_user = current_user
      @from_noteable = from_noteable
      @to_noteable = to_noteable
      @from_project = from_noteable.project
      @new_discussion_ids = {}
    end

    def execute
      from_noteable.notes_with_associations.find_each do |note|
        copy_note(note)
      end

      ServiceResponse.success
    end

    private

    attr_reader :from_noteable, :to_noteable, :from_project, :current_user, :new_discussion_ids

    def copy_note(note)
      new_note = note.dup
      new_params = params_from_note(note, new_note)
      new_note.update!(new_params)

      copy_award_emoji(note, new_note)
    end

    def params_from_note(note, new_note)
      new_discussion_ids[note.discussion_id] ||= Discussion.discussion_id(new_note)

      new_params = sanitized_note_params(note)

      new_params.merge!(
        project: to_noteable.project,
        noteable: to_noteable,
        discussion_id: new_discussion_ids[note.discussion_id],
        created_at: note.created_at,
        updated_at: note.updated_at
      )

      if note.system_note_metadata
        new_params[:system_note_metadata] = note.system_note_metadata.dup

        # TODO: Implement copying of description versions when an issue is moved
        # https://gitlab.com/gitlab-org/gitlab/issues/32300
        new_params[:system_note_metadata].description_version = nil
      end

      new_params
    end

    # Skip copying cached markdown HTML if text
    # does not contain references or uploads.
    def sanitized_note_params(note)
      MarkdownContentRewriterService
        .new(current_user, note, :note, from_project, to_noteable.resource_parent)
        .execute
    end

    def copy_award_emoji(from_note, to_note)
      AwardEmojis::CopyService.new(from_note, to_note).execute
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Notes::CopyService, feature_category: :team_planning do
  describe '#initialize' do
    let_it_be(:noteable) { create(:issue) }

    it 'validates that we cannot copy notes to the same Noteable' do
      expect { described_class.new(nil, noteable, noteable) }.to raise_error(ArgumentError)
    end
  end

  describe '#execute' do
    let_it_be(:user) { create(:user) }
    let_it_be(:group) { create(:group) }
    let_it_be(:from_project) { create(:project, :public, group: group) }
    let_it_be(:to_project) { create(:project, :public, group: group) }
    let_it_be(:from_noteable) { create(:issue, project: from_project) }
    let_it_be(:to_noteable) { create(:issue, project: to_project) }

    subject(:execute_service) { described_class.new(user, from_noteable, to_noteable).execute }

    context 'rewriting the note body' do
      context 'simple notes' do
        let!(:notes) do
          [
            create(
              :note, noteable: from_noteable, project: from_noteable.project,
              created_at: 2.weeks.ago, updated_at: 1.week.ago
            ),
            create(:note, noteable: from_noteable, project: from_noteable.project),
            create(:note, system: true, noteable: from_noteable, project: from_noteable.project)
          ]
        end

        it 'rewrites existing notes in valid order' do
          execute_service

          expect(to_noteable.notes.order('id ASC').pluck(:note).first(3)).to eq(notes.map(&:note))
        end

        it 'copies all the issue notes' do
          execute_service

          expect(to_noteable.notes.count).to eq(3)
        end

        it 'does not change the note attributes' do
          execute_service

          new_note = to_noteable.notes.first

          expect(new_note).to have_attributes(
            note: notes.first.note,
            author: notes.first.author
          )
        end

        it 'copies the award emojis' do
          create(:award_emoji, awardable: notes.first, name: 'thumbsup')

          execute_service

          new_award_emoji = to_noteable.notes.first.award_emoji.first

          expect(new_award_emoji.name).to eq('thumbsup')
        end

        it 'copies system_note_metadata for system note' do
          system_note_metadata = create(:system_note_metadata, note: notes.last)

          execute_service

          new_note = to_noteable.notes.last

          aggregate_failures do
            expect(new_note.system_note_metadata.action).to eq(system_note_metadata.action)
            expect(new_note.system_note_metadata.id).not_to eq(system_note_metadata.id)
          end
        end

        it 'returns success' do
          aggregate_failures do
            expect(execute_service).to be_kind_of(ServiceResponse)
            expect(execute_service).to be_success
          end
        end

        it 'copies rendered markdown from note_html' do
          expect(Banzai::Renderer).not_to receive(:cacheless_render_field)

          execute_service

          new_note = to_noteable.notes.first
          expect(new_note.note_html).to eq(notes.first.note_html)
        end
      end

      context 'notes with mentions' do
        let!(:note_with_mention) { create(:note, noteable: from_noteable, author: from_noteable.author, project: from_noteable.project, note: ""note with mention #{user.to_reference}"") }
        let!(:note_with_no_mention) { create(:note, noteable: from_noteable, author: from_noteable.author, project: from_noteable.project, note: ""note without mention"") }

        it 'saves user mentions with actual mentions for new issue' do
          execute_service

          aggregate_failures do
            expect(to_noteable.user_mentions.first.mentioned_users_ids).to match_array([user.id])
            expect(to_noteable.user_mentions.count).to eq(1)
          end
        end
      end

      context 'notes with reference' do
        let(:other_issue) { create(:issue, project: from_noteable.project) }
        let(:merge_request) { create(:merge_request) }
        let(:text) { ""See ##{other_issue.iid} and #{merge_request.project.full_path}!#{merge_request.iid}"" }
        let!(:note) { create(:note, noteable: from_noteable, note: text, project: from_noteable.project) }

        it 'rewrites the references correctly' do
          execute_service

          new_note = to_noteable.notes.first

          expected_text = ""See #{other_issue.project.path}##{other_issue.iid} and #{merge_request.project.full_path}!#{merge_request.iid}""

          aggregate_failures do
            expect(new_note.note).to eq(expected_text)
            expect(new_note.author).to eq(note.author)
          end
        end

        it 'does not copy rendered markdown from note_html' do
          execute_service

          new_note = to_noteable.notes.first
          expect(new_note.note_html).not_to eq(note.note_html)
        end
      end

      context 'notes with upload' do
        let(:uploader) { build(:file_uploader, project: from_noteable.project) }
        let(:text) { ""Simple text with image: #{uploader.markdown_link} "" }
        let!(:note) { create(:note, noteable: from_noteable, note: text, project: from_noteable.project) }

        it 'rewrites note content correctly' do
          execute_service
          new_note = to_noteable.notes.first

          aggregate_failures do
            expect(note.note).to match(/Simple text with image:/o)
            expect(FileUploader::MARKDOWN_PATTERN.match(note.note)).not_to be_nil
            expect(new_note.note).to match(/Simple text with image:/o)
            expect(FileUploader::MARKDOWN_PATTERN.match(new_note.note)).not_to be_nil
            expect(note.note).not_to eq(new_note.note)
            expect(note.note_html).not_to eq(new_note.note_html)
          end
        end

        it 'does not copy rendered markdown from note_html' do
          execute_service

          new_note = to_noteable.notes.first
          expect(new_note.note_html).not_to eq(note.note_html)
        end
      end

      context 'discussion notes' do
        let(:note) { create(:note, noteable: from_noteable, note: 'sample note', project: from_noteable.project) }
        let!(:discussion) { create(:discussion_note_on_issue, in_reply_to: note, note: 'reply to sample note') }

        it 'rewrites discussion correctly' do
          execute_service

          aggregate_failures do
            expect(to_noteable.notes.count).to eq(from_noteable.notes.count)
            expect(to_noteable.notes.where(discussion_id: discussion.discussion_id).count).to eq(0)
            expect(from_noteable.notes.where(discussion_id: discussion.discussion_id).count).to eq(1)
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Notes
  class PostProcessService
    attr_accessor :note

    def initialize(note)
      @note = note
    end

    def execute
      # Skip system notes, like status changes and cross-references and awards
      unless note.system?
        EventCreateService.new.leave_note(note, note.author)

        return if note.for_personal_snippet?

        note.create_cross_references!
        ::SystemNoteService.design_discussion_added(note) if create_design_discussion_system_note?

        execute_note_hooks
      end
    end

    private

    def create_design_discussion_system_note?
      note && note.for_design? && note.start_of_discussion?
    end

    def hook_data
      Gitlab::DataBuilder::Note.build(note, note.author)
    end

    def execute_note_hooks
      return unless note.project

      note_data = hook_data
      is_confidential = note.confidential?(include_noteable: true)
      hooks_scope = is_confidential ? :confidential_note_hooks : :note_hooks

      note.project.execute_hooks(note_data, hooks_scope)
      note.project.execute_integrations(note_data, hooks_scope)

      execute_group_mention_hooks(note, note_data, is_confidential)
    end

    def execute_group_mention_hooks(note, note_data, is_confidential)
      Integrations::GroupMentionService.new(note, hook_data: note_data, is_confidential: is_confidential).execute
    end
  end
end

Notes::PostProcessService.prepend_mod_with('Notes::PostProcessService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Notes::PostProcessService, feature_category: :team_planning do
  let(:project) { create(:project) }
  let(:issue) { create(:issue, project: project) }
  let(:user) { create(:user) }

  describe '#execute' do
    before do
      project.add_maintainer(user)
      note_opts = {
        note: 'Awesome comment',
        noteable_type: 'Issue',
        noteable_id: issue.id
      }

      @note = Notes::CreateService.new(project, user, note_opts).execute
    end

    it do
      expect(project).to receive(:execute_hooks)
      expect(project).to receive(:execute_integrations)
      expect_next_instance_of(Integrations::GroupMentionService) do |group_mention_service|
        expect(group_mention_service).to receive(:execute)
      end

      described_class.new(@note).execute
    end

    context 'with a confidential issue' do
      let(:issue) { create(:issue, :confidential, project: project) }

      it ""doesn't call note hooks/integrations"" do
        expect(project).not_to receive(:execute_hooks).with(anything, :note_hooks)
        expect(project).not_to receive(:execute_integrations).with(anything, :note_hooks)

        described_class.new(@note).execute
      end

      it ""calls confidential-note hooks/integrations"" do
        expect(project).to receive(:execute_hooks).with(anything, :confidential_note_hooks)
        expect(project).to receive(:execute_integrations).with(anything, :confidential_note_hooks)

        described_class.new(@note).execute
      end
    end

    context 'when the noteable is a design' do
      let_it_be(:noteable) { create(:design, :with_file) }
      let_it_be(:discussion_note) { create_note }

      subject { described_class.new(note).execute }

      def create_note(in_reply_to: nil)
        create(:diff_note_on_design, noteable: noteable, in_reply_to: in_reply_to)
      end

      context 'when the note is the start of a new discussion' do
        let(:note) { discussion_note }

        it 'creates a new system note' do
          expect { subject }.to change { Note.system.count }.by(1)
        end
      end

      context 'when the note is a reply within a discussion' do
        let_it_be(:note) { create_note(in_reply_to: discussion_note) }

        it 'does not create a new system note' do
          expect { subject }.not_to change { Note.system.count }
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# QuickActionsService class
#
# Executes quick actions commands extracted from note text
#
# Most commands returns parameters to be applied later
# using QuickActionService#apply_updates
#
module Notes
  class QuickActionsService < BaseService
    attr_reader :interpret_service

    delegate :commands_executed_count, to: :interpret_service, allow_nil: true

    SUPPORTED_NOTEABLES = %w[WorkItem Issue MergeRequest Commit].freeze

    private_constant :SUPPORTED_NOTEABLES

    def self.supported_noteables
      SUPPORTED_NOTEABLES
    end

    def self.supported?(note)
      return true if note.for_work_item?

      supported_noteables.include? note.noteable_type
    end

    def supported?(note)
      self.class.supported?(note)
    end

    def execute(note, options = {})
      return [note.note, {}] unless supported?(note)

      @interpret_service = QuickActions::InterpretService.new(project, current_user, options)

      interpret_service.execute(note.note, note.noteable)
    end

    # Applies updates extracted to note#noteable
    # The update parameters are extracted on self#execute
    def apply_updates(update_params, note)
      return if update_params.empty?
      return unless supported?(note)

      # We need the `id` after the note is persisted
      if update_params[:spend_time]
        update_params[:spend_time][:note_id] = note.id
      end

      execute_update_service(note, update_params)
    end

    private

    def execute_update_service(note, params)
      service_response = noteable_update_service(note, params).execute(note.noteable)

      service_errors = if service_response.respond_to?(:errors)
                         service_response.errors.full_messages
                       elsif service_response.respond_to?(:[]) && service_response[:status] == :error
                         Array.wrap(service_response[:message])
                       end

      service_errors.blank? ? ServiceResponse.success : ServiceResponse.error(message: service_errors)
    end

    def noteable_update_service(note, update_params)
      if note.for_work_item?
        parsed_params = note.noteable.transform_quick_action_params(update_params)

        WorkItems::UpdateService.new(
          container: note.resource_parent,
          current_user: current_user,
          params: parsed_params[:common],
          widget_params: parsed_params[:widgets]
        )
      elsif note.for_issue?
        Issues::UpdateService.new(container: note.resource_parent, current_user: current_user, params: update_params)
      elsif note.for_merge_request?
        MergeRequests::UpdateService.new(
          project: note.resource_parent, current_user: current_user, params: update_params
        )
      elsif note.for_commit?
        Commits::TagService.new(note.resource_parent, current_user, update_params)
      end
    end
  end
end

Notes::QuickActionsService.prepend_mod_with('Notes::QuickActionsService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Notes::QuickActionsService, feature_category: :team_planning do
  shared_context 'note on noteable' do
    let_it_be(:project) { create(:project, :repository) }
    let_it_be(:maintainer) { create(:user).tap { |u| project.add_maintainer(u) } }
    let_it_be(:assignee) { create(:user) }

    before do
      project.add_maintainer(assignee)
    end
  end

  shared_examples 'note on noteable that supports quick actions' do
    include_context 'note on noteable'

    before do
      note.note = note_text
    end

    let!(:milestone) { create(:milestone, project: project) }
    let!(:labels) { create_pair(:label, project: project) }

    describe 'note with only command' do
      describe '/close, /label, /assign & /milestone' do
        let(:note_text) do
          %(/close\n/label ~#{labels.first.name} ~#{labels.last.name}\n/assign @#{assignee.username}\n/milestone %""#{milestone.name}"")
        end

        it 'closes noteable, sets labels, assigns, and sets milestone to noteable, and leave no note' do
          content = execute(note)

          expect(content).to be_empty
          expect(note.noteable).to be_closed
          expect(note.noteable.labels).to match_array(labels)
          expect(note.noteable.assignees).to eq([assignee])
          expect(note.noteable.milestone).to eq(milestone)
        end
      end

      context '/relate' do
        let_it_be(:issue) { create(:issue, project: project) }
        let_it_be(:other_issue) { create(:issue, project: project) }

        let(:note_text) { ""/relate #{other_issue.to_reference}"" }
        let(:note) { create(:note_on_issue, noteable: issue, project: project, note: note_text) }

        context 'user cannot relate issues', :sidekiq_inline do
          before do
            project.team.find_member(maintainer.id).destroy!
            project.update!(visibility: Gitlab::VisibilityLevel::PUBLIC)
          end

          it 'does not create issue relation' do
            expect { execute(note) }.not_to change { IssueLink.count }
          end
        end

        context 'user is allowed to relate issues' do
          it 'creates issue relation' do
            expect { execute(note) }.to change { IssueLink.count }.by(1)
          end
        end
      end

      describe '/reopen' do
        before do
          note.noteable.close!
          expect(note.noteable).to be_closed
        end
        let(:note_text) { '/reopen' }

        it 'opens the noteable, and leave no note' do
          content = execute(note)

          expect(content).to be_empty
          expect(note.noteable).to be_open
        end
      end

      describe '/spend' do
        context 'when note is not persisted' do
          let(:note_text) { '/spend 1h' }

          it 'adds time to noteable, adds timelog with nil note_id and has no content' do
            content = execute(note)

            expect(content).to be_empty
            expect(note.noteable.time_spent).to eq(3600)
            expect(Timelog.last.note_id).to be_nil
          end
        end

        context 'when note is persisted' do
          let(:note_text) { ""a note \n/spend 1h"" }

          it 'updates the spent time and populates timelog with note_id' do
            new_content, update_params = service.execute(note)
            note.update!(note: new_content)
            service.apply_updates(update_params, note)

            expect(Timelog.last.note_id).to eq(note.id)
          end
        end

        context 'adds a system note' do
          context 'when not specifying a date' do
            let(:note_text) { ""/spend 1h"" }

            it 'does not include the date' do
              _, update_params = service.execute(note)
              service.apply_updates(update_params, note)

              expect(Note.last.note).to eq('added 1h of time spent')
            end
          end

          context 'when specifying a date' do
            let(:note_text) { ""/spend 1h 2020-01-01"" }

            it 'does include the date' do
              _, update_params = service.execute(note)
              service.apply_updates(update_params, note)

              expect(Note.last.note).to eq('added 1h of time spent at 2020-01-01')
            end
          end
        end
      end
    end

    describe '/estimate' do
      before do
        # reset to 10 minutes before each test
        note.noteable.update!(time_estimate: 600)
      end

      shared_examples 'does not update time_estimate and displays the correct error message' do
        it 'shows validation error message' do
          content = execute(note)

          expect(content).to be_empty
          expect(note.noteable.errors[:time_estimate]).to include('must have a valid format and be greater than or equal to zero.')
          expect(note.noteable.reload.time_estimate).to eq(600)
        end
      end

      context 'when the time estimate is valid' do
        let(:note_text) { '/estimate 1h' }

        it 'adds time estimate to noteable' do
          content = execute(note)

          expect(content).to be_empty
          expect(note.noteable.reload.time_estimate).to eq(3600)
        end
      end

      context 'when the time estimate is 0' do
        let(:note_text) { '/estimate 0' }

        it 'adds time estimate to noteable' do
          content = execute(note)

          expect(content).to be_empty
          expect(note.noteable.reload.time_estimate).to eq(0)
        end
      end

      context 'when the time estimate is invalid' do
        let(:note_text) { '/estimate a' }

        include_examples ""does not update time_estimate and displays the correct error message""
      end

      context 'when the time estimate is partially invalid' do
        let(:note_text) { '/estimate 1d 3id' }

        include_examples ""does not update time_estimate and displays the correct error message""
      end

      context 'when the time estimate is negative' do
        let(:note_text) { '/estimate -1h' }

        include_examples ""does not update time_estimate and displays the correct error message""
      end
    end

    describe '/confidential' do
      let_it_be_with_reload(:noteable) { create(:work_item, :issue, project: project) }
      let_it_be(:note_text) { '/confidential' }
      let_it_be(:note) { create(:note, noteable: noteable, project: project, note: note_text) }

      context 'when work item does not have children' do
        it 'leaves the note empty' do
          expect(execute(note)).to be_empty
        end

        it 'marks work item as confidential' do
          expect { execute(note) }.to change { noteable.reload.confidential }.from(false).to(true)
        end
      end

      context 'when work item has children' do
        before do
          create(:parent_link, work_item: task, work_item_parent: noteable)
        end

        context 'when children are not confidential' do
          let(:task) { create(:work_item, :task, project: project) }

          it 'does not mark parent work item as confidential' do
            expect { execute(note) }.to not_change { noteable.reload.confidential }.from(false)
            expect(noteable.errors[:base]).to include('A confidential work item cannot have a parent that already has non-confidential children.')
          end
        end

        context 'when children are confidential' do
          let(:task) { create(:work_item, :confidential, :task, project: project) }

          it 'marks parent work item as confidential' do
            expect { execute(note) }.to change { noteable.reload.confidential }.from(false).to(true)
          end
        end
      end
    end

    describe 'note with command & text' do
      describe '/close, /label, /assign & /milestone' do
        let(:note_text) do
          %(HELLO\n/close\n/label ~#{labels.first.name} ~#{labels.last.name}\n/assign @#{assignee.username}\n/milestone %""#{milestone.name}""\nWORLD)
        end

        it 'closes noteable, sets labels, assigns, and sets milestone to noteable' do
          content = execute(note)

          expect(content).to eq ""HELLO\nWORLD""
          expect(note.noteable).to be_closed
          expect(note.noteable.labels).to match_array(labels)
          expect(note.noteable.assignees).to eq([assignee])
          expect(note.noteable.milestone).to eq(milestone)
        end
      end

      describe '/reopen' do
        before do
          note.noteable.close
          expect(note.noteable).to be_closed
        end
        let(:note_text) { ""HELLO\n/reopen\nWORLD"" }

        it 'opens the noteable' do
          content = execute(note)

          expect(content).to eq ""HELLO\nWORLD""
          expect(note.noteable).to be_open
        end
      end
    end

    describe '/milestone' do
      let(:issue) { create(:issue, project: project) }
      let(:note_text) { %(/milestone %""#{milestone.name}"") }
      let(:note) { create(:note_on_issue, noteable: issue, project: project, note: note_text) }

      context 'on an incident' do
        before do
          issue.update!(work_item_type: WorkItems::Type.default_by_type(:incident))
        end

        it 'leaves the note empty' do
          expect(execute(note)).to be_empty
        end

        it 'assigns the milestone' do
          expect { execute(note) }.to change { issue.reload.milestone }.from(nil).to(milestone)
        end
      end

      context 'on a merge request' do
        let(:note_mr) { create(:note_on_merge_request, project: project, note: note_text) }

        it 'leaves the note empty' do
          expect(execute(note_mr)).to be_empty
        end

        it 'assigns the milestone' do
          expect { execute(note) }.to change { issue.reload.milestone }.from(nil).to(milestone)
        end
      end
    end

    describe '/remove_milestone' do
      let(:issue) { create(:issue, project: project, milestone: milestone) }
      let(:note_text) { '/remove_milestone' }
      let(:note) { create(:note_on_issue, noteable: issue, project: project, note: note_text) }

      context 'on an issue' do
        it 'leaves the note empty' do
          expect(execute(note)).to be_empty
        end

        it 'removes the milestone' do
          expect { execute(note) }.to change { issue.reload.milestone }.from(milestone).to(nil)
        end
      end

      context 'on an incident' do
        before do
          issue.update!(work_item_type: WorkItems::Type.default_by_type(:incident))
        end

        it 'leaves the note empty' do
          expect(execute(note)).to be_empty
        end

        it 'removes the milestone' do
          expect { execute(note) }.to change { issue.reload.milestone }.from(milestone).to(nil)
        end
      end

      context 'on a merge request' do
        let(:note_mr) { create(:note_on_merge_request, project: project, note: note_text) }

        it 'leaves the note empty' do
          expect(execute(note_mr)).to be_empty
        end

        it 'removes the milestone' do
          expect { execute(note) }.to change { issue.reload.milestone }.from(milestone).to(nil)
        end
      end
    end

    describe '/add_child' do
      let_it_be_with_reload(:noteable) { create(:work_item, :objective, project: project) }
      let_it_be_with_reload(:child) { create(:work_item, :objective, project: project) }
      let_it_be_with_reload(:second_child) { create(:work_item, :objective, project: project) }
      let_it_be(:note_text) { ""/add_child #{child.to_reference}, #{second_child.to_reference}"" }
      let_it_be(:note) { create(:note, noteable: noteable, project: project, note: note_text) }
      let_it_be(:children) { [child, second_child] }

      shared_examples 'adds child work items' do
        it 'leaves the note empty' do
          expect(execute(note)).to be_empty
        end

        it 'adds child work items' do
          execute(note)

          expect(noteable.valid?).to be_truthy
          expect(noteable.work_item_children).to eq(children)
        end
      end

      context 'when using work item reference' do
        let_it_be(:note_text) { ""/add_child #{child.to_reference(full: true)},#{second_child.to_reference(full: true)}"" }

        it_behaves_like 'adds child work items'
      end

      context 'when using work item iid' do
        it_behaves_like 'adds child work items'
      end

      context 'when using work item URL' do
        let_it_be(:project_path) { ""#{Gitlab.config.gitlab.url}/#{project.full_path}"" }
        let_it_be(:url) { ""#{project_path}/work_items/#{child.iid},#{project_path}/work_items/#{second_child.iid}"" }
        let_it_be(:note_text) { ""/add_child #{url}"" }

        it_behaves_like 'adds child work items'
      end
    end

    describe '/set_parent' do
      let_it_be_with_reload(:noteable) { create(:work_item, :objective, project: project) }
      let_it_be_with_reload(:parent) { create(:work_item, :objective, project: project) }
      let_it_be(:note_text) { ""/set_parent #{parent.to_reference}"" }
      let_it_be(:note) { create(:note, noteable: noteable, project: project, note: note_text) }

      shared_examples 'sets work item parent' do
        it 'leaves the note empty' do
          expect(execute(note)).to be_empty
        end

        it 'sets work item parent' do
          execute(note)

          expect(parent.valid?).to be_truthy
          expect(noteable.work_item_parent).to eq(parent)
        end
      end

      context 'when using work item reference' do
        let_it_be(:note_text) { ""/set_parent #{project.full_path}#{parent.to_reference}"" }

        it_behaves_like 'sets work item parent'
      end

      context 'when using work item iid' do
        let_it_be(:note_text) { ""/set_parent #{parent.to_reference}"" }

        it_behaves_like 'sets work item parent'
      end

      context 'when using work item URL' do
        let_it_be(:url) { ""#{Gitlab.config.gitlab.url}/#{project.full_path}/work_items/#{parent.iid}"" }
        let_it_be(:note_text) { ""/set_parent #{url}"" }

        it_behaves_like 'sets work item parent'
      end
    end

    describe '/promote_to' do
      shared_examples 'promotes work item' do |from:, to:|
        it 'leaves the note empty' do
          expect(execute(note)).to be_empty
        end

        it 'promotes to provided type' do
          expect { execute(note) }.to change { noteable.work_item_type.base_type }.from(from).to(to)
        end
      end

      context 'on a task' do
        let_it_be_with_reload(:noteable) { create(:work_item, :task, project: project) }
        let_it_be(:note_text) { '/promote_to Issue' }
        let_it_be(:note) { create(:note, noteable: noteable, project: project, note: note_text) }

        it_behaves_like 'promotes work item', from: 'task', to: 'issue'

        context 'when type name is lower case' do
          let_it_be(:note_text) { '/promote_to issue' }

          it_behaves_like 'promotes work item', from: 'task', to: 'issue'
        end
      end

      context 'on an issue' do
        let_it_be_with_reload(:noteable) { create(:work_item, :issue, project: project) }
        let_it_be(:note_text) { '/promote_to Incident' }
        let_it_be(:note) { create(:note, noteable: noteable, project: project, note: note_text) }

        it_behaves_like 'promotes work item', from: 'issue', to: 'incident'

        context 'when type name is lower case' do
          let_it_be(:note_text) { '/promote_to incident' }

          it_behaves_like 'promotes work item', from: 'issue', to: 'incident'
        end
      end
    end
  end

  describe '.supported?' do
    include_context 'note on noteable'

    let(:note) { create(:note_on_issue, project: project) }

    context 'with a note on an issue' do
      it 'returns true' do
        expect(described_class.supported?(note)).to be_truthy
      end
    end

    context 'with a note on a commit' do
      let(:note) { create(:note_on_commit, project: project) }

      it 'returns false' do
        expect(described_class.supported?(note)).to be_truthy
      end
    end
  end

  describe '#supported?' do
    include_context 'note on noteable'

    it 'delegates to the class method' do
      service = described_class.new(project, maintainer)
      note = create(:note_on_issue, project: project)

      expect(described_class).to receive(:supported?).with(note)

      service.supported?(note)
    end
  end

  describe '#execute' do
    let(:service) { described_class.new(project, maintainer) }

    it_behaves_like 'note on noteable that supports quick actions' do
      let_it_be(:issue, reload: true) { create(:issue, project: project) }
      let(:note) { build(:note_on_issue, project: project, noteable: issue) }
    end

    it_behaves_like 'note on noteable that supports quick actions' do
      let_it_be(:incident, reload: true) { create(:incident, project: project) }
      let(:note) { build(:note_on_issue, project: project, noteable: incident) }
    end

    it_behaves_like 'note on noteable that supports quick actions' do
      let(:merge_request) { create(:merge_request, source_project: project) }
      let(:note) { build(:note_on_merge_request, project: project, noteable: merge_request) }
    end

    context 'note on work item that supports quick actions' do
      include_context 'note on noteable'

      let_it_be(:work_item, reload: true) { create(:work_item, project: project) }

      let(:note) { build(:note_on_work_item, project: project, noteable: work_item) }

      let!(:labels) { create_pair(:label, project: project) }

      before do
        note.note = note_text
      end

      describe 'note with only command' do
        describe '/close, /label & /assign' do
          let(:note_text) do
            %(/close\n/label ~#{labels.first.name} ~#{labels.last.name}\n/assign @#{assignee.username}\n)
          end

          it 'closes noteable, sets labels, assigns and leave no note' do
            content = execute(note)

            expect(content).to be_empty
            expect(note.noteable).to be_closed
            expect(note.noteable.labels).to match_array(labels)
            expect(note.noteable.assignees).to eq([assignee])
          end
        end

        describe '/reopen' do
          before do
            note.noteable.close!
            expect(note.noteable).to be_closed
          end
          let(:note_text) { '/reopen' }

          it 'opens the noteable, and leave no note' do
            content = execute(note)

            expect(content).to be_empty
            expect(note.noteable).to be_open
          end
        end
      end

      describe 'note with command & text' do
        describe '/close, /label, /assign' do
          let(:note_text) do
            %(HELLO\n/close\n/label ~#{labels.first.name} ~#{labels.last.name}\n/assign @#{assignee.username}\nWORLD)
          end

          it 'closes noteable, sets labels, assigns, and sets milestone to noteable' do
            content = execute(note)

            expect(content).to eq ""HELLO\nWORLD""
            expect(note.noteable).to be_closed
            expect(note.noteable.labels).to match_array(labels)
            expect(note.noteable.assignees).to eq([assignee])
          end
        end

        describe '/reopen' do
          before do
            note.noteable.close
            expect(note.noteable).to be_closed
          end
          let(:note_text) { ""HELLO\n/reopen\nWORLD"" }

          it 'opens the noteable' do
            content = execute(note)

            expect(content).to eq ""HELLO\nWORLD""
            expect(note.noteable).to be_open
          end
        end
      end
    end
  end

  describe '#apply_updates' do
    include_context 'note on noteable'

    let_it_be(:issue) { create(:issue, project: project) }
    let_it_be(:work_item, reload: true) { create(:work_item, :issue, project: project) }
    let_it_be(:merge_request) { create(:merge_request, source_project: project) }
    let_it_be(:issue_note) { create(:note_on_issue, project: project, noteable: issue) }
    let_it_be(:work_item_note) { create(:note, project: project, noteable: work_item) }
    let_it_be(:mr_note) { create(:note_on_merge_request, project: project, noteable: merge_request) }
    let_it_be(:commit_note) { create(:note_on_commit, project: project) }
    let(:update_params) { {} }

    subject(:apply_updates) { described_class.new(project, maintainer).apply_updates(update_params, note) }

    context 'with a note on an issue' do
      let(:note) { issue_note }

      it 'returns successful service response if update returned no errors' do
        update_params[:confidential] = true
        expect(apply_updates.success?).to be true
      end

      it 'returns service response with errors if update failed' do
        update_params[:title] = """"
        expect(apply_updates.success?).to be false
        expect(apply_updates.message).to include(""Title can't be blank"")
      end
    end

    context 'with a note on a merge request' do
      let(:note) { mr_note }

      it 'returns successful service response if update returned no errors' do
        update_params[:title] = 'New title'
        expect(apply_updates.success?).to be true
      end

      it 'returns service response with errors if update failed' do
        update_params[:title] = """"
        expect(apply_updates.success?).to be false
        expect(apply_updates.message).to include(""Title can't be blank"")
      end
    end

    context 'with a note on a work item' do
      let(:note) { work_item_note }

      before do
        update_params[:confidential] = true
      end

      it 'returns successful service response if update returned no errors' do
        expect(apply_updates.success?).to be true
      end

      it 'returns service response with errors if update failed' do
        task = create(:work_item, :task, project: project)
        create(:parent_link, work_item: task, work_item_parent: work_item)

        expect(apply_updates.success?).to be false
        expect(apply_updates.message)
          .to include(""A confidential work item cannot have a parent that already has non-confidential children."")
      end
    end

    context 'with a note on a commit' do
      let(:note) { commit_note }

      it 'returns successful service response if update returned no errors' do
        update_params[:tag_name] = 'test'
        expect(apply_updates.success?).to be true
      end

      it 'returns service response with errors if update failed' do
        update_params[:tag_name] = '-test'
        expect(apply_updates.success?).to be false
        expect(apply_updates.message).to include('Tag name invalid')
      end
    end
  end

  context 'CE restriction for issue assignees' do
    describe '/assign' do
      let(:project) { create(:project) }
      let(:assignee) { create(:user) }
      let(:maintainer) { create(:user) }
      let(:service) { described_class.new(project, maintainer) }
      let(:note) { create(:note_on_issue, note: note_text, project: project) }

      let(:note_text) do
        %(/assign @#{assignee.username} @#{maintainer.username}\n"")
      end

      before do
        stub_licensed_features(multiple_issue_assignees: false)
        project.add_maintainer(maintainer)
        project.add_maintainer(assignee)
      end

      it 'adds only one assignee from the list' do
        execute(note)

        expect(note.noteable.assignees.count).to eq(1)
      end
    end
  end

  def execute(note)
    content, update_params = service.execute(note)
    service.apply_updates(update_params, note)

    content
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Notes
  class BuildService < ::BaseService
    def execute
      in_reply_to_discussion_id = params.delete(:in_reply_to_discussion_id)
      external_author = params.delete(:external_author)

      discussion = nil

      if external_author.present?
        note_metadata = Notes::NoteMetadata.new(email_participant: external_author)
        params[:note_metadata] = note_metadata
      end

      if in_reply_to_discussion_id.present?
        discussion = find_discussion(in_reply_to_discussion_id)

        return discussion_not_found unless discussion && can?(current_user, :create_note, discussion.noteable)

        discussion = discussion.convert_to_discussion! if discussion.can_convert_to_discussion?

        params.merge!(discussion.reply_attributes)
      end

      # The `confidential` param for notes is deprecated with 15.3
      # and renamed to `internal`.
      # We still accept `confidential` until the param gets removed from the API.
      # Until we have not migrated the database column to `internal` we need to rename
      # the parameter. Issue: https://gitlab.com/gitlab-org/gitlab/-/issues/367923.
      params[:confidential] = params[:internal] || params[:confidential]
      params.delete(:internal)

      new_note(params, discussion)
    end

    private

    def new_note(params, discussion)
      note = Note.new(params)
      note.project = project
      note.author = current_user

      parent_confidential = discussion&.confidential?
      can_set_confidential = can?(current_user, :mark_note_as_internal, note)

      return discussion_not_found if parent_confidential && !can_set_confidential

      note.confidential = (parent_confidential.nil? && can_set_confidential ? params.delete(:confidential) : parent_confidential)
      note.resolve_without_save(current_user) if discussion&.resolved?
      note
    end

    def find_discussion(discussion_id)
      if project
        project.notes.find_discussion(discussion_id)
      else
        Note.find_discussion(discussion_id)
      end
    end

    def discussion_not_found
      note = Note.new
      note.errors.add(:base, _('Discussion to reply to cannot be found'))
      note
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Notes::BuildService, feature_category: :team_planning do
  include AdminModeHelper

  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:note) { create(:discussion_note_on_issue, project: project) }
  let_it_be(:author) { note.author }
  let_it_be(:user) { author }
  let_it_be(:noteable_author) { create(:user) }
  let_it_be(:other_user) { create(:user) }
  let_it_be(:external) { create(:user, :external) }

  let(:base_params) { { note: 'Test' } }
  let(:params) { {} }

  subject(:new_note) { described_class.new(project, user, base_params.merge(params)).execute }

  describe '#execute' do
    context 'when in_reply_to_discussion_id is specified' do
      let(:params) { { in_reply_to_discussion_id: note.discussion_id } }

      context 'when a note with that original discussion ID exists' do
        it 'sets the note up to be in reply to that note' do
          expect(new_note).to be_valid
          expect(new_note.in_reply_to?(note)).to be_truthy
          expect(new_note.resolved?).to be_falsey
        end

        context 'when discussion is resolved' do
          let_it_be(:merge_request) { create(:merge_request, source_project: project) }
          let_it_be(:mr_note) { create(:discussion_note_on_merge_request, :resolved, noteable: merge_request, project: project, author: author) }

          let(:params) { { in_reply_to_discussion_id: mr_note.discussion_id } }

          it 'resolves the note' do
            expect(new_note).to be_valid
            expect(new_note.resolved?).to be_truthy
          end
        end
      end

      context 'when a note with that discussion ID exists' do
        it 'sets the note up to be in reply to that note' do
          expect(new_note).to be_valid
          expect(new_note.in_reply_to?(note)).to be_truthy
        end
      end

      context 'when no note with that discussion ID exists' do
        let(:params) { { in_reply_to_discussion_id: 'foo' } }

        it 'sets an error' do
          expect(new_note.errors[:base]).to include('Discussion to reply to cannot be found')
        end
      end

      context 'when user has no access to discussion' do
        let(:user) { other_user }

        it 'sets an error' do
          expect(new_note.errors[:base]).to include('Discussion to reply to cannot be found')
        end
      end

      context 'personal snippet note' do
        def reply(note, user = other_user)
          described_class.new(
            nil,
            user,
            note: 'Test',
            in_reply_to_discussion_id: note.discussion_id
          ).execute
        end

        let_it_be(:snippet_author) { noteable_author }

        context 'when a snippet is public' do
          it 'creates a reply note' do
            snippet = create(:personal_snippet, :public)
            note = create(:discussion_note_on_personal_snippet, noteable: snippet)

            new_note = reply(note)

            expect(new_note).to be_valid
            expect(new_note.in_reply_to?(note)).to be_truthy
          end
        end

        context 'when a snippet is private' do
          let_it_be(:snippet) { create(:personal_snippet, :private, author: snippet_author) }
          let_it_be(:note) { create(:discussion_note_on_personal_snippet, noteable: snippet) }

          it 'creates a reply note when the author replies' do
            new_note = reply(note, snippet_author)

            expect(new_note).to be_valid
            expect(new_note.in_reply_to?(note)).to be_truthy
          end

          it 'sets an error when another user replies' do
            new_note = reply(note)

            expect(new_note.errors[:base]).to include('Discussion to reply to cannot be found')
          end
        end

        context 'when a snippet is internal' do
          let_it_be(:snippet) { create(:personal_snippet, :internal, author: snippet_author) }
          let_it_be(:note) { create(:discussion_note_on_personal_snippet, noteable: snippet) }

          it 'creates a reply note when the author replies' do
            new_note = reply(note, snippet_author)

            expect(new_note).to be_valid
            expect(new_note.in_reply_to?(note)).to be_truthy
          end

          it 'creates a reply note when a regular user replies' do
            new_note = reply(note)

            expect(new_note).to be_valid
            expect(new_note.in_reply_to?(note)).to be_truthy
          end

          it 'sets an error when an external user replies' do
            new_note = reply(note, external)

            expect(new_note.errors[:base]).to include('Discussion to reply to cannot be found')
          end
        end
      end
    end

    context 'when replying to individual note' do
      let_it_be(:note) { create(:note_on_issue, project: project) }

      let(:params) { { in_reply_to_discussion_id: note.discussion_id } }

      it 'sets the note up to be in reply to that note' do
        expect(new_note).to be_valid
        expect(new_note).to be_a(DiscussionNote)
        expect(new_note.discussion_id).to eq(note.discussion_id)
      end

      context 'when noteable does not support replies' do
        let_it_be(:note) { create(:note_on_commit, project: project) }

        it 'builds another individual note' do
          expect(new_note).to be_valid
          expect(new_note).to be_a(Note)
          expect(new_note.discussion_id).not_to eq(note.discussion_id)
        end
      end
    end

    context 'confidential comments' do
      let_it_be(:project) { create(:project, :public) }
      let_it_be(:guest) { create(:user) }
      let_it_be(:reporter) { create(:user) }
      let_it_be(:admin) { create(:admin) }
      let_it_be(:issuable_assignee) { other_user }
      let_it_be(:issue) do
        create(:issue, project: project, author: noteable_author, assignees: [issuable_assignee])
      end

      before do
        project.add_guest(guest)
        project.add_reporter(reporter)
      end

      context 'when creating a new confidential comment' do
        let(:params) { { internal: true, noteable: issue } }

        shared_examples 'user allowed to set comment as confidential' do
          it { expect(new_note.confidential).to be_truthy }
        end

        shared_examples 'user not allowed to set comment as confidential' do
          it { expect(new_note.confidential).to be_falsey }
        end

        context 'reporter' do
          let(:user) { reporter }

          it_behaves_like 'user allowed to set comment as confidential'
        end

        context 'issuable author' do
          let(:user) { noteable_author }

          it_behaves_like 'user not allowed to set comment as confidential'
        end

        context 'issuable assignee' do
          let(:user) { issuable_assignee }

          it_behaves_like 'user not allowed to set comment as confidential'
        end

        context 'admin' do
          before do
            enable_admin_mode!(admin)
          end

          let(:user) { admin }

          it_behaves_like 'user allowed to set comment as confidential'
        end

        context 'external' do
          let(:user) { external }

          it_behaves_like 'user not allowed to set comment as confidential'
        end

        context 'guest' do
          let(:user) { guest }

          it_behaves_like 'user not allowed to set comment as confidential'
        end

        context 'when using the deprecated `confidential` parameter' do
          let(:params) { { internal: true, noteable: issue } }

          shared_examples 'user allowed to set comment as confidential' do
            it { expect(new_note.confidential).to be_truthy }
          end
        end
      end

      context 'when replying to a confidential comment' do
        let_it_be(:note) { create(:note_on_issue, confidential: true, noteable: issue, project: project) }

        let(:params) { { in_reply_to_discussion_id: note.discussion_id, confidential: false } }

        shared_examples 'returns `Discussion to reply to cannot be found` error' do
          it do
            expect(new_note.errors.added?(:base, ""Discussion to reply to cannot be found"")).to be true
          end
        end

        shared_examples 'confidential set to `true`' do
          it '`confidential` param is ignored to match the parent note confidentiality' do
            expect(new_note.confidential).to be_truthy
          end
        end

        context 'with reporter access' do
          let(:user) { reporter }

          it_behaves_like 'confidential set to `true`'
        end

        context 'with admin access' do
          let(:user) { admin }

          before do
            enable_admin_mode!(admin)
          end

          it_behaves_like 'confidential set to `true`'
        end

        context 'with noteable author' do
          let(:user) { note.noteable.author }

          it_behaves_like 'returns `Discussion to reply to cannot be found` error'
        end

        context 'with noteable assignee' do
          let(:user) { issuable_assignee }

          it_behaves_like 'returns `Discussion to reply to cannot be found` error'
        end

        context 'with guest access' do
          let(:user) { guest }

          it_behaves_like 'returns `Discussion to reply to cannot be found` error'
        end

        context 'with external user' do
          let(:user) { external }

          it_behaves_like 'returns `Discussion to reply to cannot be found` error'
        end
      end

      context 'when replying to a public comment' do
        let_it_be(:note) { create(:note_on_issue, confidential: false, noteable: issue, project: project) }

        let(:params) { { in_reply_to_discussion_id: note.discussion_id, confidential: true } }

        it '`confidential` param is ignored and set to `false`' do
          expect(new_note.confidential).to be_falsey
        end
      end
    end

    context 'when noteable is not set' do
      let(:params) { { noteable_type: note.noteable_type, noteable_id: note.noteable_id } }

      it 'builds a note without saving it' do
        expect(new_note).to be_valid
        expect(new_note).not_to be_persisted
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Notes
  class DestroyService < ::Notes::BaseService
    def execute(note)
      TodoService.new.destroy_target(note) do |note|
        note.destroy
      end

      clear_noteable_diffs_cache(note)
      track_note_removal_usage_for_issues(note) if note.for_issue?
      track_note_removal_usage_for_merge_requests(note) if note.for_merge_request?
      track_note_removal_usage_for_design(note) if note.for_design?
    end

    private

    def track_note_removal_usage_for_issues(note)
      Gitlab::UsageDataCounters::IssueActivityUniqueCounter.track_issue_comment_removed_action(
        author: note.author,
        project: project
      )
    end

    def track_note_removal_usage_for_merge_requests(note)
      Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter.track_remove_comment_action(note: note)
    end

    def track_note_removal_usage_for_design(note)
      Gitlab::UsageDataCounters::IssueActivityUniqueCounter.track_issue_design_comment_removed_action(
        author: note.author,
        project: project
      )
    end
  end
end

Notes::DestroyService.prepend_mod_with('Notes::DestroyService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Notes::DestroyService, feature_category: :team_planning do
  let_it_be(:project) { create(:project, :public) }
  let_it_be(:issue) { create(:issue, project: project) }

  let(:user) { issue.author }

  describe '#execute' do
    it 'deletes a note' do
      note = create(:note, project: project, noteable: issue)

      described_class.new(project, user).execute(note)

      expect(project.issues.find(issue.id).notes).not_to include(note)
    end

    it 'updates the todo counts for users with todos for the note' do
      note = create(:note, project: project, noteable: issue)
      create(:todo, note: note, target: issue, user: user, author: user, project: project)

      expect { described_class.new(project, user).execute(note) }
        .to change { user.todos_pending_count }.from(1).to(0)
    end

    describe 'comment removed event tracking', :snowplow do
      let(:event) { Gitlab::UsageDataCounters::IssueActivityUniqueCounter::ISSUE_COMMENT_REMOVED }
      let(:note) { create(:note, project: project, noteable: issue) }
      let(:service_action) { described_class.new(project, user).execute(note) }

      it 'tracks issue comment removal usage data', :clean_gitlab_redis_shared_state do
        counter = Gitlab::UsageDataCounters::HLLRedisCounter

        expect(Gitlab::UsageDataCounters::IssueActivityUniqueCounter).to receive(:track_issue_comment_removed_action)
                                                                           .with(author: user, project: project)
                                                                           .and_call_original
        expect do
          service_action
        end.to change {
                 counter.unique_events(event_names: event, start_date: Date.today.beginning_of_week, end_date: 1.week.from_now)
               }.by(1)
      end

      it_behaves_like 'internal event tracking' do
        let(:namespace) { project.namespace }
        subject(:execute_service_action) { service_action }
      end
    end

    it 'tracks merge request usage data' do
      mr = create(:merge_request, source_project: project)
      note = create(:note, project: project, noteable: mr)
      expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter).to receive(:track_remove_comment_action).with(note: note)

      described_class.new(project, user).execute(note)
    end

    context 'in a merge request' do
      let_it_be(:repo_project) { create(:project, :repository) }
      let_it_be(:merge_request) do
        create(:merge_request, source_project: repo_project, target_project: repo_project)
      end

      let_it_be(:note) do
        create(:diff_note_on_merge_request, project: repo_project, noteable: merge_request)
      end

      it 'does not track issue comment removal usage data' do
        expect(Gitlab::UsageDataCounters::IssueActivityUniqueCounter).not_to receive(:track_issue_comment_removed_action)

        described_class.new(repo_project, user).execute(note)
      end

      context 'noteable highlight cache clearing' do
        before do
          allow(note.position).to receive(:unfolded_diff?) { true }
        end

        it 'clears noteable diff cache when it was unfolded for the note position' do
          expect(merge_request).to receive_message_chain(:diffs, :clear_cache)

          described_class.new(repo_project, user).execute(note)
        end

        it 'does not clear cache when note is not the first of the discussion' do
          reply_note = create(:diff_note_on_merge_request,
            in_reply_to: note, project: repo_project, noteable: merge_request)

          expect(merge_request).not_to receive(:diffs)

          described_class.new(repo_project, user).execute(reply_note)
        end
      end
    end

    it 'tracks design comment removal' do
      note = create(:note_on_design, project: project)
      expect(Gitlab::UsageDataCounters::IssueActivityUniqueCounter).to receive(
        :track_issue_design_comment_removed_action
      ).with(
        author: note.author,
        project: project
      )

      described_class.new(project, user).execute(note)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Notes
  class UpdateService < BaseService
    def execute(note)
      return note unless note.editable? && params.present?

      old_mentioned_users = note.mentioned_users(current_user).to_a

      note.assign_attributes(params)

      return note unless note.valid?

      track_note_edit_usage_for_issues(note) if note.for_issue?
      track_note_edit_usage_for_merge_requests(note) if note.for_merge_request?

      only_commands = false

      quick_actions_service = QuickActionsService.new(project, current_user)
      if quick_actions_service.supported?(note)
        content, update_params, message = quick_actions_service.execute(note, {})

        only_commands = content.empty?

        note.note = content
      end

      update_note(note, only_commands)
      note.save

      unless only_commands || note.for_personal_snippet?
        note.create_new_cross_references!(current_user)

        update_todos(note, old_mentioned_users)

        update_suggestions(note)
      end

      if quick_actions_service.commands_executed_count.to_i > 0
        if update_params.present?
          quick_actions_service.apply_updates(update_params, note)
          note.commands_changes = update_params
        end

        if only_commands
          delete_note(note, message)
        else
          note.save
        end
      end

      note
    end

    private

    def update_note(note, only_commands)
      return unless note.note_changed?

      note.assign_attributes(last_edited_at: Time.current, updated_by: current_user)
      note.check_for_spam(action: :update, user: current_user) unless only_commands
    end

    def delete_note(note, message)
      # We must add the error after we call #save because errors are reset
      # when #save is called
      note.errors.add(:commands_only, message.presence || _('Commands did not apply'))
      # Allow consumers to detect problems applying commands
      note.errors.add(:commands, _('Commands did not apply')) unless message.present?

      Notes::DestroyService.new(project, current_user).execute(note)
    end

    def update_suggestions(note)
      return unless note.supports_suggestion?

      Suggestion.transaction do
        note.suggestions.delete_all
        Suggestions::CreateService.new(note).execute
      end

      # We need to refresh the previous suggestions call cache
      # in order to get the new records.
      note.reset
    end

    def update_todos(note, old_mentioned_users)
      return unless note.previous_changes.include?('note')

      TodoService.new.update_note(note, current_user, old_mentioned_users)
    end

    def track_note_edit_usage_for_issues(note)
      Gitlab::UsageDataCounters::IssueActivityUniqueCounter.track_issue_comment_edited_action(
        author: note.author,
        project: project
      )
    end

    def track_note_edit_usage_for_merge_requests(note)
      Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter.track_edit_comment_action(note: note)
    end
  end
end

Notes::UpdateService.prepend_mod_with('Notes::UpdateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Notes::UpdateService, feature_category: :team_planning do
  let(:group) { create(:group, :public) }
  let(:project) { create(:project, :public, group: group) }
  let(:private_group) { create(:group, :private) }
  let(:private_project) { create(:project, :private, group: private_group) }
  let(:user) { create(:user) }
  let(:user2) { create(:user) }
  let(:user3) { create(:user) }
  let(:issue) { create(:issue, project: project) }
  let(:issue2) { create(:issue, project: private_project) }
  let(:note) { create(:note, project: project, noteable: issue, author: user, note: ""Old note #{user2.to_reference}"") }
  let(:markdown) do
    <<-MARKDOWN.strip_heredoc
      ```suggestion
        foo
      ```

      ```suggestion
        bar
      ```
    MARKDOWN
  end

  before do
    project.add_maintainer(user)
    project.add_developer(user2)
    project.add_developer(user3)
    group.add_developer(user3)
    private_group.add_developer(user)
    private_group.add_developer(user2)
    private_project.add_developer(user3)
  end

  describe '#execute' do
    def update_note(opts)
      @note = Notes::UpdateService.new(project, user, opts).execute(note)
      @note.reload
    end

    it 'does not update the note when params is blank' do
      travel_to(1.day.from_now) do
        expect { update_note({}) }.not_to change { note.reload.updated_at }
      end
    end

    context 'when the note is invalid' do
      let(:edit_note_text) { { note: 'new text' } }

      before do
        allow(note).to receive(:valid?).and_return(false)
      end

      it 'does not update the note' do
        travel_to(1.day.from_now) do
          expect { update_note(edit_note_text) }.not_to change { note.reload.updated_at }
        end
      end

      it 'returns the note' do
        expect(update_note(edit_note_text)).to eq(note)
      end
    end

    describe 'event tracking', :snowplow do
      let(:event) { Gitlab::UsageDataCounters::IssueActivityUniqueCounter::ISSUE_COMMENT_EDITED }

      it 'does not track usage data when params is blank' do
        expect(Gitlab::UsageDataCounters::IssueActivityUniqueCounter).not_to receive(:track_issue_comment_edited_action)
        expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter).not_to receive(:track_edit_comment_action)

        update_note({})
      end

      it_behaves_like 'internal event tracking' do
        let(:event) { Gitlab::UsageDataCounters::IssueActivityUniqueCounter::ISSUE_COMMENT_EDITED }
        let(:namespace) { project.namespace }

        subject(:service_action) { update_note(note: 'new text') }
      end

      it 'tracks issue usage data', :clean_gitlab_redis_shared_state do
        counter = Gitlab::UsageDataCounters::HLLRedisCounter

        expect(Gitlab::UsageDataCounters::IssueActivityUniqueCounter).to receive(:track_issue_comment_edited_action)
                                                                           .with(author: user, project: project)
                                                                           .and_call_original
        expect do
          update_note(note: 'new text')
        end.to change { counter.unique_events(event_names: event, start_date: Date.today.beginning_of_week, end_date: 1.week.from_now) }.by(1)
      end
    end

    context 'when note text was changed' do
      let!(:note) { create(:note, project: project, noteable: issue, author: user2, note: ""Old note #{user3.to_reference}"") }
      let(:edit_note_text) { update_note({ note: 'new text' }) }

      it 'update last_edited_at' do
        travel_to(1.day.from_now) do
          expect { edit_note_text }.to change { note.reload.last_edited_at }
        end
      end

      it 'update updated_by' do
        travel_to(1.day.from_now) do
          expect { edit_note_text }.to change { note.reload.updated_by }
        end
      end

      it 'checks for spam' do
        expect(note).to receive(:check_for_spam).with(action: :update, user: user)
        edit_note_text
      end

      context 'when quick action only update' do
        it ""delete note and return commands_only error"" do
          updated_note = described_class.new(project, user, { note: ""/close\n"" }).execute(note)

          expect(updated_note.destroyed?).to eq(true)
          expect(updated_note.errors).to match_array([
            ""Note can't be blank"",
            ""Commands only Closed this issue.""
          ])
        end
      end
    end

    context 'when note text was not changed' do
      let!(:note) { create(:note, project: project, noteable: issue, author: user2, note: ""Old note #{user3.to_reference}"") }
      let(:does_not_edit_note_text) { update_note({}) }

      it 'does not update last_edited_at' do
        travel_to(1.day.from_now) do
          expect { does_not_edit_note_text }.not_to change { note.reload.last_edited_at }
        end
      end

      it 'does not update updated_by' do
        travel_to(1.day.from_now) do
          expect { does_not_edit_note_text }.not_to change { note.reload.updated_by }
        end
      end

      it 'does not check for spam' do
        expect(note).not_to receive(:check_for_spam)
        does_not_edit_note_text
      end
    end

    context 'when the notable is a merge request' do
      let(:merge_request) { create(:merge_request, source_project: project) }
      let(:note) { create(:note, project: project, noteable: merge_request, author: user, note: ""Old note #{user2.to_reference}"") }

      it 'tracks merge request usage data' do
        expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter).to receive(:track_edit_comment_action).with(note: note)

        update_note(note: 'new text')
      end
    end

    context 'with system note' do
      before do
        note.update_column(:system, true)
      end

      it 'does not update the note' do
        expect { update_note(note: 'new text') }.not_to change { note.reload.note }
      end

      it 'does not track usage data' do
        expect(Gitlab::UsageDataCounters::IssueActivityUniqueCounter).not_to receive(:track_issue_comment_edited_action)

        update_note(note: 'new text')
      end
    end

    context 'suggestions' do
      it 'refreshes note suggestions' do
        suggestion = create(:suggestion)
        note = suggestion.note

        expect { described_class.new(project, user, note: markdown).execute(note) }
          .to change { note.suggestions.count }.from(1).to(2)

        expect(note.suggestions.order(:relative_order).map(&:to_content))
          .to eq([""  foo\n"", ""  bar\n""])
      end
    end

    context 'todos' do
      shared_examples 'does not update todos' do
        it 'keep todos' do
          expect(todo.reload).to be_pending
        end

        it 'does not create any new todos' do
          expect(Todo.count).to eq(1)
        end
      end

      shared_examples 'creates one todo' do
        it 'marks todos as done' do
          expect(todo.reload).to be_done
        end

        it 'creates only 1 new todo' do
          expect(Todo.count).to eq(2)
        end
      end

      context 'when note includes a user mention' do
        let!(:todo) { create(:todo, :assigned, user: user, project: project, target: issue, author: user2) }

        context 'when the note does not change mentions' do
          before do
            update_note({ note: ""Old note #{user2.to_reference}"" })
          end

          it_behaves_like 'does not update todos'
        end

        context 'when the note changes to include one more user mention' do
          before do
            update_note({ note: ""New note #{user2.to_reference} #{user3.to_reference}"" })
          end

          it_behaves_like 'creates one todo'
        end

        context 'when the note changes to include a group mentions' do
          before do
            update_note({ note: ""New note #{private_group.to_reference}"" })
          end

          it_behaves_like 'creates one todo'
        end
      end

      context 'when note includes a group mention' do
        context 'when the group is public' do
          let(:note) { create(:note, project: project, noteable: issue, author: user, note: ""Old note #{group.to_reference}"") }
          let!(:todo) { create(:todo, :assigned, user: user, project: project, target: issue, author: user2) }

          context 'when the note does not change mentions' do
            before do
              update_note({ note: ""Old note #{group.to_reference}"" })
            end

            it_behaves_like 'does not update todos'
          end

          context 'when the note changes mentions' do
            before do
              update_note({ note: ""New note #{user2.to_reference} #{user3.to_reference}"" })
            end

            it_behaves_like 'creates one todo'
          end
        end

        context 'when the group is private' do
          let(:note) { create(:note, project: project, noteable: issue, author: user, note: ""Old note #{private_group.to_reference}"") }
          let!(:todo) { create(:todo, :assigned, user: user, project: project, target: issue, author: user2) }

          context 'when the note does not change mentions' do
            before do
              update_note({ note: ""Old note #{private_group.to_reference}"" })
            end

            it_behaves_like 'does not update todos'
          end

          context 'when the note changes mentions' do
            before do
              update_note({ note: ""New note #{user2.to_reference} #{user3.to_reference}"" })
            end

            it_behaves_like 'creates one todo'
          end
        end
      end
    end

    context 'for a personal snippet' do
      let_it_be(:snippet) { create(:personal_snippet, :public) }

      let(:note) { create(:note, project: nil, noteable: snippet, author: user, note: ""Note on a snippet with reference #{issue.to_reference}"") }

      it 'does not create todos' do
        expect { update_note({ note: ""Mentioning user #{user2}"" }) }.not_to change { note.todos.count }
      end

      it 'does not create suggestions' do
        expect { update_note({ note: ""Updated snippet with markdown suggestion #{markdown}"" }) }
          .not_to change { note.suggestions.count }
      end

      it 'does not create mentions' do
        expect(note).not_to receive(:create_new_cross_references!)
        update_note({ note: ""Updated with new reference: #{issue.to_reference}"" })
      end

      it 'does not track usage data' do
        expect(Gitlab::UsageDataCounters::IssueActivityUniqueCounter).not_to receive(:track_issue_comment_edited_action)

        update_note(note: 'new text')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Notes
  class RenderService < BaseRenderer
    # Renders a collection of Note instances.
    #
    # notes - The notes to render.
    #
    # Possible options:
    #
    # requested_path - The request path.
    # project_wiki - The project's wiki.
    # ref - The current Git reference.
    # only_path - flag to turn relative paths into absolute ones.
    # xhtml - flag to save the html in XHTML
    def execute(notes, options = {})
      Banzai::ObjectRenderer
        .new(user: current_user, redaction_context: options)
        .render(notes, :note)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Notes::RenderService, feature_category: :team_planning do
  describe '#execute' do
    it 'renders a Note' do
      note = double(:note)
      wiki = double(:wiki)
      user = double(:user)

      expect(Banzai::ObjectRenderer)
        .to receive(:new)
        .with(
          user: user,
          redaction_context: {
              requested_path: 'foo',
              project_wiki: wiki,
              ref: 'bar',
              only_path: nil,
              xhtml: false
          }
        )
        .and_call_original

      expect_any_instance_of(Banzai::ObjectRenderer)
        .to receive(:render)
        .with([note], :note)

      described_class.new(user).execute(
        [note],
        requested_path: 'foo',
        project_wiki: wiki,
        ref: 'bar',
        only_path: nil,
        xhtml: false
      )
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Notes
  class CreateService < ::Notes::BaseService
    include IncidentManagement::UsageData

    def execute(skip_capture_diff_note_position: false, skip_merge_status_trigger: false, skip_set_reviewed: false)
      note = Notes::BuildService.new(project, current_user, params.except(:merge_request_diff_head_sha)).execute

      # n+1: https://gitlab.com/gitlab-org/gitlab-foss/issues/37440
      note_valid = Gitlab::GitalyClient.allow_n_plus_1_calls do
        # We may set errors manually in Notes::BuildService for this reason
        # we also need to check for already existing errors.
        note.errors.empty? && note.valid?
      end

      return note unless note_valid

      # We execute commands (extracted from `params[:note]`) on the noteable
      # **before** we save the note because if the note consists of commands
      # only, there is no need be create a note!

      execute_quick_actions(note) do |only_commands|
        note.check_for_spam(action: :create, user: current_user) unless only_commands

        note.run_after_commit do
          # Finish the harder work in the background
          NewNoteWorker.perform_async(note.id)
        end

        note_saved = note.with_transaction_returning_status do
          break false if only_commands

          note.save.tap do
            update_discussions(note)
          end
        end

        if note_saved
          when_saved(
            note,
            skip_capture_diff_note_position: skip_capture_diff_note_position,
            skip_merge_status_trigger: skip_merge_status_trigger,
            skip_set_reviewed: skip_set_reviewed
          )
        end
      end

      note
    end

    private

    def execute_quick_actions(note)
      return yield(false) unless quick_actions_supported?(note)

      content, update_params, message, command_names = quick_actions_service.execute(note, quick_action_options)
      only_commands = content.empty?
      note.note = content
      note.command_names = command_names

      yield(only_commands)

      do_commands(note, update_params, message, command_names, only_commands)
    end

    def quick_actions_supported?(note)
      quick_actions_service.supported?(note)
    end

    def quick_actions_service
      @quick_actions_service ||= QuickActionsService.new(project, current_user)
    end

    def update_discussions(note)
      # Ensure that individual notes that are promoted into discussions are
      # updated in a transaction with the note creation to avoid inconsistencies:
      # https://gitlab.com/gitlab-org/gitlab/-/issues/301237
      if note.part_of_discussion? && note.discussion.can_convert_to_discussion?
        note.discussion.convert_to_discussion!.save
        note.clear_memoization(:discussion)
      end
    end

    def when_saved(
      note, skip_capture_diff_note_position: false, skip_merge_status_trigger: false,
      skip_set_reviewed: false)
      todo_service.new_note(note, current_user)
      clear_noteable_diffs_cache(note)
      Suggestions::CreateService.new(note).execute
      increment_usage_counter(note)
      track_event(note, current_user)

      if note.for_merge_request? && note.start_of_discussion?
        set_reviewed(note) unless skip_set_reviewed

        if !skip_capture_diff_note_position && note.diff_note?
          Discussions::CaptureDiffNotePositionService.new(note.noteable, note.diff_file&.paths).execute(note.discussion)
        end

        if !skip_merge_status_trigger && note.to_be_resolved?
          GraphqlTriggers.merge_request_merge_status_updated(note.noteable)
        end
      end
    end

    def do_commands(note, update_params, message, command_names, only_commands)
      return if quick_actions_service.commands_executed_count.to_i == 0

      update_error = quick_actions_update_errors(note, update_params)
      if update_error
        note.errors.add(:validation, update_error)
        message = update_error
      end

      # We must add the error after we call #save because errors are reset
      # when #save is called
      if only_commands
        note.errors.add(:commands_only, message.presence || _('Failed to apply commands.'))
        note.errors.add(:command_names, command_names.flatten)
        # Allow consumers to detect problems applying commands
        note.errors.add(:commands, _('Failed to apply commands.')) unless message.present?
      end
    end

    def quick_actions_update_errors(note, params)
      return unless params.present?

      invalid_message = validate_commands(note, params)
      return invalid_message if invalid_message

      service_response = quick_actions_service.apply_updates(params, note)
      note.commands_changes = params
      return if service_response.success?

      service_response.message.join(', ')
    end

    def quick_action_options
      {
        merge_request_diff_head_sha: params[:merge_request_diff_head_sha],
        review_id: params[:review_id]
      }
    end

    def validate_commands(note, update_params)
      if invalid_reviewers?(update_params)
        ""Reviewers #{note.noteable.class.max_number_of_assignees_or_reviewers_message}""
      elsif invalid_assignees?(update_params)
        ""Assignees #{note.noteable.class.max_number_of_assignees_or_reviewers_message}""
      end
    end

    def invalid_reviewers?(update_params)
      if update_params.key?(:reviewer_ids)
        possible_reviewers = update_params[:reviewer_ids]&.uniq&.size

        possible_reviewers > ::Issuable::MAX_NUMBER_OF_ASSIGNEES_OR_REVIEWERS
      else
        false
      end
    end

    def invalid_assignees?(update_params)
      if update_params.key?(:assignee_ids)
        possible_assignees = update_params[:assignee_ids]&.uniq&.size

        possible_assignees > ::Issuable::MAX_NUMBER_OF_ASSIGNEES_OR_REVIEWERS
      else
        false
      end
    end

    def track_event(note, user)
      track_note_creation_usage_for_issues(note) if note.for_issue?
      track_note_creation_usage_for_merge_requests(note) if note.for_merge_request?
      track_incident_action(user, note.noteable, 'incident_comment') if note.for_issue?
      track_note_creation_in_ipynb(note)
      track_note_creation_visual_review(note)

      metric_key_path = 'counts.commit_comment'

      Gitlab::Tracking.event(
        'Notes::CreateService',
        'create_commit_comment',
        project: project,
        namespace: project&.namespace,
        user: user,
        label: metric_key_path,
        context: [Gitlab::Usage::MetricDefinition.context_for(metric_key_path).to_context]
      )
    end

    def tracking_data_for(note)
      label = Gitlab.ee? && note.author == Users::Internal.visual_review_bot ? 'anonymous_visual_review_note' : 'note'

      {
        label: label,
        value: note.id
      }
    end

    def track_note_creation_usage_for_issues(note)
      Gitlab::UsageDataCounters::IssueActivityUniqueCounter.track_issue_comment_added_action(
        author: note.author,
        project: project
      )
    end

    def track_note_creation_usage_for_merge_requests(note)
      Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter.track_create_comment_action(note: note)
    end

    def should_track_ipynb_notes?(note)
      note.respond_to?(:diff_file) && note.diff_file&.ipynb?
    end

    def track_note_creation_in_ipynb(note)
      return unless should_track_ipynb_notes?(note)

      Gitlab::UsageDataCounters::IpynbDiffActivityCounter.note_created(note)
    end

    def track_note_creation_visual_review(note)
      Gitlab::Tracking.event('Notes::CreateService', 'execute', **tracking_data_for(note))
    end

    def set_reviewed(note)
      return if Feature.enabled?(:mr_request_changes, current_user)

      ::MergeRequests::UpdateReviewerStateService.new(project: project, current_user: current_user)
        .execute(note.noteable, ""reviewed"")
    end
  end
end

Notes::CreateService.prepend_mod_with('Notes::CreateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Notes::CreateService, feature_category: :team_planning do
  let_it_be(:group) { create(:group) }
  let_it_be(:project) { create(:project, :repository, group: group) }
  let_it_be(:issue) { create(:issue, project: project) }
  let_it_be(:user) { create(:user) }

  let(:base_opts) { { note: 'Awesome comment', noteable_type: 'Issue', noteable_id: issue.id } }
  let(:opts) { base_opts.merge(confidential: true) }

  describe '#execute' do
    subject(:note) { described_class.new(project, user, opts).execute }

    before_all do
      group.add_maintainer(user)
    end

    context ""valid params"" do
      context 'when noteable is an issue that belongs directly to a group' do
        it 'creates a note without a project and correct namespace', :aggregate_failures do
          group_issue = create(:issue, :group_level, namespace: group)
          note_params = { note: 'test note', noteable: group_issue }

          expect do
            described_class.new(nil, user, note_params).execute
          end.to change { Note.count }.by(1)

          created_note = Note.last

          expect(created_note.namespace).to eq(group)
          expect(created_note.project).to be_nil
        end
      end

      context 'when noteable is a work item that belongs directly to a group' do
        it 'creates a note without a project and correct namespace', :aggregate_failures do
          group_work_item = create(:work_item, :group_level, namespace: group)
          note_params = { note: 'test note', noteable: group_work_item }

          expect do
            described_class.new(nil, user, note_params).execute
          end.to change { Note.count }.by(1)

          created_note = Note.last

          expect(created_note.namespace).to eq(group)
          expect(created_note.project).to be_nil
        end
      end

      it_behaves_like 'does not trigger GraphQL subscription mergeRequestMergeStatusUpdated' do
        let(:action) { note }
      end

      it 'returns a valid note' do
        expect(note).to be_valid
      end

      it 'returns a persisted note' do
        expect(note).to be_persisted
      end

      it 'checks for spam' do
        expect_next_instance_of(Note) do |instance|
          expect(instance).to receive(:check_for_spam).with(action: :create, user: user)
        end

        note
      end

      it 'does not persist when spam' do
        expect_next_instance_of(Note) do |instance|
          expect(instance).to receive(:check_for_spam).with(action: :create, user: user) do
            instance.spam!
          end
        end

        expect(note).not_to be_persisted
      end

      context 'with internal parameter' do
        context 'when confidential' do
          let(:opts) { base_opts.merge(internal: true) }

          it 'returns a confidential note' do
            expect(note).to be_confidential
          end
        end

        context 'when not confidential' do
          let(:opts) { base_opts.merge(internal: false) }

          it 'returns a confidential note' do
            expect(note).not_to be_confidential
          end
        end
      end

      context 'with confidential parameter' do
        context 'when confidential' do
          let(:opts) { base_opts.merge(confidential: true) }

          it 'returns a confidential note' do
            expect(note).to be_confidential
          end
        end

        context 'when not confidential' do
          let(:opts) { base_opts.merge(confidential: false) }

          it 'returns a confidential note' do
            expect(note).not_to be_confidential
          end
        end
      end

      context 'with confidential and internal parameter set' do
        let(:opts) { base_opts.merge(internal: true, confidential: false) }

        it 'prefers the internal parameter' do
          expect(note).to be_confidential
        end
      end

      it 'note has valid content' do
        expect(note.note).to eq(opts[:note])
      end

      it 'note belongs to the correct project' do
        expect(note.project).to eq(project)
      end

      it 'TodoService#new_note is called' do
        note = build(:note, project: project, noteable: issue)
        allow(Note).to receive(:new).with(opts) { note }

        expect_any_instance_of(TodoService).to receive(:new_note).with(note, user)

        described_class.new(project, user, opts).execute
      end

      it 'enqueues NewNoteWorker' do
        note = build(:note, id: non_existing_record_id, project: project, noteable: issue)
        allow(Note).to receive(:new).with(opts) { note }

        expect(NewNoteWorker).to receive(:perform_async).with(note.id)

        described_class.new(project, user, opts).execute
      end

      context 'issue is an incident' do
        let(:issue) { create(:incident, project: project) }

        it_behaves_like 'an incident management tracked event', :incident_management_incident_comment do
          let(:current_user) { user }
        end

        it_behaves_like 'Snowplow event tracking with RedisHLL context' do
          let(:namespace) { issue.namespace }
          let(:category) { described_class.to_s }
          let(:action) { 'incident_management_incident_comment' }
          let(:label) { 'redis_hll_counters.incident_management.incident_management_total_unique_counts_monthly' }
        end
      end

      context 'in a commit', :snowplow do
        let_it_be(:commit) { create(:commit, project: project) }
        let(:opts) { { note: 'Awesome comment', noteable_type: 'Commit', commit_id: commit.id } }

        let(:counter) { Gitlab::UsageDataCounters::NoteCounter }

        let(:execute_create_service) { described_class.new(project, user, opts).execute }

        it 'tracks commit comment usage data', :clean_gitlab_redis_shared_state do
          expect(counter).to receive(:count).with(:create, 'Commit').and_call_original

          expect do
            execute_create_service
          end.to change { counter.read(:create, 'Commit') }.by(1)
        end

        it_behaves_like 'Snowplow event tracking with Redis context' do
          let(:category) { described_class.name }
          let(:action) { 'create_commit_comment' }
          let(:label) { 'counts.commit_comment' }
          let(:namespace) { project.namespace }
        end
      end

      describe 'event tracking', :snowplow do
        let(:event) { Gitlab::UsageDataCounters::IssueActivityUniqueCounter::ISSUE_COMMENT_ADDED }
        let(:execute_create_service) { described_class.new(project, user, opts).execute }

        it 'tracks issue comment usage data', :clean_gitlab_redis_shared_state do
          counter = Gitlab::UsageDataCounters::HLLRedisCounter

          expect(Gitlab::UsageDataCounters::IssueActivityUniqueCounter).to receive(:track_issue_comment_added_action)
                                                                             .with(author: user, project: project)
                                                                             .and_call_original
          expect do
            execute_create_service
          end.to change {
                   counter.unique_events(event_names: event, start_date: Date.today.beginning_of_week, end_date: 1.week.from_now)
                 }.by(1)
        end

        it 'does not track merge request usage data' do
          expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter).not_to receive(:track_create_comment_action)

          execute_create_service
        end

        it_behaves_like 'internal event tracking' do
          let(:event) { Gitlab::UsageDataCounters::IssueActivityUniqueCounter::ISSUE_COMMENT_ADDED }
          let(:namespace) { project.namespace }
          subject(:service_action) { execute_create_service }
        end
      end

      context 'in a merge request' do
        let_it_be(:project_with_repo) { create(:project, :repository) }
        let_it_be(:merge_request) do
          create(:merge_request, source_project: project_with_repo, target_project: project_with_repo)
        end

        let(:new_opts) { opts.merge(noteable_type: 'MergeRequest', noteable_id: merge_request.id) }

        context 'when mr_request_changes feature flag is disabled' do
          before do
            stub_feature_flags(mr_request_changes: false)
          end

          it 'calls MergeRequests::UpdateReviewerStateService service' do
            expect_next_instance_of(
              MergeRequests::UpdateReviewerStateService,
              project: project_with_repo, current_user: user
            ) do |service|
              expect(service).to receive(:execute).with(merge_request, ""reviewed"")
            end

            described_class.new(project_with_repo, user, new_opts).execute
          end

          it 'does not call MergeRequests::UpdateReviewerStateService service when skip_set_reviewed is true' do
            expect(MergeRequests::UpdateReviewerStateService).not_to receive(:new)

            described_class.new(project_with_repo, user, new_opts).execute(skip_set_reviewed: true)
          end
        end

        context 'when mr_request_changes feature flag is enabled' do
          it 'does not call MergeRequests::UpdateReviewerStateService service when skip_set_reviewed is true' do
            expect(MergeRequests::UpdateReviewerStateService).not_to receive(:new)

            described_class.new(project_with_repo, user, new_opts).execute(skip_set_reviewed: true)
          end
        end

        context 'noteable highlight cache clearing' do
          let(:position) do
            Gitlab::Diff::Position.new(
              old_path: ""files/ruby/popen.rb"",
              new_path: ""files/ruby/popen.rb"",
              old_line: nil,
              new_line: 14,
              diff_refs: merge_request.diff_refs
            )
          end

          let(:new_opts) do
            opts.merge(
              in_reply_to_discussion_id: nil,
              type: 'DiffNote',
              noteable_type: 'MergeRequest',
              noteable_id: merge_request.id,
              position: position.to_h,
              confidential: false
            )
          end

          before do
            allow_any_instance_of(Gitlab::Diff::Position)
              .to receive(:unfolded_diff?) { true }
          end

          it 'does not track issue comment usage data' do
            expect(Gitlab::UsageDataCounters::IssueActivityUniqueCounter).not_to receive(:track_issue_comment_added_action)

            described_class.new(project_with_repo, user, new_opts).execute
          end

          it 'tracks merge request usage data' do
            expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter).to receive(:track_create_comment_action).with(note: kind_of(Note))

            described_class.new(project_with_repo, user, new_opts).execute
          end

          it 'clears noteable diff cache when it was unfolded for the note position' do
            expect_any_instance_of(Gitlab::Diff::HighlightCache).to receive(:clear)

            described_class.new(project_with_repo, user, new_opts).execute
          end

          it 'does not clear cache when note is not the first of the discussion' do
            prev_note =
              create(:diff_note_on_merge_request, noteable: merge_request, project: project_with_repo)
            reply_opts =
              opts.merge(
                in_reply_to_discussion_id: prev_note.discussion_id,
                type: 'DiffNote',
                noteable_type: 'MergeRequest',
                noteable_id: merge_request.id,
                position: position.to_h,
                confidential: false
              )

            expect(merge_request).not_to receive(:diffs)

            described_class.new(project_with_repo, user, reply_opts).execute
          end
        end

        context 'note diff file' do
          let(:line_number) { 14 }
          let(:position) do
            Gitlab::Diff::Position.new(
              old_path: ""files/ruby/popen.rb"",
              new_path: ""files/ruby/popen.rb"",
              old_line: nil,
              new_line: line_number,
              diff_refs: merge_request.diff_refs
            )
          end

          let(:previous_note) do
            create(:diff_note_on_merge_request, noteable: merge_request, project: project_with_repo)
          end

          before do
            project_with_repo.add_maintainer(user)
          end
          context 'when eligible to have a note diff file' do
            let(:new_opts) do
              opts.merge(
                in_reply_to_discussion_id: nil,
                type: 'DiffNote',
                noteable_type: 'MergeRequest',
                noteable_id: merge_request.id,
                position: position.to_h,
                confidential: false
              )
            end

            it_behaves_like 'triggers GraphQL subscription mergeRequestMergeStatusUpdated' do
              let(:action) { described_class.new(project_with_repo, user, new_opts).execute }
            end

            it 'note is associated with a note diff file' do
              MergeRequests::MergeToRefService.new(project: merge_request.project, current_user: merge_request.author).execute(merge_request)

              note = described_class.new(project_with_repo, user, new_opts).execute

              expect(note).to be_persisted
              expect(note.note_diff_file).to be_present
              expect(note.diff_note_positions).to be_present
            end

            context 'when skip_capture_diff_note_position execute option is set to true' do
              it 'does not execute Discussions::CaptureDiffNotePositionService' do
                expect(Discussions::CaptureDiffNotePositionService).not_to receive(:new)

                described_class.new(project_with_repo, user, new_opts).execute(skip_capture_diff_note_position: true)
              end
            end

            context 'when skip_merge_status_trigger execute option is set to true' do
              it_behaves_like 'does not trigger GraphQL subscription mergeRequestMergeStatusUpdated' do
                let(:action) do
                  described_class
                    .new(project_with_repo, user, new_opts)
                    .execute(skip_merge_status_trigger: true)
                end
              end
            end

            it 'does not track ipynb note usage data' do
              expect(::Gitlab::UsageDataCounters::IpynbDiffActivityCounter).not_to receive(:note_created)

              described_class.new(project_with_repo, user, new_opts).execute
            end

            context 'is ipynb file' do
              before do
                allow_any_instance_of(::Gitlab::Diff::File).to receive(:ipynb?).and_return(true)
              end

              it 'tracks ipynb diff note creation' do
                expect(::Gitlab::UsageDataCounters::IpynbDiffActivityCounter).to receive(:note_created)

                described_class.new(project_with_repo, user, new_opts).execute
              end
            end
          end

          context 'when DiffNote is a reply' do
            let(:new_opts) do
              opts.merge(
                in_reply_to_discussion_id: previous_note.discussion_id,
                type: 'DiffNote',
                noteable_type: 'MergeRequest',
                noteable_id: merge_request.id,
                position: position.to_h,
                confidential: false
              )
            end

            it 'note is not associated with a note diff file' do
              expect(Discussions::CaptureDiffNotePositionService).not_to receive(:new)

              note = described_class.new(project_with_repo, user, new_opts).execute

              expect(note).to be_persisted
              expect(note.note_diff_file).to be_nil
            end

            context 'when DiffNote from an image' do
              let(:image_position) do
                Gitlab::Diff::Position.new(
                  old_path: ""files/images/6049019_460s.jpg"",
                  new_path: ""files/images/6049019_460s.jpg"",
                  width: 100,
                  height: 100,
                  x: 1,
                  y: 100,
                  diff_refs: merge_request.diff_refs,
                  position_type: 'image'
                )
              end

              let(:new_opts) do
                opts.merge(
                  in_reply_to_discussion_id: nil,
                  type: 'DiffNote',
                  noteable_type: 'MergeRequest',
                  noteable_id: merge_request.id,
                  position: image_position.to_h,
                  confidential: false
                )
              end

              it 'note is not associated with a note diff file' do
                note = described_class.new(project_with_repo, user, new_opts).execute

                expect(note).to be_persisted
                expect(note.note_diff_file).to be_nil
              end
            end
          end
        end
      end
    end

    context 'note with commands' do
      context 'all quick actions' do
        let_it_be(:milestone) { create(:milestone, project: project, title: ""sprint"") }
        let_it_be(:bug_label) { create(:label, project: project, title: 'bug') }
        let_it_be(:to_be_copied_label) { create(:label, project: project, title: 'to be copied') }
        let_it_be(:feature_label) { create(:label, project: project, title: 'feature') }
        let_it_be(:issue, reload: true) { create(:issue, project: project, labels: [bug_label], due_date: '2019-01-01') }
        let_it_be(:issue_2) { create(:issue, project: project, labels: [bug_label, to_be_copied_label]) }

        context 'for issues' do
          let(:issuable) { issue }
          let(:note_params) { opts }
          let(:issue_quick_actions) do
            [
              QuickAction.new(
                action_text: '/confidential',
                expectation: ->(noteable, can_use_quick_action) {
                  if can_use_quick_action
                    expect(noteable).to be_confidential
                  else
                    expect(noteable).not_to be_confidential
                  end
                }
              ),
              QuickAction.new(
                action_text: '/due 2016-08-28',
                expectation: ->(noteable, can_use_quick_action) {
                  expect(noteable.due_date == Date.new(2016, 8, 28)).to eq(can_use_quick_action)
                }
              ),
              QuickAction.new(
                action_text: '/remove_due_date',
                expectation: ->(noteable, can_use_quick_action) {
                  if can_use_quick_action
                    expect(noteable.due_date).to be_nil
                  else
                    expect(noteable.due_date).not_to be_nil
                  end
                }
              ),
              QuickAction.new(
                action_text: ""/duplicate #{issue_2.to_reference}"",
                before_action: -> {
                  issuable.reopen
                },
                expectation: ->(noteable, can_use_quick_action) {
                  expect(noteable.closed?).to eq(can_use_quick_action)
                }
              )
            ]
          end

          it_behaves_like 'issuable quick actions' do
            let(:quick_actions) { issuable_quick_actions + issue_quick_actions }
          end
        end

        context 'for merge requests', feature_category: :code_review_workflow do
          let_it_be(:merge_request) { create(:merge_request, source_project: project, labels: [bug_label]) }

          let(:issuable) { merge_request }
          let(:note_params) { opts.merge(noteable_type: 'MergeRequest', noteable_id: merge_request.id, confidential: false) }
          let(:merge_request_quick_actions) do
            [
              QuickAction.new(
                action_text: ""/target_branch fix"",
                expectation: ->(noteable, can_use_quick_action) {
                  expect(noteable.target_branch == ""fix"").to eq(can_use_quick_action)
                }
              ),
              # Set Draft status
              QuickAction.new(
                action_text: ""/draft"",
                before_action: -> {
                  issuable.reload.update!(title: ""title"")
                },
                expectation: ->(issuable, can_use_quick_action) {
                  expect(issuable.draft?).to eq(can_use_quick_action)
                }
              ),
              # Remove draft (set ready) status
              QuickAction.new(
                action_text: ""/ready"",
                before_action: -> {
                  issuable.reload.update!(title: ""Draft: title"")
                },
                expectation: ->(noteable, can_use_quick_action) {
                  expect(noteable.draft?).not_to eq(can_use_quick_action)
                }
              )
            ]
          end

          it_behaves_like 'issuable quick actions' do
            let(:quick_actions) { issuable_quick_actions + merge_request_quick_actions }
          end
        end
      end

      context 'when note only has commands' do
        it 'adds commands applied message to note errors' do
          note_text = %(/close)
          service = double(:service)
          allow(Issues::UpdateService).to receive(:new).and_return(service)
          expect(service).to receive(:execute)

          note = described_class.new(project, user, opts.merge(note: note_text)).execute

          expect(note.errors[:commands_only]).to be_present
        end

        it 'adds commands failed message to note errors' do
          note_text = %(/reopen)
          note = described_class.new(project, user, opts.merge(note: note_text)).execute

          expect(note.errors[:commands_only]).to contain_exactly('Could not apply reopen command.')
        end

        it 'generates success and failed error messages' do
          note_text = %(/close\n/reopen)
          service = double(:service)
          allow(Issues::UpdateService).to receive(:new).and_return(service)
          expect(service).to receive(:execute)

          note = described_class.new(project, user, opts.merge(note: note_text)).execute

          expect(note.errors[:commands_only]).to contain_exactly('Closed this issue. Could not apply reopen command.')
        end

        it 'does not check for spam' do
          expect_next_instance_of(Note) do |instance|
            expect(instance).not_to receive(:check_for_spam).with(action: :create, user: user)
          end

          note_text = %(/close)
          described_class.new(project, user, opts.merge(note: note_text)).execute
        end

        it 'generates failed update error messages' do
          note_text = %(/confidential)
          service = double(:service)
          issue.errors.add(:confidential, 'an error occurred')
          allow(Issues::UpdateService).to receive(:new).and_return(service)
          allow_next_instance_of(Issues::UpdateService) do |service_instance|
            allow(service_instance).to receive(:execute).and_return(issue)
          end

          note = described_class.new(project, user, opts.merge(note: note_text)).execute
          expect(note.errors[:commands_only]).to contain_exactly('Confidential an error occurred')
        end
      end
    end

    context 'personal snippet note', feature_category: :source_code_management do
      subject { described_class.new(nil, user, params).execute }

      let(:snippet) { create(:personal_snippet) }
      let(:params) do
        { note: 'comment', noteable_type: 'Snippet', noteable_id: snippet.id }
      end

      it 'returns a valid note' do
        expect(subject).to be_valid
      end

      it 'returns a persisted note' do
        expect(subject).to be_persisted
      end

      it 'note has valid content' do
        expect(subject.note).to eq(params[:note])
      end
    end

    context 'design note', feature_category: :design_management do
      subject(:service) { described_class.new(project, user, params) }

      let_it_be(:design) { create(:design, :with_file) }
      let_it_be(:project) { design.project }
      let_it_be(:user) { project.first_owner }
      let_it_be(:params) do
        {
          type: 'DiffNote',
          noteable: design,
          note: ""A message"",
          position: {
            old_path: design.full_path,
            new_path: design.full_path,
            position_type: 'image',
            width: '100',
            height: '100',
            x: '50',
            y: '50',
            base_sha: design.diff_refs.base_sha,
            start_sha: design.diff_refs.base_sha,
            head_sha: design.diff_refs.head_sha
          }
        }
      end

      it 'can create diff notes for designs' do
        note = service.execute

        expect(note).to be_a(DiffNote)
        expect(note).to be_persisted
        expect(note.noteable).to eq(design)
      end

      it 'sends a notification about this note', :sidekiq_might_not_need_inline do
        notifier = double
        allow(::NotificationService).to receive(:new).and_return(notifier)

        expect(notifier)
          .to receive(:new_note)
          .with have_attributes(noteable: design)

        service.execute
      end

      it 'correctly builds the position of the note' do
        note = service.execute

        expect(note.position.new_path).to eq(design.full_path)
        expect(note.position.old_path).to eq(design.full_path)
        expect(note.position.diff_refs).to eq(design.diff_refs)
      end
    end

    context 'note with emoji only' do
      it 'creates regular note' do
        opts = {
          note: ':smile: ',
          noteable_type: 'Issue',
          noteable_id: issue.id
        }
        note = described_class.new(project, user, opts).execute

        expect(note).to be_valid
        expect(note.note).to eq(':smile:')
      end
    end

    context 'reply to individual note' do
      let(:existing_note) { create(:note_on_issue, noteable: issue, project: project) }
      let(:reply_opts) { opts.merge(in_reply_to_discussion_id: existing_note.discussion_id) }

      subject { described_class.new(project, user, reply_opts).execute }

      it 'creates a DiscussionNote in reply to existing note' do
        expect(subject).to be_a(DiscussionNote)
        expect(subject.discussion_id).to eq(existing_note.discussion_id)
      end

      it 'converts existing note to DiscussionNote' do
        expect do
          existing_note

          travel_to(Time.current + 1.minute) { subject }

          existing_note.reload
        end.to change { existing_note.type }.from(nil).to('DiscussionNote')
            .and change { existing_note.updated_at }
      end

      context 'failure in when_saved' do
        let(:service) { described_class.new(project, user, reply_opts) }

        it 'converts existing note to DiscussionNote' do
          expect do
            existing_note

            allow(service).to receive(:when_saved).and_raise(ActiveRecord::StatementInvalid)

            travel_to(Time.current + 1.minute) do
              service.execute
            rescue ActiveRecord::StatementInvalid
            end

            existing_note.reload
          end.to change { existing_note.type }.from(nil).to('DiscussionNote')
            .and change { existing_note.updated_at }
        end
      end

      it 'returns a DiscussionNote with its parent discussion refreshed correctly' do
        discussion_notes = subject.discussion.notes

        expect(discussion_notes.size).to eq(2)
        expect(discussion_notes.first).to be_a(DiscussionNote)
      end

      context 'discussion to reply cannot be found' do
        before do
          existing_note.delete
        end

        it 'returns an note with errors' do
          note = subject

          expect(note.errors).not_to be_empty
          expect(note.errors[:base]).to eq(['Discussion to reply to cannot be found'])
        end
      end
    end

    describe ""usage counter"" do
      let(:counter) { Gitlab::UsageDataCounters::NoteCounter }

      context 'snippet note' do
        let(:snippet) { create(:project_snippet, project: project) }
        let(:opts) { { note: 'reply', noteable_type: 'Snippet', noteable_id: snippet.id, project: project } }

        it 'increments usage counter' do
          expect do
            note = described_class.new(project, user, opts).execute

            expect(note).to be_valid
          end.to change { counter.read(:create, opts[:noteable_type]) }.by 1
        end

        it 'does not increment usage counter when creation fails' do
          expect do
            note = described_class.new(project, user, { note: '' }).execute

            expect(note).to be_invalid
          end.not_to change { counter.read(:create, opts[:noteable_type]) }
        end
      end

      context 'issue note' do
        let(:issue) { create(:issue, project: project) }
        let(:opts) { { note: 'reply', noteable_type: 'Issue', noteable_id: issue.id, project: project } }

        it 'does not increment usage counter' do
          expect do
            note = described_class.new(project, user, opts).execute

            expect(note).to be_valid
          end.not_to change { counter.read(:create, opts[:noteable_type]) }
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ProtectedTags
  class DestroyService < BaseService
    def execute(protected_tag)
      protected_tag.destroy
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ProtectedTags::DestroyService, feature_category: :compliance_management do
  let(:protected_tag) { create(:protected_tag) }
  let(:project) { protected_tag.project }
  let(:user) { project.first_owner }

  describe '#execute' do
    subject(:service) { described_class.new(project, user) }

    it 'destroy a protected tag' do
      service.execute(protected_tag)

      expect(protected_tag).to be_destroyed
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ProtectedTags
  class UpdateService < ::BaseService
    def execute(protected_tag)
      raise Gitlab::Access::AccessDeniedError unless can?(current_user, :admin_project, project)

      protected_tag.update(params)
      protected_tag
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ProtectedTags::UpdateService, feature_category: :compliance_management do
  let(:protected_tag) { create(:protected_tag) }
  let(:project) { protected_tag.project }
  let(:user) { project.first_owner }
  let(:params) { { name: new_name } }

  describe '#execute' do
    let(:new_name) { 'new protected tag name' }
    let(:result) { service.execute(protected_tag) }

    subject(:service) { described_class.new(project, user, params) }

    it 'updates a protected tag' do
      expect(result.reload.name).to eq(params[:name])
    end

    context 'when updating protected tag with a name that contains HTML tags' do
      let(:new_name) { 'foo<b>bar<\b>' }
      let(:result) { service.execute(protected_tag) }

      subject(:service) { described_class.new(project, user, params) }

      it 'updates a protected tag' do
        expect(result.reload.name).to eq(new_name)
      end
    end

    context 'without admin_project permissions' do
      let(:user) { create(:user) }

      it ""raises error"" do
        expect { service.execute(protected_tag) }.to raise_error(Gitlab::Access::AccessDeniedError)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ProtectedTags
  class CreateService < ::BaseService
    attr_reader :protected_tag

    def execute
      raise Gitlab::Access::AccessDeniedError unless can?(current_user, :admin_project, project)

      project.protected_tags.create(params)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ProtectedTags::CreateService, feature_category: :compliance_management do
  let(:project) { create(:project) }
  let(:user) { project.first_owner }
  let(:params) do
    {
      name: name,
      create_access_levels_attributes: [{ access_level: Gitlab::Access::MAINTAINER }]
    }
  end

  describe '#execute' do
    let(:name) { 'tag' }

    subject(:service) { described_class.new(project, user, params) }

    it 'creates a new protected tag' do
      expect { service.execute }.to change(ProtectedTag, :count).by(1)
      expect(project.protected_tags.last.create_access_levels.map(&:access_level)).to eq([Gitlab::Access::MAINTAINER])
    end

    context 'protecting a tag with a name that contains HTML tags' do
      let(:name) { 'foo<b>bar<\b>' }

      subject(:service) { described_class.new(project, user, params) }

      it 'creates a new protected tag' do
        expect { service.execute }.to change(ProtectedTag, :count).by(1)
        expect(project.protected_tags.last.name).to eq(name)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ml
  class CreateCandidateService
    def initialize(experiment, params = {})
      @experiment = experiment
      @name = params[:name]
      @user = params[:user]
      @start_time = params[:start_time]
      @model_version = params[:model_version]
    end

    def execute
      Ml::Candidate.create!(
        experiment: experiment,
        project: experiment.project,
        name: candidate_name,
        start_time: start_time || 0,
        user: user,
        model_version: model_version
      )
    end

    private

    def candidate_name
      name.presence || random_candidate_name
    end

    def random_candidate_name
      parts = Array.new(3).map { FFaker::Animal.common_name.downcase.delete(' ') } << rand(10000)
      parts.join('-').truncate(255)
    end

    attr_reader :name, :user, :experiment, :start_time, :model_version
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ml::CreateCandidateService, feature_category: :mlops do
  describe '#execute' do
    let_it_be(:model_version) { create(:ml_model_versions, candidate: nil) }
    let_it_be(:experiment) { create(:ml_experiments, project: model_version.project) }

    let(:params) { {} }

    subject(:candidate) { described_class.new(experiment, params).execute }

    context 'with default parameters' do
      it 'creates a candidate' do
        expect { candidate }.to change { experiment.candidates.count }.by(1)
      end

      it 'gives a fake name' do
        expect(candidate.name).to match(/[a-z]+-[a-z]+-[a-z]+-\d+/)
      end

      it 'sets the correct values', :aggregate_failures do
        expect(candidate.start_time).to eq(0)
        expect(candidate.experiment).to be(experiment)
        expect(candidate.project).to be(experiment.project)
        expect(candidate.user).to be_nil
      end
    end

    context 'when parameters are passed' do
      let(:params) do
        {
          start_time: 1234,
          name: 'candidate_name',
          model_version: model_version,
          user: experiment.user
        }
      end

      context 'with default parameters' do
        it 'creates a candidate' do
          expect { candidate }.to change { experiment.candidates.count }.by(1)
        end

        it 'sets the correct values', :aggregate_failures do
          expect(candidate.start_time).to eq(1234)
          expect(candidate.experiment).to be(experiment)
          expect(candidate.project).to be(experiment.project)
          expect(candidate.user).to be(experiment.user)
          expect(candidate.name).to eq('candidate_name')
          expect(candidate.model_version_id).to eq(model_version.id)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ml
  class CreateModelVersionService
    def initialize(model, params = {})
      @model = model
      @version = params[:version]
      @package = params[:package]
      @description = params[:description]
      @user = params[:user]
    end

    def execute
      ApplicationRecord.transaction do
        @version ||= Ml::IncrementVersionService.new(@model.latest_version.try(:version)).execute

        package = @package || find_or_create_package(@model.name, @version)

        model_version = Ml::ModelVersion.create!(model: @model, project: @model.project, version: @version,
          package: package, description: @description)

        model_version.candidate = ::Ml::CreateCandidateService.new(
          @model.default_experiment,
          { model_version: model_version }
        ).execute

        model_version
      end
    end

    private

    def find_or_create_package(model_name, model_version)
      package_params = {
        name: model_name,
        version: model_version
      }

      ::Packages::MlModel::FindOrCreatePackageService
        .new(@model.project, @user, package_params)
        .execute
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ml::CreateModelVersionService, feature_category: :mlops do
  let(:model) { create(:ml_models) }
  let(:params) { {} }

  subject(:service) { described_class.new(model, params).execute }

  context 'when no versions exist' do
    it 'creates a model version', :aggregate_failures do
      expect { service }.to change { Ml::ModelVersion.count }.by(1).and change { Ml::Candidate.count }.by(1)
      expect(model.reload.latest_version.version).to eq('1.0.0')
    end
  end

  context 'when a version exist' do
    before do
      create(:ml_model_versions, model: model, version: '3.0.0')
    end

    it 'creates another model version and increments the version number', :aggregate_failures do
      expect { service }.to change { Ml::ModelVersion.count }.by(1).and change { Ml::Candidate.count }.by(1)
      expect(model.reload.latest_version.version).to eq('4.0.0')
    end
  end

  context 'when a version is created' do
    it 'creates a package' do
      expect { service }.to change { Ml::ModelVersion.count }.by(1).and change {
                                                                          Packages::MlModel::Package.count
                                                                        }.by(1)
      expect(model.reload.latest_version.package.name).to eq(model.name)
      expect(model.latest_version.package.version).to eq(model.latest_version.version)
    end
  end

  context 'when a version is created and the package already exists' do
    it 'does not creates a package' do
      next_version = Ml::IncrementVersionService.new(model.latest_version.try(:version)).execute
      create(:ml_model_package, name: model.name, version: next_version, project: model.project)

      expect { service }.to change { Ml::ModelVersion.count }.by(1).and not_change {
                                                                          Packages::MlModel::Package.count
                                                                        }
      expect(model.reload.latest_version.package.name).to eq(model.name)
      expect(model.latest_version.package.version).to eq(model.latest_version.version)
    end
  end

  context 'when a version is created and an existing package supplied' do
    it 'does not creates a package' do
      next_version = Ml::IncrementVersionService.new(model.latest_version.try(:version)).execute
      package = create(:ml_model_package, name: model.name, version: next_version, project: model.project)
      service = described_class.new(model, { package: package })

      expect { service.execute }.to change { Ml::ModelVersion.count }.by(1).and not_change {
                                                                                  Packages::MlModel::Package.count
                                                                                }
      expect(model.reload.latest_version.package.name).to eq(model.name)
      expect(model.latest_version.package.version).to eq(model.latest_version.version)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ml
  class FindOrCreateExperimentService
    def initialize(project, experiment_name, user = nil)
      @project = project
      @name = experiment_name
      @user = user
    end

    def execute
      Ml::Experiment.find_or_create(project, name, user)
    end

    private

    attr_reader :project, :name, :user
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ml::FindOrCreateExperimentService, feature_category: :mlops do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { project.first_owner }
  let_it_be(:existing_experiment) { create(:ml_experiments, project: project, user: user) }

  let(:name) { 'new_experiment' }

  subject(:new_experiment) { described_class.new(project, name, user).execute }

  describe '#execute' do
    it 'creates an experiment using Ml::Experiment.find_or_create', :aggregate_failures do
      expect(Ml::Experiment).to receive(:find_or_create).and_call_original

      expect(new_experiment.name).to eq('new_experiment')
      expect(new_experiment.project).to eq(project)
      expect(new_experiment.user).to eq(user)
    end

    context 'when experiment already exists' do
      let(:name) { existing_experiment.name }

      it 'fetches existing experiment', :aggregate_failures do
        expect { new_experiment }.not_to change { Ml::Experiment.count }

        expect(new_experiment).to eq(existing_experiment)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ml
  class DestroyModelService
    def initialize(model, user)
      @model = model
      @user = user
    end

    def execute
      return unless @model.destroy

      ::Packages::MarkPackagesForDestructionService.new(
        packages: @model.all_packages,
        current_user: @user
      ).execute
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ml::DestroyModelService, feature_category: :mlops do
  let_it_be(:user) { create(:user) }
  let_it_be(:model) { create(:ml_models, :with_latest_version_and_package) }
  let(:service) { described_class.new(model, user) }

  describe '#execute' do
    context 'when model name does not exist in the project' do
      it 'returns nil' do
        allow(model).to receive(:destroy).and_return(false)
        expect(service.execute).to be nil
      end
    end

    context 'when a model exists' do
      it 'destroys the model' do
        expect(Packages::MarkPackagesForDestructionService).to receive(:new).with(packages: model.all_packages,
          current_user: user).and_return(instance_double('Packages::MarkPackagesForDestructionService').tap do |service|
                                           expect(service).to receive(:execute)
                                         end)
        expect { service.execute }.to change { Ml::Model.count }.by(-1).and change { Ml::ModelVersion.count }.by(-1)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ml
  class CreateModelService
    def initialize(project, name, user = nil, description = nil, metadata = [])
      @project = project
      @name = name
      @description = description
      @metadata = metadata
      @user = user
    end

    def execute
      ApplicationRecord.transaction do
        model = Ml::Model.create!(
          project: @project,
          name: @name,
          user: (@user.is_a?(User) ? @user : nil),
          description: @description,
          default_experiment: default_experiment
        )

        add_metadata(model, @metadata)

        model
      end
    end

    private

    def default_experiment
      @default_experiment ||= Ml::FindOrCreateExperimentService.new(@project, @name).execute
    end

    def add_metadata(model, metadata_key_value)
      return unless model.present? && metadata_key_value.present?

      entities = metadata_key_value.map do |d|
        {
          model_id: model.id,
          name: d[:key],
          value: d[:value]
        }
      end

      entities.each do |entry|
        ::Ml::ModelMetadata.create!(entry)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ml::CreateModelService, feature_category: :mlops do
  let_it_be(:user) { create(:user) }
  let_it_be(:existing_model) { create(:ml_models) }
  let_it_be(:another_project) { create(:project) }
  let_it_be(:description) { 'description' }
  let_it_be(:metadata) { [] }

  subject(:create_model) { described_class.new(project, name, user, description, metadata).execute }

  describe '#execute' do
    context 'when model name does not exist in the project' do
      let(:name) { 'new_model' }
      let(:project) { existing_model.project }

      it 'creates a model', :aggregate_failures do
        expect { create_model }.to change { Ml::Model.count }.by(1)

        expect(create_model.name).to eq(name)
      end
    end

    context 'when model name exists but project is different' do
      let(:name) { existing_model.name }
      let(:project) { another_project }

      it 'creates a model', :aggregate_failures do
        expect { create_model }.to change { Ml::Model.count }.by(1)

        expect(create_model.name).to eq(name)
      end
    end

    context 'when model with name exists' do
      let(:name) { existing_model.name }
      let(:project) { existing_model.project }

      it 'raises an error', :aggregate_failures do
        expect { create_model }.to raise_error(ActiveRecord::RecordInvalid)
      end
    end

    context 'when metadata are supplied, add them as metadata' do
      let(:name) { 'new_model' }
      let(:project) { existing_model.project }
      let(:metadata) { [{ key: 'key1', value: 'value1' }, { key: 'key2', value: 'value2' }] }

      it 'creates metadata records', :aggregate_failures do
        expect { create_model }.to change { Ml::Model.count }.by(1)

        expect(create_model.name).to eq(name)
        expect(create_model.metadata.count).to be 2
      end
    end

    # TODO: Ensure consisted error responses https://gitlab.com/gitlab-org/gitlab/-/issues/429731
    context 'for metadata with duplicate keys, it does not create duplicate records' do
      let(:name) { 'new_model' }
      let(:project) { existing_model.project }
      let(:metadata) { [{ key: 'key1', value: 'value1' }, { key: 'key1', value: 'value2' }] }

      it 'raises an error', :aggregate_failures do
        expect { create_model }.to raise_error(ActiveRecord::RecordInvalid)
      end
    end

    # TODO: Ensure consisted error responses https://gitlab.com/gitlab-org/gitlab/-/issues/429731
    context 'for metadata with invalid keys, it does not create invalid records' do
      let(:name) { 'new_model' }
      let(:project) { existing_model.project }
      let(:metadata) { [{ key: 'key1', value: 'value1' }, { key: '', value: 'value2' }] }

      it 'raises an error', :aggregate_failures do
        expect { create_model }.to raise_error(ActiveRecord::RecordInvalid)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ml
  class UpdateModelService
    def initialize(model, description)
      @model = model
      @description = description
    end

    def execute
      @model.update!(description: @description)

      @model
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ml::UpdateModelService, feature_category: :mlops do
  let_it_be(:model) { create(:ml_models) }
  let_it_be(:description) { 'updated model description' }
  let(:service) { described_class.new(model, description) }

  describe '#execute' do
    context 'when supplied with a non-model object' do
      let(:model) { nil }

      it 'returns nil' do
        expect { service.execute }.to raise_error(NoMethodError)
      end
    end

    context 'with an existing model' do
      it 'updates the description' do
        updated = service.execute
        expect(updated.class).to be(Ml::Model)
        expect(updated.description).to eq(description)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ml
  INITIAL_VERSION = '1.0.0'
  ALLOWED_INCREMENT_TYPES = [:patch, :minor, :major].freeze

  class IncrementVersionService
    def initialize(version, increment_type = nil)
      @version = version
      @increment_type = increment_type || :major
      @parsed_version = Packages::SemVer.parse(@version.to_s)

      raise ""Version must be in a valid SemVer format"" unless @parsed_version || @version.nil?

      return if ALLOWED_INCREMENT_TYPES.include?(@increment_type)

      raise ""Increment type must be one of :patch, :minor, or :major""
    end

    def execute
      return INITIAL_VERSION if @version.nil?

      case @increment_type
      when :patch
        @parsed_version.patch += 1
      when :minor
        @parsed_version.minor += 1
      when :major
        @parsed_version.major += 1
      end

      @parsed_version.to_s
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ml::IncrementVersionService, feature_category: :mlops do
  describe '#execute' do
    let(:increment_type) { nil }
    let(:finder) { described_class.new(version, increment_type) }

    context 'when given an invalid version format' do
      let(:version) { 'foo' }

      it 'raises an error' do
        expect { finder.execute }.to raise_error(RuntimeError, ""Version must be in a valid SemVer format"")
      end
    end

    context 'when given a non-semver version format' do
      let(:version) { 1 }

      it 'raises an error' do
        expect { finder.execute }.to raise_error(RuntimeError, ""Version must be in a valid SemVer format"")
      end
    end

    context 'when given an unsupported increment type' do
      let(:version) { '1.2.3' }
      let(:increment_type) { 'foo' }

      it 'raises an error' do
        expect do
          finder.execute
        end.to raise_error(RuntimeError, ""Increment type must be one of :patch, :minor, or :major"")
      end
    end

    context 'when valid inputs are provided' do
      using RSpec::Parameterized::TableSyntax

      where(:version, :increment_type, :result) do
        nil | nil | '1.0.0'
        '0.0.1' | nil | '1.0.1'
        '1.0.0' | nil | '2.0.0'
        '1.0.0' | :major | '2.0.0'
        '1.0.0' | :minor | '1.1.0'
        '1.0.0' | :patch | '1.0.1'
      end

      with_them do
        subject { finder.execute }

        it { is_expected.to eq(result) }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ml
  class FindOrCreateModelService
    def initialize(project, name, user = nil, description = nil, metadata = [])
      @project = project
      @name = name
      @description = description
      @metadata = metadata
      @user = user
    end

    def execute
      FindModelService.new(@project, @name).execute ||
        CreateModelService.new(@project, @name, @user, @description, @metadata).execute
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ml::FindOrCreateModelService, feature_category: :mlops do
  let_it_be(:user) { create(:user) }
  let_it_be(:existing_model) { create(:ml_models) }
  let_it_be(:another_project) { create(:project) }
  let_it_be(:description) { 'description' }
  let_it_be(:metadata) { [] }

  subject(:create_model) { described_class.new(project, name, user, description, metadata).execute }

  describe '#execute' do
    context 'when model name does not exist in the project' do
      let(:name) { 'new_model' }
      let(:project) { existing_model.project }

      it 'creates a model', :aggregate_failures do
        expect { create_model }.to change { Ml::Model.count }.by(1)

        expect(create_model.name).to eq(name)
      end
    end

    context 'when model name exists but project is different' do
      let(:name) { existing_model.name }
      let(:project) { another_project }

      it 'creates a model', :aggregate_failures do
        expect { create_model }.to change { Ml::Model.count }.by(1)

        expect(create_model.name).to eq(name)
      end
    end

    context 'when model with name exists' do
      let(:name) { existing_model.name }
      let(:project) { existing_model.project }

      it 'fetches existing model', :aggregate_failures do
        expect { create_model }.to change { Ml::Model.count }.by(0)

        expect(create_model).to eq(existing_model)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ml
  class FindOrCreateModelVersionService
    def initialize(project, params = {})
      @project = project
      @name = params[:model_name]
      @version = params[:version]
      @package = params[:package]
      @description = params[:description]
    end

    def execute
      model = Ml::FindOrCreateModelService.new(@project, @name).execute

      model_version = Ml::ModelVersion.find_or_create!(model, @version, @package, @description)

      unless model_version.candidate
        model_version.candidate = ::Ml::CreateCandidateService.new(
          model.default_experiment,
          { model_version: model_version }
        ).execute
      end

      model_version
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ml::FindOrCreateModelVersionService, feature_category: :mlops do
  let_it_be(:existing_version) { create(:ml_model_versions) }
  let_it_be(:another_project) { create(:project) }
  let_it_be(:user) { create(:user) }

  let(:package) { nil }
  let(:description) { nil }

  let(:params) do
    {
      model_name: name,
      version: version,
      package: package,
      description: description,
      user: user
    }
  end

  subject(:model_version) { described_class.new(project, params).execute }

  describe '#execute' do
    context 'when model version exists' do
      let(:name) { existing_version.name }
      let(:version) { existing_version.version }
      let(:project) { existing_version.project }

      it 'returns existing model version', :aggregate_failures do
        expect { model_version }.to change { Ml::ModelVersion.count }.by(0)
        expect { model_version }.to change { Ml::Candidate.count }.by(0)
        expect(model_version).to eq(existing_version)
      end
    end

    context 'when model version does not exist' do
      let(:project) { existing_version.project }
      let(:name) { 'a_new_model' }
      let(:version) { '2.0.0' }
      let(:description) { 'A model version' }

      let(:package) { create(:ml_model_package, project: project, name: name, version: version) }

      it 'creates a new model version', :aggregate_failures do
        expect { model_version }.to change { Ml::ModelVersion.count }.by(1).and change { Ml::Candidate.count }.by(1)

        expect(model_version.name).to eq(name)
        expect(model_version.version).to eq(version)
        expect(model_version.package).to eq(package)
        expect(model_version.candidate.model_version_id).to eq(model_version.id)
        expect(model_version.description).to eq(description)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ml
  class FindModelService
    def initialize(project, name)
      @project = project
      @name = name
    end

    def execute
      Ml::Model.by_project_id_and_name(@project.id, @name)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ml::FindModelService, feature_category: :mlops do
  let_it_be(:user) { create(:user) }
  let_it_be(:existing_model) { create(:ml_models) }
  let(:finder) { described_class.new(project, name) }

  describe '#execute' do
    context 'when model name does not exist in the project' do
      let(:name) { 'new_model' }
      let(:project) { existing_model.project }

      it 'reutrns nil' do
        expect(finder.execute).to be nil
      end
    end

    context 'when model with name exists' do
      let(:name) { existing_model.name }
      let(:project) { existing_model.project }

      it 'returns the existing model' do
        expect(finder.execute).to eq(existing_model)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ml
  module ExperimentTracking
    class CandidateRepository
      attr_accessor :project, :user, :experiment, :candidate

      def initialize(project, user = nil)
        @project = project
        @user = user
      end

      def by_eid(eid)
        ::Ml::Candidate.with_project_id_and_eid(project.id, eid)
      end

      def create!(experiment, start_time, tags = nil, name = nil)
        create_params = {
          start_time: start_time,
          user: user,
          name: candidate_name(name, tags)
        }

        candidate = Ml::CreateCandidateService.new(experiment, create_params).execute

        add_tags(candidate, tags)

        candidate
      end

      def update(candidate, status, end_time)
        candidate.status = status.downcase if status
        candidate.end_time = end_time if end_time

        candidate.save
      end

      def add_metric!(candidate, name, value, tracked_at, step)
        candidate.metrics.create!(
          name: name,
          value: value,
          tracked_at: tracked_at,
          step: step
        )
      end

      def add_param!(candidate, name, value)
        candidate.params.create!(name: name, value: value)
      end

      def add_tag!(candidate, name, value)
        handle_gitlab_tags(candidate, [{ key: name, value: value }])

        candidate.metadata.create!(name: name, value: value)
      end

      def add_metrics(candidate, metric_definitions)
        extra_keys = { tracked_at: :timestamp, step: :step }
        insert_many(candidate, metric_definitions, ::Ml::CandidateMetric, extra_keys)
      end

      def add_params(candidate, param_definitions)
        insert_many(candidate, param_definitions, ::Ml::CandidateParam)
      end

      def add_tags(candidate, tag_definitions)
        return unless tag_definitions.present?

        handle_gitlab_tags(candidate, tag_definitions)

        insert_many(candidate, tag_definitions, ::Ml::CandidateMetadata)
      end

      private

      def handle_gitlab_tags(candidate, tag_definitions)
        return unless tag_definitions.any? { |t| t[:key]&.starts_with?('gitlab.') }

        Ml::ExperimentTracking::HandleCandidateGitlabMetadataService
          .new(candidate, tag_definitions)
          .execute
      end

      def timestamps
        current_time = Time.zone.now

        { created_at: current_time, updated_at: current_time }
      end

      def insert_many(candidate, definitions, entity_class, extra_keys = {})
        return unless candidate.present? && definitions.present?

        entities = definitions.map do |d|
          {
            candidate_id: candidate.id,
            name: d[:key],
            value: d[:value],
            **extra_keys.transform_values { |old_key| d[old_key] },
            **timestamps
          }
        end

        entity_class.insert_all(entities, returning: false) unless entities.empty?
      end

      def candidate_name(name, tags)
        name.presence || candidate_name_from_tags(tags)
      end

      def candidate_name_from_tags(tags)
        tags&.detect { |t| t[:key] == 'mlflow.runName' }&.dig(:value)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ml::ExperimentTracking::CandidateRepository, feature_category: :activation do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }
  let_it_be(:experiment) { create(:ml_experiments, user: user, project: project) }
  let_it_be(:candidate) { create(:ml_candidates, user: user, experiment: experiment, project: project) }

  let(:repository) { described_class.new(project, user) }

  describe '#by_eid' do
    let(:eid) { candidate.eid }

    subject { repository.by_eid(eid) }

    it { is_expected.to eq(candidate) }

    context 'when iid does not exist' do
      let(:eid) { non_existing_record_iid.to_s }

      it { is_expected.to be_nil }
    end

    context 'when iid belongs to a different project' do
      let(:repository) { described_class.new(create(:project), user) }

      it { is_expected.to be_nil }
    end
  end

  describe '#create!' do
    let(:tags) { [{ key: 'hello', value: 'world' }] }
    let(:name) { 'some_candidate' }

    subject { repository.create!(experiment, 1234, tags, name) }

    it 'creates the candidate' do
      expect(subject.start_time).to eq(1234)
      expect(subject.eid).not_to be_nil
      expect(subject.end_time).to be_nil
      expect(subject.name).to eq('some_candidate')
    end

    it 'creates with tag' do
      expect(subject.metadata.length).to eq(1)
    end

    context 'when name is passed as tag' do
      let(:tags) { [{ key: 'mlflow.runName', value: 'blah' }] }

      it 'ignores if name is not nil' do
        expect(subject.name).to eq('some_candidate')
      end

      context 'when name is nil' do
        let(:name) { nil }

        it 'sets the mlflow.runName as candidate name' do
          expect(subject.name).to eq('blah')
        end
      end

      context 'when name is nil and no mlflow.runName is not present' do
        let(:tags) { nil }
        let(:name) { nil }

        it 'gives the candidate a random name' do
          expect(subject.name).to match(/[a-z]+-[a-z]+-[a-z]+-\d+/)
        end
      end
    end
  end

  describe '#update' do
    let(:end_time) { 123456 }
    let(:status) { 'running' }

    subject { repository.update(candidate, status, end_time) }

    it { is_expected.to be_truthy }

    context 'when end_time is missing ' do
      let(:end_time) { nil }

      it { is_expected.to be_truthy }
    end

    context 'when status is wrong' do
      let(:status) { 's' }

      it 'fails assigning the value' do
        expect { subject }.to raise_error(ArgumentError)
      end
    end

    context 'when status is missing' do
      let(:status) { nil }

      it { is_expected.to be_truthy }
    end
  end

  describe '#add_metric!' do
    let(:props) { { name: 'abc', value: 1234, tracked: 12345678, step: 0 } }
    let(:metrics_before) { candidate.metrics.size }

    before do
      metrics_before
    end

    subject { repository.add_metric!(candidate, props[:name], props[:value], props[:tracked], props[:step]) }

    it 'adds a new metric' do
      expect { subject }.to change { candidate.metrics.size }.by(1)
    end

    context 'when name missing' do
      let(:props) { { value: 1234, tracked: 12345678, step: 0 } }

      it 'does not add metric' do
        expect { subject }.to raise_error(ActiveRecord::RecordInvalid)
      end
    end
  end

  describe '#add_param!' do
    let(:props) { { name: 'abc', value: 'def' } }

    subject { repository.add_param!(candidate, props[:name], props[:value]) }

    it 'adds a new param' do
      expect { subject }.to change { candidate.params.size }.by(1)
    end

    context 'when name missing' do
      let(:props) { { value: 1234 } }

      it 'throws RecordInvalid' do
        expect { subject }.to raise_error(ActiveRecord::RecordInvalid)
      end
    end

    context 'when param was already added' do
      it 'throws RecordInvalid' do
        repository.add_param!(candidate, 'new', props[:value])

        expect { repository.add_param!(candidate, 'new', props[:value]) }.to raise_error(ActiveRecord::RecordInvalid)
      end
    end
  end

  describe '#add_tag!' do
    let(:props) { { name: 'abc', value: 'def' } }

    subject { repository.add_tag!(candidate, props[:name], props[:value]) }

    it 'adds a new tag' do
      expect { subject }.to change { candidate.reload.metadata.size }.by(1)
    end

    context 'when name missing' do
      let(:props) { { value: 1234 } }

      it 'throws RecordInvalid' do
        expect { subject }.to raise_error(ActiveRecord::RecordInvalid)
      end
    end

    context 'when tag was already added' do
      it 'throws RecordInvalid' do
        repository.add_tag!(candidate, 'new', props[:value])

        expect { repository.add_tag!(candidate, 'new', props[:value]) }.to raise_error(ActiveRecord::RecordInvalid)
      end
    end

    context 'when tag starts with gitlab.' do
      it 'calls HandleCandidateGitlabMetadataService' do
        expect(Ml::ExperimentTracking::HandleCandidateGitlabMetadataService).to receive(:new).and_call_original

        repository.add_tag!(candidate, 'gitlab.CI_USER_ID', user.id)
      end
    end
  end

  describe ""#add_params"" do
    let(:params) do
      [{ key: 'model_class', value: 'LogisticRegression' }, { 'key': 'pythonEnv', value: '3.10' }]
    end

    subject { repository.add_params(candidate, params) }

    it 'adds the parameters' do
      expect { subject }.to change { candidate.reload.params.size }.by(2)
    end

    context 'if parameter misses key' do
      let(:params) do
        [{ value: 'LogisticRegression' }]
      end

      it 'does not throw and does not add' do
        expect { subject }.to raise_error(ActiveRecord::ActiveRecordError)
      end
    end

    context 'if parameter misses value' do
      let(:params) do
        [{ key: 'pythonEnv2' }]
      end

      it 'does not throw and does not add' do
        expect { subject }.to raise_error(ActiveRecord::ActiveRecordError)
      end
    end

    context 'if parameter repeated do' do
      let(:params) do
        [
          { 'key': 'pythonEnv0', value: '2.7' },
          { 'key': 'pythonEnv1', value: '3.9' },
          { 'key': 'pythonEnv1', value: '3.10' }
        ]
      end

      before do
        repository.add_param!(candidate, 'pythonEnv0', '0')
      end

      it 'does not throw and adds only the first of each kind' do
        expect { subject }.to change { candidate.reload.params.size }.by(1)
      end
    end
  end

  describe ""#add_metrics"" do
    let(:metrics) do
      [
        { key: 'mae', value: 2.5, timestamp: 1552550804 },
        { key: 'rmse', value: 2.7, timestamp: 1552550804 }
      ]
    end

    subject { repository.add_metrics(candidate, metrics) }

    it 'adds the metrics' do
      expect { subject }.to change { candidate.reload.metrics.size }.by(2)
    end

    context 'when metrics have repeated keys' do
      let(:metrics) do
        [
          { key: 'mae', value: 2.5, timestamp: 1552550804 },
          { key: 'rmse', value: 2.7, timestamp: 1552550804 },
          { key: 'mae', value: 2.7, timestamp: 1552550805 }
        ]
      end

      it 'adds all of them' do
        expect { subject }.to change { candidate.reload.metrics.size }.by(3)
      end
    end
  end

  describe ""#add_tags"" do
    let(:tags) do
      [{ key: 'gitlab.tag1', value: 'hello' }, { 'key': 'gitlab.tag2', value: 'world' }]
    end

    subject { repository.add_tags(candidate, tags) }

    it 'adds the tags' do
      expect { subject }.to change { candidate.reload.metadata.size }.by(2)
    end

    context 'if tags misses key' do
      let(:tags) { [{ value: 'hello' }] }

      it 'does throw and does not add' do
        expect { subject }.to raise_error(ActiveRecord::ActiveRecordError)
      end
    end

    context 'if tag misses value' do
      let(:tags) { [{ key: 'gitlab.tag1' }] }

      it 'does throw and does not add' do
        expect { subject }.to raise_error(ActiveRecord::ActiveRecordError)
      end
    end

    context 'if tag repeated' do
      let(:params) do
        [
          { 'key': 'gitlab.tag1', value: 'hello' },
          { 'key': 'gitlab.tag2', value: 'world' },
          { 'key': 'gitlab.tag1', value: 'gitlab' }
        ]
      end

      before do
        repository.add_tag!(candidate, 'gitlab.tag2', '0')
      end

      it 'does not throw and adds only the first of each kind' do
        expect { subject }.to change { candidate.reload.metadata.size }.by(1)
      end
    end

    context 'when tags is nil' do
      let(:tags) { nil }

      it 'does not handle gitlab tags' do
        expect(repository).not_to receive(:handle_gitlab_tags)

        subject
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ml
  module ExperimentTracking
    class HandleCandidateGitlabMetadataService
      def initialize(candidate, metadata)
        @candidate = candidate
        @metadata = metadata.index_by { |m| m[:key] }
      end

      def execute
        handle_build_metadata(@metadata['gitlab.CI_JOB_ID'])

        @candidate.save
      end

      private

      def handle_build_metadata(build_metadata)
        return unless build_metadata

        build = Ci::Build.find_by_id(build_metadata[:value])

        raise ArgumentError, 'gitlab.CI_JOB_ID must refer to an existing build' unless build

        @candidate.ci_build = build
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ml::ExperimentTracking::HandleCandidateGitlabMetadataService, feature_category: :activation do
  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:user) { project.owner }
  let_it_be(:pipeline) { create(:ci_pipeline, project: project) }
  let_it_be(:build) { create(:ci_build, :success, pipeline: pipeline) }

  let(:metadata) { [] }
  let(:candidate) { create(:ml_candidates, project: project, user: user) }

  describe 'execute' do
    subject { described_class.new(candidate, metadata).execute }

    context 'when metadata includes gitlab.CI_JOB_ID', 'and gitlab.CI_JOB_ID is valid' do
      let(:metadata) do
        [
          { key: 'gitlab.CI_JOB_ID', value: build.id.to_s }
        ]
      end

      it 'updates candidate correctly', :aggregate_failures do
        subject

        expect(candidate.ci_build).to eq(build)
      end
    end

    context 'when metadata includes gitlab.CI_JOB_ID and gitlab.CI_JOB_ID is invalid' do
      let(:metadata) { [{ key: 'gitlab.CI_JOB_ID', value: non_existing_record_id.to_s }] }

      it 'raises error' do
        expect { subject }
          .to raise_error(ArgumentError, 'gitlab.CI_JOB_ID must refer to an existing build')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ml
  module ExperimentTracking
    class ExperimentRepository
      attr_accessor :project, :user

      def initialize(project, user = nil)
        @project = project
        @user = user
      end

      def by_iid_or_name(iid: nil, name: nil)
        return ::Ml::Experiment.by_project_id_and_iid(project.id, iid) if iid

        ::Ml::Experiment.by_project_id_and_name(project.id, name) if name
      end

      def all
        ::Ml::Experiment.by_project_id(project.id)
      end

      def create!(name, tags = nil)
        experiment = ::Ml::Experiment.create!(name: name,
                                              user: user,
                                              project: project)

        add_tags(experiment, tags)

        experiment
      end

      def add_tag!(experiment, key, value)
        return unless experiment.present?

        experiment.metadata.create!(name: key, value: value)
      end

      private

      def timestamps
        current_time = Time.zone.now

        { created_at: current_time, updated_at: current_time }
      end

      def add_tags(experiment, tag_definitions)
        return unless experiment.present? && tag_definitions.present?

        entities = tag_definitions.map do |d|
          {
            experiment_id: experiment.id,
            name: d[:key],
            value: d[:value],
            **timestamps
          }
        end

        ::Ml::ExperimentMetadata.insert_all(entities, returning: false) unless entities.empty?
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Ml::ExperimentTracking::ExperimentRepository, feature_category: :activation do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }
  let_it_be(:experiment) { create(:ml_experiments, user: user, project: project) }
  let_it_be(:experiment2) { create(:ml_experiments, user: user, project: project) }
  let_it_be(:experiment3) { create(:ml_experiments, user: user, project: project) }
  let_it_be(:experiment4) { create(:ml_experiments, user: user) }

  let(:repository) { described_class.new(project, user) }

  describe '#by_iid_or_name' do
    let(:iid) { experiment.iid }
    let(:name) { nil }

    subject { repository.by_iid_or_name(iid: iid, name: name) }

    context 'when iid passed' do
      it('fetches the experiment') { is_expected.to eq(experiment) }

      context 'and name passed' do
        let(:name) { experiment2.name }

        it('ignores the name') { is_expected.to eq(experiment) }
      end

      context 'and does not exist' do
        let(:iid) { non_existing_record_iid }

        it { is_expected.to eq(nil) }
      end
    end

    context 'when iid is not passed', 'and name is passed' do
      let(:iid) { nil }

      context 'when name exists' do
        let(:name) { experiment2.name }

        it('fetches the experiment') { is_expected.to eq(experiment2) }
      end

      context 'when name does not exist' do
        let(:name) { non_existing_record_iid }

        it { is_expected.to eq(nil) }
      end
    end
  end

  describe '#all' do
    it 'fetches experiments for project' do
      expect(repository.all).to match_array([experiment, experiment2, experiment3])
    end
  end

  describe '#create!' do
    let(:name) { 'hello' }
    let(:tags) { nil }

    subject { repository.create!(name, tags) }

    it 'creates the experiment' do
      expect { subject }.to change { repository.all.size }.by(1)
    end

    context 'when name exists' do
      let(:name) { experiment.name }

      it 'throws error' do
        expect { subject }.to raise_error(ActiveRecord::ActiveRecordError)
      end
    end

    context 'when has tags' do
      let(:tags) { [{ key: 'hello', value: 'world' }] }

      it 'creates the experiment with tag' do
        expect(subject.metadata.length).to eq(1)
      end
    end

    context 'when name is missing' do
      let(:name) { nil }

      it 'throws error' do
        expect { subject }.to raise_error(ActiveRecord::ActiveRecordError)
      end
    end
  end

  describe '#add_tag!' do
    let(:props) { { name: 'abc', value: 'def' } }

    subject { repository.add_tag!(experiment, props[:name], props[:value]) }

    it 'adds a new tag' do
      expect { subject }.to change { experiment.reload.metadata.size }.by(1)
    end

    context 'when name missing' do
      let(:props) { { value: 1234 } }

      it 'throws RecordInvalid' do
        expect { subject }.to raise_error(ActiveRecord::RecordInvalid)
      end
    end

    context 'when tag was already added' do
      it 'throws RecordInvalid' do
        repository.add_tag!(experiment, 'new', props[:value])

        expect { repository.add_tag!(experiment, 'new', props[:value]) }.to raise_error(ActiveRecord::RecordInvalid)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ml
  module ModelVersions
    class UpdateModelVersionService
      def initialize(project, name, version, description)
        @project = project
        @name = name
        @version = version
        @description = description
      end

      def execute
        model_version = Ml::ModelVersion
                          .by_project_id_name_and_version(@project.id, @name, @version)

        return ServiceResponse.error(message: 'Model not found') unless model_version.present?

        result = model_version.update(description: @description)

        return ServiceResponse.error(message: 'Model update failed') unless result

        ServiceResponse.success(payload: model_version)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ml::ModelVersions::UpdateModelVersionService, feature_category: :mlops do
  let_it_be(:existing_version) { create(:ml_model_versions) }

  let(:project) { existing_version.project }
  let(:name) { existing_version.name }
  let(:version) { existing_version.version }
  let(:description) { 'A model version description' }

  subject(:execute_service) { described_class.new(project, name, version, description).execute }

  describe '#execute' do
    context 'when model version exists' do
      it { is_expected.to be_success }

      it 'updates the model version description' do
        execute_service

        expect(execute_service.payload.description).to eq(description)
      end
    end

    context 'when description is invalid' do
      let(:description) { 'a' * 501 }

      it { is_expected.to be_error }
    end

    context 'when model does not exist' do
      let(:name) { 'a_new_model' }

      it { is_expected.to be_error }
    end

    context 'when model version does not exist' do
      let(:name) { '2.0.0' }

      it { is_expected.to be_error }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ml
  module ModelVersions
    class GetModelVersionService
      def initialize(project, name, version)
        @project = project
        @name = name
        @version = version
      end

      def execute
        Ml::ModelVersion.by_project_id_name_and_version(
          @project.id,
          @name,
          @version
        )
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ml::ModelVersions::GetModelVersionService, feature_category: :mlops do
  let_it_be(:existing_version) { create(:ml_model_versions) }
  let_it_be(:another_project) { create(:project) }

  subject(:model_version) { described_class.new(project, name, version).execute }

  describe '#execute' do
    context 'when model version exists' do
      let(:name) { existing_version.name }
      let(:version) { existing_version.version }
      let(:project) { existing_version.project }

      it { is_expected.to eq(existing_version) }
    end

    context 'when model version does not exist' do
      let(:project) { existing_version.project }
      let(:name) { 'a_new_model' }
      let(:version) { '2.0.0' }

      it { is_expected.to be_nil }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Ml
  module ModelVersions
    class DeleteService
      def initialize(project, name, version, user)
        @project = project
        @name = name
        @version = version
        @user = user
      end

      def execute
        model_version = Ml::ModelVersion
                          .by_project_id_name_and_version(@project.id, @name, @version)
        return ServiceResponse.error(message: 'Model not found') unless model_version

        if model_version.package.present?
          result = ::Packages::MarkPackageForDestructionService
                     .new(container: model_version.package, current_user: @user)
                     .execute

          return ServiceResponse.error(message: result.message) unless result.success?
        end

        return ServiceResponse.error(message: 'Could not destroy the model version') unless model_version.destroy

        ServiceResponse.success
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Ml::ModelVersions::DeleteService, feature_category: :mlops do
  let_it_be(:valid_model_version) do
    create(:ml_model_versions, :with_package)
  end

  let(:project) { valid_model_version.project }
  let(:user) { valid_model_version.project.owner }
  let(:name) { valid_model_version.name }
  let(:version) { valid_model_version.version }

  subject(:execute_service) { described_class.new(project, name, version, user).execute }

  describe '#execute' do
    context 'when model version exists' do
      it 'deletes the model version', :aggregate_failures do
        expect(execute_service).to be_success
        expect(Ml::ModelVersion.find_by(id: valid_model_version.id)).to be_nil
      end
    end

    context 'when model version does not exist' do
      let(:version) { 'wrong-version' }

      it { is_expected.to be_error.and have_attributes(message: 'Model not found') }
    end

    context 'when model version has no package' do
      before do
        valid_model_version.update!(package: nil)
      end

      it 'does not trigger destroy package service', :aggregate_failures do
        expect(Packages::MarkPackageForDestructionService).not_to receive(:new)
        expect(execute_service).to be_success
      end
    end

    context 'when package cannot be marked for destruction' do
      before do
        allow_next_instance_of(Packages::MarkPackageForDestructionService) do |service|
          allow(service).to receive(:execute).and_return(ServiceResponse.error(message: 'error'))
        end
      end

      it 'does not delete the model version', :aggregate_failures do
        is_expected.to be_error.and have_attributes(message: 'error')
        expect(Ml::ModelVersion.find_by(id: valid_model_version.id)).to eq(valid_model_version)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module DesignManagement
  class MoveDesignsService < DesignService
    # @param user [User] The current user
    # @param [Hash] params
    # @option params [DesignManagement::Design] :current_design
    # @option params [DesignManagement::Design] :previous_design (nil)
    # @option params [DesignManagement::Design] :next_design (nil)
    def initialize(user, params)
      super(nil, user, params.merge(issue: nil))
    end

    def execute
      return error(:no_focus) unless current_design.present?
      return error(:cannot_move) unless current_user.can?(:move_design, current_design)
      return error(:no_neighbors) unless neighbors.present?
      return error(:not_distinct) unless all_distinct?
      return error(:not_same_issue) unless all_same_issue?

      move_nulls_to_end
      current_design.move_between(previous_design, next_design)
      current_design.save!
      success
    end

    def error(message)
      ServiceResponse.error(message: message)
    end

    def success
      ServiceResponse.success
    end

    private

    delegate :issue, :project, to: :current_design

    def move_nulls_to_end
      moved_records = current_design.class.move_nulls_to_end(issue.designs.in_creation_order)
      return if moved_records == 0

      current_design.reset
      next_design&.reset
      previous_design&.reset
    end

    def neighbors
      [previous_design, next_design].compact
    end

    def all_distinct?
      ids.uniq.size == ids.size
    end

    def all_same_issue?
      issue.designs.id_in(ids).count == ids.size
    end

    def ids
      @ids ||= [current_design, *neighbors].map(&:id)
    end

    def current_design
      params[:current_design]
    end

    def previous_design
      params[:previous_design]
    end

    def next_design
      params[:next_design]
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe DesignManagement::MoveDesignsService, feature_category: :design_management do
  include DesignManagementTestHelpers

  let_it_be(:issue) { create(:issue) }
  let_it_be(:developer) { create(:user, developer_projects: [issue.project]) }
  let_it_be(:designs) { create_list(:design, 3, :with_relative_position, issue: issue) }

  let(:project) { issue.project }

  let(:service) { described_class.new(current_user, params) }

  let(:params) do
    {
      current_design: current_design,
      previous_design: previous_design,
      next_design: next_design
    }
  end

  let(:current_user) { developer }
  let(:current_design) { nil }
  let(:previous_design) { nil }
  let(:next_design) { nil }

  before do
    enable_design_management
  end

  describe '#execute' do
    subject { service.execute }

    context 'the user cannot move designs' do
      let(:current_design) { designs.first }
      let(:current_user) { build_stubbed(:user) }

      it 'raises cannot_move' do
        expect(subject).to be_error.and(have_attributes(message: :cannot_move))
      end
    end

    context 'the designs are not distinct' do
      let(:current_design) { designs.first }
      let(:previous_design) { designs.first }

      it 'raises not_distinct' do
        expect(subject).to be_error.and(have_attributes(message: :not_distinct))
      end
    end

    context 'the designs are not on the same issue' do
      let(:current_design) { designs.first }
      let(:previous_design) { create(:design) }

      it 'raises not_same_issue' do
        expect(subject).to be_error.and(have_attributes(message: :not_same_issue))
      end
    end

    context 'no focus is passed' do
      let(:previous_design) { designs.second }
      let(:next_design) { designs.third }

      it 'raises no_focus' do
        expect(subject).to be_error.and(have_attributes(message: :no_focus))
      end
    end

    context 'no neighbours are passed' do
      let(:current_design) { designs.first }

      it 'raises no_neighbors' do
        expect(subject).to be_error.and(have_attributes(message: :no_neighbors))
      end
    end

    context 'moving a design with neighbours' do
      let(:current_design) { designs.first }
      let(:previous_design) { designs.second }
      let(:next_design) { designs.third }

      it 'repositions existing designs and correctly places the given design' do
        other_design1 = create(:design, issue: issue, relative_position: 10)
        other_design2 = create(:design, issue: issue, relative_position: 20)
        other_design3, other_design4 = create_list(:design, 2, issue: issue)

        expect(subject).to be_success

        expect(issue.designs.ordered).to eq(
          [
            # Existing designs which already had a relative_position set.
            # These should stay at the beginning, in the same order.
            other_design1,
            other_design2,

            # The designs we're passing into the service.
            # These should be placed between the existing designs, in the correct order.
            previous_design,
            current_design,
            next_design,

            # Existing designs which didn't have a relative_position set.
            # These should be placed at the end, in the order of their IDs.
            other_design3,
            other_design4
          ])
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module DesignManagement
  # Service class for counting and caching the number of unresolved
  # notes of a Design
  class DesignUserNotesCountService < ::BaseCountService
    # The version of the cache format. This should be bumped whenever the
    # underlying logic changes. This removes the need for explicitly flushing
    # all caches.
    VERSION = 1

    def initialize(design)
      @design = design
    end

    def relation_for_count
      design.notes.user
    end

    def raw?
      # Since we're storing simple integers we don't need all of the
      # additional Marshal data Rails includes by default.
      true
    end

    def cache_key
      ['designs', 'notes_count', VERSION, design.id]
    end

    private

    attr_reader :design
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe DesignManagement::DesignUserNotesCountService, :use_clean_rails_memory_store_caching, feature_category: :design_management do
  let_it_be(:design) { create(:design, :with_file) }

  subject { described_class.new(design) }

  it_behaves_like 'a counter caching service'

  describe '#count' do
    it 'returns the count of notes' do
      create_list(:diff_note_on_design, 3, noteable: design)

      expect(subject.count).to eq(3)
    end
  end

  describe '#cache_key' do
    it 'contains the `VERSION` and `design.id`' do
      expect(subject.cache_key).to eq(['designs', 'notes_count', DesignManagement::DesignUserNotesCountService::VERSION, design.id])
    end
  end

  describe 'cache invalidation' do
    it 'changes when a new note is created' do
      new_note_attrs = attributes_for(:diff_note_on_design, noteable: design)

      expect do
        Notes::CreateService.new(design.project, create(:user), new_note_attrs).execute
      end.to change { subject.count }.by(1)
    end

    it 'changes when a note is destroyed' do
      note = create(:diff_note_on_design, noteable: design)

      expect do
        Notes::DestroyService.new(note.project, note.author).execute(note)
      end.to change { subject.count }.by(-1)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module DesignManagement
  class SaveDesignsService < DesignService
    include RunsDesignActions
    include OnSuccessCallbacks

    MAX_FILES = 10

    def initialize(project, user, params = {})
      super

      @files = params.fetch(:files)
    end

    def execute
      return error(""Not allowed!"") unless can_create_designs?
      return error(""Only #{MAX_FILES} files are allowed simultaneously"") if files.size > MAX_FILES
      return error(""Duplicate filenames are not allowed!"") if files.map(&:original_filename).uniq.length != files.length
      return error(""Design copy is in progress"") if design_collection.copy_in_progress?

      uploaded_designs, version = upload_designs!
      skipped_designs = designs - uploaded_designs

      create_events
      design_collection.reset_copy!

      success({ designs: uploaded_designs, version: version, skipped_designs: skipped_designs })
    rescue ::ActiveRecord::RecordInvalid => e
      error(e.message)
    end

    private

    attr_reader :files

    def upload_designs!
      ::DesignManagement::Version.with_lock(project.id, repository) do
        actions = build_actions

        [
          actions.map(&:design),
          actions.presence && run_actions(actions)
        ]
      end
    end

    # Returns `Design` instances that correspond with `files`.
    # New `Design`s will be created where a file name does not match
    # an existing `Design`
    def designs
      @designs ||= files.map do |file|
        collection.find_or_create_design!(filename: file.original_filename)
      end
    end

    def build_actions
      @actions ||= files.zip(designs).flat_map do |(file, design)|
        Array.wrap(build_design_action(file, design))
      end
    end

    def build_design_action(file, design)
      content = file_content(file, design.full_path)
      return if design_unchanged?(design, content)

      action = new_file?(design) ? :create : :update
      on_success do
        track_usage_metrics(action)
      end

      DesignManagement::DesignAction.new(design, action, content)
    end

    # Returns true if the design file is the same as its latest version
    def design_unchanged?(design, content)
      content == existing_blobs[design]&.data
    end

    def create_events
      by_action = @actions.group_by(&:action).transform_values { |grp| grp.map(&:design) }

      event_create_service.save_designs(current_user, **by_action)
    end

    def event_create_service
      @event_create_service ||= EventCreateService.new
    end

    def commit_message
      <<~MSG
      Updated #{files.size} #{'designs'.pluralize(files.size)}

      #{formatted_file_list}
      MSG
    end

    def formatted_file_list
      filenames.map { |name| ""- #{name}"" }.join(""\n"")
    end

    def filenames
      @filenames ||= files.map(&:original_filename)
    end

    def can_create_designs?
      Ability.allowed?(current_user, :create_design, issue)
    end

    def new_file?(design)
      !existing_blobs[design]
    end

    def file_content(file, full_path)
      transformer = ::Lfs::FileTransformer.new(project, repository, target_branch)
      transformer.new_file(full_path, file.to_io, detect_content_type: Feature.enabled?(:design_management_allow_dangerous_images, project)).content
    end

    # Returns the latest blobs for the designs as a Hash of `{ Design => Blob }`
    def existing_blobs
      @existing_blobs ||= begin
        items = designs.map { |d| [target_branch, d.full_path] }

        repository.blobs_at(items).each_with_object({}) do |blob, h|
          design = designs.find { |d| d.full_path == blob.path }

          h[design] = blob
        end
      end
    end

    def track_usage_metrics(action)
      if action == :update
        ::Gitlab::UsageDataCounters::IssueActivityUniqueCounter
          .track_issue_designs_modified_action(author: current_user, project: project)
      else
        ::Gitlab::UsageDataCounters::IssueActivityUniqueCounter
          .track_issue_designs_added_action(author: current_user, project: project)
      end

      ::Gitlab::UsageDataCounters::DesignsCounter.count(action)
    end
  end
end

DesignManagement::SaveDesignsService.prepend_mod_with('DesignManagement::SaveDesignsService')

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe DesignManagement::SaveDesignsService, feature_category: :design_management do
  include DesignManagementTestHelpers
  include ConcurrentHelpers

  let_it_be_with_reload(:issue) { create(:issue) }
  let_it_be(:developer) { create(:user, developer_projects: [issue.project]) }

  let(:project) { issue.project }
  let(:user) { developer }
  let(:files) { [rails_sample] }
  let(:design_repository) { project.find_or_create_design_management_repository.repository }

  let(:rails_sample_name) { 'rails_sample.jpg' }
  let(:rails_sample) { sample_image(rails_sample_name) }
  let(:dk_png) { sample_image('dk.png') }

  def sample_image(filename)
    fixture_file_upload(""spec/fixtures/#{filename}"")
  end

  def commit_count
    design_repository.expire_statistics_caches
    design_repository.expire_root_ref_cache
    design_repository.commit_count
  end

  before do
    if issue.design_collection.repository.exists?
      issue.design_collection.repository.expire_all_method_caches
      issue.design_collection.repository.raw.delete_all_refs_except([Gitlab::Git::BLANK_SHA])
    end

    allow(::DesignManagement::NewVersionWorker)
      .to receive(:perform_async).with(Integer, false).and_return(nil)
  end

  def run_service(files_to_upload = nil)
    design_files = files_to_upload || files
    design_files.each(&:rewind)

    service = described_class.new(project, user, issue: issue, files: design_files)
    service.execute
  end

  # Randomly alter the content of files.
  # This allows the files to be updated by the service, as unmodified
  # files are rejected.
  def touch_files(files_to_touch = nil)
    design_files = files_to_touch || files

    design_files.each do |f|
      f.tempfile.write(SecureRandom.random_bytes)
    end
  end

  let(:response) { run_service }

  shared_examples 'a service error' do
    it 'returns an error', :aggregate_failures do
      expect(response).to match(a_hash_including(status: :error))
    end
  end

  shared_examples 'an execution error' do
    it 'returns an error', :aggregate_failures do
      expect { service.execute }.to raise_error(some_error)
    end
  end

  describe '#execute' do
    context 'when the feature is not available' do
      before do
        enable_design_management(false)
      end

      it_behaves_like 'a service error'

      it 'does not create an event in the activity stream' do
        expect { run_service }.not_to change { Event.count }
      end
    end

    context 'when the feature is available' do
      before do
        enable_design_management(true)
      end

      describe 'repository existence' do
        def repository_exists
          # Expire the memoized value as the service creates it's own instance
          design_repository.expire_exists_cache
          design_repository.exists?
        end

        it 'is ensured when the service runs' do
          run_service

          expect(repository_exists).to be true
        end
      end

      it 'creates a commit, an event in the activity stream and updates the creation count', :aggregate_failures do
        counter = Gitlab::UsageDataCounters::DesignsCounter

        expect(Gitlab::UsageDataCounters::IssueActivityUniqueCounter).to receive(:track_issue_designs_added_action)
                                                                           .with(author: user, project: project)

        expect { run_service }
          .to change { Event.count }.by(1)
          .and change { Event.for_design.created_action.count }.by(1)
          .and change { counter.read(:create) }.by(1)

        expect(design_repository.commit).to have_attributes(
          author: user,
          message: include(rails_sample_name)
        )
      end

      it_behaves_like 'internal event tracking' do
        let(:event) { Gitlab::UsageDataCounters::IssueActivityUniqueCounter::ISSUE_DESIGNS_ADDED }
        let(:namespace) { project.namespace }
        subject(:service_action) { run_service }
      end

      it 'can run the same command in parallel' do
        parellism = 4

        blocks = Array.new(parellism).map do
          unique_files = [RenameableUpload.unique_file('rails_sample.jpg')]

          -> { run_service(unique_files) }
        end

        expect { run_parallel(blocks) }.to change(DesignManagement::Version, :count).by(parellism)
      end

      context 'when the design collection is in the process of being copied', :clean_gitlab_redis_shared_state do
        before do
          issue.design_collection.start_copy!
        end

        it_behaves_like 'a service error'
      end

      context 'when the design collection has a copy error', :clean_gitlab_redis_shared_state do
        before do
          issue.design_collection.copy_state = 'error'
          issue.design_collection.send(:set_stored_copy_state!)
        end

        it 'resets the copy state' do
          expect { run_service }.to change { issue.design_collection.copy_state }.from('error').to('ready')
        end
      end

      describe 'the response' do
        it 'includes designs with the expected properties' do
          updated_designs = response[:designs]

          expect(updated_designs).to all(have_attributes(diff_refs: be_present))
          expect(updated_designs.size).to eq(1)
          expect(updated_designs.first.versions.size).to eq(1)
          expect(updated_designs.first.versions.first.author).to eq(user)
        end
      end

      describe 'saving the file to LFS' do
        before do
          expect_next_instance_of(Lfs::FileTransformer) do |transformer|
            expect(transformer).to receive(:lfs_file?).and_return(true)
          end
        end

        it 'saves the design to LFS and saves the repository_type of the LfsObjectsProject as design' do
          expect { run_service }
            .to change { LfsObject.count }.by(1)
            .and change { project.lfs_objects_projects.count }.from(0).to(1)

          expect(project.lfs_objects_projects.first.repository_type).to eq('design')
        end
      end

      context 'when HEAD branch is different from master' do
        before do
          stub_feature_flags(main_branch_over_master: true)
        end

        it 'does not raise an exception during update' do
          run_service

          expect { run_service }.not_to raise_error
        end
      end

      context 'when a design is being updated' do
        before do
          run_service
          touch_files
        end

        it 'creates a new version for the existing design and updates the file' do
          expect(issue.designs.size).to eq(1)
          expect(DesignManagement::Version.for_designs(issue.designs).size).to eq(1)

          updated_designs = response[:designs]

          expect(updated_designs.size).to eq(1)
          expect(updated_designs.first.versions.size).to eq(2)
        end

        it 'updates UsageData for changed designs' do
          expect(Gitlab::UsageDataCounters::IssueActivityUniqueCounter).to receive(:track_issue_designs_modified_action)
                                                                             .with(author: user, project: project)

          run_service
        end

        it_behaves_like 'internal event tracking' do
          let(:event) { Gitlab::UsageDataCounters::IssueActivityUniqueCounter::ISSUE_DESIGNS_MODIFIED }
          let(:namespace) { project.namespace }
          subject(:service_action) { run_service }
        end

        it 'records the correct events' do
          counter = Gitlab::UsageDataCounters::DesignsCounter
          expect { run_service }
            .to change { counter.read(:update) }.by(1)
            .and change { Event.count }.by(1)
            .and change { Event.for_design.updated_action.count }.by(1)
        end

        context 'when uploading a new design' do
          it 'does not link the new version to the existing design' do
            existing_design = issue.designs.first

            updated_designs = run_service([dk_png])[:designs]

            expect(existing_design.versions.reload.size).to eq(1)
            expect(updated_designs.size).to eq(1)
            expect(updated_designs.first.versions.size).to eq(1)
          end
        end

        context 'when detecting content type' do
          it 'detects content type when feature flag is enabled' do
            expect_next_instance_of(::Lfs::FileTransformer) do |file_transformer|
              expect(file_transformer).to receive(:new_file)
                .with(anything, anything, hash_including(detect_content_type: true)).and_call_original
            end

            run_service
          end

          it 'skips content type detection when feature flag is disabled' do
            stub_feature_flags(design_management_allow_dangerous_images: false)
            expect_next_instance_of(::Lfs::FileTransformer) do |file_transformer|
              expect(file_transformer).to receive(:new_file)
                .with(anything, anything, hash_including(detect_content_type: false)).and_call_original
            end

            run_service
          end
        end
      end

      context 'when a design has not changed since its previous version' do
        before do
          run_service
        end

        it 'does not create a new version, and returns the design in `skipped_designs`' do
          response = nil

          expect { response = run_service }.not_to change { issue.design_versions.count }

          expect(response[:designs]).to be_empty
          expect(response[:skipped_designs].size).to eq(1)
        end
      end

      context 'when doing a mixture of updates and creations' do
        let(:files) { [rails_sample, dk_png] }

        before do
          # Create just the first one, which we will later update.
          run_service([files.first])
          touch_files([files.first])
        end

        it 'has the correct side-effects' do
          counter = Gitlab::UsageDataCounters::DesignsCounter

          expect(::DesignManagement::NewVersionWorker)
            .to receive(:perform_async).once.with(Integer, false).and_return(nil)

          expect { run_service }
            .to change { Event.count }.by(2)
            .and change { Event.for_design.count }.by(2)
            .and change { Event.created_action.count }.by(1)
            .and change { Event.updated_action.count }.by(1)
            .and change { counter.read(:create) }.by(1)
            .and change { counter.read(:update) }.by(1)
            .and change { commit_count }.by(1)
        end
      end

      context 'when uploading multiple files' do
        let(:files) { [rails_sample, dk_png] }

        it 'returns information about both designs in the response' do
          expect(response).to include(designs: have_attributes(size: 2), status: :success)
        end

        it 'has the correct side-effects', :request_store do
          counter = Gitlab::UsageDataCounters::DesignsCounter
          service = described_class.new(project, user, issue: issue, files: files)

          # Some unrelated calls that are usually cached or happen only once
          # We expect:
          #  - An exists?
          #  - a check for existing blobs
          #  - default branch
          #  - an after_commit callback on LfsObjectsProject
          design_repository.create_if_not_exists
          design_repository.has_visible_content?

          expect(::DesignManagement::NewVersionWorker)
            .to receive(:perform_async).once.with(Integer, false).and_return(nil)

          expect { service.execute }
            .to change { issue.designs.count }.from(0).to(2)
            .and change { DesignManagement::Version.count }.by(1)
            .and change { counter.read(:create) }.by(2)
            .and change { Gitlab::GitalyClient.get_request_count }.by(3)
            .and change { commit_count }.by(1)
        end

        context 'when uploading too many files' do
          let(:files) { Array.new(DesignManagement::SaveDesignsService::MAX_FILES + 1) { dk_png } }

          it 'returns the correct error' do
            expect(response[:message]).to match(/only \d+ files are allowed simultaneously/i)
          end
        end

        context 'when uploading duplicate files' do
          let(:files) { [rails_sample, dk_png, rails_sample] }

          it 'returns the correct error' do
            expect(response[:message]).to match('Duplicate filenames are not allowed!')
          end
        end
      end

      context 'when the user is not allowed to upload designs' do
        let(:user) { build_stubbed(:user, id: non_existing_record_id) }

        it_behaves_like 'a service error'
      end

      describe 'failure modes' do
        let(:service) { described_class.new(project, user, issue: issue, files: files) }
        let(:response) { service.execute }

        before do
          expect(service).to receive(:run_actions).and_raise(some_error)
        end

        context 'when creating the commit fails' do
          let(:some_error) { Gitlab::Git::BaseError }

          it_behaves_like 'an execution error'
        end

        context 'when creating the versions fails' do
          let(:some_error) { ActiveRecord::RecordInvalid }

          it_behaves_like 'a service error'
        end
      end

      context ""when a design already existed in the repo but we didn't know about it in the database"" do
        let(:filename) { rails_sample_name }

        before do
          path = File.join(build(:design, issue: issue, filename: filename).full_path)
          design_repository.create_if_not_exists
          design_repository.create_file(
            user,
            path, 'something fake',
            branch_name: project.default_branch_or_main,
            message: 'Somehow created without being tracked in db'
          )
        end

        it 'creates the design and a new version for it' do
          first_updated_design = response[:designs].first

          expect(first_updated_design.filename).to eq(filename)
          expect(first_updated_design.versions.size).to eq(1)
        end
      end

      describe 'scalability', skip: 'See: https://gitlab.com/gitlab-org/gitlab/-/issues/213169' do
        before do
          run_service([sample_image('banana_sample.gif')]) # ensure project, issue, etc are created
        end

        it 'runs the same queries for all requests, regardless of number of files' do
          one = [dk_png]
          two = [rails_sample, dk_png]

          baseline = ActiveRecord::QueryRecorder.new { run_service(one) }

          expect { run_service(two) }.not_to exceed_query_limit(baseline)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module DesignManagement
  class DeleteDesignsService < DesignService
    include RunsDesignActions
    include OnSuccessCallbacks

    def initialize(project, user, params = {})
      super

      @designs = params.fetch(:designs)
    end

    def execute
      return error('Forbidden!') unless can_delete_designs?

      version = delete_designs!
      EventCreateService.new.destroy_designs(designs, current_user)
      Gitlab::UsageDataCounters::IssueActivityUniqueCounter.track_issue_designs_removed_action(
        author: current_user,
        project: project
      )
      TodosDestroyer::DestroyedDesignsWorker.perform_async(designs.map(&:id))

      success(version: version)
    end

    def commit_message
      n = designs.size

      <<~MSG
      Removed #{n} #{'designs'.pluralize(n)}

      #{formatted_file_list}
      MSG
    end

    private

    attr_reader :designs

    def delete_designs!
      DesignManagement::Version.with_lock(project.id, repository) do
        run_actions(build_actions)
      end
    end

    def can_delete_designs?
      Ability.allowed?(current_user, :destroy_design, issue)
    end

    def build_actions
      designs.map { |d| design_action(d) }
    end

    def design_action(design)
      on_success do
        counter.count(:delete)
      end

      DesignManagement::DesignAction.new(design, :delete)
    end

    def counter
      ::Gitlab::UsageDataCounters::DesignsCounter
    end

    def formatted_file_list
      designs.map { |design| ""- #{design.full_path}"" }.join(""\n"")
    end
  end
end

DesignManagement::DeleteDesignsService.prepend_mod_with('DesignManagement::DeleteDesignsService')

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe DesignManagement::DeleteDesignsService, feature_category: :design_management do
  include DesignManagementTestHelpers

  let_it_be(:project) { create(:project) }
  let_it_be(:issue) { create(:issue, project: project) }
  let_it_be(:user) { create(:user) }

  let(:designs) { create_designs }

  subject(:service) { described_class.new(project, user, issue: issue, designs: designs) }

  # Defined as a method so that the response is not cached. We also construct
  # a new service executor each time to avoid the intermediate cached values
  # it constructs during its execution.
  def run_service(delenda = nil)
    service = described_class.new(project, user, issue: issue, designs: delenda || designs)
    service.execute
  end

  let(:response) { run_service }

  shared_examples 'a service error' do
    it 'returns an error', :aggregate_failures do
      expect(response).to include(status: :error)
    end
  end

  shared_examples 'a top-level error' do
    let(:expected_error) { StandardError }
    it 'raises an en expected error', :aggregate_failures do
      expect { run_service }.to raise_error(expected_error)
    end
  end

  shared_examples 'a success' do
    it 'returns successfully', :aggregate_failures do
      expect(response).to include(status: :success)
    end

    it 'saves the user as the author' do
      version = response[:version]

      expect(version.author).to eq(user)
    end
  end

  before do
    enable_design_management(enabled)
    project.add_developer(user)
  end

  describe ""#execute"" do
    context ""when the feature is not available"" do
      let(:enabled) { false }

      it_behaves_like ""a service error""

      it 'does not create any events in the activity stream' do
        expect do
          run_service
        rescue StandardError
          nil
        end.not_to change { Event.count }
      end
    end

    context ""when the feature is available"" do
      let(:enabled) { true }

      it 'is able to delete designs' do
        expect(service.send(:can_delete_designs?)).to be true
      end

      context 'no designs were passed' do
        let(:designs) { [] }

        it_behaves_like ""a top-level error""

        it 'does not log any events' do
          counter = ::Gitlab::UsageDataCounters::DesignsCounter

          expect do
            run_service
          rescue StandardError
            nil
          end
            .not_to change { [counter.totals, Event.count] }
        end

        it 'does not log any UsageData metrics' do
          redis_hll = ::Gitlab::UsageDataCounters::HLLRedisCounter
          event = Gitlab::UsageDataCounters::IssueActivityUniqueCounter::ISSUE_DESIGNS_REMOVED

          expect do
            run_service
          rescue StandardError
            nil
          end
            .not_to change { redis_hll.unique_events(event_names: event, start_date: Date.today, end_date: 1.week.from_now) }

          begin
            run_service
          rescue StandardError
            nil
          end
        end
      end

      context 'one design is passed' do
        before do
          create_designs(2)
        end

        let!(:designs) { create_designs(1) }

        it 'removes that design' do
          expect { run_service }.to change { issue.designs.current.count }.from(3).to(2)
        end

        it 'logs a deletion event' do
          counter = ::Gitlab::UsageDataCounters::DesignsCounter
          expect { run_service }.to change { counter.read(:delete) }.by(1)
        end

        it 'updates UsageData for removed designs' do
          expect(Gitlab::UsageDataCounters::IssueActivityUniqueCounter).to receive(:track_issue_designs_removed_action)
                                                                             .with(author: user, project: project)

          run_service
        end

        it 'creates an event in the activity stream' do
          expect { run_service }
            .to change { Event.count }.by(1)
            .and change { Event.destroyed_action.for_design.count }.by(1)
        end

        it 'informs the new-version-worker' do
          expect(::DesignManagement::NewVersionWorker).to receive(:perform_async).with(Integer, false)

          run_service
        end

        it 'creates a new version' do
          expect { run_service }.to change { DesignManagement::Version.where(issue: issue).count }.by(1)
        end

        it 'returns the new version' do
          version = response[:version]

          expect(version).to eq(DesignManagement::Version.for_issue(issue).ordered.first)
        end

        it_behaves_like ""a success""

        it 'removes the design from the current design list' do
          run_service

          expect(issue.designs.current).not_to include(designs.first)
        end

        it 'marks the design as deleted' do
          expect { run_service }
            .to change { designs.first.deleted? }.from(false).to(true)
        end

        it 'schedules deleting todos for that design' do
          expect(TodosDestroyer::DestroyedDesignsWorker).to receive(:perform_async).with([designs.first.id])

          run_service
        end

        it_behaves_like 'internal event tracking' do
          let(:event) { Gitlab::UsageDataCounters::IssueActivityUniqueCounter::ISSUE_DESIGNS_REMOVED }
          let(:namespace) { project.namespace }

          subject(:service_action) { run_service }
        end
      end

      context 'more than one design is passed' do
        before do
          create_designs(1)
        end

        let!(:designs) { create_designs(2) }

        it 'makes the correct changes' do
          counter = ::Gitlab::UsageDataCounters::DesignsCounter

          expect { run_service }
            .to change { issue.designs.current.count }.from(3).to(1)
            .and change { counter.read(:delete) }.by(2)
            .and change { Event.count }.by(2)
            .and change { Event.destroyed_action.for_design.count }.by(2)
        end

        it 'schedules deleting todos for that design' do
          expect(TodosDestroyer::DestroyedDesignsWorker).to receive(:perform_async).with(designs.map(&:id))

          run_service
        end

        it_behaves_like ""a success""

        context 'after executing the service' do
          let(:deleted_designs) { designs.map(&:reset) }

          let!(:version) { run_service[:version] }

          it 'removes the removed designs from the current design list' do
            expect(issue.designs.current).not_to include(*deleted_designs)
          end

          it 'does not make the designs impossible to find' do
            expect(issue.designs).to include(*deleted_designs)
          end

          it 'associates the new version with all the designs' do
            current_versions = deleted_designs.map { |d| d.most_recent_action.version }
            expect(current_versions).to all(eq version)
          end

          it 'marks all deleted designs as deleted' do
            expect(deleted_designs).to all(be_deleted)
          end

          it 'marks all deleted designs with the same deletion version' do
            expect(deleted_designs.map { |d| d.most_recent_action.version_id }.uniq)
              .to have_attributes(size: 1)
          end
        end
      end

      describe 'scalability' do
        before do
          run_service(create_designs(1)) # ensure project, issue, etc are created
        end

        it 'makes the same number of DB requests for one design as for several' do
          one = create_designs(1)
          many = create_designs(5)

          baseline = ActiveRecord::QueryRecorder.new { run_service(one) }

          expect { run_service(many) }.not_to exceed_query_limit(baseline)
        end
      end
    end
  end

  private

  def create_designs(how_many = 2)
    create_list(:design, how_many, :with_lfs_file, issue: issue)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module DesignManagement
  # This service generates smaller image versions for `DesignManagement::Design`
  # records within a given `DesignManagement::Version`.
  class GenerateImageVersionsService < DesignService
    # We limit processing to only designs with file sizes that don't
    # exceed `MAX_DESIGN_SIZE`.
    #
    # Note, we may be able to remove checking this limit, if when we come to
    # implement a file size limit for designs, there are no designs that
    # exceed 40MB on GitLab.com
    #
    # See https://gitlab.com/gitlab-org/gitlab/-/merge_requests/22860#note_281780387
    MAX_DESIGN_SIZE = 40.megabytes.freeze

    def initialize(version)
      super(version.project, version.author, issue: version.issue)

      @version = version
    end

    def execute
      # rubocop: disable CodeReuse/ActiveRecord
      version.actions.includes(:design).each do |action|
        generate_image(action)
      end
      # rubocop: enable CodeReuse/ActiveRecord

      success(version: version)
    end

    private

    attr_reader :version

    def generate_image(action)
      raw_file = get_raw_file(action)

      unless raw_file
        log_error(""No design file found for Action: #{action.id}"")
        return
      end

      # Skip attempting to process images that would be rejected by CarrierWave.
      return unless DesignManagement::DesignV432x230Uploader::MIME_TYPE_ALLOWLIST.include?(raw_file.content_type)

      # Store and process the file
      action.image_v432x230.store!(raw_file)
      action.save!
    rescue CarrierWave::IntegrityError => e
      Gitlab::ErrorTracking.log_exception(e, project_id: project.id, design_id: action.design_id, version_id: action.version_id)
      log_error(e.message)
    rescue CarrierWave::UploadError => e
      Gitlab::ErrorTracking.track_exception(e, project_id: project.id, design_id: action.design_id, version_id: action.version_id)
      log_error(e.message)
    end

    # Returns the `CarrierWave::SanitizedFile` of the original design file
    def get_raw_file(action)
      raw_files_by_path[action.design.full_path]
    end

    # Returns the `Carrierwave:SanitizedFile` instances for all of the original
    # design files, mapping to { design.filename => `Carrierwave::SanitizedFile` }.
    #
    # As design files are stored in Git LFS, the only way to retrieve their original
    # files is to first fetch the LFS pointer file data from the Git design repository.
    # The LFS pointer file data contains an ""OID"" that lets us retrieve `LfsObject`
    # records, which have an Uploader (`LfsObjectUploader`) for the original design file.
    def raw_files_by_path
      @raw_files_by_path ||= LfsObject.for_oids(blobs_by_oid.keys).each_with_object({}) do |lfs_object, h|
        blob = blobs_by_oid[lfs_object.oid]
        file = lfs_object.file.file
        # The `CarrierWave::SanitizedFile` is loaded without knowing the `content_type`
        # of the file, due to the file not having an extension.
        #
        # Set the content_type from the `Blob`.
        file.content_type = blob.content_type
        h[blob.path] = file
      end
    end

    # Returns the `Blob`s that correspond to the design files in the repository.
    #
    # All design `Blob`s are LFS Pointer files, and are therefore small amounts
    # of data to load.
    #
    # `Blob`s whose size are above a certain threshold: `MAX_DESIGN_SIZE`
    # are filtered out.
    def blobs_by_oid
      @blobs ||= begin
        items = version.designs.map { |design| [version.sha, design.full_path] }
        blobs = repository.blobs_at(items)
        blobs.reject! { |blob| blob.lfs_size > MAX_DESIGN_SIZE }
        blobs.index_by(&:lfs_oid)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe DesignManagement::GenerateImageVersionsService, feature_category: :design_management do
  let_it_be(:project) { create(:project) }
  let_it_be(:issue) { create(:issue, project: project) }
  let_it_be(:version) { create(:design, :with_lfs_file, issue: issue).versions.first }
  let_it_be(:action) { version.actions.first }

  describe '#execute' do
    it 'generates the image' do
      expect { described_class.new(version).execute }
        .to change { action.reload.image_v432x230.file }
        .from(nil).to(CarrierWave::SanitizedFile)
    end

    it 'skips generating image versions if the mime type is not allowlisted' do
      stub_const('DesignManagement::DesignV432x230Uploader::MIME_TYPE_ALLOWLIST', [])

      described_class.new(version).execute

      expect(action.reload.image_v432x230.file).to eq(nil)
    end

    it 'skips generating image versions if the design file size is too large' do
      stub_const(""#{described_class.name}::MAX_DESIGN_SIZE"", 1.byte)

      described_class.new(version).execute

      expect(action.reload.image_v432x230.file).to eq(nil)
    end

    it 'returns the status' do
      result = described_class.new(version).execute

      expect(result[:status]).to eq(:success)
    end

    it 'returns the version' do
      result = described_class.new(version).execute

      expect(result[:version]).to eq(version)
    end

    it 'logs if the raw image cannot be found' do
      version.designs.first.update!(filename: 'foo.png')

      expect(Gitlab::AppLogger).to receive(:error).with(""No design file found for Action: #{action.id}"")

      described_class.new(version).execute
    end

    context 'when an error is encountered when generating the image versions' do
      context ""CarrierWave::IntegrityError"" do
        before do
          expect_next_instance_of(DesignManagement::DesignV432x230Uploader) do |uploader|
            expect(uploader).to receive(:cache!).and_raise(CarrierWave::IntegrityError, 'foo')
          end
        end

        it 'logs the exception' do
          expect(Gitlab::ErrorTracking).to receive(:log_exception).with(
            instance_of(CarrierWave::IntegrityError),
            project_id: project.id, version_id: version.id, design_id: version.designs.first.id
          )

          described_class.new(version).execute
        end

        it 'logs the error' do
          expect(Gitlab::AppLogger).to receive(:error).with('foo')

          described_class.new(version).execute
        end
      end

      context ""CarrierWave::UploadError"" do
        before do
          expect_next_instance_of(DesignManagement::DesignV432x230Uploader) do |uploader|
            expect(uploader).to receive(:cache!).and_raise(CarrierWave::UploadError, 'foo')
          end
        end

        it 'logs the error' do
          expect(Gitlab::AppLogger).to receive(:error).with('foo')

          described_class.new(version).execute
        end

        it 'tracks the error' do
          expect(Gitlab::ErrorTracking).to receive(:track_exception).with(
            instance_of(CarrierWave::UploadError),
            project_id: project.id, version_id: version.id, design_id: version.designs.first.id
          )

          described_class.new(version).execute
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Service to copy a DesignCollection from one Issue to another.
# Copies the DesignCollection's Designs, Versions, and Notes on Designs.
module DesignManagement
  module CopyDesignCollection
    class CopyService < DesignService
      # rubocop: disable CodeReuse/ActiveRecord
      def initialize(project, user, params = {})
        super

        @target_issue = params.fetch(:target_issue)
        @target_project = @target_issue.project
        @target_repository = @target_project.design_repository
        @target_design_collection = @target_issue.design_collection
        @temporary_branch = ""CopyDesignCollectionService_#{SecureRandom.hex}""
        # The user who triggered the copy may not have permissions to push
        # to the design repository.
        @git_user = @target_project.first_owner

        @designs = DesignManagement::Design.unscoped.where(issue: issue).order(:id).load
        @versions = DesignManagement::Version.unscoped.where(issue: issue).order(:id).includes(:designs).load

        @sha_attribute = Gitlab::Database::ShaAttribute.new
        @shas = []
        @event_enum_map = DesignManagement::DesignAction::EVENT_FOR_GITALY_ACTION.invert
      end
      # rubocop: enable CodeReuse/ActiveRecord

      def execute
        return error('User cannot copy design collection to issue') unless user_can_copy?
        return error('Target design collection must first be queued') unless target_design_collection.copy_in_progress?
        return error('Design collection has no designs') if designs.empty?
        return error('Target design collection already has designs') unless target_design_collection.empty?

        with_temporary_branch do
          copy_commits!

          ApplicationRecord.transaction do
            design_ids = copy_designs!
            version_ids = copy_versions!
            copy_actions!(design_ids, version_ids)
            link_lfs_files!
            copy_notes!(design_ids)
            finalize!
          end
        end

        ServiceResponse.success
      rescue StandardError => error
        log_exception(error)

        target_design_collection.error_copy!

        error('Designs were unable to be copied successfully')
      end

      private

      attr_reader :designs, :event_enum_map, :git_user, :sha_attribute, :shas,
        :temporary_branch, :target_design_collection, :target_issue,
        :target_repository, :target_project, :versions

      alias_method :merge_branch, :target_branch

      def log_exception(exception)
        payload = {
          issue_id: issue.id,
          project_id: project.id,
          target_issue_id: target_issue.id,
          target_project: target_project.id
        }

        Gitlab::ErrorTracking.track_exception(exception, payload)
      end

      def error(message)
        ServiceResponse.error(message: message)
      end

      def user_can_copy?
        current_user.can?(:read_design, design_collection) &&
          current_user.can?(:admin_issue, target_issue)
      end

      def with_temporary_branch(&block)
        target_repository.create_if_not_exists

        create_default_branch! if target_repository.empty?
        create_temporary_branch!

        yield
      ensure
        remove_temporary_branch!
      end

      # A project that does not have any designs will have a blank design
      # repository. To create a temporary branch from default branch we need to
      # create default branch first by adding a file to it.
      def create_default_branch!
        target_repository.create_file(
          git_user,
          "".CopyDesignCollectionService_#{Time.now.to_i}"",
          '.gitlab',
          message: ""Commit to create #{merge_branch} branch in CopyDesignCollectionService"",
          branch_name: merge_branch
        )
      end

      def create_temporary_branch!
        target_repository.add_branch(
          git_user,
          temporary_branch,
          target_repository.root_ref
        )
      end

      def remove_temporary_branch!
        return unless target_repository.branch_exists?(temporary_branch)

        target_repository.rm_branch(git_user, temporary_branch)
      end

      # Merge the temporary branch containing the commits to default branch
      # and update the state of the target_design_collection.
      def finalize!
        source_sha = shas.last

        target_repository.raw.merge(
          git_user,
          source_sha: source_sha,
          target_branch: merge_branch,
          message: 'CopyDesignCollectionService finalize merge'
        ) { nil }

        target_design_collection.end_copy!
      end

      # rubocop: disable CodeReuse/ActiveRecord
      def copy_commits!
        # Execute another query to include actions and their designs
        DesignManagement::Version.unscoped.where(id: versions).order(:id).includes(actions: :design).find_each(batch_size: 100) do |version|
          gitaly_actions = version.actions.map do |action|
            design = action.design
            # Map the raw Action#event enum value to a Gitaly ""action"" for the
            # `Repository#commit_files` call.
            gitaly_action_name = @event_enum_map[action.event_before_type_cast]
            # `content` will be the LfsPointer file and not the design file,
            # and can be nil for deletions.
            content = blobs.dig(version.sha, design.filename)&.data
            file_path = DesignManagement::Design.build_full_path(target_issue, design)

            {
              action: gitaly_action_name,
              file_path: file_path,
              content: content
            }.compact
          end

          sha = target_repository.commit_files(
            git_user,
            branch_name: temporary_branch,
            message: commit_message(version),
            actions: gitaly_actions
          )

          shas << sha
        end
      end
      # rubocop: enable CodeReuse/ActiveRecord

      def copy_designs!
        design_attributes = attributes_config[:design_attributes]

        ::DesignManagement::Design.with_project_iid_supply(target_project) do |supply|
          new_rows = designs.each_with_index.map do |design, i|
            design.attributes.slice(*design_attributes).merge(
              issue_id: target_issue.id,
              project_id: target_project.id,
              iid: supply.next_value
            )
          end

          # TODO Replace `ApplicationRecord.legacy_bulk_insert` with `BulkInsertSafe`
          # once https://gitlab.com/gitlab-org/gitlab/-/issues/247718 is fixed.
          # When this is fixed, we can remove the call to
          # `with_project_iid_supply` above, since the objects will be instantiated
          # and callbacks (including `ensure_project_iid!`) will fire.
          ::ApplicationRecord.legacy_bulk_insert( # rubocop:disable Gitlab/BulkInsert
            DesignManagement::Design.table_name,
            new_rows,
            return_ids: true
          )
        end
      end

      def copy_versions!
        version_attributes = attributes_config[:version_attributes]
        # `shas` are the list of Git commits made during the Git copy phase,
        # and will be ordered 1:1 with old versions
        shas_enum = shas.to_enum

        new_rows = versions.map do |version|
          version.attributes.slice(*version_attributes).merge(
            issue_id: target_issue.id,
            sha: sha_attribute.serialize(shas_enum.next)
          )
        end

        # TODO Replace `ApplicationRecord.legacy_bulk_insert` with `BulkInsertSafe`
        # once https://gitlab.com/gitlab-org/gitlab/-/issues/247718 is fixed.
        ::ApplicationRecord.legacy_bulk_insert( # rubocop:disable Gitlab/BulkInsert
          DesignManagement::Version.table_name,
          new_rows,
          return_ids: true
        )
      end

      # rubocop: disable CodeReuse/ActiveRecord
      def copy_actions!(new_design_ids, new_version_ids)
        # Create a map of <Old design id> => <New design id>
        design_id_map = new_design_ids.each_with_index.to_h do |design_id, i|
          [designs[i].id, design_id]
        end

        # Create a map of <Old version id> => <New version id>
        version_id_map = new_version_ids.each_with_index.to_h do |version_id, i|
          [versions[i].id, version_id]
        end

        actions = DesignManagement::Action.unscoped.select(:design_id, :version_id, :event).where(design: designs, version: versions)

        new_rows = actions.map do |action|
          {
            design_id: design_id_map[action.design_id],
            version_id: version_id_map[action.version_id],
            event: action.event_before_type_cast
          }
        end

        # We cannot use `BulkInsertSafe` because of the uploader mounted in `Action`.
        ::ApplicationRecord.legacy_bulk_insert( # rubocop:disable Gitlab/BulkInsert
          DesignManagement::Action.table_name,
          new_rows
        )
      end
      # rubocop: enable CodeReuse/ActiveRecord

      def commit_message(version)
        ""Copy commit #{version.sha} from issue #{issue.to_reference(full: true)}""
      end

      # rubocop: disable CodeReuse/ActiveRecord
      def copy_notes!(design_ids)
        new_designs = DesignManagement::Design.unscoped.find(design_ids)

        # Execute another query to filter only designs with notes
        DesignManagement::Design.unscoped.where(id: designs).joins(:notes).distinct.find_each(batch_size: 100) do |old_design|
          new_design = new_designs.find { |d| d.filename == old_design.filename }

          Notes::CopyService.new(current_user, old_design, new_design).execute
        end
      end
      # rubocop: enable CodeReuse/ActiveRecord

      # rubocop: disable CodeReuse/ActiveRecord
      def link_lfs_files!
        oids = blobs.values.flat_map(&:values).map(&:lfs_oid)
        repository_type = LfsObjectsProject.repository_types[:design]

        new_rows = LfsObject.where(oid: oids).find_each(batch_size: 1000).map do |lfs_object|
          {
            project_id: target_project.id,
            lfs_object_id: lfs_object.id,
            repository_type: repository_type
          }
        end

        # We cannot use `BulkInsertSafe` due to the LfsObjectsProject#update_project_statistics
        # callback that fires after_commit.
        ::ApplicationRecord.legacy_bulk_insert( # rubocop:disable Gitlab/BulkInsert
          LfsObjectsProject.table_name,
          new_rows,
          on_conflict: :do_nothing # Upsert
        )
      end
      # rubocop: enable CodeReuse/ActiveRecord

      # Blob data is used to find the oids for LfsObjects and to copy to Git.
      # Blobs are reasonably small in memory, as their data are LFS Pointer files.
      #
      # Returns all blobs for the designs as a Hash of `{ Blob#commit_id => { Design#filename => Blob } }`
      def blobs
        @blobs ||= begin
          items = versions.flat_map { |v| v.designs.map { |d| [v.sha, DesignManagement::Design.build_full_path(issue, d)] } }

          repository.blobs_at(items).each_with_object({}) do |blob, h|
            design = designs.find { |d| DesignManagement::Design.build_full_path(issue, d) == blob.path }

            h[blob.commit_id] ||= {}
            h[blob.commit_id][design.filename] = blob
          end
        end
      end

      def attributes_config
        @attributes_config ||= YAML.load_file(attributes_config_file).symbolize_keys
      end

      def attributes_config_file
        Rails.root.join('lib/gitlab/design_management/copy_design_collection_model_attributes.yml')
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe DesignManagement::CopyDesignCollection::CopyService, :clean_gitlab_redis_shared_state, feature_category: :portfolio_management do
  include DesignManagementTestHelpers

  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project) }
  let_it_be(:issue, refind: true) { create(:issue, project: project) }

  let(:target_issue) { create(:issue) }

  subject { described_class.new(project, user, issue: issue, target_issue: target_issue).execute }

  before do
    enable_design_management
  end

  shared_examples 'service error' do |message:|
    it 'returns an error response', :aggregate_failures do
      expect(subject).to be_kind_of(ServiceResponse)
      expect(subject).to be_error
      expect(subject.message).to eq(message)
    end
  end

  shared_examples 'service success' do
    it 'returns a success response', :aggregate_failures do
      expect(subject).to be_kind_of(ServiceResponse)
      expect(subject).to be_success
    end
  end

  include_examples 'service error', message: 'User cannot copy design collection to issue'

  context 'when user has permission to read the design collection' do
    before_all do
      project.add_reporter(user)
    end

    include_examples 'service error', message: 'User cannot copy design collection to issue'

    context 'when the user also has permission to admin the target issue' do
      let(:target_repository) { target_issue.project.design_repository }

      before do
        target_issue.project.add_reporter(user)
      end

      include_examples 'service error', message: 'Target design collection must first be queued'

      context 'when the target design collection has been queued' do
        before do
          target_issue.design_collection.start_copy!
        end

        include_examples 'service error', message: 'Design collection has no designs'

        context 'when design collection has designs' do
          let_it_be(:designs) do
            create_list(:design, 3, :with_lfs_file, :with_relative_position, issue: issue, project: project)
          end

          context 'when target issue already has designs' do
            before do
              create(:design, issue: target_issue, project: target_issue.project)
            end

            include_examples 'service error', message: 'Target design collection already has designs'
          end

          context 'when target project already has designs' do
            let!(:issue_x) { create(:issue, project: target_issue.project) }
            let!(:existing) { create(:design, issue: issue_x, project: target_issue.project) }

            let(:new_designs) do
              target_issue.reset
              target_issue.designs.where.not(id: existing.id)
            end

            it 'sets IIDs for new designs above existing ones' do
              subject

              expect(new_designs).to all(have_attributes(iid: (be > existing.iid)))
            end

            it 'does not allow for IID collisions' do
              subject
              create(:design, issue: issue_x, project: target_issue.project)

              design_iids = target_issue.project.designs.map(&:id)

              expect(design_iids).to match_array(design_iids.uniq)
            end
          end

          include_examples 'service success'

          it 'creates a design repository for the target project' do
            expect { subject }.to change { target_repository.exists? }.from(false).to(true)
          end

          context 'when the target project already has a design repository' do
            before do
              target_repository.create_if_not_exists
            end

            include_examples 'service success'
          end

          it 'copies the designs correctly', :aggregate_failures do
            expect { subject }.to change { target_issue.designs.count }.by(3)

            old_designs = issue.designs.ordered
            new_designs = target_issue.designs.ordered

            new_designs.zip(old_designs).each do |new_design, old_design|
              expect(new_design).to have_attributes(
                filename: old_design.filename,
                description: old_design.description,
                relative_position: old_design.relative_position,
                issue: target_issue,
                project: target_issue.project
              )
            end
          end

          it 'copies the design versions correctly', :aggregate_failures do
            expect { subject }.to change { target_issue.design_versions.count }.by(3)

            old_versions = issue.design_versions.ordered
            new_versions = target_issue.design_versions.ordered

            new_versions.zip(old_versions).each do |new_version, old_version|
              expect(new_version).to have_attributes(
                created_at: old_version.created_at,
                author_id: old_version.author_id
              )
              expect(new_version.designs.pluck(:filename)).to eq(old_version.designs.pluck(:filename))
              expect(new_version.actions.pluck(:event)).to eq(old_version.actions.pluck(:event))
            end
          end

          it 'copies the design actions correctly', :aggregate_failures do
            expect { subject }.to change { DesignManagement::Action.count }.by(3)

            old_actions = issue.design_versions.ordered.flat_map(&:actions)
            new_actions = target_issue.design_versions.ordered.flat_map(&:actions)

            new_actions.zip(old_actions).each do |new_action, old_action|
              # This is a way to identify if the versions linked to the actions
              # are correct is to compare design filenames, as the SHA changes.
              new_design_filenames = new_action.version.designs.ordered.pluck(:filename)
              old_design_filenames = old_action.version.designs.ordered.pluck(:filename)

              expect(new_design_filenames).to eq(old_design_filenames)
              expect(new_action.event).to eq(old_action.event)
              expect(new_action.design.filename).to eq(old_action.design.filename)
            end
          end

          it 'copies design notes correctly', :aggregate_failures, :sidekiq_inline do
            old_notes = [
              create(:diff_note_on_design, note: 'first note', noteable: designs.first, project: project, author: create(:user)),
              create(:diff_note_on_design, note: 'second note', noteable: designs.first, project: project, author: create(:user))
            ]
            matchers = old_notes.map do |note|
              have_attributes(
                note.attributes.slice(
                  :type,
                  :author_id,
                  :note,
                  :position
                )
              )
            end

            expect { subject }.to change { Note.count }.by(2)

            new_notes = target_issue.designs.first.notes.fresh

            expect(new_notes).to match_array(matchers)
          end

          it 'links the LfsObjects' do
            expect { subject }.to change { target_issue.project.lfs_objects.count }.by(3)
          end

          it 'copies the Git repository data', :aggregate_failures do
            subject

            expect(commits_on_master(limit: 99)).to include(*target_issue.design_versions.ordered.pluck(:sha))
          end

          it 'creates a default branch if none previously existed' do
            expect { subject }.to change { target_repository.branch_names }.from([]).to([project.design_repository.root_ref])
          end

          it 'does not create default branch when one exists' do
            target_repository.create_if_not_exists
            target_repository.create_file(user, '.meta', '.gitlab', branch_name: 'new-branch', message: 'message')

            expect { subject }.not_to change { target_repository.branch_names }
            expect(target_repository.branch_names).to eq(['new-branch'])
          end

          it 'leaves the design collection in the correct copy state' do
            subject

            expect(target_issue.design_collection).to be_copy_ready
          end

          describe 'rollback' do
            before do
              # Ensure the very last step throws an error
              expect_next_instance_of(described_class) do |service|
                expect(service).to receive(:finalize!).and_raise
              end
            end

            include_examples 'service error', message: 'Designs were unable to be copied successfully'

            it 'rollsback all PostgreSQL data created', :aggregate_failures do
              expect { subject }.not_to change {
                [
                  DesignManagement::Design.count,
                  DesignManagement::Action.count,
                  DesignManagement::Version.count,
                  Note.count
                ]
              }

              collections = [
                target_issue.design_collection,
                target_issue.designs,
                target_issue.design_versions
              ]

              expect(collections).to all(be_empty)
            end

            it 'does not alter master branch', :aggregate_failures do
              # Add some Git data to the target_repository, so we are testing
              # that any original data remains
              issue_2 = create(:issue, project: target_issue.project)
              create(:design, :with_file, issue: issue_2, project: target_issue.project)

              expect { subject }.not_to change { commits_on_master }
            end

            it 'sets the design collection copy state' do
              subject

              expect(target_issue.design_collection).to be_copy_error
            end
          end

          def commits_on_master(limit: 10)
            target_repository.commits(target_repository.root_ref, limit: limit).map(&:id)
          end
        end
      end
    end
  end

  describe 'Alert if schema changes', :aggregate_failures do
    let_it_be(:config_file) { Rails.root.join('lib/gitlab/design_management/copy_design_collection_model_attributes.yml') }
    let_it_be(:config) { YAML.load_file(config_file).symbolize_keys }

    %w[Design Action Version].each do |model|
      specify do
        attributes = config[""#{model.downcase}_attributes"".to_sym] || []
        ignored_attributes = config[""ignore_#{model.downcase}_attributes"".to_sym]

        expect(attributes + ignored_attributes).to contain_exactly(
          *DesignManagement.const_get(model, false).column_names
        ), failure_message(model)
      end
    end

    def failure_message(model)
      <<-MSG
      The schema of the `#{model}` model has changed.

      `#{described_class.name}` refers to specific lists of attributes of `#{model}` to either
      copy or ignore, so that we continue to copy designs correctly after schema changes.

      Please update:
      #{config_file}
      to reflect the latest changes to `#{model}`. See that file for more information.
      MSG
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Service for setting the initial copy_state on the target DesignCollection
# and queuing a CopyDesignCollectionWorker.
module DesignManagement
  module CopyDesignCollection
    class QueueService
      def initialize(current_user, issue, target_issue)
        @current_user = current_user
        @issue = issue
        @target_issue = target_issue
        @target_design_collection = target_issue.design_collection
      end

      def execute
        return error('User cannot copy designs to issue') unless user_can_copy?
        return error('Target design collection copy state must be `ready`') unless target_design_collection.can_start_copy?

        target_design_collection.start_copy!

        DesignManagement::CopyDesignCollectionWorker.perform_async(current_user.id, issue.id, target_issue.id)

        ServiceResponse.success
      end

      private

      delegate :design_collection, to: :issue

      attr_reader :current_user, :issue, :target_design_collection, :target_issue

      def error(message)
        ServiceResponse.error(message: message)
      end

      def user_can_copy?
        current_user.can?(:read_design, issue) &&
          current_user.can?(:admin_issue, target_issue)
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe DesignManagement::CopyDesignCollection::QueueService, :clean_gitlab_redis_shared_state,
  feature_category: :design_management do
  include DesignManagementTestHelpers

  let_it_be(:user) { create(:user) }
  let_it_be(:issue) { create(:issue) }
  let_it_be(:target_issue, refind: true) { create(:issue) }
  let_it_be(:design) { create(:design, issue: issue, project: issue.project) }

  subject { described_class.new(user, issue, target_issue).execute }

  before do
    enable_design_management
  end

  it 'returns an error if user does not have permission' do
    expect(subject).to be_kind_of(ServiceResponse)
    expect(subject).to be_error
    expect(subject.message).to eq('User cannot copy designs to issue')
  end

  context 'when user has permission' do
    before_all do
      issue.project.add_reporter(user)
      target_issue.project.add_reporter(user)
    end

    it 'returns an error if design collection copy_state is not queuable' do
      target_issue.design_collection.start_copy!

      expect(subject).to be_kind_of(ServiceResponse)
      expect(subject).to be_error
      expect(subject.message).to eq('Target design collection copy state must be `ready`')
    end

    it 'sets the design collection copy state' do
      expect { subject }.to change { target_issue.design_collection.copy_state }.from('ready').to('in_progress')
    end

    it 'queues a DesignManagement::CopyDesignCollectionWorker', :clean_gitlab_redis_queues do
      expect { subject }.to change(DesignManagement::CopyDesignCollectionWorker.jobs, :size).by(1)
    end

    it 'returns success' do
      expect(subject).to be_kind_of(ServiceResponse)
      expect(subject).to be_success
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module UserPreferences
  class UpdateService < BaseService
    def initialize(user, params = {})
      @preferences = user.user_preference
      @params = params.to_h.dup.with_indifferent_access
    end

    def execute
      if @preferences.update(@params)
        ServiceResponse.success(
          message: 'Preference was updated',
          payload: { preferences: @preferences })
      else
        ServiceResponse.error(message: 'Could not update preference')
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe UserPreferences::UpdateService, feature_category: :user_profile do
  let(:user) { create(:user) }
  let(:params) { { view_diffs_file_by_file: false, pass_user_identities_to_ci_jwt: true } }

  describe '#execute' do
    subject(:service) { described_class.new(user, params) }

    context 'successfully updating the record' do
      it 'updates the preference and returns a success' do
        result = service.execute

        expect(result.status).to eq(:success)
        expect(result.payload[:preferences].view_diffs_file_by_file).to eq(params[:view_diffs_file_by_file])
        expect(result.payload[:preferences].pass_user_identities_to_ci_jwt
              ).to eq(params[:pass_user_identities_to_ci_jwt])
      end
    end

    context 'unsuccessfully updating the record' do
      before do
        allow(user.user_preference).to receive(:update).and_return(false)
      end

      it 'returns an error' do
        result = service.execute

        expect(result.status).to eq(:error)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class ValidateManualOtpService < BaseService
    include ::Gitlab::Auth::Otp::Fortinet
    include ::Gitlab::Auth::Otp::DuoAuth

    def initialize(current_user)
      @current_user = current_user
      @strategy = if forti_authenticator_enabled?(current_user)
                    ::Gitlab::Auth::Otp::Strategies::FortiAuthenticator::ManualOtp.new(current_user)
                  elsif forti_token_cloud_enabled?(current_user)
                    ::Gitlab::Auth::Otp::Strategies::FortiTokenCloud.new(current_user)
                  elsif duo_auth_enabled?(current_user)
                    ::Gitlab::Auth::Otp::Strategies::DuoAuth::ManualOtp.new(current_user)
                  else
                    ::Gitlab::Auth::Otp::Strategies::Devise.new(current_user)
                  end
    end

    def execute(otp_code)
      strategy.validate(otp_code)
    rescue StandardError => ex
      Gitlab::ErrorTracking.log_exception(ex)
      error(ex.message)
    end

    private

    attr_reader :strategy
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::ValidateManualOtpService, feature_category: :user_profile do
  let_it_be(:user) { create(:user) }

  let(:otp_code) { 42 }

  subject(:validate) { described_class.new(user).execute(otp_code) }

  context 'Devise' do
    it 'calls Devise strategy' do
      expect_next_instance_of(::Gitlab::Auth::Otp::Strategies::Devise) do |strategy|
        expect(strategy).to receive(:validate).with(otp_code).once
      end

      validate
    end
  end

  context 'FortiAuthenticator' do
    before do
      stub_feature_flags(forti_authenticator: user)
      allow(::Gitlab.config.forti_authenticator).to receive(:enabled).and_return(true)
    end

    it 'calls ManualOtp strategy' do
      expect_next_instance_of(::Gitlab::Auth::Otp::Strategies::FortiAuthenticator::ManualOtp) do |strategy|
        expect(strategy).to receive(:validate).with(otp_code).once
      end

      validate
    end

    it 'handles unexpected error' do
      error_message = ""boom!""

      expect_next_instance_of(::Gitlab::Auth::Otp::Strategies::FortiAuthenticator::ManualOtp) do |strategy|
        expect(strategy).to receive(:validate).with(otp_code).once.and_raise(StandardError, error_message)
      end
      expect(Gitlab::ErrorTracking).to receive(:log_exception)

      result = validate

      expect(result[:status]).to eq(:error)
      expect(result[:message]).to eq(error_message)
    end
  end

  context 'FortiTokenCloud' do
    before do
      stub_feature_flags(forti_token_cloud: user)
      allow(::Gitlab.config.forti_token_cloud).to receive(:enabled).and_return(true)
    end

    it 'calls FortiTokenCloud strategy' do
      expect_next_instance_of(::Gitlab::Auth::Otp::Strategies::FortiTokenCloud) do |strategy|
        expect(strategy).to receive(:validate).with(otp_code).once
      end

      validate
    end
  end

  context 'DuoAuth' do
    before do
      allow(::Gitlab.config.duo_auth).to receive(:enabled).and_return(true)
    end

    it 'calls DuoAuth strategy' do
      expect_next_instance_of(::Gitlab::Auth::Otp::Strategies::DuoAuth::ManualOtp) do |strategy|
        expect(strategy).to receive(:validate).with(otp_code).once
      end

      validate
    end

    it ""handles unexpected error"" do
      error_message = ""boom!""

      expect_next_instance_of(::Gitlab::Auth::Otp::Strategies::DuoAuth::ManualOtp) do |strategy|
        expect(strategy).to receive(:validate).with(otp_code).once.and_raise(StandardError, error_message)
      end
      expect(Gitlab::ErrorTracking).to receive(:log_exception)

      result = validate

      expect(result[:status]).to eq(:error)
      expect(result[:message]).to eq(error_message)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class ActivityService
    LEASE_TIMEOUT = 1.minute.to_i

    def initialize(author:, namespace: nil, project: nil)
      @user = if author.respond_to?(:username)
                author
              elsif author.respond_to?(:user)
                author.user
              end

      @user = nil unless user.is_a?(User)
      @namespace = namespace
      @project = project
    end

    def execute
      return unless user

      ::Gitlab::Database::LoadBalancing::Session.without_sticky_writes { record_activity }
    end

    private

    attr_reader :user, :namespace, :project

    def record_activity
      return if Gitlab::Database.read_only?

      today = Date.today
      return if user.last_activity_on == today

      lease = Gitlab::ExclusiveLease.new(""activity_service:#{user.id}"", timeout: LEASE_TIMEOUT)
      return unless lease.try_obtain

      user.update_attribute(:last_activity_on, today)

      Gitlab::UsageDataCounters::HLLRedisCounter.track_event('unique_active_user', values: user.id)

      Gitlab::Tracking.event(
        'Users::ActivityService',
        'perform_action',
        user: user,
        namespace: namespace,
        project: project,
        label: 'redis_hll_counters.manage.unique_active_users_monthly',
        context: [
          Gitlab::Tracking::ServicePingContext.new(data_source: :redis_hll, event: 'unique_active_user').to_context
        ]
      )
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::ActivityService, feature_category: :user_profile do
  include ExclusiveLeaseHelpers

  let(:user) { create(:user, last_activity_on: last_activity_on) }

  subject { described_class.new(author: user) }

  describe '#execute', :clean_gitlab_redis_shared_state do
    shared_examples 'does not update last_activity_on' do
      it 'does not update user attribute' do
        expect { subject.execute }.not_to change(user, :last_activity_on)
      end

      it 'does not track Snowplow event' do
        subject.execute

        expect_no_snowplow_event
      end
    end

    context 'when last activity is nil' do
      let(:last_activity_on) { nil }

      it 'updates last_activity_on for the user' do
        expect { subject.execute }
          .to change(user, :last_activity_on).from(last_activity_on).to(Date.today)
      end
    end

    context 'when last activity is in the past' do
      let(:last_activity_on) { Date.today - 1.week }

      it 'updates last_activity_on for the user' do
        expect { subject.execute }
          .to change(user, :last_activity_on)
                .from(last_activity_on)
                .to(Date.today)
      end

      it 'tries to obtain ExclusiveLease' do
        expect(Gitlab::ExclusiveLease).to receive(:new).with(""activity_service:#{user.id}"", anything).and_call_original

        subject.execute
      end

      it 'tracks RedisHLL event' do
        expect(Gitlab::UsageDataCounters::HLLRedisCounter)
          .to receive(:track_event)
          .with('unique_active_user', values: user.id)

        subject.execute
      end

      it_behaves_like 'Snowplow event tracking with RedisHLL context' do
        subject(:record_activity) { described_class.new(author: user, namespace: namespace, project: project).execute }

        let(:category) { described_class.name }
        let(:action) { 'perform_action' }
        let(:label) { 'redis_hll_counters.manage.unique_active_users_monthly' }
        let(:namespace) { build(:group) }
        let(:project) { build(:project) }
        let(:context) do
          payload = Gitlab::Tracking::ServicePingContext.new(
            data_source: :redis_hll,
            event: 'unique_active_user'
          ).to_context

          [Gitlab::Json.dump(payload)]
        end
      end
    end

    context 'when a bad object is passed' do
      let(:fake_object) { double(username: 'hello') }

      it 'does not record activity' do
        service = described_class.new(author: fake_object)

        expect(service).not_to receive(:record_activity)

        service.execute
      end
    end

    context 'when last activity is today' do
      let(:last_activity_on) { Date.today }

      it_behaves_like 'does not update last_activity_on'

      it 'does not try to obtain ExclusiveLease' do
        expect(Gitlab::ExclusiveLease).not_to receive(:new).with(""activity_service:#{user.id}"", anything)

        subject.execute
      end
    end

    context 'when in GitLab read-only instance' do
      let(:last_activity_on) { nil }

      before do
        allow(Gitlab::Database).to receive(:read_only?).and_return(true)
      end

      it_behaves_like 'does not update last_activity_on'
    end

    context 'when a lease could not be obtained' do
      let(:last_activity_on) { nil }

      before do
        stub_exclusive_lease_taken(""activity_service:#{user.id}"", timeout: 1.minute.to_i)
      end

      it_behaves_like 'does not update last_activity_on'
    end
  end

  context 'with DB Load Balancing' do
    let(:user) { create(:user, last_activity_on: last_activity_on) }

    context 'when last activity is in the past' do
      let(:user) { create(:user, last_activity_on: Date.today - 1.week) }

      context 'database load balancing is configured' do
        before do
          ::Gitlab::Database::LoadBalancing::Session.clear_session
        end

        let(:service) do
          service = described_class.new(author: user)

          ::Gitlab::Database::LoadBalancing::Session.clear_session

          service
        end

        it 'does not stick to primary' do
          expect(::Gitlab::Database::LoadBalancing::Session.current).not_to be_performed_write

          service.execute

          expect(user.last_activity_on).to eq(Date.today)
          expect(::Gitlab::Database::LoadBalancing::Session.current).to be_performed_write
          expect(::Gitlab::Database::LoadBalancing::Session.current).not_to be_using_primary
        end
      end

      context 'database load balancing is not configured' do
        let(:service) { described_class.new(author: user) }

        it 'updates user without error' do
          service.execute

          expect(user.last_activity_on).to eq(Date.today)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class SetNamespaceCommitEmailService
    include Gitlab::Allowable

    attr_reader :current_user, :target_user, :namespace, :email_id

    def initialize(current_user, namespace, email_id, params)
      @current_user = current_user
      @target_user = params.delete(:user) || current_user
      @namespace = namespace
      @email_id = email_id
    end

    def execute
      return error(_('Namespace must be provided.')) if namespace.nil?

      unless can?(current_user, :admin_user_email_address, target_user)
        return error(_(""User doesn't exist or you don't have permission to change namespace commit emails.""))
      end

      unless can?(target_user, :read_namespace_via_membership, namespace)
        return error(_(""Namespace doesn't exist or you don't have permission.""))
      end

      email = target_user.emails.find_by(id: email_id) unless email_id.nil? # rubocop: disable CodeReuse/ActiveRecord
      existing_namespace_commit_email = target_user.namespace_commit_email_for_namespace(namespace)
      if existing_namespace_commit_email.nil?
        return error(_('Email must be provided.')) if email.nil?

        create_namespace_commit_email(email)
      elsif email_id.nil?
        remove_namespace_commit_email(existing_namespace_commit_email)
      else
        update_namespace_commit_email(existing_namespace_commit_email, email)
      end
    end

    private

    def remove_namespace_commit_email(namespace_commit_email)
      namespace_commit_email.destroy
      success(nil)
    end

    def create_namespace_commit_email(email)
      namespace_commit_email = ::Users::NamespaceCommitEmail.new(
        user: target_user,
        namespace: namespace,
        email: email
      )

      save_namespace_commit_email(namespace_commit_email)
    end

    def update_namespace_commit_email(namespace_commit_email, email)
      namespace_commit_email.email = email

      save_namespace_commit_email(namespace_commit_email)
    end

    def save_namespace_commit_email(namespace_commit_email)
      if !namespace_commit_email.save
        error_in_save(namespace_commit_email)
      else
        success(namespace_commit_email)
      end
    end

    def success(namespace_commit_email)
      ServiceResponse.success(payload: {
        namespace_commit_email: namespace_commit_email
      })
    end

    def error(message)
      ServiceResponse.error(message: message)
    end

    def error_in_save(namespace_commit_email)
      return error(_('Failed to save namespace commit email.')) if namespace_commit_email.errors.empty?

      error(namespace_commit_email.errors.full_messages.to_sentence)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::SetNamespaceCommitEmailService, feature_category: :user_profile do
  include AfterNextHelpers

  let_it_be(:user) { create(:user) }
  let_it_be(:group) { create(:group) }
  let_it_be(:email) { create(:email, user: user) }
  let_it_be(:existing_achievement) { create(:achievement, namespace: group) }

  let(:namespace) { group }
  let(:current_user) { user }
  let(:target_user) { user }
  let(:email_id) { email.id }
  let(:params) { { user: target_user } }
  let(:service) { described_class.new(current_user, namespace, email_id, params) }

  before_all do
    group.add_reporter(user)
  end

  shared_examples 'success' do
    it 'creates namespace commit email' do
      result = service.execute

      expect(result.payload[:namespace_commit_email]).to be_a(Users::NamespaceCommitEmail)
      expect(result.payload[:namespace_commit_email]).to be_persisted
    end
  end

  describe '#execute' do
    context 'when current_user is not provided' do
      let(:current_user) { nil }

      it 'returns error message' do
        expect(service.execute.message)
          .to eq(""User doesn't exist or you don't have permission to change namespace commit emails."")
      end
    end

    context 'when current_user does not have permission to change namespace commit emails' do
      let(:target_user) { create(:user) }

      it 'returns error message' do
        expect(service.execute.message)
          .to eq(""User doesn't exist or you don't have permission to change namespace commit emails."")
      end
    end

    context 'when target_user does not have permission to access the namespace' do
      let(:namespace) { create(:group) }

      it 'returns error message' do
        expect(service.execute.message).to eq(""Namespace doesn't exist or you don't have permission."")
      end
    end

    context 'when namespace is not provided' do
      let(:namespace) { nil }

      it 'returns error message' do
        expect(service.execute.message).to eq('Namespace must be provided.')
      end
    end

    context 'when target user is not current user' do
      context 'when current user is an admin' do
        let(:current_user) { create(:user, :admin) }

        context 'when admin mode is enabled', :enable_admin_mode do
          it 'creates namespace commit email' do
            result = service.execute

            expect(result.payload[:namespace_commit_email]).to be_a(Users::NamespaceCommitEmail)
            expect(result.payload[:namespace_commit_email]).to be_persisted
          end
        end

        context 'when admin mode is not enabled' do
          it 'returns error message' do
            expect(service.execute.message)
              .to eq(""User doesn't exist or you don't have permission to change namespace commit emails."")
          end
        end
      end

      context 'when current user is not an admin' do
        let(:current_user) { create(:user) }

        it 'returns error message' do
          expect(service.execute.message)
            .to eq(""User doesn't exist or you don't have permission to change namespace commit emails."")
        end
      end
    end

    context 'when namespace commit email does not exist' do
      context 'when email_id is not provided' do
        let(:email_id) { nil }

        it 'returns error message' do
          expect(service.execute.message).to eq('Email must be provided.')
        end
      end

      context 'when model save fails' do
        before do
          allow_next(::Users::NamespaceCommitEmail).to receive(:save).and_return(false)
        end

        it 'returns error message' do
          expect(service.execute.message).to eq('Failed to save namespace commit email.')
        end
      end

      context 'when namepsace is a group' do
        it_behaves_like 'success'
      end

      context 'when namespace is a user' do
        let(:namespace) { current_user.namespace }

        it_behaves_like 'success'
      end

      context 'when namespace is a project' do
        let_it_be(:project) { create(:project) }

        let(:namespace) { project.project_namespace }

        before do
          project.add_reporter(current_user)
        end

        it_behaves_like 'success'
      end
    end

    context 'when namespace commit email already exists' do
      let!(:existing_namespace_commit_email) do
        create(:namespace_commit_email,
          user: target_user,
          namespace: namespace,
          email: create(:email, user: target_user))
      end

      context 'when email_id is not provided' do
        let(:email_id) { nil }

        it 'destroys the namespace commit email' do
          result = service.execute

          expect(result.message).to be_nil
          expect(result.payload[:namespace_commit_email]).to be_nil
        end
      end

      context 'and email_id is provided' do
        let(:email_id) { create(:email, user: current_user).id }

        it 'updates namespace commit email' do
          result = service.execute

          existing_namespace_commit_email.reload

          expect(result.payload[:namespace_commit_email]).to eq(existing_namespace_commit_email)
          expect(existing_namespace_commit_email.email_id).to eq(email_id)
        end
      end

      context 'when model save fails' do
        before do
          allow_any_instance_of(::Users::NamespaceCommitEmail).to receive(:save).and_return(false) # rubocop:disable RSpec/AnyInstanceOf
        end

        it 'returns generic error message' do
          expect(service.execute.message).to eq('Failed to save namespace commit email.')
        end

        context 'with model errors' do
          before do
            allow_any_instance_of(::Users::NamespaceCommitEmail).to receive_message_chain(:errors, :empty?).and_return(false) # rubocop:disable RSpec/AnyInstanceOf
            allow_any_instance_of(::Users::NamespaceCommitEmail).to receive_message_chain(:errors, :full_messages, :to_sentence).and_return('Model error') # rubocop:disable RSpec/AnyInstanceOf
          end

          it 'returns the model error message' do
            expect(service.execute.message).to eq('Model error')
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class BannedUserBaseService < BaseService
    def initialize(current_user)
      @current_user = current_user
    end

    def execute(user)
      return permission_error unless allowed?
      return state_error(user) unless valid_state?(user)

      if update_user(user)
        log_event(user)
        track_event(user)
        success
      else
        messages = user.errors.full_messages
        error(messages.uniq.join('. '))
      end
    end

    private

    attr_reader :current_user

    # Overridden in Users::BanService
    def track_event(_); end

    def state_error(user)
      error(_(""You cannot %{action} %{state} users."" % { action: action.to_s, state: user.state }), :forbidden)
    end

    def allowed?
      can?(current_user, :admin_all_resources)
    end

    def permission_error
      error(_(""You are not allowed to %{action} a user"" % { action: action.to_s }), :forbidden)
    end

    def log_event(user)
      Gitlab::AppLogger.info(message: ""User #{action}"", user: user.username.to_s, email: user.email.to_s, ""#{action}_by"": current_user.username.to_s, ip_address: current_user.current_sign_in_ip.to_s)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::BannedUserBaseService, feature_category: :user_management do
  let(:admin) { create(:admin) }
  let(:base_service) { described_class.new(admin) }

  describe '#initialize' do
    it 'sets the current_user instance value' do
      expect(base_service.instance_values[""current_user""]).to eq(admin)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class TrustService < BaseService
    def initialize(current_user)
      @current_user = current_user
    end

    def execute(user)
      UserCustomAttribute.set_trusted_by(user: user, trusted_by: @current_user)
      success
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::TrustService, feature_category: :user_management do
  let_it_be(:current_user) { create(:admin) }

  subject(:service) { described_class.new(current_user) }

  describe '#execute' do
    let(:user) { create(:user) }

    subject(:operation) { service.execute(user) }

    it 'updates the custom attributes', :aggregate_failures do
      expect(user.custom_attributes).to be_empty

      operation
      user.reload

      expect(user.custom_attributes.by_key(UserCustomAttribute::TRUSTED_BY)).to be_present
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class BlockService < BaseService
    def initialize(current_user)
      @current_user = current_user
    end

    def execute(user)
      return error('An internal user cannot be blocked', 403) if user.internal?

      if user.block
        after_block_hook(user)
        success
      else
        messages = user.errors.full_messages
        error(messages.uniq.join('. '))
      end
    end

    private

    # overridden by EE module
    def after_block_hook(user)
      custom_attribute = {
        user_id: user.id,
        key: UserCustomAttribute::BLOCKED_BY,
        value: ""#{current_user.username}/#{current_user.id}+#{Time.current}""
      }
      UserCustomAttribute.upsert_custom_attributes([custom_attribute])
    end
  end
end

Users::BlockService.prepend_mod_with('Users::BlockService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::BlockService, feature_category: :user_management do
  let_it_be(:current_user) { create(:admin) }

  subject(:service) { described_class.new(current_user) }

  describe '#execute' do
    subject(:operation) { service.execute(user) }

    context 'when successful' do
      let(:user) { create(:user) }

      it { is_expected.to eq(status: :success) }

      it ""change the user's state"" do
        expect { operation }.to change { user.state }.to('blocked')
      end

      it 'saves a custom attribute', :aggregate_failures, :freeze_time, feature_category: :insider_threat do
        operation

        custom_attribute = user.custom_attributes.last

        expect(custom_attribute.key).to eq(UserCustomAttribute::BLOCKED_BY)
        expect(custom_attribute.value).to eq(""#{current_user.username}/#{current_user.id}+#{Time.current}"")
      end
    end

    context 'when failed' do
      let(:user) { create(:user, :blocked) }

      it 'returns error result' do
        aggregate_failures 'error result' do
          expect(operation[:status]).to eq(:error)
          expect(operation[:message]).to match(/State cannot transition/)
        end
      end

      it ""does not change the user's state"" do
        expect { operation }.not_to change { user.state }
      end
    end

    context 'when internal user' do
      let(:user) { create(:user, :bot) }

      it 'returns error result' do
        expect(operation[:status]).to eq(:error)
        expect(operation[:message]).to eq('An internal user cannot be blocked')
        expect(operation[:http_status]).to eq(403)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  # Service for refreshing the authorized projects of a user.
  #
  # This particular service class can not be used to update data for the same
  # user concurrently. Doing so could lead to an incorrect state. To ensure this
  # doesn't happen a caller must synchronize access (e.g. using
  # `Gitlab::ExclusiveLease`).
  #
  # Usage:
  #
  #     user = User.find_by(username: 'alice')
  #     service = Users::RefreshAuthorizedProjectsService.new(some_user)
  #     service.execute
  class RefreshAuthorizedProjectsService
    attr_reader :user, :source

    LEASE_TIMEOUT = 1.minute.to_i

    # user - The User for which to refresh the authorized projects.
    def initialize(user, source: nil, incorrect_auth_found_callback: nil, missing_auth_found_callback: nil)
      @user = user
      @source = source
      @incorrect_auth_found_callback = incorrect_auth_found_callback
      @missing_auth_found_callback = missing_auth_found_callback
    end

    def execute
      lease_key = ""refresh_authorized_projects:#{user.id}""
      lease = Gitlab::ExclusiveLease.new(lease_key, timeout: LEASE_TIMEOUT)

      until uuid = lease.try_obtain
        # Keep trying until we obtain the lease. If we don't do so we may end up
        # not updating the list of authorized projects properly. To prevent
        # hammering Redis too much we'll wait for a bit between retries.
        sleep(0.1)
      end

      begin
        # We need an up to date User object that has access to all relations that
        # may have been created earlier. The only way to ensure this is to reload
        # the User object.
        user.reset
        execute_without_lease
      ensure
        Gitlab::ExclusiveLease.cancel(lease_key, uuid)
      end
    end

    # This method returns the updated User object.
    def execute_without_lease
      remove, add = AuthorizedProjectUpdate::FindRecordsDueForRefreshService.new(
        user,
        source: source,
        incorrect_auth_found_callback: incorrect_auth_found_callback,
        missing_auth_found_callback: missing_auth_found_callback
      ).execute

      update_authorizations(remove, add)
    end

    # Updates the list of authorizations for the current user.
    #
    # remove - The project IDs of the authorization rows to remove.
    # add - Rows to insert in the form `[{ user_id: user_id, project_id: project_id, access_level: access_level}, ...]`
    def update_authorizations(remove = [], add = [])
      log_refresh_details(remove, add)

      ProjectAuthorizations::Changes.new do |changes|
        changes.add(add)
        changes.remove_projects_for_user(user, remove)
      end.apply!

      user.update!(project_authorizations_recalculated_at: Time.zone.now) if remove.any? || add.any?

      # Since we batch insert authorization rows, Rails' associations may get
      # out of sync. As such we force a reload of the User object.
      user.reset
    end

    private

    attr_reader :incorrect_auth_found_callback, :missing_auth_found_callback

    def log_refresh_details(remove, add)
      Gitlab::AppJsonLogger.info(
        event: 'authorized_projects_refresh',
        user_id: user.id,
        'authorized_projects_refresh.source': source,
        'authorized_projects_refresh.rows_deleted_count': remove.length,
        'authorized_projects_refresh.rows_added_count': add.length,
        # most often there's only a few entries in remove and add, but limit it to the first 5
        # entries to avoid flooding the logs
        'authorized_projects_refresh.rows_deleted_slice': remove.first(5),
        'authorized_projects_refresh.rows_added_slice': add.first(5).map(&:values)
      )
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::RefreshAuthorizedProjectsService, feature_category: :user_management do
  include ExclusiveLeaseHelpers

  # We're using let! here so that any expectations for the service class are not
  # triggered twice.
  let!(:project) { create(:project) }

  let(:user) { project.namespace.first_owner }
  let(:service) { described_class.new(user) }

  describe '#execute', :clean_gitlab_redis_shared_state do
    it 'refreshes the authorizations using a lease' do
      lease_key = ""refresh_authorized_projects:#{user.id}""

      expect_to_obtain_exclusive_lease(lease_key, 'uuid')
      expect_to_cancel_exclusive_lease(lease_key, 'uuid')
      expect(service).to receive(:execute_without_lease)

      service.execute
    end

    context 'callbacks' do
      let(:callback) { double('callback') }

      context 'incorrect_auth_found_callback callback' do
        let(:user) { create(:user) }
        let(:service) do
          described_class.new(user, incorrect_auth_found_callback: callback)
        end

        it 'is called' do
          access_level = Gitlab::Access::DEVELOPER
          create(:project_authorization, user: user, project: project, access_level: access_level)

          expect(callback).to receive(:call).with(project.id, access_level).once

          service.execute
        end
      end

      context 'missing_auth_found_callback callback' do
        let(:service) do
          described_class.new(user, missing_auth_found_callback: callback)
        end

        it 'is called' do
          ProjectAuthorization.delete_all

          expect(callback).to receive(:call).with(project.id, Gitlab::Access::OWNER).once

          service.execute
        end
      end
    end
  end

  describe '#execute_without_lease' do
    before do
      user.project_authorizations.delete_all
    end

    it 'updates the authorized projects of the user' do
      project2 = create(:project)
      project_authorization = user.project_authorizations
        .create!(project: project2, access_level: Gitlab::Access::MAINTAINER)

      to_be_removed = [project_authorization.project_id]

      to_be_added = [
        { user_id: user.id, project_id: project.id, access_level: Gitlab::Access::OWNER }
      ]

      expect(service).to receive(:update_authorizations)
        .with(to_be_removed, to_be_added)

      service.execute_without_lease
    end

    it 'sets the access level of a project to the highest available level' do
      user.project_authorizations.delete_all

      project_authorization = user.project_authorizations
        .create!(project: project, access_level: Gitlab::Access::DEVELOPER)

      to_be_removed = [project_authorization.project_id]

      to_be_added = [
        { user_id: user.id, project_id: project.id, access_level: Gitlab::Access::OWNER }
      ]

      expect(service).to receive(:update_authorizations)
        .with(to_be_removed, to_be_added)

      service.execute_without_lease
    end

    it 'updates project_authorizations_recalculated_at', :freeze_time do
      default_date = Time.zone.local('2010')
      expect do
        service.execute_without_lease
      end.to change { user.project_authorizations_recalculated_at }.from(default_date).to(Time.zone.now)
    end

    it 'returns a User' do
      expect(service.execute_without_lease).to be_an_instance_of(User)
    end
  end

  describe '#update_authorizations' do
    context 'when there are no rows to add and remove' do
      it 'does not change authorizations' do
        expect { service.update_authorizations([], []) }.to not_change { user.project_authorizations.count }
      end
    end

    it 'removes authorizations that should be removed' do
      authorization = user.project_authorizations.find_by(project_id: project.id)

      service.update_authorizations([authorization.project_id])

      expect(user.project_authorizations).to be_empty
    end

    it 'inserts authorizations that should be added' do
      user.project_authorizations.delete_all

      to_be_added = [
        { user_id: user.id, project_id: project.id, access_level: Gitlab::Access::MAINTAINER }
      ]

      service.update_authorizations([], to_be_added)

      authorizations = user.project_authorizations

      expect(authorizations.length).to eq(1)
      expect(authorizations[0].user_id).to eq(user.id)
      expect(authorizations[0].project_id).to eq(project.id)
      expect(authorizations[0].access_level).to eq(Gitlab::Access::MAINTAINER)
    end

    it 'logs the details of the refresh' do
      source = :foo
      service = described_class.new(user, source: source)
      user.project_authorizations.delete_all

      expect(Gitlab::AppJsonLogger).to(
        receive(:info).with(
          event: 'authorized_projects_refresh',
          user_id: user.id,
          'authorized_projects_refresh.source': source,
          'authorized_projects_refresh.rows_deleted_count': 0,
          'authorized_projects_refresh.rows_added_count': 1,
          'authorized_projects_refresh.rows_deleted_slice': [],
          'authorized_projects_refresh.rows_added_slice': [[user.id, project.id, Gitlab::Access::MAINTAINER]]
        )
      )

      to_be_added = [
        { user_id: user.id, project_id: project.id, access_level: Gitlab::Access::MAINTAINER }
      ]

      service.update_authorizations([], to_be_added)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# When a user is destroyed, some of their associated records are
# moved to a ""Ghost User"", to prevent these associated records from
# being destroyed.
#
# For example, all the issues/MRs a user has created are _not_ destroyed
# when the user is destroyed.
module Users
  class MigrateRecordsToGhostUserService
    extend ActiveSupport::Concern

    DestroyError = Class.new(StandardError)

    attr_reader :ghost_user, :user, :initiator_user, :hard_delete

    def initialize(user, initiator_user, execution_tracker)
      @user = user
      @initiator_user = initiator_user
      @execution_tracker = execution_tracker
      @ghost_user = Users::Internal.ghost
    end

    def execute(hard_delete: false)
      @hard_delete = hard_delete

      migrate_records
      post_migrate_records
    end

    private

    attr_reader :execution_tracker

    def migrate_records
      migrate_user_achievements

      return if hard_delete

      migrate_issues
      migrate_merge_requests
      migrate_notes
      migrate_abuse_reports
      migrate_award_emoji
      migrate_snippets
      migrate_reviews
      migrate_releases
    end

    def post_migrate_records
      delete_snippets

      # Rails attempts to load all related records into memory before
      # destroying: https://github.com/rails/rails/issues/22510
      # This ensures we delete records in batches.
      user.destroy_dependent_associations_in_batches(exclude: [:snippets])
      user.nullify_dependent_associations_in_batches

      # Destroy the namespace after destroying the user since certain methods may depend on the namespace existing
      user_data = user.destroy
      user.namespace.destroy

      user_data
    end

    def delete_snippets
      response = Snippets::BulkDestroyService.new(initiator_user, user.snippets).execute(skip_authorization: true)
      raise DestroyError, response.message if response.error?
    end

    def migrate_issues
      batched_migrate(Issue, :author_id)
      batched_migrate(Issue, :last_edited_by_id)
    end

    def migrate_merge_requests
      batched_migrate(MergeRequest, :author_id)
      batched_migrate(MergeRequest, :merge_user_id)
    end

    def migrate_notes
      batched_migrate(Note, :author_id)
    end

    def migrate_abuse_reports
      user.reported_abuse_reports.update_all(reporter_id: ghost_user.id)
    end

    def migrate_award_emoji
      user.award_emoji.update_all(user_id: ghost_user.id)
    end

    def migrate_snippets
      snippets = user.snippets.only_project_snippets
      snippets.update_all(author_id: ghost_user.id)
    end

    def migrate_reviews
      batched_migrate(Review, :author_id)
    end

    def migrate_releases
      batched_migrate(Release, :author_id)
    end

    def migrate_user_achievements
      batched_migrate(Achievements::UserAchievement, :awarded_by_user_id)
      batched_migrate(Achievements::UserAchievement, :revoked_by_user_id)
    end

    # rubocop:disable CodeReuse/ActiveRecord
    def batched_migrate(base_scope, column, batch_size: 50)
      loop do
        update_count = base_scope.where(column => user.id).limit(batch_size).update_all(column => ghost_user.id)
        break if update_count == 0
        raise Gitlab::Utils::ExecutionTracker::ExecutionTimeOutError if execution_tracker.over_limit?
      end
    end
    # rubocop:enable CodeReuse/ActiveRecord
  end
end

Users::MigrateRecordsToGhostUserService.prepend_mod_with('Users::MigrateRecordsToGhostUserService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::MigrateRecordsToGhostUserService, feature_category: :user_management do
  include BatchDestroyDependentAssociationsHelper

  let!(:user) { create(:user) }
  let(:service) { described_class.new(user, admin, execution_tracker) }
  let(:execution_tracker) { instance_double(::Gitlab::Utils::ExecutionTracker, over_limit?: false) }

  let_it_be(:admin) { create(:admin) }
  let_it_be(:project) { create(:project, :repository) }

  context ""when migrating a user's associated records to the ghost user"" do
    context 'for issues' do
      context 'when deleted user is present as both author and edited_user' do
        include_examples 'migrating records to the ghost user', Issue, [:author, :last_edited_by] do
          let(:created_record) do
            create(:issue, project: project, author: user, last_edited_by: user)
          end
        end
      end

      context 'when deleted user is present only as edited_user' do
        include_examples 'migrating records to the ghost user', Issue, [:last_edited_by] do
          let(:created_record) { create(:issue, project: project, author: create(:user), last_edited_by: user) }
        end
      end

      context ""when deleted user is the assignee"" do
        let!(:issue) { create(:issue, project: project, assignees: [user]) }

        it 'migrates the issue so that it is ""Unassigned""' do
          service.execute

          migrated_issue = Issue.find_by_id(issue.id)
          expect(migrated_issue).to be_present
          expect(migrated_issue.assignees).to be_empty
        end
      end
    end

    context 'for merge requests' do
      context 'when deleted user is present as both author and merge_user' do
        include_examples 'migrating records to the ghost user', MergeRequest, [:author, :merge_user] do
          let(:created_record) do
            create(
              :merge_request,
              source_project: project,
              author: user,
              merge_user: user,
              target_branch: ""first""
            )
          end
        end
      end

      context 'when deleted user is present only as both merge_user' do
        include_examples 'migrating records to the ghost user', MergeRequest, [:merge_user] do
          let(:created_record) do
            create(
              :merge_request,
              source_project: project,
              merge_user: user,
              target_branch: ""first""
            )
          end
        end
      end

      context ""when deleted user is the assignee"" do
        let!(:merge_request) { create(:merge_request, source_project: project, assignees: [user]) }

        it 'migrates the merge request so that it is ""Unassigned""' do
          service.execute

          migrated_merge_request = MergeRequest.find_by_id(merge_request.id)
          expect(migrated_merge_request).to be_present
          expect(migrated_merge_request.assignees).to be_empty
        end
      end
    end

    context 'for notes' do
      include_examples 'migrating records to the ghost user', Note do
        let(:created_record) { create(:note, project: project, author: user) }
      end
    end

    context 'for abuse reports' do
      include_examples 'migrating records to the ghost user', AbuseReport do
        let(:created_record) { create(:abuse_report, reporter: user, user: create(:user)) }
      end
    end

    context 'for award emoji' do
      include_examples 'migrating records to the ghost user', AwardEmoji, [:user] do
        let(:created_record) { create(:award_emoji, user: user) }

        context ""when the awardable already has an award emoji of the same name assigned to the ghost user"" do
          let(:awardable) { create(:issue) }

          let!(:existing_award_emoji) do
            create(:award_emoji, user: Users::Internal.ghost, name: ""thumbsup"", awardable: awardable)
          end

          let!(:award_emoji) { create(:award_emoji, user: user, name: ""thumbsup"", awardable: awardable) }

          it ""migrates the award emoji regardless"" do
            service.execute

            migrated_record = AwardEmoji.find_by_id(award_emoji.id)

            expect(migrated_record.user).to eq(Users::Internal.ghost)
          end

          it ""does not leave the migrated award emoji in an invalid state"" do
            service.execute

            migrated_record = AwardEmoji.find_by_id(award_emoji.id)

            expect(migrated_record).to be_valid
          end
        end
      end
    end

    context 'for snippets' do
      include_examples 'migrating records to the ghost user', Snippet do
        let(:created_record) { create(:snippet, project: project, author: user) }
      end
    end

    context 'for reviews' do
      include_examples 'migrating records to the ghost user', Review, [:author] do
        let(:created_record) { create(:review, author: user) }
      end
    end

    context 'for releases' do
      include_examples 'migrating records to the ghost user', Release, [:author] do
        let(:created_record) { create(:release, author: user) }
      end
    end

    context 'for user achievements' do
      include_examples 'migrating records to the ghost user', Achievements::UserAchievement,
        [:awarded_by_user, :revoked_by_user] do
        let(:created_record) { create(:user_achievement, awarded_by_user: user, revoked_by_user: user) }
      end
    end
  end

  context 'on post-migrate cleanups' do
    it 'destroys the user and personal namespace' do
      namespace = user.namespace

      allow(user).to receive(:destroy).and_call_original

      service.execute

      expect { User.find(user.id) }.to raise_error(ActiveRecord::RecordNotFound)
      expect { Namespace.find(namespace.id) }.to raise_error(ActiveRecord::RecordNotFound)
    end

    it 'deletes user associations in batches' do
      expect(user).to receive(:destroy_dependent_associations_in_batches)

      service.execute
    end

    context 'for batched nullify' do
      # rubocop:disable Layout/LineLength
      def nullify_in_batches_regexp(table, column, user, batch_size: 100)
        %r{^UPDATE ""#{table}"" SET ""#{column}"" = NULL WHERE ""#{table}"".""id"" IN \(SELECT ""#{table}"".""id"" FROM ""#{table}"" WHERE ""#{table}"".""#{column}"" = #{user.id} LIMIT #{batch_size}\)}
      end
      # rubocop:enable Layout/LineLength

      it 'nullifies related associations in batches' do
        expect(user).to receive(:nullify_dependent_associations_in_batches).and_call_original

        service.execute
      end

      it 'nullifies associations marked as `dependent: :nullify` and'\
         'destroys the associations marked as `dependent: :destroy`, in batches', :aggregate_failures do
        # associations to be nullified
        issue = create(:issue, closed_by: user, updated_by: user)
        resource_label_event = create(:resource_label_event, user: user)
        resource_state_event = create(:resource_state_event, user: user)
        created_project = create(:project, creator: user)

        # associations to be destroyed
        todos = create_list(:todo, 2, project: issue.project, user: user, author: user, target: issue)
        event = create(:event, project: issue.project, author: user)

        query_recorder = ActiveRecord::QueryRecorder.new do
          service.execute
        end

        issue.reload
        resource_label_event.reload
        resource_state_event.reload
        created_project.reload

        expect(issue.closed_by).to be_nil
        expect(issue.updated_by_id).to be_nil
        expect(resource_label_event.user_id).to be_nil
        expect(resource_state_event.user_id).to be_nil
        expect(created_project.creator_id).to be_nil
        expect(user.authored_todos).to be_empty
        expect(user.todos).to be_empty
        expect(user.authored_events).to be_empty

        expected_queries = [
          nullify_in_batches_regexp(:issues, :updated_by_id, user),
          nullify_in_batches_regexp(:issues, :closed_by_id, user),
          nullify_in_batches_regexp(:resource_label_events, :user_id, user),
          nullify_in_batches_regexp(:resource_state_events, :user_id, user),
          nullify_in_batches_regexp(:projects, :creator_id, user)
        ]

        expected_queries += delete_in_batches_regexps(:todos, :user_id, user, todos)
        expected_queries += delete_in_batches_regexps(:todos, :author_id, user, todos)
        expected_queries += delete_in_batches_regexps(:events, :author_id, user, [event])

        expect(query_recorder.log).to include(*expected_queries)
      end

      it 'nullifies merge request associations', :aggregate_failures do
        merge_request = create(
          :merge_request,
          source_project: project,
          target_project: project,
          assignee: user,
          updated_by: user,
          merge_user: user
        )
        merge_request.metrics.update!(merged_by: user, latest_closed_by: user)
        merge_request.reviewers = [user]
        merge_request.assignees = [user]

        query_recorder = ActiveRecord::QueryRecorder.new do
          service.execute
        end

        merge_request.reload

        expect(merge_request.updated_by).to be_nil
        expect(merge_request.assignee).to be_nil
        expect(merge_request.assignee_id).to be_nil
        expect(merge_request.metrics.merged_by).to be_nil
        expect(merge_request.metrics.latest_closed_by).to be_nil
        expect(merge_request.reviewers).to be_empty
        expect(merge_request.assignees).to be_empty

        expected_queries = [
          nullify_in_batches_regexp(:merge_requests, :updated_by_id, user),
          nullify_in_batches_regexp(:merge_requests, :assignee_id, user),
          nullify_in_batches_regexp(:merge_request_metrics, :merged_by_id, user),
          nullify_in_batches_regexp(:merge_request_metrics, :latest_closed_by_id, user)
        ]

        expected_queries += delete_in_batches_regexps(
          :merge_request_assignees,
          :user_id,
          user,
          merge_request.assignees
        )
        expected_queries += delete_in_batches_regexps(
          :merge_request_reviewers,
          :user_id,
          user,
          merge_request.reviewers
        )

        expect(query_recorder.log).to include(*expected_queries)
      end
    end

    context 'for snippets' do
      let(:gitlab_shell) { Gitlab::Shell.new }

      it 'does not include snippets when deleting in batches' do
        expect(user).to receive(:destroy_dependent_associations_in_batches).with({ exclude: [:snippets] })

        service.execute
      end

      it 'calls the bulk snippet destroy service for the user personal snippets' do
        repo1 = create(:personal_snippet, :repository, author: user).snippet_repository
        repo2 = create(:project_snippet, :repository, project: project, author: user).snippet_repository

        aggregate_failures do
          expect(gitlab_shell.repository_exists?(repo1.shard_name, ""#{repo1.disk_path}.git"")).to be(true)
          expect(gitlab_shell.repository_exists?(repo2.shard_name, ""#{repo2.disk_path}.git"")).to be(true)
        end

        # Call made when destroying user personal projects
        expect(Snippets::BulkDestroyService).not_to(
          receive(:new).with(admin, project.snippets).and_call_original)

        # Call to remove user personal snippets and for
        # project snippets where projects are not user personal
        # ones
        expect(Snippets::BulkDestroyService).to(
          receive(:new).with(admin, user.snippets.only_personal_snippets).and_call_original)

        service.execute

        aggregate_failures do
          expect(gitlab_shell.repository_exists?(repo1.shard_name, ""#{repo1.disk_path}.git"")).to be(false)
          expect(gitlab_shell.repository_exists?(repo2.shard_name, ""#{repo2.disk_path}.git"")).to be(true)
        end
      end

      it 'calls the bulk snippet destroy service with hard delete option if it is present' do
        # this avoids getting into Projects::DestroyService as it would
        # call Snippets::BulkDestroyService first!
        allow(user).to receive(:personal_projects).and_return([])

        expect_next_instance_of(Snippets::BulkDestroyService) do |bulk_destroy_service|
          expect(bulk_destroy_service).to receive(:execute).with({ skip_authorization: true }).and_call_original
        end

        service.execute(hard_delete: true)
      end

      it 'does not delete project snippets that the user is the author of' do
        repo = create(:project_snippet, :repository, author: user).snippet_repository

        service.execute

        expect(gitlab_shell.repository_exists?(repo.shard_name, ""#{repo.disk_path}.git"")).to be(true)
        expect(Users::Internal.ghost.snippets).to include(repo.snippet)
      end

      context 'when an error is raised deleting snippets' do
        it 'does not delete user' do
          snippet = create(:personal_snippet, :repository, author: user)

          bulk_service = double
          allow(Snippets::BulkDestroyService).to receive(:new).and_call_original
          allow(Snippets::BulkDestroyService).to receive(:new).with(admin, user.snippets).and_return(bulk_service)
          allow(bulk_service).to receive(:execute).and_return(ServiceResponse.error(message: 'foo'))

          aggregate_failures do
            expect { service.execute }.to(
              raise_error(Users::MigrateRecordsToGhostUserService::DestroyError, 'foo'))
            expect(snippet.reload).not_to be_nil
            expect(
              gitlab_shell.repository_exists?(snippet.repository_storage, ""#{snippet.disk_path}.git"")
            ).to be(true)
          end
        end
      end
    end

    context 'when hard_delete option is given' do
      it 'will not ghost certain records' do
        issue = create(:issue, author: user)

        service.execute(hard_delete: true)

        expect(Issue).not_to exist(issue.id)
      end

      it 'migrates awarded and revoked fields of user achievements' do
        user_achievement = create(:user_achievement, awarded_by_user: user, revoked_by_user: user)

        service.execute(hard_delete: true)
        user_achievement.reload

        expect(user_achievement.revoked_by_user).to eq(Users::Internal.ghost)
        expect(user_achievement.awarded_by_user).to eq(Users::Internal.ghost)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class AuthorizedBuildService < BuildService
    extend ::Gitlab::Utils::Override

    private

    override :validate_access!
    def validate_access!
      # no-op
    end

    def signup_params
      super + [:skip_confirmation, :external]
    end
  end
end

Users::AuthorizedBuildService.prepend_mod_with('Users::AuthorizedBuildService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::AuthorizedBuildService, feature_category: :user_management do
  describe '#execute' do
    let_it_be(:current_user) { create(:user) }

    let(:params) { build_stubbed(:user).slice(:first_name, :last_name, :username, :email, :password) }

    subject(:user) { described_class.new(current_user, params).execute }

    it_behaves_like 'common user build items'
    it_behaves_like 'current user not admin build items'

    context 'for additional authorized build allowed params' do
      before do
        params.merge!(external: true)
      end

      it { expect(user).to be_external }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class RejectService < BaseService
    def initialize(current_user)
      @current_user = current_user
    end

    def execute(user)
      return error(_('You are not allowed to reject a user'), :forbidden) unless allowed?
      return error(_('User does not have a pending request'), :conflict) unless user.blocked_pending_approval?

      user.delete_async(deleted_by: current_user, params: { hard_delete: true })

      after_reject_hook(user)

      NotificationService.new.user_admin_rejection(user.name, user.email)

      log_event(user)

      success(message: 'Success', http_status: :ok)
    end

    private

    attr_reader :current_user

    def allowed?
      can?(current_user, :reject_user)
    end

    def after_reject_hook(user)
      # overridden by EE module
    end

    def log_event(user)
      Gitlab::AppLogger.info(message: ""User instance access request rejected"", user: user.username.to_s, email: user.email.to_s, rejected_by: current_user.username.to_s, ip_address: current_user.current_sign_in_ip.to_s)
    end
  end
end

Users::RejectService.prepend_mod_with('Users::RejectService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::RejectService, feature_category: :user_management do
  let_it_be(:current_user) { create(:admin) }

  let(:user) { create(:user, :blocked_pending_approval) }

  subject(:execute) { described_class.new(current_user).execute(user) }

  describe '#execute' do
    context 'failures' do
      context 'when the executor user is not allowed to reject users' do
        let(:current_user) { create(:user) }

        it 'returns error result' do
          expect(subject[:status]).to eq(:error)
          expect(subject[:message]).to match(/You are not allowed to reject a user/)
        end
      end

      context 'when the executor user is an admin in admin mode', :enable_admin_mode do
        context 'when user is not in pending approval state' do
          let(:user) { create(:user, state: 'active') }

          it 'returns error result' do
            expect(subject[:status]).to eq(:error)
            expect(subject[:message])
              .to match(/User does not have a pending request/)
          end
        end
      end
    end

    context 'success' do
      context 'when the executor user is an admin in admin mode', :enable_admin_mode do
        it 'initiates user removal', :sidekiq_inline do
          subject

          expect(subject[:status]).to eq(:success)
          expect(
            Users::GhostUserMigration.where(user: user, initiator_user: current_user)
          ).to be_exists
        end

        it 'emails the user on rejection' do
          expect_next_instance_of(NotificationService) do |notification|
            allow(notification).to receive(:user_admin_rejection).with(user.name, user.notification_email_or_default)
          end

          subject
        end

        it 'logs rejection in application logs' do
          allow(Gitlab::AppLogger).to receive(:info)

          subject

          expect(Gitlab::AppLogger).to have_received(:info).with(
            message: ""User instance access request rejected"",
            user: user.username.to_s,
            email: user.email.to_s,
            rejected_by: current_user.username.to_s,
            ip_address: current_user.current_sign_in_ip.to_s
          )
        end
      end
    end

    context 'audit events' do
      context 'when not licensed' do
        before do
          stub_licensed_features(admin_audit_log: false)
        end

        it 'does not log any audit event' do
          expect { subject }.not_to change(AuditEvent, :count)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  # Service class for caching and retrieving the last push event of a user.
  class LastPushEventService
    EXPIRATION = 2.hours

    def initialize(user)
      @user = user
    end

    # Caches the given push event for the current user in the Rails cache.
    #
    # event - An instance of PushEvent to cache.
    def cache_last_push_event(event)
      keys = [
        project_cache_key(event.project),
        user_cache_key
      ]

      if forked_from = event.project.forked_from_project
        keys << project_cache_key(forked_from)
      end

      keys.each { |key| set_key(key, event.id) }
    end

    # Returns the last PushEvent for the current user.
    #
    # This method will return nil if no event was found.
    def last_event_for_user
      find_cached_event(user_cache_key)
    end

    # Returns the last PushEvent for the current user and the given project.
    #
    # project - An instance of Project for which to retrieve the PushEvent.
    #
    # This method will return nil if no event was found.
    def last_event_for_project(project)
      find_cached_event(project_cache_key(project))
    end

    def find_cached_event(cache_key)
      event_id = get_key(cache_key)

      return unless event_id

      unless (event = find_event_in_database(event_id))
        # We don't want to keep querying the same data over and over when a
        # merge request has been created, thus we remove the key if no event
        # (meaning an MR was created) is returned.
        Rails.cache.delete(cache_key)
      end

      event
    end

    private

    # rubocop: disable CodeReuse/ActiveRecord
    def find_event_in_database(id)
      PushEvent
        .without_existing_merge_requests
        .find_by(id: id)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def user_cache_key
      ""last-push-event/#{@user.id}""
    end

    def project_cache_key(project)
      ""last-push-event/#{@user.id}/#{project.id}""
    end

    def get_key(key)
      Rails.cache.read(key, raw: true)
    end

    def set_key(key, value)
      # We're using raw values here since this takes up less space and we don't
      # store complex objects.
      Rails.cache.write(key, value, raw: true, expires_in: EXPIRATION)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::LastPushEventService, feature_category: :source_code_management do
  let(:user) { build(:user, id: 1) }
  let(:project) { build(:project, id: 2) }
  let(:event) { build(:push_event, id: 3, author: user, project: project) }
  let(:service) { described_class.new(user) }

  describe '#cache_last_push_event' do
    it ""caches the event for the event's project and current user"" do
      expect(service).to receive(:set_key)
        .ordered
        .with('last-push-event/1/2', 3)

      expect(service).to receive(:set_key)
        .ordered
        .with('last-push-event/1', 3)

      service.cache_last_push_event(event)
    end

    it 'caches the event for the origin project when pushing to a fork' do
      source = build(:project, id: 5)

      allow(project).to receive(:forked_from_project).and_return(source)

      expect(service).to receive(:set_key)
        .ordered
        .with('last-push-event/1/2', 3)

      expect(service).to receive(:set_key)
        .ordered
        .with('last-push-event/1', 3)

      expect(service).to receive(:set_key)
        .ordered
        .with('last-push-event/1/5', 3)

      service.cache_last_push_event(event)
    end
  end

  describe '#last_event_for_user' do
    it 'returns the last push event for the current user' do
      expect(service).to receive(:find_cached_event)
        .with('last-push-event/1')
        .and_return(event)

      expect(service.last_event_for_user).to eq(event)
    end

    it 'returns nil when no push event could be found' do
      expect(service).to receive(:find_cached_event)
        .with('last-push-event/1')
        .and_return(nil)

      expect(service.last_event_for_user).to be_nil
    end
  end

  describe '#last_event_for_project' do
    it 'returns the last push event for the given project' do
      expect(service).to receive(:find_cached_event)
        .with('last-push-event/1/2')
        .and_return(event)

      expect(service.last_event_for_project(project)).to eq(event)
    end

    it 'returns nil when no push event could be found' do
      expect(service).to receive(:find_cached_event)
        .with('last-push-event/1/2')
        .and_return(nil)

      expect(service.last_event_for_project(project)).to be_nil
    end
  end

  describe '#find_cached_event', :use_clean_rails_memory_store_caching do
    context 'with a non-existing cache key' do
      it 'returns nil' do
        expect(service.find_cached_event('bla')).to be_nil
      end
    end

    context 'with an existing cache key' do
      before do
        service.cache_last_push_event(event)
      end

      it 'returns a PushEvent when no merge requests exist for the event' do
        allow(service).to receive(:find_event_in_database)
          .with(event.id)
          .and_return(event)

        expect(service.find_cached_event('last-push-event/1')).to eq(event)
      end

      it 'removes the cache key when no event could be found and returns nil' do
        allow(PushEvent).to receive(:without_existing_merge_requests)
          .and_return(PushEvent.none)

        expect(Rails.cache).to receive(:delete)
          .with('last-push-event/1')
          .and_call_original

        expect(service.find_cached_event('last-push-event/1')).to be_nil
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class UpsertCreditCardValidationService < BaseService
    attr_reader :params

    def initialize(params)
      @params = params.to_h.with_indifferent_access
    end

    def execute
      credit_card = Users::CreditCardValidation.find_or_initialize_by_user(user_id)

      credit_card_params = {
        credit_card_validated_at: credit_card_validated_at,
        last_digits: last_digits,
        holder_name: holder_name,
        network: network,
        expiration_date: expiration_date
      }

      credit_card.update(credit_card_params)

      success
    rescue ActiveRecord::InvalidForeignKey, ActiveRecord::NotNullViolation
      error
    rescue StandardError => e
      Gitlab::ErrorTracking.track_exception(e)
      error
    end

    private

    def user_id
      params.fetch(:user_id)
    end

    def credit_card_validated_at
      params.fetch(:credit_card_validated_at)
    end

    def last_digits
      Integer(params.fetch(:credit_card_mask_number), 10)
    end

    def holder_name
      params.fetch(:credit_card_holder_name)
    end

    def network
      params.fetch(:credit_card_type)
    end

    def expiration_date
      year = params.fetch(:credit_card_expiration_year)
      month = params.fetch(:credit_card_expiration_month)

      Date.new(year, month, -1) # last day of the month
    end

    def success
      ServiceResponse.success(message: _('Credit card validation record saved'))
    end

    def error
      ServiceResponse.error(message: _('Error saving credit card validation record'))
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::UpsertCreditCardValidationService, feature_category: :user_profile do
  include CryptoHelpers

  let_it_be(:user) { create(:user) }

  let(:user_id) { user.id }

  let(:network) { 'American Express' }
  let(:holder_name) {  'John Smith' }
  let(:last_digits) {  '1111' }
  let(:expiration_year) { Date.today.year + 10 }
  let(:expiration_month) { 1 }
  let(:expiration_date) { Date.new(expiration_year, expiration_month, -1) }
  let(:credit_card_validated_at) { Time.utc(2020, 1, 1) }

  let(:params) do
    {
      user_id: user_id,
      credit_card_validated_at: credit_card_validated_at,
      credit_card_expiration_year: expiration_year,
      credit_card_expiration_month: expiration_month,
      credit_card_holder_name: holder_name,
      credit_card_type: network,
      credit_card_mask_number: last_digits
    }
  end

  describe '#execute' do
    subject(:service) { described_class.new(params) }

    context 'successfully set credit card validation record for the user' do
      context 'when user does not have credit card validation record' do
        it 'creates the credit card validation and returns a success', :aggregate_failures do
          expect(user.credit_card_validated_at).to be nil

          service_result = service.execute

          expect(service_result.status).to eq(:success)
          expect(service_result.message).to eq(_('Credit card validation record saved'))

          user.reload

          expect(user.credit_card_validation).to have_attributes(
            credit_card_validated_at: credit_card_validated_at,
            network_hash: sha256(network.downcase),
            holder_name_hash: sha256(holder_name.downcase),
            last_digits_hash: sha256(last_digits),
            expiration_date_hash: sha256(expiration_date.to_s)
          )
        end
      end

      context 'when user has credit card validation record' do
        let(:previous_credit_card_validated_at) { Time.utc(1999, 2, 2) }

        before do
          create(:credit_card_validation, user: user, credit_card_validated_at: previous_credit_card_validated_at)
        end

        it 'updates the credit card validation record and returns a success', :aggregate_failures do
          expect(user.credit_card_validated_at).to eq(previous_credit_card_validated_at)

          service_result = service.execute

          expect(service_result.status).to eq(:success)
          expect(service_result.message).to eq(_('Credit card validation record saved'))

          user.reload

          expect(user.credit_card_validated_at).to eq(credit_card_validated_at)
        end
      end
    end

    shared_examples 'returns an error without tracking the exception' do
      it 'does not send an exception to Gitlab::ErrorTracking' do
        expect(Gitlab::ErrorTracking).not_to receive(:track_exception)

        service.execute
      end

      it 'returns an error', :aggregate_failures do
        service_result = service.execute

        expect(service_result.status).to eq(:error)
        expect(service_result.message).to eq(_('Error saving credit card validation record'))
      end
    end

    shared_examples 'returns an error and tracks the exception' do
      it 'sends an exception to Gitlab::ErrorTracking' do
        expect(Gitlab::ErrorTracking).to receive(:track_exception)

        service.execute
      end

      it 'returns an error', :aggregate_failures do
        service_result = service.execute

        expect(service_result.status).to eq(:error)
        expect(service_result.message).to eq(_('Error saving credit card validation record'))
      end
    end

    context 'when the user_id does not exist' do
      let(:user_id) { non_existing_record_id }

      it_behaves_like 'returns an error without tracking the exception'
    end

    context 'when the request is missing the credit_card_validated_at field' do
      let(:params) { { user_id: user_id } }

      it_behaves_like 'returns an error and tracks the exception'
    end

    context 'when the request is missing the user_id field' do
      let(:params) { { credit_card_validated_at: credit_card_validated_at } }

      it_behaves_like 'returns an error and tracks the exception'
    end

    context 'when there is an unexpected error' do
      let(:exception) { StandardError.new }

      before do
        allow_next_instance_of(::Users::CreditCardValidation) do |instance|
          allow(instance).to receive(:save).and_raise(exception)
        end
      end

      it_behaves_like 'returns an error and tracks the exception'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class SetStatusService
    include Gitlab::Allowable

    attr_reader :current_user, :target_user, :params

    def initialize(current_user, params)
      @current_user = current_user
      @params = params.dup
      @target_user = params.delete(:user) || current_user
    end

    def execute
      return false unless can?(current_user, :update_user_status, target_user)

      if status_cleared?
        remove_status
      else
        set_status
      end
    end

    private

    def set_status
      params[:emoji] = UserStatus::DEFAULT_EMOJI if params[:emoji].blank?
      params[:availability] = UserStatus.availabilities[:not_set] unless new_user_availability

      bump_user if user_status.update(params)
    end

    def remove_status
      bump_user if UserStatus.delete(target_user.id).nonzero?
      true
    end

    def user_status
      target_user.status || target_user.build_status
    end

    def status_cleared?
      params[:emoji].blank? &&
        params[:message].blank? &&
        (new_user_availability.blank? || new_user_availability == UserStatus.availabilities[:not_set])
    end

    def new_user_availability
      UserStatus.availabilities[params[:availability]]
    end

    def bump_user
      # Intentionally not calling `touch` as that will trigger other callbacks
      # on target_user (e.g. after_touch, after_commit, after_rollback) and we
      # don't need them to happen here.
      target_user.update_column(:updated_at, Time.current)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::SetStatusService, feature_category: :user_management do
  let(:current_user) { create(:user) }

  subject(:service) { described_class.new(current_user, params) }

  describe '#execute' do
    shared_examples_for 'bumps user' do
      it 'bumps User#updated_at' do
        expect { service.execute }.to change { current_user.updated_at }
      end
    end

    shared_examples_for 'does not bump user' do
      it 'does not bump User#updated_at' do
        expect { service.execute }.not_to change { current_user.updated_at }
      end
    end

    context 'when params are set' do
      let(:params) { { emoji: 'taurus', message: 'a random status', availability: 'busy' } }

      it 'creates a status' do
        service.execute

        expect(current_user.status.emoji).to eq('taurus')
        expect(current_user.status.message).to eq('a random status')
        expect(current_user.status.availability).to eq('busy')
      end

      it 'updates a status if it already existed' do
        create(:user_status, user: current_user)

        expect { service.execute }.not_to change { UserStatus.count }
        expect(current_user.status.message).to eq('a random status')
      end

      it 'returns true' do
        create(:user_status, user: current_user)
        expect(service.execute).to be(true)
      end

      it_behaves_like 'bumps user'

      context 'when setting availability to not_set' do
        before do
          params[:availability] = 'not_set'

          create(:user_status, user: current_user, availability: 'busy')
        end

        it 'updates the availability' do
          expect { service.execute }.to change { current_user.status.availability }.from('busy').to('not_set')
        end
      end

      context 'when the given availability value is not valid' do
        before do
          params[:availability] = 'not a valid value'
        end

        it 'does not update the status' do
          user_status = create(:user_status, user: current_user)

          expect { service.execute }.not_to change { user_status.reload }
        end
      end

      context 'for another user' do
        let(:target_user) { create(:user) }
        let(:params) do
          { emoji: 'taurus', message: 'a random status', user: target_user }
        end

        context 'the current user is admin', :enable_admin_mode do
          let(:current_user) { create(:admin) }

          it 'changes the status when the current user is allowed to do that' do
            expect { service.execute }.to change { target_user.status }
          end
        end

        it 'does not update the status if the current user is not allowed' do
          expect { service.execute }.not_to change { target_user.status }
        end

        it_behaves_like 'does not bump user'
      end
    end

    context 'without params' do
      let(:params) { {} }

      shared_examples 'removes user status record' do
        it 'deletes the user status record' do
          expect { service.execute }
            .to change { current_user.reload.status }.from(user_status).to(nil)
        end

        it_behaves_like 'bumps user'
      end

      context 'when user has existing user status record' do
        let!(:user_status) { create(:user_status, user: current_user) }

        it_behaves_like 'removes user status record'

        context 'when not_set is given for availability' do
          let(:params) { { availability: 'not_set' } }

          it_behaves_like 'removes user status record'
        end
      end

      context 'when user has no existing user status record' do
        it_behaves_like 'does not bump user'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class InProductMarketingEmailRecords
    attr_reader :records

    def initialize
      @records = []
    end

    def save!
      Users::InProductMarketingEmail.bulk_insert!(@records)
      @records = []
    end

    def add(user, track: nil, series: nil)
      @records << Users::InProductMarketingEmail.new(
        user: user,
        track: track,
        series: series,
        created_at: Time.zone.now,
        updated_at: Time.zone.now
      )
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::InProductMarketingEmailRecords, feature_category: :onboarding do
  let_it_be(:user) { create :user }

  subject(:records) { described_class.new }

  it 'initializes records' do
    expect(subject.records).to match_array []
  end

  describe '#save!' do
    before do
      allow(Users::InProductMarketingEmail).to receive(:bulk_insert!)

      records.add(user, track: :team_short, series: 0)
      records.add(user, track: :create, series: 1)
    end

    it 'bulk inserts added records' do
      expect(Users::InProductMarketingEmail).to receive(:bulk_insert!).with(records.records)
      records.save!
    end

    it 'resets its records' do
      records.save!
      expect(records.records).to match_array []
    end
  end

  describe '#add' do
    it 'adds a Users::InProductMarketingEmail record to its records', :aggregate_failures do
      freeze_time do
        records.add(user, track: :team_short, series: 0)
        records.add(user, track: :create, series: 1)

        first, second = records.records

        expect(first).to be_a Users::InProductMarketingEmail
        expect(first.track.to_sym).to eq :team_short
        expect(first.series).to eq 0
        expect(first.created_at).to eq Time.zone.now
        expect(first.updated_at).to eq Time.zone.now

        expect(second).to be_a Users::InProductMarketingEmail
        expect(second.track.to_sym).to eq :create
        expect(second.series).to eq 1
        expect(second.created_at).to eq Time.zone.now
        expect(second.updated_at).to eq Time.zone.now
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class DismissProjectCalloutService < DismissCalloutService
    private

    def callout
      current_user.find_or_initialize_project_callout(params[:feature_name], params[:project_id])
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::DismissProjectCalloutService, feature_category: :user_management do
  describe '#execute' do
    let_it_be(:user) { create(:user) }
    let_it_be(:project) { create(:project) }

    let(:params) { { feature_name: feature_name, project_id: project.id } }
    let(:feature_name) { Users::ProjectCallout.feature_names.each_key.first }

    subject(:execute) do
      described_class.new(
        container: nil, current_user: user, params: params
      ).execute
    end

    it_behaves_like 'dismissing user callout', Users::ProjectCallout

    it 'sets the project_id' do
      expect(execute.project_id).to eq(project.id)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class UnblockService < BaseService
    def initialize(current_user)
      @current_user = current_user
    end

    def execute(user)
      if user.activate
        after_unblock_hook(user)
        ServiceResponse.success(payload: { user: user })
      else
        ServiceResponse.error(message: user.errors.full_messages)
      end
    end

    private

    def after_unblock_hook(user)
      custom_attribute = {
        user_id: user.id,
        key: UserCustomAttribute::UNBLOCKED_BY,
        value: ""#{current_user.username}/#{current_user.id}+#{Time.current}""
      }
      UserCustomAttribute.upsert_custom_attributes([custom_attribute])
    end
  end
end

Users::UnblockService.prepend_mod_with('Users::UnblockService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::UnblockService, feature_category: :user_management do
  let_it_be(:current_user) { create(:admin) }

  subject(:service) { described_class.new(current_user) }

  describe '#execute' do
    subject(:operation) { service.execute(user) }

    context 'when successful' do
      let(:user) { create(:user, :blocked) }

      it { expect(operation.success?).to eq(true) }

      it ""change the user's state"" do
        expect { operation }.to change { user.active? }.to(true)
      end

      it 'saves a custom attribute', :aggregate_failures, :freeze_time, feature_category: :insider_threat do
        operation

        custom_attribute = user.custom_attributes.last

        expect(custom_attribute.key).to eq(UserCustomAttribute::UNBLOCKED_BY)
        expect(custom_attribute.value).to eq(""#{current_user.username}/#{current_user.id}+#{Time.current}"")
      end
    end

    context 'when failed' do
      let(:user) { create(:user) }

      it 'returns error result', :aggregate_failures do
        expect(operation.error?).to eq(true)
        expect(operation[:message]).to include(/State cannot transition/)
      end

      it ""does not change the user's state"" do
        expect { operation }.not_to change { user.state }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class UntrustService < BaseService
    def initialize(current_user)
      @current_user = current_user
    end

    def execute(user)
      user.trusted_with_spam_attribute.delete
      success
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::UntrustService, feature_category: :user_management do
  let_it_be(:current_user) { create(:admin) }

  subject(:service) { described_class.new(current_user) }

  describe '#execute' do
    let(:user) { create(:user) }

    subject(:operation) { service.execute(user) }

    before do
      UserCustomAttribute.upsert_custom_attributes(
        [{
          user_id: user.id,
          key: UserCustomAttribute::TRUSTED_BY,
          value: 'not important'
        }]
      )
    end

    it 'updates the custom attributes', :aggregate_failures do
      expect(user.trusted_with_spam_attribute).to be_present

      operation
      user.reload

      expect(user.trusted_with_spam_attribute).to be nil
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class AssignedIssuesCountService < ::BaseCountService
    def initialize(current_user:, max_limit: User::MAX_LIMIT_FOR_ASSIGNEED_ISSUES_COUNT)
      @current_user = current_user
      @max_limit = max_limit
    end

    def cache_key
      ['users', @current_user.id, 'max_assigned_open_issues_count']
    end

    def cache_options
      { force: false, expires_in: User::COUNT_CACHE_VALIDITY_PERIOD }
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def uncached_count
      # When a user has many assigned issues, counting them all can be very slow.
      # As a workaround, we will short-circuit the counting query once the count reaches some threshold.
      #
      # Concretely, given a threshold, say 100 (= max_limit),
      # iterate through the first 100 issues, sorted by ID desc, assigned to the user using `issue_assignees` table.
      # For each issue iterated, use IssuesFinder to check if the issue should be counted.
      initializer = IssueAssignee
        .select(:issue_id).joins("", LATERAL (#{finder_constraint.to_sql}) as issues"")
        .where(user_id: @current_user.id)
        .order(issue_id: :desc)
        .limit(1)
      recursive_finder = initializer.where(""issue_assignees.issue_id < assigned_issues.issue_id"")

      cte = <<~SQL
        WITH RECURSIVE assigned_issues AS (
          (
            #{initializer.to_sql}
          )
          UNION ALL
          (
            SELECT next_assigned_issue.issue_id
            FROM assigned_issues,
              LATERAL (
                #{recursive_finder.to_sql}
              ) next_assigned_issue
          )
        ) SELECT COUNT(*) FROM (SELECT * FROM assigned_issues LIMIT #{@max_limit}) issues
      SQL

      ApplicationRecord.connection.execute(cte).first[""count""]
    end
    # rubocop: enable CodeReuse/ActiveRecord

    private

    # rubocop: disable CodeReuse/ActiveRecord
    def finder_constraint
      IssuesFinder.new(@current_user, assignee_id: @current_user.id, state: 'opened', non_archived: true)
                  .execute
                  .where(""issues.id=issue_assignees.issue_id"").limit(1)
    end
    # rubocop: enable CodeReuse/ActiveRecord
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::AssignedIssuesCountService, :use_clean_rails_memory_store_caching,
  feature_category: :team_planning do
  let_it_be(:user) { create(:user) }
  let_it_be(:max_limit) { 10 }

  let(:current_user) { user }

  subject { described_class.new(current_user: current_user, max_limit: max_limit) }

  it_behaves_like 'a counter caching service'

  context 'when user has assigned open issues from archived and closed projects' do
    before do
      project = create(:project, :public)
      archived_project = create(:project, :public, :archived)

      create(:issue, project: project, author: user, assignees: [user])
      create(:issue, :closed, project: project, author: user, assignees: [user])
      create(:issue, project: archived_project, author: user, assignees: [user])
    end

    it 'count all assigned open issues excluding those from closed or archived projects' do
      expect(subject.count).to eq(1)
    end
  end

  context 'when the number of assigned open issues exceeds max_limit' do
    let_it_be(:banned_user) { create(:user, :banned) }
    let_it_be(:project) { create(:project).tap { |p| p.add_developer(user) } }

    context 'when user is admin', :enable_admin_mode do
      let_it_be(:admin) { create(:admin) }
      let_it_be(:issues) { create_list(:issue, max_limit + 1, project: project, assignees: [admin]) }
      let_it_be(:banned_issue) { create(:issue, project: project, assignees: [admin], author: banned_user) }

      let(:current_user) { admin }

      it 'returns the max_limit count' do
        expect(subject.count).to eq max_limit
      end
    end

    context 'when user is non-admin' do
      let_it_be(:issues) { create_list(:issue, max_limit + 1, project: project, assignees: [user]) }
      let_it_be(:closed_issue) { create(:issue, :closed, project: project, assignees: [user]) }
      let_it_be(:banned_issue) { create(:issue, project: project, assignees: [user], author: banned_user) }

      it 'returns the max_limit count' do
        expect(subject.count).to eq max_limit
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class RegistrationsBuildService < BuildService
    extend ::Gitlab::Utils::Override

    private

    def signup_params
      super + [:skip_confirmation]
    end

    override :assign_skip_confirmation_from_settings?
    def assign_skip_confirmation_from_settings?
      user_params[:skip_confirmation].blank?
    end
  end
end

Users::RegistrationsBuildService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::RegistrationsBuildService, feature_category: :system_access do
  describe '#execute' do
    let(:base_params) { build_stubbed(:user).slice(:first_name, :last_name, :username, :email, :password) }
    let(:skip_param) { {} }
    let(:params) { base_params.merge(skip_param) }

    subject(:service) { described_class.new(nil, params) }

    before do
      stub_application_setting(signup_enabled?: true)
    end

    context 'when automatic user confirmation is not enabled' do
      before do
        stub_application_setting_enum('email_confirmation_setting', 'hard')
      end

      context 'when skip_confirmation is true' do
        let(:skip_param) { { skip_confirmation: true } }

        it 'confirms the user' do
          expect(service.execute).to be_confirmed
        end
      end

      context 'when skip_confirmation is not set' do
        it 'does not confirm the user' do
          expect(service.execute).not_to be_confirmed
        end
      end

      context 'when skip_confirmation is false' do
        let(:skip_param) { { skip_confirmation: false } }

        it 'does not confirm the user' do
          expect(service.execute).not_to be_confirmed
        end
      end
    end

    context 'when automatic user confirmation is enabled' do
      before do
        stub_application_setting_enum('email_confirmation_setting', 'off')
      end

      context 'when skip_confirmation is true' do
        let(:skip_param) { { skip_confirmation: true } }

        it 'confirms the user' do
          expect(service.execute).to be_confirmed
        end
      end

      context 'when skip_confirmation is not set the application setting takes precedence' do
        it 'confirms the user' do
          expect(service.execute).to be_confirmed
        end
      end

      context 'when skip_confirmation is false the application setting takes precedence' do
        let(:skip_param) { { skip_confirmation: false } }

        it 'confirms the user' do
          expect(service.execute).to be_confirmed
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class DismissGroupCalloutService < DismissCalloutService
    private

    def callout
      current_user.find_or_initialize_group_callout(params[:feature_name], params[:group_id])
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::DismissGroupCalloutService, feature_category: :user_management do
  describe '#execute' do
    let_it_be(:user) { create(:user) }
    let_it_be(:group) { create(:group) }

    let(:params) { { feature_name: feature_name, group_id: group.id } }
    let(:feature_name) { Users::GroupCallout.feature_names.each_key.first }

    subject(:execute) do
      described_class.new(
        container: nil, current_user: user, params: params
      ).execute
    end

    it_behaves_like 'dismissing user callout', Users::GroupCallout

    it 'sets the group_id' do
      expect(execute.group_id).to eq(group.id)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class RepairLdapBlockedService
    attr_accessor :user

    def initialize(user)
      @user = user
    end

    def execute
      user.block if ldap_hard_blocked?
    end

    private

    def ldap_hard_blocked?
      user.ldap_blocked? && !user.ldap_user?
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::RepairLdapBlockedService, feature_category: :system_access do
  let(:user) { create(:omniauth_user, provider: 'ldapmain', state: 'ldap_blocked') }
  let(:identity) { user.ldap_identity }

  subject(:service) { described_class.new(user) }

  describe '#execute' do
    it 'changes to normal block after destroying last ldap identity' do
      identity.destroy!
      service.execute

      expect(user.reload).not_to be_ldap_blocked
    end

    it 'changes to normal block after changing last ldap identity to another provider' do
      identity.update_attribute(:provider, 'twitter')
      service.execute

      expect(user.reload).not_to be_ldap_blocked
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class UpdateCanonicalEmailService
    extend ActiveSupport::Concern

    INCLUDED_DOMAINS_PATTERN = [/gmail.com/].freeze

    def initialize(user:)
      raise ArgumentError, ""Please provide a user"" unless user.is_a?(User)

      @user = user
    end

    def execute
      return unless user.email
      return unless user.email.match? Devise.email_regexp

      canonical_email = canonicalize_email

      unless canonical_email
        # the canonical email doesn't exist, probably because the domain doesn't match
        # destroy any UserCanonicalEmail record associated with this user
        user.user_canonical_email&.delete
        # nothing else to do here
        return
      end

      if user.user_canonical_email
        # update to the new value
        user.user_canonical_email.canonical_email = canonical_email
      else
        user.build_user_canonical_email(canonical_email: canonical_email)
      end
    end

    private

    attr_reader :user

    def canonicalize_email
      email = user.email

      portions = email.split('@')
      username = portions.shift
      rest = portions.join

      regex = Regexp.union(INCLUDED_DOMAINS_PATTERN)
      return unless regex.match?(rest)

      no_dots = username.tr('.', '')
      before_plus = no_dots.split('+')[0]
      ""#{before_plus}@#{rest}""
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::UpdateCanonicalEmailService, feature_category: :user_profile do
  let(:other_email) { ""differentaddress@includeddomain.com"" }

  before do
    stub_const(""Users::UpdateCanonicalEmailService::INCLUDED_DOMAINS_PATTERN"", [/includeddomain/])
  end

  describe '#initialize' do
    context 'unsuccessful' do
      it 'raises an error if there is no user' do
        expect { described_class.new(user: nil) }.to raise_error(ArgumentError, /Please provide a user/)
      end

      it 'raises an error if the object is not a User' do
        expect { described_class.new(user: 123) }.to raise_error(ArgumentError, /Please provide a user/)
      end
    end

    context 'when a user is provided' do
      it 'does not error' do
        user = build(:user)

        expect { described_class.new(user: user) }.not_to raise_error
      end
    end
  end

  describe ""#canonicalize_email"" do
    let(:user) { build(:user) }
    let(:subject) { described_class.new(user: user) }

    context 'when the email domain is included' do
      context 'strips out any . or anything after + in the agent for included domains' do
        using RSpec::Parameterized::TableSyntax

        let(:expected_result) { 'user@includeddomain.com' }

        where(:raw_email, :expected_result) do
          'user@includeddomain.com'      | 'user@includeddomain.com'
          'u.s.e.r@includeddomain.com'   | 'user@includeddomain.com'
          'user+123@includeddomain.com'  | 'user@includeddomain.com'
          'us.er+123@includeddomain.com' | 'user@includeddomain.com'
        end

        with_them do
          before do
            user.email = raw_email
          end

          specify do
            subject.execute

            expect(user.user_canonical_email).not_to be_nil
            expect(user.user_canonical_email.canonical_email).to eq expected_result
          end
        end
      end

      context 'when the user has an existing canonical email' do
        it 'updates the user canonical email record' do
          user.user_canonical_email = build(:user_canonical_email, canonical_email: other_email)
          user.email = ""us.er+123@includeddomain.com""

          subject.execute

          expect(user.user_canonical_email.canonical_email).to eq ""user@includeddomain.com""
        end
      end
    end

    context 'when the email domain is not included' do
      it 'returns nil' do
        user.email = ""u.s.er+343@excludeddomain.com""

        subject.execute

        expect(user.user_canonical_email).to be_nil
      end

      it 'destroys any existing UserCanonicalEmail record' do
        user.email = ""u.s.er+343@excludeddomain.com""
        user.user_canonical_email = build(:user_canonical_email, canonical_email: other_email)
        expect(user.user_canonical_email).to receive(:delete)

        subject.execute
      end
    end

    context 'when the user email is not processable' do
      [nil, 'nonsense'].each do |invalid_address|
        context ""with #{invalid_address}"" do
          before do
            user.email = invalid_address
          end

          specify do
            subject.execute

            expect(user.user_canonical_email).to be_nil
          end

          it 'preserves any existing record' do
            user.email = nil
            user.user_canonical_email = build(:user_canonical_email, canonical_email: other_email)

            subject.execute

            expect(user.user_canonical_email.canonical_email).to eq other_email
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class BanService < BannedUserBaseService
    extend ::Gitlab::Utils::Override

    private

    def update_user(user)
      user.ban
    end

    def valid_state?(user)
      user.active?
    end

    def action
      :ban
    end

    override :track_event
    def track_event(user)
      experiment(:phone_verification_for_low_risk_users, user: user).track(:banned)
    end
  end
end

Users::BanService.prepend_mod_with('Users::BanService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::BanService, feature_category: :user_management do
  let(:user) { create(:user) }

  let_it_be(:current_user) { create(:admin) }

  shared_examples 'does not modify the BannedUser record or user state' do
    it 'does not modify the BannedUser record or user state' do
      expect { ban_user }.not_to change { Users::BannedUser.count }
      expect { ban_user }.not_to change { user.state }
    end
  end

  context 'ban', :aggregate_failures do
    subject(:ban_user) { described_class.new(current_user).execute(user) }

    context 'when successful', :enable_admin_mode do
      it 'returns success status' do
        response = ban_user

        expect(response[:status]).to eq(:success)
      end

      it 'bans the user' do
        expect { ban_user }.to change { user.state }.from('active').to('banned')
      end

      it 'creates a BannedUser' do
        expect { ban_user }.to change { Users::BannedUser.count }.by(1)
        expect(Users::BannedUser.last.user_id).to eq(user.id)
      end

      it 'logs ban in application logs' do
        expect(Gitlab::AppLogger).to receive(:info).with(message: ""User ban"", user: user.username.to_s, email: user.email.to_s, ban_by: current_user.username.to_s, ip_address: current_user.current_sign_in_ip.to_s)

        ban_user
      end

      it 'tracks the event', :experiment do
        expect(experiment(:phone_verification_for_low_risk_users))
          .to track(:banned).on_next_instance.with_context(user: user)

        ban_user
      end
    end

    context 'when failed' do
      context 'when user is blocked', :enable_admin_mode do
        before do
          user.block!
        end

        it 'returns state error message' do
          response = ban_user

          expect(response[:status]).to eq(:error)
          expect(response[:message]).to match('You cannot ban blocked users.')
        end

        it_behaves_like 'does not modify the BannedUser record or user state'
      end

      context 'when user is not an admin' do
        it 'returns permissions error message' do
          response = ban_user

          expect(response[:status]).to eq(:error)
          expect(response[:message]).to match(/You are not allowed to ban a user/)
        end

        it_behaves_like 'does not modify the BannedUser record or user state'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class BuildService < BaseService
    ALLOWED_USER_TYPES = %i[project_bot security_policy_bot].freeze

    delegate :user_default_internal_regex_enabled?,
      :user_default_internal_regex_instance,
      to: :'Gitlab::CurrentSettings.current_application_settings'

    def initialize(current_user, params = {})
      @current_user = current_user
      @params = params.dup
      @identity_params = params.slice(*identity_attributes)
    end

    def execute
      build_user
      build_identity
      update_canonical_email

      user
    end

    private

    attr_reader :identity_params, :user_params, :user

    def identity_attributes
      [:extern_uid, :provider]
    end

    def build_user
      if admin?
        admin_build_user
      else
        standard_build_user
      end

      user.assign_personal_namespace
    end

    def admin?
      return false unless current_user

      current_user.admin?
    end

    def admin_build_user
      build_user_params_for_admin
      init_user
      password_reset
    end

    def standard_build_user
      # current_user non admin or nil
      validate_access!
      build_user_params_for_non_admin
      init_user
    end

    def build_user_params_for_admin
      @user_params = params.slice(*admin_create_params)
      @user_params.merge!(force_random_password: true, password_expires_at: nil) if params[:reset_password]
    end

    def init_user
      assign_common_user_params

      @user = User.new(user_params)
    end

    def assign_common_user_params
      @user_params[:created_by_id] = current_user&.id
      @user_params[:external] = user_external? if set_external_param?

      @user_params.delete(:user_type) unless allowed_user_type?
    end

    def set_external_param?
      user_default_internal_regex_enabled? && !user_params.key?(:external)
    end

    def user_external?
      user_default_internal_regex_instance.match(params[:email]).nil?
    end

    def allowed_user_type?
      ALLOWED_USER_TYPES.include?(user_params[:user_type]&.to_sym)
    end

    def password_reset
      @reset_token = user.generate_reset_token if params[:reset_password]

      if user_params[:force_random_password]
        random_password = User.random_password
        @user.password = user.password_confirmation = random_password
      end
    end

    def validate_access!
      return if can_create_user?

      raise Gitlab::Access::AccessDeniedError
    end

    def can_create_user?
      current_user.nil? && Gitlab::CurrentSettings.allow_signup?
    end

    def build_user_params_for_non_admin
      @user_params = params.slice(*signup_params)
      # if skip_confirmation is set to `true`, devise will set confirmed_at
      # see: https://github.com/heartcombo/devise/blob/8593801130f2df94a50863b5db535c272b00efe1/lib/devise/models/confirmable.rb#L156
      @user_params[:skip_confirmation] = skip_user_confirmation_email_from_setting if assign_skip_confirmation_from_settings?
      @user_params[:name] = fallback_name if use_fallback_name?
    end

    def assign_skip_confirmation_from_settings?
      user_params[:skip_confirmation].nil?
    end

    def skip_user_confirmation_email_from_setting
      Gitlab::CurrentSettings.email_confirmation_setting_off?
    end

    def use_fallback_name?
      user_params[:name].blank? && fallback_name.present?
    end

    def fallback_name
      ""#{user_params[:first_name]} #{user_params[:last_name]}""
    end

    def build_identity
      return if identity_params.empty?

      user.identities.build(identity_params)
    end

    def update_canonical_email
      Users::UpdateCanonicalEmailService.new(user: user).execute
    end

    # Allowed params for creating a user (admins only)
    def admin_create_params
      [
        :access_level,
        :admin,
        :avatar,
        :bio,
        :can_create_group,
        :color_scheme_id,
        :email,
        :external,
        :force_random_password,
        :hide_no_password,
        :hide_no_ssh_key,
        :linkedin,
        :name,
        :password,
        :password_automatically_set,
        :password_expires_at,
        :projects_limit,
        :remember_me,
        :skip_confirmation,
        :skype,
        :theme_id,
        :twitter,
        :discord,
        :username,
        :website_url,
        :private_profile,
        :organization,
        :location,
        :public_email,
        :user_type,
        :note,
        :view_diffs_file_by_file
      ]
    end

    # Allowed params for user signup
    def signup_params
      [
        :email,
        :name,
        :password,
        :password_automatically_set,
        :preferred_language,
        :username,
        :user_type,
        :first_name,
        :last_name
      ]
    end
  end
end

Users::BuildService.prepend_mod_with('Users::BuildService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::BuildService, feature_category: :user_management do
  using RSpec::Parameterized::TableSyntax

  describe '#execute' do
    let_it_be(:current_user) { nil }

    let(:params) { build_stubbed(:user).slice(:first_name, :last_name, :username, :email, :password) }
    let(:service) { described_class.new(current_user, params) }

    context 'with nil current_user' do
      subject(:user) { service.execute }

      it_behaves_like 'common user build items'
      it_behaves_like 'current user not admin build items'

      context 'with ""user_default_external"" application setting' do
        using RSpec::Parameterized::TableSyntax

        where(:user_default_external, :external, :email, :user_default_internal_regex, :result) do
          true  | nil   | 'fl@example.com'        | nil                     | true
          true  | true  | 'fl@example.com'        | nil                     | true
          true  | false | 'fl@example.com'        | nil                     | true # admin difference

          true  | nil   | 'fl@example.com'        | ''                      | true
          true  | true  | 'fl@example.com'        | ''                      | true
          true  | false | 'fl@example.com'        | ''                      | true # admin difference

          true  | nil   | 'fl@example.com'        | '^(?:(?!\.ext@).)*$\r?' | false
          true  | true  | 'fl@example.com'        | '^(?:(?!\.ext@).)*$\r?' | false # admin difference
          true  | false | 'fl@example.com'        | '^(?:(?!\.ext@).)*$\r?' | false

          true  | nil   | 'tester.ext@domain.com' | '^(?:(?!\.ext@).)*$\r?' | true
          true  | true  | 'tester.ext@domain.com' | '^(?:(?!\.ext@).)*$\r?' | true
          true  | false | 'tester.ext@domain.com' | '^(?:(?!\.ext@).)*$\r?' | true # admin difference

          false | nil   | 'fl@example.com'        | nil                     | false
          false | true  | 'fl@example.com'        | nil                     | false # admin difference
          false | false | 'fl@example.com'        | nil                     | false

          false | nil   | 'fl@example.com'        | ''                      | false
          false | true  | 'fl@example.com'        | ''                      | false # admin difference
          false | false | 'fl@example.com'        | ''                      | false

          false | nil   | 'fl@example.com'        | '^(?:(?!\.ext@).)*$\r?' | false
          false | true  | 'fl@example.com'        | '^(?:(?!\.ext@).)*$\r?' | false # admin difference
          false | false | 'fl@example.com'        | '^(?:(?!\.ext@).)*$\r?' | false

          false | nil   | 'tester.ext@domain.com' | '^(?:(?!\.ext@).)*$\r?' | false
          false | true  | 'tester.ext@domain.com' | '^(?:(?!\.ext@).)*$\r?' | false # admin difference
          false | false | 'tester.ext@domain.com' | '^(?:(?!\.ext@).)*$\r?' | false
        end

        with_them do
          before do
            stub_application_setting(user_default_external: user_default_external)
            stub_application_setting(user_default_internal_regex: user_default_internal_regex)

            params.merge!({ external: external, email: email }.compact)
          end

          it 'sets the value of Gitlab::CurrentSettings.user_default_external' do
            expect(user.external).to eq(result)
          end
        end
      end
    end

    context 'with non admin current_user' do
      let_it_be(:current_user) { create(:user) }

      it 'raises AccessDeniedError exception' do
        expect { described_class.new(current_user, params).execute }.to raise_error Gitlab::Access::AccessDeniedError
      end
    end

    context 'with an admin current_user' do
      let_it_be(:current_user) { create(:admin) }

      let(:params) { build_stubbed(:user).slice(:name, :username, :email, :password) }
      let(:service) { described_class.new(current_user, ActionController::Parameters.new(params).permit!) }

      subject(:user) { service.execute }

      it_behaves_like 'common user build items'

      context 'with allowed params' do
        let(:params) do
          {
            access_level: 1,
            admin: 1,
            avatar: anything,
            bio: 1,
            can_create_group: 1,
            color_scheme_id: 1,
            email: 1,
            external: 1,
            force_random_password: 1,
            hide_no_password: 1,
            hide_no_ssh_key: 1,
            linkedin: 1,
            name: 1,
            password: 1,
            password_automatically_set: 1,
            password_expires_at: 1,
            projects_limit: 1,
            remember_me: 1,
            skip_confirmation: 1,
            skype: 1,
            theme_id: 1,
            twitter: 1,
            username: 1,
            website_url: 1,
            private_profile: 1,
            organization: 1,
            location: 1,
            public_email: 1,
            user_type: 'project_bot',
            note: 1,
            view_diffs_file_by_file: 1
          }
        end

        it 'sets all allowed attributes' do
          expect(User).to receive(:new).with(hash_including(params)).and_call_original

          service.execute
        end
      end

      context 'with ""user_default_external"" application setting' do
        where(:user_default_external, :external, :email, :user_default_internal_regex, :result) do
          true  | nil   | 'fl@example.com'        | nil                     | true
          true  | true  | 'fl@example.com'        | nil                     | true
          true  | false | 'fl@example.com'        | nil                     | false # admin difference

          true  | nil   | 'fl@example.com'        | ''                      | true
          true  | true  | 'fl@example.com'        | ''                      | true
          true  | false | 'fl@example.com'        | ''                      | false # admin difference

          true  | nil   | 'fl@example.com'        | '^(?:(?!\.ext@).)*$\r?' | false
          true  | true  | 'fl@example.com'        | '^(?:(?!\.ext@).)*$\r?' | true # admin difference
          true  | false | 'fl@example.com'        | '^(?:(?!\.ext@).)*$\r?' | false

          true  | nil   | 'tester.ext@domain.com' | '^(?:(?!\.ext@).)*$\r?' | true
          true  | true  | 'tester.ext@domain.com' | '^(?:(?!\.ext@).)*$\r?' | true
          true  | false | 'tester.ext@domain.com' | '^(?:(?!\.ext@).)*$\r?' | false # admin difference

          false | nil   | 'fl@example.com'        | nil                     | false
          false | true  | 'fl@example.com'        | nil                     | true # admin difference
          false | false | 'fl@example.com'        | nil                     | false

          false | nil   | 'fl@example.com'        | ''                      | false
          false | true  | 'fl@example.com'        | ''                      | true # admin difference
          false | false | 'fl@example.com'        | ''                      | false

          false | nil   | 'fl@example.com'        | '^(?:(?!\.ext@).)*$\r?' | false
          false | true  | 'fl@example.com'        | '^(?:(?!\.ext@).)*$\r?' | true # admin difference
          false | false | 'fl@example.com'        | '^(?:(?!\.ext@).)*$\r?' | false

          false | nil   | 'tester.ext@domain.com' | '^(?:(?!\.ext@).)*$\r?' | false
          false | true  | 'tester.ext@domain.com' | '^(?:(?!\.ext@).)*$\r?' | true # admin difference
          false | false | 'tester.ext@domain.com' | '^(?:(?!\.ext@).)*$\r?' | false
        end

        with_them do
          before do
            stub_application_setting(user_default_external: user_default_external)
            stub_application_setting(user_default_internal_regex: user_default_internal_regex)

            params.merge!({ external: external, email: email }.compact)
          end

          it 'sets the value of Gitlab::CurrentSettings.user_default_external' do
            expect(user.external).to eq(result)
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class DismissCalloutService < BaseContainerService
    def execute
      callout.tap do |record|
        record.update(dismissed_at: Time.current) if record.valid?
      end
    end

    private

    def callout
      current_user.find_or_initialize_callout(params[:feature_name])
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::DismissCalloutService, feature_category: :user_management do
  describe '#execute' do
    let_it_be(:user) { create(:user) }

    let(:params) { { feature_name: feature_name } }
    let(:feature_name) { Users::Callout.feature_names.each_key.first }

    subject(:execute) do
      described_class.new(
        container: nil, current_user: user, params: params
      ).execute
    end

    it_behaves_like 'dismissing user callout', Users::Callout
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class AutoBanService < BaseService
    def initialize(user:, reason:)
      @user = user
      @reason = reason
    end

    def execute
      if user.ban
        record_custom_attribute
        success
      else
        messages = user.errors.full_messages
        error(messages.uniq.join('. '))
      end
    end

    private

    attr_reader :user, :reason

    def record_custom_attribute
      custom_attribute = {
        user_id: user.id,
        key: UserCustomAttribute::AUTO_BANNED_BY,
        value: reason
      }
      UserCustomAttribute.upsert_custom_attributes([custom_attribute])
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::AutoBanService, feature_category: :instance_resiliency do
  let_it_be_with_reload(:user) { create(:user) }
  let(:reason) { :auto_ban_reason }

  context 'when auto banning a user', :aggregate_failures do
    subject(:auto_ban_user) { described_class.new(user: user, reason: reason).execute }

    context 'when successful' do
      it 'returns success status' do
        response = auto_ban_user

        expect(response[:status]).to eq(:success)
      end

      it 'bans the user' do
        expect { auto_ban_user }.to change { user.state }.from('active').to('banned')
      end

      it 'creates a BannedUser' do
        expect { auto_ban_user }.to change { Users::BannedUser.count }.by(1)
        expect(Users::BannedUser.last.user_id).to eq(user.id)
      end

      describe 'recording a custom attribute' do
        it 'records a custom attribute' do
          expect { auto_ban_user }.to change { UserCustomAttribute.count }.by(1)
          expect(user.custom_attributes.by_key(UserCustomAttribute::AUTO_BANNED_BY).first.value).to eq(reason.to_s)
        end
      end
    end

    context 'when failed' do
      context 'when user is blocked' do
        before do
          user.block!
        end

        it 'returns state error message' do
          response = auto_ban_user

          expect(response[:status]).to eq(:error)
          expect(response[:message]).to match('State cannot transition via \""ban\""')
        end

        it 'does not modify the BannedUser record or user state' do
          expect { auto_ban_user }.not_to change { Users::BannedUser.count }
          expect { auto_ban_user }.not_to change { user.state }
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class UnbanService < BannedUserBaseService
    private

    def update_user(user)
      user.unban
    end

    def valid_state?(user)
      user.banned?
    end

    def action
      :unban
    end
  end
end

Users::UnbanService.prepend_mod_with('Users::UnbanService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::UnbanService, feature_category: :user_management do
  let(:user) { create(:user) }

  let_it_be(:current_user) { create(:admin) }

  shared_examples 'does not modify the BannedUser record or user state' do
    it 'does not modify the BannedUser record or user state' do
      expect { unban_user }.not_to change { Users::BannedUser.count }
      expect { unban_user }.not_to change { user.state }
    end
  end

  context 'unban', :aggregate_failures do
    subject(:unban_user) { described_class.new(current_user).execute(user) }

    context 'when successful', :enable_admin_mode do
      before do
        user.ban!
      end

      it 'returns success status' do
        response = unban_user

        expect(response[:status]).to eq(:success)
      end

      it 'unbans the user' do
        expect { unban_user }.to change { user.state }.from('banned').to('active')
      end

      it 'removes the BannedUser' do
        expect { unban_user }.to change { Users::BannedUser.count }.by(-1)
        expect(user.reload.banned_user).to be_nil
      end

      it 'logs unban in application logs' do
        expect(Gitlab::AppLogger).to receive(:info).with(message: ""User unban"", user: user.username.to_s, email: user.email.to_s, unban_by: current_user.username.to_s, ip_address: current_user.current_sign_in_ip.to_s)

        unban_user
      end
    end

    context 'when failed' do
      context 'when user is already active', :enable_admin_mode do
        it 'returns state error message' do
          response = unban_user

          expect(response[:status]).to eq(:error)
          expect(response[:message]).to match('You cannot unban active users.')
        end

        it_behaves_like 'does not modify the BannedUser record or user state'
      end

      context 'when user is not an admin' do
        before do
          user.ban!
        end

        it 'returns permissions error message' do
          response = unban_user

          expect(response[:status]).to eq(:error)
          expect(response[:message]).to match(/You are not allowed to unban a user/)
        end

        it_behaves_like 'does not modify the BannedUser record or user state'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class DeactivateService < BaseService
    def initialize(current_user, skip_authorization: false)
      @current_user = current_user
      @skip_authorization = skip_authorization
    end

    def execute(user)
      unless allowed?
        return ::ServiceResponse.error(message: _('You are not authorized to perform this action'),
          reason: :forbidden)
      end

      if user.blocked?
        return ::ServiceResponse.error(message: _('Error occurred. A blocked user cannot be deactivated'),
          reason: :forbidden)
      end

      if user.internal?
        return ::ServiceResponse.error(message: _('Internal users cannot be deactivated'),
          reason: :forbidden)
      end

      return ::ServiceResponse.success(message: _('User has already been deactivated')) if user.deactivated?

      unless user.can_be_deactivated?
        message = _(
          'The user you are trying to deactivate has been active in the past %{minimum_inactive_days} days ' \
          'and cannot be deactivated')

        deactivation_error_message = format(message,
          minimum_inactive_days: Gitlab::CurrentSettings.deactivate_dormant_users_period)
        return ::ServiceResponse.error(message: deactivation_error_message, reason: :forbidden)
      end

      unless user.deactivate
        return ::ServiceResponse.error(message: user.errors.full_messages.to_sentence,
          reason: :bad_request)
      end

      log_event(user)

      ::ServiceResponse.success
    end

    private

    attr_reader :current_user

    def allowed?
      return true if @skip_authorization

      can?(current_user, :admin_all_resources)
    end

    def log_event(user)
      Gitlab::AppLogger.info(message: 'User deactivated', user: user.username.to_s, email: user.email.to_s,
        deactivated_by: current_user.username.to_s, ip_address: current_user.current_sign_in_ip.to_s)
    end
  end
end

Users::DeactivateService.prepend_mod_with('Users::DeactivateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::DeactivateService, feature_category: :user_management do
  let_it_be(:current_user) { build(:admin) }
  let_it_be(:user) { build(:user) }

  subject(:service) { described_class.new(current_user) }

  describe '#execute' do
    subject(:operation) { service.execute(user) }

    context 'when successful', :enable_admin_mode do
      let(:user) { create(:user) }

      it 'returns success status' do
        expect(operation[:status]).to eq(:success)
      end

      it ""changes the user's state"" do
        expect { operation }.to change { user.state }.to('deactivated')
      end

      it 'creates a log entry' do
        expect(Gitlab::AppLogger).to receive(:info).with(message: ""User deactivated"", user: user.username,
          email: user.email, deactivated_by: current_user.username, ip_address: current_user.current_sign_in_ip.to_s)

        operation
      end
    end

    context 'when the user is already deactivated', :enable_admin_mode do
      let(:user) { create(:user, :deactivated) }

      it 'returns error result' do
        aggregate_failures 'error result' do
          expect(operation[:status]).to eq(:success)
          expect(operation[:message]).to eq('User has already been deactivated')
        end
      end

      it ""does not change the user's state"" do
        expect { operation }.not_to change { user.state }
      end
    end

    context 'when internal user', :enable_admin_mode do
      let(:user) { create(:user, :bot) }

      it 'returns an error message' do
        expect(operation[:status]).to eq(:error)
        expect(operation[:message]).to eq('Internal users cannot be deactivated')
        expect(operation.reason).to eq :forbidden
      end
    end

    context 'when user is blocked', :enable_admin_mode do
      let(:user) { create(:user, :blocked) }

      it 'returns an error message' do
        expect(operation[:status]).to eq(:error)
        expect(operation[:message]).to eq('Error occurred. A blocked user cannot be deactivated')
        expect(operation.reason).to eq :forbidden
      end
    end

    context 'when user is not an admin' do
      it 'returns permissions error message' do
        expect(operation[:status]).to eq(:error)
        expect(operation[:message]).to eq(""You are not authorized to perform this action"")
        expect(operation.reason).to eq :forbidden
      end
    end

    context 'when skip_authorization is true' do
      let(:non_admin_user) { create(:user) }
      let(:user_to_deactivate) { create(:user) }
      let(:skip_authorization_service) { described_class.new(non_admin_user, skip_authorization: true) }

      it 'deactivates the user even if the current user is not an admin' do
        expect(skip_authorization_service.execute(user_to_deactivate)[:status]).to eq(:success)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class ValidatePushOtpService < BaseService
    include ::Gitlab::Auth::Otp::Fortinet

    def initialize(current_user)
      @current_user = current_user
      @strategy = if forti_authenticator_enabled?(current_user)
                    ::Gitlab::Auth::Otp::Strategies::FortiAuthenticator::PushOtp.new(current_user)
                  end
    end

    def execute
      strategy.validate
    rescue StandardError => ex
      Gitlab::ErrorTracking.log_exception(ex)
      error(ex.message)
    end

    private

    attr_reader :strategy
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::ValidatePushOtpService, feature_category: :user_profile do
  let_it_be(:user) { create(:user) }

  subject(:validate) { described_class.new(user).execute }

  context 'FortiAuthenticator' do
    before do
      stub_feature_flags(forti_authenticator: user)
      allow(::Gitlab.config.forti_authenticator).to receive(:enabled).and_return(true)
    end

    it 'calls PushOtp strategy' do
      expect_next_instance_of(::Gitlab::Auth::Otp::Strategies::FortiAuthenticator::PushOtp) do |strategy|
        expect(strategy).to receive(:validate).once
      end

      validate
    end
  end

  context 'unexpected error' do
    before do
      stub_feature_flags(forti_authenticator: user)
      allow(::Gitlab.config.forti_authenticator).to receive(:enabled).and_return(true)
    end

    it 'returns error' do
      error_message = ""boom!""

      expect_next_instance_of(::Gitlab::Auth::Otp::Strategies::FortiAuthenticator::PushOtp) do |strategy|
        expect(strategy).to receive(:validate).once.and_raise(StandardError, error_message)
      end
      expect(Gitlab::ErrorTracking).to receive(:log_exception)

      result = validate

      expect(result[:status]).to eq(:error)
      expect(result[:message]).to eq(error_message)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  # Service class for getting the number of SSH keys that belong to a user.
  class KeysCountService < BaseCountService
    attr_reader :user

    # user - The User for which to get the number of SSH keys.
    def initialize(user)
      @user = user
    end

    def relation_for_count
      user.keys.auth
    end

    def raw?
      # Since we're storing simple integers we don't need all of the additional
      # Marshal data Rails includes by default.
      true
    end

    def cache_key
      ""users/key-count-service/#{user.id}""
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::KeysCountService, :use_clean_rails_memory_store_caching, feature_category: :system_access do
  let(:user) { create(:user) }

  subject { described_class.new(user) }

  it_behaves_like 'a counter caching service'

  describe '#count' do
    before do
      create(:personal_key, user: user)
    end

    it 'returns the number of SSH keys as an Integer' do
      expect(subject.count).to eq(1)
    end

    it 'does not count signing keys' do
      create(:key, usage_type: :signing, user: user)

      expect(subject.count).to eq(1)
    end
  end

  describe '#uncached_count' do
    it 'returns the number of SSH keys' do
      expect(subject.uncached_count).to be_zero
    end
  end

  describe '#cache_key' do
    it 'returns the cache key' do
      expect(subject.cache_key).to eq(""users/key-count-service/#{user.id}"")
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class DestroyService
    DestroyError = Class.new(StandardError)

    attr_accessor :current_user

    def initialize(current_user)
      @current_user = current_user

      @scheduled_records_gauge = Gitlab::Metrics.gauge(
        :gitlab_ghost_user_migration_scheduled_records_total,
        'The total number of scheduled ghost user migrations'
      )
      @lag_gauge = Gitlab::Metrics.gauge(
        :gitlab_ghost_user_migration_lag_seconds,
        'The waiting time in seconds of the oldest scheduled record for ghost user migration'
      )
    end

    # Asynchronously destroys +user+
    # Migrating the associated user records, and post-migration cleanup is
    # handled by the Users::MigrateRecordsToGhostUserWorker cron worker.
    #
    # The operation will fail if the user is the sole owner of any groups. To
    # force the groups to be destroyed, pass `delete_solo_owned_groups: true` in
    # +options+.
    #
    # The user's contributions will be migrated to a global ghost user. To
    # force the contributions to be destroyed, pass `hard_delete: true` in
    # +options+.
    #
    # `hard_delete: true` implies `delete_solo_owned_groups: true`.  To perform
    # a hard deletion without destroying solo-owned groups, pass
    # `delete_solo_owned_groups: false, hard_delete: true` in +options+.
    #

    def execute(user, options = {})
      delete_solo_owned_groups = options.fetch(:delete_solo_owned_groups, options[:hard_delete])

      unless Ability.allowed?(current_user, :destroy_user, user) || options[:skip_authorization]
        raise Gitlab::Access::AccessDeniedError, ""#{current_user} tried to destroy user #{user}!""
      end

      if !delete_solo_owned_groups && user.solo_owned_groups.present?
        user.errors.add(:base, 'You must transfer ownership or delete groups before you can remove user')
        return user
      end

      user.block

      # Load the records. Groups are unavailable after membership is destroyed.
      solo_owned_groups = user.solo_owned_groups.load

      user.members.each_batch { |batch| batch.destroy_all } # rubocop:disable Style/SymbolProc, Cop/DestroyAll

      solo_owned_groups.each do |group|
        Groups::DestroyService.new(group, current_user).execute
      end

      user.personal_projects.each do |project|
        success = ::Projects::DestroyService.new(project, current_user).execute
        raise DestroyError, ""Project #{project.id} can't be deleted"" unless success
      end

      yield(user) if block_given?

      hard_delete = options.fetch(:hard_delete, false)
      Users::GhostUserMigration.create!(
        user: user,
        initiator_user: current_user,
        hard_delete: hard_delete
      )

      update_metrics
    end

    private

    attr_reader :scheduled_records_gauge, :lag_gauge

    def update_metrics
      update_scheduled_records_gauge
      update_lag_gauge
    end

    def update_scheduled_records_gauge
      # We do not want to issue unbounded COUNT() queries, hence we limit the
      # query to count 1001 records and then approximate the result.
      count = Users::GhostUserMigration.limit(1001).count

      if count == 1001
        # more than 1000 records, approximate count
        min = Users::GhostUserMigration.minimum(:id) || 0
        max = Users::GhostUserMigration.maximum(:id) || 0

        scheduled_records_gauge.set({}, max - min)
      else
        # less than 1000 records, count is accurate
        scheduled_records_gauge.set({}, count)
      end
    end

    def update_lag_gauge
      oldest_job = Users::GhostUserMigration.first
      lag_gauge.set({}, Time.current - oldest_job.created_at)
    end
  end
end

Users::DestroyService.prepend_mod_with('Users::DestroyService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::DestroyService, feature_category: :user_management do
  let!(:user)      { create(:user) }
  let!(:admin)     { create(:admin) }
  let!(:namespace) { user.namespace }
  let!(:project)   { create(:project, namespace: namespace) }
  let(:service)    { described_class.new(admin) }
  let(:gitlab_shell) { Gitlab::Shell.new }

  describe ""Initiates user deletion and deletes all their personal projects"", :enable_admin_mode do
    context 'no options are given' do
      it 'creates GhostUserMigration record to handle migration in a worker' do
        expect { service.execute(user) }
          .to(
            change do
              Users::GhostUserMigration.where(user: user, initiator_user: admin).exists?
            end.from(false).to(true))
      end

      it 'will delete the personal project' do
        expect_next_instance_of(Projects::DestroyService) do |destroy_service|
          expect(destroy_service).to receive(:execute).once.and_return(true)
        end

        service.execute(user)
      end
    end

    context 'personal projects in pending_delete' do
      before do
        project.pending_delete = true
        project.save!
      end

      it 'destroys a personal project in pending_delete' do
        expect_next_instance_of(Projects::DestroyService) do |destroy_service|
          expect(destroy_service).to receive(:execute).once.and_return(true)
        end

        service.execute(user)
      end
    end

    context ""solo owned groups present"" do
      let(:solo_owned)  { create(:group) }
      let(:member)      { create(:group_member) }
      let(:user)        { member.user }

      before do
        solo_owned.group_members = [member]
      end

      it 'returns the user with attached errors' do
        expect(service.execute(user)).to be(user)
        expect(user.errors.full_messages).to(
          contain_exactly('You must transfer ownership or delete groups before you can remove user'))
      end

      it 'does not delete the user, nor the group' do
        service.execute(user)

        expect(User.find(user.id)).to eq user
        expect(Group.find(solo_owned.id)).to eq solo_owned
      end
    end

    context ""deletions with solo owned groups"" do
      let(:solo_owned)      { create(:group) }
      let(:member)          { create(:group_member) }
      let(:user)            { member.user }

      before do
        solo_owned.group_members = [member]
        service.execute(user, delete_solo_owned_groups: true)
      end

      it 'deletes solo owned groups' do
        expect { Group.find(solo_owned.id) }.to raise_error(ActiveRecord::RecordNotFound)
      end
    end

    context 'deletions with inherited group owners' do
      let(:group) { create(:group, :nested) }
      let(:user) { create(:user) }
      let(:inherited_owner) { create(:user) }

      before do
        group.parent.add_owner(inherited_owner)
        group.add_owner(user)

        service.execute(user, delete_solo_owned_groups: true)
      end

      it 'does not delete the group' do
        expect(Group.exists?(id: group)).to be_truthy
      end
    end

    describe ""user personal's repository removal"" do
      context 'storages' do
        before do
          perform_enqueued_jobs { service.execute(user) }
        end

        context 'legacy storage' do
          let!(:project) { create(:project, :empty_repo, :legacy_storage, namespace: user.namespace) }

          it 'removes repository' do
            expect(
              gitlab_shell.repository_exists?(project.repository_storage, ""#{project.disk_path}.git"")
            ).to be_falsey
          end
        end

        context 'hashed storage' do
          let!(:project) { create(:project, :empty_repo, namespace: user.namespace) }

          it 'removes repository' do
            expect(
              gitlab_shell.repository_exists?(project.repository_storage, ""#{project.disk_path}.git"")
            ).to be_falsey
          end
        end
      end

      context 'repository removal status is taken into account' do
        it 'raises exception' do
          expect_next_instance_of(::Projects::DestroyService) do |destroy_service|
            expect(destroy_service).to receive(:execute).and_return(false)
          end

          expect { service.execute(user) }
            .to raise_error(Users::DestroyService::DestroyError, ""Project #{project.id} can't be deleted"")
        end
      end
    end

    describe ""calls the before/after callbacks"" do
      it 'of project_members' do
        expect_any_instance_of(ProjectMember).to receive(:run_callbacks).with(:find).once
        expect_any_instance_of(ProjectMember).to receive(:run_callbacks).with(:initialize).once
        expect_any_instance_of(ProjectMember).to receive(:run_callbacks).with(:destroy).once

        service.execute(user)
      end

      it 'of group_members' do
        group_member = create(:group_member)
        group_member.group.group_members.create!(user: user, access_level: 40)

        expect_any_instance_of(GroupMember).to receive(:run_callbacks).with(:find).once
        expect_any_instance_of(GroupMember).to receive(:run_callbacks).with(:initialize).once
        expect_any_instance_of(GroupMember).to receive(:run_callbacks).with(:destroy).once

        service.execute(user)
      end
    end

    describe 'prometheus metrics', :prometheus do
      context 'scheduled records' do
        context 'with a single record' do
          it 'updates the scheduled records gauge' do
            service.execute(user)

            gauge = Gitlab::Metrics.registry.get(:gitlab_ghost_user_migration_scheduled_records_total)
            expect(gauge.get).to eq(1)
          end
        end

        context 'with approximate count due to large number of records' do
          it 'updates the scheduled records gauge' do
            allow(Users::GhostUserMigration)
              .to(receive_message_chain(:limit, :count).and_return(1001))
            allow(Users::GhostUserMigration).to(receive(:minimum)).and_return(42)
            allow(Users::GhostUserMigration).to(receive(:maximum)).and_return(9042)

            service.execute(user)

            gauge = Gitlab::Metrics.registry.get(:gitlab_ghost_user_migration_scheduled_records_total)
            expect(gauge.get).to eq(9000)
          end
        end
      end

      context 'lag' do
        it 'update the lag gauge', :freeze_time do
          create(:ghost_user_migration, created_at: 10.minutes.ago)

          service.execute(user)

          gauge = Gitlab::Metrics.registry.get(:gitlab_ghost_user_migration_lag_seconds)
          expect(gauge.get).to eq(600)
        end
      end
    end
  end

  describe ""Deletion permission checks"" do
    it 'does not delete the user when user is not an admin' do
      other_user = create(:user)

      expect { described_class.new(other_user).execute(user) }.to raise_error(Gitlab::Access::AccessDeniedError)

      expect(Users::GhostUserMigration).not_to be_exists
    end

    context 'when admin mode is enabled', :enable_admin_mode do
      it 'allows admins to delete anyone' do
        expect { described_class.new(admin).execute(user) }
          .to(
            change do
              Users::GhostUserMigration.where(user: user, initiator_user: admin).exists?
            end.from(false).to(true))
      end
    end

    context 'when admin mode is disabled' do
      it 'disallows admins to delete anyone' do
        expect { described_class.new(admin).execute(user) }.to raise_error(Gitlab::Access::AccessDeniedError)

        expect(Users::GhostUserMigration).not_to be_exists
      end
    end

    it 'allows users to delete their own account' do
      expect { described_class.new(user).execute(user) }
        .to(
          change do
            Users::GhostUserMigration.where(user: user, initiator_user: user).exists?
          end.from(false).to(true))
    end

    it 'allows user to be deleted if skip_authorization: true' do
      other_user = create(:user)

      expect do
        described_class.new(user)
                       .execute(other_user, skip_authorization: true)
      end.to(
        change do
          Users::GhostUserMigration.where(user: other_user, initiator_user: user).exists?
        end.from(false).to(true))
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class UpdateService < BaseService
    include NewUserNotifier
    attr_reader :user, :identity_params

    ATTRS_REQUIRING_PASSWORD_CHECK = %w[email].freeze
    BATCH_SIZE = 100

    def initialize(current_user, params = {})
      @current_user = current_user
      @validation_password = params.delete(:validation_password)
      @user = params.delete(:user)
      @status_params = params.delete(:status)
      @identity_params = params.slice(*identity_attributes)
      @params = params.dup
    end

    def execute(validate: true, check_password: false, &block)
      yield(@user) if block

      user_exists = @user.persisted?
      @user.user_detail # prevent assignment

      discard_read_only_attributes
      assign_attributes

      if check_password && require_password_check? && !@user.valid_password?(@validation_password)
        return error(s_(""Profiles|Invalid password""))
      end

      assign_identity
      build_canonical_email
      reset_unconfirmed_email

      if @user.save(validate: validate) && update_status
        after_update(user_exists)
      else
        messages = @user.errors.full_messages + Array(@user.status&.errors&.full_messages)
        error(messages.uniq.join('. '))
      end
    end

    def execute!(*args, **kargs, &block)
      result = execute(*args, **kargs, &block)

      raise ActiveRecord::RecordInvalid, @user unless result[:status] == :success

      true
    end

    private

    def require_password_check?
      return false unless @user.persisted?
      return false if @user.password_automatically_set?

      changes = @user.changed
      ATTRS_REQUIRING_PASSWORD_CHECK.any? { |param| changes.include?(param) }
    end

    def build_canonical_email
      return unless @user.email_changed?

      Users::UpdateCanonicalEmailService.new(user: @user).execute
    end

    def reset_unconfirmed_email
      return unless @user.persisted?
      return unless @user.email_changed?

      @user.update_column(:unconfirmed_email, nil)
    end

    def update_status
      return true unless @status_params

      Users::SetStatusService.new(current_user, @status_params.merge(user: @user)).execute
    end

    def notify_success(user_exists)
      notify_new_user(@user, nil) unless user_exists
    end

    def discard_read_only_attributes
      discard_synced_attributes
    end

    def discard_synced_attributes
      if (metadata = @user.user_synced_attributes_metadata)
        read_only = metadata.read_only_attributes

        params.reject! { |key, _| read_only.include?(key.to_sym) }
      end
    end

    def assign_attributes
      @user.assign_attributes(params.except(*identity_attributes)) unless params.empty?
    end

    def assign_identity
      return unless identity_params.present?

      identity = user.identities.find_or_create_by(provider_params) # rubocop: disable CodeReuse/ActiveRecord
      identity.update(identity_params)
    end

    def identity_attributes
      [:provider, :extern_uid]
    end

    def provider_attributes
      [:provider]
    end

    def provider_params
      identity_params.slice(*provider_attributes)
    end

    def after_update(user_exists)
      notify_success(user_exists)
      remove_followers_and_followee!

      success
    end

    def remove_followers_and_followee!
      return false unless user.user_preference.enabled_following_previously_changed?(from: true, to: false)

      # rubocop: disable CodeReuse/ActiveRecord
      loop do
        inner_query = Users::UserFollowUser
                        .where(follower_id: user.id).or(Users::UserFollowUser.where(followee_id: user.id))
                        .select(:follower_id, :followee_id)
                        .limit(BATCH_SIZE)

        deleted_records = Users::UserFollowUser.where('(follower_id, followee_id) IN (?)', inner_query).delete_all

        break if deleted_records == 0
      end
      # rubocop: enable CodeReuse/ActiveRecord
    end
  end
end

Users::UpdateService.prepend_mod_with('Users::UpdateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::UpdateService, feature_category: :user_profile do
  let(:password) { User.random_password }
  let(:user) { create(:user, password: password, password_confirmation: password) }

  describe '#execute' do
    it 'updates time preferences' do
      result = update_user(user, timezone: 'Europe/Warsaw', time_display_relative: true)

      expect(result).to eq(status: :success)
      expect(user.reload.timezone).to eq('Europe/Warsaw')
      expect(user.time_display_relative).to eq(true)
    end

    it 'returns an error result when record cannot be updated' do
      result = {}
      expect do
        result = update_user(user, { email: 'invalid', validation_password: password })
      end.not_to change { user.reload.email }
      expect(result[:status]).to eq(:error)
      expect(result[:message]).to eq('Email is invalid')
    end

    it 'includes namespace error messages' do
      create(:group, path: 'taken')
      result = {}
      expect do
        result = update_user(user, { username: 'taken' })
      end.not_to change { user.reload.username }
      expect(result[:status]).to eq(:error)
      expect(result[:message]).to eq('A user, alias, or group already exists with that username.')
    end

    it 'updates the status if status params were given' do
      update_user(user, status: { message: ""On a call"" })

      expect(user.status.message).to eq(""On a call"")
    end

    it 'does not delete the status if no status param was passed' do
      create(:user_status, user: user, message: 'Busy!')

      update_user(user, name: 'New name')

      expect(user.status.message).to eq('Busy!')
    end

    it 'includes status error messages' do
      result = update_user(user, status: { emoji: ""Moo!"" })

      expect(result[:status]).to eq(:error)
      expect(result[:message]).to eq(""Emoji is not a valid emoji name"")
    end

    it 'updates user detail with provided attributes' do
      result = update_user(user, job_title: 'Backend Engineer')

      expect(result).to eq(status: :success)
      expect(user.job_title).to eq('Backend Engineer')
    end

    context 'updating canonical email' do
      context 'if email was changed' do
        subject do
          update_user(user, email: 'user+extrastuff@example.com', validation_password: password)
        end

        it 'calls canonicalize_email' do
          expect_next_instance_of(Users::UpdateCanonicalEmailService) do |service|
            expect(service).to receive(:execute)
          end

          subject
        end

        context 'when race condition' do
          # See https://gitlab.com/gitlab-org/gitlab/-/issues/382957
          it 'updates email for stale user', :aggregate_failures do
            unconfirmed_email = 'unconfirmed-email-user-has-access-to@example.com'
            forgery_email = 'forgery@example.com'

            user.update!(email: unconfirmed_email)

            stale_user = User.find(user.id)

            service1 = described_class.new(stale_user, { email: unconfirmed_email }.merge(user: stale_user))

            service2 = described_class.new(user, { email: forgery_email }.merge(user: user))

            service2.execute
            reloaded_user = User.find(user.id)
            expect(reloaded_user.unconfirmed_email).to eq(forgery_email)
            expect(stale_user.confirmation_token).not_to eq(user.confirmation_token)
            expect(reloaded_user.confirmation_token).to eq(user.confirmation_token)

            service1.execute
            reloaded_user = User.find(user.id)
            expect(reloaded_user.unconfirmed_email).to eq(unconfirmed_email)
            expect(stale_user.confirmation_token).not_to eq(user.confirmation_token)
            expect(reloaded_user.confirmation_token).to eq(stale_user.confirmation_token)
          end
        end

        context 'when check_password is true' do
          def update_user(user, opts)
            described_class.new(user, opts.merge(user: user)).execute(check_password: true)
          end

          it 'returns error if no password confirmation was passed', :aggregate_failures do
            result = {}

            expect do
              result = update_user(user, { email: 'example@example.com' })
            end.not_to change { user.reload.unconfirmed_email }
            expect(result[:status]).to eq(:error)
            expect(result[:message]).to eq('Invalid password')
          end

          it 'returns error if wrong password confirmation was passed', :aggregate_failures do
            result = {}

            expect do
              result = update_user(user, { email: 'example@example.com', validation_password: 'wrongpassword' })
            end.not_to change { user.reload.unconfirmed_email }
            expect(result[:status]).to eq(:error)
            expect(result[:message]).to eq('Invalid password')
          end

          it 'does not require password if it was automatically set', :aggregate_failures do
            user.update!(password_automatically_set: true)
            result = {}

            expect do
              result = update_user(user, { email: 'example@example.com' })
            end.to change { user.reload.unconfirmed_email }
            expect(result[:status]).to eq(:success)
          end

          it 'does not require a password if the attribute changed does not require it' do
            result = {}

            expect do
              result = update_user(user, { job_title: 'supreme leader of the universe' })
            end.to change { user.reload.job_title }
            expect(result[:status]).to eq(:success)
          end
        end
      end

      context 'when check_password is left to false' do
        it 'does not require a password check', :aggregate_failures do
          result = {}
          expect do
            result = update_user(user, { email: 'example@example.com' })
          end.to change { user.reload.unconfirmed_email }
          expect(result[:status]).to eq(:success)
        end
      end

      context 'if email was NOT changed' do
        it 'skips update canonicalize email service call' do
          expect do
            update_user(user, job_title: 'supreme leader of the universe')
          end.not_to change { user.user_canonical_email }
        end

        it 'does not reset unconfirmed email' do
          unconfirmed_email = 'unconfirmed-email@example.com'
          user.update!(email: unconfirmed_email)

          expect do
            update_user(user, job_title: 'supreme leader of the universe')
          end.not_to change { user.unconfirmed_email }
        end
      end
    end

    it 'does not try to reset unconfirmed email for a new user' do
      expect do
        update_user(build(:user), job_title: 'supreme leader of the universe')
      end.not_to raise_error
    end

    describe 'updates the enabled_following' do
      let(:user) { create(:user) }

      before do
        3.times do
          user.follow(create(:user))
          create(:user).follow(user)
        end
        user.reload
      end

      it 'removes followers and followees' do
        expect do
          update_user(user, enabled_following: false)
        end.to change { user.followed_users.count }.from(3).to(0)
                                                   .and change { user.following_users.count }.from(3).to(0)
        expect(user.enabled_following).to eq(false)
      end

      context 'when there is more followers/followees then batch limit' do
        before do
          stub_env('BATCH_SIZE', 1)
        end

        it 'removes followers and followees' do
          expect do
            update_user(user, enabled_following: false)
          end.to change { user.followed_users.count }.from(3).to(0)
                                                     .and change { user.following_users.count }.from(3).to(0)
          expect(user.enabled_following).to eq(false)
        end
      end
    end

    def update_user(user, opts)
      described_class.new(user, opts.merge(user: user)).execute
    end
  end

  describe '#execute!' do
    it 'updates the name' do
      service = described_class.new(user, user: user, name: 'New Name')
      expect(service).not_to receive(:notify_new_user)

      result = service.execute!

      expect(result).to be true
      expect(user.name).to eq('New Name')
    end

    it 'raises an error when record cannot be updated' do
      expect do
        update_user(user, email: 'invalid', validation_password: password)
      end.to raise_error(ActiveRecord::RecordInvalid)
    end

    it 'fires system hooks when a new user is saved' do
      system_hook_service = spy(:system_hook_service)
      user = build(:user)
      service = described_class.new(user, user: user, name: 'John Doe')
      expect(service).to receive(:notify_new_user).and_call_original
      expect(service).to receive(:system_hook_service).and_return(system_hook_service)

      service.execute

      expect(system_hook_service).to have_received(:execute_hooks_for).with(user, :create)
    end

    def update_user(user, opts)
      described_class.new(user, opts.merge(user: user)).execute!
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class UpdateHighestMemberRoleService < BaseService
    attr_reader :user

    def initialize(user)
      @user = user
    end

    def execute
      return true if user_highest_role.persisted? && highest_access_level == user_highest_role.highest_access_level

      user_highest_role.update!(highest_access_level: highest_access_level)
    end

    private

    def user_highest_role
      @user_highest_role ||= @user.user_highest_role || @user.build_user_highest_role
    end

    def highest_access_level
      @highest_access_level ||= @user.current_highest_access_level
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::UpdateHighestMemberRoleService, feature_category: :user_management do
  let(:user) { create(:user) }
  let(:execute_service) { described_class.new(user).execute }

  describe '#execute' do
    context 'when user_highest_role already exists' do
      let!(:user_highest_role) { create(:user_highest_role, :guest, user: user) }

      context 'when the current highest access level equals the already stored highest access level' do
        it 'does not update the highest access level' do
          create(:group_member, :guest, user: user)

          expect { execute_service }.not_to change { user_highest_role.reload.highest_access_level }
        end
      end

      context 'when the current highest access level does not equal the already stored highest access level' do
        it 'updates the highest access level' do
          create(:group_member, :developer, user: user)

          expect { execute_service }
            .to change { user_highest_role.reload.highest_access_level }
            .from(Gitlab::Access::GUEST)
            .to(Gitlab::Access::DEVELOPER)
        end
      end
    end

    context 'when user_highest_role does not exist' do
      it 'creates an user_highest_role object to store the highest access level' do
        create(:group_member, :guest, user: user)

        expect { execute_service }.to change { UserHighestRole.count }.from(0).to(1)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class ApproveService < BaseService
    def initialize(current_user)
      @current_user = current_user
    end

    def execute(user)
      return error(_('You are not allowed to approve a user'), :forbidden) unless allowed?
      return error(_('The user you are trying to approve is not pending approval'), :conflict) if user.active? || !approval_required?(user)

      if user.activate
        # Resends confirmation email if the user isn't confirmed yet.
        # Please see Devise's implementation of `resend_confirmation_instructions` for detail.
        user.resend_confirmation_instructions
        user.accept_pending_invitations! if user.active_for_authentication?
        DeviseMailer.user_admin_approval(user).deliver_later

        if user.created_by_id
          reset_token = user.generate_reset_token
          NotificationService.new.new_user(user, reset_token)
        end

        log_event(user)
        after_approve_hook(user)
        success(message: 'Success', http_status: :created)
      else
        error(user.errors.full_messages.uniq.join('. '), :unprocessable_entity)
      end
    end

    private

    attr_reader :current_user

    def after_approve_hook(user)
      # overridden by EE module
    end

    def allowed?
      can?(current_user, :approve_user)
    end

    def approval_required?(user)
      user.blocked_pending_approval?
    end

    def log_event(user)
      Gitlab::AppLogger.info(message: ""User instance access request approved"", user: user.username.to_s, email: user.email.to_s, approved_by: current_user.username.to_s, ip_address: current_user.current_sign_in_ip.to_s)
    end
  end
end

Users::ApproveService.prepend_mod_with('Users::ApproveService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::ApproveService, feature_category: :user_management do
  let_it_be(:current_user) { create(:admin) }

  let(:user) { create(:user, :blocked_pending_approval) }

  subject(:execute) { described_class.new(current_user).execute(user) }

  describe '#execute' do
    context 'failures' do
      context 'when the executor user is not allowed to approve users' do
        let(:current_user) { create(:user) }

        it 'returns error result' do
          expect(subject[:status]).to eq(:error)
          expect(subject[:message]).to match(/You are not allowed to approve a user/)
        end
      end

      context 'when the executor user is an admin not in admin mode' do
        it 'returns error result' do
          expect(subject[:status]).to eq(:error)
          expect(subject[:message]).to match(/You are not allowed to approve a user/)
        end
      end

      context 'when the executor user is an admin in admin mode', :enable_admin_mode do
        context 'when user is not in pending approval state' do
          let(:user) { create(:user, state: 'active') }

          it 'returns error result' do
            expect(subject[:status]).to eq(:error)
            expect(subject[:message])
              .to match(/The user you are trying to approve is not pending approval/)
          end
        end

        context 'when user cannot be activated' do
          let(:user) do
            build(:user, state: 'blocked_pending_approval', email: 'invalid email')
          end

          it 'returns error result' do
            expect(subject[:status]).to eq(:error)
            expect(subject[:message]).to match(/Email is invalid/)
          end

          it 'does not change the state of the user' do
            expect { subject }.not_to change { user.state }
          end
        end
      end
    end

    context 'success' do
      context 'when the executor user is an admin in admin mode', :enable_admin_mode do
        it 'activates the user' do
          expect(subject[:status]).to eq(:success)
          expect(user.reload).to be_active
        end

        it 'logs approval in application logs' do
          allow(Gitlab::AppLogger).to receive(:info)

          subject

          expect(Gitlab::AppLogger).to have_received(:info).with(message: ""User instance access request approved"", user: user.username.to_s, email: user.email.to_s, approved_by: current_user.username.to_s, ip_address: current_user.current_sign_in_ip.to_s)
        end

        it 'emails the user on approval' do
          expect(DeviseMailer).to receive(:user_admin_approval).with(user).and_call_original
          expect { subject }.to have_enqueued_mail(DeviseMailer, :user_admin_approval)
        end

        context 'when the user was created via sign up' do
          it 'does not send a password reset email' do
            expect { subject }.not_to have_enqueued_mail(Notify, :new_user_email)
          end
        end

        context 'when the user was created by an admin' do
          let(:user) { create(:user, :blocked_pending_approval, created_by_id: current_user.id) }

          it 'sends a password reset email' do
            allow(user).to receive(:generate_reset_token).and_return(:reset_token)

            expect(Notify).to receive(:new_user_email).with(user.id, :reset_token).and_call_original

            expect { subject }.to have_enqueued_mail(Notify, :new_user_email)
          end
        end

        context 'email confirmation status' do
          context 'user is unconfirmed' do
            let(:user) { create(:user, :blocked_pending_approval, :unconfirmed) }

            it 'sends confirmation instructions' do
              expect { subject }
                .to have_enqueued_mail(DeviseMailer, :confirmation_instructions)
            end
          end

          context 'user is confirmed' do
            it 'does not send a confirmation email' do
              expect { subject }
                .not_to have_enqueued_mail(DeviseMailer, :confirmation_instructions)
            end
          end

          context 'audit events' do
            context 'when not licensed' do
              before do
                stub_licensed_features(
                  admin_audit_log: false
                )
              end

              it 'does not log any audit event' do
                expect { subject }.not_to change(AuditEvent, :count)
              end
            end
          end
        end

        context 'pending invitations' do
          let!(:project_member_invite) { create(:project_member, :invited, invite_email: user.email) }
          let!(:group_member_invite) { create(:group_member, :invited, invite_email: user.email) }

          context 'user is unconfirmed' do
            let(:user) { create(:user, :blocked_pending_approval, :unconfirmed) }

            it 'does not accept pending invites of the user' do
              expect(subject[:status]).to eq(:success)

              group_member_invite.reload
              project_member_invite.reload

              expect(group_member_invite).to be_invite
              expect(project_member_invite).to be_invite
            end
          end

          context 'user is confirmed' do
            it 'accepts pending invites of the user' do
              expect(subject[:status]).to eq(:success)

              group_member_invite.reload
              project_member_invite.reload

              expect(group_member_invite).not_to be_invite
              expect(project_member_invite).not_to be_invite
              expect(group_member_invite.user).to eq(user)
              expect(project_member_invite.user).to eq(user)
            end
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class RespondToTermsService
    def initialize(user, term)
      @user = user
      @term = term
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def execute(accepted:)
      agreement = @user.term_agreements.find_or_initialize_by(term: @term)
      agreement.accepted = accepted

      if agreement.save
        store_accepted_term(accepted)
      end

      agreement
    end
    # rubocop: enable CodeReuse/ActiveRecord

    private

    def store_accepted_term(accepted)
      @user.update_column(:accepted_term_id, accepted ? @term.id : nil)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::RespondToTermsService, feature_category: :user_profile do
  let(:user) { create(:user) }
  let(:term) { create(:term) }

  subject(:service) { described_class.new(user, term) }

  describe '#execute' do
    it 'creates a new agreement if it did not exist' do
      expect { service.execute(accepted: true) }
        .to change { user.term_agreements.size }.by(1)
    end

    it 'updates an agreement if it existed' do
      agreement = create(:term_agreement, user: user, term: term, accepted: true)

      service.execute(accepted: true)

      expect(agreement.reload.accepted).to be_truthy
    end

    it 'adds the accepted terms to the user' do
      service.execute(accepted: true)

      expect(user.reload.accepted_term).to eq(term)
    end

    it 'removes accepted terms when declining' do
      user.update!(accepted_term: term)

      service.execute(accepted: false)

      expect(user.reload.accepted_term).to be_nil
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class UpdateTodoCountCacheService < BaseService
    QUERY_BATCH_SIZE = 10

    attr_reader :user_ids

    # user_ids - An array of User IDs
    def initialize(user_ids)
      @user_ids = user_ids
    end

    def execute
      user_ids.each_slice(QUERY_BATCH_SIZE) do |user_ids_batch|
        todo_counts = Todo.for_user(user_ids_batch).count_grouped_by_user_id_and_state

        user_ids_batch.each do |user_id|
          update_count_cache(user_id, todo_counts, :done)
          update_count_cache(user_id, todo_counts, :pending)
        end
      end
    end

    private

    def update_count_cache(user_id, todo_counts, state)
      count = todo_counts.fetch([user_id, state.to_s], 0)

      Rails.cache.write(
        ['users', user_id, ""todos_#{state}_count""],
        count,
        expires_in: User::COUNT_CACHE_VALIDITY_PERIOD
      )
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::UpdateTodoCountCacheService, feature_category: :team_planning do
  describe '#execute' do
    let_it_be(:user1) { create(:user) }
    let_it_be(:user2) { create(:user) }

    let_it_be(:todo1) { create(:todo, user: user1, state: :done) }
    let_it_be(:todo2) { create(:todo, user: user1, state: :done) }
    let_it_be(:todo3) { create(:todo, user: user1, state: :pending) }
    let_it_be(:todo4) { create(:todo, user: user2, state: :done) }
    let_it_be(:todo5) { create(:todo, user: user2, state: :pending) }
    let_it_be(:todo6) { create(:todo, user: user2, state: :pending) }

    def execute_all
      described_class.new([user1.id, user2.id]).execute
    end

    def execute_single
      described_class.new([user1.id]).execute
    end

    it 'updates the todos_counts for users', :use_clean_rails_memory_store_caching do
      Rails.cache.write(['users', user1.id, 'todos_done_count'], 0)
      Rails.cache.write(['users', user1.id, 'todos_pending_count'], 0)
      Rails.cache.write(['users', user2.id, 'todos_done_count'], 0)
      Rails.cache.write(['users', user2.id, 'todos_pending_count'], 0)

      expect { execute_all }
        .to change(user1, :todos_done_count).from(0).to(2)
        .and change(user1, :todos_pending_count).from(0).to(1)
        .and change(user2, :todos_done_count).from(0).to(1)
        .and change(user2, :todos_pending_count).from(0).to(2)

      Todo.delete_all

      expect { execute_all }
        .to change(user1, :todos_done_count).from(2).to(0)
        .and change(user1, :todos_pending_count).from(1).to(0)
        .and change(user2, :todos_done_count).from(1).to(0)
        .and change(user2, :todos_pending_count).from(2).to(0)
    end

    it 'avoids N+1 queries' do
      control_count = ActiveRecord::QueryRecorder.new { execute_single }.count

      expect { execute_all }.not_to exceed_query_limit(control_count)
    end

    it 'executes one query per batch of users' do
      stub_const(""#{described_class}::QUERY_BATCH_SIZE"", 1)

      expect(ActiveRecord::QueryRecorder.new { execute_single }.count).to eq(1)
      expect(ActiveRecord::QueryRecorder.new { execute_all }.count).to eq(2)
    end

    it 'sets the correct cache expire time' do
      expect(Rails.cache).to receive(:write)
        .with(['users', user1.id, anything], anything, expires_in: User::COUNT_CACHE_VALIDITY_PERIOD)
        .twice

      execute_single
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class ActivateService < BaseService
    def initialize(current_user)
      @current_user = current_user
    end

    def execute(user)
      return error(_('You are not authorized to perform this action'), :forbidden) unless allowed?

      return error(_('Error occurred. A blocked user must be unblocked to be activated'), :forbidden) if user.blocked?

      return success(_('Successfully activated')) if user.active?

      if user.activate
        after_activate_hook(user)
        log_event(user)
        success(_('Successfully activated'))
      else
        error(user.errors.full_messages.to_sentence, :unprocessable_entity)
      end
    end

    private

    attr_reader :current_user

    def allowed?
      can?(current_user, :admin_all_resources)
    end

    def after_activate_hook(user)
      # overridden by EE module
    end

    def log_event(user)
      Gitlab::AppLogger.info(message: 'User activated', user: user.username.to_s, email: user.email.to_s,
        activated_by: current_user.username.to_s, ip_address: current_user.current_sign_in_ip.to_s)
    end

    def success(message)
      ::ServiceResponse.success(message: message)
    end

    def error(message, reason)
      ::ServiceResponse.error(message: message, reason: reason)
    end
  end
end

Users::ActivateService.prepend_mod_with('Users::ActivateService') # rubocop: disable Cop/InjectEnterpriseEditionModule

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::ActivateService, feature_category: :user_management do
  let_it_be(:current_user) { build(:admin) }

  subject(:service) { described_class.new(current_user) }

  describe '#execute' do
    let!(:user) { create(:user, :deactivated) }

    subject(:operation) { service.execute(user) }

    context 'when successful', :enable_admin_mode do
      it 'returns success status' do
        expect(operation[:status]).to eq(:success)
      end

      it ""changes the user's state"" do
        expect { operation }.to change { user.state }.to('active')
      end

      it 'creates a log entry' do
        expect(Gitlab::AppLogger).to receive(:info).with(message: ""User activated"", user: user.username,
          email: user.email, activated_by: current_user.username, ip_address: current_user.current_sign_in_ip.to_s)

        operation
      end
    end

    context 'when the user is already active', :enable_admin_mode do
      let(:user) { create(:user) }

      it 'returns success result' do
        aggregate_failures 'success result' do
          expect(operation[:status]).to eq(:success)
          expect(operation[:message]).to eq('Successfully activated')
        end
      end

      it ""does not change the user's state"" do
        expect { operation }.not_to change { user.state }
      end
    end

    context 'when user activation fails', :enable_admin_mode do
      before do
        allow(user).to receive(:activate).and_return(false)
      end

      it 'returns an unprocessable entity error' do
        result = service.execute(user)

        expect(result[:status]).to eq(:error)
        expect(result[:reason]).to eq(:unprocessable_entity)
      end
    end

    context 'when user is not an admin' do
      let(:non_admin_user) { build(:user) }
      let(:service) { described_class.new(non_admin_user) }

      it 'returns permissions error message' do
        expect(operation[:status]).to eq(:error)
        expect(operation[:message]).to eq(""You are not authorized to perform this action"")
        expect(operation.reason).to eq :forbidden
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class MigrateRecordsToGhostUserInBatchesService
    LIMIT_SIZE = 1000

    def initialize
      @execution_tracker = Gitlab::Utils::ExecutionTracker.new
    end

    def execute
      ghost_user_migrations.each do |job|
        break if execution_tracker.over_limit?

        service = Users::MigrateRecordsToGhostUserService.new(
          job.user,
          job.initiator_user,
          execution_tracker
        )
        service.execute(hard_delete: job.hard_delete)
      rescue Gitlab::Utils::ExecutionTracker::ExecutionTimeOutError
        # no-op
      rescue StandardError => e
        ::Gitlab::ErrorTracking.track_exception(e)
        reschedule(job)
      end
    end

    private

    attr_reader :execution_tracker

    def ghost_user_migrations
      Users::GhostUserMigration.consume_order.limit(LIMIT_SIZE)
    end

    def reschedule(job)
      job.update(consume_after: 30.minutes.from_now)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::MigrateRecordsToGhostUserInBatchesService, feature_category: :user_management do
  let(:service) { described_class.new }

  let_it_be(:ghost_user_migration) { create(:ghost_user_migration) }

  describe '#execute' do
    it 'stops when execution time limit reached' do
      expect_next_instance_of(::Gitlab::Utils::ExecutionTracker) do |tracker|
        expect(tracker).to receive(:over_limit?).and_return(true)
      end

      expect(Users::MigrateRecordsToGhostUserService).not_to receive(:new)

      service.execute
    end

    it 'calls Users::MigrateRecordsToGhostUserService' do
      expect_next_instance_of(Users::MigrateRecordsToGhostUserService) do |service|
        expect(service).to(
          receive(:execute)
            .with(hard_delete: ghost_user_migration.hard_delete))
      end

      service.execute
    end

    it 'process jobs ordered by the consume_after timestamp' do
      older_ghost_user_migration = create(
        :ghost_user_migration,
        user: create(:user),
        consume_after: 5.minutes.ago
      )

      # setup execution tracker to only allow a single job to be processed
      allow_next_instance_of(::Gitlab::Utils::ExecutionTracker) do |tracker|
        allow(tracker).to receive(:over_limit?).and_return(false, true)
      end

      expect(Users::MigrateRecordsToGhostUserService).to(
        receive(:new).with(
          older_ghost_user_migration.user,
          older_ghost_user_migration.initiator_user,
          any_args
        )
      ).and_call_original

      service.execute
    end

    it 'reschedules job in case of an error', :freeze_time do
      expect_next_instance_of(Users::MigrateRecordsToGhostUserService) do |service|
        expect(service).to(receive(:execute)).and_raise(ActiveRecord::QueryCanceled)
      end
      expect(Gitlab::ErrorTracking).to receive(:track_exception)

      expect { service.execute }.to(
        change { ghost_user_migration.reload.consume_after }
          .to(30.minutes.from_now))
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class CreateService < BaseService
    include NewUserNotifier

    def initialize(current_user, params = {})
      @current_user = current_user
      @params = params.dup
    end

    def execute
      user = build_class.new(current_user, params).execute
      reset_token = user.generate_reset_token if user.recently_sent_password_reset?

      after_create_hook(user, reset_token) if user.save

      user
    end

    private

    def after_create_hook(user, reset_token)
      notify_new_user(user, reset_token)
    end

    def build_class
      # overridden by inheriting classes
      Users::BuildService
    end
  end
end

Users::CreateService.prepend_mod_with('Users::CreateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::CreateService, feature_category: :user_management do
  describe '#execute' do
    let(:password) { User.random_password }
    let(:admin_user) { create(:admin) }

    context 'with an admin user' do
      let(:service) { described_class.new(admin_user, params) }
      let(:email) { 'jd@example.com' }

      context 'when required parameters are provided' do
        let(:params) do
          { name: 'John Doe', username: 'jduser', email: email, password: password }
        end

        it 'returns a persisted user' do
          expect(service.execute).to be_persisted
        end

        it 'persists the given attributes' do
          user = service.execute
          user.reload

          expect(user).to have_attributes(
            name: params[:name],
            username: params[:username],
            email: params[:email],
            password: params[:password],
            created_by_id: admin_user.id
          )
        end

        context 'when the current_user is not persisted' do
          let(:admin_user) { build(:admin) }

          it 'persists the given attributes and sets created_by_id to nil' do
            user = service.execute
            user.reload

            expect(user).to have_attributes(
              name: params[:name],
              username: params[:username],
              email: params[:email],
              password: params[:password],
              created_by_id: nil
            )
          end
        end

        it 'user is not confirmed if skip_confirmation param is not present' do
          expect(service.execute).not_to be_confirmed
        end

        it 'logs the user creation' do
          expect(service).to receive(:log_info).with(""User \""John Doe\"" (jd@example.com) was created"")

          service.execute
        end

        it 'executes system hooks' do
          system_hook_service = spy(:system_hook_service)

          expect(service).to receive(:system_hook_service).and_return(system_hook_service)

          user = service.execute

          expect(system_hook_service).to have_received(:execute_hooks_for).with(user, :create)
        end

        it 'does not send a notification email' do
          notification_service = spy(:notification_service)

          expect(service).not_to receive(:notification_service)

          service.execute

          expect(notification_service).not_to have_received(:new_user)
        end
      end

      context 'when force_random_password parameter is true' do
        let(:params) do
          { name: 'John Doe', username: 'jduser', email: 'jd@example.com', password: password, force_random_password: true }
        end

        it 'generates random password' do
          user = service.execute

          expect(user.password).not_to eq password
          expect(user.password).to be_present
        end
      end

      context 'when password_automatically_set parameter is true' do
        let(:params) do
          {
            name: 'John Doe',
            username: 'jduser',
            email: 'jd@example.com',
            password: password,
            password_automatically_set: true
          }
        end

        it 'persists the given attributes' do
          user = service.execute
          user.reload

          expect(user).to have_attributes(
            name: params[:name],
            username: params[:username],
            email: params[:email],
            password: params[:password],
            created_by_id: admin_user.id,
            password_automatically_set: params[:password_automatically_set]
          )
        end
      end

      context 'when skip_confirmation parameter is true' do
        let(:params) do
          { name: 'John Doe', username: 'jduser', email: 'jd@example.com', password: password, skip_confirmation: true }
        end

        it 'confirms the user' do
          expect(service.execute).to be_confirmed
        end
      end

      context 'when reset_password parameter is true' do
        let(:params) do
          { name: 'John Doe', username: 'jduser', email: 'jd@example.com', password: password, reset_password: true }
        end

        it 'resets password even if a password parameter is given' do
          expect(service.execute).to be_recently_sent_password_reset
        end

        it 'sends a notification email' do
          notification_service = spy(:notification_service)

          expect(service).to receive(:notification_service).and_return(notification_service)

          user = service.execute

          expect(notification_service).to have_received(:new_user).with(user, an_instance_of(String))
        end
      end
    end

    context 'with nil user' do
      let(:params) do
        { name: 'John Doe', username: 'jduser', email: 'jd@example.com', password: password, skip_confirmation: true }
      end

      let(:service) { described_class.new(nil, params) }

      it 'persists the given attributes' do
        user = service.execute
        user.reload

        expect(user).to have_attributes(
          name: params[:name],
          username: params[:username],
          email: params[:email],
          password: params[:password],
          created_by_id: nil,
          admin: false
        )
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  class BatchStatusCleanerService
    BATCH_SIZE = 100

    # Cleanup BATCH_SIZE user_statuses records
    # rubocop: disable CodeReuse/ActiveRecord
    def self.execute(batch_size: BATCH_SIZE)
      scope = UserStatus
        .select(:user_id)
        .scheduled_for_cleanup
        .lock('FOR UPDATE SKIP LOCKED')
        .limit(batch_size)

      deleted_rows = UserStatus.where(user_id: scope).delete_all

      { deleted_rows: deleted_rows }
    end
    # rubocop: enable CodeReuse/ActiveRecord
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::BatchStatusCleanerService, feature_category: :user_management do
  let_it_be(:user_status_1) { create(:user_status, emoji: 'coffee', message: 'msg1', clear_status_at: 1.year.ago) }
  let_it_be(:user_status_2) { create(:user_status, emoji: 'coffee', message: 'msg1', clear_status_at: 1.year.from_now) }
  let_it_be(:user_status_3) { create(:user_status, emoji: 'coffee', message: 'msg1', clear_status_at: 2.years.ago) }
  let_it_be(:user_status_4) { create(:user_status, emoji: 'coffee', message: 'msg1') }

  subject(:result) { described_class.execute }

  it 'cleans up scheduled user statuses' do
    expect(result[:deleted_rows]).to eq(2)

    deleted_statuses = UserStatus.where(user_id: [user_status_1.user_id, user_status_3.user_id])
    expect(deleted_statuses).to be_empty
  end

  it 'does not affect rows with future clear_status_at' do
    expect { result }.not_to change { user_status_2.reload }
  end

  it 'does not affect rows without clear_status_at' do
    expect { result }.not_to change { user_status_4.reload }
  end

  describe 'batch_size' do
    it 'clears status in batches' do
      result = described_class.execute(batch_size: 1)

      expect(result[:deleted_rows]).to eq(1)

      result = described_class.execute(batch_size: 1)

      expect(result[:deleted_rows]).to eq(1)

      result = described_class.execute(batch_size: 1)

      expect(result[:deleted_rows]).to eq(0)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  module SavedReplies
    class DestroyService
      def initialize(saved_reply:)
        @saved_reply = saved_reply
      end

      def execute
        if saved_reply.destroy
          ServiceResponse.success(payload: { saved_reply: saved_reply })
        else
          ServiceResponse.error(message: saved_reply.errors.full_messages)
        end
      end

      private

      attr_reader :saved_reply
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::SavedReplies::DestroyService, feature_category: :team_planning do
  describe '#execute' do
    let!(:saved_reply) { create(:saved_reply) }

    subject { described_class.new(saved_reply: saved_reply).execute }

    context 'when destroy fails' do
      before do
        allow(saved_reply).to receive(:destroy).and_return(false)
      end

      it 'does not remove Saved Reply from database' do
        expect { subject }.not_to change(::Users::SavedReply, :count)
      end

      it { is_expected.not_to be_success }
    end

    context 'when destroy succeeds' do
      it { is_expected.to be_success }

      it 'removes Saved Reply from database' do
        expect { subject }.to change(::Users::SavedReply, :count).by(-1)
      end

      it 'returns saved reply' do
        expect(subject[:saved_reply]).to eq(saved_reply)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  module SavedReplies
    class UpdateService
      def initialize(saved_reply:, name:, content:)
        @saved_reply = saved_reply
        @name = name
        @content = content
      end

      def execute
        if saved_reply.update(name: name, content: content)
          ServiceResponse.success(payload: { saved_reply: saved_reply.reset })
        else
          ServiceResponse.error(message: saved_reply.errors.full_messages)
        end
      end

      private

      attr_reader :saved_reply, :name, :content
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::SavedReplies::UpdateService, feature_category: :team_planning do
  describe '#execute' do
    let_it_be(:current_user) { create(:user) }
    let_it_be(:saved_reply) { create(:saved_reply, user: current_user) }
    let_it_be(:other_saved_reply) { create(:saved_reply, user: current_user) }
    let_it_be(:saved_reply_from_other_user) { create(:saved_reply) }

    subject { described_class.new(saved_reply: saved_reply, name: name, content: content).execute }

    context 'when update fails' do
      let(:name) { other_saved_reply.name }
      let(:content) { '' }

      it { is_expected.not_to be_success }

      it 'returns error messages' do
        expect(subject.errors).to match_array([""Content can't be blank"", ""Name has already been taken""])
      end
    end

    context 'when update succeeds' do
      let(:name) { saved_reply_from_other_user.name }
      let(:content) { 'New content for Saved Reply' }

      it { is_expected.to be_success }

      it 'updates new Saved Reply in database' do
        expect { subject }.not_to change(::Users::SavedReply, :count)
      end

      it 'returns saved reply' do
        expect(subject[:saved_reply]).to eq(saved_reply)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  module SavedReplies
    class CreateService
      def initialize(current_user:, name:, content:)
        @current_user = current_user
        @name = name
        @content = content
      end

      def execute
        saved_reply = saved_replies.build(name: name, content: content)

        if saved_reply.save
          ServiceResponse.success(payload: { saved_reply: saved_reply })
        else
          ServiceResponse.error(message: saved_reply.errors.full_messages)
        end
      end

      private

      attr_reader :current_user, :name, :content

      delegate :saved_replies, to: :current_user
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::SavedReplies::CreateService, feature_category: :team_planning do
  describe '#execute' do
    let_it_be(:current_user) { create(:user) }
    let_it_be(:saved_reply) { create(:saved_reply, user: current_user) }

    subject { described_class.new(current_user: current_user, name: name, content: content).execute }

    context 'when create fails' do
      let(:name) { saved_reply.name }
      let(:content) { '' }

      it { is_expected.not_to be_success }

      it 'does not create new Saved Reply in database' do
        expect { subject }.not_to change(::Users::SavedReply, :count)
      end

      it 'returns error messages' do
        expect(subject.errors).to match_array([""Content can't be blank"", ""Name has already been taken""])
      end
    end

    context 'when create succeeds' do
      let(:name) { 'new_saved_reply_name' }
      let(:content) { 'New content for Saved Reply' }

      it { is_expected.to be_success }

      it 'creates new Saved Reply in database' do
        expect { subject }.to change(::Users::SavedReply, :count).by(1)
      end

      it 'returns new saved reply', :aggregate_failures do
        expect(subject[:saved_reply]).to eq(::Users::SavedReply.last)
        expect(subject[:saved_reply].name).to eq(name)
        expect(subject[:saved_reply].content).to eq(content)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  module EmailVerification
    class ValidateTokenService < EmailVerification::BaseService
      include ActionView::Helpers::DateHelper

      TOKEN_VALID_FOR_MINUTES = 60

      def initialize(attr:, user:, token:)
        super(attr: attr, user: user)

        @token = token
      end

      def execute
        return failure(:rate_limited) if verification_rate_limited?
        return failure(:invalid) unless valid?
        return failure(:expired) if expired_token?

        success
      end

      private

      attr_reader :user

      def verification_rate_limited?
        Gitlab::ApplicationRateLimiter.throttled?(:email_verification, scope: user[attr])
      end

      def valid?
        return false unless token.present?

        Devise.secure_compare(user[attr], digest)
      end

      def expired_token?
        generated_at = case attr
                       when :unlock_token then user.locked_at
                       when :confirmation_token then user.confirmation_sent_at
                       end

        generated_at < TOKEN_VALID_FOR_MINUTES.minutes.ago
      end

      def success
        { status: :success }
      end

      def failure(reason)
        {
          status: :failure,
          reason: reason,
          message: failure_message(reason)
        }
      end

      def failure_message(reason)
        case reason
        when :rate_limited
          format(s_(""IdentityVerification|You've reached the maximum amount of tries. ""\
             'Wait %{interval} or send a new code and try again.'), interval: email_verification_interval)
        when :expired
          s_('IdentityVerification|The code has expired. Send a new code and try again.')
        when :invalid
          s_('IdentityVerification|The code is incorrect. Enter it again, or send a new code.')
        end
      end

      def email_verification_interval
        interval_in_seconds = Gitlab::ApplicationRateLimiter.rate_limits[:email_verification][:interval]
        distance_of_time_in_words(interval_in_seconds)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::EmailVerification::ValidateTokenService, :clean_gitlab_redis_rate_limiting, feature_category: :system_access do
  using RSpec::Parameterized::TableSyntax

  let(:service) { described_class.new(attr: attr, user: user, token: token) }
  let(:email) { build_stubbed(:user).email }
  let(:token) { 'token' }
  let(:encrypted_token) { Devise.token_generator.digest(User, email, token) }
  let(:generated_at_attr) { attr == :unlock_token ? :locked_at : :confirmation_sent_at }
  let(:token_generated_at) { 1.minute.ago }
  let(:user) { build(:user, email: email, attr => encrypted_token, generated_at_attr => token_generated_at) }

  describe '#execute' do
    context 'with a valid attribute' do
      where(:attr) { [:unlock_token, :confirmation_token] }

      with_them do
        context 'when successful' do
          it 'returns a success status' do
            expect(service.execute).to eq(status: :success)
          end
        end

        context 'when rate limited' do
          before do
            allow(Gitlab::ApplicationRateLimiter).to receive(:throttled?)
              .with(:email_verification, scope: encrypted_token).and_return(true)
          end

          it 'returns a failure status' do
            expect(service.execute).to eq(
              {
                status: :failure,
                reason: :rate_limited,
                message: format(s_(""IdentityVerification|You've reached the maximum amount of tries. ""\
                         'Wait %{interval} or send a new code and try again.'), interval: '10 minutes')
              }
            )
          end
        end

        context 'when expired' do
          let(:token_generated_at) { 2.hours.ago }

          it 'returns a failure status' do
            expect(service.execute).to eq(
              {
                status: :failure,
                reason: :expired,
                message: s_('IdentityVerification|The code has expired. Send a new code and try again.')
              }
            )
          end
        end

        context 'when invalid' do
          let(:encrypted_token) { 'xxx' }

          it 'returns a failure status' do
            expect(service.execute).to eq(
              {
                status: :failure,
                reason: :invalid,
                message: s_('IdentityVerification|The code is incorrect. Enter it again, or send a new code.')
              }
            )
          end
        end

        context 'when encrypted token was not set and a blank token is provided' do
          let(:encrypted_token) { nil }
          let(:token) { '' }

          it 'returns a failure status' do
            expect(service.execute).to eq(
              {
                status: :failure,
                reason: :invalid,
                message: s_('IdentityVerification|The code is incorrect. Enter it again, or send a new code.')
              }
            )
          end
        end
      end
    end

    context 'with an invalid attribute' do
      let(:attr) { :username }

      it 'raises an error' do
        expect { service.execute }.to raise_error(ArgumentError, 'Invalid attribute')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  module EmailVerification
    class GenerateTokenService < EmailVerification::BaseService
      TOKEN_LENGTH = 6

      def execute
        @token = generate_token

        [token, digest]
      end

      private

      def generate_token
        SecureRandom.random_number(10**TOKEN_LENGTH).to_s.rjust(TOKEN_LENGTH, '0')
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::EmailVerification::GenerateTokenService, feature_category: :system_access do
  using RSpec::Parameterized::TableSyntax

  let(:user) { build_stubbed(:user) }
  let(:service) { described_class.new(attr: attr, user: user) }
  let(:token) { 'token' }
  let(:digest) { service.send(:digest) }

  describe '#execute' do
    context 'with a valid attribute' do
      where(:attr) { [:unlock_token, :confirmation_token] }

      with_them do
        before do
          allow_next_instance_of(described_class) do |service|
            allow(service).to receive(:generate_token).and_return(token)
          end
        end

        it ""returns a token and it's digest"" do
          expect(service.execute).to eq([token, digest])
        end
      end
    end

    context 'with an invalid attribute' do
      let(:attr) { :xxx }

      it 'raises an error' do
        expect { service.execute }.to raise_error(ArgumentError, 'Invalid attribute')
      end
    end

    context 'when similar tokens are generated' do
      let(:attr) { :confirmation_token }

      before do
        allow_next_instance_of(described_class) do |service|
          allow(service).to receive(:generate_token).and_return(token)
        end
      end

      it 'generates a unique digest' do
        second_service = described_class.new(attr: attr, user: build_stubbed(:user))

        expect(service.execute[1]).not_to eq(second_service.execute[1])
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Users
  module EmailVerification
    class UpdateEmailService
      include ActionView::Helpers::DateHelper

      RATE_LIMIT = :email_verification_code_send

      def initialize(user:)
        @user = user
      end

      def execute(email:)
        return failure(:rate_limited) if rate_limited?
        return failure(:already_offered) if already_offered?
        return failure(:no_change) if no_change?(email)
        return failure(:validation_error) unless update_email

        success
      end

      private

      attr_reader :user

      def rate_limited?
        Gitlab::ApplicationRateLimiter.throttled?(RATE_LIMIT, scope: user)
      end

      def already_offered?
        user.email_reset_offered_at.present?
      end

      def no_change?(email)
        user.email = email
        !user.will_save_change_to_email?
      end

      def update_email
        user.skip_confirmation_notification!
        user.save
      end

      def success
        { status: :success }
      end

      def failure(reason)
        {
          status: :failure,
          reason: reason,
          message: failure_message(reason)
        }
      end

      def failure_message(reason)
        case reason
        when :rate_limited
          interval = distance_of_time_in_words(Gitlab::ApplicationRateLimiter.rate_limits[RATE_LIMIT][:interval])
          format(
            s_(""IdentityVerification|You've reached the maximum amount of tries. Wait %{interval} and try again.""),
            interval: interval
          )
        when :already_offered
          s_('IdentityVerification|Email update is only offered once.')
        when :no_change
          s_('IdentityVerification|A code has already been sent to this email address. ' \
             'Check your spam folder or enter another email address.')
        when :validation_error
          user.errors.full_messages.join(' ')
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Users::EmailVerification::UpdateEmailService, feature_category: :instance_resiliency do
  let_it_be_with_reload(:user) { create(:user) }
  let(:email) { build_stubbed(:user).email }

  describe '#execute' do
    subject(:execute_service) { described_class.new(user: user).execute(email: email) }

    context 'when successful' do
      it { is_expected.to eq(status: :success) }

      it 'does not send a confirmation instructions email' do
        expect { execute_service }.not_to have_enqueued_mail(DeviseMailer, :confirmation_instructions)
      end

      it 'sets the unconfirmed_email and confirmation_sent_at fields', :freeze_time do
        expect { execute_service }
          .to change { user.unconfirmed_email }.from(nil).to(email)
          .and change { user.confirmation_sent_at }.from(nil).to(Time.current)
      end
    end

    context 'when rate limited' do
      before do
        allow(Gitlab::ApplicationRateLimiter).to receive(:throttled?)
          .with(:email_verification_code_send, scope: user).and_return(true)
      end

      it 'returns a failure status' do
        expect(execute_service).to eq(
          {
            status: :failure,
            reason: :rate_limited,
            message: format(s_(""IdentityVerification|You've reached the maximum amount of tries. "" \
                               'Wait %{interval} and try again.'), interval: 'about 1 hour')
          }
        )
      end
    end

    context 'when email reset has already been offered' do
      before do
        user.email_reset_offered_at = 1.minute.ago
      end

      it 'returns a failure status' do
        expect(execute_service).to eq(
          {
            status: :failure,
            reason: :already_offered,
            message: s_('IdentityVerification|Email update is only offered once.')
          }
        )
      end
    end

    context 'when email is unchanged' do
      let(:email) { user.email }

      it 'returns a failure status' do
        expect(execute_service).to eq(
          {
            status: :failure,
            reason: :no_change,
            message: s_('IdentityVerification|A code has already been sent to this email address. ' \
                        'Check your spam folder or enter another email address.')
          }
        )
      end
    end

    context 'when email is missing' do
      let(:email) { '' }

      it 'returns a failure status' do
        expect(execute_service).to eq(
          {
            status: :failure,
            reason: :validation_error,
            message: ""Email can't be blank""
          }
        )
      end
    end

    context 'when email is not valid' do
      let(:email) { 'xxx' }

      it 'returns a failure status' do
        expect(execute_service).to eq(
          {
            status: :failure,
            reason: :validation_error,
            message: 'Email is invalid'
          }
        )
      end
    end

    context 'when email is already taken' do
      before do
        create(:user, email: email)
      end

      it 'returns a failure status' do
        expect(execute_service).to eq(
          {
            status: :failure,
            reason: :validation_error,
            message: 'Email has already been taken'
          }
        )
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ServiceDeskSettings
  class UpdateService < BaseService
    include ::ServiceDesk::CustomEmails::Logger

    def execute
      settings = ServiceDeskSetting.safe_find_or_create_by!(project_id: project.id)

      params[:project_key] = nil if params[:project_key].blank?

      apply_feature_flag_restrictions!

      # We want to know when custom email got enabled
      write_log_message = params[:custom_email_enabled].present? && !settings.custom_email_enabled?

      if settings.update(params)
        log_info if write_log_message

        ServiceResponse.success
      else
        ServiceResponse.error(message: settings.errors.full_messages.to_sentence)
      end
    end

    private

    def apply_feature_flag_restrictions!
      return if Feature.enabled?(:issue_email_participants, project)
      return unless params.include?(:add_external_participants_from_cc)

      params.delete(:add_external_participants_from_cc)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ServiceDeskSettings::UpdateService, :aggregate_failures, feature_category: :service_desk do
  describe '#execute' do
    let_it_be(:settings) do
      create(:service_desk_setting, outgoing_name: 'original name', custom_email: 'user@example.com')
    end

    let_it_be(:credential) { create(:service_desk_custom_email_credential, project: settings.project) }
    let_it_be(:verification) { create(:service_desk_custom_email_verification, :finished, project: settings.project) }
    let_it_be(:user) { create(:user) }

    context 'with valid params' do
      let(:params) { { outgoing_name: 'some name', project_key: 'foo', add_external_participants_from_cc: true } }

      it 'updates service desk settings' do
        response = described_class.new(settings.project, user, params).execute

        expect(response).to be_success
        expect(settings.reset).to have_attributes(
          outgoing_name: 'some name',
          project_key: 'foo',
          add_external_participants_from_cc: true
        )
      end

      context 'with custom email verification in finished state' do
        let(:params) { { custom_email_enabled: true } }

        before do
          allow(Gitlab::AppLogger).to receive(:info)
        end

        it 'allows to enable custom email' do
          settings.project.reset

          response = described_class.new(settings.project, user, params).execute

          expect(response).to be_success
          expect(settings.reset.custom_email_enabled).to be true
          expect(Gitlab::AppLogger).to have_received(:info).with({ category: 'custom_email' })
        end
      end

      context 'when issue_email_participants feature flag is disabled' do
        before do
          stub_feature_flags(issue_email_participants: false)
        end

        it 'updates service desk setting but not add_external_participants_from_cc value' do
          response = described_class.new(settings.project, user, params).execute

          expect(response).to be_success
          expect(settings.reset).to have_attributes(
            outgoing_name: 'some name',
            project_key: 'foo',
            add_external_participants_from_cc: false
          )
        end
      end
    end

    context 'when project_key is an empty string' do
      let(:params) { { project_key: '' } }

      it 'sets nil project_key' do
        response = described_class.new(settings.project, user, params).execute

        expect(response).to be_success
        expect(settings.reload.project_key).to be_nil
      end
    end

    context 'with invalid params' do
      let(:params) { { outgoing_name: 'x' * 256 } }

      it 'does not update service desk settings' do
        response = described_class.new(settings.project, user, params).execute

        expect(response).to be_error
        expect(response.message).to eq 'Outgoing name is too long (maximum is 255 characters)'
        expect(settings.reload.outgoing_name).to eq 'original name'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  class ExportCsvService < ExportCsv::BaseService
    NotAvailableError = StandardError.new('This feature is currently behind a feature flag and it is not available.')

    def csv_data
      raise NotAvailableError unless Feature.enabled?(:import_export_work_items_csv, resource_parent)

      super
    end

    def email(mail_to_user)
      Notify.export_work_items_csv_email(mail_to_user, resource_parent, csv_data, csv_builder.status).deliver_now
    end

    private

    def associations_to_preload
      [:project, [work_item_type: :enabled_widget_definitions], :author]
    end

    def header_to_value_hash
      {
        'Id' => 'iid',
        'Title' => 'title',
        'Description' => ->(work_item) { get_widget_value_for(work_item, :description) },
        'Type' => ->(work_item) { work_item.work_item_type.name },
        'Author' => 'author_name',
        'Author Username' => ->(work_item) { work_item.author.username },
        'Created At (UTC)' => ->(work_item) { work_item.created_at.to_fs(:csv) }
      }
    end

    def get_widget_value_for(work_item, field)
      widget_name = field_to_widget_map[field]
      widget = work_item.get_widget(widget_name)

      widget.try(field)
    end

    def field_to_widget_map
      {
        description: :description
      }
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WorkItems::ExportCsvService, :with_license, feature_category: :team_planning do
  let_it_be(:user) { create(:user) }
  let_it_be(:group) { create(:group) }
  let_it_be(:project) { create(:project, :public, group: group) }
  let_it_be(:work_item_1) { create(:work_item, description: 'test', project: project) }
  let_it_be(:work_item_2) { create(:work_item, :incident, project: project) }

  subject { described_class.new(WorkItem.all, project) }

  def csv
    CSV.parse(subject.csv_data, headers: true)
  end

  context 'when import_export_work_items_csv flag is not enabled' do
    before do
      stub_feature_flags(import_export_work_items_csv: false)
    end

    it 'renders an error' do
      expect { subject.csv_data }.to raise_error(described_class::NotAvailableError)
    end
  end

  it 'renders csv to string' do
    expect(subject.csv_data).to be_a String
  end

  describe '#email' do
    it 'emails csv' do
      expect { subject.email(user) }.to change { ActionMailer::Base.deliveries.count }.from(0).to(1)
    end
  end

  it 'returns two work items' do
    expect(csv.count).to eq(2)
  end

  specify 'iid' do
    expect(csv[0]['Id']).to eq work_item_1.iid.to_s
  end

  specify 'title' do
    expect(csv[0]['Title']).to eq work_item_1.title
  end

  specify 'type' do
    expect(csv[0]['Type']).to eq('Issue')
    expect(csv[1]['Type']).to eq('Incident')
  end

  specify 'author name' do
    expect(csv[0]['Author']).to eq(work_item_1.author_name)
  end

  specify 'author username' do
    expect(csv[0]['Author Username']).to eq(work_item_1.author.username)
  end

  specify 'created_at' do
    expect(csv[0]['Created At (UTC)']).to eq(work_item_1.created_at.to_fs(:csv))
  end

  specify 'description' do
    expect(csv[0]['Description']).to be_present
    expect(csv[0]['Description']).to eq(work_item_1.description)
  end

  it 'preloads fields to avoid N+1 queries' do
    control = ActiveRecord::QueryRecorder.new { subject.csv_data }

    create(:work_item, :task, project: project)

    expect { subject.csv_data }.not_to exceed_query_limit(control)
  end

  it_behaves_like 'a service that returns invalid fields from selection'

  # TODO - once we have a UI for this feature
  # we can turn these into feature specs.
  # more info at: https://gitlab.com/gitlab-org/gitlab/-/issues/396943
  context 'when importing an exported file' do
    context 'for work item of type issue' do
      it_behaves_like 'a exported file that can be imported' do
        let_it_be(:user) { create(:user) }
        let_it_be(:origin_project) { create(:project) }
        let_it_be(:target_project) { create(:project) }
        let_it_be(:work_item) { create(:work_item, project: origin_project) }

        let(:expected_matching_fields) { %w[title work_item_type] }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  class DeleteTaskService
    def initialize(work_item:, lock_version:, current_user: nil, task_params: {})
      @work_item = work_item
      @current_user = current_user
      @task_params = task_params
      @lock_version = lock_version
      @task = task_params[:task]
      @errors = []
    end

    def execute
      transaction_result = ::WorkItem.transaction do
        replacement_result = TaskListReferenceRemovalService.new(
          work_item: @work_item,
          task: @task,
          line_number_start: @task_params[:line_number_start],
          line_number_end: @task_params[:line_number_end],
          lock_version: @lock_version,
          current_user: @current_user
        ).execute

        next ::ServiceResponse.error(message: replacement_result.errors, http_status: 422) if replacement_result.error?

        delete_result = ::WorkItems::DeleteService.new(
          container: @task.project,
          current_user: @current_user
        ).execute(@task)

        if delete_result.error?
          @errors += delete_result.errors
          raise ActiveRecord::Rollback
        end

        delete_result
      end

      return transaction_result if transaction_result

      ::ServiceResponse.error(message: @errors, http_status: 422)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WorkItems::DeleteTaskService, feature_category: :team_planning do
  let_it_be(:project) { create(:project) }
  let_it_be(:developer) { create(:user).tap { |u| project.add_developer(u) } }
  let_it_be_with_refind(:task) { create(:work_item, project: project, author: developer) }
  let_it_be_with_refind(:list_work_item) do
    create(:work_item, project: project, description: ""- [ ] #{task.to_reference}+"")
  end

  let(:current_user) { developer }
  let(:line_number_start) { 1 }
  let(:params) do
    {
      line_number_start: line_number_start,
      line_number_end: 1,
      task: task
    }
  end

  before_all do
    create(:issue_link, source_id: list_work_item.id, target_id: task.id)
  end

  shared_examples 'failing WorkItems::DeleteTaskService' do |error_message|
    it { is_expected.to be_error }

    it 'does not remove work item or issue links' do
      expect do
        service_result
        list_work_item.reload
      end.to not_change(WorkItem, :count).and(
        not_change(IssueLink, :count)
      ).and(
        not_change(list_work_item, :description)
      )
    end

    it 'returns an error message' do
      expect(service_result.errors).to contain_exactly(error_message)
    end
  end

  describe '#execute' do
    subject(:service_result) do
      described_class.new(
        work_item: list_work_item,
        current_user: current_user,
        lock_version: list_work_item.lock_version,
        task_params: params
      ).execute
    end

    context 'when work item params are valid' do
      it { is_expected.to be_success }

      it 'deletes the work item and the related issue link' do
        expect do
          service_result
        end.to change(WorkItem, :count).by(-1).and(
          change(IssueLink, :count).by(-1)
        )
      end

      it 'removes the task list item with the work item reference' do
        expect do
          service_result
        end.to change(list_work_item, :description).from(list_work_item.description).to(""- [ ] #{task.title}"")
      end
    end

    context 'when first operation fails' do
      let(:line_number_start) { -1 }

      it_behaves_like 'failing WorkItems::DeleteTaskService', 'line_number_start must be greater than 0'
    end

    context 'when last operation fails' do
      let_it_be(:non_member_user) { create(:user) }

      let(:current_user) { non_member_user }

      it_behaves_like 'failing WorkItems::DeleteTaskService', 'User not authorized to delete work item'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  class PrepareImportCsvService < Import::PrepareService
    extend ::Gitlab::Utils::Override

    private

    override :worker
    def worker
      ImportWorkItemsCsvWorker
    end

    override :success_message
    def success_message
      _(""Your work items are being imported. Once finished, you'll receive a confirmation email."")
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WorkItems::PrepareImportCsvService, feature_category: :team_planning do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }

  let(:file) { double }
  let(:upload_service) { double }
  let(:uploader) { double }
  let(:upload) { double }

  let(:subject) do
    described_class.new(project, user, file: file).execute
  end

  context 'when file is uploaded correctly' do
    let(:upload_id) { 99 }

    before do
      mock_upload
    end

    it 'returns a success message' do
      result = subject

      expect(result[:status]).to eq(:success)
      expect(result[:message]).to eq(
        ""Your work items are being imported. Once finished, you'll receive a confirmation email."")
    end

    it 'enqueues the ImportWorkItemsCsvWorker' do
      expect(WorkItems::ImportWorkItemsCsvWorker).to receive(:perform_async).with(user.id, project.id, upload_id)

      subject
    end
  end

  context 'when file upload fails' do
    before do
      mock_upload(false)
    end

    it 'returns an error message' do
      result = subject

      expect(result[:status]).to eq(:error)
      expect(result[:message]).to eq('File upload error.')
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  class TaskListReferenceReplacementService
    STALE_OBJECT_MESSAGE = 'Stale work item. Check lock version'

    def initialize(work_item:, current_user:, work_item_reference:, line_number_start:, line_number_end:, title:, lock_version:)
      @work_item = work_item
      @current_user = current_user
      @work_item_reference = work_item_reference
      @line_number_start = line_number_start
      @line_number_end = line_number_end
      @title = title
      @lock_version = lock_version
    end

    def execute
      return ::ServiceResponse.error(message: STALE_OBJECT_MESSAGE) if @work_item.lock_version > @lock_version
      return ::ServiceResponse.error(message: 'line_number_start must be greater than 0') if @line_number_start < 1
      return ::ServiceResponse.error(message: 'line_number_end must be greater or equal to line_number_start') if @line_number_end < @line_number_start
      return ::ServiceResponse.error(message: ""Work item description can't be blank"") if @work_item.description.blank?

      source_lines = @work_item.description.split(""\n"")
      markdown_task_first_line = source_lines[@line_number_start - 1]
      task_line = Taskable::ITEM_PATTERN.match(markdown_task_first_line)

      return ::ServiceResponse.error(message: ""Unable to detect a task on line #{@line_number_start}"") unless task_line

      captures = task_line.captures

      markdown_task_first_line.sub!(Taskable::ITEM_PATTERN, ""#{captures[0]} #{captures[1]} #{@work_item_reference}+"")

      source_lines[@line_number_start - 1] = markdown_task_first_line
      remove_additional_lines!(source_lines)

      ::WorkItems::UpdateService.new(
        container: @work_item.project,
        current_user: @current_user,
        params: { description: source_lines.join(""\n""), lock_version: @lock_version }
      ).execute(@work_item)

      ::ServiceResponse.success
    rescue ActiveRecord::StaleObjectError
      ::ServiceResponse.error(message: STALE_OBJECT_MESSAGE)
    end

    private

    def remove_additional_lines!(source_lines)
      return if @line_number_end <= @line_number_start

      source_lines.delete_if.each_with_index do |_line, index|
        index >= @line_number_start && index < @line_number_end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WorkItems::TaskListReferenceReplacementService, feature_category: :team_planning do
  let_it_be(:developer) { create(:user) }
  let_it_be(:project) { create(:project, :repository).tap { |project| project.add_developer(developer) } }
  let_it_be(:single_line_work_item, refind: true) { create(:work_item, project: project, description: '- [ ] single line', lock_version: 3) }
  let_it_be(:multiple_line_work_item, refind: true) { create(:work_item, project: project, description: ""Any text\n\n* [ ] Item to be converted\n    second line\n    third line"", lock_version: 3) }

  let(:line_number_start) { 3 }
  let(:line_number_end) { 5 }
  let(:title) { 'work item title' }
  let(:reference) { 'any reference' }
  let(:work_item) { multiple_line_work_item }
  let(:lock_version) { 3 }
  let(:expected_additional_text) { '' }

  shared_examples 'successful work item task reference replacement service' do
    it { is_expected.to be_success }

    it 'replaces the original issue markdown description with new work item reference' do
      result

      expect(work_item.description).to eq(""#{expected_additional_text}#{task_prefix} #{reference}+"")
    end
  end

  shared_examples 'failing work item task reference replacement service' do |error_message|
    it { is_expected.to be_error }

    it 'returns an error message' do
      expect(result.errors).to contain_exactly(error_message)
    end
  end

  describe '#execute' do
    subject(:result) do
      described_class.new(
        work_item: work_item,
        current_user: developer,
        work_item_reference: reference,
        line_number_start: line_number_start,
        line_number_end: line_number_end,
        title: title,
        lock_version: lock_version
      ).execute
    end

    context 'when task mardown spans a single line' do
      let(:line_number_start) { 1 }
      let(:line_number_end) { 1 }
      let(:work_item) { single_line_work_item }
      let(:task_prefix) { '- [ ]' }

      it_behaves_like 'successful work item task reference replacement service'

      it 'creates description version note' do
        expect { result }.to change(Note, :count).by(1)
        expect(work_item.notes.last.note).to eq('changed the description')
        expect(work_item.saved_description_version.id).to eq(work_item.notes.last.system_note_metadata.description_version_id)
      end
    end

    context 'when task mardown spans multiple lines' do
      let(:task_prefix) { '* [ ]' }
      let(:expected_additional_text) { ""Any text\n\n"" }

      it_behaves_like 'successful work item task reference replacement service'
    end

    context 'when description does not contain a task' do
      let_it_be(:no_matching_work_item) { create(:work_item, project: project, description: 'no matching task') }

      let(:work_item) { no_matching_work_item }

      it_behaves_like 'failing work item task reference replacement service', 'Unable to detect a task on line 3'
    end

    context 'when description is empty' do
      let_it_be(:empty_work_item) { create(:work_item, project: project, description: '') }

      let(:work_item) { empty_work_item }

      it_behaves_like 'failing work item task reference replacement service', ""Work item description can't be blank""
    end

    context 'when line_number_start is lower than 1' do
      let(:line_number_start) { 0 }

      it_behaves_like 'failing work item task reference replacement service', 'line_number_start must be greater than 0'
    end

    context 'when line_number_end is lower than line_number_start' do
      let(:line_number_end) { line_number_start - 1 }

      it_behaves_like 'failing work item task reference replacement service', 'line_number_end must be greater or equal to line_number_start'
    end

    context 'when lock_version is older than current' do
      let(:lock_version) { 2 }

      it_behaves_like 'failing work item task reference replacement service', 'Stale work item. Check lock version'
    end

    context 'when work item is stale before updating' do
      it_behaves_like 'failing work item task reference replacement service', 'Stale work item. Check lock version' do
        before do
          ::WorkItem.where(id: work_item.id).update_all(lock_version: lock_version + 1)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  class ImportCsvService < ImportCsv::BaseService
    extend ::Gitlab::Utils::Override

    FeatureNotAvailableError = StandardError.new(
      'This feature is currently behind a feature flag and it is not available.'
    )
    NotAuthorizedError = StandardError.new('You do not have permission to import work items in this project.')

    override :initialize
    def initialize(*args)
      super

      @type_errors = {
        blank: [],
        missing: {},
        disallowed: {}
      }
    end

    def self.required_headers
      %w[title type].freeze
    end

    def execute
      raise FeatureNotAvailableError if ::Feature.disabled?(:import_export_work_items_csv, project)
      raise NotAuthorizedError unless Ability.allowed?(user, :import_work_items, project)

      super
    end

    def email_results_to_user
      Notify.import_work_items_csv_email(user.id, project.id, results).deliver_later
    end

    private

    attr_accessor :type_errors

    def create_object(attributes)
      super[:work_item]
    end

    def create_object_class
      ::WorkItems::CreateService
    end

    override :attributes_for
    def attributes_for(row)
      {
        title: row[:title],
        work_item_type: match_work_item_type(row[:type])
      }
    end

    override :validate_headers_presence!
    def validate_headers_presence!(headers)
      required_headers = self.class.required_headers

      headers.downcase!
      return if headers && required_headers.all? { |rh| headers.include?(rh) }

      required_headers_message = ""Required headers are missing. Required headers are #{required_headers.join(', ')}""
      raise CSV::MalformedCSVError.new(required_headers_message, 1)
    end

    def match_work_item_type(work_item_type)
      match = available_work_item_types[work_item_type&.downcase]
      match[:type] if match
    end

    def available_work_item_types
      {
        issue: {
          allowed: Ability.allowed?(user, :create_issue, project),
          type: WorkItems::Type.default_by_type(:issue)
        }
      }.with_indifferent_access
    end
    strong_memoize_attr :available_work_item_types

    def preprocess!
      with_csv_lines.each do |row, line_no|
        work_item_type = row[:type]&.strip&.downcase

        if work_item_type.blank?
          type_errors[:blank] << line_no
        elsif missing?(work_item_type)
          # does this work item exist in the range of work items we support?
          (type_errors[:missing][work_item_type] ||= []) << line_no
        elsif !allowed?(work_item_type)
          (type_errors[:disallowed][work_item_type] ||= []) << line_no
        end
      end

      return if type_errors[:blank].empty? &&
        type_errors[:missing].blank? &&
        type_errors[:disallowed].blank?

      results[:type_errors] = type_errors
      raise PreprocessError
    end

    def missing?(work_item_type_name)
      !available_work_item_types.key?(work_item_type_name)
    end

    def allowed?(work_item_type_name)
      !!available_work_item_types[work_item_type_name][:allowed]
    end
  end
end

WorkItems::ImportCsvService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WorkItems::ImportCsvService, feature_category: :team_planning do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }
  let_it_be(:author) { create(:user, username: 'csv_author') }
  let(:file) { fixture_file_upload('spec/fixtures/work_items_valid_types.csv') }
  let(:service) do
    uploader = FileUploader.new(project)
    uploader.store!(file)

    described_class.new(user, project, uploader)
  end

  let_it_be(:issue_type) { ::WorkItems::Type.default_issue_type }

  let(:work_items) { ::WorkItems::WorkItemsFinder.new(user, project: project).execute }
  let(:email_method) { :import_work_items_csv_email }

  subject { service.execute }

  describe '#execute', :aggregate_failures do
    context 'when user has permission' do
      before do
        project.add_reporter(user)
      end

      it_behaves_like 'importer with email notification'

      context 'when file format is valid' do
        context 'when work item types are available' do
          it 'creates the expected number of work items' do
            expect { subject }.to change { work_items.count }.by 2
          end

          it 'sets work item attributes' do
            result = subject

            expect(work_items.reload).to contain_exactly(
              have_attributes(
                title: 'Valid issue',
                work_item_type_id: issue_type.id
              ),
              have_attributes(
                title: 'Valid issue with alternate case',
                work_item_type_id: issue_type.id
              )
            )

            expect(result[:success]).to eq(2)
            expect(result[:error_lines]).to eq([])
            expect(result[:type_errors]).to be_nil
            expect(result[:parse_error]).to eq(false)
          end
        end

        context 'when csv contains work item types that are missing or not available' do
          let(:file) { fixture_file_upload('spec/fixtures/work_items_invalid_types.csv') }

          it 'creates no work items' do
            expect { subject }.not_to change { work_items.count }
          end

          it 'returns the correct result' do
            result = subject

            expect(result[:success]).to eq(0)
            expect(result[:error_lines]).to be_empty # there are problematic lines detailed below
            expect(result[:parse_error]).to eq(false)
            expect(result[:type_errors]).to match({
              blank: [4],
              disallowed: {}, # tested in the EE version
              missing: {
                ""isssue"" => [2],
                ""issue!!"" => [3]
              }
            })
          end
        end
      end

      context 'when file is missing necessary headers' do
        let(:file) { fixture_file_upload('spec/fixtures/work_items_missing_header.csv') }

        it 'creates no records' do
          result = subject

          expect(result[:success]).to eq(0)
          expect(result[:error_lines]).to eq([1])
          expect(result[:type_errors]).to be_nil
          expect(result[:parse_error]).to eq(true)
        end

        it 'creates no work items' do
          expect { subject }.not_to change { work_items.count }
        end
      end

      context 'when import_export_work_items_csv feature flag is off' do
        before do
          stub_feature_flags(import_export_work_items_csv: false)
        end

        it 'raises an error' do
          expect { subject }.to raise_error(/This feature is currently behind a feature flag and it is not available./)
        end
      end
    end

    context 'when user does not have permission' do
      before do
        project.add_guest(user)
      end

      it 'raises an error' do
        expect { subject }.to raise_error(/You do not have permission to import work items in this project/)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  class CreateFromTaskService
    def initialize(work_item:, perform_spam_check: true, current_user: nil, work_item_params: {})
      @work_item = work_item
      @current_user = current_user
      @work_item_params = work_item_params
      @perform_spam_check = perform_spam_check
      @errors = []
    end

    def execute
      transaction_result = ApplicationRecord.transaction do
        create_and_link_result = CreateAndLinkService.new(
          project: @work_item.project,
          current_user: @current_user,
          params: @work_item_params.slice(:title, :work_item_type_id),
          perform_spam_check: @perform_spam_check,
          link_params: { parent_work_item: @work_item }
        ).execute

        if create_and_link_result.error?
          @errors += create_and_link_result.errors
          raise ActiveRecord::Rollback
        end

        replacement_result = TaskListReferenceReplacementService.new(
          work_item: @work_item,
          current_user: @current_user,
          work_item_reference: create_and_link_result[:work_item].to_reference,
          line_number_start: @work_item_params[:line_number_start],
          line_number_end: @work_item_params[:line_number_end],
          title: @work_item_params[:title],
          lock_version: @work_item_params[:lock_version]
        ).execute

        if replacement_result.error?
          @errors += replacement_result.errors
          raise ActiveRecord::Rollback
        end

        create_and_link_result
      end

      return transaction_result if transaction_result

      ::ServiceResponse.error(message: @errors, http_status: 422)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WorkItems::CreateFromTaskService, feature_category: :team_planning do
  let_it_be(:project) { create(:project) }
  let_it_be(:developer) { create(:user) }
  let_it_be(:list_work_item, refind: true) { create(:work_item, project: project, description: ""- [ ] Item to be converted\n    second line\n    third line"") }

  let(:work_item_to_update) { list_work_item }
  let(:link_params) { {} }
  let(:current_user) { developer }
  let(:params) do
    {
      title: 'Awesome work item',
      work_item_type_id: WorkItems::Type.default_by_type(:task).id,
      line_number_start: 1,
      line_number_end: 3,
      lock_version: work_item_to_update.lock_version
    }
  end

  before_all do
    project.add_developer(developer)
  end

  shared_examples 'CreateFromTask service with invalid params' do
    it { is_expected.to be_error }

    it 'does not create a work item or links' do
      expect do
        service_result
      end.to not_change(WorkItem, :count).and(
        not_change(WorkItems::ParentLink, :count)
      )
    end
  end

  describe '#execute' do
    subject(:service_result) { described_class.new(work_item: work_item_to_update, current_user: current_user, work_item_params: params).execute }

    context 'when work item params are valid' do
      it { is_expected.to be_success }

      it 'creates a work item and creates parent link to the original work item' do
        expect do
          service_result
        end.to change(WorkItem, :count).by(1).and(
          change(WorkItems::ParentLink, :count).by(1)
        )

        expect(work_item_to_update.reload.work_item_children).not_to be_empty
      end

      it 'replaces the original issue markdown description with new work item reference' do
        service_result

        created_work_item = WorkItem.last

        expect(list_work_item.description).to eq(""- [ ] #{created_work_item.to_reference}+"")
      end

      it_behaves_like 'title with extra spaces'
    end

    context 'when last operation fails' do
      before do
        params.merge!(line_number_start: 0)
      end

      it 'rollbacks all operations' do
        expect do
          service_result
        end.to not_change(WorkItem, :count).and(
          not_change(WorkItems::ParentLink, :count)
        )
      end

      it { is_expected.to be_error }

      it 'returns an error message' do
        expect(service_result.errors).to contain_exactly('line_number_start must be greater than 0')
      end
    end

    context 'when work item params are invalid' do
      let(:params) { { title: '' } }

      it_behaves_like 'CreateFromTask service with invalid params'

      it 'returns work item errors' do
        expect(service_result.errors).to contain_exactly(""Title can't be blank"")
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  class TaskListReferenceRemovalService
    STALE_OBJECT_MESSAGE = 'Stale work item. Check lock version'

    def initialize(work_item:, task:, line_number_start:, line_number_end:, lock_version:, current_user:)
      @work_item = work_item
      @task = task
      @line_number_start = line_number_start
      @line_number_end = line_number_end
      @lock_version = lock_version
      @current_user = current_user
      @task_reference = /#{Regexp.escape(@task.to_reference)}(?!\d)\+/
    end

    def execute
      return ::ServiceResponse.error(message: 'line_number_start must be greater than 0') if @line_number_start < 1
      return ::ServiceResponse.error(message: ""Work item description can't be blank"") if @work_item.description.blank?

      if @line_number_end < @line_number_start
        return ::ServiceResponse.error(message: 'line_number_end must be greater or equal to line_number_start')
      end

      source_lines = @work_item.description.split(""\n"")

      line_matches_reference = (@line_number_start..@line_number_end).any? do |line_number|
        markdown_line = source_lines[line_number - 1]

        if @task_reference.match?(markdown_line)
          markdown_line.sub!(@task_reference, @task.title)
        end
      end

      unless line_matches_reference
        return ::ServiceResponse.error(
          message: ""Unable to detect a task on lines #{@line_number_start}-#{@line_number_end}""
        )
      end

      ::WorkItems::UpdateService.new(
        container: @work_item.project,
        current_user: @current_user,
        params: { description: source_lines.join(""\n""), lock_version: @lock_version }
      ).execute(@work_item)

      if @work_item.valid?
        ::ServiceResponse.success
      else
        ::ServiceResponse.error(message: @work_item.errors.full_messages)
      end
    rescue ActiveRecord::StaleObjectError
      ::ServiceResponse.error(message: STALE_OBJECT_MESSAGE)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WorkItems::TaskListReferenceRemovalService, feature_category: :team_planning do
  let_it_be(:developer) { create(:user) }
  let_it_be(:project) { create(:project, :repository).tap { |project| project.add_developer(developer) } }
  let_it_be(:task) { create(:work_item, project: project, title: 'Task title') }
  let_it_be(:single_line_work_item, refind: true) do
    create(:work_item, project: project, description: ""- [ ] #{task.to_reference}+ single line"")
  end

  let_it_be(:multiple_line_work_item, refind: true) do
    create(
      :work_item,
      project: project,
      description: <<~MARKDOWN
        Any text

        * [ ] Item to be converted
            #{task.to_reference}+ second line
            third line
        * [x] task

        More text
      MARKDOWN
    )
  end

  let(:line_number_start) { 3 }
  let(:line_number_end) { 5 }
  let(:work_item) { multiple_line_work_item }
  let(:lock_version) { work_item.lock_version }

  shared_examples 'successful work item task reference removal service' do |expected_description|
    it { is_expected.to be_success }

    it 'removes the task list item containing the task reference' do
      expect do
        result
      end.to change(work_item, :description).from(work_item.description).to(expected_description)
    end

    it 'creates system notes' do
      expect do
        result
      end.to change(Note, :count).by(1)

      expect(Note.last.note).to include('changed the description')
    end
  end

  shared_examples 'failing work item task reference removal service' do |error_message|
    it { is_expected.to be_error }

    it 'does not change the work item description' do
      expect do
        result
        work_item.reload
      end.to not_change(work_item, :description)
    end

    it 'returns an error message' do
      expect(result.errors).to contain_exactly(error_message)
    end
  end

  describe '#execute' do
    subject(:result) do
      described_class.new(
        work_item: work_item,
        task: task,
        line_number_start: line_number_start,
        line_number_end: line_number_end,
        lock_version: lock_version,
        current_user: developer
      ).execute
    end

    context 'when task mardown spans a single line' do
      let(:line_number_start) { 1 }
      let(:line_number_end) { 1 }
      let(:work_item) { single_line_work_item }

      it_behaves_like 'successful work item task reference removal service', '- [ ] Task title single line'

      context 'when description does not contain a task' do
        let_it_be(:no_matching_work_item) { create(:work_item, project: project, description: 'no matching task') }

        let(:work_item) { no_matching_work_item }

        it_behaves_like 'failing work item task reference removal service', 'Unable to detect a task on lines 1-1'
      end

      context 'when description reference does not exactly match the task reference' do
        before do
          work_item.update!(description: work_item.description.gsub(task.to_reference, ""#{task.to_reference}200""))
        end

        it_behaves_like 'failing work item task reference removal service', 'Unable to detect a task on lines 1-1'
      end
    end

    context 'when task mardown spans multiple lines' do
      it_behaves_like 'successful work item task reference removal service',
        ""Any text\n\n* [ ] Item to be converted\n    Task title second line\n    third line\n* [x] task\n\nMore text""
    end

    context 'when updating the work item fails' do
      before do
        work_item.title = nil
      end

      it_behaves_like 'failing work item task reference removal service', ""Title can't be blank""
    end

    context 'when description is empty' do
      let_it_be(:empty_work_item) { create(:work_item, project: project, description: '') }

      let(:work_item) { empty_work_item }

      it_behaves_like 'failing work item task reference removal service', ""Work item description can't be blank""
    end

    context 'when line_number_start is lower than 1' do
      let(:line_number_start) { 0 }

      it_behaves_like 'failing work item task reference removal service', 'line_number_start must be greater than 0'
    end

    context 'when line_number_end is lower than line_number_start' do
      let(:line_number_end) { line_number_start - 1 }

      it_behaves_like 'failing work item task reference removal service',
        'line_number_end must be greater or equal to line_number_start'
    end

    context 'when lock_version is older than current' do
      let(:lock_version) { work_item.lock_version - 1 }

      it_behaves_like 'failing work item task reference removal service', 'Stale work item. Check lock version'
    end

    context 'when work item is stale before updating' do
      it_behaves_like 'failing work item task reference removal service', 'Stale work item. Check lock version' do
        before do
          ::WorkItem.where(id: work_item.id).update_all(lock_version: lock_version + 1)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  class BuildService < ::Issues::BuildService
    private

    def model_klass
      ::WorkItem
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WorkItems::BuildService, feature_category: :team_planning do
  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:guest) { create(:user) }

  let(:user) { guest }

  before_all do
    project.add_guest(guest)
  end

  describe '#execute' do
    subject { described_class.new(container: project, current_user: user, params: {}).execute }

    it { is_expected.to be_a(::WorkItem) }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  # Create and link operations are not run inside a transaction in this class
  # because CreateFromTaskService also creates a transaction.
  # This class should always be run inside a transaction as we could end up with
  # new work items that were never associated with other work items as expected.
  class CreateAndLinkService
    def initialize(project:, perform_spam_check: true, current_user: nil, params: {}, link_params: {})
      @project = project
      @current_user = current_user
      @params = params
      @link_params = link_params
      @perform_spam_check = perform_spam_check
    end

    def execute
      create_result = CreateService.new(
        container: @project,
        current_user: @current_user,
        params: @params.merge(title: @params[:title].strip).reverse_merge(confidential: confidential_parent),
        perform_spam_check: @perform_spam_check
      ).execute
      return create_result if create_result.error?

      work_item = create_result[:work_item]
      return ::ServiceResponse.success(payload: payload(work_item)) if @link_params.blank?

      result = WorkItems::ParentLinks::CreateService.new(
        @link_params[:parent_work_item],
        @current_user,
        { target_issuable: work_item }
      ).execute

      if result[:status] == :success
        ::ServiceResponse.success(payload: payload(work_item))
      else
        ::ServiceResponse.error(message: result[:message], http_status: 404)
      end
    end

    private

    def confidential_parent
      !!@link_params[:parent_work_item]&.confidential
    end

    def payload(work_item)
      { work_item: work_item }
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WorkItems::CreateAndLinkService, feature_category: :portfolio_management do
  let_it_be(:group) { create(:group) }
  let_it_be(:project) { create(:project, group: group) }
  let_it_be(:user) { create(:user) }
  let_it_be(:related_work_item, refind: true) { create(:work_item, project: project) }
  let_it_be(:invalid_parent) { create(:work_item, :task, project: project) }

  let(:link_params) { {} }

  let(:params) do
    {
      title: 'Awesome work item',
      description: 'please fix',
      work_item_type_id: WorkItems::Type.default_by_type(:task).id
    }
  end

  before_all do
    project.add_developer(user)
  end

  shared_examples 'successful work item and link creator' do
    it 'creates a work item successfully with links' do
      expect do
        service_result
      end.to change(WorkItem, :count).by(1).and(
        change(WorkItems::ParentLink, :count).by(1)
      )
    end

    it 'copies confidential status from the parent' do
      expect do
        service_result
      end.to change(WorkItem, :count).by(1)

      created_task = WorkItem.last

      expect(created_task.confidential).to eq(related_work_item.confidential)
    end
  end

  describe '#execute' do
    subject(:service_result) { described_class.new(project: project, current_user: user, params: params, link_params: link_params).execute }

    context 'when work item params are valid' do
      it { is_expected.to be_success }

      it 'creates a work item successfully with no links' do
        expect do
          service_result
        end.to change(WorkItem, :count).by(1).and(
          not_change(IssueLink, :count)
        )
      end

      it_behaves_like 'title with extra spaces'

      context 'when link params are valid' do
        let(:link_params) { { parent_work_item: related_work_item } }

        context 'when parent is not confidential' do
          it_behaves_like 'successful work item and link creator'
        end

        context 'when parent is confidential' do
          before do
            related_work_item.update!(confidential: true)
          end

          it_behaves_like 'successful work item and link creator'
        end
      end

      context 'when link creation fails' do
        let(:link_params) { { parent_work_item: invalid_parent } }

        it { is_expected.to be_error }

        it 'does not create a link and does not rollback transaction' do
          expect do
            service_result
          end.to not_change(WorkItems::ParentLink, :count).and(
            change(WorkItem, :count).by(1)
          )
        end

        it 'returns a link creation error message' do
          expect(service_result.errors).to contain_exactly(/is not allowed to add this type of parent/)
        end
      end
    end

    context 'when work item params are invalid' do
      let(:params) do
        {
          title: '',
          description: 'invalid work item'
        }
      end

      it { is_expected.to be_error }

      it 'does not create a work item or links' do
        expect do
          service_result
        end.to not_change(WorkItem, :count).and(
          not_change(WorkItems::ParentLink, :count)
        )
      end

      it 'returns work item errors' do
        expect(service_result.errors).to contain_exactly(""Title can't be blank"")
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  class UpdateService < ::Issues::UpdateService
    extend Gitlab::Utils::Override
    include WidgetableService

    def initialize(container:, current_user: nil, params: {}, perform_spam_check: false, widget_params: {})
      params[:widget_params] = true if widget_params.present?

      super(container: container, current_user: current_user, params: params, perform_spam_check: perform_spam_check)

      @widget_params = widget_params
    end

    def execute(work_item)
      updated_work_item = super

      if updated_work_item.valid?
        success(payload(work_item))
      else
        error(updated_work_item.errors.full_messages, :unprocessable_entity, pass_back: payload(updated_work_item))
      end
    rescue ::WorkItems::Widgets::BaseService::WidgetError => e
      error(e.message, :unprocessable_entity)
    end

    private

    override :handle_quick_actions
    def handle_quick_actions(work_item)
      # Do not handle quick actions unless the work item is the default Issue.
      # The available quick actions for a work item depend on its type and widgets.
      return unless work_item.work_item_type.default_issue?

      super
    end

    def prepare_update_params(work_item)
      execute_widgets(
        work_item: work_item,
        callback: :prepare_update_params,
        widget_params: @widget_params,
        service_params: params
      )

      super
    end

    def before_update(work_item, skip_spam_check: false)
      execute_widgets(work_item: work_item, callback: :before_update_callback, widget_params: @widget_params)

      super
    end

    def transaction_update(work_item, opts = {})
      execute_widgets(work_item: work_item, callback: :before_update_in_transaction, widget_params: @widget_params)

      super
    end

    override :after_update
    def after_update(work_item, old_associations)
      super

      GraphqlTriggers.issuable_title_updated(work_item) if work_item.previous_changes.key?(:title)
    end

    def payload(work_item)
      { work_item: work_item }
    end

    def handle_label_changes(issuable, old_labels)
      return false unless super

      Gitlab::UsageDataCounters::WorkItemActivityUniqueCounter.track_work_item_labels_changed_action(
        author: current_user
      )
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WorkItems::UpdateService, feature_category: :team_planning do
  let_it_be(:developer) { create(:user) }
  let_it_be(:guest) { create(:user) }
  let_it_be(:project) { create(:project) }
  let_it_be(:parent) { create(:work_item, project: project) }
  let_it_be_with_reload(:work_item) { create(:work_item, project: project, assignees: [developer]) }

  let(:widget_params) { {} }
  let(:opts) { {} }
  let(:current_user) { developer }

  before do
    project.add_developer(developer)
    project.add_guest(guest)
  end

  describe '#execute' do
    let(:service) do
      described_class.new(
        container: project,
        current_user: current_user,
        params: opts,
        widget_params: widget_params
      )
    end

    subject(:update_work_item) { service.execute(work_item) }

    shared_examples 'update service that triggers graphql dates updated subscription' do
      it 'triggers graphql subscription issueableDatesUpdated' do
        expect(GraphqlTriggers).to receive(:issuable_dates_updated).with(work_item).and_call_original

        update_work_item
      end
    end

    context 'when applying quick actions' do
      let(:opts) { { description: ""/shrug"" } }

      context 'when work item type is not the default Issue' do
        before do
          task_type = WorkItems::Type.default_by_type(:task)
          work_item.update_columns(work_item_type_id: task_type.id)
        end

        it 'does not apply the quick action' do
          expect do
            update_work_item
          end.to change(work_item, :description).to('/shrug')
        end
      end

      context 'when work item type is the default Issue' do
        let(:issue) { create(:work_item, description: '') }

        it 'applies the quick action' do
          expect do
            update_work_item
          end.to change(work_item, :description).to(' ¯\＿(ツ)＿/¯')
        end
      end
    end

    context 'when title is changed' do
      let(:opts) { { title: 'changed' } }

      it 'triggers issuable_title_updated graphql subscription' do
        expect(GraphqlTriggers).to receive(:issuable_title_updated).with(work_item).and_call_original
        expect(Gitlab::UsageDataCounters::WorkItemActivityUniqueCounter).to receive(:track_work_item_title_changed_action).with(author: current_user)
        # During the work item transition we also want to track work items as issues
        expect(Gitlab::UsageDataCounters::IssueActivityUniqueCounter).to receive(:track_issue_title_changed_action)
        expect(update_work_item[:status]).to eq(:success)
      end

      it_behaves_like 'internal event tracking' do
        let(:event) { Gitlab::UsageDataCounters::IssueActivityUniqueCounter::ISSUE_TITLE_CHANGED }
        let(:user) { current_user }
        let(:namespace) { project.namespace }
        subject(:service_action) { update_work_item[:status] }
      end

      it_behaves_like 'update service that triggers GraphQL work_item_updated subscription' do
        subject(:execute_service) { update_work_item }
      end
    end

    context 'when title is not changed' do
      let(:opts) { { description: 'changed' } }

      it 'does not trigger issuable_title_updated graphql subscription' do
        expect(GraphqlTriggers).not_to receive(:issuable_title_updated)
        expect(Gitlab::UsageDataCounters::WorkItemActivityUniqueCounter).not_to receive(:track_work_item_title_changed_action)
        expect(update_work_item[:status]).to eq(:success)
      end

      it 'does not emit Snowplow event', :snowplow do
        expect_no_snowplow_event

        update_work_item
      end
    end

    context 'when dates are changed' do
      let(:opts) { { start_date: Date.today } }

      it 'tracks users updating work item dates' do
        expect(Gitlab::UsageDataCounters::WorkItemActivityUniqueCounter).to receive(:track_work_item_date_changed_action).with(author: current_user)

        update_work_item
      end

      it_behaves_like 'update service that triggers GraphQL work_item_updated subscription' do
        subject(:execute_service) { update_work_item }
      end
    end

    context 'when decription is changed' do
      let(:opts) { { description: 'description changed' } }

      it 'triggers GraphQL description updated subscription' do
        expect(GraphqlTriggers).to receive(:issuable_description_updated).with(work_item).and_call_original

        update_work_item
      end

      it_behaves_like 'update service that triggers GraphQL work_item_updated subscription' do
        subject(:execute_service) { update_work_item }
      end
    end

    context 'when decription is not changed' do
      let(:opts) { { title: 'title changed' } }

      it 'does not trigger GraphQL description updated subscription' do
        expect(GraphqlTriggers).not_to receive(:issuable_description_updated)

        update_work_item
      end
    end

    context 'when updating state_event' do
      context 'when state_event is close' do
        let(:opts) { { state_event: 'close' } }

        it 'closes the work item' do
          expect do
            update_work_item
            work_item.reload
          end.to change(work_item, :state).from('opened').to('closed')
        end
      end

      context 'when state_event is reopen' do
        let(:opts) { { state_event: 'reopen' } }

        before do
          work_item.close!
        end

        it 'reopens the work item' do
          expect do
            update_work_item
            work_item.reload
          end.to change(work_item, :state).from('closed').to('opened')
        end
      end
    end

    it_behaves_like 'work item widgetable service' do
      let(:widget_params) do
        {
          hierarchy_widget: { parent: parent },
          description_widget: { description: 'foo' }
        }
      end

      let(:service) do
        described_class.new(
          container: project,
          current_user: current_user,
          params: opts,
          widget_params: widget_params
        )
      end

      let(:service_execute) { service.execute(work_item) }

      let(:supported_widgets) do
        [
          { klass: WorkItems::Widgets::DescriptionService::UpdateService, callback: :before_update_callback, params: { description: 'foo' } },
          { klass: WorkItems::Widgets::HierarchyService::UpdateService, callback: :before_update_in_transaction, params: { parent: parent } }
        ]
      end
    end

    context 'when updating widgets' do
      let(:widget_service_class) { WorkItems::Widgets::DescriptionService::UpdateService }
      let(:widget_params) { { description_widget: { description: 'changed' } } }

      context 'when widget service is not present' do
        before do
          allow(widget_service_class).to receive(:new).and_return(nil)
        end

        it 'ignores widget param' do
          expect { update_work_item }.not_to change(work_item, :description)
        end
      end

      context 'when the widget does not support update callback' do
        before do
          allow_next_instance_of(widget_service_class) do |instance|
            allow(instance)
              .to receive(:before_update_callback)
              .with(params: { description: 'changed' }).and_return(nil)
          end
        end

        it 'ignores widget param' do
          expect { update_work_item }.not_to change(work_item, :description)
        end
      end

      context 'for the description widget' do
        it 'updates the description of the work item' do
          update_work_item

          expect(work_item.description).to eq('changed')
        end

        it_behaves_like 'update service that triggers GraphQL work_item_updated subscription' do
          subject(:execute_service) { update_work_item }
        end

        context 'with mentions', :mailer, :sidekiq_might_not_need_inline do
          shared_examples 'creates the todo and sends email' do |attribute|
            it 'creates a todo and sends email' do
              expect { perform_enqueued_jobs { update_work_item } }.to change(Todo, :count).by(1)
              expect(work_item.reload.attributes[attribute.to_s]).to eq(""mention #{guest.to_reference}"")
              should_email(guest)
            end
          end

          context 'when description contains a user mention' do
            let(:widget_params) { { description_widget: { description: ""mention #{guest.to_reference}"" } } }

            it_behaves_like 'creates the todo and sends email', :description
          end

          context 'when title contains a user mention' do
            let(:opts) { { title: ""mention #{guest.to_reference}"" } }

            it_behaves_like 'creates the todo and sends email', :title
          end
        end

        context 'when work item validation fails' do
          let(:opts) { { title: '' } }

          it 'returns validation errors' do
            expect(update_work_item[:message]).to contain_exactly(""Title can't be blank"")
          end

          it 'does not execute after-update widgets', :aggregate_failures do
            expect(service).to receive(:update).and_call_original
            expect(service).not_to receive(:execute_widgets).with(callback: :update, widget_params: widget_params)

            expect { update_work_item }.not_to change(work_item, :description)
          end
        end
      end

      context 'for start and due date widget' do
        let(:updated_date) { 1.week.from_now.to_date }

        context 'when due_date is updated' do
          let(:widget_params) { { start_and_due_date_widget: { due_date: updated_date } } }

          it_behaves_like 'update service that triggers graphql dates updated subscription'
        end

        context 'when start_date is updated' do
          let(:widget_params) { { start_and_due_date_widget: { start_date: updated_date } } }

          it_behaves_like 'update service that triggers graphql dates updated subscription'
        end

        context 'when no date param is updated' do
          let(:opts) { { title: 'should not trigger' } }

          it 'does not trigger date updated subscription' do
            expect(GraphqlTriggers).not_to receive(:issuable_dates_updated)

            update_work_item
          end
        end
      end

      context 'for the hierarchy widget' do
        let(:opts) { { title: 'changed' } }
        let_it_be(:child_work_item) { create(:work_item, :task, project: project) }

        let(:widget_params) { { hierarchy_widget: { children: [child_work_item] } } }

        it 'updates the children of the work item' do
          expect do
            update_work_item
            work_item.reload
          end.to change(WorkItems::ParentLink, :count).by(1)

          expect(work_item.work_item_children).to include(child_work_item)
        end

        it_behaves_like 'update service that triggers GraphQL work_item_updated subscription' do
          subject(:execute_service) { update_work_item }
        end

        context 'when child type is invalid' do
          let_it_be(:child_work_item) { create(:work_item, project: project) }

          it 'returns error status' do
            expect(subject[:status]).to be(:error)
            expect(subject[:message])
              .to match(""#{child_work_item.to_reference} cannot be added: is not allowed to add this type of parent"")
          end

          it 'does not update work item attributes' do
            expect do
              update_work_item
              work_item.reload
            end.to not_change(WorkItems::ParentLink, :count).and(not_change(work_item, :title))
          end
        end

        context 'when work item validation fails' do
          let(:opts) { { title: '' } }

          it 'returns validation errors' do
            expect(update_work_item[:message]).to contain_exactly(""Title can't be blank"")
          end

          it 'does not execute after-update widgets', :aggregate_failures do
            expect(service).to receive(:update).and_call_original
            expect(service).not_to receive(:execute_widgets).with(callback: :before_update_in_transaction, widget_params: widget_params)
            expect(work_item.work_item_children).not_to include(child_work_item)

            update_work_item
          end
        end
      end

      context 'for milestone widget' do
        let_it_be(:milestone) { create(:milestone, project: project) }

        let(:widget_params) { { milestone_widget: { milestone_id: milestone.id } } }

        context 'when milestone is updated' do
          it ""triggers 'issuableMilestoneUpdated'"" do
            expect(work_item.milestone).to eq(nil)
            expect(GraphqlTriggers).to receive(:issuable_milestone_updated).with(work_item).and_call_original

            update_work_item
          end

          it_behaves_like 'update service that triggers GraphQL work_item_updated subscription' do
            subject(:execute_service) { update_work_item }
          end
        end

        context 'when milestone remains unchanged' do
          before do
            update_work_item
          end

          it ""does not trigger 'issuableMilestoneUpdated'"" do
            expect(work_item.milestone).to eq(milestone)
            expect(GraphqlTriggers).not_to receive(:issuable_milestone_updated)

            update_work_item
          end
        end
      end

      context 'for current user todos widget' do
        let_it_be(:user_todo) { create(:todo, target: work_item, user: developer, project: project, state: :pending) }
        let_it_be(:other_todo) { create(:todo, target: work_item, user: create(:user), project: project, state: :pending) }

        context 'when action is mark_as_done' do
          let(:widget_params) { { current_user_todos_widget: { action: 'mark_as_done' } } }

          it 'marks current user todo as done' do
            expect do
              update_work_item
              user_todo.reload
              other_todo.reload
            end.to change(user_todo, :state).from('pending').to('done').and not_change { other_todo.state }
          end

          it_behaves_like 'update service that triggers GraphQL work_item_updated subscription' do
            subject(:execute_service) { update_work_item }
          end
        end

        context 'when action is add' do
          let(:widget_params) { { current_user_todos_widget: { action: 'add' } } }

          it 'adds a ToDo for the work item' do
            expect do
              update_work_item
              work_item.reload
            end.to change(Todo, :count).by(1)
          end
        end
      end
    end

    describe 'label updates' do
      let_it_be(:label1) { create(:label, project: project) }
      let_it_be(:label2) { create(:label, project: project) }

      context 'when labels are changed' do
        let(:label) { create(:label, project: project) }
        let(:opts) { { label_ids: [label1.id] } }

        it 'tracks users updating work item labels' do
          expect(Gitlab::UsageDataCounters::WorkItemActivityUniqueCounter).to receive(:track_work_item_labels_changed_action).with(author: current_user)

          update_work_item
        end

        it_behaves_like 'update service that triggers GraphQL work_item_updated subscription' do
          subject(:execute_service) { update_work_item }
        end

        it_behaves_like 'broadcasting issuable labels updates' do
          let(:issuable) { work_item }
          let(:label_a) { label1 }
          let(:label_b) { label2 }

          def update_issuable(update_params)
            described_class.new(
              container: project,
              current_user: current_user,
              params: update_params,
              widget_params: widget_params
            ).execute(work_item)
          end
        end
      end

      context 'when labels are not changed' do
        shared_examples 'work item update that does not track label updates' do
          it 'does not track users updating work item labels' do
            expect(Gitlab::UsageDataCounters::WorkItemActivityUniqueCounter).not_to receive(:track_work_item_labels_changed_action)

            update_work_item
          end
        end

        context 'when labels param is not provided' do
          let(:opts) { { title: 'not updating labels' } }

          it_behaves_like 'work item update that does not track label updates'
        end

        context 'when labels param is provided but labels remain unchanged' do
          let(:opts) { { label_ids: [] } }

          it_behaves_like 'work item update that does not track label updates'
        end

        context 'when labels param is provided invalid values' do
          let(:opts) { { label_ids: [non_existing_record_id] } }

          it_behaves_like 'work item update that does not track label updates'
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  class CreateService < Issues::CreateService
    extend ::Gitlab::Utils::Override
    include WidgetableService

    def initialize(container:, perform_spam_check: true, current_user: nil, params: {}, widget_params: {})
      super(
        container: container,
        current_user: current_user,
        params: params,
        perform_spam_check: perform_spam_check,
        build_service: ::WorkItems::BuildService.new(container: container, current_user: current_user, params: params)
      )
      @widget_params = widget_params
    end

    def execute
      result = super
      return result if result.error?

      work_item = result[:issue]

      if work_item.valid?
        success(payload(work_item))
      else
        error(work_item.errors.full_messages, :unprocessable_entity, pass_back: payload(work_item))
      end
    rescue ::WorkItems::Widgets::BaseService::WidgetError => e
      error(e.message, :unprocessable_entity)
    end

    def before_create(work_item)
      execute_widgets(
        work_item: work_item,
        callback: :before_create_callback,
        widget_params: @widget_params
      )

      super
    end

    def transaction_create(work_item)
      super.tap do |save_result|
        if save_result
          execute_widgets(
            work_item: work_item,
            callback: :after_create_in_transaction,
            widget_params: @widget_params
          )
        end
      end
    end

    private

    override :handle_quick_actions
    def handle_quick_actions(work_item)
      # Do not handle quick actions unless the work item is the default Issue.
      # The available quick actions for a work item depend on its type and widgets.
      return if work_item.work_item_type != WorkItems::Type.default_by_type(:issue)

      super
    end

    def authorization_action
      :create_work_item
    end

    def payload(work_item)
      { work_item: work_item }
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WorkItems::CreateService, feature_category: :team_planning do
  include AfterNextHelpers

  RSpec.shared_examples 'creates work item in container' do |container_type|
    let_it_be_with_reload(:project) { create(:project) }
    let_it_be_with_reload(:group) { create(:group) }

    let_it_be(:container) do
      case container_type
      when :project then project
      when :project_namespace then project.project_namespace
      when :group then group
      end
    end

    let_it_be(:container_args) do
      case container_type
      when :project, :project_namespace then { project: project }
      when :group then { namespace: group }
      end
    end

    let_it_be(:parent) { create(:work_item, **container_args) }
    let_it_be(:guest) { create(:user) }
    let_it_be(:reporter) { create(:user) }
    let_it_be(:user_with_no_access) { create(:user) }

    let(:widget_params) { {} }
    let(:perform_spam_check) { false }
    let(:current_user) { guest }
    let(:opts) do
      {
        title: 'Awesome work_item',
        description: 'please fix'
      }
    end

    before_all do
      memberships_container = container.is_a?(Namespaces::ProjectNamespace) ? container.reload.project : container
      memberships_container.add_guest(guest)
      memberships_container.add_reporter(reporter)
    end

    describe '#execute' do
      shared_examples 'fails creating work item and returns errors' do
        it 'does not create new work item if parent can not be set' do
          expect { service_result }.not_to change(WorkItem, :count)

          expect(service_result[:status]).to be(:error)
          expect(service_result[:message]).to match(error_message)
        end
      end

      let(:service) do
        described_class.new(
          container: container,
          current_user: current_user,
          params: opts,
          perform_spam_check: perform_spam_check,
          widget_params: widget_params
        )
      end

      subject(:service_result) { service.execute }

      context 'when user is not allowed to create a work item in the container' do
        let(:current_user) { user_with_no_access }

        it { is_expected.to be_error }

        it 'returns an access error' do
          expect(service_result.errors).to contain_exactly('Operation not allowed')
        end
      end

      context 'when applying quick actions' do
        let(:work_item) { service_result[:work_item] }
        let(:opts) do
          {
            title: 'My work item',
            work_item_type: work_item_type,
            description: '/shrug'
          }
        end

        context 'when work item type is not the default Issue' do
          let(:work_item_type) { create(:work_item_type, :task, namespace: group) }

          it 'saves the work item without applying the quick action' do
            expect(service_result).to be_success
            expect(work_item).to be_persisted
            expect(work_item.description).to eq('/shrug')
          end
        end

        context 'when work item type is the default Issue' do
          let(:work_item_type) { WorkItems::Type.default_by_type(:issue) }

          it 'saves the work item and applies the quick action' do
            expect(service_result).to be_success
            expect(work_item).to be_persisted
            expect(work_item.description).to eq(' ¯\＿(ツ)＿/¯')
          end
        end
      end

      context 'when params are valid' do
        it 'created instance is a WorkItem' do
          expect(Issuable::CommonSystemNotesService).to receive_message_chain(:new, :execute)

          work_item = service_result[:work_item]

          expect(work_item).to be_persisted
          expect(work_item).to be_a(::WorkItem)
          expect(work_item.title).to eq('Awesome work_item')
          expect(work_item.description).to eq('please fix')
          expect(work_item.work_item_type.base_type).to eq('issue')
        end

        it 'calls NewIssueWorker with correct arguments' do
          expect(NewIssueWorker).to receive(:perform_async).with(Integer, current_user.id, 'WorkItem')

          service_result
        end
      end

      context 'when params are invalid' do
        let(:opts) { { title: '' } }

        it { is_expected.to be_error }

        it 'returns validation errors' do
          expect(service_result.errors).to contain_exactly(""Title can't be blank"")
        end

        it 'does not execute after-create transaction widgets' do
          expect(service).to receive(:create).and_call_original
          expect(service).not_to receive(:execute_widgets)
                                   .with(callback: :after_create_in_transaction, widget_params: widget_params)

          service_result
        end
      end

      context 'checking spam' do
        let(:perform_spam_check) { true }

        it 'checks for spam' do
          expect_next_instance_of(WorkItem) do |instance|
            expect(instance).to receive(:check_for_spam).with(user: current_user, action: :create)
          end

          service_result
        end

        context 'when `perform_spam_check` is set to `false`' do
          let(:perform_spam_check) { false }

          it 'does not check for spam' do
            expect_next_instance_of(WorkItem) do |instance|
              expect(instance).not_to receive(:check_for_spam)
            end

            service_result
          end
        end
      end

      it_behaves_like 'work item widgetable service' do
        let(:widget_params) do
          {
            hierarchy_widget: { parent: parent }
          }
        end

        let(:service) do
          described_class.new(
            container: container,
            current_user: current_user,
            params: opts,
            widget_params: widget_params
          )
        end

        let(:service_execute) { service.execute }

        let(:supported_widgets) do
          [
            {
              klass: WorkItems::Widgets::HierarchyService::CreateService,
              callback: :after_create_in_transaction,
              params: { parent: parent }
            }
          ]
        end
      end

      describe 'hierarchy widget' do
        let(:widget_params) { { hierarchy_widget: { parent: parent } } }

        context 'when user can admin parent link' do
          let(:current_user) { reporter }

          context 'when parent is valid work item' do
            let(:opts) do
              {
                title: 'Awesome work_item',
                description: 'please fix',
                work_item_type: WorkItems::Type.default_by_type(:task)
              }
            end

            it 'creates new work item and sets parent reference' do
              expect { service_result }.to change(WorkItem, :count).by(1).and(
                change(WorkItems::ParentLink, :count).by(1)
              )

              expect(service_result[:status]).to be(:success)
            end
          end

          context 'when parent type is invalid' do
            let_it_be(:parent) { create(:work_item, :task, **container_args) }

            it_behaves_like 'fails creating work item and returns errors' do
              let(:error_message) { 'is not allowed to add this type of parent' }
            end
          end
        end

        context 'when user cannot admin parent link' do
          let(:current_user) { guest }

          let(:opts) do
            {
              title: 'Awesome work_item',
              description: 'please fix',
              work_item_type: WorkItems::Type.default_by_type(:task)
            }
          end

          it_behaves_like 'fails creating work item and returns errors' do
            let(:error_message) { 'No matching work item found. Make sure that you are adding a valid work item ID.' }
          end
        end
      end
    end
  end

  it_behaves_like 'creates work item in container', :project
  it_behaves_like 'creates work item in container', :project_namespace
  it_behaves_like 'creates work item in container', :group
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  class DeleteService < Issuable::DestroyService
    def execute(work_item)
      unless current_user.can?(:delete_work_item, work_item)
        return ::ServiceResponse.error(message: 'User not authorized to delete work item')
      end

      if super
        ::ServiceResponse.success
      else
        ::ServiceResponse.error(message: work_item.errors.full_messages)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WorkItems::DeleteService, feature_category: :team_planning do
  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:guest) { create(:user) }
  let_it_be(:work_item, refind: true) { create(:work_item, project: project, author: guest) }

  let(:user) { guest }

  before_all do
    project.add_guest(guest)
    # note necessary to test note removal as part of work item deletion
    create(:note, project: project, noteable: work_item)
  end

  describe '#execute' do
    subject(:result) { described_class.new(container: project, current_user: user).execute(work_item) }

    context 'when user can delete the work item' do
      it { is_expected.to be_success }

      # currently we don't expect destroy to fail. Mocking here for coverage and keeping
      # the service's return type consistent
      context 'when there are errors preventing to delete the work item' do
        before do
          allow(work_item).to receive(:destroy).and_return(false)
          work_item.errors.add(:title)
        end

        it { is_expected.to be_error }

        it 'returns error messages' do
          expect(result.errors).to contain_exactly('Title is invalid')
        end
      end
    end

    context 'when user cannot delete the work item' do
      let(:user) { create(:user) }

      it { is_expected.to be_error }

      it 'returns error messages' do
        expect(result.errors).to contain_exactly('User not authorized to delete work item')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  module Callbacks
    class AwardEmoji < Base
      def before_update
        return unless params.present? && params.key?(:name) && params.key?(:action)
        return unless has_permission?(:award_emoji)

        execute_emoji_service(params[:action], params[:name])
      end

      private

      def execute_emoji_service(action, name)
        class_name = {
          add: ::AwardEmojis::AddService,
          remove: ::AwardEmojis::DestroyService,
          toggle: ::AwardEmojis::ToggleService
        }

        raise_error(invalid_action_error(action)) unless class_name.key?(action)

        result = class_name[action].new(work_item, name, current_user).execute

        raise_error(result[:message]) if result[:status] == :error
      end

      def invalid_action_error(key)
        format(_(""%{key} is not a valid action.""), key: key)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WorkItems::Callbacks::AwardEmoji, feature_category: :team_planning do
  let_it_be(:reporter) { create(:user) }
  let_it_be(:unauthorized_user) { create(:user) }
  let_it_be(:project) { create(:project, :private) }
  let_it_be(:work_item) { create(:work_item, project: project) }

  let(:current_user) { reporter }

  before_all do
    project.add_reporter(reporter)
  end

  describe '#before_update' do
    subject do
      described_class.new(issuable: work_item, current_user: current_user, params: params)
        .before_update
    end

    shared_examples 'raises a WidgetError' do
      it { expect { subject }.to raise_error(::WorkItems::Widgets::BaseService::WidgetError, message) }
    end

    context 'when awarding an emoji' do
      let(:params) { { action: :add, name: 'star' } }

      context 'when user has no access' do
        let(:current_user) { unauthorized_user }

        it 'does not award the emoji' do
          expect { subject }.not_to change { AwardEmoji.count }
        end
      end

      context 'when user has access' do
        it 'awards the emoji to the work item' do
          expect { subject }.to change { AwardEmoji.count }.by(1)

          emoji = AwardEmoji.last

          expect(emoji.name).to eq('star')
          expect(emoji.awardable_id).to eq(work_item.id)
          expect(emoji.user).to eq(current_user)
        end

        context 'when the name is incorrect' do
          let(:params) { { action: :add, name: 'foo' } }

          it_behaves_like 'raises a WidgetError' do
            let(:message) { 'Name is not a valid emoji name' }
          end
        end

        context 'when the action is incorrect' do
          let(:params) { { action: :foo, name: 'star' } }

          it_behaves_like 'raises a WidgetError' do
            let(:message) { 'foo is not a valid action.' }
          end
        end
      end
    end

    context 'when removing emoji' do
      let(:params) { { action: :remove, name: 'thumbsup' } }

      context 'when user has no access' do
        let(:current_user) { unauthorized_user }

        it 'does not remove the emoji' do
          expect { subject }.not_to change { AwardEmoji.count }
        end
      end

      context 'when user has access' do
        it 'removes existing emoji' do
          create(:award_emoji, :upvote, awardable: work_item, user: current_user)

          expect { subject }.to change { AwardEmoji.count }.by(-1)
        end

        context 'when work item does not have the emoji' do
          let(:params) { { action: :remove, name: 'star' } }

          it_behaves_like 'raises a WidgetError' do
            let(:message) { 'User has not awarded emoji of type star on the awardable' }
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  module RelatedWorkItemLinks
    class DestroyService < BaseService
      def initialize(work_item, user, params)
        @work_item = work_item
        @current_user = user
        @params = params.dup
        @failed_ids = []
        @removed_ids = []
      end

      def execute
        return error(_('No work item found.'), 403) unless can?(current_user, :admin_work_item_link, work_item)
        return error(_('No work item IDs provided.'), 409) if params[:item_ids].empty?

        destroy_links_for(params[:item_ids])

        if removed_ids.any?
          success(message: response_message, items_removed: removed_ids, items_with_errors: failed_ids.flatten)
        else
          error(error_message)
        end
      end

      private

      attr_reader :work_item, :current_user, :failed_ids, :removed_ids

      def destroy_links_for(item_ids)
        destroy_links(source: work_item, target: item_ids, direction: :target)
        destroy_links(source: item_ids, target: work_item, direction: :source)
      end

      def destroy_links(source:, target:, direction:)
        WorkItems::RelatedWorkItemLink.for_source_and_target(source, target).each do |link|
          linked_item = link.try(direction)

          if can?(current_user, :admin_work_item_link, linked_item)
            link.destroy!
            removed_ids << linked_item.id
            create_notes(link)
          else
            failed_ids << linked_item.id
          end
        end
      end

      def create_notes(link)
        SystemNoteService.unrelate_issuable(link.source, link.target, current_user)
        SystemNoteService.unrelate_issuable(link.target, link.source, current_user)
      end

      def error_message
        not_linked = params[:item_ids] - (removed_ids + failed_ids)
        error_messages = []

        if failed_ids.any?
          error_messages << format(
            _('%{item_ids} could not be removed due to insufficient permissions'), item_ids: failed_ids.to_sentence
          )
        end

        if not_linked.any?
          error_messages << format(
            _('%{item_ids} could not be removed due to not being linked'), item_ids: not_linked.to_sentence
          )
        end

        return '' unless error_messages.any?

        format(_('IDs with errors: %{error_messages}.'), error_messages: error_messages.join(', '))
      end

      def response_message
        success_message = format(_('Successfully unlinked IDs: %{item_ids}.'), item_ids: removed_ids.to_sentence)

        return success_message unless error_message.present?

        ""#{success_message} #{error_message}""
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WorkItems::RelatedWorkItemLinks::DestroyService, feature_category: :portfolio_management do
  describe '#execute' do
    let_it_be(:project) { create(:project_empty_repo, :private) }
    let_it_be(:other_project) { create(:project_empty_repo, :private) }
    let_it_be(:user) { create(:user) }
    let_it_be(:source) { create(:work_item, project: project) }
    let_it_be(:linked_item1) { create(:work_item, project: project) }
    let_it_be(:linked_item2) { create(:work_item, project: project) }
    let_it_be(:no_access_item) { create(:work_item, project: other_project) }
    let_it_be(:not_linked_item) { create(:work_item, project: project) }

    let_it_be(:link1) { create(:work_item_link, source: source, target: linked_item1) }
    let_it_be(:link2) { create(:work_item_link, source: source, target: linked_item2) }
    let_it_be(:link3) { create(:work_item_link, source: source, target: no_access_item) }

    let(:ids_to_remove) { [linked_item1.id, linked_item2.id, no_access_item.id, not_linked_item.id] }

    subject(:destroy_links) { described_class.new(source, user, { item_ids: ids_to_remove }).execute }

    context 'when user can `admin_work_item_link` for the work item' do
      before_all do
        project.add_guest(user)
      end

      it 'removes existing linked items with access' do
        expect { destroy_links }.to change { WorkItems::RelatedWorkItemLink.count }.by(-2)
      end

      it 'creates notes for the source and target of each removed link' do
        [linked_item1, linked_item2].each do |item|
          expect(SystemNoteService).to receive(:unrelate_issuable).with(source, item, user)
          expect(SystemNoteService).to receive(:unrelate_issuable).with(item, source, user)
        end

        destroy_links
      end

      it 'returns correct response message' do
        message = ""Successfully unlinked IDs: #{linked_item1.id} and #{linked_item2.id}. IDs with errors: "" \
                  ""#{no_access_item.id} could not be removed due to insufficient permissions, "" \
                  ""#{not_linked_item.id} could not be removed due to not being linked.""

        is_expected.to eq(
          status: :success,
          message: message,
          items_removed: [linked_item1.id, linked_item2.id],
          items_with_errors: [no_access_item.id]
        )
      end

      context 'when all items fail' do
        let(:ids_to_remove) { [no_access_item.id] }
        let(:params) { { item_ids: [no_access_item.id] } }
        let(:error_msg) { ""IDs with errors: #{ids_to_remove[0]} could not be removed due to insufficient permissions."" }

        it 'returns an error response' do
          expect { destroy_links }.not_to change { WorkItems::RelatedWorkItemLink.count }

          is_expected.to eq(status: :error, message: error_msg)
        end
      end

      context 'when item_ids is empty' do
        let(:ids_to_remove) { [] }

        it 'returns error response' do
          is_expected.to eq(message: 'No work item IDs provided.', status: :error, http_status: 409)
        end
      end
    end

    context 'when user cannot `admin_work_item_link` for the work item' do
      it 'returns error response' do
        is_expected.to eq(message: 'No work item found.', status: :error, http_status: 403)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  module RelatedWorkItemLinks
    class CreateService < IssuableLinks::CreateService
      extend ::Gitlab::Utils::Override

      def execute
        return error(_('No matching work item found.'), 404) unless can?(current_user, :admin_work_item_link, issuable)

        response = super
        create_notes_async if new_links.any?

        if response[:status] == :success
          response[:message] = format(
            _('Successfully linked ID(s): %{item_ids}.'),
            item_ids: linked_ids(response[:created_references]).to_sentence
          )
        end

        response
      end

      def linkable_issuables(work_items)
        @linkable_issuables ||= work_items.select { |work_item| can_link_item?(work_item) }
      end

      def previous_related_issuables
        @related_issues ||= issuable.linked_work_items(authorize: false).to_a
      end

      private

      def create_notes(_issuable_link)
        # no-op notes are created asynchronously
      end

      def link_class
        WorkItems::RelatedWorkItemLink
      end

      def can_link_item?(work_item)
        return true if can?(current_user, :admin_work_item_link, work_item)

        @errors << format(
          _(""Item with ID: %{id} cannot be added. You don't have permission to perform this action.""),
          id: work_item.id
        )

        false
      end

      def linked_ids(created_links)
        created_links.collect(&:target_id)
      end

      def create_notes_async
        link_ids = new_links.collect(&:id)

        worker_params = {
          issuable_class: issuable.class.name,
          issuable_id: issuable.id,
          link_ids: link_ids,
          link_type: params[:link_type] || 'relates_to',
          user_id: current_user.id
        }

        Issuable::RelatedLinksCreateWorker.perform_async(worker_params)
      end

      override :issuables_already_assigned_message
      def issuables_already_assigned_message
        _('Items are already linked')
      end

      override :issuables_not_found_message
      def issuables_not_found_message
        _('No matching work item found. Make sure you are adding a valid ID and you have access to the item.')
      end
    end
  end
end

WorkItems::RelatedWorkItemLinks::CreateService.prepend_mod_with('WorkItems::RelatedWorkItemLinks::CreateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WorkItems::RelatedWorkItemLinks::CreateService, feature_category: :portfolio_management do
  describe '#execute' do
    let_it_be(:user) { create(:user) }
    let_it_be(:group) { create(:group) }
    let_it_be(:project) { create(:project, group: group) }
    let_it_be(:issuable) { create(:work_item, project: project) }
    let_it_be(:issuable2) { create(:work_item, project: project) }
    let_it_be(:restricted_issuable) { create(:work_item) }
    let_it_be(:another_project) { create(:project, group: group) }
    let_it_be(:issuable3) { create(:work_item, project: another_project) }
    let_it_be(:issuable_a) { create(:work_item, project: project) }
    let_it_be(:issuable_b) { create(:work_item, project: project) }
    let_it_be(:issuable_link) { create(:work_item_link, source: issuable, target: issuable_b) }

    let(:issuable_parent) { issuable.project }
    let(:issuable_type) { 'work item' }
    let(:issuable_link_class) { WorkItems::RelatedWorkItemLink }
    let(:params) { {} }

    before_all do
      project.add_guest(user)
      another_project.add_guest(user)
    end

    it_behaves_like 'issuable link creation', use_references: false do
      let(:response_keys) { [:status, :created_references, :message] }
      let(:async_notes) { true }
      let(:already_assigned_error_msg) { ""Items are already linked"" }
      let(:no_found_error_msg) do
        'No matching work item found. Make sure you are adding a valid ID and you have access to the item.'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  module ParentLinks
    class BaseService < IssuableLinks::CreateService
      extend ::Gitlab::Utils::Override

      private

      def set_parent(issuable, work_item)
        link = WorkItems::ParentLink.for_work_item(work_item)
        link.work_item_parent = issuable
        link
      end

      def create_notes(work_item)
        SystemNoteService.relate_work_item(issuable, work_item, current_user)
      end

      def linkable_issuables(work_items)
        @linkable_issuables ||= if can_admin_link?(issuable)
                                  work_items.select { |work_item| linkable?(work_item) }
                                else
                                  []
                                end
      end

      def linkable?(work_item)
        can_admin_link?(work_item) && previous_related_issuables.exclude?(work_item)
      end

      def can_admin_link?(work_item)
        can?(current_user, :admin_parent_link, work_item)
      end

      override :previous_related_issuables
      def previous_related_issuables
        @previous_related_issuables ||= issuable.work_item_children.to_a
      end

      override :target_issuable_type
      def target_issuable_type
        'work item'
      end

      override :issuables_not_found_message
      def issuables_not_found_message
        format(_('No matching %{issuable} found. Make sure that you are adding a valid %{issuable} ID.'),
          issuable: target_issuable_type)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

module WorkItems
  class ParentLinksService < WorkItems::ParentLinks::BaseService; end
end

RSpec.describe WorkItems::ParentLinks::BaseService, feature_category: :portfolio_management do
  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project) }
  let_it_be(:work_item) { create(:work_item, :objective, project: project) }
  let_it_be(:target_work_item) { create(:work_item, :objective, project: project) }

  let(:params) { { target_issuable: target_work_item } }
  let(:described_class_descendant) { WorkItems::ParentLinksService }

  before do
    project.add_reporter(user)
  end

  describe '#execute' do
    subject { described_class_descendant.new(work_item, user, params).execute }

    context 'when user has sufficient permissions' do
      it 'raises NotImplementedError' do
        expect { subject }.to raise_error(NotImplementedError)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  module ParentLinks
    class ReorderService < WorkItems::ParentLinks::BaseService
      private

      override :relate_issuables
      def relate_issuables(work_item)
        notes_are_expected = work_item.work_item_parent != issuable
        link = set_parent(issuable, work_item)
        reorder(link, params[:adjacent_work_item], params[:relative_position])

        create_notes(work_item) if link.save && notes_are_expected

        link
      end

      def reorder(link, adjacent_work_item, relative_position)
        WorkItems::ParentLink.move_nulls_to_end(RelativePositioning.mover.context(link).relative_siblings)

        link.move_before(adjacent_work_item.parent_link) if relative_position == 'BEFORE'
        link.move_after(adjacent_work_item.parent_link) if relative_position == 'AFTER'
      end

      override :render_conflict_error?
      def render_conflict_error?
        return false if params[:adjacent_work_item] && params[:relative_position]

        super
      end

      override :linkable?
      def linkable?(work_item)
        can_admin_link?(work_item)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WorkItems::ParentLinks::ReorderService, feature_category: :portfolio_management do
  describe '#execute' do
    let_it_be(:reporter) { create(:user) }
    let_it_be(:guest) { create(:user) }
    let_it_be(:project) { create(:project) }
    let_it_be_with_reload(:parent) { create(:work_item, :objective, project: project) }
    let_it_be_with_reload(:work_item) { create(:work_item, :objective, project: project) }
    let_it_be_with_reload(:top_adjacent) { create(:work_item, :objective, project: project) }
    let_it_be_with_reload(:last_adjacent) { create(:work_item, :objective, project: project) }

    let(:parent_link_class) { WorkItems::ParentLink }
    let(:user) { reporter }
    let(:params) { { target_issuable: work_item } }
    let(:relative_range) { [top_adjacent, last_adjacent].map(&:parent_link).map(&:relative_position) }

    subject { described_class.new(parent, user, params).execute }

    before do
      project.add_reporter(reporter)
      project.add_guest(guest)

      create(:parent_link, work_item: top_adjacent, work_item_parent: parent)
      create(:parent_link, work_item: last_adjacent, work_item_parent: parent)
    end

    shared_examples 'raises a service error' do |message, status = 409|
      it { is_expected.to eq(service_error(message, http_status: status)) }
    end

    shared_examples 'returns not found error' do
      it 'returns error' do
        error = ""No matching work item found. Make sure that you are adding a valid work item ID.""

        is_expected.to eq(service_error(error))
      end

      it 'creates no relationship' do
        expect { subject }.not_to change { parent_link_class.count }
      end
    end

    shared_examples 'returns conflict error' do
      it_behaves_like 'raises a service error', 'Work item(s) already assigned'

      it 'creates no relationship' do
        expect { subject }.to not_change { parent_link_class.count }
      end
    end

    shared_examples 'processes ordered hierarchy' do
      it 'returns success status and processed links', :aggregate_failures do
        expect(subject.keys).to match_array([:status, :created_references])
        expect(subject[:status]).to eq(:success)
        expect(subject[:created_references].map(&:work_item_id)).to match_array([work_item.id])
      end

      it 'orders hierarchy' do
        subject

        expect(last_adjacent.parent_link.relative_position).to be_between(*relative_range)
      end
    end

    context 'when user has insufficient permissions' do
      let(:user) { guest }

      it_behaves_like 'returns not found error'

      context 'when user is a guest assigned to the work item' do
        before do
          work_item.assignees = [guest]
        end

        it_behaves_like 'returns not found error'
      end
    end

    context 'when child and parent are already linked' do
      before do
        create(:parent_link, work_item: work_item, work_item_parent: parent)
      end

      it_behaves_like 'returns conflict error'

      context 'when adjacents are already in place and the user has sufficient permissions' do
        let(:base_param) { { target_issuable: work_item } }

        shared_examples 'updates hierarchy order without notes' do
          it_behaves_like 'processes ordered hierarchy'

          it 'keeps relationships', :aggregate_failures do
            expect { subject }.to not_change { parent_link_class.count }

            expect(parent_link_class.where(work_item: work_item).last.work_item_parent).to eq(parent)
          end

          it 'does not create notes', :aggregate_failures do
            expect { subject }.to not_change { work_item.notes.count }.and(not_change { work_item.notes.count })
          end
        end

        context 'when moving before adjacent work item' do
          let(:params) { base_param.merge({ adjacent_work_item: last_adjacent, relative_position: 'BEFORE' }) }

          it_behaves_like 'updates hierarchy order without notes'
        end

        context 'when moving after adjacent work item' do
          let(:params) { base_param.merge({ adjacent_work_item: top_adjacent, relative_position: 'AFTER' }) }

          it_behaves_like 'updates hierarchy order without notes'
        end
      end
    end

    context 'when new parent is assigned' do
      shared_examples 'updates hierarchy order and creates notes' do
        it_behaves_like 'processes ordered hierarchy'

        it 'creates notes', :aggregate_failures do
          subject

          expect(parent.notes.last.note).to eq(""added #{work_item.to_reference} as child objective"")
          expect(work_item.notes.last.note).to eq(""added #{parent.to_reference} as parent objective"")
        end
      end

      context 'when adjacents are already in place and the user has sufficient permissions' do
        let(:base_param) { { target_issuable: work_item } }

        context 'when moving before adjacent work item' do
          let(:params) { base_param.merge({ adjacent_work_item: last_adjacent, relative_position: 'BEFORE' }) }

          it_behaves_like 'updates hierarchy order and creates notes'
        end

        context 'when moving after adjacent work item' do
          let(:params) { base_param.merge({ adjacent_work_item: top_adjacent, relative_position: 'AFTER' }) }

          it_behaves_like 'updates hierarchy order and creates notes'
        end

        context 'when previous parent was in place' do
          before do
            create(:parent_link, work_item: work_item,
              work_item_parent: create(:work_item, :objective, project: project))
          end

          context 'when moving before adjacent work item' do
            let(:params) { base_param.merge({ adjacent_work_item: last_adjacent, relative_position: 'BEFORE' }) }

            it_behaves_like 'updates hierarchy order and creates notes'
          end

          context 'when moving after adjacent work item' do
            let(:params) { base_param.merge({ adjacent_work_item: top_adjacent, relative_position: 'AFTER' }) }

            it_behaves_like 'updates hierarchy order and creates notes'
          end
        end
      end
    end
  end

  def service_error(message, http_status: 404)
    {
      message: message,
      status: :error,
      http_status: http_status
    }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  module ParentLinks
    class DestroyService < IssuableLinks::DestroyService
      attr_reader :link, :current_user, :parent, :child

      def initialize(link, user)
        @link = link
        @current_user = user
        @parent = link.work_item_parent
        @child = link.work_item
      end

      private

      def create_notes
        unrelate_note = SystemNoteService.unrelate_work_item(parent, child, current_user)

        ResourceLinkEvent.create(
          user: @current_user,
          work_item: @link.work_item_parent,
          child_work_item: @link.work_item,
          action: ResourceLinkEvent.actions[:remove],
          system_note_metadata_id: unrelate_note&.system_note_metadata&.id
        )
      end

      def not_found_message
        _('No Work Item Link found')
      end

      def permission_to_remove_relation?
        can?(current_user, :admin_parent_link, child) && can?(current_user, :admin_parent_link, parent)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WorkItems::ParentLinks::DestroyService, feature_category: :team_planning do
  describe '#execute' do
    let_it_be(:reporter) { create(:user) }
    let_it_be(:guest) { create(:user) }
    let_it_be(:project) { create(:project) }
    let_it_be(:work_item) { create(:work_item, project: project) }
    let_it_be(:task) { create(:work_item, :task, project: project) }
    let_it_be(:parent_link) { create(:parent_link, work_item: task, work_item_parent: work_item) }

    let(:parent_link_class) { WorkItems::ParentLink }

    subject { described_class.new(parent_link, user).execute }

    before do
      project.add_reporter(reporter)
      project.add_guest(guest)
    end

    context 'when user has permissions to update work items' do
      let(:user) { reporter }

      it 'removes relation and creates notes', :aggregate_failures do
        expect { subject }
          .to change(parent_link_class, :count).by(-1)
          .and change(WorkItems::ResourceLinkEvent, :count).by(1)

        expect(work_item.notes.last.note).to eq(""removed child task #{task.to_reference}"")
        expect(task.notes.last.note).to eq(""removed parent issue #{work_item.to_reference}"")
        expect(WorkItems::ResourceLinkEvent.last).to have_attributes(
          user_id: user.id,
          issue_id: work_item.id,
          child_work_item_id: task.id,
          action: ""remove"",
          system_note_metadata_id: task.notes.last.system_note_metadata.id
        )
      end

      it 'returns success message' do
        is_expected.to eq(message: 'Relation was removed', status: :success)
      end

      context 'when note creation fails for some reason' do
        [Note.new, nil].each do |unrelate_child_note|
          it 'still records the link event', :aggregate_failures do
            allow(SystemNoteService).to receive(:unrelate_work_item).and_return(unrelate_child_note)

            expect { subject }
              .to change(WorkItems::ResourceLinkEvent, :count).by(1)
              .and not_change(Note, :count)

            expect(WorkItems::ResourceLinkEvent.last).to have_attributes(
              user_id: user.id,
              issue_id: work_item.id,
              child_work_item_id: task.id,
              action: ""remove"",
              system_note_metadata_id: nil
            )
          end
        end
      end
    end

    context 'when user has insufficient permissions' do
      let(:user) { guest }

      it 'does not remove relation', :aggregate_failures do
        expect { subject }
          .to not_change(parent_link_class, :count).from(1)
          .and not_change(WorkItems::ResourceLinkEvent, :count)
        expect(SystemNoteService).not_to receive(:unrelate_work_item)
      end

      it 'returns error message' do
        is_expected.to eq(message: 'No Work Item Link found', status: :error, http_status: 404)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  module ParentLinks
    class CreateService < WorkItems::ParentLinks::BaseService
      private

      override :relate_issuables
      def relate_issuables(work_item)
        link = set_parent(issuable, work_item)

        link.move_to_end

        if link.changed? && link.save
          relate_child_note = create_notes(work_item)

          ResourceLinkEvent.create(
            user: current_user,
            work_item: link.work_item_parent,
            child_work_item: link.work_item,
            action: ResourceLinkEvent.actions[:add],
            system_note_metadata_id: relate_child_note&.system_note_metadata&.id
          )
        end

        link
      end

      override :extract_references
      def extract_references
        params[:issuable_references]
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WorkItems::ParentLinks::CreateService, feature_category: :portfolio_management do
  describe '#execute' do
    let_it_be(:user) { create(:user) }
    let_it_be(:guest) { create(:user) }
    let_it_be(:project) { create(:project) }
    let_it_be(:work_item) { create(:work_item, project: project) }
    let_it_be(:task) { create(:work_item, :task, project: project) }
    let_it_be_with_reload(:task1) { create(:work_item, :task, project: project) }
    let_it_be_with_reload(:task2) { create(:work_item, :task, project: project) }
    let_it_be(:guest_task) { create(:work_item, :task) }
    let_it_be(:invalid_task) { build_stubbed(:work_item, :task, id: non_existing_record_id) }
    let_it_be(:another_project) { (create :project) }
    let_it_be(:other_project_task) { create(:work_item, :task, iid: 100, project: another_project) }
    let_it_be(:existing_parent_link) { create(:parent_link, work_item: task, work_item_parent: work_item) }

    let(:parent_link_class) { WorkItems::ParentLink }
    let(:issuable_type) { :task }
    let(:params) { {} }

    before do
      project.add_reporter(user)
      project.add_guest(guest)
      guest_task.project.add_guest(user)
      another_project.add_reporter(user)
    end

    shared_examples 'returns not found error' do
      it 'returns error' do
        error = ""No matching work item found. Make sure that you are adding a valid work item ID.""

        is_expected.to eq(service_error(error))
      end

      it 'no relationship is created' do
        expect { subject }.not_to change(parent_link_class, :count)
      end
    end

    subject { described_class.new(work_item, user, params).execute }

    context 'when the reference list is empty' do
      let(:params) { { issuable_references: [] } }

      it_behaves_like 'returns not found error'
    end

    context 'when work item not found' do
      let(:params) { { issuable_references: [invalid_task] } }

      it_behaves_like 'returns not found error'
    end

    context 'when user has no permission to link work items' do
      let(:params) { { issuable_references: [guest_task] } }

      it_behaves_like 'returns not found error'
    end

    context 'child and parent are the same work item' do
      let(:params) { { issuable_references: [work_item] } }

      it 'no relationship is created' do
        expect { subject }.not_to change(parent_link_class, :count)
      end
    end

    context 'when adjacent is already in place' do
      using RSpec::Parameterized::TableSyntax

      let_it_be_with_reload(:parent_item) { create(:work_item, :objective, project: project) }
      let_it_be_with_reload(:current_item) { create(:work_item, :objective, project: project) }

      let_it_be_with_reload(:adjacent) do
        create(:work_item, :objective, project: project)
      end

      let_it_be_with_reload(:link_to_adjacent) do
        create(:parent_link, work_item_parent: parent_item, work_item: adjacent)
      end

      subject { described_class.new(parent_item, user, { target_issuable: current_item }).execute }

      where(:adjacent_position, :expected_order) do
        -100 | lazy { [adjacent, current_item] }
        0    | lazy { [adjacent, current_item] }
        100  | lazy { [adjacent, current_item] }
      end

      with_them do
        before do
          link_to_adjacent.update!(relative_position: adjacent_position)
        end

        it 'sets relative positions' do
          expect { subject }.to change(parent_link_class, :count).by(1)
          expect(parent_item.work_item_children_by_relative_position).to eq(expected_order)
        end
      end
    end

    context 'when there are tasks to relate' do
      let(:params) { { issuable_references: [task1, task2] } }

      it 'creates relationships', :aggregate_failures do
        expect { subject }.to change(parent_link_class, :count).by(2)

        tasks_parent = parent_link_class.where(work_item: [task1, task2]).map(&:work_item_parent).uniq
        expect(tasks_parent).to match_array([work_item])
      end

      it 'returns success status and created links', :aggregate_failures do
        expect(subject.keys).to match_array([:status, :created_references])
        expect(subject[:status]).to eq(:success)
        expect(subject[:created_references].map(&:work_item_id)).to match_array([task1.id, task2.id])
      end

      it 'creates notes and records the events', :aggregate_failures do
        expect { subject }.to change(WorkItems::ResourceLinkEvent, :count).by(2)

        work_item_notes = work_item.notes.last(2)
        resource_link_events = WorkItems::ResourceLinkEvent.last(2)
        expect(work_item_notes.first.note).to eq(""added #{task1.to_reference} as child task"")
        expect(work_item_notes.last.note).to eq(""added #{task2.to_reference} as child task"")
        expect(task1.notes.last.note).to eq(""added #{work_item.to_reference} as parent issue"")
        expect(task2.notes.last.note).to eq(""added #{work_item.to_reference} as parent issue"")
        expect(resource_link_events.first).to have_attributes(
          user_id: user.id,
          issue_id: work_item.id,
          child_work_item_id: task1.id,
          action: ""add"",
          system_note_metadata_id: task1.notes.last.system_note_metadata.id
        )
        expect(resource_link_events.last).to have_attributes(
          user_id: user.id,
          issue_id: work_item.id,
          child_work_item_id: task2.id,
          action: ""add"",
          system_note_metadata_id: task2.notes.last.system_note_metadata.id
        )
      end

      context 'when note creation fails for some reason' do
        let(:params) { { issuable_references: [task1] } }

        [Note.new, nil].each do |relate_child_note|
          it 'still records the link event', :aggregate_failures do
            allow_next_instance_of(WorkItems::ParentLinks::CreateService) do |instance|
              allow(instance).to receive(:create_notes).and_return(relate_child_note)
            end

            expect { subject }
              .to change(WorkItems::ResourceLinkEvent, :count).by(1)
              .and not_change(Note, :count)

            expect(WorkItems::ResourceLinkEvent.last).to have_attributes(
              user_id: user.id,
              issue_id: work_item.id,
              child_work_item_id: task1.id,
              action: ""add"",
              system_note_metadata_id: nil
            )
          end
        end
      end

      context 'when task is already assigned' do
        let(:params) { { issuable_references: [task, task2] } }

        it 'creates links only for non related tasks', :aggregate_failures do
          expect { subject }
            .to change(parent_link_class, :count).by(1)
            .and change(WorkItems::ResourceLinkEvent, :count).by(1)

          expect(subject[:created_references].map(&:work_item_id)).to match_array([task2.id])
          expect(work_item.notes.last.note).to eq(""added #{task2.to_reference} as child task"")
          expect(task2.notes.last.note).to eq(""added #{work_item.to_reference} as parent issue"")
          expect(task.notes).to be_empty
          expect(WorkItems::ResourceLinkEvent.last).to have_attributes(
            user_id: user.id,
            issue_id: work_item.id,
            child_work_item_id: task2.id,
            action: ""add"",
            system_note_metadata_id: task2.notes.last.system_note_metadata.id
          )
        end
      end

      context 'when there are invalid children' do
        let_it_be(:issue) { create(:work_item, project: project) }

        let(:params) { { issuable_references: [task1, issue, other_project_task] } }

        it 'creates links only for valid children' do
          expect { subject }.to change { parent_link_class.count }.by(1)
        end

        it 'returns error status' do
          error = ""#{issue.to_reference} cannot be added: is not allowed to add this type of parent. "" \
            ""#{other_project_task.to_reference} cannot be added: parent must be in the same project or group as child.""

          is_expected.to eq(service_error(error, http_status: 422))
        end

        it 'creates notes for valid links' do
          subject

          expect(work_item.notes.last.note).to eq(""added #{task1.to_reference} as child task"")
          expect(task1.notes.last.note).to eq(""added #{work_item.to_reference} as parent issue"")
          expect(issue.notes).to be_empty
          expect(other_project_task.notes).to be_empty
        end
      end

      context 'when parent type is invalid' do
        let(:work_item) { create :work_item, :task, project: project }

        let(:params) { { target_issuable: task1 } }

        it 'returns error status' do
          error = ""#{task1.to_reference} cannot be added: is not allowed to add this type of parent""

          is_expected.to eq(service_error(error, http_status: 422))
        end
      end

      context 'when max depth is reached' do
        let(:params) { { issuable_references: [task2] } }

        before do
          stub_const(""#{parent_link_class}::MAX_CHILDREN"", 1)
        end

        it 'returns error status' do
          error = ""#{task2.to_reference} cannot be added: parent already has maximum number of children.""

          is_expected.to eq(service_error(error, http_status: 422))
        end
      end

      context 'when params include invalid ids' do
        let(:params) { { issuable_references: [task1, guest_task] } }

        it 'creates links only for valid IDs' do
          expect { subject }.to change(parent_link_class, :count).by(1)
        end
      end

      context 'when user is a guest' do
        let(:user) { guest }

        it_behaves_like 'returns not found error'
      end

      context 'when user is a guest assigned to the work item' do
        let(:user) { guest }

        before do
          work_item.assignees = [guest]
        end

        it_behaves_like 'returns not found error'
      end
    end
  end

  def service_error(message, http_status: 404)
    {
      message: message,
      status: :error,
      http_status: http_status
    }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  module Widgets
    module CurrentUserTodosService
      class UpdateService < WorkItems::Widgets::BaseService
        def before_update_in_transaction(params:)
          return unless params.present? && params.key?(:action)

          case params[:action]
          when ""add""
            add_todo
          when ""mark_as_done""
            mark_as_done(params[:todo_id])
          end
        end

        private

        def add_todo
          return unless has_permission?(:create_todo)

          TodoService.new.mark_todo(work_item, current_user)&.first
        end

        def mark_as_done(todo_id)
          todos = TodosFinder.new(current_user, state: :pending, target_id: work_item.id).execute
          todos = todo_id ? todos.id_in(todo_id) : todos

          return if todos.empty?

          TodoService.new.resolve_todos(todos, current_user, resolved_by_action: :api_done)
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WorkItems::Widgets::CurrentUserTodosService::UpdateService, feature_category: :team_planning do
  let_it_be(:reporter) { create(:user) }
  let_it_be(:project) { create(:project, :private) }
  let_it_be(:current_user) { reporter }
  let_it_be(:work_item) { create(:work_item, project: project) }

  let_it_be(:pending_todo1) do
    create(:todo, state: :pending, target: work_item, target_type: work_item.class.name, user: current_user)
  end

  let_it_be(:pending_todo2) do
    create(:todo, state: :pending, target: work_item, target_type: work_item.class.name, user: current_user)
  end

  let_it_be(:done_todo) do
    create(:todo, state: :done, target: work_item, target_type: work_item.class.name, user: current_user)
  end

  let_it_be(:other_work_item_todo) { create(:todo, state: :pending, target: create(:work_item), user: current_user) }
  let_it_be(:other_user_todo) do
    create(:todo, state: :pending, target: work_item, target_type: work_item.class.name, user: create(:user))
  end

  let(:widget) { work_item.widgets.find { |widget| widget.is_a?(WorkItems::Widgets::CurrentUserTodos) } }

  before_all do
    project.add_reporter(reporter)
  end

  describe '#before_update_in_transaction' do
    subject do
      described_class.new(widget: widget, current_user: current_user)
        .before_update_in_transaction(params: params)
    end

    context 'when adding a todo' do
      let(:params) { { action: ""add"" } }

      context 'when user has no access' do
        let(:current_user) { create(:user) }

        it 'does add a todo' do
          expect { subject }.not_to change { Todo.count }
        end
      end

      context 'when user has access' do
        let(:params) { { action: ""add"" } }

        it 'creates a new todo for the user and the work item' do
          expect { subject }.to change { current_user.todos.count }.by(1)

          todo = current_user.todos.last

          expect(todo.target.id).to eq(work_item.id)
          expect(todo).to be_pending
        end
      end
    end

    context 'when marking as done' do
      let(:params) { { action: ""mark_as_done"" } }

      context 'when user has no access' do
        let(:current_user) { create(:user) }

        it 'does not change todo status' do
          subject

          expect(pending_todo1.reload).to be_pending
          expect(pending_todo2.reload).to be_pending
          expect(other_work_item_todo.reload).to be_pending
          expect(other_user_todo.reload).to be_pending
        end
      end

      context 'when resolving all todos of the work item', :aggregate_failures do
        it 'resolves todos of the user for the work item' do
          subject

          expect(pending_todo1.reload).to be_done
          expect(pending_todo2.reload).to be_done
          expect(other_work_item_todo.reload).to be_pending
          expect(other_user_todo.reload).to be_pending
        end
      end

      context 'when resolving a specific todo', :aggregate_failures do
        let(:params) { { action: ""mark_as_done"", todo_id: pending_todo1.id } }

        it 'resolves todos of the user for the work item' do
          subject

          expect(pending_todo1.reload).to be_done
          expect(pending_todo2.reload).to be_pending
          expect(other_work_item_todo.reload).to be_pending
          expect(other_user_todo.reload).to be_pending
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  module Widgets
    module HierarchyService
      class UpdateService < WorkItems::Widgets::HierarchyService::BaseService
        INVALID_RELATIVE_POSITION_ERROR = 'Relative position is not valid.'
        CHILDREN_REORDERING_ERROR = 'Relative position cannot be combined with childrenIds.'
        UNRELATED_ADJACENT_HIERARCHY_ERROR = 'The adjacent work item\'s parent must match the new parent work item.'
        INVALID_ADJACENT_PARENT_ERROR = 'The adjacent work item\'s parent must match the current parent work item.'

        def before_update_in_transaction(params:)
          return unless params.present?

          if positioning?(params)
            service_response!(handle_positioning(params))
          else
            service_response!(handle_hierarchy_changes(params))
          end
        end

        private

        def handle_positioning(params)
          validate_positioning!(params)

          arguments = {
            target_issuable: work_item,
            adjacent_work_item: params.delete(:adjacent_work_item),
            relative_position: params.delete(:relative_position)
          }
          work_item_parent = params.delete(:parent) || work_item.work_item_parent
          ::WorkItems::ParentLinks::ReorderService.new(work_item_parent, current_user, arguments).execute
        end

        def positioning?(params)
          params[:relative_position].present? || params[:adjacent_work_item].present?
        end

        def error!(message)
          service_response!(error(_(message)))
        end

        def validate_positioning!(params)
          error!(INVALID_RELATIVE_POSITION_ERROR) if incomplete_relative_position?(params)
          error!(CHILDREN_REORDERING_ERROR) if positioning_children?(params)
          error!(UNRELATED_ADJACENT_HIERARCHY_ERROR) if unrelated_adjacent_hierarchy?(params)
          error!(INVALID_ADJACENT_PARENT_ERROR) if invalid_adjacent_parent?(params)
        end

        def positioning_children?(params)
          params.key?(:children)
        end

        def incomplete_relative_position?(params)
          params[:adjacent_work_item].blank? || params[:relative_position].blank?
        end

        def unrelated_adjacent_hierarchy?(params)
          return false if params[:parent].blank?

          params[:parent] != params[:adjacent_work_item].work_item_parent
        end

        def invalid_adjacent_parent?(params)
          return false if params[:parent].present?

          work_item.work_item_parent != params[:adjacent_work_item].work_item_parent
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WorkItems::Widgets::HierarchyService::UpdateService, feature_category: :portfolio_management do
  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project) }

  let_it_be(:work_item) { create(:work_item, project: project) }
  let_it_be(:parent_work_item) { create(:work_item, project: project) }
  let_it_be(:child_work_item) { create(:work_item, :task, project: project) }
  let_it_be(:existing_link) { create(:parent_link, work_item: child_work_item, work_item_parent: work_item) }

  let(:widget) { work_item.widgets.find { |widget| widget.is_a?(WorkItems::Widgets::Hierarchy) } }
  let(:not_found_error) { 'No matching work item found. Make sure that you are adding a valid work item ID.' }

  shared_examples 'raises a WidgetError' do |message|
    it { expect { subject }.to raise_error(described_class::WidgetError, message) }
  end

  shared_examples 'raises a WidgetError with message' do
    let(:message) { not_found_error }

    it { expect { subject }.to raise_error(described_class::WidgetError, message) }
  end

  describe '#update' do
    subject { described_class.new(widget: widget, current_user: user).before_update_in_transaction(params: params) }

    context 'when parent and children params are present' do
      let(:params) { { parent: parent_work_item, children: [child_work_item] } }

      it_behaves_like 'raises a WidgetError', 'A Work Item can be a parent or a child, but not both.'
    end

    context 'when invalid params are present' do
      let(:params) { { other_parent: parent_work_item } }

      it_behaves_like 'raises a WidgetError', 'One or more arguments are invalid: other_parent.'
    end

    context 'when relative position params are incomplete' do
      context 'when only adjacent_work_item is present' do
        let(:params) do
          { parent: parent_work_item, adjacent_work_item: child_work_item }
        end

        it_behaves_like 'raises a WidgetError', described_class::INVALID_RELATIVE_POSITION_ERROR
      end

      context 'when only relative_position is present' do
        let(:params) do
          { parent: parent_work_item, relative_position: 'AFTER' }
        end

        it_behaves_like 'raises a WidgetError', described_class::INVALID_RELATIVE_POSITION_ERROR
      end
    end

    context 'when updating children' do
      let_it_be(:child_work_item2) { create(:work_item, :task, project: project) }
      let_it_be(:child_work_item3) { create(:work_item, :task, project: project) }
      let_it_be(:child_work_item4) { create(:work_item, :task, project: project) }

      context 'when user has insufficient permissions to link work items' do
        let(:params) { { children: [child_work_item4] } }

        it_behaves_like 'raises a WidgetError with message' do
          let(:message) { not_found_error }
        end
      end

      context 'when user has sufficient permissions to link work item' do
        before do
          project.add_developer(user)
        end

        context 'with valid children params' do
          let(:params) { { children: [child_work_item2, child_work_item3] } }

          it 'correctly sets work item parent' do
            subject

            expect(work_item.reload.work_item_children)
              .to contain_exactly(child_work_item, child_work_item2, child_work_item3)
          end

          context 'when relative_position and adjacent_work_item are given' do
            context 'with BEFORE value' do
              let(:params) do
                { children: [child_work_item3], relative_position: 'BEFORE', adjacent_work_item: child_work_item }
              end

              it_behaves_like 'raises a WidgetError', described_class::CHILDREN_REORDERING_ERROR
            end

            context 'with AFTER value' do
              let(:params) do
                { children: [child_work_item2], relative_position: 'AFTER', adjacent_work_item: child_work_item }
              end

              it_behaves_like 'raises a WidgetError', described_class::CHILDREN_REORDERING_ERROR
            end
          end
        end

        context 'when child is already assigned' do
          let(:params) { { children: [child_work_item] } }

          it_behaves_like 'raises a WidgetError', 'Work item(s) already assigned'
        end

        context 'when child type is invalid' do
          let_it_be(:child_issue) { create(:work_item, project: project) }

          let(:params) { { children: [child_issue] } }

          it_behaves_like 'raises a WidgetError with message' do
            let(:message) { ""#{child_issue.to_reference} cannot be added: is not allowed to add this type of parent"" }
          end
        end
      end
    end

    context 'when updating parent' do
      let_it_be(:work_item) { create(:work_item, :task, project: project) }

      let(:params) { { parent: parent_work_item } }

      context 'when user has insufficient permissions to link work items' do
        it_behaves_like 'raises a WidgetError with message' do
          let(:message) { not_found_error }
        end
      end

      context 'when user has sufficient permissions to link work item' do
        before do
          project.add_developer(user)
        end

        it 'correctly sets new parent' do
          expect(subject[:status]).to eq(:success)
          expect(work_item.work_item_parent).to eq(parent_work_item)
        end

        context 'when parent is nil' do
          let(:params) { { parent: nil } }

          it 'removes the work item parent if present' do
            work_item.update!(work_item_parent: parent_work_item)

            expect do
              subject
              work_item.reload
            end.to change(work_item, :work_item_parent).from(parent_work_item).to(nil)
          end

          it 'returns success status if parent not present', :aggregate_failures do
            work_item.update!(work_item_parent: nil)

            expect(subject[:status]).to eq(:success)
            expect(work_item.reload.work_item_parent).to be_nil
          end
        end

        context 'when type is invalid' do
          let_it_be(:parent_task) { create(:work_item, :task, project: project) }

          let(:params) { { parent: parent_task } }

          it_behaves_like 'raises a WidgetError with message' do
            let(:message) { ""#{work_item.to_reference} cannot be added: is not allowed to add this type of parent"" }
          end
        end

        context 'with positioning arguments' do
          let_it_be_with_reload(:adjacent) { create(:work_item, :task, project: project) }

          let_it_be_with_reload(:adjacent_link) do
            create(:parent_link, work_item: adjacent, work_item_parent: parent_work_item)
          end

          let(:params) { { parent: parent_work_item, adjacent_work_item: adjacent, relative_position: 'AFTER' } }

          it 'correctly sets new parent and position' do
            expect(subject[:status]).to eq(:success)
            expect(work_item.work_item_parent).to eq(parent_work_item)
            expect(work_item.parent_link.relative_position).to be > adjacent_link.relative_position
          end

          context 'when other hierarchy adjacent is provided' do
            let_it_be(:other_hierarchy_adjacent) { create(:parent_link).work_item }

            let(:params) do
              { parent: parent_work_item, adjacent_work_item: other_hierarchy_adjacent, relative_position: 'AFTER' }
            end

            it_behaves_like 'raises a WidgetError', described_class::UNRELATED_ADJACENT_HIERARCHY_ERROR
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  module Widgets
    module HierarchyService
      class CreateService < WorkItems::Widgets::HierarchyService::BaseService
        def after_create_in_transaction(params:)
          return unless params.present?

          service_response!(handle_hierarchy_changes(params))
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WorkItems::Widgets::HierarchyService::CreateService, feature_category: :portfolio_management do
  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project) }
  let_it_be(:parent_item) { create(:work_item, project: project) }

  let(:widget) { parent_item.widgets.find { |widget| widget.is_a?(WorkItems::Widgets::Hierarchy) } }

  shared_examples 'raises a WidgetError' do
    it { expect { subject }.to raise_error(described_class::WidgetError, message) }
  end

  before_all do
    project.add_developer(user)
  end

  describe '#create' do
    subject { described_class.new(widget: widget, current_user: user).after_create_in_transaction(params: params) }

    context 'when invalid params are present' do
      let(:params) { { other_parent: 'parent_work_item' } }

      it_behaves_like 'raises a WidgetError' do
        let(:message) { 'One or more arguments are invalid: other_parent.' }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  module Widgets
    module NotificationsService
      class UpdateService < WorkItems::Widgets::BaseService
        def before_update_in_transaction(params:)
          return unless params.present? && params.key?(:subscribed)
          return unless has_permission?(:update_subscription)

          update_subscription(work_item, params)
        end

        private

        def update_subscription(work_item, subscription_params)
          work_item.set_subscription(
            current_user,
            subscription_params[:subscribed],
            work_item.project
          )
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WorkItems::Widgets::NotificationsService::UpdateService, feature_category: :team_planning do
  let_it_be(:group) { create(:group) }
  let_it_be(:project) { create(:project, :private, group: group) }
  let_it_be(:guest) { create(:user).tap { |u| project.add_guest(u) } }
  let_it_be(:author) { create(:user).tap { |u| project.add_guest(u) } }
  let_it_be_with_reload(:work_item) { create(:work_item, project: project, author: author) }
  let_it_be(:current_user) { guest }

  let(:widget) { work_item.widgets.find { |widget| widget.is_a?(WorkItems::Widgets::Notifications) } }
  let(:service) { described_class.new(widget: widget, current_user: current_user) }

  describe '#before_update_in_transaction' do
    let(:expected) { params[:subscribed] }

    subject(:update_notifications) { service.before_update_in_transaction(params: params) }

    shared_examples 'failing to update subscription' do
      context 'when user is subscribed with a subscription record' do
        let_it_be(:subscription) { create_subscription(:subscribed) }

        it ""does not update the work item's subscription"" do
          expect do
            update_notifications
            subscription.reload
          end.to not_change { subscription.subscribed }
            .and(not_change { work_item.subscribed?(current_user, project) })
        end
      end

      context 'when user is subscribed by being a participant' do
        let_it_be(:current_user) { author }

        it 'does not create subscription record or change subscription state' do
          expect { update_notifications }
            .to not_change { Subscription.count }
            .and(not_change { work_item.subscribed?(current_user, project) })
        end
      end
    end

    shared_examples 'updating notifications subscription successfully' do
      it 'updates existing subscription record' do
        expect do
          update_notifications
          subscription.reload
        end.to change { subscription.subscribed }.to(expected)
          .and(change { work_item.subscribed?(current_user, project) }.to(expected))
      end
    end

    context 'when update fails' do
      context 'when user lack update_subscription permissions' do
        let_it_be(:params) { { subscribed: false } }

        before do
          allow(Ability).to receive(:allowed?).and_call_original
          allow(Ability).to receive(:allowed?)
            .with(current_user, :update_subscription, work_item)
            .and_return(false)
        end

        it_behaves_like 'failing to update subscription'
      end

      context 'when notifications params are not present' do
        let_it_be(:params) { {} }

        it_behaves_like 'failing to update subscription'
      end
    end

    context 'when update is successful' do
      context 'when subscribing' do
        let_it_be(:subscription) { create_subscription(:unsubscribed) }
        let(:params) { { subscribed: true } }

        it_behaves_like 'updating notifications subscription successfully'
      end

      context 'when unsubscribing' do
        let(:params) { { subscribed: false } }

        context 'when user is subscribed with a subscription record' do
          let_it_be(:subscription) { create_subscription(:subscribed) }

          it_behaves_like 'updating notifications subscription successfully'
        end

        context 'when user is subscribed by being a participant' do
          let_it_be(:current_user) { author }

          it 'creates a subscription with expected value' do
            expect { update_notifications }
              .to change { Subscription.count }.by(1)
              .and(change { work_item.subscribed?(current_user, project) }.to(expected))

            expect(Subscription.last.subscribed).to eq(expected)
          end
        end
      end
    end
  end

  def create_subscription(state)
    create(
      :subscription,
      project: project,
      user: current_user,
      subscribable: work_item,
      subscribed: (state == :subscribed)
    )
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  module Widgets
    module DescriptionService
      class UpdateService < WorkItems::Widgets::BaseService
        def before_update_callback(params: {})
          params[:description] = nil if new_type_excludes_widget?

          return unless params.present? && params.key?(:description)
          return unless has_permission?(:update_work_item)

          work_item.description = params[:description]
          work_item.assign_attributes(last_edited_at: Time.current, last_edited_by: current_user)
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WorkItems::Widgets::DescriptionService::UpdateService, feature_category: :portfolio_management do
  let_it_be(:random_user) { create(:user) }
  let_it_be(:author) { create(:user) }
  let_it_be(:guest) { create(:user) }
  let_it_be(:reporter) { create(:user) }
  let_it_be(:project) { create(:project, :public) }

  let(:params) { { description: 'updated description' } }
  let(:current_user) { author }
  let(:work_item) do
    create(
      :work_item,
      author: author,
      project: project,
      description: 'old description',
      last_edited_at: Date.yesterday,
      last_edited_by: random_user
    )
  end

  let(:widget) { work_item.widgets.find { |widget| widget.is_a?(WorkItems::Widgets::Description) } }

  describe '#update' do
    let(:service) { described_class.new(widget: widget, current_user: current_user) }

    subject(:before_update_callback) { service.before_update_callback(params: params) }

    shared_examples 'sets work item description' do
      it 'correctly sets work item description value' do
        subject

        expect(work_item.description).to eq(params[:description])
        expect(work_item.last_edited_by).to eq(current_user)
        expect(work_item.last_edited_at).to be_within(2.seconds).of(Time.current)
      end
    end

    shared_examples 'does not set work item description' do
      it 'does not change work item description value' do
        subject

        expect(work_item.description).to eq('old description')
        expect(work_item.last_edited_by).to eq(random_user)
        expect(work_item.last_edited_at).to eq(Date.yesterday)
      end
    end

    context 'when user has permission to update description' do
      context 'when user is work item author' do
        let(:current_user) { author }

        it_behaves_like 'sets work item description'
      end

      context 'when user is a project reporter' do
        let(:current_user) { reporter }

        before do
          project.add_reporter(reporter)
        end

        it_behaves_like 'sets work item description'
      end

      context 'when description is nil' do
        let(:current_user) { author }
        let(:params) { { description: nil } }

        it_behaves_like 'sets work item description'
      end

      context 'when description is empty' do
        let(:current_user) { author }
        let(:params) { { description: '' } }

        it_behaves_like 'sets work item description'
      end

      context 'when description param is not present' do
        let(:params) { {} }

        it_behaves_like 'does not set work item description'
      end

      context 'when widget does not exist in new type' do
        let(:current_user) { author }
        let(:params) { {} }

        before do
          allow(service).to receive(:new_type_excludes_widget?).and_return(true)
          work_item.update!(description: 'test')
        end

        it ""resets the work item's description"" do
          expect { before_update_callback }
            .to change { work_item.description }
            .from('test')
            .to(nil)
        end
      end
    end

    context 'when user does not have permission to update description' do
      context 'when user is a project guest' do
        let(:current_user) { guest }

        before do
          project.add_guest(guest)
        end

        it_behaves_like 'does not set work item description'
      end

      context 'with private project' do
        let_it_be(:project) { create(:project) }

        context 'when user is work item author' do
          let(:current_user) { author }

          it_behaves_like 'does not set work item description'
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  module Widgets
    module LabelsService
      class UpdateService < WorkItems::Widgets::BaseService
        def prepare_update_params(params: {})
          if new_type_excludes_widget?
            params[:remove_label_ids] = @work_item.labels.map(&:id)
            params[:add_label_ids] = []
          end

          return if params.blank?
          return unless has_permission?(:set_work_item_metadata)

          service_params.merge!(params.slice(:add_label_ids, :remove_label_ids))
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WorkItems::Widgets::LabelsService::UpdateService, feature_category: :team_planning do
  let_it_be(:group) { create(:group) }
  let_it_be(:project) { create(:project, group: group) }
  let_it_be(:label1) { create(:label, project: project) }
  let_it_be(:label2) { create(:label, project: project) }
  let_it_be(:label3) { create(:label, project: project) }
  let_it_be(:current_user) { create(:user).tap { |user| project.add_reporter(user) } }

  let(:work_item) { create(:work_item, project: project, labels: [label1, label2]) }
  let(:widget) { work_item.widgets.find { |widget| widget.is_a?(WorkItems::Widgets::Labels) } }
  let(:service) { described_class.new(widget: widget, current_user: current_user) }

  describe '#prepare_update_params' do
    context 'when params are set' do
      let(:params) { { add_label_ids: [label1.id], remove_label_ids: [label2.id] } }

      it ""sets params correctly"" do
        expect(service.prepare_update_params(params: params)).to include(
          {
            add_label_ids: match_array([label1.id]),
            remove_label_ids: match_array([label2.id])
          }
        )
      end

      context ""and user doesn't have permissions to update labels"" do
        let_it_be(:current_user) { create(:user) }

        it 'removes label params' do
          expect(service.prepare_update_params(params: params)).to be_nil
        end
      end
    end

    context 'when widget does not exist in new type' do
      let(:params) { {} }

      before do
        allow(service).to receive(:new_type_excludes_widget?).and_return(true)
      end

      it ""sets correct params to remove work item labels"" do
        expect(service.prepare_update_params(params: params)).to include(
          {
            remove_label_ids: match_array([label1.id, label2.id]),
            add_label_ids: []
          }
        )
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  module Widgets
    module StartAndDueDateService
      class UpdateService < WorkItems::Widgets::BaseService
        def before_update_callback(params: {})
          return widget.work_item.assign_attributes({ start_date: nil, due_date: nil }) if new_type_excludes_widget?

          return if params.blank?
          return unless has_permission?(:set_work_item_metadata)

          widget.work_item.assign_attributes(params.slice(:start_date, :due_date))
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WorkItems::Widgets::StartAndDueDateService::UpdateService, feature_category: :portfolio_management do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user).tap { |user| project.add_reporter(user) } }
  let_it_be_with_reload(:work_item) { create(:work_item, project: project) }

  let(:widget) { work_item.widgets.find { |widget| widget.is_a?(WorkItems::Widgets::StartAndDueDate) } }

  describe '#before_update_callback' do
    let(:start_date) { Date.today }
    let(:due_date) { 1.week.from_now.to_date }
    let(:service) { described_class.new(widget: widget, current_user: user) }

    subject(:update_params) { service.before_update_callback(params: params) }

    context 'when start and due date params are present' do
      let(:params) { { start_date: Date.today, due_date: 1.week.from_now.to_date } }

      it 'correctly sets date values' do
        expect do
          update_params
        end.to change(work_item, :start_date).from(nil).to(start_date).and(
          change(work_item, :due_date).from(nil).to(due_date)
        )
      end

      context ""and user doesn't have permissions to update start and due date"" do
        let_it_be(:user) { create(:user) }

        it 'removes start and due date params params' do
          expect(update_params).to be_nil
        end
      end
    end

    context 'when date params are not present' do
      let(:params) { {} }

      it 'does not change work item date values' do
        expect do
          update_params
        end.to not_change(work_item, :start_date).from(nil).and(
          not_change(work_item, :due_date).from(nil)
        )
      end
    end

    context 'when work item had both date values already set' do
      before do
        work_item.update!(start_date: start_date, due_date: due_date)
      end

      context 'when one of the two params is null' do
        let(:params) { { start_date: nil } }

        it 'sets only one date to null' do
          expect do
            update_params
          end.to change(work_item, :start_date).from(start_date).to(nil).and(
            not_change(work_item, :due_date).from(due_date)
          )
        end
      end
    end

    context 'when widget does not exist in new type' do
      let(:params) { {} }

      before do
        allow(service).to receive(:new_type_excludes_widget?).and_return(true)
        work_item.update!(start_date: start_date, due_date: due_date)
      end

      it 'sets both dates to null' do
        expect do
          update_params
        end.to change(work_item, :start_date).from(start_date).to(nil).and(
          change(work_item, :due_date).from(due_date).to(nil)
        )
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WorkItems
  module Widgets
    module AssigneesService
      class UpdateService < WorkItems::Widgets::BaseService
        def before_update_in_transaction(params:)
          params[:assignee_ids] = [] if new_type_excludes_widget?

          return unless params.present? && params.has_key?(:assignee_ids)
          return unless has_permission?(:set_work_item_metadata)

          assignee_ids = filter_assignees_count(params[:assignee_ids])
          assignee_ids = filter_assignee_permissions(assignee_ids)

          return if assignee_ids.sort == work_item.assignee_ids.sort

          work_item.assignee_ids = assignee_ids
          work_item.touch
        end

        private

        def filter_assignees_count(assignee_ids)
          return assignee_ids if work_item.allows_multiple_assignees?

          assignee_ids.first(1)
        end

        def filter_assignee_permissions(assignee_ids)
          assignees = User.id_in(assignee_ids)

          assignees.select { |assignee| assignee.can?(:read_work_item, work_item) }.map(&:id)
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WorkItems::Widgets::AssigneesService::UpdateService, :freeze_time, feature_category: :portfolio_management do
  let_it_be(:reporter) { create(:user) }
  let_it_be(:project) { create(:project, :private) }
  let_it_be(:new_assignee) { create(:user) }

  let(:work_item) do
    create(:work_item, project: project, updated_at: 1.day.ago)
  end

  let(:widget) { work_item.widgets.find { |widget| widget.is_a?(WorkItems::Widgets::Assignees) } }
  let(:current_user) { reporter }
  let(:params) { { assignee_ids: [new_assignee.id] } }

  before_all do
    project.add_reporter(reporter)
    project.add_guest(new_assignee)
  end

  describe '#before_update_in_transaction' do
    let(:service) { described_class.new(widget: widget, current_user: current_user) }

    subject { service.before_update_in_transaction(params: params) }

    it 'updates the assignees and sets updated_at to the current time' do
      subject

      expect(work_item.assignee_ids).to contain_exactly(new_assignee.id)
      expect(work_item.updated_at).to be_like_time(Time.current)
    end

    context 'when passing an empty array' do
      let(:params) { { assignee_ids: [] } }

      before do
        work_item.assignee_ids = [reporter.id]
      end

      it 'removes existing assignees' do
        subject

        expect(work_item.assignee_ids).to be_empty
        expect(work_item.updated_at).to be_like_time(Time.current)
      end
    end

    context 'when user does not have access' do
      let(:current_user) { create(:user) }

      it 'does not update the assignees' do
        subject

        expect(work_item.assignee_ids).to be_empty
        expect(work_item.updated_at).to be_like_time(1.day.ago)
      end
    end

    context 'when multiple assignees are given' do
      let(:params) { { assignee_ids: [new_assignee.id, reporter.id] } }

      context 'when work item allows multiple assignees' do
        before do
          allow(work_item).to receive(:allows_multiple_assignees?).and_return(true)
        end

        it 'sets all the given assignees' do
          subject

          expect(work_item.assignee_ids).to contain_exactly(new_assignee.id, reporter.id)
          expect(work_item.updated_at).to be_like_time(Time.current)
        end
      end

      context 'when work item does not allow multiple assignees' do
        before do
          allow(work_item).to receive(:allows_multiple_assignees?).and_return(false)
        end

        it 'only sets the first assignee' do
          subject

          expect(work_item.assignee_ids).to contain_exactly(new_assignee.id)
          expect(work_item.updated_at).to be_like_time(Time.current)
        end
      end
    end

    context 'when assignee does not have access to the work item' do
      let(:params) { { assignee_ids: [create(:user).id] } }

      it 'does not set the assignee' do
        subject

        expect(work_item.assignee_ids).to be_empty
        expect(work_item.updated_at).to be_like_time(1.day.ago)
      end
    end

    context 'when assignee ids are the same as the existing ones' do
      before do
        work_item.assignee_ids = [new_assignee.id]
      end

      it 'does not touch updated_at' do
        subject

        expect(work_item.assignee_ids).to contain_exactly(new_assignee.id)
        expect(work_item.updated_at).to be_like_time(1.day.ago)
      end
    end

    context 'when widget does not exist in new type' do
      let(:params) { {} }

      before do
        allow(service).to receive(:new_type_excludes_widget?).and_return(true)
        work_item.assignee_ids = [new_assignee.id]
      end

      it ""resets the work item's assignees"" do
        subject

        expect(work_item.assignee_ids).to be_empty
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Webauthn
  class RegisterService < BaseService
    def initialize(user, params, challenge)
      @user = user
      @params = params
      @challenge = challenge
    end

    def execute
      registration = WebauthnRegistration.new

      begin
        webauthn_credential = WebAuthn::Credential.from_create(Gitlab::Json.parse(@params[:device_response]))
        webauthn_credential.verify(@challenge)

        registration.update(
          credential_xid: Base64.strict_encode64(webauthn_credential.raw_id),
          public_key: webauthn_credential.public_key,
          counter: webauthn_credential.sign_count,
          name: @params[:name],
          user: @user
        )
      rescue JSON::ParserError
        registration.errors.add(:base, _('Your WebAuthn device did not send a valid JSON response.'))
      rescue WebAuthn::Error => e
        registration.errors.add(:base, e.message)
      end

      registration
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'
require 'webauthn/fake_client'

RSpec.describe Webauthn::RegisterService, feature_category: :system_access do
  let(:client) { WebAuthn::FakeClient.new(origin) }
  let(:user) { create(:user) }
  let(:challenge) { Base64.strict_encode64(SecureRandom.random_bytes(32)) }

  let(:origin) { 'http://localhost' }

  describe '#execute' do
    it 'returns a registration if challenge matches' do
      create_result = client.create(challenge: challenge) # rubocop:disable Rails/SaveBang
      webauthn_credential = WebAuthn::Credential.from_create(create_result)

      params = { device_response: create_result.to_json, name: 'abc' }
      service = described_class.new(user, params, challenge)

      registration = service.execute
      expect(registration.credential_xid).to eq(Base64.strict_encode64(webauthn_credential.raw_id))
      expect(registration.errors.size).to eq(0)
    end

    it 'returns an error if challenge does not match' do
      create_result = client.create(challenge: Base64.strict_encode64(SecureRandom.random_bytes(16))) # rubocop:disable Rails/SaveBang

      params = { device_response: create_result.to_json, name: 'abc' }
      service = described_class.new(user, params, challenge)

      registration = service.execute
      expect(registration.errors.size).to eq(1)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Webauthn
  class AuthenticateService < BaseService
    def initialize(user, device_response, challenge)
      @user = user
      @device_response = device_response
      @challenge = challenge
    end

    def execute
      parsed_device_response = Gitlab::Json.parse(@device_response)

      webauthn_credential = WebAuthn::Credential.from_get(parsed_device_response)
      encoded_raw_id = Base64.strict_encode64(webauthn_credential.raw_id)
      stored_webauthn_credential = @user.webauthn_registrations.find_by_credential_xid(encoded_raw_id)

      encoder = WebAuthn.configuration.encoder

      if stored_webauthn_credential &&
          validate_webauthn_credential(webauthn_credential) &&
          verify_webauthn_credential(webauthn_credential, stored_webauthn_credential, @challenge, encoder)

        stored_webauthn_credential.update!(counter: webauthn_credential.sign_count)
        return true
      end

      false
    rescue JSON::ParserError, WebAuthn::SignCountVerificationError, WebAuthn::Error
      false
    end

    private

    ##
    # Validates that webauthn_credential is syntactically valid
    #
    # duplicated from WebAuthn::PublicKeyCredential#verify
    # which can't be used here as we need to call WebAuthn::AuthenticatorAssertionResponse#verify instead
    # (which is done in #verify_webauthn_credential)
    def validate_webauthn_credential(webauthn_credential)
      webauthn_credential.type == WebAuthn::TYPE_PUBLIC_KEY &&
        webauthn_credential.raw_id && webauthn_credential.id &&
        webauthn_credential.raw_id == WebAuthn.standard_encoder.decode(webauthn_credential.id)
    end

    ##
    # Verifies that webauthn_credential matches stored_credential with the given challenge
    #
    def verify_webauthn_credential(webauthn_credential, stored_credential, challenge, encoder)
      # We need to adjust the relaying party id (RP id) we verify against if the registration in question
      # is a migrated U2F registration. This is beacuse the appid of U2F and the rp id of WebAuthn differ.
      rp_id = webauthn_credential.client_extension_outputs['appid'] ? WebAuthn.configuration.origin : URI(WebAuthn.configuration.origin).host
      webauthn_credential.response.verify(
        encoder.decode(challenge),
        public_key: encoder.decode(stored_credential.public_key),
        sign_count: stored_credential.counter,
        rp_id: rp_id
      )
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'
require 'webauthn/fake_client'

RSpec.describe Webauthn::AuthenticateService, feature_category: :system_access do
  let(:client) { WebAuthn::FakeClient.new(origin) }
  let(:user) { create(:user) }
  let(:challenge) { Base64.strict_encode64(SecureRandom.random_bytes(32)) }

  let(:origin) { 'http://localhost' }

  before do
    create_result = client.create(challenge: challenge) # rubocop:disable Rails/SaveBang

    webauthn_credential = WebAuthn::Credential.from_create(create_result)

    registration = WebauthnRegistration.new(
      credential_xid: Base64.strict_encode64(webauthn_credential.raw_id),
      public_key: webauthn_credential.public_key,
      counter: 0,
      name: 'name',
      user_id: user.id
    )
    registration.save!
  end

  describe '#execute' do
    it 'returns true if the response is valid and a matching stored credential is present' do
      get_result = client.get(challenge: challenge)

      get_result['clientExtensionResults'] = {}
      service = described_class.new(user, get_result.to_json, challenge)

      expect(service.execute).to eq true
    end

    context 'when response is valid but no matching stored credential is present' do
      it 'returns false' do
        other_client = WebAuthn::FakeClient.new(origin)
        other_client.create(challenge: challenge) # rubocop:disable Rails/SaveBang

        get_result = other_client.get(challenge: challenge)

        get_result['clientExtensionResults'] = {}
        service = described_class.new(user, get_result.to_json, challenge)

        expect(service.execute).to eq false
      end
    end

    context 'when device response includes invalid json' do
      it 'returns false' do
        service = described_class.new(user, 'invalid JSON', '')
        expect(service.execute).to eq false
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Webauthn
  class DestroyService < BaseService
    attr_reader :webauthn_registration, :user, :current_user

    def initialize(current_user, user, webauthn_registrations_id)
      @current_user = current_user
      @user = user
      @webauthn_registration = user.webauthn_registrations.find(webauthn_registrations_id)
    end

    def execute
      return error(_('You are not authorized to perform this action')) unless authorized?

      webauthn_registration.destroy
      user.reset_backup_codes! if last_two_factor_registration?
    end

    private

    def last_two_factor_registration?
      user.webauthn_registrations.empty? && !user.otp_required_for_login?
    end

    def authorized?
      current_user.can?(:disable_two_factor, user)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Webauthn::DestroyService, feature_category: :system_access do
  let(:user) { create(:user, :two_factor_via_webauthn, registrations_count: 1) }
  let(:current_user) { user }

  describe '#execute' do
    let(:webauthn_id) { user.webauthn_registrations.first.id }

    subject { described_class.new(current_user, user, webauthn_id).execute }

    context 'with only one webauthn method enabled' do
      context 'when another user is calling the service' do
        context 'for a user without permissions' do
          let(:current_user) { create(:user) }

          it 'does not destry the webauthn registration' do
            expect { subject }.not_to change { user.webauthn_registrations.count }
          end

          it 'does not remove the user backup codes' do
            expect { subject }.not_to change { user.otp_backup_codes }
          end

          it 'returns error' do
            expect(subject[:status]).to eq(:error)
          end
        end

        context 'for an admin' do
          it 'destroys the webauthn registration' do
            expect { subject }.to change { user.webauthn_registrations.count }.by(-1)
          end

          it 'removes the user backup codes' do
            subject

            expect(user.otp_backup_codes).to be_nil
          end
        end
      end

      context 'when current user is calling the service' do
        context 'when there is also OTP enabled' do
          before do
            user.otp_required_for_login = true
            user.otp_secret = User.generate_otp_secret(32)
            user.otp_grace_period_started_at = Time.current
            user.generate_otp_backup_codes!
            user.save!
          end

          it 'removes the webauth registrations' do
            expect { subject }.to change { user.webauthn_registrations.count }.by(-1)
          end

          it 'does not remove the user backup codes' do
            expect { subject }.not_to change { user.otp_backup_codes }
          end
        end
      end
    end

    context 'with multiple webauthn methods enabled' do
      before do
        create(:webauthn_registration, user: user)
      end

      it 'destroys the webauthn registration' do
        expect { subject }.to change { user.webauthn_registrations.count }.by(-1)
      end

      it 'does not remove the user backup codes' do
        expect { subject }.not_to change { user.otp_backup_codes }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  class CreateEventService < BaseService
    def execute
      ::Packages::Event.unique_counters_for(event_scope, event_name, originator_type).each do |event_name|
        ::Gitlab::UsageDataCounters::HLLRedisCounter.track_event(event_name, values: current_user.id)
      end

      ::Packages::Event.counters_for(event_scope, event_name, originator_type).each do |event_name|
        ::Gitlab::UsageDataCounters::PackageEventCounter.count(event_name)
      end
    end

    def originator_type
      case current_user
      when User
        :user
      when DeployToken
        :deploy_token
      else
        :guest
      end
    end

    private

    def event_scope
      @event_scope ||= scope.is_a?(::Packages::Package) ? scope.package_type : scope
    end

    def scope
      params[:scope]
    end

    def event_name
      params[:event_name]
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::CreateEventService, feature_category: :package_registry do
  let(:scope) { 'generic' }
  let(:event_name) { 'push_package' }

  let(:params) do
    {
      scope: scope,
      event_name: event_name
    }
  end

  subject { described_class.new(nil, user, params).execute }

  describe '#execute' do
    shared_examples 'redis package unique event creation' do |originator_type, expected_scope|
      it 'tracks the event' do
        expect(::Gitlab::UsageDataCounters::HLLRedisCounter).to receive(:track_event).with(/package/, values: user.id)

        subject
      end
    end

    shared_examples 'redis package count event creation' do |originator_type, expected_scope|
      it 'tracks the event' do
        expect(::Gitlab::UsageDataCounters::PackageEventCounter).to receive(:count).at_least(:once)

        subject
      end
    end

    context 'with a user' do
      let(:user) { create(:user) }

      it_behaves_like 'redis package unique event creation', 'user', 'generic'
      it_behaves_like 'redis package count event creation', 'user', 'generic'
    end

    context 'with a deploy token' do
      let(:user) { create(:deploy_token) }

      it_behaves_like 'redis package unique event creation', 'deploy_token', 'generic'
      it_behaves_like 'redis package count event creation', 'deploy_token', 'generic'
    end

    context 'with no user' do
      let(:user) { nil }

      it_behaves_like 'redis package count event creation', 'guest', 'generic'
    end

    context 'with a package as scope' do
      let(:scope) { create(:npm_package) }

      context 'as guest' do
        let(:user) { nil }

        it_behaves_like 'redis package count event creation', 'guest', 'npm'
      end

      context 'with user' do
        let(:user) { create(:user) }

        it_behaves_like 'redis package unique event creation', 'user', 'npm'
        it_behaves_like 'redis package count event creation', 'user', 'npm'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  # WARNING: ensure that permissions are verified before using this service.
  class MarkPackageFilesForDestructionService
    BATCH_SIZE = 500

    def initialize(package_files)
      @package_files = package_files
    end

    def execute(batch_deadline: nil, batch_size: BATCH_SIZE)
      timeout = false
      updates_count = 0
      min_batch_size = [batch_size, BATCH_SIZE].min

      @package_files.each_batch(of: min_batch_size) do |batched_package_files|
        if batch_deadline && Time.zone.now > batch_deadline
          timeout = true
          break
        end

        updates_count += batched_package_files.update_all(status: :pending_destruction)
      end

      payload = { marked_package_files_count: updates_count }

      return response_error(payload) if timeout

      response_success(payload)
    end

    private

    def response_success(payload)
      ServiceResponse.success(
        message: 'Package files are now pending destruction',
        payload: payload
      )
    end

    def response_error(payload)
      ServiceResponse.error(
        message: 'Timeout while marking package files as pending destruction',
        payload: payload
      )
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::MarkPackageFilesForDestructionService, :aggregate_failures,
  feature_category: :package_registry do
  let(:service) { described_class.new(package_files) }

  describe '#execute', :aggregate_failures do
    let(:batch_deadline) { nil }

    subject { service.execute(batch_deadline: batch_deadline) }

    shared_examples 'executing successfully' do |marked_package_files_count: 0|
      it 'marks package files for destruction' do
        expect { subject }
          .to change { ::Packages::PackageFile.pending_destruction.count }.by(package_files.size)
      end

      it 'executes successfully' do
        expect(subject).to be_success
        expect(subject.message).to eq('Package files are now pending destruction')
        expect(subject.payload).to eq(marked_package_files_count: marked_package_files_count)
      end
    end

    context 'with no package files' do
      let_it_be(:package_files) { ::Packages::PackageFile.none }

      it_behaves_like 'executing successfully'
    end

    context 'with a single package file' do
      let_it_be(:package_file) { create(:package_file) }
      let_it_be(:package_files) { ::Packages::PackageFile.id_in(package_file.id) }

      it_behaves_like 'executing successfully', marked_package_files_count: 1
    end

    context 'with many package files' do
      let_it_be(:package_files) { ::Packages::PackageFile.id_in(create_list(:package_file, 3).map(&:id)) }

      it_behaves_like 'executing successfully', marked_package_files_count: 3

      context 'with a batch deadline' do
        let_it_be(:batch_deadline) { 250.seconds.from_now }

        context 'when the deadline is not hit' do
          before do
            expect(Time.zone).to receive(:now).and_return(batch_deadline - 10.seconds)
          end

          it_behaves_like 'executing successfully', marked_package_files_count: 3
        end

        context 'when the deadline is hit' do
          it 'does not execute the batch loop' do
            expect(Time.zone).to receive(:now).and_return(batch_deadline + 10.seconds)
            expect { subject }.to not_change { ::Packages::PackageFile.pending_destruction.count }
            expect(subject).to be_error
            expect(subject.message).to eq('Timeout while marking package files as pending destruction')
            expect(subject.payload).to eq(marked_package_files_count: 0)
          end
        end
      end

      context 'when a batch size is defined' do
        let_it_be(:batch_deadline) { 250.seconds.from_now }

        let(:batch_size) { 2 }

        subject { service.execute(batch_deadline: batch_deadline, batch_size: batch_size) }

        before do
          expect(Time.zone).to receive(:now).twice.and_call_original
        end

        it_behaves_like 'executing successfully', marked_package_files_count: 3
      end
    end

    context 'with an error during the update' do
      let_it_be(:package_files) { ::Packages::PackageFile.none }

      before do
        expect(package_files).to receive(:each_batch).and_raise('error!')
      end

      it 'raises the error' do
        expect { subject }
          .to raise_error('error!')
          .and not_change { ::Packages::PackageFile.pending_destruction.count }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  class UpdatePackageFileService
    delegate :file, to: :@package_file

    def initialize(package_file, params)
      @package_file = package_file
      @params = params
    end

    def execute
      check_params

      return if same_as_params?

      # we need to access the file *before* updating the attributes linked to its path/key.
      file_storage_mode = file.file_storage?

      @package_file.package_id = package_id if package_id
      @package_file.file_name = file_name if file_name

      if file_storage_mode
        # package file is in mode LOCAL: we can pass the `file` to the update
        @package_file.file = file
      else
        # package file is in mode REMOTE: don't pass the `file` to the update
        # instead, pass the new file path. This will move the file
        # in object storage.
        @package_file.new_file_path = File.join(file.store_dir, @package_file.file_name)
      end

      @package_file.save!
    end

    private

    def check_params
      raise ArgumentError, 'package_file not persisted' unless @package_file.persisted?
      raise ArgumentError, 'package_id and file_name are blank' if package_id.blank? && file_name.blank?
    end

    def same_as_params?
      return false if package_id && package_id != @package_file.package_id
      return false if file_name && file_name != @package_file.file_name

      true
    end

    def package_id
      @params[:package_id]
    end

    def file_name
      @params[:file_name]
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::UpdatePackageFileService, feature_category: :package_registry do
  let_it_be(:another_package) { create(:package) }
  let_it_be(:old_file_name) { 'old_file_name.txt' }
  let_it_be(:new_file_name) { 'new_file_name.txt' }

  let(:package) { package_file.package }
  let(:params) { { package_id: another_package.id, file_name: new_file_name } }
  let(:service) { described_class.new(package_file, params) }

  describe '#execute' do
    subject { service.execute }

    shared_examples 'updating package file with valid parameters' do
      context 'with both parameters set' do
        it 'updates the package file accordingly' do
          expect { subject }
            .to change { package.package_files.count }.from(1).to(0)
            .and change { another_package.package_files.count }.from(0).to(1)
            .and change { package_file.package_id }.from(package.id).to(another_package.id)
            .and change { package_file.file_name }.from(old_file_name).to(new_file_name)
        end
      end

      context 'with only file_name set' do
        let(:params) { { file_name: new_file_name } }

        it 'updates the package file accordingly' do
          expect { subject }
            .to not_change { package.package_files.count }
            .and not_change { another_package.package_files.count }
            .and not_change { package_file.package_id }
            .and change { package_file.file_name }.from(old_file_name).to(new_file_name)
        end
      end

      context 'with only package_id set' do
        let(:params) { { package_id: another_package.id } }

        it 'updates the package file accordingly' do
          expect { subject }
            .to change { package.package_files.count }.from(1).to(0)
            .and change { another_package.package_files.count }.from(0).to(1)
            .and change { package_file.package_id }.from(package.id).to(another_package.id)
            .and not_change { package_file.file_name }
        end
      end
    end

    shared_examples 'not updating package with invalid parameters' do
      context 'with blank parameters' do
        let(:params) { {} }

        it 'raise an argument error' do
          expect { subject }.to raise_error(ArgumentError, 'package_id and file_name are blank')
        end
      end

      context 'with non persisted package file' do
        let(:package_file) { build(:package_file) }

        it 'raise an argument error' do
          expect { subject }.to raise_error(ArgumentError, 'package_file not persisted')
        end
      end
    end

    context 'with object storage disabled' do
      let(:package_file) { create(:package_file, file_name: old_file_name) }

      before do
        stub_package_file_object_storage(enabled: false)
      end

      it_behaves_like 'updating package file with valid parameters' do
        before do
          expect(package_file).to receive(:remove_previously_stored_file).and_call_original
          expect(package_file).not_to receive(:move_in_object_storage)
        end
      end

      it_behaves_like 'not updating package with invalid parameters'
    end

    context 'with object storage enabled' do
      let(:package_file) do
        create(
          :package_file,
          file_name: old_file_name,
          file: CarrierWaveStringFile.new_file(
            file_content: 'content',
            filename: old_file_name,
            content_type: 'text/plain'
          ),
          file_store: ::Packages::PackageFileUploader::Store::REMOTE
        )
      end

      before do
        stub_package_file_object_storage(enabled: true)
      end

      it_behaves_like 'updating package file with valid parameters' do
        before do
          expect(package_file).not_to receive(:remove_previously_stored_file)
          expect(package_file).to receive(:move_in_object_storage).and_call_original
        end
      end

      it_behaves_like 'not updating package with invalid parameters' do
        before do
          expect(package_file.file.file).not_to receive(:copy_to)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
  class CreatePackageFileService
    attr_reader :package, :params

    def initialize(package, params)
      @package = package
      @params = params
    end

    def execute
      package_file = package.package_files.build(
        file: params[:file],
        size: params[:size],
        file_name: params[:file_name],
        file_sha1: params[:file_sha1],
        file_sha256: params[:file_sha256],
        file_md5: params[:file_md5]
      )

      if params[:build].present?
        package_file.package_file_build_infos << package_file.package_file_build_infos.build(pipeline: params[:build].pipeline)
      end

      package_file.save!
      package_file
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::CreatePackageFileService, feature_category: :package_registry do
  let_it_be(:package) { create(:maven_package) }
  let_it_be(:user) { create(:user) }

  let(:service) { described_class.new(package, params) }

  describe '#execute' do
    subject { service.execute }

    context 'with valid params' do
      let(:params) do
        {
          file: Tempfile.new,
          file_name: 'foo.jar'
        }
      end

      it 'creates a new package file' do
        package_file = subject

        expect(package_file).to be_valid
        expect(package_file.file_name).to eq('foo.jar')
      end

      it_behaves_like 'assigns build to package file'
    end

    context 'file is missing' do
      let(:params) do
        {
          file_name: 'foo.jar'
        }
      end

      it 'raises an error' do
        expect { subject }.to raise_error(ActiveRecord::RecordInvalid)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
  class UpdateTagsService
    include Gitlab::Utils::StrongMemoize

    def initialize(package, tags = [])
      @package = package
      @tags = tags
    end

    def execute
      return if @tags.empty?

      tags_to_destroy = existing_tags - @tags
      tags_to_create = @tags - existing_tags

      @package.tags.with_name(tags_to_destroy).delete_all if tags_to_destroy.any?
      ::ApplicationRecord.legacy_bulk_insert(Packages::Tag.table_name, rows(tags_to_create)) if tags_to_create.any? # rubocop:disable Gitlab/BulkInsert
    end

    private

    def existing_tags
      @package.tag_names
    end
    strong_memoize_attr :existing_tags

    def rows(tags)
      now = Time.zone.now
      tags.map do |tag|
        {
          package_id: @package.id,
          name: tag,
          created_at: now,
          updated_at: now,
          project_id: @package.project_id
        }
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::UpdateTagsService, feature_category: :package_registry do
  let_it_be(:package, reload: true) { create(:nuget_package) }

  let(:tags) { %w[test-tag tag1 tag2 tag3] }
  let(:service) { described_class.new(package, tags) }

  describe '#execute' do
    subject { service.execute }

    RSpec.shared_examples 'updating tags' do |tags_count|
      it 'updates a tag' do
        expect { subject }.to change { Packages::Tag.count }.by(tags_count)
        expect(package.reload.tags.map(&:name)).to contain_exactly(*tags)
      end
    end

    it_behaves_like 'updating tags', 4

    context 'with an existing tag' do
      before do
        create(:packages_tag, package: package2, name: 'test-tag')
      end

      context 'on the same package' do
        let_it_be(:package2) { package }

        it_behaves_like 'updating tags', 3

        context 'with different name' do
          before do
            create(:packages_tag, package: package2, name: 'to_be_destroyed')
          end

          it_behaves_like 'updating tags', 2
        end
      end

      context 'on a different package' do
        let_it_be(:package2) { create(:nuget_package) }

        it_behaves_like 'updating tags', 4
      end
    end

    context 'with empty tags' do
      let(:tags) { [] }

      it 'is a no op' do
        expect(package).not_to receive(:tags)
        expect(::ApplicationRecord).not_to receive(:legacy_bulk_insert)

        subject
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
  class RemoveTagService < BaseService
    attr_reader :package_tag

    def initialize(package_tag)
      raise ArgumentError, ""Package tag must be set"" if package_tag.blank?

      @package_tag = package_tag
    end

    def execute
      package_tag.delete
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::RemoveTagService, feature_category: :package_registry do
  let!(:package_tag) { create(:packages_tag) }

  describe '#execute' do
    subject { described_class.new(package_tag).execute }

    context 'with existing tag' do
      it { expect { subject }.to change { Packages::Tag.count }.by(-1) }
    end

    context 'with nil' do
      subject { described_class.new(nil) }

      it { expect { subject }.to raise_error(ArgumentError) }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  class MarkPackageForDestructionService < BaseContainerService
    alias_method :package, :container

    def execute
      return service_response_error(""You don't have access to this package"", 403) unless user_can_delete_package?

      package.pending_destruction!

      package.mark_package_files_for_destruction
      package.sync_maven_metadata(current_user)

      service_response_success('Package was successfully marked as pending destruction')
    rescue StandardError => e
      track_exception(e)
      service_response_error('Failed to mark the package as pending destruction', 400)
    end

    private

    def service_response_error(message, http_status)
      ServiceResponse.error(message: message, http_status: http_status)
    end

    def service_response_success(message)
      ServiceResponse.success(message: message)
    end

    def user_can_delete_package?
      can?(current_user, :destroy_package, package.project)
    end

    def track_exception(error)
      Gitlab::ErrorTracking.track_exception(
        error,
        project_id: package.project_id,
        package_id: package.id
      )
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::MarkPackageForDestructionService, feature_category: :package_registry do
  let_it_be(:user) { create(:user) }
  let_it_be_with_reload(:package) { create(:npm_package) }

  describe '#execute' do
    subject(:service) { described_class.new(container: package, current_user: user) }

    context 'when the user is authorized' do
      before do
        package.project.add_maintainer(user)
      end

      context 'when it is successful' do
        it 'marks the package and package files as pending destruction' do
          expect(package).to receive(:sync_maven_metadata).and_call_original
          expect(package).to receive(:mark_package_files_for_destruction).and_call_original
          expect { service.execute }.to change { package.status }.from('default').to('pending_destruction')
        end

        it 'returns a success ServiceResponse' do
          response = service.execute

          expect(response).to be_a(ServiceResponse)
          expect(response).to be_success
          expect(response.message).to eq(""Package was successfully marked as pending destruction"")
        end
      end

      context 'when it is not successful' do
        before do
          allow(package).to receive(:pending_destruction!).and_raise(StandardError, ""test"")
        end

        it 'returns an error ServiceResponse' do
          expect(Gitlab::ErrorTracking).to receive(:track_exception).with(
            instance_of(StandardError),
            project_id: package.project_id,
            package_id: package.id
          )

          response = service.execute

          expect(package).not_to receive(:sync_maven_metadata)
          expect(response).to be_a(ServiceResponse)
          expect(response).to be_error
          expect(response.message).to eq(""Failed to mark the package as pending destruction"")
          expect(response.status).to eq(:error)
        end
      end
    end

    context 'when the user is not authorized' do
      it 'returns an error ServiceResponse' do
        response = service.execute

        expect(response).to be_a(ServiceResponse)
        expect(response).to be_error
        expect(response.message).to eq(""You don't have access to this package"")
        expect(response.status).to eq(:error)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  class CreateTemporaryPackageService < ::Packages::CreatePackageService
    PACKAGE_VERSION = '0.0.0'

    def execute(package_type, name: 'Temporary.Package')
      create_package!(package_type,
        name: name,
        version: ""#{PACKAGE_VERSION}-#{uuid}"",
        status: 'processing'
      )
    end

    private

    def uuid
      SecureRandom.uuid
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::CreateTemporaryPackageService, feature_category: :package_registry do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }
  let_it_be(:params) { {} }
  let_it_be(:package_name) { 'my-package' }
  let_it_be(:package_type) { 'rubygems' }

  describe '#execute' do
    subject { described_class.new(project, user, params).execute(package_type, name: package_name) }

    let(:package) { Packages::Package.last }

    it 'creates the package', :aggregate_failures do
      expect { subject }.to change { Packages::Package.count }.by(1)

      expect(package).to be_valid
      expect(package).to be_processing
      expect(package.name).to eq(package_name)
      expect(package.version).to start_with(described_class::PACKAGE_VERSION)
      expect(package.package_type).to eq(package_type)
    end

    it 'can create two packages in a row', :aggregate_failures do
      expect { subject }.to change { Packages::Package.count }.by(1)

      expect do
        described_class.new(project, user, params).execute(package_type, name: package_name)
      end.to change { Packages::Package.count }.by(1)

      expect(package).to be_valid
      expect(package).to be_processing
      expect(package.name).to eq(package_name)
      expect(package.version).to start_with(described_class::PACKAGE_VERSION)
      expect(package.package_type).to eq(package_type)
    end

    it_behaves_like 'assigns the package creator'
    it_behaves_like 'assigns build to package'
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  class MarkPackagesForDestructionService
    include BaseServiceUtility

    BATCH_SIZE = 20

    UNAUTHORIZED_RESPONSE = ServiceResponse.error(
      message: ""You don't have the permission to perform this action"",
      reason: :unauthorized
    ).freeze

    ERROR_RESPONSE = ServiceResponse.error(
      message: 'Failed to mark the packages as pending destruction'
    ).freeze

    SUCCESS_RESPONSE = ServiceResponse.success(
      message: 'Packages were successfully marked as pending destruction'
    ).freeze

    # Initialize this service with the given packages and user.
    #
    # * `packages`: must be an ActiveRecord relationship.
    # * `current_user`: an User object. Could be nil.
    def initialize(packages:, current_user: nil)
      @packages = packages
      @current_user = current_user
    end

    def execute(batch_size: BATCH_SIZE)
      no_access = false
      min_batch_size = [batch_size, BATCH_SIZE].min
      package_ids = []

      @packages.each_batch(of: min_batch_size) do |batched_packages|
        loaded_packages = batched_packages.including_project_route.to_a
        package_ids = loaded_packages.map(&:id)

        break no_access = true unless can_destroy_packages?(loaded_packages)

        ::Packages::Package.id_in(package_ids)
                           .update_all(status: :pending_destruction)

        sync_maven_metadata(loaded_packages)
        mark_package_files_for_destruction(loaded_packages)
      end

      return UNAUTHORIZED_RESPONSE if no_access

      SUCCESS_RESPONSE
    rescue StandardError => e
      track_exception(e, package_ids)
      ERROR_RESPONSE
    end

    private

    def mark_package_files_for_destruction(packages)
      ::Packages::MarkPackageFilesForDestructionWorker.bulk_perform_async_with_contexts(
        packages,
        arguments_proc: -> (package) { package.id },
        context_proc: -> (package) { { project: package.project, user: @current_user } }
      )
    end

    def sync_maven_metadata(packages)
      maven_packages_with_version = packages.select { |pkg| pkg.maven? && pkg.version? }
      ::Packages::Maven::Metadata::SyncWorker.bulk_perform_async_with_contexts(
        maven_packages_with_version,
        arguments_proc: -> (package) { [@current_user.id, package.project_id, package.name] },
        context_proc: -> (package) { { project: package.project, user: @current_user } }
      )
    end

    def can_destroy_packages?(packages)
      packages.all? do |package|
        can?(@current_user, :destroy_package, package)
      end
    end

    def track_exception(error, package_ids)
      Gitlab::ErrorTracking.track_exception(error, package_ids: package_ids)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::MarkPackagesForDestructionService, :sidekiq_inline, feature_category: :package_registry do
  let_it_be(:project) { create(:project) }
  let_it_be_with_reload(:packages) { create_list(:npm_package, 3, project: project) }

  let(:user) { project.owner }

  # The service only accepts ActiveRecord relationships and not arrays.
  let(:service) { described_class.new(packages: ::Packages::Package.id_in(package_ids), current_user: user) }
  let(:package_ids) { packages.map(&:id) }

  describe '#execute' do
    subject { service.execute }

    context 'when the user is authorized' do
      before do
        project.add_maintainer(user)
      end

      context 'when it is successful' do
        it 'marks the packages as pending destruction' do
          expect(::Packages::Maven::Metadata::SyncService).not_to receive(:new)

          expect { subject }.to change { ::Packages::Package.pending_destruction.count }.from(0).to(3)
                                  .and change { Packages::PackageFile.pending_destruction.count }.from(0).to(3)
          packages.each { |pkg| expect(pkg.reload).to be_pending_destruction }

          expect(subject).to be_a(ServiceResponse)
          expect(subject).to be_success
          expect(subject.message).to eq('Packages were successfully marked as pending destruction')
        end

        context 'with maven packages' do
          let_it_be_with_reload(:packages) { create_list(:maven_package, 3, project: project) }

          it 'marks the packages as pending destruction' do
            expect(::Packages::Maven::Metadata::SyncService).to receive(:new).once.and_call_original

            expect { subject }.to change { ::Packages::Package.pending_destruction.count }.from(0).to(3)
                                    .and change { Packages::PackageFile.pending_destruction.count }.from(0).to(9)
            packages.each { |pkg| expect(pkg.reload).to be_pending_destruction }

            expect(subject).to be_a(ServiceResponse)
            expect(subject).to be_success
            expect(subject.message).to eq('Packages were successfully marked as pending destruction')
          end

          context 'without version' do
            before do
              ::Packages::Package.id_in(package_ids).update_all(version: nil)
            end

            it 'marks the packages as pending destruction' do
              expect(::Packages::Maven::Metadata::SyncService).not_to receive(:new)

              expect { subject }.to change { ::Packages::Package.pending_destruction.count }.from(0).to(3)
                                      .and change { Packages::PackageFile.pending_destruction.count }.from(0).to(9)
              packages.each { |pkg| expect(pkg.reload).to be_pending_destruction }

              expect(subject).to be_a(ServiceResponse)
              expect(subject).to be_success
              expect(subject.message).to eq('Packages were successfully marked as pending destruction')
            end
          end
        end
      end

      context 'when it is not successful' do
        before do
          allow(service).to receive(:can_destroy_packages?).and_raise(StandardError, 'test')
        end

        it 'returns an error ServiceResponse' do
          expect(::Packages::Maven::Metadata::SyncService).not_to receive(:new)

          expect(Gitlab::ErrorTracking).to receive(:track_exception).with(
            instance_of(StandardError),
            package_ids: package_ids
          )

          expect { subject }.to not_change { ::Packages::Package.pending_destruction.count }
                                  .and not_change { ::Packages::PackageFile.pending_destruction.count }

          expect(subject).to be_a(ServiceResponse)
          expect(subject).to be_error
          expect(subject.message).to eq(""Failed to mark the packages as pending destruction"")
          expect(subject.status).to eq(:error)
        end
      end
    end

    context 'when the user is not authorized' do
      let(:user) { nil }

      it 'returns an error ServiceResponse' do
        expect(::Packages::Maven::Metadata::SyncService).not_to receive(:new)

        expect { subject }.to not_change { ::Packages::Package.pending_destruction.count }
                                .and not_change { ::Packages::PackageFile.pending_destruction.count }

        expect(subject).to be_a(ServiceResponse)
        expect(subject).to be_error
        expect(subject.message).to eq(""You don't have the permission to perform this action"")
        expect(subject.status).to eq(:error)
        expect(subject.reason).to eq(:unauthorized)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
  # rubocop: disable Gitlab/BulkInsert
  class CreateDependencyService < BaseService
    attr_reader :package, :dependencies

    def initialize(package, dependencies)
      @package = package
      @dependencies = dependencies
    end

    def execute
      Packages::DependencyLink.dependency_types.each_key do |type|
        create_dependency(type)
      end
    end

    private

    def create_dependency(type)
      return unless dependencies[type].is_a?(Hash)

      names_and_version_patterns = dependencies[type]
      existing_ids, existing_names = find_existing_ids_and_names(names_and_version_patterns)
      dependencies_to_insert = names_and_version_patterns

      if existing_names.any?
        dependencies_to_insert = names_and_version_patterns.reject { |k, _| k.in?(existing_names) }
      end

      ApplicationRecord.transaction do
        inserted_ids = bulk_insert_package_dependencies(dependencies_to_insert)
        bulk_insert_package_dependency_links(type, (existing_ids + inserted_ids))
      end
    end

    def find_existing_ids_and_names(names_and_version_patterns)
      ids_and_names = Packages::Dependency.for_package_names_and_version_patterns(names_and_version_patterns)
                                          .pluck_ids_and_names
      ids = ids_and_names.map(&:first) || []
      names = ids_and_names.map(&:second) || []
      [ids, names]
    end

    def bulk_insert_package_dependencies(names_and_version_patterns)
      return [] if names_and_version_patterns.empty?

      rows = names_and_version_patterns.map do |name, version_pattern|
        {
          name: name,
          version_pattern: version_pattern
        }
      end

      ids = ApplicationRecord.legacy_bulk_insert(Packages::Dependency.table_name, rows, return_ids: true, on_conflict: :do_nothing)
      return ids if ids.size == names_and_version_patterns.size

      Packages::Dependency.uncached do
        # The bulk_insert statement above do not dirty the query cache. To make
        # sure that the results are fresh from the database and not from a stalled
        # and potentially wrong cache, this query has to be done with the query
        # cache disabled.
        Packages::Dependency.ids_for_package_names_and_version_patterns(names_and_version_patterns)
      end
    end

    def bulk_insert_package_dependency_links(type, dependency_ids)
      rows = dependency_ids.map do |dependency_id|
        {
          package_id: package.id,
          dependency_id: dependency_id,
          dependency_type: Packages::DependencyLink.dependency_types[type.to_s]
        }
      end

      ApplicationRecord.legacy_bulk_insert(Packages::DependencyLink.table_name, rows)
    end
  end
  # rubocop: enable Gitlab/BulkInsert
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::CreateDependencyService, feature_category: :package_registry do
  describe '#execute' do
    let_it_be(:namespace) { create(:namespace) }
    let_it_be(:version) { '1.0.1' }
    let_it_be(:package_name) { ""@#{namespace.path}/my-app"" }

    context 'when packages are published' do
      let(:json_file) { 'packages/npm/payload.json' }
      let(:params) do
        Gitlab::Json.parse(fixture_file(json_file)
                .gsub('@root/npm-test', package_name)
                .gsub('1.0.1', version))
                .with_indifferent_access
      end

      let(:package_version) { params[:versions].each_key.first }
      let(:dependencies) { params[:versions][package_version] }
      let(:package) { create(:npm_package) }
      let(:dependency_names) { package.dependency_links.flat_map(&:dependency).map(&:name).sort }
      let(:dependency_link_types) { package.dependency_links.map(&:dependency_type).sort }

      subject { described_class.new(package, dependencies).execute }

      it 'creates dependencies and links' do
        expect(Packages::Dependency)
            .to receive(:ids_for_package_names_and_version_patterns)
            .once
            .and_call_original

        expect { subject }
          .to change { Packages::Dependency.count }.by(1)
          .and change { Packages::DependencyLink.count }.by(1)
        expect(dependency_names).to match_array(%w[express])
        expect(dependency_link_types).to match_array(%w[dependencies])
      end

      context 'with repeated packages' do
        let(:json_file) { 'packages/npm/payload_with_duplicated_packages.json' }

        it 'creates dependencies and links' do
          expect(Packages::Dependency)
            .to receive(:ids_for_package_names_and_version_patterns)
            .exactly(4).times
            .and_call_original

          expect { subject }
            .to change { Packages::Dependency.count }.by(4)
            .and change { Packages::DependencyLink.count }.by(6)
          expect(dependency_names).to match_array(%w[d3 d3 d3 dagre-d3 dagre-d3 express])
          expect(dependency_link_types).to match_array(%w[bundleDependencies dependencies dependencies devDependencies devDependencies peerDependencies])
        end
      end

      context 'with dependencies bulk insert conflicts' do
        let_it_be(:rows) { [{ name: 'express', version_pattern: '^4.16.4' }] }

        it 'creates dependences and links' do
          original_bulk_insert = ::ApplicationRecord.method(:legacy_bulk_insert)
          expect(::ApplicationRecord)
            .to receive(:legacy_bulk_insert) do |table, rows, return_ids: false, disable_quote: [], on_conflict: nil|
              call_count = table == Packages::Dependency.table_name ? 2 : 1
              call_count.times { original_bulk_insert.call(table, rows, return_ids: return_ids, disable_quote: disable_quote, on_conflict: on_conflict) }
            end.twice
          expect(Packages::Dependency)
            .to receive(:ids_for_package_names_and_version_patterns)
            .twice
            .and_call_original

          expect { subject }
            .to change { Packages::Dependency.count }.by(1)
            .and change { Packages::DependencyLink.count }.by(1)
          expect(dependency_names).to match_array(%w[express])
          expect(dependency_link_types).to match_array(%w[dependencies])
        end
      end

      context 'with existing dependencies' do
        let(:other_package) { create(:npm_package) }

        before do
          described_class.new(other_package, dependencies).execute
        end

        it 'reuses them' do
          expect { subject }
            .to not_change { Packages::Dependency.count }
            .and change { Packages::DependencyLink.count }.by(1)
        end
      end

      context 'with a dependency not described with a hash' do
        let(:invalid_dependencies) { dependencies.tap { |d| d['bundleDependencies'] = false } }

        subject { described_class.new(package, invalid_dependencies).execute }

        it 'creates dependencies and links' do
          expect(Packages::Dependency)
              .to receive(:ids_for_package_names_and_version_patterns)
              .once
              .and_call_original

          expect { subject }
            .to change { Packages::Dependency.count }.by(1)
            .and change { Packages::DependencyLink.count }.by(1)
          expect(dependency_names).to match_array(%w[express])
          expect(dependency_link_types).to match_array(%w[dependencies])
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module MlModel
    class CreatePackageFileService < BaseService
      def execute
        ::Packages::Package.transaction do
          package = find_or_create_package
          find_or_create_model_version(package)

          create_package_file(package)
        end
      end

      private

      def find_or_create_package
        package_params = {
          name: params[:package_name],
          version: params[:package_version],
          build: params[:build],
          status: params[:status]
        }

        package = ::Packages::MlModel::FindOrCreatePackageService
                    .new(project, current_user, package_params)
                    .execute

        package.update_column(:status, params[:status]) if params[:status] && params[:status] != package.status

        package.create_build_infos!(params[:build])

        package
      end

      def find_or_create_model_version(package)
        model_version_params = {
          model_name: package.name,
          version: package.version,
          package: package,
          user: current_user
        }

        Ml::FindOrCreateModelVersionService.new(project, model_version_params).execute
      end

      def create_package_file(package)
        file_params = {
          file: params[:file],
          size: params[:file].size,
          file_sha256: params[:file].sha256,
          file_name: params[:file_name],
          build: params[:build]
        }

        ::Packages::CreatePackageFileService.new(package, file_params).execute
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::MlModel::CreatePackageFileService, feature_category: :mlops do
  describe '#execute' do
    let_it_be(:project) { create(:project) }
    let_it_be(:user) { create(:user) }
    let_it_be(:pipeline) { create(:ci_pipeline, user: user, project: project) }
    let_it_be(:file_name) { 'myfile.tar.gz.1' }

    let(:build) { instance_double(Ci::Build, pipeline: pipeline) }

    let(:sha256) { '440e5e148a25331bbd7991575f7d54933c0ebf6cc735a18ee5066ac1381bb590' }
    let(:temp_file) { Tempfile.new(""test"") }
    let(:file) { UploadedFile.new(temp_file.path, sha256: sha256) }
    let(:package_service) { double }

    subject(:execute_service) { described_class.new(project, user, params).execute }

    before do
      FileUtils.touch(temp_file)
    end

    after do
      FileUtils.rm_f(temp_file)
    end

    context 'without existing package' do
      let(:params) do
        {
          package_name: 'new_model',
          package_version: '1.0.0',
          file: file,
          file_name: file_name
        }
      end

      it 'creates package file', :aggregate_failures do
        expect { execute_service }
          .to change { Packages::MlModel::Package.count }.by(1)
          .and change { Packages::PackageFile.count }.by(1)
          .and change { Packages::PackageFileBuildInfo.count }.by(0)
          .and change { Ml::ModelVersion.count }.by(1)

        new_model = Packages::MlModel::Package.last
        package_file = new_model.package_files.last
        new_model_version = Ml::ModelVersion.last

        expect(new_model.name).to eq('new_model')
        expect(new_model.version).to eq('1.0.0')
        expect(new_model.status).to eq('default')
        expect(package_file.package).to eq(new_model)
        expect(package_file.file_name).to eq(file_name)
        expect(package_file.size).to eq(file.size)
        expect(package_file.file_sha256).to eq(sha256)
        expect(new_model_version.name).to eq('new_model')
        expect(new_model_version.version).to eq('1.0.0')
        expect(new_model_version.package).to eq(new_model)
      end
    end

    context 'with existing package' do
      let_it_be(:model) { create(:ml_model_package, creator: user, project: project, version: '0.1.0') }

      let(:params) do
        {
          package_name: model.name,
          package_version: model.version,
          file: file,
          file_name: file_name,
          status: :hidden,
          build: build
        }
      end

      it 'adds the package file and updates status and ci_build', :aggregate_failures do
        expect { execute_service }
          .to change { project.packages.ml_model.count }.by(0)
          .and change { model.package_files.count }.by(1)
          .and change { Packages::PackageFileBuildInfo.count }.by(1)

        model.reload

        package_file = model.package_files.last

        expect(model.build_infos.first.pipeline).to eq(build.pipeline)
        expect(model.status).to eq('hidden')

        expect(package_file.package).to eq(model)
        expect(package_file.file_name).to eq(file_name)
        expect(package_file.size).to eq(file.size)
        expect(package_file.file_sha256).to eq(sha256)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module MlModel
    class FindOrCreatePackageService < ::Packages::CreatePackageService
      def execute
        find_or_create_package!(::Packages::Package.package_types['ml_model'])
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::MlModel::FindOrCreatePackageService, feature_category: :mlops do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { project.creator }
  let_it_be(:ci_build) { create(:ci_build, :running, user: user, project: project) }

  let(:base_params) do
    {
      name: 'mymodel',
      version: '0.0.1'
    }
  end

  let(:params) { base_params }

  describe '#execute' do
    subject(:execute_service) { described_class.new(project, user, params).execute }

    context 'when model does not exist' do
      it 'creates the model' do
        expect { subject }.to change { project.packages.ml_model.count }.by(1)

        package = project.packages.ml_model.last

        aggregate_failures do
          expect(package.creator).to eq(user)
          expect(package.package_type).to eq('ml_model')
          expect(package.name).to eq('mymodel')
          expect(package.version).to eq('0.0.1')
          expect(package.build_infos.count).to eq(0)
        end
      end

      context 'when build is provided' do
        let(:params) { base_params.merge(build: ci_build) }

        it 'creates package and package build info' do
          expect { subject }.to change { project.packages.ml_model.count }.by(1)

          package = project.packages.ml_model.last

          aggregate_failures do
            expect(package.creator).to eq(user)
            expect(package.package_type).to eq('ml_model')
            expect(package.name).to eq('mymodel')
            expect(package.version).to eq('0.0.1')
            expect(package.build_infos.first.pipeline).to eq(ci_build.pipeline)
          end
        end
      end
    end

    context 'when model already exists' do
      it 'does not create a new model', :aggregate_failures do
        model = project.packages.ml_model.create!(params)

        expect do
          new_model = subject
          expect(new_model).to eq(model)
        end.not_to change { project.packages.ml_model.count }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Pypi
    class CreatePackageService < ::Packages::CreatePackageService
      include ::Gitlab::Utils::StrongMemoize

      def execute
        ::Packages::Package.transaction do
          meta = Packages::Pypi::Metadatum.new(
            package: created_package,
            required_python: params[:requires_python] || '',
            metadata_version: params[:metadata_version],
            author_email: params[:author_email],
            description: params[:description]&.truncate(::Packages::Pypi::Metadatum::MAX_DESCRIPTION_LENGTH),
            description_content_type: params[:description_content_type],
            summary: params[:summary],
            keywords: params[:keywords]
          )

          unless meta.valid?
            raise ActiveRecord::RecordInvalid, meta
          end

          params.delete(:md5_digest) if Gitlab::FIPS.enabled?

          Packages::Pypi::Metadatum.upsert(meta.attributes)

          ::Packages::CreatePackageFileService.new(created_package, file_params).execute

          created_package
        end
      end

      private

      def created_package
        find_or_create_package!(:pypi)
      end
      strong_memoize_attr :created_package

      def file_params
        {
          build: params[:build],
          file: params[:content],
          file_name: params[:content].original_filename,
          file_md5: params[:md5_digest],
          file_sha256: params[:sha256_digest]
        }
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::Pypi::CreatePackageService, :aggregate_failures, feature_category: :package_registry do
  include PackagesManagerApiSpecHelpers

  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }

  let(:sha256) { '1' * 64 }
  let(:md5) { '567' }

  let(:requires_python) { '>=2.7' }
  let(:params) do
    {
      name: 'foo',
      version: '1.0',
      content: temp_file('foo.tgz'),
      requires_python: requires_python,
      sha256_digest: sha256,
      md5_digest: md5
    }
  end

  describe '#execute' do
    subject { described_class.new(project, user, params).execute }

    let(:created_package) { Packages::Package.pypi.last }

    context 'without an existing package' do
      it 'creates the package' do
        expect { subject }.to change { Packages::Package.pypi.count }.by(1)

        expect(created_package.name).to eq 'foo'
        expect(created_package.version).to eq '1.0'

        expect(created_package.pypi_metadatum.required_python).to eq '>=2.7'
        expect(created_package.package_files.size).to eq 1
        expect(created_package.package_files.first.file_name).to eq 'foo.tgz'
        expect(created_package.package_files.first.file_sha256).to eq sha256
        expect(created_package.package_files.first.file_md5).to eq md5
      end
    end

    context 'with FIPS mode', :fips_mode do
      it 'does not generate file_md5' do
        expect { subject }.to change { Packages::Package.pypi.count }.by(1)

        expect(created_package.name).to eq 'foo'
        expect(created_package.version).to eq '1.0'

        expect(created_package.pypi_metadatum.required_python).to eq '>=2.7'
        expect(created_package.package_files.size).to eq 1
        expect(created_package.package_files.first.file_name).to eq 'foo.tgz'
        expect(created_package.package_files.first.file_sha256).to eq sha256
        expect(created_package.package_files.first.file_md5).to be_nil
      end
    end

    context 'without required_python' do
      before do
        params.delete(:requires_python)
      end

      it 'creates the package' do
        expect { subject }.to change { Packages::Package.pypi.count }.by(1)

        expect(created_package.pypi_metadatum.required_python).to eq ''
      end
    end

    context 'with additional metadata' do
      before do
        params.merge!(
          metadata_version: '2.3',
          author_email: 'cschultz@example.com, snoopy@peanuts.com',
          description: 'Example description',
          description_content_type: 'text/plain',
          summary: 'A module for collecting votes from beagles.',
          keywords: 'dog,puppy,voting,election'
        )
      end

      it 'creates the package' do
        expect { subject }.to change { Packages::Package.pypi.count }.by(1)

        expect(created_package.pypi_metadatum.metadata_version).to eq('2.3')
        expect(created_package.pypi_metadatum.author_email).to eq('cschultz@example.com, snoopy@peanuts.com')
        expect(created_package.pypi_metadatum.description).to eq('Example description')
        expect(created_package.pypi_metadatum.description_content_type).to eq('text/plain')
        expect(created_package.pypi_metadatum.summary).to eq('A module for collecting votes from beagles.')
        expect(created_package.pypi_metadatum.keywords).to eq('dog,puppy,voting,election')
      end
    end

    context 'with a very long metadata description field' do
      let(:max_length) { ::Packages::Pypi::Metadatum::MAX_DESCRIPTION_LENGTH }
      let(:truncated_description) { ('x' * (max_length + 1)).truncate(max_length) }

      before do
        params.merge!(
          description: 'x' * (max_length + 1)
        )
      end

      it 'truncates the description field' do
        expect { subject }.to change { Packages::Package.pypi.count }.by(1)

        expect(created_package.pypi_metadatum.description).to eq(truncated_description)
      end
    end

    context 'with an invalid metadata' do
      let(:requires_python) { 'x' * 256 }

      it 'raises an error' do
        expect { subject }.to raise_error(ActiveRecord::RecordInvalid)
      end
    end

    it_behaves_like 'assigns the package creator' do
      let(:package) { created_package }
    end

    it_behaves_like 'assigns build to package'
    it_behaves_like 'assigns status to package'

    context 'with an existing package' do
      before do
        described_class.new(project, user, params).execute
      end

      context 'with an existing file' do
        before do
          params[:content] = temp_file('foo.tgz')
          params[:sha256_digest] = sha256
          params[:md5_digest] = md5
        end

        it 'throws an error' do
          expect { subject }
            .to change { Packages::Package.pypi.count }.by(0)
            .and change { Packages::PackageFile.count }.by(0)
            .and raise_error(/File name has already been taken/)
        end

        context 'with a pending_destruction package' do
          before do
            Packages::Package.pypi.last.pending_destruction!
          end

          it 'creates a new package' do
            expect { subject }
              .to change { Packages::Package.pypi.count }.by(1)
              .and change { Packages::PackageFile.count }.by(1)

            expect(created_package.name).to eq 'foo'
            expect(created_package.version).to eq '1.0'

            expect(created_package.pypi_metadatum.required_python).to eq '>=2.7'
            expect(created_package.package_files.size).to eq 1
            expect(created_package.package_files.first.file_name).to eq 'foo.tgz'
            expect(created_package.package_files.first.file_sha256).to eq sha256
            expect(created_package.package_files.first.file_md5).to eq md5
          end
        end
      end

      context 'without an existing file' do
        before do
          params[:content] = temp_file('another.tgz')
        end

        it 'adds the file' do
          expect { subject }
            .to change { Packages::Package.pypi.count }.by(0)
            .and change { Packages::PackageFile.count }.by(1)

          expect(created_package.package_files.size).to eq 2
          expect(created_package.package_files.map(&:file_name).sort).to eq ['another.tgz', 'foo.tgz']
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Go
    class CreatePackageService < BaseService
      GoZipSizeError = Class.new(StandardError)

      attr_accessor :version

      def initialize(project, user = nil, version:)
        super(project, user)

        @version = version
      end

      def execute
        # check for existing package to avoid SQL errors due to the index
        package = ::Packages::Go::PackageFinder.new(version.mod.project, version.mod.name, version.name).execute
        return package if package

        # this can be expensive, so do it outside the transaction
        files = {}
        files[:mod] = prepare_file(version, :mod, version.gomod)
        files[:zip] = prepare_file(version, :zip, version.archive.string)

        ApplicationRecord.transaction do
          # create new package and files
          package = create_package
          files.each { |type, (file, digests)| create_file(package, type, file, digests) }
          package
        end
      end

      private

      def prepare_file(version, type, content)
        file = CarrierWaveStringFile.new(content)
        raise GoZipSizeError, ""#{version.mod.name}@#{version.name}.#{type} exceeds size limit"" if file.size > project.actual_limits.golang_max_file_size

        digests = {
          sha1: Digest::SHA1.hexdigest(content),
          sha256: Digest::SHA256.hexdigest(content)
        }

        digests[:md5] = Digest::MD5.hexdigest(content) unless Gitlab::FIPS.enabled?

        [file, digests]
      end

      def create_package
        version.mod.project.packages.create!(
          name: version.mod.name,
          version: version.name,
          package_type: :golang,
          created_at: version.commit.committed_date
        )
      end

      def create_file(package, type, file, digests)
        CreatePackageFileService.new(package,
          file: file,
          size: file.size,
          file_name: ""#{version.name}.#{type}"",
          file_md5: digests[:md5],
          file_sha1: digests[:sha1],
          file_sha256: digests[:sha256]
        ).execute
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Go::CreatePackageService, feature_category: :package_registry do
  let_it_be(:project) { create :project_empty_repo, path: 'my-go-lib' }
  let_it_be(:mod) { create :go_module, project: project }

  before_all do
    create :go_module_commit, :module, project: project, tag: 'v1.0.0'
  end

  shared_examples 'creates a package' do |files:|
    it ""returns a valid package with #{files ? files.to_s : 'no'} file(s)"" do
      expect(subject).to be_valid
      expect(subject.name).to eq(version.mod.name)
      expect(subject.version).to eq(version.name)
      expect(subject.package_type).to eq('golang')
      expect(subject.created_at).to eq(version.commit.committed_date)
      expect(subject.package_files.count).to eq(files)
    end
  end

  shared_examples 'creates a package file' do |type|
    it ""returns a package with a #{type} file"" do
      file_name = ""#{version.name}.#{type}""
      expect(subject.package_files.map { |f| f.file_name }).to include(file_name)

      file = subject.package_files.with_file_name(file_name).first
      expect(file).not_to be_nil
      expect(file.file).not_to be_nil
      expect(file.size).to eq(file.file.size)
      expect(file.file_name).to eq(file_name)
      expect(file.file_md5).not_to be_nil
      expect(file.file_sha1).not_to be_nil
      expect(file.file_sha256).not_to be_nil
    end

    context 'with FIPS mode', :fips_mode do
      it 'does not generate file_md5' do
        file_name = ""#{version.name}.#{type}""
        expect(subject.package_files.map { |f| f.file_name }).to include(file_name)

        file = subject.package_files.with_file_name(file_name).first
        expect(file).not_to be_nil
        expect(file.file).not_to be_nil
        expect(file.size).to eq(file.file.size)
        expect(file.file_name).to eq(file_name)
        expect(file.file_md5).to be_nil
        expect(file.file_sha1).not_to be_nil
        expect(file.file_sha256).not_to be_nil
      end
    end
  end

  describe '#execute' do
    subject { described_class.new(project, nil, version: version).execute }

    let(:version) { create :go_module_version, :tagged, mod: mod, name: 'v1.0.0' }

    context 'with no existing package' do
      it_behaves_like 'creates a package', files: 2
      it_behaves_like 'creates a package file', :mod
      it_behaves_like 'creates a package file', :zip

      it 'creates a new package' do
        expect { subject }
          .to change { project.packages.count }.by(1)
          .and change { Packages::PackageFile.count }.by(2)
      end
    end

    context 'with an existing package' do
      before do
        described_class.new(project, version: version).execute
      end

      it_behaves_like 'creates a package', files: 2
      it_behaves_like 'creates a package file', :mod
      it_behaves_like 'creates a package file', :zip

      it 'does not create a package or files' do
        expect { subject }
          .to not_change { project.packages.count }
          .and not_change { Packages::PackageFile.count }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Go
    class SyncPackagesService < BaseService
      include Gitlab::Golang

      def initialize(project, ref, path = '')
        super(project)

        @ref = ref
        @path = path

        raise ArgumentError, 'project is required' unless project
        raise ArgumentError, 'ref is required' unless ref
        raise ArgumentError, ""ref #{ref} not found"" unless project.repository.find_tag(ref) || project.repository.find_branch(ref)
      end

      def execute_async
        Packages::Go::SyncPackagesWorker.perform_async(project.id, @ref, @path)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Go::SyncPackagesService, feature_category: :package_registry do
  include_context 'basic Go module'

  let(:params) { { info: true, mod: true, zip: true } }

  describe '#execute_async' do
    it 'schedules a package refresh' do
      expect(::Packages::Go::SyncPackagesWorker).to receive(:perform_async).once

      described_class.new(project, 'master').execute_async
    end
  end

  describe '#initialize' do
    context 'without a project' do
      it 'raises an error' do
        expect { described_class.new(nil, 'master') }
          .to raise_error(ArgumentError, 'project is required')
      end
    end

    context 'without a ref' do
      it 'raises an error' do
        expect { described_class.new(project, nil) }
          .to raise_error(ArgumentError, 'ref is required')
      end
    end

    context 'with an invalid ref' do
      it 'raises an error' do
        expect { described_class.new(project, 'not-a-ref') }
        .to raise_error(ArgumentError)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Debian
    class GenerateDistributionKeyService
      include Gitlab::Utils::StrongMemoize

      def initialize(params: {})
        @params = params
      end

      def execute
        using_pinentry do |ctx|
          # Generate key
          ctx.generate_key generate_key_params

          key = ctx.keys.first # rubocop:disable Gitlab/KeysFirstAndValuesFirst
          fingerprint = key.fingerprint

          # Export private key
          data = GPGME::Data.new
          ctx.export_keys fingerprint, data, GPGME::EXPORT_MODE_SECRET
          data.seek 0
          private_key = data.read

          # Export public key
          data = GPGME::Data.new
          ctx.export_keys fingerprint, data
          data.seek 0
          public_key = data.read

          {
            private_key: private_key,
            public_key: public_key,
            passphrase: passphrase,
            fingerprint: fingerprint
          }
        end
      end

      private

      attr_reader :params

      def passphrase
        params[:passphrase] || ::User.random_password
      end
      strong_memoize_attr :passphrase

      def pinentry_script_content
        escaped_passphrase = Shellwords.escape(passphrase)

        <<~EOF
        #!/bin/sh

        echo OK Pleased to meet you

        while read -r cmd; do
          case ""$cmd"" in
            GETPIN) echo D #{escaped_passphrase}; echo OK;;
            *) echo OK;;
          esac
        done
        EOF
      end

      def using_pinentry
        Gitlab::Gpg.using_tmp_keychain do
          home_dir = Gitlab::Gpg.current_home_dir

          File.write(""#{home_dir}/pinentry.sh"", pinentry_script_content, mode: 'w', perm: 0755)

          File.write(""#{home_dir}/gpg-agent.conf"", ""pinentry-program #{home_dir}/pinentry.sh\n"", mode: 'w')

          GPGME::Ctx.new(armor: true, offline: true) do |ctx|
            yield ctx
          end
        end
      end

      def generate_key_params
        # https://www.gnupg.org/documentation/manuals/gnupg/Unattended-GPG-key-generation.html
        '<GnupgKeyParms format=""internal"">' + ""\n"" +
          {
            'Key-Type': params[:key_type] || 'RSA',
            'Key-Length': params[:key_length] || 4096,
            'Key-Usage': params[:key_usage] || 'sign',
            'Name-Real': params[:name_real] || 'GitLab Debian repository',
            'Name-Email': params[:name_email] || Gitlab.config.gitlab.email_reply_to,
            'Name-Comment': params[:name_comment] || 'GitLab Debian repository automatic signing key',
            'Expire-Date': params[:expire_date] || 0,
            Passphrase: passphrase
          }.map { |k, v| ""#{k}: #{v}\n"" }.join +
          '</GnupgKeyParms>'
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Debian::GenerateDistributionKeyService, feature_category: :package_registry do
  let(:params) { {} }

  subject { described_class.new(params: params) }

  let(:response) { subject.execute }

  it 'returns an Hash', :aggregate_failures do
    expect(GPGME::Ctx).to receive(:new).with(armor: true, offline: true).and_call_original
    expect(User).to receive(:random_password).with(no_args).and_call_original

    expect(response).to be_a Hash
    expect(response.keys).to contain_exactly(:private_key, :public_key, :fingerprint, :passphrase)
    expect(response[:private_key]).to start_with('-----BEGIN PGP PRIVATE KEY BLOCK-----')
    expect(response[:public_key]).to start_with('-----BEGIN PGP PUBLIC KEY BLOCK-----')
    expect(response[:fingerprint].length).to eq(40)
    expect(response[:passphrase].length).to be > 10
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Debian
    class UpdateDistributionService
      def initialize(distribution, params)
        @distribution = distribution
        @params = params

        @components = params.delete(:components)

        @architectures = params.delete(:architectures)
        @architectures += ['all'] unless @architectures.nil?

        @errors = []
      end

      def execute
        update_distribution
      end

      private

      attr_reader :distribution, :params, :components, :architectures, :errors

      def append_errors(record, prefix = '')
        return if record.valid?

        prefix = ""#{prefix} "" unless prefix.empty?
        @errors += record.errors.full_messages.map { |message| ""#{prefix}#{message}"" }
      end

      def update_distribution
        result = distribution.transaction do
          if distribution.update(params)
            update_components if components
            update_architectures if architectures

            success
          else
            append_errors(distribution)
            error
          end
        end

        result ||= error

        ::Packages::Debian::GenerateDistributionWorker.perform_async(distribution.class.container_type, distribution.id) if result.success?

        result
      end

      def update_components
        update_objects(distribution.components, components, error_label: 'Component')
      end

      def update_architectures
        update_objects(distribution.architectures, architectures, error_label: 'Architecture')
      end

      def update_objects(objects, object_names_from_params, error_label:)
        current_object_names = objects.map(&:name)
        missing_object_names = object_names_from_params - current_object_names
        extra_object_names = current_object_names - object_names_from_params

        missing_object_names.each do |name|
          new_object = objects.create(name: name)
          append_errors(new_object, error_label)
          raise ActiveRecord::Rollback unless new_object.persisted?
        end

        extra_object_names.each do |name|
          object = objects.with_name(name).first
          raise ActiveRecord::Rollback unless object.destroy
        end
      end

      def success
        ServiceResponse.success(payload: { distribution: distribution })
      end

      def error
        ServiceResponse.error(message: errors.to_sentence, payload: { distribution: distribution })
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Debian::UpdateDistributionService, feature_category: :package_registry do
  RSpec.shared_examples 'Update Debian Distribution' do |expected_message, expected_components, expected_architectures, component_file_delta = 0|
    it 'returns ServiceResponse', :aggregate_failures do
      expect(distribution).to receive(:update).with(simple_params).and_call_original if expected_message.nil?
      expect(::Packages::Debian::GenerateDistributionWorker).to receive(:perform_async).with(distribution.class.container_type, distribution.id).and_call_original if expected_message.nil?
      expect(::Packages::Debian::GenerateDistributionWorker).not_to receive(:perform_async) unless expected_message.nil?

      if component_file_delta.zero?
        expect { response }
          .to not_change { container.debian_distributions.klass.all.count }
          .and not_change { container.debian_distributions.count }
          .and not_change { component1.class.all.count }
          .and not_change { architecture1.class.all.count }
          .and not_change { component_file1.class.all.count }
      else
        expect { response }
          .to not_change { container.debian_distributions.klass.all.count }
          .and not_change { container.debian_distributions.count }
          .and not_change { component1.class.all.count }
          .and not_change { architecture1.class.all.count }
          .and change { component_file1.class.all.count }
          .from(4).to(4 + component_file_delta)
      end

      expect(response).to be_a(ServiceResponse)
      expect(response.success?).to eq(expected_message.nil?)
      expect(response.error?).to eq(!expected_message.nil?)
      expect(response.message).to eq(expected_message)

      expect(response.payload).to eq(distribution: distribution)

      distribution.reload
      distribution.components.reload
      distribution.architectures.reload

      if expected_message.nil?
        simple_params.each_pair do |name, value|
          expect(distribution.send(name)).to eq(value)
        end
      else
        original_params.each_pair do |name, value|
          expect(distribution.send(name)).to eq(value)
        end
      end

      expect(distribution.components.map(&:name)).to contain_exactly(*expected_components)
      expect(distribution.architectures.map(&:name)).to contain_exactly(*expected_architectures)
    end
  end

  RSpec.shared_examples 'Debian Update Distribution Service' do |container_type, can_freeze|
    context ""with a Debian #{container_type} distribution"" do
      let_it_be(:container, freeze: can_freeze) { create(container_type) } # rubocop:disable Rails/SaveBang
      let_it_be(:distribution, reload: true) { create(""debian_#{container_type}_distribution"", container: container) }
      let_it_be(:component1) { create(""debian_#{container_type}_component"", distribution: distribution, name: 'component1') }
      let_it_be(:component2) { create(""debian_#{container_type}_component"", distribution: distribution, name: 'component2') }
      let_it_be(:architecture0) { create(""debian_#{container_type}_architecture"", distribution: distribution, name: 'all') }
      let_it_be(:architecture1) { create(""debian_#{container_type}_architecture"", distribution: distribution, name: 'architecture1') }
      let_it_be(:architecture2) { create(""debian_#{container_type}_architecture"", distribution: distribution, name: 'architecture2') }
      let_it_be(:component_file1) { create(""debian_#{container_type}_component_file"", :sources, component: component1) }
      let_it_be(:component_file2) { create(""debian_#{container_type}_component_file"", component: component1, architecture: architecture1) }
      let_it_be(:component_file3) { create(""debian_#{container_type}_component_file"", :sources, component: component2) }
      let_it_be(:component_file4) { create(""debian_#{container_type}_component_file"", component: component2, architecture: architecture2) }

      let(:original_params) do
        {
          suite: nil,
          origin: nil,
          label: nil,
          version: nil,
          description: nil,
          valid_time_duration_seconds: nil,
          automatic: true,
          automatic_upgrades: false
        }
      end

      let(:params) { {} }
      let(:simple_params) { params.except(:components, :architectures) }

      subject { described_class.new(distribution, params) }

      let(:response) { subject.execute }

      context 'with valid simple params' do
        let(:params) do
          {
            suite: 'my-suite',
            origin: 'my-origin',
            label: 'my-label',
            version: '42.0',
            description: 'my-description',
            valid_time_duration_seconds: 7.days,
            automatic: false,
            automatic_upgrades: true
          }
        end

        it_behaves_like 'Update Debian Distribution', nil, %w[component1 component2], %w[all architecture1 architecture2]
      end

      context 'with invalid simple params' do
        let(:params) do
          {
            suite: 'suite erronée',
            origin: 'origin erronée',
            label: 'label erronée',
            version: 'version erronée',
            description: 'description erronée',
            valid_time_duration_seconds: 1.hour
          }
        end

        it_behaves_like 'Update Debian Distribution', 'Suite is invalid, Origin is invalid, Label is invalid, Version is invalid, and Valid time duration seconds must be greater than or equal to 86400', %w[component1 component2], %w[all architecture1 architecture2]
      end

      context 'with valid components and architectures' do
        let(:params) do
          {
            suite: 'my-suite',
            components: %w[component2 component3],
            architectures: %w[architecture2 architecture3]
          }
        end

        it_behaves_like 'Update Debian Distribution', nil, %w[component2 component3], %w[all architecture2 architecture3], -2
      end

      context 'with invalid components' do
        let(:params) do
          {
            suite: 'my-suite',
            components: %w[component2 erroné],
            architectures: %w[architecture2 architecture3]
          }
        end

        it_behaves_like 'Update Debian Distribution', 'Component Name is invalid', %w[component1 component2], %w[all architecture1 architecture2]
      end

      context 'with invalid architectures' do
        let(:params) do
          {
            suite: 'my-suite',
            components: %w[component2 component3],
            architectures: %w[architecture2 erroné]
          }
        end

        it_behaves_like 'Update Debian Distribution', 'Architecture Name is invalid', %w[component1 component2], %w[all architecture1 architecture2]
      end
    end
  end

  it_behaves_like 'Debian Update Distribution Service', :project, true
  it_behaves_like 'Debian Update Distribution Service', :group, false
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Debian
    class FindOrCreateIncomingService < ::Packages::CreatePackageService
      def execute
        find_or_create_package!(:debian, name: ::Packages::Debian::INCOMING_PACKAGE_NAME, version: nil)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Debian::FindOrCreateIncomingService, feature_category: :package_registry do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }

  subject(:service) { described_class.new(project, user) }

  describe '#execute' do
    subject(:package) { service.execute }

    context 'run once' do
      it 'creates a new package', :aggregate_failures do
        expect(package).to be_valid
        expect(package.project_id).to eq(project.id)
        expect(package.creator_id).to eq(user.id)
        expect(package.name).to eq('incoming')
        expect(package.version).to be_nil
        expect(package.package_type).to eq('debian')
        expect(package.debian_incoming?).to be_truthy
      end

      it_behaves_like 'assigns the package creator'
    end

    context 'run twice' do
      let!(:package2) { service.execute }

      it 'returns the same object' do
        expect(package2.id).to eq(package.id)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Debian
    # Returns .deb file metadata
    class ExtractDebMetadataService
      CommandFailedError = Class.new(StandardError)

      def initialize(file_path)
        @file_path = file_path
      end

      def execute
        unless success?
          raise CommandFailedError, ""The `#{cmd}` command failed (status: #{result.status}) with the following error:\n#{result.stderr}""
        end

        sections = ParseDebian822Service.new(result.stdout).execute

        sections.each_value.first
      end

      private

      def cmd
        @cmd ||= begin
          dpkg_deb_path = Gitlab.config.packages.dpkg_deb_path
          [dpkg_deb_path, '--field', @file_path]
        end
      end

      def result
        @result ||= Gitlab::Popen.popen_with_detail(cmd)
      end

      def success?
        result.status&.exitstatus == 0
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::Debian::ExtractDebMetadataService, feature_category: :package_registry do
  subject { described_class.new(file_path) }

  let(:file_name) { 'libsample0_1.2.3~alpha2_amd64.deb' }
  let(:file_path) { ""spec/fixtures/packages/debian/#{file_name}"" }

  context 'with correct file' do
    it 'return as expected' do
      expected = {
        'Package' => 'libsample0',
        'Source' => 'sample',
        'Version' => '1.2.3~alpha2',
        'Architecture' => 'amd64',
        'Maintainer' => 'John Doe <john.doe@example.com>',
        'Installed-Size' => '7',
        'Section' => 'libs',
        'Priority' => 'optional',
        'Multi-Arch' => 'same',
        'Homepage' => 'https://gitlab.com/',
        'Description' => ""Some mostly empty lib\nUsed in GitLab tests.\n\nTesting another paragraph.""
      }

      expect(subject.execute).to eq expected
    end
  end

  context 'with incorrect file' do
    let(:file_name) { 'README.md' }

    it 'raise error' do
      expect { subject.execute }.to raise_error(described_class::CommandFailedError, /is not a Debian format archive/i)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Debian
    class CreatePackageFileService
      def initialize(package:, current_user:, params: {})
        @package = package
        @current_user = current_user
        @params = params
      end

      def execute
        raise ArgumentError, ""Invalid package"" unless package.present?
        raise ArgumentError, ""Invalid user"" unless current_user.present?

        # Debian package file are first uploaded to incoming with empty metadata,
        # and are moved later by Packages::Debian::ProcessPackageFileService
        package_file = package.package_files.create!(
          file: params[:file],
          size: params[:file]&.size,
          file_name: params[:file_name],
          file_sha1: params[:file_sha1],
          file_sha256: params[:file]&.sha256,
          file_md5: params[:file_md5],
          debian_file_metadatum_attributes: {
            file_type: 'unknown',
            architecture: nil,
            fields: nil
          }
        )

        if end_of_new_upload?
          ::Packages::Debian::ProcessPackageFileWorker.perform_async(
            package_file.id,
            params[:distribution],
            params[:component]
          )
        end

        package_file
      end

      private

      attr_reader :package, :current_user, :params

      def end_of_new_upload?
        params[:distribution].present? || params[:file_name].end_with?('.changes')
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Debian::CreatePackageFileService, feature_category: :package_registry do
  include WorkhorseHelpers

  let_it_be(:package) { create(:debian_incoming, without_package_files: true) }
  let_it_be(:current_user) { create(:user) }

  describe '#execute' do
    let(:file_name) { 'libsample0_1.2.3~alpha2_amd64.deb' }
    let(:fixture_path) { ""spec/fixtures/packages/debian/#{file_name}"" }
    let(:params) { default_params }

    let(:default_params) do
      {
        file: file,
        file_name: file_name,
        file_sha1: '54321',
        file_md5: '12345'
      }.with_indifferent_access
    end

    let(:service) { described_class.new(package: package, current_user: current_user, params: params) }

    subject(:package_file) { service.execute }

    shared_examples 'a valid deb' do |process_package_file_worker|
      it 'creates a new package file', :aggregate_failures do
        if process_package_file_worker
          expect(::Packages::Debian::ProcessPackageFileWorker)
            .to receive(:perform_async).with(an_instance_of(Integer), params[:distribution], params[:component])
        else
          expect(::Packages::Debian::ProcessPackageFileWorker).not_to receive(:perform_async)
        end

        expect(package_file).to be_valid
        expect(package_file.file.read).to start_with('!<arch>')
        expect(package_file.size).to eq(1124)
        expect(package_file.file_name).to eq(file_name)
        expect(package_file.file_sha1).to eq('54321')
        expect(package_file.file_sha256).to eq('543212345')
        expect(package_file.file_md5).to eq('12345')
        expect(package_file.debian_file_metadatum).to be_valid
        expect(package_file.debian_file_metadatum.file_type).to eq('unknown')
        expect(package_file.debian_file_metadatum.architecture).to be_nil
        expect(package_file.debian_file_metadatum.fields).to be_nil
      end
    end

    shared_examples 'a valid changes' do
      it 'creates a new package file', :aggregate_failures do
        expect(::Packages::Debian::ProcessPackageFileWorker)
        .to receive(:perform_async).with(an_instance_of(Integer), nil, nil)

        expect(package_file).to be_valid
        expect(package_file.file.read).to start_with('Format: 1.8')
        expect(package_file.size).to eq(2422)
        expect(package_file.file_name).to eq(file_name)
        expect(package_file.file_sha1).to eq('54321')
        expect(package_file.file_sha256).to eq('543212345')
        expect(package_file.file_md5).to eq('12345')
        expect(package_file.debian_file_metadatum).to be_valid
        expect(package_file.debian_file_metadatum.file_type).to eq('unknown')
        expect(package_file.debian_file_metadatum.architecture).to be_nil
        expect(package_file.debian_file_metadatum.fields).to be_nil
      end
    end

    context 'with temp file' do
      let!(:file) do
        upload_path = ::Packages::PackageFileUploader.workhorse_local_upload_path
        file_path = upload_path + '/' + file_name

        FileUtils.mkdir_p(upload_path)
        File.write(file_path, File.read(fixture_path))

        UploadedFile.new(file_path, filename: File.basename(file_path), sha256: '543212345')
      end

      it_behaves_like 'a valid deb'

      context 'with a .changes file' do
        let(:file_name) { 'sample_1.2.3~alpha2_amd64.changes' }
        let(:fixture_path) { ""spec/fixtures/packages/debian/#{file_name}"" }

        it_behaves_like 'a valid changes'
      end

      context 'with distribution' do
        let(:params) { default_params.merge(distribution: 'unstable', component: 'main') }

        it_behaves_like 'a valid deb', true
      end

      context 'when current_user is missing' do
        let(:current_user) { nil }

        it 'raises an error' do
          expect { package_file }.to raise_error(ArgumentError, 'Invalid user')
        end
      end
    end

    context 'with remote file' do
      let!(:fog_connection) do
        stub_package_file_object_storage(direct_upload: true)
      end

      before do
        allow_next_instance_of(UploadedFile) do |uploaded_file|
          allow(uploaded_file).to receive(:sha256).and_return('543212345')
        end
      end

      let(:tmp_object) do
        fog_connection.directories.new(key: 'packages').files.create( # rubocop:disable Rails/SaveBang
          key: ""tmp/uploads/#{file_name}"",
          body: File.read(fixture_path)
        )
      end

      let!(:file) { fog_to_uploaded_file(tmp_object) }

      it_behaves_like 'a valid deb'
    end

    context 'when package is missing' do
      let(:package) { nil }
      let(:params) { {} }

      it 'raises an error' do
        expect { package_file }.to raise_error(ArgumentError, 'Invalid package')
      end
    end

    context 'when params is empty' do
      let(:params) { {} }

      it 'raises an error' do
        expect { package_file }.to raise_error(ActiveRecord::RecordInvalid)
      end
    end

    context 'when file is missing' do
      let(:file_name) { 'libsample0_1.2.3~alpha2_amd64.deb' }
      let(:file) { nil }

      it 'raises an error' do
        expect { package_file }.to raise_error(ActiveRecord::RecordInvalid)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Debian
    class CreateDistributionService
      def initialize(container, user, params)
        @container = container
        @params = params
        @params[:creator] = user

        @components = params.delete(:components) || ['main']

        @architectures = params.delete(:architectures) || ['amd64']
        @architectures += ['all']

        @distribution = nil
        @errors = []
      end

      def execute
        create_distribution
      end

      private

      attr_reader :container, :params, :components, :architectures, :distribution, :errors

      def append_errors(record, prefix = '')
        return if record.valid?

        prefix = ""#{prefix} "" unless prefix.empty?
        @errors += record.errors.full_messages.map { |message| ""#{prefix}#{message}"" }
      end

      def create_distribution
        @distribution = container.debian_distributions.new(params)

        append_errors(distribution)
        return error unless errors.empty?

        result = distribution.transaction do
          next unless distribution.save

          create_components
          create_architectures
          success
        end

        result ||= error

        ::Packages::Debian::GenerateDistributionWorker.perform_async(distribution.class.container_type, distribution.reset.id) if result.success?

        result
      end

      def create_components
        create_objects(distribution.components, components, error_label: 'Component')
      end

      def create_architectures
        create_objects(distribution.architectures, architectures, error_label: 'Architecture')
      end

      def create_objects(objects, object_names_from_params, error_label:)
        object_names_from_params.each do |name|
          new_object = objects.create(name: name)
          append_errors(new_object, error_label)
          raise ActiveRecord::Rollback unless new_object.persisted?
        end
      end

      def success
        ServiceResponse.success(payload: { distribution: distribution }, http_status: :created)
      end

      def error
        ServiceResponse.error(message: errors.to_sentence, payload: { distribution: distribution })
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Debian::CreateDistributionService, feature_category: :package_registry do
  RSpec.shared_examples 'Create Debian Distribution' do |expected_message, expected_components, expected_architectures|
    let_it_be(:container) { create(container_type) } # rubocop:disable Rails/SaveBang

    it 'returns ServiceResponse', :aggregate_failures do
      if expected_message.nil?
        expect(::Packages::Debian::GenerateDistributionWorker).to receive(:perform_async).with(container_type, an_instance_of(Integer))

        expect { response }
          .to change { container.debian_distributions.klass.all.count }
          .from(0).to(1)
          .and change { container.debian_distributions.count }
          .from(0).to(1)
          .and change { container.debian_distributions.first&.components&.count }
          .from(nil).to(expected_components.count)
          .and change { container.debian_distributions.first&.architectures&.count }
          .from(nil).to(expected_architectures.count)
          .and not_change { Packages::Debian::ProjectComponentFile.count }
          .and not_change { Packages::Debian::GroupComponentFile.count }
      else
        expect(::Packages::Debian::GenerateDistributionWorker).not_to receive(:perform_async)
        expect { response }
          .to not_change { container.debian_distributions.klass.all.count }
          .and not_change { container.debian_distributions.count }
          .and not_change { Packages::Debian::ProjectComponent.count }
          .and not_change { Packages::Debian::GroupComponent.count }
          .and not_change { Packages::Debian::ProjectArchitecture.count }
          .and not_change { Packages::Debian::GroupArchitecture.count }
          .and not_change { Packages::Debian::ProjectComponentFile.count }
          .and not_change { Packages::Debian::GroupComponentFile.count }
      end

      expect(response).to be_a(ServiceResponse)
      expect(response.success?).to eq(expected_message.nil?)
      expect(response.error?).to eq(!expected_message.nil?)
      expect(response.message).to eq(expected_message)

      distribution = response.payload[:distribution]
      expect(distribution.persisted?).to eq(expected_message.nil?)
      expect(distribution.container).to eq(container)
      expect(distribution.creator).to eq(user)
      params.each_pair do |name, value|
        expect(distribution.send(name)).to eq(value)
      end

      expect(distribution.components.map(&:name)).to contain_exactly(*expected_components)
      expect(distribution.architectures.map(&:name)).to contain_exactly(*expected_architectures)
    end
  end

  shared_examples 'Debian Create Distribution Service' do
    context 'with only the codename param' do
      let(:params) { { codename: 'my-codename' } }

      it_behaves_like 'Create Debian Distribution', nil, %w[main], %w[all amd64]
    end

    context 'with codename, components and architectures' do
      let(:params) do
        {
          codename: 'my-codename',
          components: %w[contrib non-free],
          architectures: %w[arm64]
        }
      end

      it_behaves_like 'Create Debian Distribution', nil, %w[contrib non-free], %w[all arm64]
    end

    context 'with invalid suite' do
      let(:params) do
        {
          codename: 'my-codename',
          suite: 'erroné'
        }
      end

      it_behaves_like 'Create Debian Distribution', 'Suite is invalid', %w[], %w[]
    end

    context 'with invalid component name' do
      let(:params) do
        {
          codename: 'my-codename',
          components: %w[before erroné after],
          architectures: %w[arm64]
        }
      end

      it_behaves_like 'Create Debian Distribution', 'Component Name is invalid', %w[before erroné], %w[]
    end

    context 'with invalid architecture name' do
      let(:params) do
        {
          codename: 'my-codename',
          components: %w[contrib non-free],
          architectures: %w[before erroné after']
        }
      end

      it_behaves_like 'Create Debian Distribution', 'Architecture Name is invalid', %w[contrib non-free], %w[before erroné]
    end
  end

  let_it_be(:user) { create(:user) }

  subject { described_class.new(container, user, params) }

  let(:response) { subject.execute }

  context 'within a projet' do
    let_it_be(:container_type) { :project }

    it_behaves_like 'Debian Create Distribution Service'
  end

  context 'within a group' do
    let_it_be(:container_type) { :group }

    it_behaves_like 'Debian Create Distribution Service'
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Debian
    class ExtractChangesMetadataService
      include Gitlab::Utils::StrongMemoize

      ExtractionError = Class.new(StandardError)

      def initialize(package_file)
        @package_file = package_file
        @entries = {}
      end

      def execute
        {
          file_type: file_type,
          architecture: metadata[:architecture],
          fields: fields,
          files: files
        }
      rescue ActiveModel::ValidationError => e
        raise ExtractionError, e.message
      end

      private

      def metadata
        ::Packages::Debian::ExtractMetadataService.new(@package_file).execute
      end
      strong_memoize_attr :metadata

      def file_type
        metadata[:file_type]
      end

      def fields
        metadata[:fields]
      end

      def files
        raise ExtractionError, ""is not a changes file"" unless file_type == :changes
        raise ExtractionError, ""Files field is missing"" if fields['Files'].blank?
        raise ExtractionError, ""Checksums-Sha1 field is missing"" if fields['Checksums-Sha1'].blank?
        raise ExtractionError, ""Checksums-Sha256 field is missing"" if fields['Checksums-Sha256'].blank?

        init_entries_from_files
        entries_from_checksums_sha1
        entries_from_checksums_sha256
        entries_from_package_files

        @entries
      end
      strong_memoize_attr :files

      def init_entries_from_files
        each_lines_for('Files') do |line|
          md5sum, size, section, priority, filename = line.split
          entry = FileEntry.new(
            filename: filename,
            size: size.to_i,
            md5sum: md5sum,
            section: section,
            priority: priority)

          @entries[filename] = entry
        end
      end

      def entries_from_checksums_sha1
        each_lines_for('Checksums-Sha1') do |line|
          sha1sum, size, filename = line.split
          entry = @entries[filename]
          raise ExtractionError, ""#{filename} is listed in Checksums-Sha1 but not in Files"" unless entry
          raise ExtractionError, ""Size for #{filename} in Files and Checksums-Sha1 differ"" unless entry.size == size.to_i

          entry.sha1sum = sha1sum
        end
      end

      def entries_from_checksums_sha256
        each_lines_for('Checksums-Sha256') do |line|
          sha256sum, size, filename = line.split
          entry = @entries[filename]
          raise ExtractionError, ""#{filename} is listed in Checksums-Sha256 but not in Files"" unless entry
          raise ExtractionError, ""Size for #{filename} in Files and Checksums-Sha256 differ"" unless entry.size == size.to_i

          entry.sha256sum = sha256sum
        end
      end

      def each_lines_for(field)
        fields[field].split(""\n"").each do |line|
          next if line.blank?

          yield(line)
        end
      end

      def entries_from_package_files
        @entries.each do |filename, entry|
          entry.package_file = ::Packages::PackageFileFinder.new(incoming, filename).execute!
          entry.validate!
        rescue ActiveRecord::RecordNotFound
          raise ExtractionError, ""#{filename} is listed in Files but was not uploaded""
        end
      end

      def incoming
        @package_file.package.project.packages.debian_incoming_package!
      end
      strong_memoize_attr(:incoming)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Debian::ExtractChangesMetadataService, feature_category: :package_registry do
  describe '#execute' do
    let_it_be(:incoming) { create(:debian_incoming) }
    let_it_be(:temp_package) do
      create(:debian_package, without_package_files: true, with_changes_file: true, project: incoming.project)
    end

    let(:source_file) { incoming.package_files.first }
    let(:dsc_file) { incoming.package_files.second }
    let(:changes_file) { temp_package.package_files.first }
    let(:service) { described_class.new(changes_file) }

    subject { service.execute }

    context 'with valid package file' do
      it 'extract metadata', :aggregate_failures do
        expected_fields = { 'Architecture' => 'source amd64', 'Binary' => 'libsample0 sample-dev sample-udeb' }

        expect(subject[:file_type]).to eq(:changes)
        expect(subject[:architecture]).to be_nil
        expect(subject[:fields]).to include(expected_fields)
        expect(subject[:files].count).to eq(7)
      end
    end

    context 'with invalid package file' do
      let(:changes_file) { incoming.package_files.first }

      it 'raise ArgumentError', :aggregate_failures do
        expect { subject }.to raise_error(described_class::ExtractionError, ""is not a changes file"")
      end
    end

    context 'with invalid metadata' do
      let(:md5_dsc) { ""#{dsc_file.file_md5} 671 libs optional sample_1.2.3~alpha2.dsc"" }
      let(:md5_source) { ""#{source_file.file_md5} 864 libs optional sample_1.2.3~alpha2.tar.xz"" }
      let(:md5s) { ""#{md5_dsc}\n#{md5_source}"" }
      let(:sha1_dsc) { ""#{dsc_file.file_sha1} 671 sample_1.2.3~alpha2.dsc"" }
      let(:sha1_source) { ""#{source_file.file_sha1} 864 sample_1.2.3~alpha2.tar.xz"" }
      let(:sha1s) { ""#{sha1_dsc}\n#{sha1_source}"" }
      let(:sha256_dsc) { ""#{dsc_file.file_sha256} 671 sample_1.2.3~alpha2.dsc"" }
      let(:sha256_source) { ""#{source_file.file_sha256} 864 sample_1.2.3~alpha2.tar.xz"" }
      let(:sha256s) { ""#{sha256_dsc}\n#{sha256_source}"" }
      let(:fields) { { 'Files' => md5s, 'Checksums-Sha1' => sha1s, 'Checksums-Sha256' => sha256s } }
      let(:metadata) { { file_type: :changes, architecture: 'amd64', fields: fields } }

      before do
        allow_next_instance_of(::Packages::Debian::ExtractMetadataService) do |extract_metadata_service|
          allow(extract_metadata_service).to receive(:execute).and_return(metadata)
        end
      end

      context 'without Files field' do
        let(:md5s) { nil }

        it 'raise ArgumentError', :aggregate_failures do
          expect { subject }.to raise_error(described_class::ExtractionError, ""Files field is missing"")
        end
      end

      context 'without Checksums-Sha1 field' do
        let(:sha1s) { nil }

        it 'raise ArgumentError', :aggregate_failures do
          expect { subject }.to raise_error(described_class::ExtractionError, ""Checksums-Sha1 field is missing"")
        end
      end

      context 'without Checksums-Sha256 field' do
        let(:sha256s) { nil }

        it 'raise ArgumentError', :aggregate_failures do
          expect { subject }.to raise_error(described_class::ExtractionError, ""Checksums-Sha256 field is missing"")
        end
      end

      context 'with file in Checksums-Sha1 but not in Files' do
        let(:md5_dsc) { '' }

        it 'raise ArgumentError', :aggregate_failures do
          expect { subject }.to raise_error(described_class::ExtractionError, ""sample_1.2.3~alpha2.dsc is listed in Checksums-Sha1 but not in Files"")
        end
      end

      context 'with different size in Checksums-Sha1' do
        let(:sha1_dsc) { ""#{dsc_file.file_sha1} 42 sample_1.2.3~alpha2.dsc"" }

        it 'raise ArgumentError', :aggregate_failures do
          expect { subject }.to raise_error(described_class::ExtractionError, ""Size for sample_1.2.3~alpha2.dsc in Files and Checksums-Sha1 differ"")
        end
      end

      context 'with file in Checksums-Sha256 but not in Files' do
        let(:md5_dsc) { '' }
        let(:sha1_dsc) { '' }

        it 'raise ArgumentError', :aggregate_failures do
          expect { subject }.to raise_error(described_class::ExtractionError, ""sample_1.2.3~alpha2.dsc is listed in Checksums-Sha256 but not in Files"")
        end
      end

      context 'with different size in Checksums-Sha256' do
        let(:sha256_dsc) { ""#{dsc_file.file_sha256} 42 sample_1.2.3~alpha2.dsc"" }

        it 'raise ArgumentError', :aggregate_failures do
          expect { subject }.to raise_error(described_class::ExtractionError, ""Size for sample_1.2.3~alpha2.dsc in Files and Checksums-Sha256 differ"")
        end
      end

      context 'with file in Files but not in Checksums-Sha1' do
        let(:sha1_dsc) { '' }

        it 'raise ArgumentError', :aggregate_failures do
          expect { subject }.to raise_error(described_class::ExtractionError, ""Validation failed: Sha1sum can't be blank"")
        end
      end

      context 'with file in Files but not in Checksums-Sha256' do
        let(:sha256_dsc) { '' }

        it 'raise ArgumentError', :aggregate_failures do
          expect { subject }.to raise_error(described_class::ExtractionError, ""Validation failed: Sha256sum can't be blank"")
        end
      end

      context 'with invalid MD5' do
        let(:md5_dsc) { '1234567890123456789012345678012 671 libs optional sample_1.2.3~alpha2.dsc' }

        it 'raise ArgumentError', :aggregate_failures do
          expect { subject }.to raise_error(described_class::ExtractionError, ""Validation failed: Md5sum mismatch for sample_1.2.3~alpha2.dsc: #{dsc_file.file_md5} != 1234567890123456789012345678012"")
        end
      end

      context 'with invalid SHA1' do
        let(:sha1_dsc) { '1234567890123456789012345678901234567890 671 sample_1.2.3~alpha2.dsc' }

        it 'raise ArgumentError', :aggregate_failures do
          expect { subject }.to raise_error(described_class::ExtractionError, ""Validation failed: Sha1sum mismatch for sample_1.2.3~alpha2.dsc: #{dsc_file.file_sha1} != 1234567890123456789012345678901234567890"")
        end
      end

      context 'with invalid SHA256' do
        let(:sha256_dsc) { '1234567890123456789012345678901234567890123456789012345678901234 671 sample_1.2.3~alpha2.dsc' }

        it 'raise ArgumentError', :aggregate_failures do
          expect { subject }.to raise_error(described_class::ExtractionError, ""Validation failed: Sha256sum mismatch for sample_1.2.3~alpha2.dsc: #{dsc_file.file_sha256} != 1234567890123456789012345678901234567890123456789012345678901234"")
        end
      end
    end

    context 'with missing package file' do
      before do
        incoming.package_files.first.destroy!
      end

      it 'raise ArgumentError' do
        expect { subject }.to raise_error(described_class::ExtractionError, ""sample_1.2.3~alpha2.tar.xz is listed in Files but was not uploaded"")
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Debian
    class ExtractMetadataService
      include Gitlab::Utils::StrongMemoize

      ExtractionError = Class.new(StandardError)

      def initialize(package_file)
        @package_file = package_file
      end

      def execute
        raise ExtractionError, 'invalid package file' unless valid_package_file?

        if file_type == :unsupported
          raise ExtractionError, ""unsupported file extension for file #{package_file.file_name}""
        end

        extract_metadata
      end

      private

      attr_reader :package_file

      def valid_package_file?
        package_file && package_file.package&.debian? && !package_file.file.empty_size?
      end

      def file_type_basic
        %i[dsc deb udeb buildinfo changes ddeb].each do |format|
          return format if package_file.file_name.end_with?("".#{format}"")
        end

        nil
      end

      def file_type_source
        # https://manpages.debian.org/buster/dpkg-dev/dpkg-source.1.en.html#Format:_3.0_(quilt)
        %i[gz bz2 lzma xz].each do |format|
          return :source if package_file.file_name.end_with?("".tar.#{format}"")
        end

        nil
      end

      def file_type
        file_type_basic || file_type_source || :unsupported
      end
      strong_memoize_attr :file_type

      def file_type_debian?
        file_type == :deb || file_type == :udeb || file_type == :ddeb
      end

      def file_type_meta?
        file_type == :dsc || file_type == :buildinfo || file_type == :changes
      end

      def fields
        if file_type_debian?
          package_file.file.use_open_file(unlink_early: false) do |file|
            ::Packages::Debian::ExtractDebMetadataService.new(file.file_path).execute
          end
        elsif file_type_meta?
          package_file.file.use_open_file do |file|
            ::Packages::Debian::ParseDebian822Service.new(file.read).execute.each_value.first
          end
        end
      end
      strong_memoize_attr :fields

      def extract_metadata
        architecture = fields['Architecture'] if file_type_debian?

        {
          file_type: file_type,
          architecture: architecture,
          fields: fields
        }
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Debian::ExtractMetadataService, feature_category: :package_registry do
  let(:service) { described_class.new(package_file) }

  subject { service.execute }

  RSpec.shared_context 'with Debian package file' do |trait|
    let(:package_file) { create(:debian_package_file, trait) }
  end

  RSpec.shared_examples 'Test Debian ExtractMetadata Service' do |expected_file_type, expected_architecture, expected_fields|
    it ""returns file_type #{expected_file_type.inspect}, architecture #{expected_architecture.inspect} and fields #{expected_fields.nil? ? '' : 'including '}#{expected_fields.inspect}"",
      :aggregate_failures do
      expect(subject[:file_type]).to eq(expected_file_type)
      expect(subject[:architecture]).to eq(expected_architecture)

      if expected_fields.nil?
        expect(subject[:fields]).to be_nil
      else
        expect(subject[:fields]).to include(**expected_fields)
      end
    end
  end

  using RSpec::Parameterized::TableSyntax

  context 'with valid file types' do
    where(:case_name, :trait, :expected_file_type, :expected_architecture, :expected_fields) do
      'with source'     | :source    | :source    | nil     | nil
      'with dsc'        | :dsc       | :dsc       | nil     | { 'Binary' => 'sample-dev, libsample0, sample-udeb, sample-ddeb' }
      'with deb'        | :deb       | :deb       | 'amd64' | { 'Multi-Arch' => 'same' }
      'with udeb'       | :udeb      | :udeb      | 'amd64' | { 'Package' => 'sample-udeb' }
      'with ddeb'       | :ddeb      | :ddeb      | 'amd64' | { 'Package' => 'sample-ddeb' }
      'with buildinfo'  | :buildinfo | :buildinfo | nil     | { 'Architecture' => 'amd64 source',
                                                                'Build-Architecture' => 'amd64' }
      'with changes'    | :changes   | :changes   | nil     | { 'Architecture' => 'source amd64',
                                                                'Binary' => 'libsample0 sample-dev sample-udeb' }
    end

    with_them do
      include_context 'with Debian package file', params[:trait] do
        it_behaves_like 'Test Debian ExtractMetadata Service',
          params[:expected_file_type],
          params[:expected_architecture],
          params[:expected_fields]
      end
    end
  end

  context 'with valid source extensions' do
    where(:ext) do
      %i[gz bz2 lzma xz]
    end

    with_them do
      let(:package_file) do
        create(:debian_package_file, :source, file_name: ""myfile.tar.#{ext}"",
          file_fixture: 'spec/fixtures/packages/debian/sample_1.2.3~alpha2.tar.xz')
      end

      it_behaves_like 'Test Debian ExtractMetadata Service', :source
    end
  end

  context 'with invalid source extensions' do
    where(:ext) do
      %i[gzip bzip2]
    end

    with_them do
      let(:package_file) do
        create(:debian_package_file, :source, file_name: ""myfile.tar.#{ext}"",
          file_fixture: 'spec/fixtures/packages/debian/sample_1.2.3~alpha2.tar.xz')
      end

      it 'raises an error' do
        expect do
          subject
        end.to raise_error(described_class::ExtractionError,
          ""unsupported file extension for file #{package_file.file_name}"")
      end
    end
  end

  context 'with invalid file name' do
    let(:package_file) { create(:debian_package_file, :invalid) }

    it 'raises an error' do
      expect do
        subject
      end.to raise_error(described_class::ExtractionError,
        ""unsupported file extension for file #{package_file.file_name}"")
    end
  end

  context 'with invalid package file' do
    let(:package_file) { create(:conan_package_file) }

    it 'raises an error' do
      expect { subject }.to raise_error(described_class::ExtractionError, 'invalid package file')
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Debian
    class GenerateDistributionService
      include Gitlab::Utils::StrongMemoize
      include ExclusiveLeaseGuard

      ONE_HOUR = 1.hour.freeze

      # used by ExclusiveLeaseGuard
      DEFAULT_LEASE_TIMEOUT = 1.hour.to_i.freeze

      # From https://salsa.debian.org/ftp-team/dak/-/blob/991aaa27a7f7aa773bb9c0cf2d516e383d9cffa0/setup/core-init.d/080_metadatakeys#L9
      METADATA_KEYS = %w[
        Package
        Source
        Binary
        Version
        Essential
        Installed-Size
        Maintainer
        Uploaders
        Original-Maintainer
        Build-Depends
        Build-Depends-Indep
        Build-Conflicts
        Build-Conflicts-Indep
        Architecture
        Standards-Version
        Format
        Files
        Dm-Upload-Allowed
        Vcs-Browse
        Vcs-Hg
        Vcs-Darcs
        Vcs-Svn
        Vcs-Git
        Vcs-Browser
        Vcs-Arch
        Vcs-Bzr
        Vcs-Mtn
        Vcs-Cvs
        Checksums-Sha256
        Checksums-Sha1
        Replaces
        Provides
        Depends
        Pre-Depends
        Recommends
        Suggests
        Enhances
        Conflicts
        Breaks
        Description
        Origin
        Bugs
        Multi-Arch
        Homepage
        Tag
        Package-Type
        Installer-Menu-Item
      ].freeze

      def initialize(distribution)
        @distribution = distribution
        @oldest_kept_generated_at = nil
        @sha256 = []
      end

      def execute
        try_obtain_lease do
          @distribution.transaction do
            # We consider `apt-get update` can take at most one hour
            # We keep all generations younger than one hour
            # and the previous generation
            @oldest_kept_generated_at = @distribution.component_files.updated_before(release_date - ONE_HOUR).maximum(:updated_at)
            generate_component_files
            generate_release
            destroy_old_component_files
          end
        end
      end

      private

      def generate_component_files
        @distribution.components.ordered_by_name.each do |component|
          @distribution.architectures.ordered_by_name.each do |architecture|
            generate_component_file(component, :packages, architecture, :deb)
            generate_component_file(component, :di_packages, architecture, :udeb)
          end
          generate_component_file(component, :sources, nil, :dsc)
        end
      end

      def generate_component_file(component, component_file_type, architecture, package_file_type)
        paragraphs = @distribution.package_files
                                  .preload_package
                                  .preload_debian_file_metadata
                                  .with_debian_component_name(component.name)
                                  .with_debian_architecture_name(architecture&.name)
                                  .with_debian_file_type(package_file_type)
                                  .find_each
                                  .map { |package_file| package_stanza_from_fields(package_file) }
        reuse_or_create_component_file(component, component_file_type, architecture, paragraphs.join(""\n""))
      end

      def package_stanza_from_fields(package_file)
        [
          METADATA_KEYS.map do |metadata_key|
            metadata_name = metadata_key
            metadata_value = package_file.debian_fields[metadata_key]

            if package_file.debian_dsc?
              metadata_name = 'Package' if metadata_key == 'Source'
              checksum = case metadata_key
                         when 'Files' then package_file.file_md5
                         when 'Checksums-Sha256' then package_file.file_sha256
                         when 'Checksums-Sha1' then package_file.file_sha1
                         end

              if checksum
                metadata_value = ""\n#{checksum} #{package_file.size} #{package_file.file_name}#{metadata_value}""
              end
            end

            rfc822_field(metadata_name, metadata_value)
          end,
          rfc822_field('Section', package_file.debian_fields['Section'] || 'misc'),
          rfc822_field('Priority', package_file.debian_fields['Priority'] || 'extra'),
          package_file_extra_fields(package_file)
        ].flatten.compact.join('')
      end

      def package_file_extra_fields(package_file)
        if package_file.debian_dsc?
          [
            rfc822_field('Directory', package_dirname(package_file))
          ]
        else
          # NB: MD5sum was removed for FIPS compliance
          [
            rfc822_field('Filename', ""#{package_dirname(package_file)}/#{package_file.file_name}""),
            rfc822_field('Size', package_file.size),
            rfc822_field('SHA256', package_file.file_sha256)
          ]
        end
      end

      def package_dirname(package_file)
        letter = package_file.package.name.start_with?('lib') ? package_file.package.name[0..3] : package_file.package.name[0]
        ""#{pool_prefix(package_file)}/#{letter}/#{package_file.package.name}/#{package_file.package.version}""
      end

      def pool_prefix(package_file)
        case @distribution
        when ::Packages::Debian::GroupDistribution
          ""pool/#{@distribution.codename}/#{package_file.package.project_id}""
        else
          ""pool/#{@distribution.codename}""
        end
      end

      def reuse_or_create_component_file(component, component_file_type, architecture, content)
        file_sha256 = Digest::SHA256.hexdigest(content)
        component_files = component.files
                                   .with_file_type(component_file_type)
                                   .with_architecture(architecture)
                                   .with_compression_type(nil)
                                   .order_updated_asc
        component_file = component_files.with_file_sha256(file_sha256).last
        last_component_file = component_files.last

        if content.empty? && (!last_component_file || last_component_file.file_sha256 == file_sha256)
          # Do not create empty component file for empty content
          # when there is no last component file or when the last component file is empty too
          component_file = last_component_file || component.files.build(
            updated_at: release_date,
            file_type: component_file_type,
            architecture: architecture,
            compression_type: nil,
            size: 0
          )
        elsif component_file
          # Reuse existing component file
          component_file.touch(time: release_date)
        else
          # Create a new component file
          component_file = component.files.create!(
            updated_at: release_date,
            file_type: component_file_type,
            architecture: architecture,
            compression_type: nil,
            file: CarrierWaveStringFile.new(content),
            file_sha256: file_sha256,
            size: content.bytesize
          )
        end

        @sha256.append("" #{file_sha256} #{component_file.size.to_s.rjust(8)} #{component_file.relative_path}"")
      end

      def generate_release
        @distribution.key || @distribution.create_key(GenerateDistributionKeyService.new.execute)
        @distribution.file = CarrierWaveStringFile.new(release_content)
        @distribution.file_signature = SignDistributionService.new(@distribution, release_content, detach: true).execute
        @distribution.signed_file = CarrierWaveStringFile.new(
          SignDistributionService.new(@distribution, release_content).execute
        )
        @distribution.updated_at = release_date
        @distribution.save!
      end

      def release_content
        release_header + release_sums
      end
      strong_memoize_attr :release_content

      def release_header
        [
          %w[origin label suite version codename].map do |attribute|
            rfc822_field(attribute.capitalize, @distribution.attributes[attribute])
          end,
          rfc822_field('Date', release_date.to_formatted_s(:rfc822)),
          valid_until_field,
          rfc822_field('NotAutomatic', !@distribution.automatic, !@distribution.automatic),
          rfc822_field('ButAutomaticUpgrades', @distribution.automatic_upgrades, !@distribution.automatic && @distribution.automatic_upgrades),
          rfc822_field('Acquire-By-Hash', 'yes'),
          rfc822_field('Architectures', @distribution.architectures.map { |architecture| architecture.name }.sort.join(' ')),
          rfc822_field('Components', @distribution.components.map { |component| component.name }.sort.join(' ')),
          rfc822_field('Description', @distribution.description)
        ].flatten.compact.join('')
      end

      def release_date
        Time.now.utc
      end
      strong_memoize_attr :release_date

      def release_sums
        # NB: MD5Sum was removed for FIPS compliance
        [""SHA256:"", @sha256].flatten.compact.join(""\n"") + ""\n""
      end

      def rfc822_field(name, value, condition = true)
        return unless condition
        return if value.blank?

        value = "" #{value}"" unless value[0] == ""\n""
        ""#{name}:#{value.to_s.gsub(""\n\n"", ""\n.\n"").gsub(""\n"", ""\n "")}\n""
      end

      def valid_until_field
        return unless @distribution.valid_time_duration_seconds

        rfc822_field('Valid-Until', release_date.since(@distribution.valid_time_duration_seconds).to_formatted_s(:rfc822))
      end

      def destroy_old_component_files
        return if @oldest_kept_generated_at.nil?

        @distribution.component_files.updated_before(@oldest_kept_generated_at).destroy_all # rubocop:disable Cop/DestroyAll
      end

      # used by ExclusiveLeaseGuard
      def lease_key
        ""packages:debian:generate_distribution_service:#{@distribution.class.container_type}_distribution:#{@distribution.id}""
      end

      # used by ExclusiveLeaseGuard
      def lease_timeout
        DEFAULT_LEASE_TIMEOUT
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Debian::GenerateDistributionService, feature_category: :package_registry do
  include_context 'with published Debian package'

  let(:service) { described_class.new(distribution) }

  [:project, :group].each do |container_type|
    context ""for #{container_type}"" do
      include_context 'with Debian distribution', container_type

      describe '#execute' do
        subject { service.execute }

        let(:subject2) { described_class.new(distribution).execute }
        let(:subject3) { described_class.new(distribution).execute }

        it_behaves_like 'Generate Debian Distribution and component files'
      end

      describe '#lease_key' do
        subject { service.send(:lease_key) }

        let(:prefix) { ""packages:debian:generate_distribution_service:"" }

        it 'returns an unique key' do
          is_expected.to eq ""#{prefix}#{container_type}_distribution:#{distribution.id}""
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Debian
    # Parse String as Debian RFC822 control data format
    # https://manpages.debian.org/unstable/dpkg-dev/deb822.5
    class ParseDebian822Service
      InvalidDebian822Error = Class.new(StandardError)

      def initialize(input)
        @input = input
      end

      def execute
        output = {}
        @input.each_line('', chomp: true) do |block|
          section = {}
          section_name, field = nil
          block.each_line(chomp: true) do |line|
            next if comment_line?(line)

            if continuation_line?(line)
              raise InvalidDebian822Error, ""Parse error. Unexpected continuation line"" if field.nil?

              section[field] += ""\n""
              section[field] += line[1..] unless paragraph_separator?(line)
            elsif match = match_section_line(line)
              section_name = match[:name] if section_name.nil?
              field = match[:field]

              raise InvalidDebian822Error, ""Duplicate field '#{field}' in section '#{section_name}'"" if section.include?(field)

              section[field] = match[:value]
            else
              raise InvalidDebian822Error, ""Parse error on line #{line}""
            end
          end

          raise InvalidDebian822Error, ""Duplicate section '#{section_name}'"" if output[section_name]

          output[section_name] = section
        end

        output
      end

      private

      def comment_line?(line)
        line.match?(/^#/)
      end

      def continuation_line?(line)
        line.match?(/^ /)
      end

      def paragraph_separator?(line)
        line == ' .'
      end

      def match_section_line(line)
        line.match(/(?<name>(?<field>^\S+):\s*(?<value>.*))/)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Debian::ParseDebian822Service, feature_category: :package_registry do
  subject { described_class.new(input) }

  context 'with dpkg-deb --field output' do
    let(:input) do
      <<~HEREDOC
        Package: libsample0
        Source: sample
        Version: 1.2.3~alpha2
        Architecture: amd64
        Maintainer: John Doe <john.doe@example.com>
        Installed-Size: 9
        Section: libs
        Priority: optional
        Multi-Arch: same
        Homepage: https://gitlab.com/
        Description: Some mostly empty lib
         Used in GitLab tests.
         .
         Testing another paragraph.
      HEREDOC
    end

    it 'return as expected, preserving order' do
      expected = {
        'Package: libsample0' => {
          'Package' => 'libsample0',
          'Source' => 'sample',
          'Version' => '1.2.3~alpha2',
          'Architecture' => 'amd64',
          'Maintainer' => 'John Doe <john.doe@example.com>',
          'Installed-Size' => '9',
          'Section' => 'libs',
          'Priority' => 'optional',
          'Multi-Arch' => 'same',
          'Homepage' => 'https://gitlab.com/',
          'Description' => ""Some mostly empty lib\nUsed in GitLab tests.\n\nTesting another paragraph.""
        }
      }

      expect(subject.execute.to_s).to eq(expected.to_s)
    end
  end

  context 'with control file' do
    let(:input) { fixture_file('packages/debian/sample/debian/control') }

    it 'return as expected, preserving order' do
      expected = {
        'Source: sample' => {
          'Source' => 'sample',
          'Priority' => 'optional',
          'Maintainer' => 'John Doe <john.doe@example.com>',
          'Build-Depends' => 'debhelper-compat (= 13)',
          'Standards-Version' => '4.5.0',
          'Section' => 'libs',
          'Homepage' => 'https://gitlab.com/',
          # 'Vcs-Browser' => 'https://salsa.debian.org/debian/sample-1.2.3',
          # '#Vcs-Git' => 'https://salsa.debian.org/debian/sample-1.2.3.git',
          'Rules-Requires-Root' => 'no'
        },
        'Package: sample-dev' => {
          'Package' => 'sample-dev',
          'Section' => 'libdevel',
          'Architecture' => 'any',
          'Multi-Arch' => 'same',
          'Depends' => 'libsample0 (= ${binary:Version}), ${misc:Depends}',
          'Description' => ""Some mostly empty development files\nUsed in GitLab tests.\n\nTesting another paragraph.""
        },
        'Package: libsample0' => {
          'Package' => 'libsample0',
          'Architecture' => 'any',
          'Multi-Arch' => 'same',
          'Depends' => '${shlibs:Depends}, ${misc:Depends}',
          'Description' => ""Some mostly empty lib\nUsed in GitLab tests.\n\nTesting another paragraph.""
        },
        'Package: sample-udeb' => {
          'Package' => 'sample-udeb',
          'Package-Type' => 'udeb',
          'Architecture' => 'any',
          'Depends' => 'installed-base',
          'Description' => 'Some mostly empty udeb'
        },
        'Package: sample-ddeb' => {
          'Package' => 'sample-ddeb',
          'Architecture' => 'any',
          'Description' => 'Some fake Ubuntu ddeb'
        }
      }

      expect(subject.execute.to_s).to eq(expected.to_s)
    end
  end

  context 'with empty input' do
    let(:input) { '' }

    it 'return a empty hash' do
      expect(subject.execute).to eq({})
    end
  end

  context 'with unexpected continuation line' do
    let(:input) { ' continuation' }

    it 'raise error' do
      expect { subject.execute }.to raise_error(described_class::InvalidDebian822Error, 'Parse error. Unexpected continuation line')
    end
  end

  context 'with duplicate field' do
    let(:input) do
      <<~HEREDOC
        Package: libsample0
        Source: sample
        Source: sample
      HEREDOC
    end

    it 'raise error' do
      expect { subject.execute }.to raise_error(described_class::InvalidDebian822Error, ""Duplicate field 'Source' in section 'Package: libsample0'"")
    end
  end

  context 'with incorrect input' do
    let(:input) do
      <<~HEREDOC
        Hello
      HEREDOC
    end

    it 'raise error' do
      expect { subject.execute }.to raise_error(described_class::InvalidDebian822Error, 'Parse error on line Hello')
    end
  end

  context 'with duplicate section' do
    let(:input) do
      <<~HEREDOC
        Package: libsample0

        Package: libsample0
      HEREDOC
    end

    it 'raise error' do
      expect { subject.execute }.to raise_error(described_class::InvalidDebian822Error, ""Duplicate section 'Package: libsample0'"")
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Debian
    class SignDistributionService
      include Gitlab::Utils::StrongMemoize

      def initialize(distribution, content, detach: false)
        @distribution = distribution
        @content = content
        @detach = detach
      end

      def execute
        raise ArgumentError, 'distribution key is missing' unless @distribution.key

        sig_mode = GPGME::GPGME_SIG_MODE_CLEAR

        sig_mode = GPGME::GPGME_SIG_MODE_DETACH if @detach

        Gitlab::Gpg.using_tmp_keychain do
          GPGME::Ctx.new(
            armor: true,
            offline: true,
            pinentry_mode: GPGME::PINENTRY_MODE_LOOPBACK,
            password: @distribution.key.passphrase
          ) do |ctx|
            ctx.import(GPGME::Data.from_str(@distribution.key.public_key))
            ctx.import(GPGME::Data.from_str(@distribution.key.private_key))
            signature = GPGME::Data.new
            ctx.sign(GPGME::Data.from_str(@content), signature, sig_mode)
            signature.to_s
          end
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Debian::SignDistributionService, feature_category: :package_registry do
  let_it_be(:group) { create(:group, :public) }

  let(:content) { FFaker::Lorem.paragraph }
  let(:service) { described_class.new(distribution, content, detach: detach) }

  shared_examples 'Sign Distribution' do |container_type, detach: false|
    context ""for #{container_type} detach=#{detach}"" do
      let(:detach) { detach }

      if container_type == :group
        let_it_be(:distribution) { create('debian_group_distribution', container: group) }
      else
        let_it_be(:project) { create(:project, group: group) }
        let_it_be(:distribution) { create('debian_project_distribution', container: project) }
      end

      describe '#execute' do
        subject { service.execute }

        context 'without an existing key' do
          it 'raises ArgumentError', :aggregate_failures do
            expect { subject }
              .to raise_error(ArgumentError, 'distribution key is missing')
          end
        end

        context 'with an existing key' do
          let!(:key) { create(""debian_#{container_type}_distribution_key"", distribution: distribution) }

          it 'returns the content signed', :aggregate_failures do
            expect(Packages::Debian::GenerateDistributionKeyService).not_to receive(:new)

            key_class = ""Packages::Debian::#{container_type.capitalize}DistributionKey"".constantize

            expect { subject }
              .to not_change { key_class.count }

            if detach
              expect(subject).to start_with(""-----BEGIN PGP SIGNATURE-----\n"")
            else
              expect(subject).to start_with(""-----BEGIN PGP SIGNED MESSAGE-----\nHash: SHA256\n\n#{content}\n-----BEGIN PGP SIGNATURE-----\n"")
            end

            expect(subject).to end_with(""\n-----END PGP SIGNATURE-----\n"")
          end
        end
      end
    end
  end

  it_behaves_like 'Sign Distribution', :project
  it_behaves_like 'Sign Distribution', :project, detach: true
  it_behaves_like 'Sign Distribution', :group
  it_behaves_like 'Sign Distribution', :group, detach: true
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Debian
    class ProcessPackageFileService
      include ExclusiveLeaseGuard
      include Gitlab::Utils::StrongMemoize

      SOURCE_FIELD_SPLIT_REGEX = /[ ()]/
      # used by ExclusiveLeaseGuard
      DEFAULT_LEASE_TIMEOUT = 1.hour.to_i.freeze

      SIMPLE_DEB_FILE_TYPES = %i[deb udeb ddeb].freeze

      def initialize(package_file, distribution_name, component_name)
        @package_file = package_file
        @distribution_name = distribution_name
        @component_name = component_name
      end

      def execute
        return if @package_file.package.pending_destruction?

        validate!

        try_obtain_lease do
          distribution.transaction do
            rename_package_and_set_version
            update_package
            update_files_metadata if changes_file?
            update_file_metadata
            cleanup_temp_package
          end

          ::Packages::Debian::GenerateDistributionWorker.perform_async(:project, package.debian_distribution.id)
        end
      end

      private

      def validate!
        raise ArgumentError, 'package file without Debian metadata' unless @package_file.debian_file_metadatum
        raise ArgumentError, 'already processed package file' unless @package_file.debian_file_metadatum.unknown?

        changes_file? ? validate_changes_file! : validate_package_file!
      end

      def changes_file?
        @package_file.file_name.end_with?('.changes')
      end

      def validate_changes_file!
        raise ArgumentError, 'unwanted distribution name' unless @distribution_name.nil?
        raise ArgumentError, 'unwanted component name' unless @component_name.nil?
        raise ArgumentError, 'missing Source field' unless file_metadata.dig(:fields, 'Source').present?
        raise ArgumentError, 'missing Version field' unless file_metadata.dig(:fields, 'Version').present?
        raise ArgumentError, 'missing Distribution field' unless file_metadata.dig(:fields, 'Distribution').present?
      end

      def validate_package_file!
        raise ArgumentError, 'missing distribution name' unless @distribution_name.present?
        raise ArgumentError, 'missing component name' unless @component_name.present?

        return if SIMPLE_DEB_FILE_TYPES.include?(file_metadata[:file_type])

        raise ArgumentError, ""invalid package file type: #{file_metadata[:file_type]}""
      end

      def file_metadata
        metadata_service_class.new(@package_file).execute
      end
      strong_memoize_attr :file_metadata

      def metadata_service_class
        changes_file? ? ::Packages::Debian::ExtractChangesMetadataService : ::Packages::Debian::ExtractMetadataService
      end

      def distribution
        Packages::Debian::DistributionsFinder.new(
          @package_file.package.project,
          codename_or_suite: package_distribution
        ).execute.last!
      end
      strong_memoize_attr :distribution

      def package_distribution
        return file_metadata[:fields]['Distribution'] if changes_file?

        @distribution_name
      end

      def package
        packages = temp_package.project
                               .packages
                               .existing_debian_packages_with(name: package_name, version: package_version)
        package = packages.with_debian_codename_or_suite(package_distribution)
                          .first

        unless package
          package_in_other_distribution = packages.first

          if package_in_other_distribution
            raise ArgumentError, ""Debian package #{package_name} #{package_version} exists "" \
                                 ""in distribution #{package_in_other_distribution.debian_distribution.codename}""
          end
        end

        package || temp_package
      end
      strong_memoize_attr :package

      def temp_package
        @package_file.package
      end
      strong_memoize_attr :temp_package

      def package_name
        return file_metadata[:fields]['Source'] if changes_file?

        package_name_and_version[0]
      end

      def package_version
        return file_metadata[:fields]['Version'] if changes_file?

        package_name_and_version[1]
      end

      def package_name_and_version
        package_name = file_metadata[:fields]['Package']
        package_version = file_metadata[:fields]['Version']

        if file_metadata[:fields]['Source']
          # ""sample"" or ""sample (1.2.3~alpha2)""
          source_field_parts = file_metadata[:fields]['Source'].split(SOURCE_FIELD_SPLIT_REGEX)
          package_name = source_field_parts[0]
          package_version = source_field_parts[2] || package_version
        end

        [package_name, package_version]
      end
      strong_memoize_attr :package_name_and_version

      def rename_package_and_set_version
        package.update!(
          name: package_name,
          version: package_version,
          status: :default
        )
      end

      def update_package
        return unless using_temporary_package?

        package.update!(
          debian_publication_attributes: { distribution_id: distribution.id }
        )
      end

      def using_temporary_package?
        package.id == temp_package.id
      end

      def update_files_metadata
        file_metadata[:files].each do |_, entry|
          file_metadata = ::Packages::Debian::ExtractMetadataService.new(entry.package_file).execute

          ::Packages::UpdatePackageFileService.new(entry.package_file, package_id: package.id)
            .execute

          # Force reload from database, as package has changed
          entry.package_file.reload_package

          entry.package_file.debian_file_metadatum.update!(
            file_type: file_metadata[:file_type],
            component: entry.component,
            architecture: file_metadata[:architecture],
            fields: file_metadata[:fields]
          )
        end
      end

      def update_file_metadata
        ::Packages::UpdatePackageFileService.new(@package_file, package_id: package.id)
          .execute

        # Force reload from database, as package has changed
        @package_file.reload_package

        @package_file.debian_file_metadatum.update!(
          file_type: file_metadata[:file_type],
          component: @component_name,
          architecture: file_metadata[:architecture],
          fields: file_metadata[:fields]
        )
      end

      def cleanup_temp_package
        temp_package.destroy unless using_temporary_package?
      end

      # used by ExclusiveLeaseGuard
      def lease_key
        ""packages:debian:process_package_file_service:#{temp_package.project_id}_#{package_name}_#{package_version}""
      end

      # used by ExclusiveLeaseGuard
      def lease_timeout
        DEFAULT_LEASE_TIMEOUT
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Debian::ProcessPackageFileService, feature_category: :package_registry do
  include ExclusiveLeaseHelpers

  let_it_be(:distribution) { create(:debian_project_distribution, :with_file, suite: 'unstable') }

  let(:debian_file_metadatum) { package_file.debian_file_metadatum }
  let(:service) { described_class.new(package_file, distribution_name, component_name) }

  describe '#execute' do
    using RSpec::Parameterized::TableSyntax

    subject { service.execute }

    shared_examples 'common validations' do
      context 'with package file without Debian metadata' do
        let!(:package_file) { create(:debian_package_file, without_loaded_metadatum: true) }

        let(:expected_error) { ArgumentError }
        let(:expected_message) { 'package file without Debian metadata' }

        it_behaves_like 'raises error'
      end

      context 'with already processed package file' do
        let!(:package_file) { create(:debian_package_file) }

        let(:expected_error) { ArgumentError }
        let(:expected_message) { 'already processed package file' }

        it_behaves_like 'raises error'
      end

      context 'without a distribution' do
        let(:expected_error) { ActiveRecord::RecordNotFound }
        let(:expected_message) { /^Couldn't find Packages::Debian::ProjectDistribution with / }

        before do
          # Workaround ActiveRecord cache
          Packages::Debian::ProjectDistribution.find(distribution.id).delete
        end

        it_behaves_like 'raises error'
      end

      context 'when there is a matching published package in another distribution' do
        let!(:matching_package) do
          create(
            :debian_package,
            project: distribution.project,
            name: 'sample',
            version: '1.2.3~alpha2'
          )
        end

        let(:expected_error) { ArgumentError }

        let(:expected_message) do
          ""Debian package sample 1.2.3~alpha2 exists in distribution #{matching_package.debian_distribution.codename}""
        end

        it_behaves_like 'raises error'
      end
    end

    shared_examples 'raises error' do
      it 'raises error', :aggregate_failures do
        expect(::Packages::Debian::GenerateDistributionWorker).not_to receive(:perform_async)
        expect { subject }
          .to not_change(Packages::Package, :count)
          .and not_change(Packages::PackageFile, :count)
          .and not_change { Packages::Debian::Publication.count }
          .and not_change(package.package_files, :count)
          .and not_change { package.reload.name }
          .and not_change { package.version }
          .and not_change { package.status }
          .and not_change { debian_file_metadatum&.reload&.file_type }
          .and not_change { debian_file_metadatum&.component }
          .and raise_error(expected_error, expected_message)
      end
    end

    shared_examples 'does nothing' do
      it 'does nothing', :aggregate_failures do
        expect(::Packages::Debian::GenerateDistributionWorker).not_to receive(:perform_async)
        expect { subject }
          .to not_change(Packages::Package, :count)
          .and not_change(Packages::PackageFile, :count)
          .and not_change { Packages::Debian::Publication.count }
          .and not_change(package.package_files, :count)
          .and not_change { package.reload.name }
          .and not_change { package.version }
          .and not_change { package.status }
          .and not_change { debian_file_metadatum&.reload&.file_type }
          .and not_change { debian_file_metadatum&.component }
      end
    end

    shared_examples 'updates package and changes file' do
      it 'updates package and changes file', :aggregate_failures do
        expect(::Packages::Debian::GenerateDistributionWorker)
          .to receive(:perform_async).with(:project, distribution.id)
        expect { subject }
          .to not_change(Packages::Package, :count)
          .and not_change(Packages::PackageFile, :count)
          .and change { Packages::Debian::Publication.count }.by(1)
          .and change { package.package_files.count }.from(1).to(8)
          .and change { package.reload.name }.to('sample')
          .and change { package.version }.to('1.2.3~alpha2')
          .and change { package.status }.from('processing').to('default')
          .and change { package.debian_publication }.from(nil)
          .and change { debian_file_metadatum.file_type }.from('unknown').to('changes')
          .and not_change { debian_file_metadatum.component }
      end
    end

    shared_examples 'updates package and package file' do
      it 'updates package and package file', :aggregate_failures do
        expect(::Packages::Debian::GenerateDistributionWorker)
          .to receive(:perform_async).with(:project, distribution.id)
        expect { subject }
          .to not_change(Packages::Package, :count)
          .and not_change(Packages::PackageFile, :count)
          .and change { Packages::Debian::Publication.count }.by(1)
          .and not_change(package.package_files, :count)
          .and change { package.reload.name }.to('sample')
          .and change { package.version }.to('1.2.3~alpha2')
          .and change { package.status }.from('processing').to('default')
          .and change { package.debian_publication }.from(nil)
          .and change { debian_file_metadatum.file_type }.from('unknown').to(expected_file_type)
          .and change { debian_file_metadatum.component }.from(nil).to(component_name)
      end
    end

    context 'with a changes file' do
      let!(:incoming) { create(:debian_incoming, project: distribution.project) }
      let!(:temporary_with_changes) { create(:debian_temporary_with_changes, project: distribution.project) }
      let(:package) { temporary_with_changes }

      let(:package_file) { temporary_with_changes.package_files.first }
      let(:distribution_name) { nil }
      let(:component_name) { nil }

      it_behaves_like 'common validations'

      context 'with distribution_name' do
        let(:distribution_name) { distribution.codename }
        let(:expected_error) { ArgumentError }
        let(:expected_message) { 'unwanted distribution name' }

        it_behaves_like 'raises error'
      end

      context 'with component_name' do
        let(:component_name) { 'main' }
        let(:expected_error) { ArgumentError }
        let(:expected_message) { 'unwanted component name' }

        it_behaves_like 'raises error'
      end

      context 'with crafted file_metadata' do
        let(:complete_file_metadata) do
          {
            file_type: :changes,
            fields: {
              'Source' => 'abc',
              'Version' => '1.0',
              'Distribution' => 'sid'
            }
          }
        end

        let(:expected_error) { ArgumentError }

        before do
          allow_next_instance_of(::Packages::Debian::ExtractChangesMetadataService) do |extract_changes_metadata_svc|
            allow(extract_changes_metadata_svc).to receive(:execute).and_return(file_metadata)
          end
        end

        context 'with missing Source field' do
          let(:file_metadata) { complete_file_metadata.tap { |m| m[:fields].delete 'Source' } }
          let(:expected_message) { 'missing Source field' }

          it_behaves_like 'raises error'
        end

        context 'with missing Version field' do
          let(:file_metadata) { complete_file_metadata.tap { |m| m[:fields].delete 'Version' } }
          let(:expected_message) { 'missing Version field' }

          it_behaves_like 'raises error'
        end

        context 'with missing Distribution field' do
          let(:file_metadata) { complete_file_metadata.tap { |m| m[:fields].delete 'Distribution' } }
          let(:expected_message) { 'missing Distribution field' }

          it_behaves_like 'raises error'
        end
      end

      context 'when lease is already taken' do
        before do
          stub_exclusive_lease_taken(
            ""packages:debian:process_package_file_service:#{distribution.project_id}_sample_1.2.3~alpha2"",
            timeout: Packages::Debian::ProcessPackageFileService::DEFAULT_LEASE_TIMEOUT)
        end

        it_behaves_like 'does nothing'
      end

      context 'when there is no matching published package' do
        it_behaves_like 'updates package and changes file'
      end

      context 'when there is a matching published package' do
        let!(:matching_package) do
          create(
            :debian_package,
            project: distribution.project,
            published_in: distribution,
            name: 'sample',
            version: '1.2.3~alpha2'
          )
        end

        it 'reuses existing package and update package file', :aggregate_failures do
          expect(::Packages::Debian::GenerateDistributionWorker)
            .to receive(:perform_async).with(:project, distribution.id)
          expect { subject }
            .to change { Packages::Package.count }.from(3).to(2)
            .and not_change { Packages::PackageFile.count }
            .and not_change(Packages::Debian::Publication, :count)
            .and change { package.package_files.count }.from(1).to(0)
            .and change { incoming.package_files.count }.from(7).to(0)
            .and change { matching_package.package_files.count }.from(7).to(15)
            .and change { package_file.package }.from(package).to(matching_package)
            .and not_change(matching_package, :name)
            .and not_change(matching_package, :version)
            .and change { debian_file_metadatum.file_type }.from('unknown').to('changes')
            .and not_change { debian_file_metadatum.component }

          expect { package.reload }
            .to raise_error(ActiveRecord::RecordNotFound)
        end
      end

      context 'when there is a matching published package pending destruction' do
        let!(:matching_package) do
          create(
            :debian_package,
            :pending_destruction,
            project: distribution.project,
            published_in: distribution,
            name: 'sample',
            version: '1.2.3~alpha2'
          )
        end

        it_behaves_like 'updates package and changes file'
      end
    end

    context 'with a package file' do
      let!(:temporary_with_files) { create(:debian_temporary_with_files, project: distribution.project) }
      let(:package) { temporary_with_files }

      let(:package_file) { package.package_files.with_file_name('libsample0_1.2.3~alpha2_amd64.deb').first }
      let(:distribution_name) { distribution.codename }
      let(:component_name) { 'main' }

      where(:case_name, :expected_file_type, :file_name, :component_name) do
        'with a deb'   | 'deb'  | 'libsample0_1.2.3~alpha2_amd64.deb'   | 'main'
        'with an udeb' | 'udeb' | 'sample-udeb_1.2.3~alpha2_amd64.udeb' | 'contrib'
        'with an ddeb' | 'ddeb' | 'sample-ddeb_1.2.3~alpha2_amd64.ddeb' | 'main'
      end

      with_them do
        context 'with Debian package file' do
          let(:package_file) { package.package_files.with_file_name(file_name).first }

          it_behaves_like 'common validations'

          context 'without distribution name' do
            let(:distribution_name) { '' }
            let(:expected_error) { ArgumentError }
            let(:expected_message) { 'missing distribution name' }

            it_behaves_like 'raises error'
          end

          context 'without component name' do
            let(:component_name) { '' }
            let(:expected_error) { ArgumentError }
            let(:expected_message) { 'missing component name' }

            it_behaves_like 'raises error'
          end

          context 'with invalid package file type' do
            let(:package_file) { package.package_files.with_file_name('sample_1.2.3~alpha2.tar.xz').first }
            let(:expected_error) { ArgumentError }
            let(:expected_message) { 'invalid package file type: source' }

            it_behaves_like 'raises error'
          end

          context 'when lease is already taken' do
            before do
              stub_exclusive_lease_taken(
                ""packages:debian:process_package_file_service:#{distribution.project_id}_sample_1.2.3~alpha2"",
                timeout: Packages::Debian::ProcessPackageFileService::DEFAULT_LEASE_TIMEOUT)
            end

            it_behaves_like 'does nothing'
          end

          context 'when there is no matching published package' do
            it_behaves_like 'updates package and package file'

            context 'with suite as distribution name' do
              let(:distribution_name) { distribution.suite }

              it_behaves_like 'updates package and package file'
            end
          end

          context 'when there is a matching published package' do
            let!(:matching_package) do
              create(
                :debian_package,
                project: distribution.project,
                published_in: distribution,
                name: 'sample',
                version: '1.2.3~alpha2'
              )
            end

            it 'reuses existing package and update package file', :aggregate_failures do
              expect(::Packages::Debian::GenerateDistributionWorker)
                .to receive(:perform_async).with(:project, distribution.id)
              expect { subject }
                .to change { Packages::Package.count }.from(2).to(1)
                .and change { Packages::PackageFile.count }.from(14).to(8)
                .and not_change(Packages::Debian::Publication, :count)
                .and change { package.package_files.count }.from(7).to(0)
                .and change { package_file.package }.from(package).to(matching_package)
                .and not_change(matching_package, :name)
                .and not_change(matching_package, :version)
                .and change { debian_file_metadatum.file_type }.from('unknown').to(expected_file_type)
                .and change { debian_file_metadatum.component }.from(nil).to(component_name)

              expect { package.reload }
                .to raise_error(ActiveRecord::RecordNotFound)
            end
          end

          context 'when there is a matching published package pending destruction' do
            let!(:matching_package) do
              create(
                :debian_package,
                :pending_destruction,
                project: distribution.project,
                published_in: distribution,
                name: 'sample',
                version: '1.2.3~alpha2'
              )
            end

            it_behaves_like 'updates package and package file'
          end
        end
      end
    end
  end

  describe '#lease_key' do
    let(:prefix) { 'packages:debian:process_package_file_service' }

    subject { service.send(:lease_key) }

    context 'with a changes file' do
      let!(:incoming) { create(:debian_incoming, project: distribution.project) }
      let!(:temporary_with_changes) { create(:debian_temporary_with_changes, project: distribution.project) }
      let(:package) { temporary_with_changes }

      let(:package_file) { temporary_with_changes.package_files.first }
      let(:distribution_name) { nil }
      let(:component_name) { nil }

      it { is_expected.to eq(""#{prefix}:#{distribution.project_id}_sample_1.2.3~alpha2"") }
    end

    context 'with a package file' do
      let!(:temporary_with_files) { create(:debian_temporary_with_files, project: distribution.project) }
      let(:package) { temporary_with_files }

      let(:package_file) { package.package_files.with_file_name('libsample0_1.2.3~alpha2_amd64.deb').first }
      let(:distribution_name) { distribution.codename }
      let(:component_name) { 'main' }

      it { is_expected.to eq(""#{prefix}:#{distribution.project_id}_sample_1.2.3~alpha2"") }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
  module Maven
    class CreatePackageService < ::Packages::CreatePackageService
      def execute
        app_group, _, app_name = params[:name].rpartition('/')
        app_group.tr!('/', '.')

        create_package!(:maven,
          maven_metadatum_attributes: {
            path: params[:path],
            app_group: app_group,
            app_name: app_name,
            app_version: params[:version]
          }
        )
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::Maven::CreatePackageService, feature_category: :package_registry do
  let(:project) { create(:project) }
  let(:user) { create(:user) }
  let(:app_name) { 'my-app' }
  let(:version) { '1.0-SNAPSHOT' }
  let(:path) { ""my/company/app/#{app_name}"" }
  let(:path_with_version) { ""#{path}/#{version}"" }

  describe '#execute' do
    subject(:package) { described_class.new(project, user, params).execute }

    context 'with version' do
      let(:params) do
        {
          path: path_with_version,
          name: path,
          version: version
        }
      end

      it 'creates a new package with metadatum' do
        expect(package).to be_valid
        expect(package.name).to eq(path)
        expect(package.version).to eq(version)
        expect(package.package_type).to eq('maven')
        expect(package.maven_metadatum).to be_valid
        expect(package.maven_metadatum.path).to eq(path_with_version)
        expect(package.maven_metadatum.app_group).to eq('my.company.app')
        expect(package.maven_metadatum.app_name).to eq(app_name)
        expect(package.maven_metadatum.app_version).to eq(version)
      end

      it_behaves_like 'assigns the package creator'
    end

    context 'without version' do
      let(:params) do
        {
          path: path,
          name: path,
          version: nil
        }
      end

      it 'creates a new package with metadatum' do
        package = described_class.new(project, user, params).execute

        expect(package).to be_valid
        expect(package.name).to eq(path)
        expect(package.version).to be nil
        expect(package.maven_metadatum).to be_valid
        expect(package.maven_metadatum.path).to eq(path)
        expect(package.maven_metadatum.app_group).to eq('my.company.app')
        expect(package.maven_metadatum.app_name).to eq(app_name)
        expect(package.maven_metadatum.app_version).to be nil
      end

      it_behaves_like 'assigns the package creator'
    end

    context 'path is missing' do
      let(:params) do
        {
          name: path,
          version: version
        }
      end

      it 'raises an error' do
        service = described_class.new(project, user, params)

        expect { service.execute }.to raise_error(ActiveRecord::RecordInvalid)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
  module Maven
    class FindOrCreatePackageService < BaseService
      SNAPSHOT_TERM = '-SNAPSHOT'
      MAX_FILE_NAME_LENGTH = 5000

      def execute
        return ServiceResponse.error(message: 'File name is too long') if file_name_too_long?

        package =
          ::Packages::Maven::PackageFinder.new(current_user, project, path: path)
          .execute&.last

        unless Namespace::PackageSetting.duplicates_allowed?(package)
          return ServiceResponse.error(message: 'Duplicate package is not allowed') if target_package_is_duplicate?(package)
        end

        unless package
          # Maven uploads several files during `mvn deploy` in next order:
          #   - my-company/my-app/1.0-SNAPSHOT/my-app.jar
          #   - my-company/my-app/1.0-SNAPSHOT/my-app.pom
          #   - my-company/my-app/1.0-SNAPSHOT/maven-metadata.xml
          #   - my-company/my-app/maven-metadata.xml
          #
          # The last xml file does not have VERSION in URL because it contains
          # information about all versions. When uploading such file, we create
          # a package with a version set to `nil`. The xml file with a version
          # is only created and uploaded for snapshot versions.
          #
          # Gradle has a different upload order:
          #   - my-company/my-app/1.0-SNAPSHOT/maven-metadata.xml
          #   - my-company/my-app/1.0-SNAPSHOT/my-app.jar
          #   - my-company/my-app/1.0-SNAPSHOT/my-app.pom
          #   - my-company/my-app/maven-metadata.xml
          #
          # The first upload has to create the proper package (the one with the version set).
          if file_name == Packages::Maven::Metadata.filename && !snapshot_version?
            package_name = path
            version = nil
          else
            package_name, _, version = path.rpartition('/')
          end

          package_params = {
            name: package_name,
            path: path,
            status: params[:status],
            version: version
          }

          package =
            ::Packages::Maven::CreatePackageService.new(project, current_user, package_params)
                                                   .execute
        end

        package.create_build_infos!(params[:build])

        ServiceResponse.success(payload: { package: package })
      end

      private

      def file_name_too_long?
        return false unless file_name

        file_name.size > MAX_FILE_NAME_LENGTH
      end

      def target_package_is_duplicate?(package)
        # duplicate metadata files can be uploaded multiple times
        return false if package.version.nil?

        existing_file_names = strip_snapshot_parts(
          package.package_files
                 .map(&:file_name)
                 .compact
        )

        published_file_name = strip_snapshot_parts_from(file_name)
        existing_file_names.include?(published_file_name)
      end

      def strip_snapshot_parts(file_names)
        return file_names unless snapshot_version?

        Array.wrap(file_names).map { |f| strip_snapshot_parts_from(f) }
      end

      def strip_snapshot_parts_from(file_name)
        return file_name unless snapshot_version?
        return unless file_name

        match_data = file_name.match(Gitlab::Regex::Packages::MAVEN_SNAPSHOT_DYNAMIC_PARTS)

        if match_data
          file_name.gsub(match_data.captures.last, """")
        else
          file_name
        end
      end

      def snapshot_version?
        path&.ends_with?(SNAPSHOT_TERM)
      end

      def path
        params[:path]
      end

      def file_name
        params[:file_name]
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::Maven::FindOrCreatePackageService, feature_category: :package_registry do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }

  let(:app_name) { 'my-app' }
  let(:path) { ""sandbox/test/app/#{app_name}"" }
  let(:version) { '1.0.0' }
  let(:file_name) { 'test.jar' }
  let(:param_path) { ""#{path}/#{version}"" }
  let(:params) { { path: param_path, file_name: file_name } }
  let(:service) { described_class.new(project, user, params) }

  describe '#execute' do
    using RSpec::Parameterized::TableSyntax

    subject { service.execute }

    shared_examples 'reuse existing package' do
      it { expect { subject }.not_to change { Packages::Package.count } }

      it 'returns the existing package' do
        expect(subject.payload).to eq(package: existing_package)
      end
    end

    shared_examples 'create package' do
      it { expect { subject }.to change { Packages::Package.count }.by(1) }

      it 'sets the proper name and version', :aggregate_failures do
        pkg = subject.payload[:package]

        expect(pkg.name).to eq(path)
        expect(pkg.version).to eq(version)
      end

      context 'with optional attributes' do
        subject { service.execute.payload[:package] }

        it_behaves_like 'assigns build to package'
        it_behaves_like 'assigns status to package'
      end
    end

    shared_examples 'returning an error' do |with_message: ''|
      it { expect { subject }.not_to change { project.package_files.count } }

      it 'returns an error', :aggregate_failures do
        expect(subject.payload).to be_empty
        expect(subject.errors).to include(with_message)
      end
    end

    context 'path with version' do
      # Note that ""path with version"" and ""file type maven metadata xml"" only exists for snapshot versions
      # In other words, we will never have an metadata xml upload on a path with version for a non snapshot version
      where(:package_exist, :file_type, :snapshot_version, :shared_example_name) do
        true  | :jar       | false | 'reuse existing package'
        false | :jar       | false | 'create package'
        true  | :jar       | true  | 'reuse existing package'
        false | :jar       | true  | 'create package'
        true  | :maven_xml | true  | 'reuse existing package'
        false | :maven_xml | true  | 'create package'
      end

      with_them do
        let(:version) { snapshot_version ? '1.0-SNAPSHOT' : '1.0.0' }
        let(:file_name) { file_type == :maven_xml ? 'maven-metadata.xml' : 'test.jar' }

        let!(:existing_package) do
          if package_exist
            create(:maven_package, name: path, version: version, project: project)
          end
        end

        it_behaves_like params[:shared_example_name]
      end
    end

    context 'path without version' do
      let(:param_path) { path }
      let(:version) { nil }

      context 'maven-metadata.xml file' do
        let(:file_name) { 'maven-metadata.xml' }

        context 'with existing package' do
          let!(:existing_package) { create(:maven_package, name: path, version: version, project: project) }

          it_behaves_like 'reuse existing package'

          context 'marked as pending_destruction' do
            before do
              existing_package.pending_destruction!
            end

            it_behaves_like 'create package'
          end
        end

        context 'without existing package' do
          it_behaves_like 'create package'
        end
      end
    end

    context 'with a build' do
      let_it_be(:pipeline) { create(:ci_pipeline, user: user) }

      let(:build) { double('build', pipeline: pipeline) }
      let(:params) { { path: param_path, file_name: file_name, build: build } }

      it 'creates a build_info' do
        expect { subject }.to change { Packages::BuildInfo.count }.by(1)
      end

      context 'with multiple files for the same package and the same pipeline' do
        let(:file_2_params) { params.merge(file_name: 'test2.jar') }
        let(:file_3_params) { params.merge(file_name: 'test3.jar') }

        it 'creates a single build info' do
          expect do
            described_class.new(project, user, params).execute
            described_class.new(project, user, file_2_params).execute
            described_class.new(project, user, file_3_params).execute
          end.to change { ::Packages::BuildInfo.count }.by(1)
        end
      end
    end

    context 'when package duplicates are not allowed' do
      let_it_be_with_refind(:package_settings) { create(:namespace_package_setting, :group, maven_duplicates_allowed: false) }
      let_it_be_with_refind(:group) { package_settings.namespace }
      let_it_be_with_refind(:project) { create(:project, group: group) }

      let!(:existing_package) { create(:maven_package, name: path, version: version, project: project) }

      let(:existing_file_name) { file_name }
      let(:jar_file) { existing_package.package_files.with_file_name_like('%.jar').first }

      before do
        jar_file.update_column(:file_name, existing_file_name)
      end

      it_behaves_like 'returning an error', with_message: 'Duplicate package is not allowed'

      context 'for a SNAPSHOT version' do
        let(:version) { '1.0.0-SNAPSHOT' }

        it_behaves_like 'returning an error', with_message: 'Duplicate package is not allowed'
      end

      context 'when uploading to the versionless package which contains metadata about all versions' do
        let(:version) { nil }
        let(:param_path) { path }

        it_behaves_like 'reuse existing package'
      end

      context 'when uploading different non-duplicate files to the same package' do
        before do
          jar_file.destroy!
        end

        it_behaves_like 'reuse existing package'
      end

      context 'when the package name matches the exception regex' do
        before do
          package_settings.update!(maven_duplicate_exception_regex: existing_package.name)
        end

        it_behaves_like 'reuse existing package'
      end

      context 'when the package version matches the exception regex' do
        before do
          package_settings.update!(maven_duplicate_exception_regex: existing_package.version)
        end

        it_behaves_like 'reuse existing package'
      end

      context 'when uploading a similar package file name with a classifier' do
        let(:existing_file_name) { 'test.jar' }
        let(:file_name) { 'test-javadoc.jar' }

        it_behaves_like 'reuse existing package'

        context 'for a SNAPSHOT version' do
          let(:version) { '1.0.0-SNAPSHOT' }
          let(:existing_file_name) { 'test-1.0-20230303.163304-1.jar' }
          let(:file_name) { 'test-1.0-20230303.163304-1-javadoc.jar' }

          it_behaves_like 'reuse existing package'
        end
      end
    end

    context 'with a very large file name' do
      let(:params) { super().merge(file_name: 'a' * (described_class::MAX_FILE_NAME_LENGTH + 1)) }

      it_behaves_like 'returning an error', with_message: 'File name is too long'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Maven
    module Metadata
      class AppendPackageFileService
        XML_CONTENT_TYPE = 'application/xml'
        DEFAULT_CONTENT_TYPE = 'application/octet-stream'

        MD5_FILE_NAME = ""#{Metadata.filename}.md5""
        SHA1_FILE_NAME = ""#{Metadata.filename}.sha1""
        SHA256_FILE_NAME = ""#{Metadata.filename}.sha256""
        SHA512_FILE_NAME = ""#{Metadata.filename}.sha512""

        def initialize(package:, metadata_content:)
          @package = package
          @metadata_content = metadata_content
        end

        def execute
          return ServiceResponse.error(message: 'package is not set') unless @package
          return ServiceResponse.error(message: 'metadata content is not set') unless @metadata_content

          file_md5 = digest_from(@metadata_content, :md5)
          file_sha1 = digest_from(@metadata_content, :sha1)
          file_sha256 = digest_from(@metadata_content, :sha256)
          file_sha512 = digest_from(@metadata_content, :sha512)

          @package.transaction do
            append_metadata_file(
              content: @metadata_content,
              file_name: Metadata.filename,
              content_type: XML_CONTENT_TYPE,
              sha1: file_sha1,
              md5: file_md5,
              sha256: file_sha256
            )

            append_metadata_file(content: file_md5, file_name: MD5_FILE_NAME) unless Gitlab::FIPS.enabled?
            append_metadata_file(content: file_sha1, file_name: SHA1_FILE_NAME)
            append_metadata_file(content: file_sha256, file_name: SHA256_FILE_NAME)
            append_metadata_file(content: file_sha512, file_name: SHA512_FILE_NAME)
          end

          ServiceResponse.success(message: 'New metadata package file created')
        end

        private

        def append_metadata_file(content:, file_name:, content_type: DEFAULT_CONTENT_TYPE, sha1: nil, md5: nil, sha256: nil)
          file_md5 = md5 || digest_from(content, :md5)
          file_sha1 = sha1 || digest_from(content, :sha1)
          file_sha256 = sha256 || digest_from(content, :sha256)

          file = CarrierWaveStringFile.new_file(
            file_content: content,
            filename: file_name,
            content_type: content_type
          )

          ::Packages::CreatePackageFileService.new(
            @package,
            file: file,
            size: file.size,
            file_name: file_name,
            file_sha1: file_sha1,
            file_md5: file_md5,
            file_sha256: file_sha256
          ).execute
        end

        def digest_from(content, type)
          return if type == :md5 && Gitlab::FIPS.enabled?

          digest_class = case type
                         when :md5
                           Digest::MD5
                         when :sha1
                           Digest::SHA1
                         when :sha256
                           Digest::SHA256
                         when :sha512
                           Digest::SHA512
                         end
          digest_class.hexdigest(content)
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Packages::Maven::Metadata::AppendPackageFileService, feature_category: :package_registry do
  let_it_be(:package) { create(:maven_package, version: nil) }

  let(:service) { described_class.new(package: package, metadata_content: content) }
  let(:content) { 'test' }

  describe '#execute' do
    subject { service.execute }

    context 'with some content' do
      it 'creates all the related package files', :aggregate_failures do
        expect { subject }.to change { package.package_files.count }.by(5)
        expect(subject).to be_success

        expect_file(metadata_file_name, with_content: content, with_content_type: 'application/xml')
        expect_file(""#{metadata_file_name}.md5"")
        expect_file(""#{metadata_file_name}.sha1"")
        expect_file(""#{metadata_file_name}.sha256"")
        expect_file(""#{metadata_file_name}.sha512"")
      end

      context 'with FIPS mode', :fips_mode do
        it 'does not generate file_md5' do
          expect { subject }.to change { package.package_files.count }.by(4)
          expect(subject).to be_success

          expect_file(metadata_file_name, with_content: content, with_content_type: 'application/xml', fips: true)
          expect_file(""#{metadata_file_name}.sha1"", fips: true)
          expect_file(""#{metadata_file_name}.sha256"", fips: true)
          expect_file(""#{metadata_file_name}.sha512"", fips: true)
        end
      end
    end

    context 'with nil content' do
      let(:content) { nil }

      it_behaves_like 'returning an error service response', message: 'metadata content is not set'
    end

    context 'with nil package' do
      let(:package) { nil }

      it_behaves_like 'returning an error service response', message: 'package is not set'
    end

    def expect_file(file_name, fips: false, with_content: nil, with_content_type: '')
      package_file = package.package_files.recent.with_file_name(file_name).first

      expect(package_file.file).to be_present
      expect(package_file.file_name).to eq(file_name)
      expect(package_file.size).to be > 0
      expect(package_file.file_sha1).to be_present
      expect(package_file.file_sha256).to be_present
      expect(package_file.file.content_type).to eq(with_content_type)

      if fips
        expect(package_file.file_md5).not_to be_present
      else
        expect(package_file.file_md5).to be_present
      end

      if with_content
        expect(package_file.file.read).to eq(with_content)
      end
    end

    def metadata_file_name
      ::Packages::Maven::Metadata.filename
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Maven
    module Metadata
      class CreatePluginsXmlService < BaseCreateXmlService
        XPATH_PLUGIN_ARTIFACT_ID = '//plugin/artifactId'
        XPATH_PLUGINS = '//metadata/plugins'
        EMPTY_PLUGINS_PAYLOAD = {
          changes_exist: true,
          empty_plugins: true
        }.freeze

        def execute
          return ServiceResponse.error(message: 'package not set') unless @package
          return ServiceResponse.error(message: 'metadata_content not set') unless @metadata_content
          return ServiceResponse.error(message: 'metadata_content is invalid') unless plugins_xml_node.present?
          return ServiceResponse.success(payload: EMPTY_PLUGINS_PAYLOAD) if plugin_artifact_ids_from_database.empty?

          changes_exist = update_plugins_list

          payload = { changes_exist: changes_exist, empty_versions: false }
          payload[:metadata_content] = xml_doc.to_xml(indent: INDENT_SPACE) if changes_exist

          ServiceResponse.success(payload: payload)
        end

        private

        def update_plugins_list
          return false if plugin_artifact_ids_from_xml == plugin_artifact_ids_from_database

          plugins_xml_node.children.remove

          plugin_artifact_ids_from_database.each do |artifact_id|
            plugins_xml_node.add_child(plugin_node_for(artifact_id))
          end

          true
        end

        def plugins_xml_node
          xml_doc.xpath(XPATH_PLUGINS)
                   .first
        end
        strong_memoize_attr :plugins_xml_node

        def plugin_artifact_ids_from_xml
          plugins_xml_node.xpath(XPATH_PLUGIN_ARTIFACT_ID)
                            .map(&:content)
        end
        strong_memoize_attr :plugin_artifact_ids_from_xml

        def plugin_artifact_ids_from_database
          package_names = plugin_artifact_ids_from_xml.map do |artifact_id|
            ""#{@package.name}/#{artifact_id}""
          end

          packages = @package.project.packages
                                     .maven
                                     .displayable
                                     .with_name(package_names)
                                     .has_version

          ::Packages::Maven::Metadatum.for_package_ids(packages.select(:id))
                                      .order_created
                                      .pluck_app_name
                                      .uniq
        end
        strong_memoize_attr :plugin_artifact_ids_from_database

        def plugin_node_for(artifact_id)
          xml_doc.create_element('plugin').tap do |plugin_node|
            plugin_node.add_child(xml_node('name', artifact_id))
            plugin_node.add_child(xml_node('prefix', prefix_from(artifact_id)))
            plugin_node.add_child(xml_node('artifactId', artifact_id))
          end
        end

        # Maven plugin prefix generation from
        # https://github.com/apache/maven/blob/c3dba0e5ba71ee7cbd62620f669a8c206e71b5e2/maven-plugin-api/src/main/java/org/apache/maven/plugin/descriptor/PluginDescriptor.java#L189
        def prefix_from(artifact_id)
          artifact_id.gsub(/-?maven-?/, '')
                     .gsub(/-?plugin-?/, '')
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Packages::Maven::Metadata::CreatePluginsXmlService, feature_category: :package_registry do
  let_it_be(:group_id) { 'my/test' }
  let_it_be(:package) { create(:maven_package, name: group_id, version: nil) }

  let(:plugins_in_database) { %w[one-maven-plugin two three-maven-plugin] }
  let(:plugins_in_xml) { %w[one-maven-plugin two three-maven-plugin] }
  let(:service) { described_class.new(metadata_content: metadata_xml, package: package) }

  describe '#execute' do
    subject { service.execute }

    before do
      next unless package

      plugins_in_database.each do |plugin|
        create(
          :maven_package,
          name: ""#{group_id}/#{plugin}"",
          version: '1.0.0',
          project: package.project,
          maven_metadatum_attributes: {
            app_group: group_id.tr('/', '.'),
            app_name: plugin,
            app_version: '1.0.0'
          }
        )
      end
    end

    shared_examples 'returning an xml with plugins from the database' do
      it 'returns an metadata versions xml with versions in the database', :aggregate_failures do
        expect(subject).to be_success
        expect(subject.payload[:changes_exist]).to eq(true)
        expect(subject.payload[:empty_versions]).to eq(false)
        expect(plugins_from(subject.payload[:metadata_content])).to match_array(plugins_in_database)
      end
    end

    shared_examples 'returning no changes' do
      it 'returns no changes', :aggregate_failures do
        expect(subject).to be_success
        expect(subject.payload).to eq(changes_exist: false, empty_versions: false)
      end
    end

    context 'with same plugins on both sides' do
      it_behaves_like 'returning no changes'
    end

    context 'with more plugins' do
      let(:additional_plugins) { %w[four-maven-plugin five] }

      context 'in database' do
        let(:plugins_in_database) { plugins_in_xml + additional_plugins }

        # we can't distinguish that the additional plugin are actually maven plugins
        it_behaves_like 'returning no changes'
      end

      context 'in xml' do
        let(:plugins_in_xml) { plugins_in_database + additional_plugins }

        it_behaves_like 'returning an xml with plugins from the database'
      end
    end

    context 'with no versions in the database' do
      let(:plugins_in_database) { [] }

      it 'returns a success', :aggregate_failures do
        result = subject

        expect(result).to be_success
        expect(result.payload).to eq(changes_exist: true, empty_plugins: true)
      end
    end

    context 'with an incomplete metadata content' do
      let(:metadata_xml) { '<metadata></metadata>' }

      it_behaves_like 'returning an error service response', message: 'metadata_content is invalid'
    end

    context 'with an invalid metadata content' do
      let(:metadata_xml) { '<meta></metadata>' }

      it_behaves_like 'returning an error service response', message: 'metadata_content is invalid'
    end

    it_behaves_like 'handling metadata content pointing to a file for the create xml service'

    it_behaves_like 'handling invalid parameters for create xml service'
  end

  def metadata_xml
    Nokogiri::XML::Builder.new do |xml|
      xml.metadata do
        xml.plugins do
          plugins_in_xml.each do |plugin|
            xml.plugin do
              xml.name(plugin)
              xml.prefix(prefix_from(plugin))
              xml.artifactId(plugin)
            end
          end
        end
      end
    end.to_xml
  end

  def prefix_from(artifact_id)
    artifact_id.gsub(/-?maven-?/, '')
               .gsub(/-?plugin-?/, '')
  end

  def plugins_from(xml_content)
    doc = Nokogiri::XML(xml_content)
    doc.xpath('//metadata/plugins/plugin/artifactId').map(&:content)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Maven
    module Metadata
      class SyncService < BaseContainerService
        include Gitlab::Utils::StrongMemoize

        alias_method :project, :container

        MAX_FILE_SIZE = 10.megabytes.freeze

        def execute
          return error('Blank package name') unless package_name
          return error('Not allowed') unless Ability.allowed?(current_user, :destroy_package, project)

          result = success('Non existing versionless package(s). Nothing to do.')

          # update versionless package for plugins if it exists
          if metadata_package_file_for_plugins
            result = update_plugins_xml

            return result if result.error?
          end

          # update versionless_package for versions if it exists
          return update_versions_xml if metadata_package_file_for_versions

          result
        end

        private

        def update_versions_xml
          update_xml(
            kind: :versions,
            package_file: metadata_package_file_for_versions,
            service_class: CreateVersionsXmlService,
            payload_empty_field: :empty_versions
          )
        end

        def update_plugins_xml
          update_xml(
            kind: :plugins,
            package_file: metadata_package_file_for_plugins,
            service_class: CreatePluginsXmlService,
            payload_empty_field: :empty_plugins
          )
        end

        def update_xml(kind:, package_file:, service_class:, payload_empty_field:)
          return error(""Metadata file for #{kind} is too big"") if package_file.size > MAX_FILE_SIZE

          package_file.file.use_open_file do |file|
            result = service_class.new(metadata_content: file, package: package_file.package)
                                  .execute

            next result unless result.success?
            next success(""No changes for #{kind} xml"") unless result.payload[:changes_exist]

            if result.payload[payload_empty_field]
              package_file.package.destroy!
              success(""Versionless package for #{kind} destroyed"")
            else
              AppendPackageFileService.new(metadata_content: result.payload[:metadata_content], package: package_file.package)
                                      .execute
            end
          end
        end

        def metadata_package_file_for_versions
          metadata_package_file_for(versionless_package_for_versions)
        end
        strong_memoize_attr :metadata_package_file_for_versions

        def versionless_package_for_versions
          versionless_package_named(package_name)
        end
        strong_memoize_attr :versionless_package_for_versions

        def metadata_package_file_for_plugins
          pkg_name = package_name_for_plugins
          return unless pkg_name

          metadata_package_file_for(versionless_package_named(package_name_for_plugins))
        end
        strong_memoize_attr :metadata_package_file_for_plugins

        def metadata_package_file_for(package)
          return unless package

          package_files = package.installable_package_files

          package_files.with_file_name(Metadata.filename)
                       .recent
                       .first
        end

        def versionless_package_named(name)
          project.packages
                 .maven
                 .displayable
                 .with_name(name)
                 .with_version(nil)
                 .first
        end

        def package_name
          params[:package_name]
        end

        def package_name_for_plugins
          return unless versionless_package_for_versions

          group = versionless_package_for_versions.maven_metadatum.app_group
          group.tr('.', '/')
        end

        def error(message)
          ServiceResponse.error(message: message)
        end

        def success(message)
          ServiceResponse.success(message: message)
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Packages::Maven::Metadata::SyncService, feature_category: :package_registry do
  using RSpec::Parameterized::TableSyntax

  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }
  let_it_be_with_reload(:versionless_package_for_versions) { create(:maven_package, name: 'test', version: nil, project: project) }
  let_it_be_with_reload(:metadata_file_for_versions) { create(:package_file, :xml, package: versionless_package_for_versions) }
  let_it_be(:package_file_pending_destruction) { create(:package_file, :pending_destruction, package: versionless_package_for_versions, file_name: Packages::Maven::Metadata.filename) }

  let(:service) { described_class.new(container: project, current_user: user, params: { package_name: versionless_package_for_versions.name }) }

  describe '#execute' do
    let(:create_versions_xml_service_double) { double(::Packages::Maven::Metadata::CreateVersionsXmlService, execute: create_versions_xml_service_response) }
    let(:append_package_file_service_double) { double(::Packages::Maven::Metadata::AppendPackageFileService, execute: append_package_file_service_response) }

    let(:create_versions_xml_service_response) { ServiceResponse.success(payload: { changes_exist: true, empty_versions: false, metadata_content: 'test' }) }
    let(:append_package_file_service_response) { ServiceResponse.success(message: 'New metadata package files created') }

    subject { service.execute }

    before do
      allow(::Packages::Maven::Metadata::CreateVersionsXmlService)
        .to receive(:new).with(metadata_content: an_instance_of(ObjectStorage::Concern::OpenFile), package: versionless_package_for_versions).and_return(create_versions_xml_service_double)
      allow(::Packages::Maven::Metadata::AppendPackageFileService)
        .to receive(:new).with(metadata_content: an_instance_of(String), package: versionless_package_for_versions).and_return(append_package_file_service_double)
    end

    context 'permissions' do
      where(:role, :expected_result) do
        :anonymous  | :rejected
        :developer  | :rejected
        :maintainer | :accepted
      end

      with_them do
        if params[:role] == :anonymous
          let_it_be(:user) { nil }
        end

        before do
          project.send(""add_#{role}"", user) unless role == :anonymous
        end

        if params[:expected_result] == :rejected
          it_behaves_like 'returning an error service response', message: 'Not allowed'
        else
          it_behaves_like 'returning a success service response', message: 'New metadata package files created'
        end
      end
    end

    context 'with a maintainer' do
      before do
        project.add_maintainer(user)
      end

      context 'with a jar package' do
        before do
          expect(::Packages::Maven::Metadata::CreatePluginsXmlService).not_to receive(:new)
        end

        context 'with no changes' do
          let(:create_versions_xml_service_response) { ServiceResponse.success(payload: { changes_exist: false }) }

          before do
            expect(::Packages::Maven::Metadata::AppendPackageFileService).not_to receive(:new)
          end

          it_behaves_like 'returning a success service response', message: 'No changes for versions xml'
        end

        context 'with changes' do
          let(:create_versions_xml_service_response) { ServiceResponse.success(payload: { changes_exist: true, empty_versions: false, metadata_content: 'new metadata' }) }

          it_behaves_like 'returning a success service response', message: 'New metadata package files created'

          context 'with empty versions' do
            let(:create_versions_xml_service_response) { ServiceResponse.success(payload: { changes_exist: true, empty_versions: true }) }

            before do
              expect(service.send(:versionless_package_for_versions)).to receive(:destroy!)
              expect(::Packages::Maven::Metadata::AppendPackageFileService).not_to receive(:new)
            end

            it_behaves_like 'returning a success service response', message: 'Versionless package for versions destroyed'
          end
        end

        context 'with a too big maven metadata file for versions' do
          before do
            metadata_file_for_versions.update!(size: 100.megabytes)
          end

          it_behaves_like 'returning an error service response', message: 'Metadata file for versions is too big'
        end

        context 'an error from the create versions xml service' do
          let(:create_versions_xml_service_response) { ServiceResponse.error(message: 'metadata_content is invalid') }

          before do
            expect(::Packages::Maven::Metadata::AppendPackageFileService).not_to receive(:new)
          end

          it_behaves_like 'returning an error service response', message: 'metadata_content is invalid'
        end

        context 'an error from the append package file service' do
          let(:append_package_file_service_response) { ServiceResponse.error(message: 'metadata content is not set') }

          it_behaves_like 'returning an error service response', message: 'metadata content is not set'
        end

        context 'without a package name' do
          let(:service) { described_class.new(container: project, current_user: user, params: { package_name: nil }) }

          before do
            expect(::Packages::Maven::Metadata::AppendPackageFileService).not_to receive(:new)
            expect(::Packages::Maven::Metadata::CreateVersionsXmlService).not_to receive(:new)
          end

          it_behaves_like 'returning an error service response', message: 'Blank package name'
        end

        context 'without a versionless package for version' do
          before do
            versionless_package_for_versions.update!(version: '2.2.2')
            expect(::Packages::Maven::Metadata::AppendPackageFileService).not_to receive(:new)
            expect(::Packages::Maven::Metadata::CreateVersionsXmlService).not_to receive(:new)
          end

          it_behaves_like 'returning a success service response', message: 'Non existing versionless package(s). Nothing to do.'
        end

        context 'without a metadata package file for versions' do
          before do
            versionless_package_for_versions.package_files.update_all(file_name: 'test.txt')
            expect(::Packages::Maven::Metadata::AppendPackageFileService).not_to receive(:new)
            expect(::Packages::Maven::Metadata::CreateVersionsXmlService).not_to receive(:new)
          end

          it_behaves_like 'returning a success service response', message: 'Non existing versionless package(s). Nothing to do.'
        end

        context 'without a project' do
          let(:service) { described_class.new(container: nil, current_user: user, params: { package_name: versionless_package_for_versions.name }) }

          before do
            expect(::Packages::Maven::Metadata::AppendPackageFileService).not_to receive(:new)
            expect(::Packages::Maven::Metadata::CreateVersionsXmlService).not_to receive(:new)
          end

          it_behaves_like 'returning an error service response', message: 'Not allowed'
        end
      end

      context 'with a maven plugin package' do
        let_it_be(:versionless_package_name_for_plugins) { versionless_package_for_versions.maven_metadatum.app_group.tr('.', '/') }
        let_it_be_with_reload(:versionless_package_for_plugins) { create(:maven_package, name: versionless_package_name_for_plugins, version: nil, project: project) }
        let_it_be_with_reload(:metadata_file_for_plugins) { create(:package_file, :xml, package: versionless_package_for_plugins) }

        let(:create_plugins_xml_service_double) { double(::Packages::Maven::Metadata::CreatePluginsXmlService, execute: create_plugins_xml_service_response) }
        let(:create_plugins_xml_service_response) { ServiceResponse.success(payload: { changes_exist: false }) }

        before do
          allow(::Packages::Maven::Metadata::CreatePluginsXmlService)
            .to receive(:new).with(metadata_content: an_instance_of(ObjectStorage::Concern::OpenFile), package: versionless_package_for_plugins).and_return(create_plugins_xml_service_double)
          allow(::Packages::Maven::Metadata::AppendPackageFileService)
            .to receive(:new).with(metadata_content: an_instance_of(String), package: versionless_package_for_plugins).and_return(append_package_file_service_double)
        end

        context 'with no changes' do
          let(:create_versions_xml_service_response) { ServiceResponse.success(payload: { changes_exist: false }) }

          before do
            expect(::Packages::Maven::Metadata::AppendPackageFileService).not_to receive(:new)
          end

          it_behaves_like 'returning a success service response', message: 'No changes for versions xml'
        end

        context 'with changes in the versions xml' do
          let(:create_versions_xml_service_response) { ServiceResponse.success(payload: { changes_exist: true, empty_versions: false, metadata_content: 'new metadata' }) }

          it_behaves_like 'returning a success service response', message: 'New metadata package files created'

          context 'with changes in the plugin xml' do
            let(:create_plugins_xml_service_response) { ServiceResponse.success(payload: { changes_exist: true, empty_plugins: false, metadata_content: 'new metadata' }) }

            it_behaves_like 'returning a success service response', message: 'New metadata package files created'
          end

          context 'with empty versions' do
            let(:create_versions_xml_service_response) { ServiceResponse.success(payload: { changes_exist: true, empty_versions: true }) }
            let(:create_plugins_xml_service_response) { ServiceResponse.success(payload: { changes_exist: true, empty_plugins: true }) }

            before do
              expect(service.send(:versionless_package_for_versions)).to receive(:destroy!)
              expect(service.send(:metadata_package_file_for_plugins).package).to receive(:destroy!)
              expect(::Packages::Maven::Metadata::AppendPackageFileService).not_to receive(:new)
            end

            it_behaves_like 'returning a success service response', message: 'Versionless package for versions destroyed'
          end

          context 'with a too big maven metadata file for plugins' do
            before do
              metadata_file_for_plugins.update!(size: 100.megabytes)
            end

            it_behaves_like 'returning an error service response', message: 'Metadata file for plugins is too big'
          end

          context 'an error from the create versions xml service' do
            let(:create_plugins_xml_service_response) { ServiceResponse.error(message: 'metadata_content is invalid') }

            before do
              expect(::Packages::Maven::Metadata::CreateVersionsXmlService).not_to receive(:new)
              expect(::Packages::Maven::Metadata::AppendPackageFileService).not_to receive(:new)
            end

            it_behaves_like 'returning an error service response', message: 'metadata_content is invalid'
          end

          context 'an error from the append package file service' do
            let(:create_plugins_xml_service_response) { ServiceResponse.success(payload: { changes_exist: true, empty_plugins: false, metadata_content: 'new metadata' }) }
            let(:append_package_file_service_response) { ServiceResponse.error(message: 'metadata content is not set') }

            before do
              expect(::Packages::Maven::Metadata::CreateVersionsXmlService).not_to receive(:new)
            end

            it_behaves_like 'returning an error service response', message: 'metadata content is not set'
          end

          context 'without a versionless package for plugins' do
            before do
              versionless_package_for_plugins.package_files.update_all(file_name: 'test.txt')
              expect(::Packages::Maven::Metadata::CreatePluginsXmlService).not_to receive(:new)
            end

            it_behaves_like 'returning a success service response', message: 'New metadata package files created'
          end

          context 'without a versionless package for versions' do
            before do
              versionless_package_for_versions.package_files.update_all(file_name: 'test.txt')
              expect(::Packages::Maven::Metadata::CreateVersionsXmlService).not_to receive(:new)
            end

            it_behaves_like 'returning a success service response', message: 'No changes for plugins xml'
          end

          context 'without a metadata package file for plugins' do
            before do
              versionless_package_for_plugins.package_files.update_all(file_name: 'test.txt')
              expect(::Packages::Maven::Metadata::CreatePluginsXmlService).not_to receive(:new)
            end

            it_behaves_like 'returning a success service response', message: 'New metadata package files created'
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Maven
    module Metadata
      class CreateVersionsXmlService < BaseCreateXmlService
        XPATH_VERSIONING = '//metadata/versioning'
        XPATH_VERSIONS = '//versions'
        XPATH_VERSION = '//version'
        XPATH_LATEST = '//latest'
        XPATH_RELEASE = '//release'
        XPATH_LAST_UPDATED = '//lastUpdated'

        EMPTY_VERSIONS_PAYLOAD = {
          changes_exist: true,
          empty_versions: true
        }.freeze

        def execute
          return ServiceResponse.error(message: 'package not set') unless @package
          return ServiceResponse.error(message: 'metadata_content not set') unless @metadata_content
          return ServiceResponse.error(message: 'metadata_content is invalid') unless valid_metadata_content?
          return ServiceResponse.success(payload: EMPTY_VERSIONS_PAYLOAD) if versions_from_database.empty?

          changes_exist = false
          changes_exist = true if update_versions_list
          changes_exist = true if update_latest
          changes_exist = true if update_release
          update_last_updated_timestamp if changes_exist

          payload = { changes_exist: changes_exist, empty_versions: false }
          payload[:metadata_content] = xml_doc.to_xml(indent: INDENT_SPACE) if changes_exist

          ServiceResponse.success(payload: payload)
        end

        private

        def valid_metadata_content?
          versioning_xml_node.present? &&
            versions_xml_node.present? &&
            last_updated_xml_node.present?
        end

        def update_versions_list
          return false if versions_from_xml == versions_from_database

          version_xml_nodes.remove

          versions_from_database.each do |version|
            versions_xml_node.add_child(xml_node('version', version))
          end
          true
        end

        def update_latest
          return false if latest_coherent?

          latest_xml_node.content = latest_from_database
          true
        end

        def latest_coherent?
          latest_from_xml.nil? || latest_from_xml == latest_from_database
        end

        def update_release
          return false if release_coherent?

          unless release_xml_node.present?
            log_malformed_content('Missing release tag')

            return false
          end

          if release_from_database
            release_xml_node.content = release_from_database
          else
            release_xml_node.remove
          end

          true
        end

        def release_coherent?
          release_from_xml == release_from_database
        end

        def update_last_updated_timestamp
          last_updated_xml_node.content = Time.zone.now.strftime('%Y%m%d%H%M%S')
        end

        def versioning_xml_node
          xml_doc.xpath(XPATH_VERSIONING).first
        end
        strong_memoize_attr :versioning_xml_node

        def versions_xml_node
          versioning_xml_node&.xpath(XPATH_VERSIONS)
                               &.first
        end
        strong_memoize_attr :versions_xml_node

        def version_xml_nodes
          versions_xml_node&.xpath(XPATH_VERSION)
        end

        def latest_xml_node
          versioning_xml_node&.xpath(XPATH_LATEST)
                               &.first
        end
        strong_memoize_attr :latest_xml_node

        def release_xml_node
          versioning_xml_node&.xpath(XPATH_RELEASE)
                               &.first
        end
        strong_memoize_attr :release_xml_node

        def last_updated_xml_node
          versioning_xml_node.xpath(XPATH_LAST_UPDATED)
                               .first
        end
        strong_memoize_attr :last_updated_xml_node

        def versions_from_xml
          versions_xml_node.xpath(XPATH_VERSION)
                             .map(&:text)
        end
        strong_memoize_attr :versions_from_xml

        def latest_from_xml
          latest_xml_node&.text
        end

        def release_from_xml
          release_xml_node&.text
        end

        def versions_from_database
          @package.project.packages
                            .maven
                            .displayable
                            .with_name(@package.name)
                            .has_version
                            .order_created
                            .pluck_versions
        end
        strong_memoize_attr :versions_from_database

        def latest_from_database
          versions_from_database.last
        end

        def release_from_database
          non_snapshot_versions_from_database = versions_from_database.reject { |v| v.ends_with?('SNAPSHOT') }
          non_snapshot_versions_from_database.last
        end
        strong_memoize_attr :release_from_database

        def log_malformed_content(reason)
          logger.warn(
            message: 'A malformed metadata file has been encountered',
            reason: reason,
            project_id: @package.project_id,
            package_id: @package.id
          )
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Packages::Maven::Metadata::CreateVersionsXmlService, feature_category: :package_registry do
  let_it_be(:package) { create(:maven_package, version: nil) }

  let(:versions_in_database) { %w[1.3 2.0-SNAPSHOT 1.6 1.4 1.5-SNAPSHOT] }
  let(:versions_in_xml) { %w[1.3 2.0-SNAPSHOT 1.6 1.4 1.5-SNAPSHOT] }
  let(:version_latest) { nil }
  let(:version_release) { '1.4' }
  let(:service) { described_class.new(metadata_content: metadata_xml, package: package) }

  describe '#execute' do
    subject { service.execute }

    before do
      next unless package

      versions_in_database.each do |version|
        create(:maven_package, name: package.name, version: version, project: package.project)
      end
    end

    shared_examples 'returning an xml with versions in the database' do
      it 'returns an metadata versions xml with versions in the database', :aggregate_failures do
        result = subject

        expect(result).to be_success
        expect(versions_from(result.payload[:metadata_content])).to match_array(versions_in_database)
      end
    end

    shared_examples 'returning an xml with' do |release:, latest:|
      it 'returns an xml with the updated release and latest versions', :aggregate_failures do
        result = subject

        expect(result).to be_success
        expect(result.payload[:changes_exist]).to be_truthy
        xml = result.payload[:metadata_content]
        expect(release_from(xml)).to eq(release)
        expect(latest_from(xml)).to eq(latest)
      end
    end

    context 'with same versions in both sides' do
      it 'returns no changes', :aggregate_failures do
        result = subject

        expect(result).to be_success
        expect(result.payload).to eq(changes_exist: false, empty_versions: false)
      end
    end

    context 'with more versions' do
      let(:additional_versions) { %w[5.5 5.6 5.7-SNAPSHOT] }

      context 'in the xml side' do
        let(:versions_in_xml) { versions_in_database + additional_versions }

        it_behaves_like 'returning an xml with versions in the database'
      end

      context 'in the database side' do
        let(:versions_in_database) { versions_in_xml + additional_versions }

        it_behaves_like 'returning an xml with versions in the database'

        context 'with an xml without a release version' do
          let(:version_release) { nil }

          it_behaves_like 'returning an xml with versions in the database'

          it 'logs a warn with the reason' do
            expect(Gitlab::AppJsonLogger).to receive(:warn).with(
              message: 'A malformed metadata file has been encountered',
              reason: 'Missing release tag',
              project_id: package.project_id,
              package_id: package.id
            )

            subject
          end
        end
      end
    end

    context 'with completely different versions' do
      let(:versions_in_database) { %w[1.0 1.1 1.2] }
      let(:versions_in_xml) { %w[2.0 2.1 2.2] }

      it_behaves_like 'returning an xml with versions in the database'
    end

    context 'with no versions in the database' do
      let(:versions_in_database) { [] }

      it 'returns a success', :aggregate_failures do
        result = subject

        expect(result).to be_success
        expect(result.payload).to eq(changes_exist: true, empty_versions: true)
      end

      context 'with an xml without a release version' do
        let(:version_release) { nil }

        it 'returns a success', :aggregate_failures do
          result = subject

          expect(result).to be_success
          expect(result.payload).to eq(changes_exist: true, empty_versions: true)
        end
      end
    end

    context 'with differences in both sides' do
      let(:shared_versions) { %w[1.3 2.0-SNAPSHOT 1.6 1.4 1.5-SNAPSHOT] }
      let(:additional_versions_in_xml) { %w[5.5 5.6 5.7-SNAPSHOT] }
      let(:versions_in_xml) { shared_versions + additional_versions_in_xml }
      let(:additional_versions_in_database) { %w[6.5 6.6 6.7-SNAPSHOT] }
      let(:versions_in_database) { shared_versions + additional_versions_in_database }

      it_behaves_like 'returning an xml with versions in the database'
    end

    context 'with a new release and latest from the database' do
      let(:versions_in_database) { versions_in_xml + %w[4.1 4.2-SNAPSHOT] }

      it_behaves_like 'returning an xml with', release: '4.1', latest: nil

      context 'with a latest in the xml' do
        let(:version_latest) { '1.6' }

        it_behaves_like 'returning an xml with', release: '4.1', latest: '4.2-SNAPSHOT'
      end
    end

    context 'with release and latest not existing in the database' do
      let(:version_release) { '7.0' }
      let(:version_latest) { '8.0-SNAPSHOT' }

      it_behaves_like 'returning an xml with', release: '1.4', latest: '1.5-SNAPSHOT'
    end

    context 'with added versions in the database side no more recent than release' do
      let(:versions_in_database) { versions_in_xml + %w[4.1 4.2-SNAPSHOT] }

      before do
        ::Packages::Package.find_by(name: package.name, version: '4.1').update!(created_at: 2.weeks.ago)
        ::Packages::Package.find_by(name: package.name, version: '4.2-SNAPSHOT').update!(created_at: 2.weeks.ago)
      end

      it_behaves_like 'returning an xml with', release: '1.4', latest: nil

      context 'with a latest in the xml' do
        let(:version_latest) { '1.6' }

        it_behaves_like 'returning an xml with', release: '1.4', latest: '1.5-SNAPSHOT'
      end
    end

    context 'only snapshot versions are in the database' do
      let(:versions_in_database) { %w[4.2-SNAPSHOT] }

      it_behaves_like 'returning an xml with', release: nil, latest: nil

      it 'returns an xml without any release element' do
        result = subject

        xml_doc = Nokogiri::XML(result.payload[:metadata_content])
        expect(xml_doc.xpath('//metadata/versioning/release')).to be_empty
      end
    end

    context 'last updated timestamp' do
      let(:versions_in_database) { versions_in_xml + %w[4.1 4.2-SNAPSHOT] }

      it 'updates the last updated timestamp' do
        original = last_updated_from(metadata_xml)

        result = subject

        expect(result).to be_success
        expect(original).not_to eq(last_updated_from(result.payload[:metadata_content]))
      end
    end

    context 'with an incomplete metadata content' do
      let(:metadata_xml) { '<metadata></metadata>' }

      it_behaves_like 'returning an error service response', message: 'metadata_content is invalid'
    end

    context 'with an invalid metadata content' do
      let(:metadata_xml) { '<meta></metadata>' }

      it_behaves_like 'returning an error service response', message: 'metadata_content is invalid'
    end

    it_behaves_like 'handling metadata content pointing to a file for the create xml service'

    it_behaves_like 'handling invalid parameters for create xml service'
  end

  def metadata_xml
    Nokogiri::XML::Builder.new do |xml|
      xml.metadata do
        xml.groupId(package.maven_metadatum.app_group)
        xml.artifactId(package.maven_metadatum.app_name)
        xml.versioning do
          xml.release(version_release) if version_release
          xml.latest(version_latest) if version_latest
          xml.lastUpdated('20210113130531')
          xml.versions do
            versions_in_xml.each do |version|
              xml.version(version)
            end
          end
        end
      end
    end.to_xml
  end

  def versions_from(xml_content)
    doc = Nokogiri::XML(xml_content)
    doc.xpath('//metadata/versioning/versions/version').map(&:content)
  end

  def release_from(xml_content)
    doc = Nokogiri::XML(xml_content)
    doc.xpath('//metadata/versioning/release').first&.content
  end

  def latest_from(xml_content)
    doc = Nokogiri::XML(xml_content)
    doc.xpath('//metadata/versioning/latest').first&.content
  end

  def last_updated_from(xml_content)
    doc = Nokogiri::XML(xml_content)
    doc.xpath('//metadata/versioning/lastUpdated').first.content
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Composer
    class ComposerJsonService
      InvalidJson = Class.new(StandardError)

      def initialize(project, target)
        @project = project
        @target = target
      end

      def execute
        composer_json
      end

      private

      def composer_json
        composer_file = @project.repository.blob_at(@target, 'composer.json')

        composer_file_not_found! unless composer_file

        Gitlab::Json.parse(composer_file.data)
      rescue JSON::ParserError
        raise InvalidJson, 'Could not parse composer.json file. Invalid JSON.'
      end

      def composer_file_not_found!
        raise InvalidJson, 'The file composer.json was not found.'
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::Composer::ComposerJsonService, feature_category: :package_registry do
  describe '#execute' do
    let(:branch) { project.repository.find_branch('master') }
    let(:target) { branch.target }

    subject { described_class.new(project, target).execute }

    context 'with an existing file' do
      let(:project) { create(:project, :custom_repo, files: { 'composer.json' => json }) }

      context 'with a valid file' do
        let(:json) { '{ ""name"": ""package-name""}' }

        it 'returns the parsed json' do
          expect(subject).to eq({ 'name' => 'package-name' })
        end
      end

      context 'with an invalid file' do
        let(:json) { '{ name"": ""package-name""}' }

        it 'raises an error' do
          expect { subject }.to raise_error(described_class::InvalidJson, /Invalid/)
        end
      end
    end

    context 'without the composer.json file' do
      let(:project) { create(:project, :repository) }

      it 'raises an error' do
        expect { subject }.to raise_error(described_class::InvalidJson, /not found/)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Composer
    class CreatePackageService < ::Packages::CreatePackageService
      include ::Gitlab::Utils::StrongMemoize

      def execute
        # fetches json outside of transaction
        composer_json

        ::Packages::Package.transaction do
          ::Packages::Composer::Metadatum.upsert({
            package_id: created_package.id,
            target_sha: target,
            composer_json: composer_json
          })
        end

        created_package
      end

      private

      def created_package
        find_or_create_package!(:composer, name: package_name, version: package_version)
      end

      def composer_json
        ::Packages::Composer::ComposerJsonService.new(project, target).execute
      end
      strong_memoize_attr :composer_json

      def package_name
        composer_json['name']
      end

      def target
        (branch || tag).target
      end

      def branch
        params[:branch]
      end

      def tag
        params[:tag]
      end

      def package_version
        ::Packages::Composer::VersionParserService.new(tag_name: tag&.name, branch_name: branch&.name).execute
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::Composer::CreatePackageService, feature_category: :package_registry do
  include PackagesManagerApiSpecHelpers

  let_it_be(:package_name) { 'composer-package-name' }
  let_it_be(:json) { { name: package_name }.to_json }
  let_it_be(:project) { create(:project, :custom_repo, files: { 'composer.json' => json }) }
  let_it_be(:user) { create(:user) }

  let(:params) do
    {
      branch: branch,
      tag: tag
    }
  end

  describe '#execute' do
    let(:tag) { nil }
    let(:branch) { nil }

    subject { described_class.new(project, user, params).execute }

    let(:created_package) { Packages::Package.composer.last }

    context 'without an existing package' do
      context 'with a branch' do
        let(:branch) { project.repository.find_branch('master') }

        it 'creates the package' do
          expect { subject }
            .to change { Packages::Package.composer.count }.by(1)
            .and change { Packages::Composer::Metadatum.count }.by(1)

          expect(created_package.name).to eq package_name
          expect(created_package.version).to eq 'dev-master'
          expect(created_package.composer_metadatum.target_sha).to eq branch.target
          expect(created_package.composer_metadatum.composer_json.to_json).to eq json
        end

        it_behaves_like 'assigns the package creator' do
          let(:package) { created_package }
        end

        it_behaves_like 'assigns build to package'
        it_behaves_like 'assigns status to package'
      end

      context 'with a tag' do
        let(:tag) { project.repository.find_tag('v1.2.3') }

        before_all do
          project.repository.add_tag(user, 'v1.2.3', 'master')
        end

        it 'creates the package' do
          expect { subject }
            .to change { Packages::Package.composer.count }.by(1)
            .and change { Packages::Composer::Metadatum.count }.by(1)

          expect(created_package.name).to eq package_name
          expect(created_package.version).to eq '1.2.3'
        end

        it_behaves_like 'assigns the package creator' do
          let(:package) { created_package }
        end

        it_behaves_like 'assigns build to package'
        it_behaves_like 'assigns status to package'
      end
    end

    context 'with an existing package' do
      let(:branch) { project.repository.find_branch('master') }

      context 'belonging to the same project' do
        before do
          described_class.new(project, user, params).execute
        end

        it 'does not create a new package' do
          expect { subject }
            .to change { Packages::Package.composer.count }.by(0)
            .and change { Packages::Composer::Metadatum.count }.by(0)
        end
      end

      context 'belonging to another project' do
        let(:other_project) { create(:project) }
        let!(:other_package) { create(:composer_package, name: package_name, version: 'dev-master', project: other_project) }

        it 'fails with an error' do
          expect { subject }
            .to raise_error(/is already taken/)
        end

        context 'with pending_destruction package' do
          let!(:other_package) { create(:composer_package, :pending_destruction, name: package_name, version: 'dev-master', project: other_project) }

          it 'creates the package' do
            expect { subject }
              .to change { Packages::Package.composer.count }.by(1)
              .and change { Packages::Composer::Metadatum.count }.by(1)
          end
        end
      end

      context 'same name but of different type' do
        let(:other_project) { create(:project) }
        let!(:other_package) { create(:package, name: package_name, version: 'dev-master', project: other_project) }

        it 'creates the package' do
          expect { subject }
            .to change { Packages::Package.composer.count }.by(1)
            .and change { Packages::Composer::Metadatum.count }.by(1)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Composer
    class VersionParserService
      def initialize(tag_name: nil, branch_name: nil)
        @tag_name = tag_name
        @branch_name = branch_name
      end

      def execute
        if @tag_name.present?
          @tag_name.delete_prefix('v')
        elsif @branch_name.present?
          branch_suffix_or_prefix(@branch_name.match(Gitlab::Regex.composer_package_version_regex))
        end
      end

      private

      def branch_suffix_or_prefix(match)
        if match
          captures = match.captures.reject(&:blank?)
          if captures[-1] == '.x'
            captures[0] + '-dev'
          else
            captures[0] + '.x-dev'
          end
        else
          ""dev-#{@branch_name}""
        end
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::Composer::VersionParserService, feature_category: :package_registry do
  let_it_be(:params) { {} }

  describe '#execute' do
    using RSpec::Parameterized::TableSyntax

    subject { described_class.new(tag_name: tagname, branch_name: branchname).execute }

    where(:tagname, :branchname, :expected_version) do
      nil             | 'master'     | 'dev-master'
      nil             | 'my-feature' | 'dev-my-feature'
      nil             | '12-feature' | 'dev-12-feature'
      nil             | 'v1'         | '1.x-dev'
      nil             | 'v1.x'       | '1.x-dev'
      nil             | 'v1.7.x'     | '1.7.x-dev'
      nil             | 'v1.7'       | '1.7.x-dev'
      nil             | '1.7.x'      | '1.7.x-dev'
      'v1.0.0'        | nil          | '1.0.0'
      'v1.0'          | nil          | '1.0'
      'v1.0.1+meta'   | nil          | '1.0.1+meta'
      '1.0'           | nil          | '1.0'
      '1.0.2'         | nil          | '1.0.2'
      '1.0.2-beta2'   | nil          | '1.0.2-beta2'
      '1.0.1+meta'    | nil          | '1.0.1+meta'
    end

    with_them do
      it { is_expected.to eq expected_version }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Rubygems
    class DependencyResolverService < BaseService
      include Gitlab::Utils::StrongMemoize

      DEFAULT_PLATFORM = 'ruby'

      def execute
        unless Ability.allowed?(current_user, :read_package, project&.packages_policy_subject)
          return ServiceResponse.error(message: ""forbidden"", http_status: :forbidden)
        end

        return ServiceResponse.error(message: ""#{gem_name} not found"", http_status: :not_found) if packages.empty?

        payload = packages.map do |package|
          dependencies = package.dependency_links.map do |link|
            [link.dependency.name, link.dependency.version_pattern]
          end

          {
            name: gem_name,
            number: package.version,
            platform: DEFAULT_PLATFORM,
            dependencies: dependencies
          }
        end

        ServiceResponse.success(payload: payload)
      end

      private

      def packages
        project.packages.with_name(gem_name)
      end
      strong_memoize_attr :packages

      def gem_name
        params[:gem_name]
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::Rubygems::DependencyResolverService, feature_category: :package_registry do
  let_it_be(:project) { create(:project, :private) }
  let_it_be(:package) { create(:package, project: project) }
  let_it_be(:user) { create(:user) }

  let(:gem_name) { package.name }
  let(:service) { described_class.new(project, user, gem_name: gem_name) }

  describe '#execute' do
    subject { service.execute }

    context 'user without access' do
      it 'returns a service error' do
        expect(subject.error?).to be(true)
        expect(subject.message).to eq('forbidden')
      end
    end

    context 'user with access' do
      before do
        project.add_developer(user)
      end

      context 'when no package is found' do
        let(:gem_name) { nil }

        it 'returns a service error', :aggregate_failures do
          expect(subject.error?).to be(true)
          expect(subject.message).to eq(""#{gem_name} not found"")
        end
      end

      context 'package without dependencies' do
        it 'returns an empty dependencies array' do
          expected_result = [{
            name: package.name,
            number: package.version,
            platform: described_class::DEFAULT_PLATFORM,
            dependencies: []
          }]

          expect(subject.payload).to eq(expected_result)
        end
      end

      context 'package with dependencies' do
        let(:dependency_link) { create(:packages_dependency_link, :rubygems, package: package) }
        let(:dependency_link2) { create(:packages_dependency_link, :rubygems, package: package) }
        let(:dependency_link3) { create(:packages_dependency_link, :rubygems, package: package) }

        it 'returns a set of dependencies' do
          expected_result = [{
            name: package.name,
            number: package.version,
            platform: described_class::DEFAULT_PLATFORM,
            dependencies: [
              [dependency_link.dependency.name, dependency_link.dependency.version_pattern],
              [dependency_link2.dependency.name, dependency_link2.dependency.version_pattern],
              [dependency_link3.dependency.name, dependency_link3.dependency.version_pattern]
            ]
          }]

          expect(subject.payload).to eq(expected_result)
        end
      end

      context 'package with multiple versions' do
        let(:dependency_link) { create(:packages_dependency_link, :rubygems, package: package) }
        let(:dependency_link2) { create(:packages_dependency_link, :rubygems, package: package) }
        let(:dependency_link3) { create(:packages_dependency_link, :rubygems, package: package) }
        let(:package2) { create(:package, project: project, name: package.name, version: '9.9.9') }
        let(:dependency_link4) { create(:packages_dependency_link, :rubygems, package: package2) }

        it 'returns a set of dependencies' do
          expected_result = [{
            name: package.name,
            number: package.version,
            platform: described_class::DEFAULT_PLATFORM,
            dependencies: [
              [dependency_link.dependency.name, dependency_link.dependency.version_pattern],
              [dependency_link2.dependency.name, dependency_link2.dependency.version_pattern],
              [dependency_link3.dependency.name, dependency_link3.dependency.version_pattern]
            ]
          }, {
            name: package2.name,
            number: package2.version,
            platform: described_class::DEFAULT_PLATFORM,
            dependencies: [
              [dependency_link4.dependency.name, dependency_link4.dependency.version_pattern]
            ]
          }]

          expect(subject.payload).to match_array(expected_result)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

require 'rubygems/package'

module Packages
  module Rubygems
    class ProcessGemService
      include Gitlab::Utils::StrongMemoize
      include ExclusiveLeaseGuard

      ExtractionError = Class.new(StandardError)
      InvalidMetadataError = Class.new(StandardError)

      DEFAULT_LEASE_TIMEOUT = 1.hour.to_i.freeze

      def initialize(package_file)
        @package_file = package_file
      end

      def execute
        raise ExtractionError, 'Gem was not processed - package_file is not set' unless package_file
        return success if process_gem

        error('Gem was not processed')
      rescue ActiveRecord::StatementInvalid
        # TODO: We can remove this rescue block when we fix https://gitlab.com/gitlab-org/gitlab/-/issues/415899
        raise InvalidMetadataError, 'Invalid metadata'
      end

      private

      attr_reader :package_file

      def process_gem
        try_obtain_lease do
          package.transaction do
            rename_package_and_set_version
            rename_package_file
            ::Packages::Rubygems::MetadataExtractionService.new(package, gemspec).execute
            ::Packages::Rubygems::CreateGemspecService.new(package, gemspec).execute
            ::Packages::Rubygems::CreateDependenciesService.new(package, gemspec).execute
            cleanup_temp_package
          end
        end

        true
      end

      def rename_package_and_set_version
        package.update!(
          name: gemspec.name,
          version: gemspec.version,
          status: :default
        )
      end

      def rename_package_file
        # Updating file_name updates the path where the file is stored.
        # We must pass the file again so that CarrierWave can handle the update
        package_file.update!(
          file_name: ""#{gemspec.name}-#{gemspec.version}.gem"",
          file: package_file.file,
          package_id: package.id
        )
      end

      def cleanup_temp_package
        temp_package.destroy if package.id != temp_package.id
      end

      def gemspec
        gem.spec
      end
      strong_memoize_attr :gemspec

      def success
        ServiceResponse.success(payload: { package: package })
      end

      def error(message)
        ServiceResponse.error(message: message)
      end

      def temp_package
        package_file.package
      end
      strong_memoize_attr :temp_package

      def package
        package = temp_package.project
                                .packages
                                .rubygems
                                .with_name(gemspec.name)
                                .with_version(gemspec.version.to_s)
                                .not_pending_destruction
                                .last
        package || temp_package
      end
      strong_memoize_attr :package

      def gem
        # use_file will set an exclusive lease on the file for as long as
        # the resulting gem object is being used. This means we are not
        # able to rename the package_file while also using the gem object.
        # We need to use a separate AR object to create the gem file to allow
        # `package_file` to be free for update so we re-find the file here.
        Packages::PackageFile.find(package_file.id).file.use_file do |file_path|
          Gem::Package.new(File.open(file_path))
        end
      rescue StandardError
        raise ExtractionError, 'Unable to read gem file'
      end

      # used by ExclusiveLeaseGuard
      def lease_key
        ""packages:rubygems:process_gem_service:package:#{package.id}""
      end

      # used by ExclusiveLeaseGuard
      def lease_timeout
        DEFAULT_LEASE_TIMEOUT
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Rubygems::ProcessGemService, feature_category: :package_registry do
  include ExclusiveLeaseHelpers
  include RubygemsHelpers

  let_it_be_with_reload(:package) { create(:rubygems_package, :processing, name: 'temp_name', version: '0.0.0') }

  let(:package_file) { create(:package_file, :unprocessed_gem, package: package) }
  let(:gem) { gem_from_file(package_file.file) }
  let(:gemspec) { gem.spec }
  let(:service) { described_class.new(package_file) }

  describe '#execute' do
    subject { service.execute }

    context 'no gem file' do
      let(:package_file) { nil }

      it 'returns an error' do
        expect { subject }.to raise_error(::Packages::Rubygems::ProcessGemService::ExtractionError, 'Gem was not processed - package_file is not set')
      end
    end

    context 'success' do
      let(:sub_service) { double }

      before do
        expect(Packages::Rubygems::MetadataExtractionService).to receive(:new).with(package, gemspec).and_return(sub_service)
        expect(Packages::Rubygems::CreateGemspecService).to receive(:new).with(package, gemspec).and_return(sub_service)
        expect(Packages::Rubygems::CreateDependenciesService).to receive(:new).with(package, gemspec).and_return(sub_service)

        expect(sub_service).to receive(:execute).exactly(3).times.and_return(true)
      end

      it 'returns successfully', :aggregate_failures do
        result = subject

        expect(result.success?).to be true
        expect(result.payload[:package]).to eq(package)
      end

      it 'updates the package name and version', :aggregate_failures do
        expect(package.name).to eq('temp_name')
        expect(package.version).to eq('0.0.0')
        expect(package).to be_processing

        subject

        expect(package.reload.name).to eq('package')
        expect(package.version).to eq('0.0.1')
        expect(package).to be_default
      end

      it 'updates the package file name', :aggregate_failures do
        expect(package_file.file_name).to eq('package.gem')

        subject

        expect(package_file.reload.file_name).to eq('package-0.0.1.gem')
      end
    end

    context 'when the package already exists' do
      let_it_be(:existing_package) { create(:rubygems_package, name: 'package', version: '0.0.1', project: package.project) }

      let(:sub_service) { double }

      before do
        expect(Packages::Rubygems::MetadataExtractionService).to receive(:new).with(existing_package, gemspec).and_return(sub_service)
        expect(Packages::Rubygems::CreateGemspecService).to receive(:new).with(existing_package, gemspec).and_return(sub_service)
        expect(Packages::Rubygems::CreateDependenciesService).to receive(:new).with(existing_package, gemspec).and_return(sub_service)

        expect(sub_service).to receive(:execute).exactly(3).times.and_return(true)
      end

      it 'assigns the package_file to the existing package and deletes the temporary package', :aggregate_failures do
        expect(package).to receive(:destroy)

        expect { subject }.to change { existing_package.package_files.count }.by(1)

        expect(package_file.reload.package).to eq(existing_package)
      end
    end

    context 'when the package already exists marked as pending_destruction' do
      let_it_be_with_reload(:existing_package) { create(:rubygems_package, name: 'package', version: '0.0.1', project: package.project) }

      let(:sub_service) { double }

      before do
        expect(Packages::Rubygems::MetadataExtractionService).to receive(:new).with(package, gemspec).and_return(sub_service)
        expect(Packages::Rubygems::CreateGemspecService).to receive(:new).with(package, gemspec).and_return(sub_service)
        expect(Packages::Rubygems::CreateDependenciesService).to receive(:new).with(package, gemspec).and_return(sub_service)

        expect(sub_service).to receive(:execute).exactly(3).times.and_return(true)

        existing_package.pending_destruction!
      end

      it 'reuses the processing package' do
        expect { subject }
          .to not_change { package.project.packages.count }
          .and not_change { existing_package.package_files.count }
      end
    end

    context 'sub-service failure' do
      before do
        expect(Packages::Rubygems::MetadataExtractionService).to receive(:new).with(package, gemspec).and_raise(::Packages::Rubygems::ProcessGemService::ExtractionError.new('failure'))
      end

      it 'returns an error' do
        expect { subject }.to raise_error(::Packages::Rubygems::ProcessGemService::ExtractionError, 'failure')
      end
    end

    context 'bad gem file' do
      before do
        expect(Gem::Package).to receive(:new).and_raise(ArgumentError)
      end

      it 'returns an error' do
        expect { subject }.to raise_error(::Packages::Rubygems::ProcessGemService::ExtractionError, 'Unable to read gem file')
      end
    end

    context 'without obtaining an exclusive lease' do
      let(:lease_key) { ""packages:rubygems:process_gem_service:package:#{package.id}"" }

      before do
        stub_exclusive_lease_taken(lease_key, timeout: 1.hour)
      end

      it 'does not perform the services', :aggregate_failures do
        # The #use_file call triggers a separate lease on the package file being opened
        # for use with the gem. We don't want to test that here, so we allow the call to proceed
        expect(Gitlab::ExclusiveLease).to receive(:new).with(""object_storage_migrate:Packages::PackageFile:#{package_file.id}"", anything).and_call_original

        expect(Packages::Rubygems::MetadataExtractionService).not_to receive(:new)
        expect(Packages::Rubygems::CreateGemspecService).not_to receive(:new)
        expect(Packages::Rubygems::CreateDependenciesService).not_to receive(:new)

        subject

        expect(package.reload.name).to eq('temp_name')
        expect(package.version).to eq('0.0.0')
        expect(package).to be_processing
        expect(package_file.reload.file_name).to eq('package.gem')
      end
    end

    context 'with invalid metadata' do
      include_context 'with invalid Rubygems metadata'

      it 'raises the correct error' do
        expect { subject }
          .to raise_error(::Packages::Rubygems::ProcessGemService::InvalidMetadataError, 'Invalid metadata')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Rubygems
    class MetadataExtractionService
      def initialize(package, gemspec)
        @package = package
        @gemspec = gemspec
      end

      def execute
        write_metadata
      end

      private

      attr_reader :package, :gemspec

      # rubocop:disable Metrics/AbcSize
      # rubocop:disable Metrics/PerceivedComplexity
      # rubocop:disable Metrics/CyclomaticComplexity
      def write_metadata
        metadatum.update!(
          authors: gemspec&.authors,
          files: gemspec&.files&.to_json,
          summary: gemspec&.summary,
          description: gemspec&.description,
          email: gemspec&.email,
          homepage: gemspec&.homepage,
          licenses: gemspec&.licenses&.to_json,
          metadata: gemspec&.metadata&.to_json,
          author: gemspec&.author,
          bindir: gemspec&.bindir,
          executables: gemspec&.executables&.to_json,
          extensions: gemspec&.extensions&.to_json,
          extra_rdoc_files: gemspec&.extra_rdoc_files&.to_json,
          platform: gemspec&.platform,
          post_install_message: gemspec&.post_install_message,
          rdoc_options: gemspec&.rdoc_options&.to_json,
          require_paths: gemspec&.require_paths&.to_json,
          required_ruby_version: gemspec&.required_ruby_version&.to_s,
          required_rubygems_version: gemspec&.required_rubygems_version&.to_s,
          requirements: gemspec&.requirements&.to_json,
          rubygems_version: gemspec&.rubygems_version
        )
      end
      # rubocop:enable Metrics/AbcSize
      # rubocop:enable Metrics/PerceivedComplexity
      # rubocop:enable Metrics/CyclomaticComplexity

      def metadatum
        # safe_find_or_create_by! was originally called here.
        # We merely switched to `find_or_create_by!`
        # rubocop: disable CodeReuse/ActiveRecord
        Packages::Rubygems::Metadatum.find_or_create_by!(package: package)
        # rubocop: enable CodeReuse/ActiveRecord
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'
require 'rubygems/package'

RSpec.describe Packages::Rubygems::MetadataExtractionService, feature_category: :package_registry do
  include RubygemsHelpers

  let_it_be(:package) { create(:rubygems_package) }
  let_it_be(:package_file) { create(:package_file, :gem) }
  let_it_be(:gem) { gem_from_file(package_file.file) }
  let_it_be(:gemspec) { gem.spec }

  let(:service) { described_class.new(package, gemspec) }

  describe '#execute' do
    subject { service.execute }

    it 'creates the metadata' do
      expect { subject }.to change { Packages::Rubygems::Metadatum.count }.by(1)
    end

    it 'stores the metadata', :aggregate_failures do
      subject

      metadata = package.rubygems_metadatum

      expect(metadata.authors).to eq(gemspec.authors.to_json)
      expect(metadata.files).to eq(gemspec.files.to_json)
      expect(metadata.summary).to eq(gemspec.summary)
      expect(metadata.description).to eq(gemspec.description)
      expect(metadata.email).to eq(gemspec.email)
      expect(metadata.homepage).to eq(gemspec.homepage)
      expect(metadata.licenses).to eq(gemspec.licenses.to_json)
      expect(metadata.metadata).to eq(gemspec.metadata.to_json)
      expect(metadata.author).to eq(gemspec.author)
      expect(metadata.bindir).to eq(gemspec.bindir)
      expect(metadata.executables).to eq(gemspec.executables.to_json)
      expect(metadata.extensions).to eq(gemspec.extensions.to_json)
      expect(metadata.extra_rdoc_files).to eq(gemspec.extra_rdoc_files.to_json)
      expect(metadata.platform).to eq(gemspec.platform)
      expect(metadata.post_install_message).to eq(gemspec.post_install_message)
      expect(metadata.rdoc_options).to eq(gemspec.rdoc_options.to_json)
      expect(metadata.require_paths).to eq(gemspec.require_paths.to_json)
      expect(metadata.required_ruby_version).to eq(gemspec.required_ruby_version.to_s)
      expect(metadata.required_rubygems_version).to eq(gemspec.required_rubygems_version.to_s)
      expect(metadata.requirements).to eq(gemspec.requirements.to_json)
      expect(metadata.rubygems_version).to eq(gemspec.rubygems_version)
    end

    context 'with an existing metadatum' do
      let_it_be(:metadatum) { create(:rubygems_metadatum, package: package) }

      it 'updates it' do
        expect { subject }.not_to change { Packages::Rubygems::Metadatum.count }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Rubygems
    class CreateDependenciesService
      def initialize(package, gemspec)
        @package = package
        @gemspec = gemspec
      end

      def execute
        set_dependencies
      end

      private

      attr_reader :package, :gemspec

      def set_dependencies
        Packages::Dependency.transaction do
          dependency_type_rows = gemspec.dependencies.map do |dependency|
            dependency = Packages::Dependency.safe_find_or_create_by!(
              name: dependency.name,
              version_pattern: dependency.requirement.to_s
            )

            {
              dependency_id: dependency.id,
              package_id: package.id,
              dependency_type: :dependencies
            }
          end

          package.dependency_links.upsert_all(
            dependency_type_rows,
            unique_by: %i[package_id dependency_id dependency_type]
          )
        end
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::Rubygems::CreateDependenciesService, feature_category: :package_registry do
  include RubygemsHelpers

  let_it_be(:package) { create(:rubygems_package) }
  let_it_be(:package_file) { create(:package_file, :gem) }
  let_it_be(:gem) { gem_from_file(package_file.file) }
  let_it_be(:gemspec) { gem.spec }

  let(:service) { described_class.new(package, gemspec) }

  describe '#execute' do
    subject { service.execute }

    it 'creates dependencies', :aggregate_failures do
      expect { subject }.to change { Packages::Dependency.count }.by(4)

      gemspec.dependencies.each do |dependency|
        persisted_dependency = Packages::Dependency.find_by(name: dependency.name)

        expect(persisted_dependency.version_pattern).to eq dependency.requirement.to_s
      end
    end

    it 'links dependencies to the package' do
      expect { subject }.to change { package.dependency_links.count }.by(4)

      expect(package.dependency_links.first).to be_dependencies
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Rubygems
    class CreateGemspecService
      def initialize(package, gemspec)
        @package = package
        @gemspec = gemspec
      end

      def execute
        write_gemspec_to_file
      end

      private

      attr_reader :package, :gemspec

      def write_gemspec_to_file
        file = Tempfile.new

        begin
          content = gemspec.to_ruby
          file.write(content)
          file.flush

          md5 = Gitlab::FIPS.enabled? ? nil : Digest::MD5.hexdigest(content)

          package.package_files.create!(
            file: file,
            size: file.size,
            file_name: ""#{gemspec.name}.gemspec"",
            file_sha1: Digest::SHA1.hexdigest(content),
            file_md5: md5,
            file_sha256: Digest::SHA256.hexdigest(content)
          )
        ensure
          file.close
          file.unlink
        end
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::Rubygems::CreateGemspecService, feature_category: :package_registry do
  include RubygemsHelpers

  let_it_be(:package_file) { create(:package_file, :gem) }
  let_it_be(:gem) { gem_from_file(package_file.file) }
  let_it_be(:gemspec) { gem.spec }
  let_it_be(:package) { package_file.package }

  let(:service) { described_class.new(package, gemspec) }

  describe '#execute' do
    subject { service.execute }

    it 'creates a new package file', :aggregate_failures do
      expect { subject }.to change { package.package_files.count }.by(1)

      gemspec_file = package.package_files.find_by(file_name: ""#{gemspec.name}.gemspec"")
      expect(gemspec_file.file).not_to be_nil
      expect(gemspec_file.size).not_to be_nil
      expect(gemspec_file.file_md5).not_to be_nil
      expect(gemspec_file.file_sha1).not_to be_nil
      expect(gemspec_file.file_sha256).not_to be_nil
    end

    context 'with FIPS mode', :fips_mode do
      it 'does not generate file_md5' do
        expect { subject }.to change { package.package_files.count }.by(1)

        gemspec_file = package.package_files.find_by(file_name: ""#{gemspec.name}.gemspec"")
        expect(gemspec_file.file).not_to be_nil
        expect(gemspec_file.size).not_to be_nil
        expect(gemspec_file.file_md5).to be_nil
        expect(gemspec_file.file_sha1).not_to be_nil
        expect(gemspec_file.file_sha256).not_to be_nil
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Cleanup
    class UpdatePolicyService < BaseProjectService
      ALLOWED_ATTRIBUTES = %i[keep_n_duplicated_package_files].freeze

      def execute
        return ServiceResponse.error(message: 'Access denied') unless allowed?

        if policy.update(policy_params)
          ServiceResponse.success(payload: { packages_cleanup_policy: policy })
        else
          ServiceResponse.error(message: policy.errors.full_messages.to_sentence || 'Bad request')
        end
      end

      private

      def policy
        project.packages_cleanup_policy
      end
      strong_memoize_attr :policy

      def allowed?
        can?(current_user, :admin_package, project)
      end

      def policy_params
        params.slice(*ALLOWED_ATTRIBUTES)
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::Cleanup::UpdatePolicyService, feature_category: :package_registry do
  using RSpec::Parameterized::TableSyntax

  let_it_be_with_reload(:project) { create(:project) }
  let_it_be(:current_user) { create(:user) }

  let(:params) { { keep_n_duplicated_package_files: 50 } }

  describe '#execute' do
    subject { described_class.new(project: project, current_user: current_user, params: params).execute }

    shared_examples 'creating the policy' do
      it 'creates a new one' do
        expect { subject }.to change { ::Packages::Cleanup::Policy.count }.from(0).to(1)

        expect(subject.payload[:packages_cleanup_policy]).to be_present
        expect(subject.success?).to be_truthy
        expect(project.packages_cleanup_policy).to be_persisted
        expect(project.packages_cleanup_policy.keep_n_duplicated_package_files).to eq('50')
      end

      context 'with invalid parameters' do
        let(:params) { { keep_n_duplicated_package_files: 100 } }

        it 'does not create one' do
          expect { subject }.not_to change { ::Packages::Cleanup::Policy.count }

          expect(subject.status).to eq(:error)
          expect(subject.message).to eq('Keep n duplicated package files is invalid')
        end
      end
    end

    shared_examples 'updating the policy' do
      it 'updates the existing one' do
        expect { subject }.not_to change { ::Packages::Cleanup::Policy.count }

        expect(subject.payload[:packages_cleanup_policy]).to be_present
        expect(subject.success?).to be_truthy
        expect(project.packages_cleanup_policy.keep_n_duplicated_package_files).to eq('50')
      end

      context 'with invalid parameters' do
        let(:params) { { keep_n_duplicated_package_files: 100 } }

        it 'does not update one' do
          expect { subject }.not_to change { policy.keep_n_duplicated_package_files }

          expect(subject.status).to eq(:error)
          expect(subject.message).to eq('Keep n duplicated package files is invalid')
        end
      end
    end

    shared_examples 'denying access' do
      it 'returns an error' do
        subject

        expect(subject.message).to eq('Access denied')
        expect(subject.status).to eq(:error)
      end
    end

    context 'with existing container expiration policy' do
      let_it_be(:policy) { create(:packages_cleanup_policy, project: project) }

      where(:user_role, :shared_examples_name) do
        :maintainer | 'updating the policy'
        :developer  | 'denying access'
        :reporter   | 'denying access'
        :guest      | 'denying access'
        :anonymous  | 'denying access'
      end

      with_them do
        before do
          project.send(""add_#{user_role}"", current_user) unless user_role == :anonymous
        end

        it_behaves_like params[:shared_examples_name]
      end
    end

    context 'without existing container expiration policy' do
      where(:user_role, :shared_examples_name) do
        :maintainer | 'creating the policy'
        :developer  | 'denying access'
        :reporter   | 'denying access'
        :guest      | 'denying access'
        :anonymous  | 'denying access'
      end

      with_them do
        before do
          project.send(""add_#{user_role}"", current_user) unless user_role == :anonymous
        end

        it_behaves_like params[:shared_examples_name]
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Cleanup
    class ExecutePolicyService
      include Gitlab::Utils::StrongMemoize

      MAX_EXECUTION_TIME = 250.seconds

      DUPLICATED_FILES_BATCH_SIZE = 10_000
      MARK_PACKAGE_FILES_FOR_DESTRUCTION_SERVICE_BATCH_SIZE = 200

      def initialize(policy)
        @policy = policy
        @counts = {
          marked_package_files_total_count: 0,
          unique_package_id_and_file_name_total_count: 0
        }
      end

      def execute
        cleanup_duplicated_files
      end

      private

      def cleanup_duplicated_files
        return if @policy.keep_n_duplicated_package_files_disabled?

        result = installable_package_files.each_batch(of: DUPLICATED_FILES_BATCH_SIZE) do |package_files|
          break :timeout if cleanup_duplicated_files_on(package_files) == :timeout
        end

        response_success(timeout: result == :timeout)
      end

      def cleanup_duplicated_files_on(package_files)
        unique_package_id_and_file_name_from(package_files).each do |package_id, file_name|
          result = remove_duplicated_files_for(package_id: package_id, file_name: file_name)
          @counts[:marked_package_files_total_count] += result.payload[:marked_package_files_count]
          @counts[:unique_package_id_and_file_name_total_count] += 1

          break :timeout unless result.success?
        end
      end

      def unique_package_id_and_file_name_from(package_files)
        # This is a highly custom query for this service, that's why it's not in the model.
        # rubocop: disable CodeReuse/ActiveRecord
        package_files.group(:package_id, :file_name)
          .having(""COUNT(*) > #{@policy.keep_n_duplicated_package_files}"")
          .pluck(:package_id, :file_name)
        # rubocop: enable CodeReuse/ActiveRecord
      end

      def remove_duplicated_files_for(package_id:, file_name:)
        base = ::Packages::PackageFile.for_package_ids(package_id)
                 .installable
                 .with_file_name(file_name)
        ids_to_keep = base.recent
                        .limit(@policy.keep_n_duplicated_package_files)
                        .pluck_primary_key

        duplicated_package_files = base.id_not_in(ids_to_keep)
        ::Packages::MarkPackageFilesForDestructionService.new(duplicated_package_files)
          .execute(batch_deadline: batch_deadline, batch_size: MARK_PACKAGE_FILES_FOR_DESTRUCTION_SERVICE_BATCH_SIZE)
      end

      def project
        @policy.project
      end

      def installable_package_files
        ::Packages::PackageFile.installable
          .for_package_ids(
            ::Packages::Package.installable
              .for_projects(project.id)
          )
      end

      def batch_deadline
        MAX_EXECUTION_TIME.from_now
      end
      strong_memoize_attr :batch_deadline

      def response_success(timeout:)
        ServiceResponse.success(
          message: ""Packages cleanup policy executed for project #{project.id}"",
          payload: {
            timeout: timeout,
            counts: @counts
          }
        )
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::Cleanup::ExecutePolicyService, feature_category: :package_registry do
  let_it_be(:project) { create(:project) }
  let_it_be_with_reload(:policy) { create(:packages_cleanup_policy, project: project) }

  let(:service) { described_class.new(policy) }

  describe '#execute' do
    subject(:execute) { service.execute }

    context 'with the keep_n_duplicated_files parameter' do
      let_it_be(:package1) { create(:package, project: project) }
      let_it_be(:package2) { create(:package, project: project) }
      let_it_be(:package3) { create(:package, project: project) }
      let_it_be(:package4) { create(:package, :pending_destruction, project: project) }

      let_it_be(:package_file1_1) { create(:package_file, package: package1, file_name: 'file_name1') }
      let_it_be(:package_file1_2) { create(:package_file, package: package1, file_name: 'file_name1') }
      let_it_be(:package_file1_3) { create(:package_file, package: package1, file_name: 'file_name1') }

      let_it_be(:package_file1_4) { create(:package_file, package: package1, file_name: 'file_name2') }
      let_it_be(:package_file1_5) { create(:package_file, package: package1, file_name: 'file_name2') }
      let_it_be(:package_file1_6) { create(:package_file, package: package1, file_name: 'file_name2') }
      let_it_be(:package_file1_7) do
        create(:package_file, :pending_destruction, package: package1, file_name: 'file_name2')
      end

      let_it_be(:package_file2_1) { create(:package_file, package: package2, file_name: 'file_name1') }
      let_it_be(:package_file2_2) { create(:package_file, package: package2, file_name: 'file_name1') }
      let_it_be(:package_file2_3) { create(:package_file, package: package2, file_name: 'file_name1') }
      let_it_be(:package_file2_4) { create(:package_file, package: package2, file_name: 'file_name1') }

      let_it_be(:package_file3_1) { create(:package_file, package: package3, file_name: 'file_name_test') }

      let_it_be(:package_file4_1) { create(:package_file, package: package4, file_name: 'file_name1') }
      let_it_be(:package_file4_2) { create(:package_file, package: package4, file_name: 'file_name1') }

      let(:package_files_1) { package1.package_files.installable }
      let(:package_files_2) { package2.package_files.installable }
      let(:package_files_3) { package3.package_files.installable }

      context 'set to less than the total number of duplicated files' do
        before do
          # for each package file duplicate, we keep only the most recent one
          policy.update!(keep_n_duplicated_package_files: '1')
        end

        shared_examples 'keeping the most recent package files' do
          let(:response_payload) do
            {
              counts: {
                marked_package_files_total_count: 7,
                unique_package_id_and_file_name_total_count: 3
              },
              timeout: false
            }
          end

          it 'only keeps the most recent package files' do
            expect { execute }.to change { ::Packages::PackageFile.installable.count }.by(-7)

            expect(package_files_1).to contain_exactly(package_file1_3, package_file1_6)
            expect(package_files_2).to contain_exactly(package_file2_4)
            expect(package_files_3).to contain_exactly(package_file3_1)

            expect(execute).to be_success
            expect(execute.message).to eq(""Packages cleanup policy executed for project #{project.id}"")
            expect(execute.payload).to eq(response_payload)
          end
        end

        it_behaves_like 'keeping the most recent package files'

        context 'when the service needs to loop' do
          before do
            stub_const(""#{described_class.name}::DUPLICATED_FILES_BATCH_SIZE"", 2)
          end

          it_behaves_like 'keeping the most recent package files' do
            before do
              expect(::Packages::MarkPackageFilesForDestructionService)
                .to receive(:new).exactly(3).times.and_call_original
            end
          end

          context 'when a timeout is hit' do
            let(:response_payload) do
              {
                counts: {
                  marked_package_files_total_count: 4,
                  unique_package_id_and_file_name_total_count: 3
                },
                timeout: true
              }
            end

            let(:service_timeout_response) do
              ServiceResponse.error(
                message: 'Timeout while marking package files as pending destruction',
                payload: { marked_package_files_count: 0 }
              )
            end

            before do
              mock_service_timeout(on_iteration: 3)
            end

            it 'keeps part of the most recent package files' do
              expect { execute }
                .to change { ::Packages::PackageFile.installable.count }.by(-4)
                .and not_change { package_files_2.count } # untouched because of the timeout
                .and not_change { package_files_3.count } # untouched because of the timeout

              expect(package_files_1).to contain_exactly(package_file1_3, package_file1_6)
              expect(execute).to be_success
              expect(execute.message).to eq(""Packages cleanup policy executed for project #{project.id}"")
              expect(execute.payload).to eq(response_payload)
            end

            def mock_service_timeout(on_iteration:)
              execute_call_count = 1
              expect_next_instances_of(::Packages::MarkPackageFilesForDestructionService, 3) do |service|
                expect(service).to receive(:execute).and_wrap_original do |m, *args, **kwargs|
                  # timeout if we are on the right iteration
                  if execute_call_count == on_iteration
                    service_timeout_response
                  else
                    execute_call_count += 1
                    m.call(*args, **kwargs)
                  end
                end
              end
            end
          end
        end
      end

      context 'set to more than the total number of duplicated files' do
        before do
          # using the biggest value for keep_n_duplicated_package_files
          policy.update!(keep_n_duplicated_package_files: '50')
        end

        it 'keeps all package files' do
          expect { execute }.not_to change { ::Packages::PackageFile.installable.count }
        end
      end

      context 'set to all' do
        before do
          policy.update!(keep_n_duplicated_package_files: 'all')
        end

        it 'skips the policy' do
          expect(::Packages::MarkPackageFilesForDestructionService).not_to receive(:new)
          expect { execute }.not_to change { ::Packages::PackageFile.installable.count }
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Protection
    class UpdateRuleService
      include Gitlab::Allowable

      ALLOWED_ATTRIBUTES = %i[
        package_name_pattern
        package_type
        push_protected_up_to_access_level
      ].freeze

      def initialize(package_protection_rule, current_user:, params:)
        if package_protection_rule.blank? || current_user.blank?
          raise ArgumentError,
            'package_protection_rule and current_user must be set'
        end

        @package_protection_rule = package_protection_rule
        @current_user = current_user
        @params = params || {}
      end

      def execute
        unless can?(current_user, :admin_package, package_protection_rule.project)
          error_message = _('Unauthorized to update a package protection rule')
          return service_response_error(message: error_message)
        end

        package_protection_rule.update(params.slice(*ALLOWED_ATTRIBUTES))

        if package_protection_rule.errors.present?
          return service_response_error(message: package_protection_rule.errors.full_messages)
        end

        ServiceResponse.success(payload: { package_protection_rule: package_protection_rule })
      rescue StandardError => e
        service_response_error(message: e.message)
      end

      private

      attr_reader :package_protection_rule, :current_user, :params

      def service_response_error(message:)
        ServiceResponse.error(
          message: message,
          payload: { package_protection_rule: nil }
        )
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Protection::UpdateRuleService, '#execute', feature_category: :environment_management do
  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:current_user) { create(:user, maintainer_projects: [project]) }
  let_it_be_with_reload(:package_protection_rule) { create(:package_protection_rule, project: project) }

  let(:service) { described_class.new(package_protection_rule, current_user: current_user, params: params) }

  let(:params) do
    attributes_for(
      :package_protection_rule,
      package_name_pattern: ""#{package_protection_rule.package_name_pattern}-updated"",
      package_type: 'npm',
      push_protected_up_to_access_level: 'owner'
    )
  end

  subject(:service_execute) { service.execute }

  shared_examples 'a successful service response' do
    let(:expected_attributes) { params }

    it { is_expected.to be_success }

    it do
      is_expected.to have_attributes(
        errors: be_blank,
        message: be_blank,
        payload: { package_protection_rule: be_a(Packages::Protection::Rule).and(have_attributes(expected_attributes)) }
      )
    end

    it { expect { subject }.not_to change { Packages::Protection::Rule.count } }

    it { subject.tap { expect(package_protection_rule.reload).to have_attributes expected_attributes } }
  end

  shared_examples 'an erroneous service response' do
    it { is_expected.to be_error }

    it do
      is_expected.to have_attributes(
        errors: be_present,
        message: be_present,
        payload: { package_protection_rule: nil }
      )
    end

    it { expect { subject }.not_to change { Packages::Protection::Rule.count } }
    it { expect { subject }.not_to change { package_protection_rule.reload.updated_at } }
  end

  it_behaves_like 'a successful service response'

  context 'with disallowed params' do
    let(:params) { super().merge!(project_id: 1, unsupported_param: 'unsupported_param_value') }

    it_behaves_like 'a successful service response' do
      let(:expected_attributes) { params.except(:project_id, :unsupported_param) }
    end
  end

  context 'when fields are invalid' do
    let(:params) do
      { package_name_pattern: '', package_type: 'unknown_package_type',
        push_protected_up_to_access_level: 1000 }
    end

    it_behaves_like 'an erroneous service response'

    it { is_expected.to have_attributes message: /'unknown_package_type' is not a valid package_type/ }
  end

  context 'with empty params' do
    let(:params) { {} }

    it_behaves_like 'a successful service response' do
      let(:expected_attributes) { package_protection_rule.attributes }
    end

    it { expect { service_execute }.not_to change { package_protection_rule.reload.updated_at } }
  end

  context 'with nil params' do
    let(:params) { nil }

    it_behaves_like 'a successful service response' do
      let(:expected_attributes) { package_protection_rule.attributes }
    end

    it { expect { service_execute }.not_to change { package_protection_rule.reload.updated_at } }
  end

  context 'when updated field `package_name_pattern` is already taken' do
    let_it_be_with_reload(:other_existing_package_protection_rule) do
      create(:package_protection_rule, project: project,
        package_name_pattern: ""#{package_protection_rule.package_name_pattern}-other"")
    end

    let(:params) { { package_name_pattern: other_existing_package_protection_rule.package_name_pattern } }

    it_behaves_like 'an erroneous service response'

    it do
      expect { service_execute }.not_to(
        change { other_existing_package_protection_rule.reload.package_name_pattern }
      )
    end

    it do
      is_expected.to have_attributes(
        errors: match_array([/Package name pattern has already been taken/]),
        message: match_array([/Package name pattern has already been taken/])
      )
    end
  end

  context 'when current_user does not have permission' do
    let_it_be(:developer) { create(:user).tap { |u| project.add_developer(u) } }
    let_it_be(:reporter) { create(:user).tap { |u| project.add_reporter(u) } }
    let_it_be(:guest) { create(:user).tap { |u| project.add_guest(u) } }
    let_it_be(:anonymous) { create(:user) }

    where(:current_user) do
      [ref(:developer), ref(:reporter), ref(:guest), ref(:anonymous)]
    end

    with_them do
      it_behaves_like 'an erroneous service response'

      it { is_expected.to have_attributes errors: match_array(/Unauthorized/), message: /Unauthorized/ }
    end
  end

  context 'without package protection rule' do
    let(:package_protection_rule) { nil }
    let(:params) { {} }

    it { expect { service_execute }.to raise_error(ArgumentError) }
  end

  context 'without current_user' do
    let(:current_user) { nil }

    it { expect { service_execute }.to raise_error(ArgumentError) }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Protection
    class CreateRuleService < BaseProjectService
      ALLOWED_ATTRIBUTES = %i[
        package_name_pattern
        package_type
        push_protected_up_to_access_level
      ].freeze

      def execute
        unless can?(current_user, :admin_package, project)
          error_message = _('Unauthorized to create a package protection rule')
          return service_response_error(message: error_message)
        end

        package_protection_rule = project.package_protection_rules.create(params.slice(*ALLOWED_ATTRIBUTES))

        unless package_protection_rule.persisted?
          return service_response_error(message: package_protection_rule.errors.full_messages)
        end

        ServiceResponse.success(payload: { package_protection_rule: package_protection_rule })
      rescue StandardError => e
        service_response_error(message: e.message)
      end

      private

      def service_response_error(message:)
        ServiceResponse.error(
          message: message,
          payload: { package_protection_rule: nil }
        )
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Protection::CreateRuleService, '#execute', feature_category: :package_registry do
  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:maintainer) { create(:user).tap { |u| project.add_maintainer(u) } }

  let(:service) { described_class.new(project: project, current_user: current_user, params: params) }
  let(:current_user) { maintainer }
  let(:params) { attributes_for(:package_protection_rule) }

  subject { service.execute }

  shared_examples 'a successful service response' do
    let(:package_protection_rule_count_expected) { 1 }
    it { is_expected.to be_success }

    it do
      is_expected.to have_attributes(
        payload: include(
          package_protection_rule: be_a(Packages::Protection::Rule)
        )
      )
    end

    it { expect(subject.payload).to include(package_protection_rule: be_a(Packages::Protection::Rule)) }

    it do
      expect { subject }.to change { Packages::Protection::Rule.count }.by(1)

      expect(Packages::Protection::Rule.where(project: project).count).to eq package_protection_rule_count_expected
      expect(Packages::Protection::Rule.where(project: project,
        package_name_pattern: params[:package_name_pattern])).to exist
    end
  end

  shared_examples 'an erroneous service response' do
    let(:package_protection_rule_count_expected) { 0 }
    it { is_expected.to be_error }
    it { is_expected.to have_attributes(payload: include(package_protection_rule: nil)) }

    it do
      expect { subject }.to change { Packages::Protection::Rule.count }.by(0)

      expect(Packages::Protection::Rule.where(project: project).count).to eq package_protection_rule_count_expected
      expect(Packages::Protection::Rule.where(project: project,
        package_name_pattern: params[:package_name_pattern])).not_to exist
    end
  end

  context 'without existing PackageProtectionRules' do
    context 'when fields are valid' do
      it_behaves_like 'a successful service response'
    end

    context 'when fields are invalid' do
      let(:params) do
        {
          package_name_pattern: '',
          package_type: 'unknown_package_type',
          push_protected_up_to_access_level: 1000
        }
      end

      it_behaves_like 'an erroneous service response'
    end
  end

  context 'with existing PackageProtectionRule' do
    let_it_be(:existing_package_protection_rule) { create(:package_protection_rule, project: project) }

    context 'when package name pattern is slightly different' do
      let(:params) do
        attributes_for(
          :package_protection_rule,
          # The field `package_name_pattern` is unique; this is why we change the value in a minimum way
          package_name_pattern: ""#{existing_package_protection_rule.package_name_pattern}-unique"",
          package_type: existing_package_protection_rule.package_type,
          push_protected_up_to_access_level: existing_package_protection_rule.push_protected_up_to_access_level
        )
      end

      it_behaves_like 'a successful service response' do
        let(:package_protection_rule_count_expected) { 2 }
      end
    end

    context 'when field `package_name_pattern` is taken' do
      let(:params) do
        attributes_for(
          :package_protection_rule,
          package_name_pattern: existing_package_protection_rule.package_name_pattern,
          package_type: existing_package_protection_rule.package_type,
          push_protected_up_to_access_level: existing_package_protection_rule.push_protected_up_to_access_level
        )
      end

      it { is_expected.to be_error }

      it do
        expect { subject }.to change { Packages::Protection::Rule.count }.by(0)

        expect(Packages::Protection::Rule.where(project: project).count).to eq 1
        expect(
          Packages::Protection::Rule.where(
            project: project,
            package_name_pattern: params[:package_name_pattern]
          )
        ).to exist
      end
    end
  end

  context 'when disallowed params are passed' do
    let(:params) do
      attributes_for(:package_protection_rule)
        .merge(
          project_id: 1,
          unsupported_param: 'unsupported_param_value'
        )
    end

    it_behaves_like 'a successful service response'
  end

  context 'with forbidden user access level (project developer role)' do
    # Because of the access level hierarchy, we can assume that
    # other access levels below developer role will also not be able to
    # create package protection rules.
    let_it_be(:developer) { create(:user).tap { |u| project.add_developer(u) } }

    let(:current_user) { developer }

    it_behaves_like 'an erroneous service response'

    it { is_expected.to have_attributes(message: match(/Unauthorized/)) }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Protection
    class DeleteRuleService
      include Gitlab::Allowable

      def initialize(package_protection_rule, current_user:)
        if package_protection_rule.blank? || current_user.blank?
          raise ArgumentError,
            'package_protection_rule and current_user must be set'
        end

        @package_protection_rule = package_protection_rule
        @current_user = current_user
      end

      def execute
        unless can?(current_user, :admin_package, package_protection_rule.project)
          error_message = _('Unauthorized to delete a package protection rule')
          return service_response_error(message: error_message)
        end

        deleted_package_protection_rule = package_protection_rule.destroy!

        ServiceResponse.success(payload: { package_protection_rule: deleted_package_protection_rule })
      rescue StandardError => e
        service_response_error(message: e.message)
      end

      private

      attr_reader :package_protection_rule, :current_user

      def service_response_error(message:)
        ServiceResponse.error(
          message: message,
          payload: { package_protection_rule: nil }
        )
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Protection::DeleteRuleService, '#execute', feature_category: :package_registry do
  let_it_be(:project) { create(:project) }
  let_it_be(:current_user) { create(:user, maintainer_projects: [project]) }
  let_it_be_with_refind(:package_protection_rule) { create(:package_protection_rule, project: project) }

  subject { described_class.new(package_protection_rule, current_user: current_user).execute }

  shared_examples 'a successful service response' do
    it { is_expected.to be_success }

    it {
      is_expected.to have_attributes(
        errors: be_blank,
        message: be_blank,
        payload: { package_protection_rule: package_protection_rule }
      )
    }

    it { subject.tap { expect { package_protection_rule.reload }.to raise_error ActiveRecord::RecordNotFound } }
  end

  shared_examples 'an erroneous service response' do
    it { is_expected.to be_error }
    it { is_expected.to have_attributes(message: be_present, payload: { package_protection_rule: be_blank }) }

    it do
      expect { subject }.not_to change { Packages::Protection::Rule.count }

      expect { package_protection_rule.reload }.not_to raise_error
    end
  end

  it_behaves_like 'a successful service response'

  it 'deletes the package protection rule in the database' do
    expect { subject }
    .to change { project.reload.package_protection_rules }.from([package_protection_rule]).to([])
    .and change { ::Packages::Protection::Rule.count }.from(1).to(0)
  end

  context 'with deleted package protection rule' do
    let!(:package_protection_rule) do
      create(:package_protection_rule, project: project, package_name_pattern: 'protection_rule_deleted').destroy!
    end

    it_behaves_like 'a successful service response'
  end

  context 'when error occurs during delete operation' do
    before do
      allow(package_protection_rule).to receive(:destroy!).and_raise(StandardError.new('Some error'))
    end

    it_behaves_like 'an erroneous service response'

    it { is_expected.to have_attributes message: /Some error/ }
  end

  context 'when current_user does not have permission' do
    let_it_be(:developer) { create(:user).tap { |u| project.add_developer(u) } }
    let_it_be(:reporter) { create(:user).tap { |u| project.add_reporter(u) } }
    let_it_be(:guest) { create(:user).tap { |u| project.add_guest(u) } }
    let_it_be(:anonymous) { create(:user) }

    where(:current_user) do
      [ref(:developer), ref(:reporter), ref(:guest), ref(:anonymous)]
    end

    with_them do
      it_behaves_like 'an erroneous service response'

      it { is_expected.to have_attributes message: /Unauthorized to delete a package protection rule/ }
    end
  end

  context 'without package protection rule' do
    let(:package_protection_rule) { nil }

    it { expect { subject }.to raise_error(ArgumentError) }
  end

  context 'without current_user' do
    let(:current_user) { nil }
    let(:package_protection_rule) { build_stubbed(:package_protection_rule, project: project) }

    it { expect { subject }.to raise_error(ArgumentError) }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Nuget
    class ExtractRemoteMetadataFileService
      include Gitlab::Utils::StrongMemoize

      ExtractionError = Class.new(StandardError)

      MAX_FILE_SIZE = 4.megabytes.freeze
      METADATA_FILE_EXTENSION = '.nuspec'
      MAX_FRAGMENTS = 5 # nuspec file is usually in the first 2 fragments but we buffer 5 max

      def initialize(remote_url)
        @remote_url = remote_url
      end

      def execute
        raise ExtractionError, 'invalid file url' if remote_url.blank?

        if nuspec_file_content.blank? || !nuspec_file_content.instance_of?(String)
          raise ExtractionError, 'nuspec file not found'
        end

        ServiceResponse.success(payload: nuspec_file_content)
      end

      private

      attr_reader :remote_url

      def nuspec_file_content
        fragments = []

        Gitlab::HTTP.get(remote_url, stream_body: true, allow_object_storage: true) do |fragment|
          break if fragments.size >= MAX_FRAGMENTS

          fragments << fragment
          joined_fragments = fragments.join

          next if joined_fragments.exclude?(METADATA_FILE_EXTENSION)

          nuspec_content = extract_nuspec_file(joined_fragments)

          break nuspec_content if nuspec_content.present?
        end
      end
      strong_memoize_attr :nuspec_file_content

      def extract_nuspec_file(fragments)
        StringIO.open(fragments) do |io|
          Zip::InputStream.open(io) do |zip|
            process_zip_entries(zip)
          end
        rescue Zip::Error => e
          raise ExtractionError, ""Error opening zip stream: #{e.message}""
        end
      end

      def process_zip_entries(zip)
        while (entry = zip.get_next_entry) # rubocop:disable Lint/AssignmentInCondition
          next unless entry.name.end_with?(METADATA_FILE_EXTENSION)

          raise ExtractionError, 'nuspec file too big' if entry.size > MAX_FILE_SIZE

          return extract_file_content(entry)
        end
      end

      def extract_file_content(entry)
        Tempfile.create('extract_remote_metadata_file_service') do |file|
          entry.extract(file.path) { true } # allow #extract to overwrite the file
          file.read
        end
      rescue Zip::DecompressionError
        '' # Ignore decompression errors and continue reading the next fragment
      rescue Zip::EntrySizeError => e
        raise ExtractionError, ""nuspec file has the wrong entry size: #{e.message}""
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Nuget::ExtractRemoteMetadataFileService, feature_category: :package_registry do
  let_it_be(:remote_url) { 'http://example.com/package.nupkg' }
  let_it_be(:nupkg_filepath) { 'packages/nuget/package.nupkg' }

  describe '#execute' do
    subject(:service) { described_class.new(remote_url) }

    context 'when the remote URL is blank' do
      let(:remote_url) { '' }

      it { expect { service.execute }.to raise_error(described_class::ExtractionError, 'invalid file url') }
    end

    context 'when the package file is corrupted' do
      before do
        allow(Gitlab::HTTP).to receive(:get).with(remote_url, stream_body: true, allow_object_storage: true)
          .and_yield('corrupted data')
      end

      it { expect { service.execute }.to raise_error(described_class::ExtractionError, 'nuspec file not found') }
    end

    context 'when reaching the maximum received fragments' do
      before do
        allow(Gitlab::HTTP).to receive(:get).with(remote_url, stream_body: true, allow_object_storage: true)
          .and_yield('Fragment 1').and_yield('Fragment 2').and_yield('Fragment 3').and_yield('Fragment 4')
          .and_yield('Fragment 5').and_yield(fixture_file(nupkg_filepath))
      end

      it { expect { service.execute }.to raise_error(described_class::ExtractionError, 'nuspec file not found') }
    end

    context 'when nuspec file is too big' do
      before do
        allow(Gitlab::HTTP).to receive(:get).with(remote_url, stream_body: true, allow_object_storage: true)
          .and_yield(fixture_file(nupkg_filepath))
        allow_next_instance_of(Zip::Entry) do |instance|
          allow(instance).to receive(:size).and_return(6.megabytes)
        end
      end

      it { expect { service.execute }.to raise_error(described_class::ExtractionError, 'nuspec file too big') }
    end

    context 'when nuspec file is fragmented' do
      let_it_be(:nuspec_path) { expand_fixture_path('packages/nuget/with_metadata.nuspec') }
      let_it_be(:tmp_zip) { Tempfile.new('nuget_zip') }
      let_it_be(:zipped_nuspec) { zip_nuspec_file(nuspec_path, tmp_zip.path).get_raw_input_stream.read }
      let_it_be(:fragments) { zipped_nuspec.chars.each_slice(zipped_nuspec.size / 2).map(&:join) }

      before do
        allow(Gitlab::HTTP).to receive(:get).with(remote_url, stream_body: true, allow_object_storage: true)
          .and_yield(fragments[0]).and_yield(fragments[1])
      end

      after do
        tmp_zip.unlink
      end

      it 'ignores the Zip::DecompressionError and constructs the nuspec file from the fragments' do
        response = service.execute

        expect(response).to be_success
        expect(response.payload).to include('<id>DummyProject.WithMetadata</id>')
          .and include('<version>1.2.3</version>')
      end
    end

    context 'when the remote URL is valid' do
      let(:fragments) { fixture_file(nupkg_filepath).chars.each_slice(1.kilobyte).map(&:join) }

      before do
        allow(Gitlab::HTTP).to receive(:get).with(remote_url, stream_body: true, allow_object_storage: true)
          .and_yield(fragments[0]).and_yield(fragments[1]).and_yield(fragments[2]).and_yield(fragments[3])
      end

      it 'returns a success response with the nuspec file content' do
        response = service.execute

        expect(response).to be_success
        expect(response.payload).to include('<id>DummyProject.DummyPackage</id>')
          .and include('<version>1.0.0</version>')
      end
    end

    context 'with a corrupted nupkg file with a wrong entry size' do
      before do
        allow(Gitlab::HTTP).to receive(:get).with(remote_url, stream_body: true, allow_object_storage: true)
          .and_yield(fixture_file(nupkg_filepath))
        allow_next_instance_of(Zip::Entry) do |instance|
          allow(instance).to receive(:extract).and_raise(Zip::EntrySizeError)
        end
      end

      it {
        expect do
          service.execute
        end.to raise_error(described_class::ExtractionError, /nuspec file has the wrong entry size/)
      }
    end

    context 'with a Zip::Error exception' do
      before do
        allow(Gitlab::HTTP).to receive(:get).with(remote_url, stream_body: true, allow_object_storage: true)
          .and_yield(fixture_file(nupkg_filepath))
        allow(Zip::InputStream).to receive(:open).and_raise(Zip::Error)
      end

      it {
        expect do
          service.execute
        end.to raise_error(described_class::ExtractionError, /Error opening zip stream/)
      }
    end
  end

  def zip_nuspec_file(nuspec_path, zip_path)
    Zip::File.open(zip_path, Zip::File::CREATE) do |zipfile|
      zipfile.add('package.nuspec', nuspec_path)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Nuget
    class MetadataExtractionService
      def initialize(package_zip_file)
        @package_zip_file = package_zip_file
      end

      def execute
        ServiceResponse.success(payload: metadata)
      end

      private

      attr_reader :package_zip_file

      def metadata
        ::Packages::Nuget::ExtractMetadataContentService
          .new(nuspec_file_content)
          .execute
          .payload
      end

      def nuspec_file_content
        ::Packages::Nuget::ExtractMetadataFileService
          .new(package_zip_file)
          .execute
          .payload
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Nuget::MetadataExtractionService, feature_category: :package_registry do
  let_it_be(:package_file) { build(:package_file, :nuget) }
  let(:package_zip_file) { Zip::File.new(package_file.file) }
  let(:service) { described_class.new(package_zip_file) }

  describe '#execute' do
    subject { service.execute }

    let(:nuspec_file_content) do
      <<~XML
        <?xml version=""1.0"" encoding=""utf-8""?>
        <package xmlns=""http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd"">
          <metadata>
            <id>DummyProject.DummyPackage</id>
            <version>1.0.0</version>
            <title>Dummy package</title>
            <authors>Test</authors>
            <owners>Test</owners>
            <requireLicenseAcceptance>false</requireLicenseAcceptance>
            <description>This is a dummy project</description>
            <dependencies>
              <group targetFramework="".NETCoreApp3.0"">
                <dependency id=""Newtonsoft.Json"" version=""12.0.3"" exclude=""Build,Analyzers"" />
              </group>
            </dependencies>
          </metadata>
        </package>
      XML
    end

    let(:expected_metadata) do
      {
        package_name: 'DummyProject.DummyPackage',
        package_version: '1.0.0',
        authors: 'Test',
        description: 'This is a dummy project',
        package_dependencies: [
          {
            name: 'Newtonsoft.Json',
            target_framework: '.NETCoreApp3.0',
            version: '12.0.3'
          }
        ],
        package_tags: [],
        package_types: []
      }
    end

    it 'calls the necessary services and executes the metadata extraction' do
      expect_next_instance_of(Packages::Nuget::ExtractMetadataFileService, package_zip_file) do |service|
        expect(service).to receive(:execute).and_return(ServiceResponse.success(payload: nuspec_file_content))
      end

      expect_next_instance_of(Packages::Nuget::ExtractMetadataContentService, nuspec_file_content) do |service|
        expect(service).to receive(:execute).and_call_original
      end

      expect(subject.payload).to eq(expected_metadata)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Nuget
    class ExtractMetadataFileService
      ExtractionError = Class.new(StandardError)

      MAX_FILE_SIZE = 4.megabytes.freeze

      def initialize(package_zip_file)
        @package_zip_file = package_zip_file
      end

      def execute
        ServiceResponse.success(payload: nuspec_file_content)
      end

      private

      attr_reader :package_zip_file

      def nuspec_file_content
        entry = extract_nuspec_file

        raise ExtractionError, 'nuspec file not found' unless entry
        raise ExtractionError, 'nuspec file too big' if MAX_FILE_SIZE < entry.size

        Tempfile.create('nuget_extraction_package_file') do |file|
          entry.extract(file.path) { true } # allow #extract to overwrite the file
          file.read
        end
      rescue Zip::EntrySizeError => e
        raise ExtractionError, ""nuspec file has the wrong entry size: #{e.message}""
      end

      def extract_nuspec_file
        if package_zip_file.is_a?(Zip::InputStream)
          while (entry = package_zip_file.get_next_entry) # rubocop:disable Lint/AssignmentInCondition -- Following https://github.com/rubyzip/rubyzip#notes-on-zipinputstream and that's why the disable rubocop rule
            break entry if entry.name.end_with?('.nuspec')
          end
        else
          package_zip_file.glob('*.nuspec').first
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Nuget::ExtractMetadataFileService, feature_category: :package_registry do
  include PackagesManagerApiSpecHelpers

  let_it_be(:package_file) { build(:package_file, :nuget) }
  let_it_be(:package_zip_file) { Zip::File.new(package_file.file) }

  let(:service) { described_class.new(package_zip_file) }

  describe '#execute' do
    subject { service.execute }

    shared_examples 'raises an error' do |error_message|
      it { expect { subject }.to raise_error(described_class::ExtractionError, error_message) }
    end

    context 'with valid package file' do
      expected_metadata = <<~XML.squish
        <package xmlns=""http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd"">
          <metadata>
            <id>DummyProject.DummyPackage</id>
            <version>1.0.0</version>
            <title>Dummy package</title>
            <authors>Test</authors>
            <owners>Test</owners>
            <requireLicenseAcceptance>false</requireLicenseAcceptance>
            <description>This is a dummy project</description>
            <dependencies>
              <group targetFramework="".NETCoreApp3.0"">
                <dependency id=""Newtonsoft.Json"" version=""12.0.3"" exclude=""Build,Analyzers"" />
              </group>
            </dependencies>
          </metadata>
        </package>
      XML

      it 'returns the nuspec file content' do
        expect(subject.payload.squish).to include(expected_metadata)
      end

      context 'with InputStream zip' do
        let(:package_zip_file) do
          Zip::InputStream.open(
            temp_file('package.nupkg', content: File.open(package_file.file.path))
          )
        end

        it 'returns the nuspec file content' do
          expect(subject.payload.squish).to include(expected_metadata)
        end
      end
    end

    context 'without the nuspec file' do
      before do
        allow(package_zip_file).to receive(:glob).and_return([])
      end

      it_behaves_like 'raises an error', 'nuspec file not found'
    end

    context 'with a too big nuspec file' do
      before do
        allow(package_zip_file).to receive(:glob).and_return(
          [instance_double(File, size: described_class::MAX_FILE_SIZE + 1)]
        )
      end

      it_behaves_like 'raises an error', 'nuspec file too big'
    end

    context 'with a corrupted nupkg file with a wrong entry size' do
      let(:nupkg_fixture_path) { expand_fixture_path('packages/nuget/corrupted_package.nupkg') }
      let(:package_zip_file) { Zip::File.new(nupkg_fixture_path) }

      it_behaves_like 'raises an error',
        <<~ERROR.squish
          nuspec file has the wrong entry size: entry 'DummyProject.DummyPackage.nuspec' should be 255B,
          but is larger when inflated.
        ERROR
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Nuget
    class ExtractMetadataContentService
      ROOT_XPATH = '//xmlns:package/xmlns:metadata/xmlns'

      XPATHS = {
        package_name: ""#{ROOT_XPATH}:id"",
        package_version: ""#{ROOT_XPATH}:version"",
        authors: ""#{ROOT_XPATH}:authors"",
        description: ""#{ROOT_XPATH}:description"",
        license_url: ""#{ROOT_XPATH}:licenseUrl"",
        project_url: ""#{ROOT_XPATH}:projectUrl"",
        icon_url: ""#{ROOT_XPATH}:iconUrl""
      }.freeze

      XPATH_DEPENDENCIES = ""#{ROOT_XPATH}:dependencies/xmlns:dependency"".freeze
      XPATH_DEPENDENCY_GROUPS = ""#{ROOT_XPATH}:dependencies/xmlns:group"".freeze
      XPATH_TAGS = ""#{ROOT_XPATH}:tags"".freeze
      XPATH_PACKAGE_TYPES = ""#{ROOT_XPATH}:packageTypes/xmlns:packageType"".freeze

      def initialize(nuspec_file_content)
        @nuspec_file_content = nuspec_file_content
      end

      def execute
        ServiceResponse.success(payload: extract_metadata(nuspec_file_content))
      end

      private

      attr_reader :nuspec_file_content

      def extract_metadata(file)
        doc = Nokogiri::XML(file)

        XPATHS.transform_values { |query| doc.xpath(query).text.presence }
              .compact
              .tap do |metadata|
                metadata[:package_dependencies] = extract_dependencies(doc)
                metadata[:package_tags] = extract_tags(doc)
                metadata[:package_types] = extract_package_types(doc)
              end
      end

      def extract_dependencies(doc)
        dependencies = []

        doc.xpath(XPATH_DEPENDENCIES).each do |node|
          dependencies << extract_dependency(node)
        end

        doc.xpath(XPATH_DEPENDENCY_GROUPS).each do |group_node|
          target_framework = group_node.attr('targetFramework')

          group_node.xpath('xmlns:dependency').each do |node|
            dependencies << extract_dependency(node).merge(target_framework: target_framework)
          end
        end

        dependencies
      end

      def extract_dependency(node)
        {
          name: node.attr('id'),
          version: node.attr('version')
        }.compact
      end

      def extract_tags(doc)
        tags = doc.xpath(XPATH_TAGS).text

        return [] if tags.blank?

        tags.split(::Packages::Tag::NUGET_TAGS_SEPARATOR)
      end

      def extract_package_types(doc)
        doc.xpath(XPATH_PACKAGE_TYPES).map { |node| node.attr('name') }.uniq
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Nuget::ExtractMetadataContentService, feature_category: :package_registry do
  let(:nuspec_file_content) { fixture_file(nuspec_filepath) }

  let(:service) { described_class.new(nuspec_file_content) }

  describe '#execute' do
    subject { service.execute.payload }

    context 'with nuspec file content' do
      context 'with dependencies' do
        let(:nuspec_filepath) { 'packages/nuget/with_dependencies.nuspec' }

        it { is_expected.to have_key(:package_dependencies) }

        it 'extracts dependencies' do
          dependencies = subject[:package_dependencies]

          expect(dependencies).to include(name: 'Moqi', version: '2.5.6')
          expect(dependencies).to include(name: 'Castle.Core')
          expect(dependencies).to include(name: 'Test.Dependency', version: '2.3.7',
            target_framework: '.NETStandard2.0')
          expect(dependencies).to include(name: 'Newtonsoft.Json', version: '12.0.3',
            target_framework: '.NETStandard2.0')
        end
      end

      context 'with package types' do
        let(:nuspec_filepath) { 'packages/nuget/with_package_types.nuspec' }

        it { is_expected.to have_key(:package_types) }

        it 'extracts package types' do
          expect(subject[:package_types]).to include('SymbolsPackage')
        end
      end

      context 'with a nuspec file with metadata' do
        let(:nuspec_filepath) { 'packages/nuget/with_metadata.nuspec' }

        it { expect(subject[:package_tags].sort).to eq(%w[foo bar test tag1 tag2 tag3 tag4 tag5].sort) }
      end
    end

    context 'with a nuspec file content with metadata' do
      let_it_be(:nuspec_filepath) { 'packages/nuget/with_metadata.nuspec' }

      it 'returns the correct metadata' do
        expected_metadata = {
          authors: 'Author Test',
          description: 'Description Test',
          license_url: 'https://opensource.org/licenses/MIT',
          project_url: 'https://gitlab.com/gitlab-org/gitlab',
          icon_url: 'https://opensource.org/files/osi_keyhole_300X300_90ppi_0.png'
        }

        expect(subject.slice(*expected_metadata.keys)).to eq(expected_metadata)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Nuget
    class SearchService < BaseService
      include ::Packages::FinderHelper
      include Gitlab::Utils::StrongMemoize
      include ActiveRecord::ConnectionAdapters::Quoting

      MAX_PER_PAGE = 30
      MAX_VERSIONS_PER_PACKAGE = 10
      PRE_RELEASE_VERSION_MATCHING_TERM = '%-%'

      DEFAULT_OPTIONS = {
        include_prerelease_versions: true,
        per_page: Kaminari.config.default_per_page,
        padding: 0
      }.freeze

      def initialize(current_user, project_or_group, search_term, options = {})
        @current_user = current_user
        @project_or_group = project_or_group
        @search_term = search_term
        @options = DEFAULT_OPTIONS.merge(options)

        raise ArgumentError, 'negative per_page' if per_page < 0
        raise ArgumentError, 'negative padding' if padding < 0
      end

      def execute
        Result.new(
          total_count: non_paginated_matching_package_names.count,
          results: search_packages
        )
      end

      private

      def search_packages
        # custom query to get package names and versions as expected from the nuget search api
        # See https://gitlab.com/gitlab-org/gitlab/-/merge_requests/24182#technical-notes
        # and https://docs.microsoft.com/en-us/nuget/api/search-query-service-resource
        subquery_name = :partition_subquery
        arel_table = Arel::Table.new(subquery_name)
        column_names = Packages::Package.column_names.map do |cn|
          ""#{subquery_name}.#{quote_column_name(cn)}""
        end

        # rubocop: disable CodeReuse/ActiveRecord
        pkgs = Packages::Package
        pkgs = pkgs.with(project_ids_cte.to_arel) if use_project_ids_cte?
        pkgs = pkgs.select(column_names.join(','))
                   .from(package_names_partition, subquery_name)
                   .where(arel_table[:row_number].lteq(MAX_VERSIONS_PER_PACKAGE))

        return pkgs if include_prerelease_versions?

        # we can't use pkgs.without_version_like since we have a custom from
        pkgs.where.not(arel_table[:version].matches(PRE_RELEASE_VERSION_MATCHING_TERM))
        # rubocop: enable CodeReuse/ActiveRecord
      end

      def package_names_partition
        # rubocop: disable CodeReuse/ActiveRecord
        table_name = quote_table_name(Packages::Package.table_name)
        name_column = ""#{table_name}.#{quote_column_name('name')}""
        created_at_column = ""#{table_name}.#{quote_column_name('created_at')}""
        select_sql = ""ROW_NUMBER() OVER (PARTITION BY #{name_column} ORDER BY #{created_at_column} DESC) AS row_number, #{table_name}.*""

        nuget_packages.select(select_sql)
                      .with_name(paginated_matching_package_names)
                      .where(project_id: project_ids)
        # rubocop: enable CodeReuse/ActiveRecord
      end

      def paginated_matching_package_names
        pkgs = base_matching_package_names
        pkgs.page(0) # we're using a padding
            .per(per_page)
            .padding(padding)
      end

      def non_paginated_matching_package_names
        # rubocop: disable CodeReuse/ActiveRecord
        pkgs = base_matching_package_names
        pkgs = pkgs.with(project_ids_cte.to_arel) if use_project_ids_cte?
        pkgs
        # rubocop: enable CodeReuse/ActiveRecord
      end

      def base_matching_package_names
        # rubocop: disable CodeReuse/ActiveRecord
        pkgs = nuget_packages.order_name
                               .select_distinct_name
                               .where(project_id: project_ids)
        pkgs = pkgs.without_version_like(PRE_RELEASE_VERSION_MATCHING_TERM) unless include_prerelease_versions?
        pkgs = pkgs.search_by_name(@search_term) if @search_term.present?
        pkgs
        # rubocop: enable CodeReuse/ActiveRecord
      end
      strong_memoize_attr :base_matching_package_names

      def nuget_packages
        Packages::Package.nuget
                         .displayable
                         .has_version
                         .without_nuget_temporary_name
      end

      def project_ids_cte
        return unless use_project_ids_cte?

        query = projects_visible_to_user(@current_user, within_group: @project_or_group)
        Gitlab::SQL::CTE.new(:project_ids, query.select(:id))
      end
      strong_memoize_attr :project_ids_cte

      def project_ids
        return @project_or_group.id if project?

        if use_project_ids_cte?
          # rubocop: disable CodeReuse/ActiveRecord
          Project.select(:id)
                 .from(project_ids_cte.table)
          # rubocop: enable CodeReuse/ActiveRecord
        end
      end

      def use_project_ids_cte?
        group?
      end

      def project?
        @project_or_group.is_a?(::Project)
      end

      def group?
        @project_or_group.is_a?(::Group)
      end

      def include_prerelease_versions?
        @options[:include_prerelease_versions]
      end

      def padding
        @options[:padding]
      end

      def per_page
        [@options[:per_page], MAX_PER_PAGE].min
      end

      class Result
        include ActiveModel::Model

        attr_accessor :results, :total_count
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Nuget::SearchService, feature_category: :package_registry do
  let_it_be(:user) { create(:user) }
  let_it_be(:group) { create(:group) }
  let_it_be(:subgroup) { create(:group, parent: group) }
  let_it_be(:project) { create(:project, namespace: subgroup) }
  let_it_be_with_refind(:package_a) { create(:nuget_package, project: project, name: 'DummyPackageA') }
  let_it_be(:packages_b) { create_list(:nuget_package, 5, project: project, name: 'DummyPackageB') }
  let_it_be(:packages_c) { create_list(:nuget_package, 5, project: project, name: 'DummyPackageC') }
  let_it_be(:package_d) { create(:nuget_package, project: project, name: 'FooBarD') }
  let_it_be(:other_package_a) { create(:nuget_package, name: 'DummyPackageA') }
  let_it_be(:other_package_a) { create(:nuget_package, name: 'DummyPackageB') }

  let(:search_term) { 'ummy' }
  let(:per_page) { 5 }
  let(:padding) { 0 }
  let(:include_prerelease_versions) { true }
  let(:options) { { include_prerelease_versions: include_prerelease_versions, per_page: per_page, padding: padding } }

  describe '#execute' do
    subject { described_class.new(user, target, search_term, options).execute }

    shared_examples 'handling all the conditions' do
      it { expect_search_results 3, package_a, packages_b, packages_c }

      context 'with a smaller per page count' do
        let(:per_page) { 2 }

        it { expect_search_results 3, package_a, packages_b }
      end

      context 'with 0 per page count' do
        let(:per_page) { 0 }

        it { expect_search_results 3, [] }
      end

      context 'with a negative per page count' do
        let(:per_page) { -1 }

        it { expect { subject }.to raise_error(ArgumentError, 'negative per_page') }
      end

      context 'with a padding' do
        let(:padding) { 2 }

        it { expect_search_results 3, packages_c }
      end

      context 'with a too big padding' do
        let(:padding) { 5 }

        it { expect_search_results 3, [] }
      end

      context 'with a negative padding' do
        let(:padding) { -1 }

        it { expect { subject }.to raise_error(ArgumentError, 'negative padding') }
      end

      context 'with search term' do
        let(:search_term) { 'umm' }

        it { expect_search_results 3, package_a, packages_b, packages_c }
      end

      context 'with nil search term' do
        let(:search_term) { nil }

        it { expect_search_results 4, package_a, packages_b, packages_c, package_d }
      end

      context 'with empty search term' do
        let(:search_term) { '' }

        it { expect_search_results 4, package_a, packages_b, packages_c, package_d }
      end

      context 'with non-displayable packages' do
        let(:search_term) { '' }

        before do
          package_a.update_column(:status, 1)
        end

        it { expect_search_results 3, packages_b, packages_c, package_d }
      end

      context 'with prefix search term' do
        let(:search_term) { 'dummy' }

        it { expect_search_results 3, package_a, packages_b, packages_c }
      end

      context 'with suffix search term' do
        let(:search_term) { 'packagec' }

        it { expect_search_results 1, packages_c }
      end

      context 'with pre release packages' do
        let_it_be(:package_e) { create(:nuget_package, project: project, name: 'DummyPackageE', version: '3.2.1-alpha') }

        context 'including them' do
          it { expect_search_results 4, package_a, packages_b, packages_c, package_e }
        end

        context 'excluding them' do
          let(:include_prerelease_versions) { false }

          it { expect_search_results 3, package_a, packages_b, packages_c }

          context 'when mixed with release versions' do
            let_it_be(:package_e_release) { create(:nuget_package, project: project, name: 'DummyPackageE', version: '3.2.1') }

            it { expect_search_results 4, package_a, packages_b, packages_c, package_e_release }
          end
        end
      end
    end

    context 'with project' do
      let(:target) { project }

      before do
        project.add_developer(user)
      end

      it_behaves_like 'handling all the conditions'
    end

    context 'with subgroup' do
      let(:target) { subgroup }

      before do
        subgroup.add_developer(user)
      end

      it_behaves_like 'handling all the conditions'
    end

    context 'with group' do
      let(:target) { group }

      before do
        group.add_developer(user)
      end

      it_behaves_like 'handling all the conditions'
    end

    def expect_search_results(total_count, *results)
      search = subject

      expect(search.total_count).to eq total_count
      expect(search.results).to match_array(Array.wrap(results).flatten)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Nuget
    class SyncMetadatumService
      include Gitlab::Utils::StrongMemoize

      def initialize(package, metadata)
        @package = package
        @metadata = metadata
      end

      def execute
        if blank_metadata?
          metadatum.destroy! if metadatum.persisted?
        else
          metadatum.update!(
            authors: authors,
            description: description,
            license_url: license_url,
            project_url: project_url,
            icon_url: icon_url
          )
        end
      end

      private

      attr_reader :package, :metadata

      def metadatum
        package.nuget_metadatum || package.build_nuget_metadatum
      end
      strong_memoize_attr :metadatum

      def blank_metadata?
        [authors, description, project_url, license_url, icon_url].all?(&:blank?)
      end

      def authors
        truncate_value(:authors, ::Packages::Nuget::Metadatum::MAX_AUTHORS_LENGTH)
      end
      strong_memoize_attr :authors

      def description
        truncate_value(:description, ::Packages::Nuget::Metadatum::MAX_DESCRIPTION_LENGTH)
      end
      strong_memoize_attr :description

      def project_url
        metadata[:project_url]
      end

      def license_url
        metadata[:license_url]
      end

      def icon_url
        metadata[:icon_url]
      end

      def truncate_value(field, max_length)
        return unless metadata[field]

        if metadata[field].size > max_length
          log_info(""#{field.capitalize} is too long (maximum is #{max_length} characters)"", field)
        end

        metadata[field].truncate(max_length)
      end

      def log_info(message, field)
        Gitlab::AppLogger.info(
          class: self.class.name,
          message: message,
          package_id: package.id,
          project_id: package.project_id,
          field => metadata[field]
        )
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Nuget::SyncMetadatumService, feature_category: :package_registry do
  let_it_be(:package, reload: true) { create(:nuget_package) }
  let_it_be(:metadata) do
    {
      authors: 'Package authors',
      description: 'Package description',
      project_url: 'https://test.org/test',
      license_url: 'https://test.org/MIT',
      icon_url: 'https://test.org/icon.png'
    }
  end

  let(:service) { described_class.new(package, metadata) }
  let(:nuget_metadatum) { package.nuget_metadatum }

  describe '#execute' do
    subject { service.execute }

    RSpec.shared_examples 'saving metadatum attributes' do
      it 'saves nuget metadatum' do
        subject

        metadata.each do |attribute, expected_value|
          expect(nuget_metadatum.send(attribute)).to eq(expected_value)
        end
      end
    end

    it 'creates a nuget metadatum' do
      expect { subject }
        .to change { package.nuget_metadatum.present? }.from(false).to(true)
    end

    it_behaves_like 'saving metadatum attributes'

    context 'with exisiting nuget metadatum' do
      let_it_be(:package) { create(:nuget_package, :with_metadatum) }

      it 'does not create a nuget metadatum' do
        expect { subject }.to change { ::Packages::Nuget::Metadatum.count }.by(0)
      end

      it_behaves_like 'saving metadatum attributes'

      context 'with empty metadata' do
        let_it_be(:metadata) { {} }

        it 'destroys the nuget metadatum' do
          expect { subject }
            .to change { package.reload.nuget_metadatum.present? }.from(true).to(false)
        end
      end
    end

    context 'with metadata containing only authors and description' do
      let_it_be(:metadata) { { authors: 'Package authors 2', description: 'Package description 2' } }

      it 'updates the nuget metadatum' do
        subject

        expect(nuget_metadatum.authors).to eq('Package authors 2')
        expect(nuget_metadatum.description).to eq('Package description 2')
      end
    end

    context 'with too long metadata' do
      let(:metadata) { super().merge(authors: 'a' * 260, description: 'a' * 4010) }
      let(:max_authors_length) { ::Packages::Nuget::Metadatum::MAX_AUTHORS_LENGTH }
      let(:max_description_length) { ::Packages::Nuget::Metadatum::MAX_DESCRIPTION_LENGTH }

      it 'truncates authors and description to the maximum length and logs its info' do
        %i[authors description].each do |field|
          expect(Gitlab::AppLogger).to receive(:info).with(
            class: described_class.name,
            package_id: package.id,
            project_id: package.project_id,
            message: ""#{field.capitalize} is too long (maximum is #{send(""max_#{field}_length"")} characters)"",
            field => metadata[field]
          )
        end

        subject

        expect(nuget_metadatum.authors.size).to eq(max_authors_length)
        expect(nuget_metadatum.description.size).to eq(max_description_length)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Nuget
    class OdataPackageEntryService
      include API::Helpers::RelatedResourcesHelpers

      def initialize(project, params)
        @project = project
        @params = params
      end

      def execute
        ServiceResponse.success(payload: package_entry)
      end

      private

      attr_reader :project, :params

      def package_entry
        <<-XML.squish
          <entry xmlns='http://www.w3.org/2005/Atom' xmlns:d='http://schemas.microsoft.com/ado/2007/08/dataservices' xmlns:georss='http://www.georss.org/georss' xmlns:gml='http://www.opengis.net/gml' xmlns:m='http://schemas.microsoft.com/ado/2007/08/dataservices/metadata' xml:base=""#{xml_base}"">
            <id>#{id_url}</id>
            <category term='V2FeedPackage' scheme='http://schemas.microsoft.com/ado/2007/08/dataservices/scheme'/>
            <title type='text'>#{params[:package_name]}</title>
            <content type='application/zip' src=""#{download_url}""/>
            <m:properties>
              <d:Version>#{params[:package_version]}</d:Version>
            </m:properties>
          </entry>
        XML
      end

      def id_url
        expose_url ""#{api_v4_projects_packages_nuget_v2_path(id: project.id)}"" \
                   ""/Packages(Id='#{params[:package_name]}',Version='#{params[:package_version]}')""
      end

      def download_url
        if params[:package_version].present?
          expose_url api_v4_projects_packages_nuget_download_package_name_package_version_package_filename_path(
            {
              id: project.id,
              package_name: params[:package_name],
              package_version: params[:package_version],
              package_filename: file_name
            },
            true
          )
        else
          xml_base
        end
      end

      def xml_base
        expose_url api_v4_projects_packages_nuget_v2_path(id: project.id)
      end

      def file_name
        ""#{params[:package_name]}.#{params[:package_version]}.nupkg""
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Nuget::OdataPackageEntryService, feature_category: :package_registry do
  include GrapePathHelpers::NamedRouteMatcher

  let_it_be(:project) { build_stubbed(:project) }
  let_it_be(:params) { { package_name: 'dummy', package_version: '1.0.0' } }
  let(:doc) { Nokogiri::XML(subject.payload) }

  subject { described_class.new(project, params).execute }

  describe '#execute' do
    shared_examples 'returning a package entry with the correct attributes' do |pkg_version = ''|
      it 'returns a package entry with the correct attributes' do
        expect(doc.root.name).to eq('entry')
        expect(doc_node('id').text).to include(
          id_url(project.id, params[:package_name], pkg_version)
        )
        expect(doc_node('title').text).to eq(params[:package_name])
        expect(doc_node('content').attr('src')).to include(
          content_url(project.id, params[:package_name], pkg_version)
        )
        expect(doc_node('Version').text).to eq(pkg_version)
      end
    end

    context 'when package_version is present' do
      it 'returns a success ServiceResponse' do
        expect(subject).to be_success
      end

      it_behaves_like 'returning a package entry with the correct attributes', '1.0.0'
    end

    context 'when package_version is not present' do
      let(:params) { { package_name: 'dummy', package_version: nil } }

      it 'returns a success ServiceResponse' do
        expect(subject).to be_success
      end

      it_behaves_like 'returning a package entry with the correct attributes'
    end
  end

  def doc_node(name)
    doc.css('*').detect { |el| el.name == name }
  end

  def id_url(id, package_name, package_version)
    ""api/v4/projects/#{id}/packages/nuget/v2/Packages(Id='#{package_name}',Version='#{package_version}')""
  end

  def content_url(id, package_name, package_version)
    if package_version.present?
      filename = ""#{package_name}.#{package_version}.nupkg""
      api_v4_projects_packages_nuget_download_package_name_package_version_package_filename_path(
        { id: id, package_name: package_name, package_version: package_version, package_filename: filename }, true
      )
    else
      api_v4_projects_packages_nuget_v2_path(id: id)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Nuget
    class UpdatePackageFromMetadataService
      include Gitlab::Utils::StrongMemoize
      include ExclusiveLeaseGuard

      # used by ExclusiveLeaseGuard
      DEFAULT_LEASE_TIMEOUT = 1.hour.to_i.freeze
      SYMBOL_PACKAGE_IDENTIFIER = 'SymbolsPackage'
      INVALID_METADATA_ERROR_MESSAGE = 'package name, version, authors and/or description not found in metadata'
      INVALID_METADATA_ERROR_SYMBOL_MESSAGE = 'package name, version and/or description not found in metadata'
      MISSING_MATCHING_PACKAGE_ERROR_MESSAGE = 'symbol package is invalid, matching package does not exist'

      InvalidMetadataError = ZipError = Class.new(StandardError)

      def initialize(package_file, package_zip_file)
        @package_file = package_file
        @package_zip_file = package_zip_file
      end

      def execute
        unless valid_metadata?
          error_message = symbol_package? ? INVALID_METADATA_ERROR_SYMBOL_MESSAGE : INVALID_METADATA_ERROR_MESSAGE
          raise InvalidMetadataError, error_message
        end

        try_obtain_lease do
          @package_file.transaction do
            process_package_update
          end
        end
      rescue ActiveRecord::RecordInvalid => e
        raise InvalidMetadataError, e.message
      rescue Zip::Error
        raise ZipError, 'Could not open the .nupkg file'
      end

      private

      def process_package_update
        package_to_destroy = nil
        target_package = @package_file.package

        if existing_package
          package_to_destroy = @package_file.package
          target_package = existing_package
        else
          if symbol_package?
            raise InvalidMetadataError, MISSING_MATCHING_PACKAGE_ERROR_MESSAGE
          end

          update_linked_package
        end

        build_infos = package_to_destroy&.build_infos || []

        update_package(target_package, build_infos)
        create_symbol_files
        ::Packages::UpdatePackageFileService.new(@package_file, package_id: target_package.id, file_name: package_filename)
                                            .execute
        package_to_destroy&.destroy!
      end

      def update_package(package, build_infos)
        return if symbol_package?

        ::Packages::Nuget::SyncMetadatumService
          .new(package, metadata.slice(:authors, :description, :project_url, :license_url, :icon_url))
          .execute

        ::Packages::UpdateTagsService
          .new(package, package_tags)
          .execute

        package.build_infos << build_infos if build_infos.any?
      rescue StandardError => e
        raise InvalidMetadataError, e.message
      end

      def create_symbol_files
        return unless symbol_package?

        ::Packages::Nuget::Symbols::CreateSymbolFilesService
          .new(existing_package, @package_zip_file)
          .execute
      end

      def valid_metadata?
        fields = [package_name, package_version, package_description]
        fields << package_authors unless symbol_package?
        fields.all?(&:present?)
      end

      def update_linked_package
        @package_file.package.update!(
          name: package_name,
          version: package_version,
          status: :default
        )

        ::Packages::Nuget::CreateDependencyService.new(@package_file.package, package_dependencies)
                                                  .execute
        @package_file.package
      end

      def existing_package
        ::Packages::Nuget::PackageFinder
          .new(
            nil,
            @package_file.project,
            package_name: package_name,
            package_version: package_version
          )
          .execute
          .first
      end
      strong_memoize_attr :existing_package

      def package_name
        metadata[:package_name]
      end

      def package_version
        metadata[:package_version]
      end

      def package_dependencies
        metadata.fetch(:package_dependencies, [])
      end

      def package_tags
        metadata.fetch(:package_tags, [])
      end

      def package_types
        metadata.fetch(:package_types, [])
      end

      def package_authors
        metadata[:authors]
      end

      def package_description
        metadata[:description]
      end

      def symbol_package?
        package_types.include?(SYMBOL_PACKAGE_IDENTIFIER)
      end
      strong_memoize_attr :symbol_package?

      def metadata
        ::Packages::Nuget::MetadataExtractionService.new(@package_zip_file).execute.payload
      end
      strong_memoize_attr :metadata

      def package_filename
        ""#{package_name.downcase}.#{package_version.downcase}.#{symbol_package? ? 'snupkg' : 'nupkg'}""
      end

      # used by ExclusiveLeaseGuard
      def lease_key
        package_id = existing_package ? existing_package.id : @package_file.package_id
        ""packages:nuget:update_package_from_metadata_service:package:#{package_id}""
      end

      # used by ExclusiveLeaseGuard
      def lease_timeout
        DEFAULT_LEASE_TIMEOUT
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Nuget::UpdatePackageFromMetadataService, :clean_gitlab_redis_shared_state, feature_category: :package_registry do
  include ExclusiveLeaseHelpers

  let!(:package) { create(:nuget_package, :processing, :with_symbol_package, :with_build) }
  let(:package_file) { package.package_files.first }
  let(:package_zip_file) { Zip::File.new(package_file.file) }
  let(:service) { described_class.new(package_file, package_zip_file) }
  let(:package_name) { 'DummyProject.DummyPackage' }
  let(:package_version) { '1.0.0' }
  let(:package_file_name) { 'dummyproject.dummypackage.1.0.0.nupkg' }

  shared_examples 'raising an' do |error_class, with_message:|
    it ""raises an #{error_class}"" do
      expect { subject }.to raise_error(error_class, with_message)
    end
  end

  describe '#execute' do
    using RSpec::Parameterized::TableSyntax

    subject { service.execute }

    shared_examples 'taking the lease' do
      before do
        allow(service).to receive(:lease_release?).and_return(false)
      end

      it 'takes the lease' do
        expect(service).to receive(:try_obtain_lease).and_call_original

        subject

        expect(service.exclusive_lease.exists?).to be_truthy
      end
    end

    shared_examples 'not updating the package if the lease is taken' do
      context 'without obtaining the exclusive lease' do
        let(:lease_key) { ""packages:nuget:update_package_from_metadata_service:package:#{package_id}"" }
        let(:metadata) { { package_name: package_name, package_version: package_version, authors: 'author1, author2', description: 'test description' } }
        let(:package_from_package_file) { package_file.package }

        before do
          stub_exclusive_lease_taken(lease_key, timeout: 1.hour)
          # to allow the above stub, we need to stub the metadata function as the
          # original implementation will try to get an exclusive lease on the
          # file in object storage
          allow(service).to receive(:metadata).and_return(metadata)
        end

        it 'does not update the package', :aggregate_failures do
          expect(service).to receive(:try_obtain_lease).and_call_original

          expect { subject }
            .to change { ::Packages::Package.count }.by(0)
            .and change { Packages::DependencyLink.count }.by(0)
          expect(package_file.reload.file_name).not_to eq(package_file_name)
          expect(package_file.package).to be_processing
          expect(package_file.package.reload.name).not_to eq(package_name)
          expect(package_file.package.version).not_to eq(package_version)
        end
      end
    end

    context 'with no existing package' do
      let(:package_id) { package.id }

      it 'updates package and package file and creates metadatum', :aggregate_failures do
        expect { subject }
          .to not_change { ::Packages::Package.count }
          .and change { Packages::Dependency.count }.by(1)
          .and change { Packages::DependencyLink.count }.by(1)
          .and change { ::Packages::Nuget::Metadatum.count }.by(1)

        expect(package.reload.name).to eq(package_name)
        expect(package.version).to eq(package_version)
        expect(package).to be_default
        expect(package_file.reload.file_name).to eq(package_file_name)
        # hard reset needed to properly reload package_file.file
        expect(Packages::PackageFile.find(package_file.id).file.size).not_to eq 0
      end

      it_behaves_like 'taking the lease'

      it_behaves_like 'not updating the package if the lease is taken'
    end

    context 'with existing package' do
      let!(:existing_package) { create(:nuget_package, project: package.project, name: package_name, version: package_version) }
      let(:package_id) { existing_package.id }

      it 'link existing package and updates package file', :aggregate_failures do
        expect(service).to receive(:try_obtain_lease).and_call_original

        expect { subject }
          .to change { ::Packages::Package.count }.by(-1)
          .and change { Packages::Dependency.count }.by(0)
          .and change { Packages::DependencyLink.count }.by(0)
          .and change { Packages::Nuget::DependencyLinkMetadatum.count }.by(0)
          .and change { ::Packages::Nuget::Metadatum.count }.by(1)
          .and change { existing_package.build_infos.count }.by(1)
        expect(package_file.reload.file_name).to eq(package_file_name)
        expect(package_file.package).to eq(existing_package)
      end

      it_behaves_like 'taking the lease'

      it_behaves_like 'not updating the package if the lease is taken'

      context 'marked as pending_destruction' do
        before do
          existing_package.pending_destruction!
        end

        it 'reuses the processing package', :aggregate_failures do
          expect { subject }
            .to not_change { ::Packages::Package.count }
            .and change { Packages::Dependency.count }.by(1)
            .and change { Packages::DependencyLink.count }.by(1)
            .and change { ::Packages::Nuget::Metadatum.count }.by(1)
        end
      end
    end

    context 'with a nuspec file with metadata' do
      let(:nuspec_filepath) { 'packages/nuget/with_metadata.nuspec' }
      let(:expected_tags) { %w[foo bar test tag1 tag2 tag3 tag4 tag5] }

      before do
        allow_next_instance_of(Packages::Nuget::MetadataExtractionService) do |service|
          allow(service)
            .to receive(:nuspec_file_content).and_return(fixture_file(nuspec_filepath))
        end
      end

      it 'creates tags' do
        expect(service).to receive(:try_obtain_lease).and_call_original
        expect { subject }.to change { ::Packages::Tag.count }.by(8)
        expect(package.reload.tags.map(&:name)).to contain_exactly(*expected_tags)
      end

      context 'with existing package and tags' do
        let!(:existing_package) { create(:nuget_package, project: package.project, name: 'DummyProject.WithMetadata', version: '1.2.3') }
        let!(:tag1) { create(:packages_tag, package: existing_package, name: 'tag1') }
        let!(:tag2) { create(:packages_tag, package: existing_package, name: 'tag2') }
        let!(:tag3) { create(:packages_tag, package: existing_package, name: 'tag_not_in_metadata') }

        it 'creates tags and deletes those not in metadata' do
          expect(service).to receive(:try_obtain_lease).and_call_original
          expect { subject }.to change { ::Packages::Tag.count }.by(5)
          expect(existing_package.tags.map(&:name)).to contain_exactly(*expected_tags)
        end
      end

      it 'creates nuget metadatum', :aggregate_failures do
        expect { subject }
          .to not_change { ::Packages::Package.count }
          .and change { ::Packages::Nuget::Metadatum.count }.by(1)

        metadatum = package_file.reload.package.nuget_metadatum
        expect(metadatum.authors).to eq('Author Test')
        expect(metadatum.description).to eq('Description Test')
        expect(metadatum.license_url).to eq('https://opensource.org/licenses/MIT')
        expect(metadatum.project_url).to eq('https://gitlab.com/gitlab-org/gitlab')
        expect(metadatum.icon_url).to eq('https://opensource.org/files/osi_keyhole_300X300_90ppi_0.png')
      end

      context 'with too long url' do
        let_it_be(:too_long_url) { ""http://localhost/#{'bananas' * 50}"" }

        let(:metadata) { { package_name: package_name, package_version: package_version, authors: 'Author Test', description: 'Description Test', license_url: too_long_url } }

        before do
          allow(service).to receive(:metadata).and_return(metadata)
        end

        it_behaves_like 'raising an', described_class::InvalidMetadataError, with_message: /Validation failed: License url is too long/
      end

      context 'without authors or description' do
        %i[authors description].each do |property|
          context ""for #{property}"" do
            let(:metadata) { { package_name: package_name, package_version: package_version, property => nil } }

            before do
              allow(service).to receive(:metadata).and_return(metadata)
            end

            it_behaves_like 'raising an', described_class::InvalidMetadataError, with_message: described_class::INVALID_METADATA_ERROR_MESSAGE
          end
        end
      end
    end

    context 'with nuspec file with dependencies' do
      let(:nuspec_filepath) { 'packages/nuget/with_dependencies.nuspec' }
      let(:package_name) { 'Test.Package' }
      let(:package_version) { '3.5.2' }
      let(:package_file_name) { 'test.package.3.5.2.nupkg' }

      before do
        allow_next_instance_of(Packages::Nuget::MetadataExtractionService) do |service|
          allow(service)
            .to receive(:nuspec_file_content).and_return(fixture_file(nuspec_filepath))
        end
      end

      it 'updates package and package file', :aggregate_failures do
        expect { subject }
          .to not_change { ::Packages::Package.count }
          .and change { Packages::Dependency.count }.by(4)
          .and change { Packages::DependencyLink.count }.by(4)
          .and change { Packages::Nuget::DependencyLinkMetadatum.count }.by(2)

        expect(package.reload.name).to eq(package_name)
        expect(package.version).to eq(package_version)
        expect(package).to be_default
        expect(package_file.reload.file_name).to eq(package_file_name)
        # hard reset needed to properly reload package_file.file
        expect(Packages::PackageFile.find(package_file.id).file.size).not_to eq 0
      end
    end

    context 'with package file not containing a nuspec file' do
      before do
        allow_next_instance_of(Zip::File) do |file|
          allow(file).to receive(:glob).and_return([])
        end
      end

      it_behaves_like 'raising an', ::Packages::Nuget::ExtractMetadataFileService::ExtractionError, with_message: 'nuspec file not found'
    end

    context 'with a symbol package' do
      let(:package_file) { package.package_files.last }
      let(:package_file_name) { 'dummyproject.dummypackage.1.0.0.snupkg' }

      context 'with no existing package' do
        let(:package_id) { package.id }

        it_behaves_like 'raising an', described_class::InvalidMetadataError, with_message: described_class::MISSING_MATCHING_PACKAGE_ERROR_MESSAGE
      end

      context 'with existing package' do
        let!(:existing_package) { create(:nuget_package, project: package.project, name: package_name, version: package_version) }
        let(:package_id) { existing_package.id }
        let(:package_zip_file) do
          Zip::File.open(package_file.file.path) do |zipfile|
            zipfile.add('package.pdb', expand_fixture_path('packages/nuget/symbol/package.pdb'))
            zipfile
          end
        end

        it 'link existing package and updates package file', :aggregate_failures do
          expect(service).to receive(:try_obtain_lease).and_call_original
          expect(::Packages::Nuget::SyncMetadatumService).not_to receive(:new)
          expect(::Packages::UpdateTagsService).not_to receive(:new)
          expect_next_instance_of(Packages::Nuget::Symbols::CreateSymbolFilesService, existing_package, package_zip_file) do |service|
            expect(service).to receive(:execute).and_call_original
          end

          expect { subject }
            .to change { ::Packages::Package.count }.by(-1)
            .and change { Packages::Dependency.count }.by(0)
            .and change { Packages::DependencyLink.count }.by(0)
            .and change { Packages::Nuget::DependencyLinkMetadatum.count }.by(0)
            .and change { ::Packages::Nuget::Metadatum.count }.by(0)
            .and change { existing_package.nuget_symbols.count }.by(1)
          expect(package_file.reload.file_name).to eq(package_file_name)
          expect(package_file.package).to eq(existing_package)
        end

        it_behaves_like 'taking the lease'

        it_behaves_like 'not updating the package if the lease is taken'
      end
    end

    context 'with an invalid package name' do
      invalid_name_error_msg = 'Validation failed: Name is invalid'

      where(:invalid_name, :error_message) do
        ''                    | described_class::INVALID_METADATA_ERROR_MESSAGE
        'My/package'          | invalid_name_error_msg
        '../../../my_package' | invalid_name_error_msg
        '%2e%2e%2fmy_package' | invalid_name_error_msg
      end

      with_them do
        before do
          allow(service).to receive(:package_name).and_return(invalid_name)
        end

        it_behaves_like 'raising an', described_class::InvalidMetadataError, with_message: params[:error_message]
      end
    end

    context 'with an invalid package version' do
      invalid_version_error_msg = 'Validation failed: Version is invalid'

      where(:invalid_version, :error_message) do
        ''                     | described_class::INVALID_METADATA_ERROR_MESSAGE
        '555'                  | invalid_version_error_msg
        '1./2.3'               | invalid_version_error_msg
        '../../../../../1.2.3' | invalid_version_error_msg
        '%2e%2e%2f1.2.3'       | invalid_version_error_msg
      end

      with_them do
        before do
          allow(service).to receive(:package_version).and_return(invalid_version)
        end

        it_behaves_like 'raising an', described_class::InvalidMetadataError, with_message: params[:error_message]
      end
    end

    context 'with an invalid zip file' do
      before do
        allow_next_instance_of(::Packages::Nuget::MetadataExtractionService) do |instance|
          allow(instance).to receive(:execute).and_raise(Zip::Error)
        end
      end

      it_behaves_like 'raising an', described_class::ZipError, with_message: 'Could not open the .nupkg file'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Nuget
    class CheckDuplicatesService < BaseService
      include Gitlab::Utils::StrongMemoize

      ExtractionError = Class.new(StandardError)

      def execute
        return ServiceResponse.success if package_settings_allow_duplicates? || !target_package_is_duplicate?

        ServiceResponse.error(
          message: 'A package with the same name and version already exists',
          reason: :conflict
        )
      rescue ExtractionError => e
        ServiceResponse.error(message: e.message, reason: :bad_request)
      end

      private

      def package_settings_allow_duplicates?
        package_settings.nuget_duplicates_allowed? || package_settings.class.duplicates_allowed?(existing_package)
      end

      def target_package_is_duplicate?
        existing_package.name.casecmp(metadata[:package_name]) == 0 &&
          (existing_package.version.casecmp(metadata[:package_version]) == 0 ||
            existing_package.normalized_nuget_version&.casecmp(metadata[:package_version]) == 0)
      end

      def package_settings
        project.namespace.package_settings
      end
      strong_memoize_attr :package_settings

      def existing_package
        ::Packages::Nuget::PackageFinder
          .new(
            current_user,
            project,
            package_name: metadata[:package_name],
            package_version: metadata[:package_version]
          )
          .execute
          .first
      end
      strong_memoize_attr :existing_package

      def metadata
        if params[:remote_url].present?
          ::Packages::Nuget::ExtractMetadataContentService
            .new(nuspec_file_content)
            .execute
            .payload
        else # to cover the case when package file is on disk not in object storage
          Zip::InputStream.open(params[:file]) do |zip|
            ::Packages::Nuget::MetadataExtractionService
              .new(zip)
              .execute
              .payload
          end
        end
      end
      strong_memoize_attr :metadata

      def nuspec_file_content
        ::Packages::Nuget::ExtractRemoteMetadataFileService
          .new(params[:remote_url])
          .execute
          .payload
      rescue ::Packages::Nuget::ExtractRemoteMetadataFileService::ExtractionError => e
        raise ExtractionError, e.message
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Nuget::CheckDuplicatesService, feature_category: :package_registry do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }
  let_it_be(:file_name) { 'package.nupkg' }

  let(:params) do
    {
      file_name: file_name,
      file: File.open(expand_fixture_path('packages/nuget/package.nupkg'))
    }
  end

  let(:service) { described_class.new(project, user, params) }

  describe '#execute' do
    subject(:execute) { service.execute }

    shared_examples 'returning error' do |reason:, message:|
      it 'returns an error' do
        response = execute

        expect(response.status).to eq(:error)
        expect(response.reason).to eq(reason)
        expect(response.message).to eq(message)
      end
    end

    shared_examples 'returning success' do
      it 'returns success' do
        response = execute

        expect(response.status).to eq(:success)
      end
    end

    shared_examples 'handling duplicates disallowed when package exists' do
      it_behaves_like 'returning error', reason: :conflict,
        message: 'A package with the same name and version already exists'

      context 'with nuget_duplicate_exception_regex' do
        before do
          package_settings.update_column(:nuget_duplicate_exception_regex, "".*#{existing_package.name.last(3)}.*"")
        end

        it_behaves_like 'returning success'
      end
    end

    context 'with existing package' do
      let_it_be(:existing_package) { create(:nuget_package, :with_metadatum, project: project, version: '1.7.15.0') }
      let_it_be(:metadata) do
        {
          package_name: existing_package.name,
          package_version: existing_package.version,
          authors: 'authors',
          description: 'description'
        }
      end

      context 'when nuget duplicates are allowed' do
        before do
          allow_next_instance_of(Namespace::PackageSetting) do |instance|
            allow(instance).to receive(:nuget_duplicates_allowed?).and_return(true)
          end
        end

        it_behaves_like 'returning success'
      end

      context 'when nuget duplicates are not allowed' do
        let!(:package_settings) do
          create(:namespace_package_setting, :group, namespace: project.namespace, nuget_duplicates_allowed: false)
        end

        context 'when package file is in object storage' do
          let(:params) { super().merge(remote_url: 'https://example.com') }

          before do
            allow_next_instance_of(::Packages::Nuget::ExtractRemoteMetadataFileService) do |instance|
              allow(instance).to receive(:execute)
              .and_return(ServiceResponse.success(payload: Nokogiri::XML::Document.new))
            end
            allow_next_instance_of(::Packages::Nuget::ExtractMetadataContentService) do |instance|
              allow(instance).to receive(:execute).and_return(ServiceResponse.success(payload: metadata))
            end
          end

          it_behaves_like 'handling duplicates disallowed when package exists'

          context 'when ExtractRemoteMetadataFileService raises ExtractionError' do
            before do
              allow_next_instance_of(::Packages::Nuget::ExtractRemoteMetadataFileService) do |instance|
                allow(instance).to receive(:execute).and_raise(
                  ::Packages::Nuget::ExtractRemoteMetadataFileService::ExtractionError, 'nuspec file not found'
                )
              end
            end

            it_behaves_like 'returning error', reason: :bad_request, message: 'nuspec file not found'
          end

          context 'when version is normalized' do
            let(:metadata) { super().merge(package_version: '1.7.15') }

            it_behaves_like 'handling duplicates disallowed when package exists'
          end
        end

        context 'when package file is on disk' do
          before do
            allow_next_instance_of(::Packages::Nuget::MetadataExtractionService) do |instance|
              allow(instance).to receive(:execute).and_return(ServiceResponse.success(payload: metadata))
            end
          end

          it_behaves_like 'handling duplicates disallowed when package exists'
        end
      end
    end

    context 'with non existing package' do
      let_it_be(:metadata) do
        { package_name: 'foo', package_version: '1.0.0', authors: 'author', description: 'description' }
      end

      before do
        allow_next_instance_of(::Packages::Nuget::MetadataExtractionService) do |instance|
          allow(instance).to receive(:execute).and_return(ServiceResponse.success(payload: metadata))
        end
      end

      context 'when nuget duplicates are allowed' do
        let_it_be(:package_settings) do
          create(:namespace_package_setting, :group, namespace: project.namespace, nuget_duplicates_allowed: true)
        end

        it_behaves_like 'returning success'
      end

      context 'when nuget duplicates are not allowed' do
        let_it_be(:package_settings) do
          create(:namespace_package_setting, :group, namespace: project.namespace, nuget_duplicates_allowed: false)
        end

        it_behaves_like 'returning success'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Nuget
    class ProcessPackageFileService
      ExtractionError = Class.new(StandardError)

      def initialize(package_file)
        @package_file = package_file
      end

      def execute
        raise ExtractionError, 'invalid package file' unless valid_package_file?

        with_zip_file do |zip_file|
          ::Packages::Nuget::UpdatePackageFromMetadataService.new(package_file, zip_file).execute
        end
      end

      private

      attr_reader :package_file

      def valid_package_file?
        package_file && package_file.package&.nuget? && !package_file.file.empty_size?
      end

      def with_zip_file(&block)
        package_file.file.use_open_file(unlink_early: false) do |open_file|
          Zip::File.open(open_file.file_path, &block) # rubocop: disable Performance/Rubyzip
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Nuget::ProcessPackageFileService, feature_category: :package_registry do
  let_it_be(:package_file) { build(:package_file, :nuget) }

  let(:service) { described_class.new(package_file) }

  describe '#execute' do
    subject { service.execute }

    shared_examples 'raises an error' do |error_message|
      it { expect { subject }.to raise_error(described_class::ExtractionError, error_message) }
    end

    context 'with valid package file' do
      it 'calls the UpdatePackageFromMetadataService' do
        expect_next_instance_of(Packages::Nuget::UpdatePackageFromMetadataService, package_file,
          instance_of(Zip::File)) do |service|
          expect(service).to receive(:execute)
        end

        subject
      end
    end

    context 'with invalid package file' do
      let(:package_file) { nil }

      it_behaves_like 'raises an error', 'invalid package file'
    end

    context 'when linked to a non nuget package' do
      before do
        package_file.package.maven!
      end

      it_behaves_like 'raises an error', 'invalid package file'
    end

    context 'with a 0 byte package file' do
      before do
        allow_next_instance_of(Packages::PackageFileUploader) do |instance|
          allow(instance).to receive(:size).and_return(0)
        end
      end

      it_behaves_like 'raises an error', 'invalid package file'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
  module Nuget
    class CreateDependencyService < BaseService
      def initialize(package, dependencies = [])
        @package = package
        @dependencies = dependencies
      end

      def execute
        return if @dependencies.empty?

        @package.transaction do
          create_dependency_links
          create_dependency_link_metadata
        end
      end

      private

      def create_dependency_links
        ::Packages::CreateDependencyService
          .new(@package, dependencies_for_create_dependency_service)
          .execute
      end

      def create_dependency_link_metadata
        inserted_links = ::Packages::DependencyLink.preload_dependency
                                                   .for_package(@package)

        return if inserted_links.empty?

        rows = inserted_links.map do |dependency_link|
          raw_dependency = raw_dependency_for(dependency_link.dependency)

          next if raw_dependency[:target_framework].blank?

          {
            dependency_link_id: dependency_link.id,
            target_framework: raw_dependency[:target_framework]
          }
        end

        ::ApplicationRecord.legacy_bulk_insert(::Packages::Nuget::DependencyLinkMetadatum.table_name, rows.compact) # rubocop:disable Gitlab/BulkInsert
      end

      def raw_dependency_for(dependency)
        name = dependency.name
        version = dependency.version_pattern.presence

        @dependencies.find do |raw_dependency|
          raw_dependency[:name] == name && raw_dependency[:version] == version
        end
      end

      def dependencies_for_create_dependency_service
        names_and_versions = @dependencies.to_h do |dependency|
          [dependency[:name], version_or_empty_string(dependency[:version])]
        end

        { 'dependencies' => names_and_versions }
      end

      def version_or_empty_string(version)
        return '' if version.blank?

        version
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::Nuget::CreateDependencyService, feature_category: :package_registry do
  let_it_be(:package, reload: true) { create(:nuget_package) }

  describe '#execute' do
    RSpec.shared_examples 'creating dependencies, links and nuget metadata for' do |expected_dependency_names, dependency_count, dependency_link_count|
      let(:dependencies_with_metadata) { dependencies.select { |dep| dep[:target_framework].present? } }

      it 'creates dependencies, links and nuget metadata' do
        expect { subject }
          .to change { Packages::Dependency.count }.by(dependency_count)
          .and change { Packages::DependencyLink.count }.by(dependency_link_count)
          .and change { Packages::Nuget::DependencyLinkMetadatum.count }.by(dependencies_with_metadata.size)
        expect(expected_dependency_names).to contain_exactly(*dependency_names)
        expect(package.dependency_links.map(&:dependency_type).uniq).to contain_exactly('dependencies')

        dependencies_with_metadata.each do |dependency|
          name = dependency[:name]
          version_pattern = service.send(:version_or_empty_string, dependency[:version])
          metadatum = package.dependency_links.joins(:dependency)
                                              .find_by(packages_dependencies: { name: name, version_pattern: version_pattern })
                                              .nuget_metadatum
          expect(metadatum.target_framework).to eq dependency[:target_framework]
        end
      end
    end

    let_it_be(:dependencies) do
      [
        { name: 'Moqi', version: '2.5.6' },
        { name: 'Castle.Core' },
        { name: 'Test.Dependency', version: '2.3.7', target_framework: '.NETStandard2.0' },
        { name: 'Newtonsoft.Json', version: '12.0.3', target_framework: '.NETStandard2.0' }
      ]
    end

    let(:dependency_names) { package.dependency_links.flat_map(&:dependency).map(&:name) }
    let(:service) { described_class.new(package, dependencies) }

    subject { service.execute }

    it_behaves_like 'creating dependencies, links and nuget metadata for', %w[Castle.Core Moqi Newtonsoft.Json Test.Dependency], 4, 4

    context 'with existing dependencies' do
      let_it_be(:exisiting_dependency) { create(:packages_dependency, name: 'Moqi', version_pattern: '2.5.6') }

      it_behaves_like 'creating dependencies, links and nuget metadata for', %w[Castle.Core Moqi Newtonsoft.Json Test.Dependency], 3, 4
    end

    context 'with dependencies with no target framework' do
      let_it_be(:dependencies) do
        [
          { name: 'Moqi', version: '2.5.6' },
          { name: 'Castle.Core' },
          { name: 'Test.Dependency', version: '2.3.7' },
          { name: 'Newtonsoft.Json', version: '12.0.3' }
        ]
      end

      it_behaves_like 'creating dependencies, links and nuget metadata for', %w[Castle.Core Moqi Newtonsoft.Json Test.Dependency], 4, 4
    end

    context 'with empty dependencies' do
      let_it_be(:dependencies) { [] }

      it 'is a no op' do
        expect(service).not_to receive(:create_dependency_links)
        expect(service).not_to receive(:create_dependency_link_metadata)

        subject
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Nuget
    module Symbols
      class ExtractSignatureAndChecksumService
        include Gitlab::Utils::StrongMemoize

        # More information about the GUID format can be found here:
        # https://github.com/dotnet/symstore/blob/main/docs/specs/SSQP_Key_Conventions.md#key-formatting-basic-rules
        GUID_START_INDEX = 7
        GUID_END_INDEX = 26
        SIGNATURE_LENGTH = 16
        TWENTY_ZEROED_BYTES = ""\u0000"" * 20
        GUID_PARTS_LENGTHS = [4, 2, 2, 8].freeze
        GUID_AGE_PART = 'FFFFFFFF'
        TWO_CHARACTER_HEX_REGEX = /\h{2}/
        GUID_CHUNK_SIZE = 256.bytes
        SHA_CHUNK_SIZE = 16.kilobytes

        # The extraction of the signature in this service is based on the following documentation:
        # https://github.com/dotnet/symstore/blob/main/docs/specs/SSQP_Key_Conventions.md#portable-pdb-signature

        def initialize(file)
          @file = file
        end

        def execute
          return error_response unless signature

          ServiceResponse.success(payload: { signature: signature, checksum: checksum })
        end

        private

        attr_reader :file

        def signature
          return unless pdb_id

          # Convert the GUID into an array of two-character hex strings
          guid = pdb_id.first(SIGNATURE_LENGTH).unpack('H*').flat_map { |el| el.scan(TWO_CHARACTER_HEX_REGEX) }

          # Reorder the GUID parts based on arbitrary lengths
          guid = GUID_PARTS_LENGTHS.map { |length| guid.shift(length) }

          # Concatenate the parts of the GUID back together
          result = guid.first(3).map(&:reverse)
          result << guid.last
          result = result.join
          result << GUID_AGE_PART
        end
        strong_memoize_attr :signature

        # https://github.com/dotnet/corefx/blob/master/src/System.Reflection.Metadata/specs/PE-COFF.md#portable-pdb-checksum
        def checksum
          sha = OpenSSL::Digest.new('SHA256')
          count = 0
          chunk = (+'').force_encoding(Encoding::BINARY)
          file.rewind

          while file.read(SHA_CHUNK_SIZE, chunk)
            count += 1
            chunk[pdb_id] = TWENTY_ZEROED_BYTES if count == 1
            sha.update(chunk)
          end

          sha.hexdigest
        end

        def pdb_id
          # The ID is located in the first 256 bytes of the symbol `.pdb` file
          chunk = file.read(GUID_CHUNK_SIZE)
          return unless chunk

          # Find the index of the first occurrence of 'Blob'
          guid_index = chunk.index('Blob')
          return unless guid_index

          # Extract the binary GUID from the symbol content
          chunk[(guid_index + GUID_START_INDEX)..(guid_index + GUID_END_INDEX)]
        end
        strong_memoize_attr :pdb_id

        def error_response
          ServiceResponse.error(message: 'Could not find the signature in the symbol file')
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Nuget::Symbols::ExtractSignatureAndChecksumService, feature_category: :package_registry do
  let_it_be(:symbol_file_path) { expand_fixture_path('packages/nuget/symbol/package.pdb') }
  let(:symbol_file) { File.new(symbol_file_path) }

  let(:service) { described_class.new(symbol_file) }

  after do
    symbol_file.close
  end

  describe '#execute' do
    subject { service.execute }

    context 'with a valid symbol file' do
      it 'returns the signature and checksum' do
        payload = subject.payload

        expect(payload[:signature]).to eq('b91a152048fc4b3883bf3cf73fbc03f1FFFFFFFF')
        expect(payload[:checksum]).to eq('20151ab9fc48384b83bf3cf73fbc03f1d49166cc356139845f290d1d315256c0')
      end

      it 'reads the file in chunks' do
        expect(symbol_file).to receive(:read).with(described_class::GUID_CHUNK_SIZE).and_call_original
        expect(symbol_file).to receive(:read).with(described_class::SHA_CHUNK_SIZE, instance_of(String))
          .at_least(:once).and_call_original

        subject
      end
    end

    context 'with an invalid symbol file' do
      before do
        allow(symbol_file).to receive(:read).and_return('invalid')
      end

      it 'returns an error' do
        expect(subject).to be_error
        expect(subject.message).to eq('Could not find the signature in the symbol file')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Nuget
    module Symbols
      class CreateSymbolFilesService
        ExtractionError = Class.new(StandardError)
        SYMBOL_ENTRIES_LIMIT = 100
        CONTENT_TYPE = 'application/octet-stream'

        def initialize(package, package_zip_file)
          @package = package
          @symbol_entries = package_zip_file.glob('**/*.pdb')
        end

        def execute
          return if symbol_entries.empty?

          process_symbol_entries
        rescue ExtractionError => e
          Gitlab::ErrorTracking.track_exception(e, class: self.class.name, package_id: package.id)
        end

        private

        attr_reader :package, :symbol_entries

        def process_symbol_entries
          Tempfile.create('nuget_extraction_symbol_file') do |tmp_file|
            symbol_entries.each_with_index do |entry, index|
              raise ExtractionError, 'too many symbol entries' if index >= SYMBOL_ENTRIES_LIMIT

              entry.extract(tmp_file.path) { true }
              File.open(tmp_file.path, 'rb') do |file|
                create_symbol(entry.name, file)
              end
            end
          end
        rescue Zip::EntrySizeError => e
          raise ExtractionError, ""symbol file has the wrong entry size: #{e.message}""
        rescue Zip::EntryNameError => e
          raise ExtractionError, ""symbol file has the wrong entry name: #{e.message}""
        end

        def create_symbol(path, file)
          signature, checksum = extract_signature_and_checksum(file)
          return if signature.blank? || checksum.blank?

          ::Packages::Nuget::Symbol.create!(
            package: package,
            file: { tempfile: file, filename: path.downcase, content_type: CONTENT_TYPE },
            file_path: path,
            signature: signature,
            size: file.size,
            file_sha256: checksum
          )
        rescue StandardError => e
          Gitlab::ErrorTracking.track_exception(e, class: self.class.name, package_id: package.id)
        end

        def extract_signature_and_checksum(file)
          ::Packages::Nuget::Symbols::ExtractSignatureAndChecksumService
            .new(file)
            .execute
            .payload
            .values_at(:signature, :checksum)
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Nuget::Symbols::CreateSymbolFilesService, feature_category: :package_registry do
  let_it_be(:package) { create(:nuget_package) }
  let_it_be(:package_file) do
    create(:package_file, :snupkg, package: package,
      file_fixture: expand_fixture_path('packages/nuget/package_with_symbols.snupkg'))
  end

  let(:package_zip_file) { Zip::File.new(package_file.file) }
  let(:service) { described_class.new(package, package_zip_file) }

  describe '#execute' do
    subject { service.execute }

    shared_examples 'logging an error' do |error_class|
      it 'logs the error' do
        expect(Gitlab::ErrorTracking).to receive(:track_exception).with(
          an_instance_of(error_class),
          class: described_class.name,
          package_id: package.id
        )

        subject
      end
    end

    context 'when symbol files are found' do
      it 'creates a symbol record and extracts the signature' do
        expect_next_instance_of(Packages::Nuget::Symbols::ExtractSignatureAndChecksumService,
          instance_of(File)) do |service|
          expect(service).to receive(:execute).and_call_original
        end

        expect { subject }.to change { package.nuget_symbols.count }.by(1)
      end
    end

    context 'when symbol files hit the limit' do
      before do
        stub_const(""#{described_class}::SYMBOL_ENTRIES_LIMIT"", 0)
      end

      it 'does not create a symbol record' do
        expect { subject }.not_to change { package.nuget_symbols.count }
      end

      it_behaves_like 'logging an error', described_class::ExtractionError
    end

    context 'without a signature' do
      before do
        allow_next_instance_of(Packages::Nuget::Symbols::ExtractSignatureAndChecksumService) do |instance|
          allow(instance).to receive(:execute).and_return(ServiceResponse.success(payload: { signature: nil }))
        end
      end

      it 'does not call create! on the symbol record' do
        expect(::Packages::Nuget::Symbol).not_to receive(:create!)

        subject
      end
    end

    context 'without a checksum' do
      before do
        allow_next_instance_of(Packages::Nuget::Symbols::ExtractSignatureAndChecksumService) do |instance|
          allow(instance).to receive(:execute).and_return(ServiceResponse.success(payload: { checksum: nil }))
        end
      end

      it 'does not call create! on the symbol record' do
        expect(::Packages::Nuget::Symbol).not_to receive(:create!)

        subject
      end
    end

    context 'with existing duplicate symbol records' do
      let_it_be(:symbol) { create(:nuget_symbol, package: package) }

      before do
        allow_next_instance_of(Packages::Nuget::Symbols::ExtractSignatureAndChecksumService) do |instance|
          allow(instance).to receive(:execute).and_return(
            ServiceResponse.success(payload: { signature: symbol.signature, checksum: symbol.file_sha256 })
          )
        end
      end

      it 'does not create a symbol record' do
        expect { subject }.not_to change { package.nuget_symbols.count }
      end

      it_behaves_like 'logging an error', ActiveRecord::RecordInvalid
    end

    context 'when a symbol file has the wrong entry size' do
      before do
        allow_next_instance_of(Zip::Entry) do |instance|
          allow(instance).to receive(:extract).and_raise(Zip::EntrySizeError)
        end
      end

      it_behaves_like 'logging an error', described_class::ExtractionError
    end

    context 'when a symbol file has the wrong entry name' do
      before do
        allow_next_instance_of(Zip::Entry) do |instance|
          allow(instance).to receive(:extract).and_raise(Zip::EntryNameError)
        end
      end

      it_behaves_like 'logging an error', described_class::ExtractionError
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Conan
    class SinglePackageSearchService # rubocop:disable Search/NamespacedClass
      include Gitlab::Utils::StrongMemoize

      def initialize(query, current_user)
        @name, @version, @username, _ = query.split(%r{[@/]})
        @current_user = current_user
      end

      def execute
        ServiceResponse.success(payload: { results: search_results })
      end

      private

      attr_reader :name, :version, :username, :current_user

      def search_results
        return [] unless can_access_project_package?

        [package&.conan_recipe].compact
      end

      def package
        project
          .packages
          .with_name(name)
          .with_version(version)
          .order_created
          .last
      end

      def project
        Project.find_by_full_path(full_path)
      end
      strong_memoize_attr :project

      def full_path
        ::Packages::Conan::Metadatum.full_path_from(package_username: username)
      end

      def can_access_project_package?
        Ability.allowed?(current_user, :read_package, project.try(:packages_policy_subject))
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Conan::SinglePackageSearchService, feature_category: :package_registry do
  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project, :public) }

  let!(:conan_package) { create(:conan_package, project: project) }
  let!(:conan_package2) { create(:conan_package, project: project) }

  describe '#execute' do
    context 'with a valid query and user with permissions' do
      before do
        allow_next_instance_of(described_class) do |service|
          allow(service).to receive(:can_access_project_package?).and_return(true)
        end
      end

      it 'returns the correct package' do
        [conan_package, conan_package2].each do |package|
          result = described_class.new(package.conan_recipe, user).execute

          expect(result.status).to eq :success
          expect(result[:results]).to match_array([package.conan_recipe])
        end
      end
    end

    context 'with a user without permissions' do
      before do
        allow_next_instance_of(described_class) do |service|
          allow(service).to receive(:can_access_project_package?).and_return(false)
        end
      end

      it 'returns an empty array' do
        result = described_class.new(conan_package.conan_recipe, user).execute

        expect(result.status).to eq :success
        expect(result[:results]).to match_array([])
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Conan
    class CreatePackageFileService
      attr_reader :package, :file, :params

      def initialize(package, file, params)
        @package = package
        @file = file
        @params = params
      end

      def execute
        package_file = package.package_files.build(
          file: file,
          size: params['file.size'],
          file_name: params[:file_name],
          file_sha1: params['file.sha1'],
          file_md5: params['file.md5'],
          conan_file_metadatum_attributes: {
            recipe_revision: params[:recipe_revision],
            package_revision: params[:package_revision],
            conan_package_reference: params[:conan_package_reference],
            conan_file_type: params[:conan_file_type]
          }
        )

        if params[:build].present?
          package_file.package_file_build_infos << package_file.package_file_build_infos.build(pipeline: params[:build].pipeline)
        end

        package_file.save!
        package_file
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::Conan::CreatePackageFileService, feature_category: :package_registry do
  include WorkhorseHelpers

  let_it_be(:package) { create(:conan_package) }
  let_it_be(:user) { create(:user) }

  describe '#execute' do
    let(:file_name) { 'foo.tgz' }

    subject { described_class.new(package, file, params).execute }

    shared_examples 'a valid package_file' do
      let(:params) do
        {
          file_name: file_name,
          'file.md5': '12345',
          'file.sha1': '54321',
          'file.size': '128',
          'file.type': 'txt',
          recipe_revision: '0',
          package_revision: '0',
          conan_package_reference: '123456789',
          conan_file_type: :package_file
        }.with_indifferent_access
      end

      it 'creates a new package file' do
        package_file = subject

        expect(package_file).to be_valid
        expect(package_file.file_name).to eq(file_name)
        expect(package_file.file_md5).to eq('12345')
        expect(package_file.size).to eq(128)
        expect(package_file.conan_file_metadatum).to be_valid
        expect(package_file.conan_file_metadatum.recipe_revision).to eq('0')
        expect(package_file.conan_file_metadatum.package_revision).to eq('0')
        expect(package_file.conan_file_metadatum.conan_package_reference).to eq('123456789')
        expect(package_file.conan_file_metadatum.conan_file_type).to eq('package_file')
        expect(package_file.file.read).to eq('content')
      end

      it_behaves_like 'assigns build to package file'
    end

    shared_examples 'a valid recipe_file' do
      let(:params) do
        {
          file_name: file_name,
          'file.md5': '12345',
          'file.sha1': '54321',
          'file.size': '128',
          'file.type': 'txt',
          recipe_revision: '0',
          conan_file_type: :recipe_file
        }.with_indifferent_access
      end

      it 'creates a new recipe file' do
        package_file = subject

        expect(package_file).to be_valid
        expect(package_file.file_name).to eq(file_name)
        expect(package_file.file_md5).to eq('12345')
        expect(package_file.size).to eq(128)
        expect(package_file.conan_file_metadatum).to be_valid
        expect(package_file.conan_file_metadatum.recipe_revision).to eq('0')
        expect(package_file.conan_file_metadatum.package_revision).to be_nil
        expect(package_file.conan_file_metadatum.conan_package_reference).to be_nil
        expect(package_file.conan_file_metadatum.conan_file_type).to eq('recipe_file')
        expect(package_file.file.read).to eq('content')
      end

      it_behaves_like 'assigns build to package file'
    end

    context 'with temp file' do
      let!(:file) do
        upload_path = ::Packages::PackageFileUploader.workhorse_local_upload_path
        file_path = upload_path + '/' + file_name

        FileUtils.mkdir_p(upload_path)
        File.write(file_path, 'content')

        UploadedFile.new(file_path, filename: File.basename(file_path))
      end

      before do
        allow_any_instance_of(Packages::PackageFileUploader).to receive(:size).and_return(128)
      end

      it_behaves_like 'a valid package_file'
      it_behaves_like 'a valid recipe_file'
    end

    context 'with remote file' do
      let!(:fog_connection) do
        stub_package_file_object_storage(direct_upload: true)
      end

      before do
        allow_any_instance_of(Packages::PackageFileUploader).to receive(:size).and_return(128)
      end

      let(:tmp_object) do
        fog_connection.directories.new(key: 'packages').files.create( # rubocop:disable Rails/SaveBang
          key: ""tmp/uploads/#{file_name}"",
          body: 'content'
        )
      end

      let(:file) { fog_to_uploaded_file(tmp_object) }

      it_behaves_like 'a valid package_file'
      it_behaves_like 'a valid recipe_file'
    end

    context 'file is missing' do
      let(:file) { nil }
      let(:params) do
        {
          file_name: file_name,
          recipe_revision: '0',
          conan_file_type: :recipe_file
        }
      end

      it 'raises an error' do
        expect { subject }.to raise_error(ActiveRecord::RecordInvalid)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Conan
    class SearchService < BaseService
      include ActiveRecord::Sanitization::ClassMethods

      WILDCARD = '*'
      RECIPE_SEPARATOR = '@'

      def execute
        ServiceResponse.success(payload: { results: search_results })
      end

      private

      def search_results
        return [] if wildcard_query?

        return search_for_single_package(sanitized_query) if params[:query].include?(RECIPE_SEPARATOR)

        search_packages
      end

      def wildcard_query?
        params[:query] == WILDCARD
      end

      def sanitized_query
        @sanitized_query ||= sanitize_sql_like(params[:query].delete(WILDCARD))
      end

      def search_for_single_package(query)
        ::Packages::Conan::SinglePackageSearchService
          .new(query, current_user)
          .execute[:results]
      end

      def search_packages
        ::Packages::Conan::PackageFinder
          .new(current_user, { query: build_query }, project: project)
          .execute
          .map(&:conan_recipe)
      end

      def build_query
        return ""#{sanitized_query}%"" if params[:query].end_with?(WILDCARD)

        sanitized_query
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Conan::SearchService, feature_category: :package_registry do
  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project, :public) }

  let!(:conan_package) { create(:conan_package, project: project) }
  let!(:conan_package2) { create(:conan_package, project: project) }

  subject { described_class.new(project, user, query: query) }

  before do
    project.add_developer(user)
  end

  describe '#execute' do
    context 'with wildcard' do
      let(:partial_name) { conan_package.name.first[0, 3] }
      let(:query) { ""#{partial_name}*"" }

      it 'makes a wildcard query' do
        result = subject.execute

        expect(result.status).to eq :success
        expect(result.payload).to eq(results: [conan_package2.conan_recipe, conan_package.conan_recipe])
      end
    end

    context 'with only wildcard' do
      let(:query) { '*' }

      it 'returns empty' do
        result = subject.execute

        expect(result.status).to eq :success
        expect(result.payload).to eq(results: [])
      end
    end

    context 'with no wildcard' do
      let(:query) { conan_package.name }

      it 'makes a search using the beginning of the recipe' do
        result = subject.execute

        expect(result.status).to eq :success
        expect(result.payload).to eq(results: [conan_package.conan_recipe])
      end
    end

    context 'with full recipe match' do
      let(:query) { conan_package.conan_recipe }

      it 'makes an exact search' do
        result = subject.execute

        expect(result.status).to eq :success
        expect(result.payload).to eq(results: [conan_package.conan_recipe])
      end
    end

    context 'with malicious query' do
      let(:query) { 'DROP TABLE foo;' }

      it 'returns empty' do
        result = subject.execute

        expect(result.status).to eq :success
        expect(result.payload).to eq(results: [])
      end
    end

    context 'for project' do
      let_it_be(:project2) { create(:project, :public) }
      let(:query) { conan_package.name }
      let!(:conan_package3) { create(:conan_package, name: conan_package.name, project: project2) }

      context 'when passing a project' do
        it 'returns only packages of the given project' do
          result = subject.execute

          expect(result.status).to eq :success
          expect(result[:results]).to match_array([conan_package.conan_recipe])
        end
      end

      context 'when passing a project with nil' do
        it 'returns all packages' do
          result = described_class.new(nil, user, query: query).execute

          expect(result.status).to eq :success
          expect(result[:results]).to eq([conan_package3.conan_recipe, conan_package.conan_recipe])
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Conan
    class CreatePackageService < ::Packages::CreatePackageService
      def execute
        create_package!(:conan,
          name: params[:package_name],
          version: params[:package_version],
          conan_metadatum_attributes: {
            package_username: params[:package_username],
            package_channel: params[:package_channel]
          }
        )
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::Conan::CreatePackageService, feature_category: :package_registry do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }

  subject(:service) { described_class.new(project, user, params) }

  describe '#execute' do
    subject(:package) { service.execute }

    context 'valid params' do
      let(:params) do
        {
          package_name: 'my-pkg',
          package_version: '1.0.0',
          package_username: ::Packages::Conan::Metadatum.package_username_from(full_path: project.full_path),
          package_channel: 'stable'
        }
      end

      it 'creates a new package' do
        expect(package).to be_valid
        expect(package.name).to eq(params[:package_name])
        expect(package.version).to eq(params[:package_version])
        expect(package.package_type).to eq('conan')
        expect(package.conan_metadatum.package_username).to eq(params[:package_username])
        expect(package.conan_metadatum.package_channel).to eq(params[:package_channel])
      end

      it_behaves_like 'assigns the package creator'
      it_behaves_like 'assigns build to package'
      it_behaves_like 'assigns status to package'
    end

    context 'invalid params' do
      let(:params) do
        {
          package_name: 'my-pkg',
          package_version: '1.0.0',
          package_username: 'foo/bar',
          package_channel: 'stable'
        }
      end

      it 'fails' do
        expect { package }.to raise_exception(ActiveRecord::RecordInvalid)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module TerraformModule
    class CreatePackageService < ::Packages::CreatePackageService
      include Gitlab::Utils::StrongMemoize

      def execute
        return error('Version is empty.', 400) if params[:module_version].blank?
        return error('Access Denied', 403) if current_package_exists_elsewhere?
        return error('Package version already exists.', 403) if current_package_version_exists?
        return error('File is too large.', 400) if file_size_exceeded?

        ApplicationRecord.transaction { create_terraform_module_package! }
      end

      private

      def create_terraform_module_package!
        package = create_package!(:terraform_module, name: name, version: params[:module_version])

        ::Packages::CreatePackageFileService.new(package, file_params).execute

        package
      end

      def current_package_exists_elsewhere?
        ::Packages::Package
          .for_projects(project.root_namespace.all_projects.id_not_in(project.id))
          .with_package_type(:terraform_module)
          .with_name(name)
          .not_pending_destruction
          .exists?
      end

      def current_package_version_exists?
        project.packages
          .with_package_type(:terraform_module)
          .with_name(name)
          .with_version(params[:module_version])
          .not_pending_destruction
          .exists?
      end

      def name
        ""#{params[:module_name]}/#{params[:module_system]}""
      end
      strong_memoize_attr :name

      def file_name
        ""#{params[:module_name]}-#{params[:module_system]}-#{params[:module_version]}.tgz""
      end
      strong_memoize_attr :file_name

      def file_params
        {
          file: params[:file],
          size: params[:file].size,
          file_sha256: params[:file].sha256,
          file_name: file_name,
          build: params[:build]
        }
      end

      def file_size_exceeded?
        project.actual_limits.exceeded?(:generic_packages_max_file_size, params[:file].size)
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::TerraformModule::CreatePackageService, feature_category: :package_registry do
  let_it_be(:namespace) { create(:namespace) }
  let_it_be(:project) { create(:project, namespace: namespace) }
  let_it_be(:user) { create(:user) }
  let_it_be(:sha256) { '440e5e148a25331bbd7991575f7d54933c0ebf6cc735a18ee5066ac1381bb590' }

  let(:overrides) { {} }

  let(:params) do
    {
      module_name: 'foo',
      module_system: 'bar',
      module_version: '1.0.1',
      file: UploadedFile.new(Tempfile.new('test').path, sha256: sha256),
      file_name: 'foo-bar-1.0.1.tgz'
    }.merge(overrides)
  end

  subject { described_class.new(project, user, params).execute }

  describe '#execute' do
    shared_examples 'creating a package' do
      it 'creates a package' do
        expect { subject }
          .to change { ::Packages::Package.count }.by(1)
          .and change { ::Packages::Package.terraform_module.count }.by(1)
      end
    end

    context 'valid package' do
      it_behaves_like 'creating a package'
    end

    context 'package already exists elsewhere' do
      let(:project2) { create(:project, namespace: namespace) }
      let!(:existing_package) { create(:terraform_module_package, project: project2, name: 'foo/bar', version: '1.0.0') }

      it { expect(subject[:http_status]).to eq 403 }
      it { expect(subject[:message]).to be 'Access Denied' }

      context 'marked as pending_destruction' do
        before do
          existing_package.pending_destruction!
        end

        it_behaves_like 'creating a package'
      end
    end

    context 'version already exists' do
      let!(:existing_version) { create(:terraform_module_package, project: project, name: 'foo/bar', version: '1.0.1') }

      it { expect(subject[:http_status]).to eq 403 }
      it { expect(subject[:message]).to be 'Package version already exists.' }

      context 'marked as pending_destruction' do
        before do
          existing_version.pending_destruction!
        end

        it_behaves_like 'creating a package'
      end
    end

    context 'with empty version' do
      let(:overrides) { { module_version: '' } }

      it { expect(subject[:http_status]).to eq 400 }
      it { expect(subject[:message]).to eq 'Version is empty.' }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Generic
    class CreatePackageFileService < BaseService
      def execute
        ::Packages::Package.transaction do
          create_package_file(find_or_create_package)
        end
      end

      private

      def find_or_create_package
        package_params = {
          name: params[:package_name],
          version: params[:package_version],
          build: params[:build],
          status: params[:status]
        }

        package = ::Packages::Generic::FindOrCreatePackageService
          .new(project, current_user, package_params)
          .execute

        unless Namespace::PackageSetting.duplicates_allowed?(package)
          raise ::Packages::DuplicatePackageError if target_file_is_duplicate?(package)
        end

        package.update_column(:status, params[:status]) if params[:status] && params[:status] != package.status

        package.create_build_infos!(params[:build])

        package
      end

      def create_package_file(package)
        file_params = {
          file: params[:file],
          size: params[:file].size,
          file_sha256: params[:file].sha256,
          file_name: params[:file_name],
          build: params[:build]
        }

        ::Packages::CreatePackageFileService.new(package, file_params).execute
      end

      def target_file_is_duplicate?(package)
        package
          .package_files
          .with_file_name(params[:file_name])
          .not_pending_destruction
          .exists?
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Generic::CreatePackageFileService, feature_category: :package_registry do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }
  let_it_be(:pipeline) { create(:ci_pipeline, user: user) }
  let_it_be(:file_name) { 'myfile.tar.gz.1' }

  let(:build) { double('build', pipeline: pipeline) }

  describe '#execute' do
    let_it_be(:package) { create(:generic_package, project: project) }

    let(:sha256) { '440e5e148a25331bbd7991575f7d54933c0ebf6cc735a18ee5066ac1381bb590' }
    let(:temp_file) { Tempfile.new(""test"") }
    let(:file) { UploadedFile.new(temp_file.path, sha256: sha256) }
    let(:package_service) { double }

    let(:params) do
      {
        package_name: 'mypackage',
        package_version: '0.0.1',
        file: file,
        file_name: file_name,
        build: build
      }
    end

    let(:package_params) do
      {
        name: params[:package_name],
        version: params[:package_version],
        build: params[:build],
        status: nil
      }
    end

    subject(:execute_service) { described_class.new(project, user, params).execute }

    before do
      FileUtils.touch(temp_file)
      expect(::Packages::Generic::FindOrCreatePackageService).to receive(:new).with(project, user, package_params).and_return(package_service)
      expect(package_service).to receive(:execute).and_return(package)
    end

    after do
      FileUtils.rm_f(temp_file)
    end

    it 'creates package file', :aggregate_failures do
      expect { execute_service }.to change { package.package_files.count }.by(1)
        .and change { Packages::PackageFileBuildInfo.count }.by(1)

      package_file = package.package_files.last
      aggregate_failures do
        expect(package_file.package.status).to eq('default')
        expect(package_file.package).to eq(package)
        expect(package_file.file_name).to eq(file_name)
        expect(package_file.size).to eq(file.size)
        expect(package_file.file_sha256).to eq(sha256)
      end
    end

    context 'with a status' do
      let(:params) { super().merge(status: 'hidden') }
      let(:package_params) { super().merge(status: 'hidden') }

      it 'updates an existing packages status' do
        expect { execute_service }.to change { package.package_files.count }.by(1)
          .and change { Packages::PackageFileBuildInfo.count }.by(1)

        package_file = package.package_files.last
        aggregate_failures do
          expect(package_file.package.status).to eq('hidden')
        end
      end
    end

    it_behaves_like 'assigns build to package file'

    context 'with existing package' do
      let_it_be(:duplicate_file) { create(:package_file, package: package, file_name: file_name) }

      it { expect { execute_service }.to change { project.package_files.count }.by(1) }

      context 'when duplicates are not allowed' do
        before do
          package.project.namespace.package_settings.update!(generic_duplicates_allowed: false)
        end

        it 'does not allow duplicates' do
          expect { execute_service }.to raise_error(::Packages::DuplicatePackageError)
            .and change { project.package_files.count }.by(0)
        end

        context 'when the file is pending destruction' do
          before do
            duplicate_file.update_column(:status, :pending_destruction)
          end

          it 'allows creating the file' do
            expect { execute_service }.to change { project.package_files.count }.by(1)
          end
        end

        context 'when the package name matches the exception regex' do
          before do
            package.project.namespace.package_settings.update!(generic_duplicate_exception_regex: '.*')
          end

          it { expect { execute_service }.to change { project.package_files.count }.by(1) }
        end
      end

      context 'with multiple files for the same package and the same pipeline' do
        let(:file_2_params) { params.merge(file_name:  'myfile.tar.gz.2', file: file2) }
        let(:file_3_params) { params.merge(file_name:  'myfile.tar.gz.3', file: file3) }

        let(:temp_file2) { Tempfile.new(""test2"") }
        let(:temp_file3) { Tempfile.new(""test3"") }

        let(:file2) { UploadedFile.new(temp_file2.path, sha256: sha256) }
        let(:file3) { UploadedFile.new(temp_file3.path, sha256: sha256) }

        before do
          FileUtils.touch(temp_file2)
          FileUtils.touch(temp_file3)
          expect(::Packages::Generic::FindOrCreatePackageService).to receive(:new).with(project, user, package_params).and_return(package_service).twice
          expect(package_service).to receive(:execute).and_return(package).twice
        end

        after do
          FileUtils.rm_f(temp_file2)
          FileUtils.rm_f(temp_file3)
        end

        it 'creates the build info only once' do
          expect do
            described_class.new(project, user, params).execute
            described_class.new(project, user, file_2_params).execute
            described_class.new(project, user, file_3_params).execute
          end.to change { package.build_infos.count }.by(1)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Generic
    class FindOrCreatePackageService < ::Packages::CreatePackageService
      def execute
        find_or_create_package!(::Packages::Package.package_types['generic'])
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Generic::FindOrCreatePackageService, feature_category: :package_registry do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }
  let_it_be(:ci_build) { create(:ci_build, :running, user: user) }

  let(:params) do
    {
      name: 'mypackage',
      version: '0.0.1'
    }
  end

  describe '#execute' do
    context 'when packages does not exist yet' do
      it 'creates package' do
        service = described_class.new(project, user, params)

        expect { service.execute }.to change { project.packages.generic.count }.by(1)

        package = project.packages.generic.last

        aggregate_failures do
          expect(package.creator).to eq(user)
          expect(package.name).to eq('mypackage')
          expect(package.version).to eq('0.0.1')
          expect(package.last_build_info).to be_nil
        end
      end

      it 'creates package and package build info when build is provided' do
        service = described_class.new(project, user, params.merge(build: ci_build))

        expect { service.execute }.to change { project.packages.generic.count }.by(1)

        package = project.packages.generic.last

        aggregate_failures do
          expect(package.creator).to eq(user)
          expect(package.name).to eq('mypackage')
          expect(package.version).to eq('0.0.1')
          expect(package.last_build_info.pipeline).to eq(ci_build.pipeline)
        end
      end
    end

    context 'when packages already exists' do
      let!(:package) { project.packages.generic.create!(params) }

      context 'when package was created manually' do
        it 'finds the package and does not create package build info even if build is provided' do
          service = described_class.new(project, user, params.merge(build: ci_build))

          expect do
            found_package = service.execute

            expect(found_package).to eq(package)
          end.not_to change { project.packages.generic.count }

          expect(package.reload.last_build_info).to be_nil
        end
      end

      context 'when package was created by pipeline' do
        let(:pipeline) { create(:ci_pipeline, project: project) }

        before do
          package.build_infos.create!(pipeline: pipeline)
        end

        it 'finds the package and does not change package build info even if build is provided' do
          service = described_class.new(project, user, params.merge(build: ci_build))

          expect do
            found_package = service.execute

            expect(found_package).to eq(package)
          end.not_to change { project.packages.generic.count }

          expect(package.reload.last_build_info.pipeline).to eq(pipeline)
        end
      end

      context 'when a pending_destruction package exists', :aggregate_failures do
        let!(:package) { project.packages.generic.create!(params.merge(status: :pending_destruction)) }

        it 'creates a new package' do
          service = described_class.new(project, user, params)

          expect { service.execute }.to change { project.packages.generic.count }.by(1)

          package = project.packages.generic.last

          expect(package.creator).to eq(user)
          expect(package.name).to eq('mypackage')
          expect(package.version).to eq('0.0.1')
          expect(package.last_build_info).to be_nil
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Rpm
    class ParsePackageService
      include ::Gitlab::Utils::StrongMemoize

      BUILD_ATTRIBUTES_METHOD_NAMES = %i[changelogs requirements provides].freeze
      STATIC_ATTRIBUTES = %i[name version release summary description arch
                             license sourcerpm group buildhost packager vendor].freeze

      CHANGELOGS_RPM_KEYS = %i[changelogtext changelogtime].freeze
      REQUIREMENTS_RPM_KEYS = %i[requirename requireversion requireflags].freeze
      PROVIDES_RPM_KEYS = %i[providename provideflags provideversion].freeze

      def initialize(package_file)
        @rpm = RPM::File.new(package_file)
      end

      def execute
        raise ArgumentError, 'Unable to parse package' unless valid_package?

        {
          files: rpm.files || [],
          epoch: package_tags[:epoch] || '0',
          changelogs: build_changelogs,
          requirements: build_requirements,
          provides: build_provides,
          directories: package_tags[:dirnames]
        }.merge(extract_static_attributes)
      end

      private

      attr_reader :rpm

      def valid_package?
        rpm.files && package_tags && true
      rescue RuntimeError
        # if arr-pm throws an error due to an incorrect file format,
        # we just want this validation to fail rather than throw an exception
        false
      end

      def package_tags
        rpm.tags
      end
      strong_memoize_attr :package_tags

      def extract_static_attributes
        STATIC_ATTRIBUTES.index_with do |attribute|
          package_tags[attribute]
        end
      end

      # Define methods for building RPM attribute data from parsed package
      # Transform
      # changelogtime: [123, 234],
      # changelogname: [""First"", ""Second""]
      # changelogtext: [""Work1"", ""Work2""]
      # Into
      # changelog: [
      #   {changelogname: ""First"", changelogtext: ""Work1"", changelogtime: 123},
      #   {changelogname: ""Second"", changelogtext: ""Work2"", changelogtime: 234}
      # ]
      BUILD_ATTRIBUTES_METHOD_NAMES.each do |resource|
        define_method(""build_#{resource}"") do
          resource_keys = self.class.const_get(""#{resource.upcase}_RPM_KEYS"", false).dup
          return [] if resource_keys.any? { package_tags[_1].blank? }

          first_attributes = package_tags[resource_keys.first]
          zipped_data = first_attributes.zip(*resource_keys[1..].map { package_tags[_1] })
          build_hashes(resource_keys, zipped_data)
        end
      end

      def build_hashes(resource_keys, zipped_data)
        zipped_data.map do |data|
          resource_keys.zip(data).to_h
        end
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::Rpm::ParsePackageService, feature_category: :package_registry do
  let(:package_file) { File.open('spec/fixtures/packages/rpm/hello-0.0.1-1.fc29.x86_64.rpm') }

  describe 'dynamic private methods' do
    described_class::BUILD_ATTRIBUTES_METHOD_NAMES.each do |attribute|
      it 'define dynamic build attribute method' do
        expect(described_class).to be_private_method_defined(""build_#{attribute}"")
      end
    end
  end

  describe '#execute' do
    subject { described_class.new(package_file).execute }

    shared_examples 'valid package parsing' do
      it 'return hash' do
        expect(subject).to be_a(Hash)
      end

      it 'has all static attribute keys' do
        expect(subject.keys).to include(*described_class::STATIC_ATTRIBUTES)
      end

      it 'includes epoch attribute' do
        expect(subject[:epoch]).not_to be_blank
      end

      it 'has all built attributes with array values' do
        result = subject
        described_class::BUILD_ATTRIBUTES_METHOD_NAMES.each do |attribute|
          expect(result).to have_key(attribute)
          expect(result[attribute]).to be_a(Array)
        end
      end
    end

    context 'when wrong format file received' do
      let(:package_file) { File.open('spec/fixtures/rails_sample.jpg') }

      it 'raise error' do
        expect { subject }.to raise_error(ArgumentError)
      end
    end

    context 'when valid file uploaded' do
      context 'when .rpm file uploaded' do
        it_behaves_like 'valid package parsing'
      end

      context 'when .src.rpm file uploaded' do
        let(:package_file) { File.open('spec/fixtures/packages/rpm/hello-0.0.1-1.fc29.src.rpm') }

        it_behaves_like 'valid package parsing'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
  module Rpm
    module RepositoryMetadata
      class BuildRepomdXmlService
        ROOT_ATTRIBUTES = {
          xmlns: 'http://linux.duke.edu/metadata/repo',
          'xmlns:rpm': 'http://linux.duke.edu/metadata/rpm'
        }.freeze
        ALLOWED_DATA_VALUE_KEYS = %i[checksum open-checksum location timestamp size open-size].freeze

        # Expected `data` structure
        #
        # data = {
        #   filelists: {
        #     checksum: { type: ""sha256"", value: ""123"" },
        #     location: { href: ""repodata/123-filelists.xml.gz"" },
        #     ...
        #   },
        #   ...
        # }
        def initialize(data)
          @data = data
        end

        def execute
          Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
            xml.repomd(ROOT_ATTRIBUTES) do
              xml.revision Time.now.to_i
              build_data_info(xml)
            end
          end.to_xml
        end

        private

        attr_reader :data

        def build_data_info(xml)
          data.each do |filename, info|
            xml.data(type: filename) do
              build_file_info(info, xml)
            end
          end
        end

        def build_file_info(info, xml)
          info.slice(*ALLOWED_DATA_VALUE_KEYS).each do |key, attributes|
            value = attributes.delete(:value)
            xml.method_missing(key, value, attributes)
          end
        end
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::Rpm::RepositoryMetadata::BuildRepomdXmlService, feature_category: :package_registry do
  describe '#execute' do
    subject { described_class.new(data).execute }

    let(:data) do
      {
        filelists: {
          checksum: { type: ""sha256"", value: ""123"" },
          'open-checksum': { type: ""sha256"", value: ""123"" },
          location: { href: ""repodata/123-filelists.xml.gz"" },
          timestamp: { value: 1644602784 },
          size: { value: 11111 },
          'open-size': { value: 11111 }
        },
        primary: {
          checksum: { type: ""sha256"", value: ""234"" },
          'open-checksum': { type: ""sha256"", value: ""234"" },
          location: { href: ""repodata/234-primary.xml.gz"" },
          timestamp: { value: 1644602784 },
          size: { value: 22222 },
          'open-size': { value: 22222 }
        },
        other: {
          checksum: { type: ""sha256"", value: ""345"" },
          'open-checksum': { type: ""sha256"", value: ""345"" },
          location: { href: ""repodata/345-other.xml.gz"" },
          timestamp: { value: 1644602784 },
          size: { value: 33333 },
          'open-size': { value: 33333 }
        }
      }
    end

    let(:creation_timestamp) { 111111 }

    before do
      allow(Time).to receive(:now).and_return(creation_timestamp)
    end

    it 'generate valid xml' do
      # Have one root attribute
      result = Nokogiri::XML::Document.parse(subject)
      expect(result.children.count).to eq(1)

      # Root attribute name is 'repomd'
      root = result.children.first
      expect(root.name).to eq('repomd')

      # Have the same count of 'data' tags as count of keys in 'data'
      expect(result.css('data').count).to eq(data.count)
    end

    it 'has all data info' do
      result = Nokogiri::XML::Document.parse(subject).remove_namespaces!

      data.each do |tag_name, tag_attributes|
        tag_attributes.each_key do |key|
          expect(result.at(""//repomd/data[@type=\""#{tag_name}\""]/#{key}"")).not_to be_nil
        end
      end
    end

    context 'when data values has unexpected keys' do
      let(:data) do
        {
          filelists: described_class::ALLOWED_DATA_VALUE_KEYS.each_with_object({}) do |key, result|
            result[:""#{key}-wrong""] = { value: 'value' }
          end
        }
      end

      it 'ignores wrong keys' do
        result = Nokogiri::XML::Document.parse(subject).remove_namespaces!

        data.each do |tag_name, tag_attributes|
          tag_attributes.each_key do |key|
            expect(result.at(""//repomd/data[@type=\""#{tag_name}\""]/#{key}"")).to be_nil
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
  module Rpm
    module RepositoryMetadata
      class BuildOtherXmlService < BuildXmlBaseService
        ROOT_TAG = 'otherdata'
        ROOT_ATTRIBUTES = {
          xmlns: 'http://linux.duke.edu/metadata/other',
          packages: '0'
        }.freeze

        def execute
          super do |xml|
            xml.package(pkgid: data[:pkgid], name: data[:name], arch: data[:arch]) do
              xml.version epoch: data[:epoch], ver: data[:version], rel: data[:release]
              build_changelog_nodes(xml)
            end
          end
        end

        private

        def build_changelog_nodes(xml)
          data[:changelogs].each do |changelog|
            xml.changelog changelog[:changelogtext], date: changelog[:changelogtime]
          end
        end
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::Rpm::RepositoryMetadata::BuildOtherXmlService, feature_category: :package_registry do
  describe '#execute' do
    subject { described_class.new(data).execute }

    include_context 'with rpm package data'

    let(:data) { xml_update_params }
    let(:changelog_xpath) { ""//package/changelog"" }

    it 'adds all changelog nodes' do
      result = subject

      expect(result.xpath(changelog_xpath).count).to eq(data[:changelogs].count)
    end

    it 'set required date attribute' do
      result = subject

      data[:changelogs].each do |changelog|
        expect(result.at(""#{changelog_xpath}[@date=\""#{changelog[:changelogtime]}\""]"")).not_to be_nil
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
  module Rpm
    module RepositoryMetadata
      class BuildPrimaryXmlService < BuildXmlBaseService
        ROOT_TAG = 'metadata'
        ROOT_ATTRIBUTES = {
          xmlns: 'http://linux.duke.edu/metadata/common',
          'xmlns:rpm': 'http://linux.duke.edu/metadata/rpm',
          packages: '0'
        }.freeze

        # Nodes that have only text without attributes
        BASE_ATTRIBUTES = %i[name arch summary description url packager].freeze
        FORMAT_NODE_BASE_ATTRIBUTES = %i[license vendor group buildhost sourcerpm].freeze

        def execute
          super do |xml|
            xml.package(type: :rpm, 'xmlns:rpm': 'http://linux.duke.edu/metadata/rpm') do
              build_base_attributes(xml)
              xml.version epoch: data[:epoch], ver: data[:version], rel: data[:release]
              xml.checksum data[:pkgid], type: 'sha256', pkgid: 'YES'
              xml.size package: data[:packagesize], installed: data[:installedsize], archive: data[:archivesize]
              xml.time file: data[:filetime], build: data[:buildtime]
              xml.location href: data[:location] if data[:location].present?
              build_format_node(xml)
            end
          end
        end

        private

        def build_base_attributes(xml)
          BASE_ATTRIBUTES.each do |attribute|
            xml.method_missing(attribute, data[attribute]) if data[attribute].present?
          end
        end

        def build_format_node(xml)
          xml.format do
            build_base_format_attributes(xml)
            build_provides_node(xml)
            build_requires_node(xml)
          end
        end

        def build_base_format_attributes(xml)
          FORMAT_NODE_BASE_ATTRIBUTES.each do |attribute|
            xml[:rpm].method_missing(attribute, data[attribute]) if data[attribute].present?
          end
        end

        def build_requires_node(xml)
          xml[:rpm].requires do
            data[:requirements].each do |requires|
              xml[:rpm].entry(
                name: requires[:requirename],
                flags: requires[:requireflags],
                ver: requires[:requireversion]
              )
            end
          end
        end

        def build_provides_node(xml)
          xml[:rpm].provides do
            data[:provides].each do |provides|
              xml[:rpm].entry(
                name: provides[:providename],
                flags: provides[:provideflags],
                ver: provides[:provideversion])
            end
          end
        end
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::Rpm::RepositoryMetadata::BuildPrimaryXmlService, feature_category: :package_registry do
  describe '#execute' do
    subject { described_class.new(data).execute }

    include_context 'with rpm package data'

    let(:data) { xml_update_params }
    let(:required_text_only_attributes) { %i[description summary arch name] }

    it 'adds node with required_text_only_attributes' do
      result = subject

      required_text_only_attributes.each do |attribute|
        expect(
          result.at(""//package/#{attribute}"").text
        ).to eq(data[attribute])
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
  module Rpm
    module RepositoryMetadata
      class BuildFilelistXmlService < BuildXmlBaseService
        ROOT_TAG = 'filelists'
        ROOT_ATTRIBUTES = {
          xmlns: 'http://linux.duke.edu/metadata/filelists',
          packages: '0'
        }.freeze

        def execute
          super do |xml|
            xml.package(pkgid: data[:pkgid], name: data[:name], arch: data[:arch]) do
              xml.version epoch: data[:epoch], ver: data[:version], rel: data[:release]
              build_file_nodes(xml)
            end
          end
        end

        private

        def build_file_nodes(xml)
          data[:files].each do |path|
            attributes = dir?(path) ? { type: 'dir' } : {}

            xml.file path, **attributes
          end
        end

        def dir?(path)
          # Add trailing slash to path to check
          # if it exists in directories list
          data[:directories].include? File.join(path, '')
        end
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::Rpm::RepositoryMetadata::BuildFilelistXmlService, feature_category: :package_registry do
  describe '#execute' do
    subject { described_class.new(data).execute }

    include_context 'with rpm package data'

    let(:data) { xml_update_params }
    let(:file_xpath) { ""//package/file"" }

    it 'adds all file nodes' do
      result = subject

      expect(result.xpath(file_xpath).count).to eq(data[:files].count)
    end

    describe 'setting type attribute' do
      context 'when all files are directories' do
        let(:dirs) do
          3.times.map { generate_directory } # rubocop:disable Performance/TimesMap
        end

        let(:files) do
          5.times.map { FFaker::Filesystem.file_name(dirs.sample) } # rubocop:disable Performance/TimesMap
        end

        let(:data) do
          {
            directories: dirs.map { ""#{_1}/"" }, # Add trailing slash as in original package
            files: dirs + files
          }
        end

        it 'set dir type attribute for directories only' do
          result = subject

          result.xpath(file_xpath).each do |tag|
            if dirs.include?(tag.content)
              expect(tag.attributes['type']&.value).to eq('dir')
            else
              expect(tag.attributes['type']).to be_nil
            end
          end
        end
      end

      def generate_directory
        FFaker::Lorem.words(3).join('/')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
  module Rpm
    module RepositoryMetadata
      class UpdateXmlService
        BUILDERS = {
          other: ::Packages::Rpm::RepositoryMetadata::BuildOtherXmlService,
          primary: ::Packages::Rpm::RepositoryMetadata::BuildPrimaryXmlService,
          filelist: ::Packages::Rpm::RepositoryMetadata::BuildFilelistXmlService
        }.freeze

        def initialize(filename:, xml: nil, data: {})
          @builder_class = BUILDERS[filename]
          raise ArgumentError, ""Filename must be one of: #{BUILDERS.keys.join(', ')}"" if @builder_class.nil?

          @xml = Nokogiri::XML(xml) if xml.present?
          @data = data
          @filename = filename
        end

        def execute
          return build_empty_structure if xml.blank?

          remove_existing_packages
          update_xml_document
          update_package_count
          xml.to_xml
        end

        private

        attr_reader :xml, :data, :builder_class, :filename

        def build_empty_structure
          Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
            xml.method_missing(builder_class::ROOT_TAG, builder_class::ROOT_ATTRIBUTES)
          end.to_xml
        end

        def update_xml_document
          # Add to the root xml element a new package metadata node
          xml.at(builder_class::ROOT_TAG).add_child(builder_class.new(data).execute)
        end

        def update_package_count
          packages_count = xml.css(""//#{builder_class::ROOT_TAG}/package"").count

          xml.at(builder_class::ROOT_TAG).attributes[""packages""].value = packages_count.to_s
        end

        def remove_existing_packages
          case filename
          when :primary
            xml.search(""checksum:contains('#{data[:pkgid]}')"").each { _1.parent&.remove }
          else
            xml.search(""[pkgid='#{data[:pkgid]}']"").each(&:remove)
          end
        end
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::Rpm::RepositoryMetadata::UpdateXmlService, feature_category: :package_registry do
  describe '#execute' do
    subject { described_class.new(filename: filename, xml: xml, data: data).execute }

    let(:xml) { nil }
    let(:data) { nil }

    shared_examples 'handling not implemented xml filename' do
      let(:filename) { :not_implemented_yet }
      let(:empty_xml) { '' }

      it 'raise error' do
        expect { subject }.to raise_error(ArgumentError)
      end
    end

    shared_context 'with primary xml file data' do
      let(:filename) { :primary }
      let(:empty_xml) do
        <<~XML
          <?xml version=""1.0"" encoding=""UTF-8""?>
          <metadata xmlns=""http://linux.duke.edu/metadata/common"" xmlns:rpm=""http://linux.duke.edu/metadata/rpm"" packages=""0""/>
        XML
      end
    end

    shared_context 'with other xml file data' do
      let(:filename) { :other }
      let(:empty_xml) do
        <<~XML
          <?xml version=""1.0"" encoding=""UTF-8""?>
          <otherdata xmlns=""http://linux.duke.edu/metadata/other"" packages=""0""/>
        XML
      end
    end

    shared_context 'with filelist xml file data' do
      let(:filename) { :filelist }
      let(:empty_xml) do
        <<~XML
          <?xml version=""1.0"" encoding=""UTF-8""?>
          <filelists xmlns=""http://linux.duke.edu/metadata/filelists"" packages=""0""/>
        XML
      end
    end

    context 'when building empty xml' do
      shared_examples 'generating empty xml' do
        it 'generate expected xml' do
          expect(subject).to eq(empty_xml)
        end
      end

      it_behaves_like 'handling not implemented xml filename'

      context ""for 'primary' xml file"" do
        include_context 'with primary xml file data'

        it_behaves_like 'generating empty xml'
      end

      context ""for 'other' xml file"" do
        include_context 'with other xml file data'

        it_behaves_like 'generating empty xml'
      end

      context ""for 'filelist' xml file"" do
        include_context 'with filelist xml file data'

        it_behaves_like 'generating empty xml'
      end
    end

    context 'when updating xml file' do
      include_context 'with rpm package data'

      let(:xml) { empty_xml }
      let(:data) { xml_update_params }
      let(:builder_class) { described_class::BUILDERS[filename] }

      shared_examples 'updating rpm xml file' do
        context 'when updating existing xml' do
          shared_examples 'changing root tag attribute' do
            it ""increment previous 'packages' value by 1"" do
              previous_value = Nokogiri::XML(xml).at(builder_class::ROOT_TAG).attributes[""packages""].value.to_i
              new_value = Nokogiri::XML(subject).at(builder_class::ROOT_TAG).attributes[""packages""].value.to_i

              expect(previous_value + 1).to eq(new_value)
            end
          end

          it 'generate valid xml add expected xml node to existing xml' do
            # Have one root attribute
            result = Nokogiri::XML::Document.parse(subject).remove_namespaces!
            expect(result.children.count).to eq(1)

            # Root node has 1 child with generated node
            expect(result.xpath(""//#{builder_class::ROOT_TAG}/package"").count).to eq(1)
          end

          context 'when empty xml' do
            it_behaves_like 'changing root tag attribute'
          end

          context 'when xml has children' do
            context ""when node with given 'pkgid' does not exist yet"" do
              let(:uniq_node_data) do
                xml_update_params.tap do |data|
                  data[:pkgid] = SecureRandom.uuid
                end
              end

              let(:xml) { build_xml_from(uniq_node_data) }

              it 'has children nodes' do
                existing_xml = Nokogiri::XML::Document.parse(xml).remove_namespaces!
                expect(existing_xml.xpath('//package').count).to eq(1)
              end

              it_behaves_like 'changing root tag attribute'
            end

            context ""when node with given 'pkgid' already exist"" do
              let(:existing_node_data) do
                existing_data = data.dup
                existing_data[:name] = FFaker::Lorem.word
                existing_data
              end

              let(:xml) { build_xml_from(existing_node_data) }

              it 'has children nodes' do
                existing_xml = Nokogiri::XML::Document.parse(xml).remove_namespaces!
                expect(existing_xml.xpath('//package').count).to eq(1)
              end

              it 'replace existing node with new data' do
                existing_xml = Nokogiri::XML::Document.parse(xml).remove_namespaces!
                result = Nokogiri::XML::Document.parse(subject).remove_namespaces!
                expect(result.xpath('//package').count).to eq(1)
                expect(result.xpath('//package').first.to_xml).not_to eq(existing_xml.xpath('//package').first.to_xml)
              end
            end

            def build_xml_from(data)
              described_class.new(filename: filename, xml: empty_xml, data: data).execute
            end
          end
        end
      end

      it_behaves_like 'handling not implemented xml filename'

      context ""for 'primary' xml file"" do
        include_context 'with primary xml file data'

        it_behaves_like 'updating rpm xml file'
      end

      context ""for 'other' xml file"" do
        include_context 'with other xml file data'

        it_behaves_like 'updating rpm xml file'
      end

      context ""for 'filelist' xml file"" do
        include_context 'with filelist xml file data'

        it_behaves_like 'updating rpm xml file'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

require 'rubygems/package'

module Packages
  module Helm
    class ExtractFileMetadataService
      ExtractionError = Class.new(StandardError)

      # Charts must be smaller than 1M because of the storage limitations of Kubernetes objects.
      # based on https://helm.sh/docs/chart_template_guide/accessing_files/
      MAX_FILE_SIZE = 1.megabytes.freeze

      def initialize(package_file)
        @package_file = package_file
      end

      def execute
        raise ExtractionError, 'invalid package file' unless valid_package_file?

        metadata
      end

      private

      def valid_package_file?
        @package_file && @package_file.package&.helm? && !@package_file.file.empty_size?
      end

      def metadata
        YAML.safe_load(chart_yaml_content)
      rescue Psych::Exception => e
        raise ExtractionError, ""Error while parsing Chart.yaml: #{e.message}""
      end

      def chart_yaml_content
        @package_file.file.use_open_file do |file|
          tar_reader = Gem::Package::TarReader.new(Zlib::GzipReader.new(file))

          chart_yaml = tar_reader.find do |entry|
            next unless entry.file?

            entry.full_name.end_with?('/Chart.yaml')
          end

          raise ExtractionError, 'Chart.yaml not found within a directory' unless chart_yaml
          raise ExtractionError, 'Chart.yaml too big' if chart_yaml.size > MAX_FILE_SIZE

          chart_yaml.read
        ensure
          tar_reader.close
        end
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::Helm::ExtractFileMetadataService, feature_category: :package_registry do
  let_it_be(:package_file) { create(:helm_package_file) }

  let(:service) { described_class.new(package_file) }

  let(:expected) do
    {
      'apiVersion' => 'v2',
      'description' => 'File, Block, and Object Storage Services for your Cloud-Native Environment',
      'icon' => 'https://rook.io/images/rook-logo.svg',
      'name' => 'rook-ceph',
      'sources' => ['https://github.com/rook/rook'],
      'version' => 'v1.5.8'
    }
  end

  subject { service.execute }

  context 'with a valid file' do
    it { is_expected.to eq(expected) }
  end

  context 'without Chart.yaml' do
    before do
      expect_next_instances_of(Gem::Package::TarReader::Entry, 14) do |entry|
        expect(entry).to receive(:full_name).exactly(:once).and_wrap_original do |m, *args|
          m.call(*args) + '_suffix'
        end
      end
    end

    it { expect { subject }.to raise_error(described_class::ExtractionError, 'Chart.yaml not found within a directory') }
  end

  context 'with Chart.yaml at root' do
    before do
      expect_next_instances_of(Gem::Package::TarReader::Entry, 14) do |entry|
        expect(entry).to receive(:full_name).exactly(:once).and_return('Chart.yaml')
      end
    end

    it { expect { subject }.to raise_error(described_class::ExtractionError, 'Chart.yaml not found within a directory') }
  end

  context 'with an invalid YAML' do
    before do
      expect_next_instance_of(Gem::Package::TarReader::Entry) do |entry|
        expect(entry).to receive(:read).and_return('{')
      end
    end

    it { expect { subject }.to raise_error(described_class::ExtractionError, 'Error while parsing Chart.yaml: (<unknown>): did not find expected node content while parsing a flow node at line 2 column 1') }
  end

  context 'with a corrupted Chart.yaml of incorrect size' do
    let(:helm_fixture_path) { expand_fixture_path('packages/helm/corrupted_chart.tgz') }
    let(:expected_error_message) { 'Chart.yaml too big' }

    before do
      allow(Zlib::GzipReader).to receive(:new).and_return(Zlib::GzipReader.new(File.open(helm_fixture_path)))
    end

    it 'raises an error with the expected message' do
      expect { subject }.to raise_error(::Packages::Helm::ExtractFileMetadataService::ExtractionError, expected_error_message)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Helm
    class ProcessFileService
      include Gitlab::Utils::StrongMemoize
      include ExclusiveLeaseGuard

      ExtractionError = Class.new(StandardError)
      DEFAULT_LEASE_TIMEOUT = 1.hour.to_i

      def initialize(channel, package_file)
        @channel = channel
        @package_file = package_file
      end

      def execute
        raise ExtractionError, 'Helm chart was not processed - package_file is not set' unless package_file

        try_obtain_lease do
          temp_package.transaction do
            rename_package_and_set_version
            rename_package_file_and_set_metadata
            cleanup_temp_package
          end
        end
      end

      private

      attr_reader :channel, :package_file

      def rename_package_and_set_version
        package.update!(
          name: metadata['name'],
          version: metadata['version'],
          status: :default
        )
      end

      def rename_package_file_and_set_metadata
        # Updating file_name updates the path where the file is stored.
        # We must pass the file again so that CarrierWave can handle the update
        package_file.update!(
          file_name: file_name,
          file: package_file.file,
          package_id: package.id,
          helm_file_metadatum_attributes: {
            channel: channel,
            metadata: metadata
          }
        )
      end

      def cleanup_temp_package
        temp_package.destroy if package.id != temp_package.id
      end

      def temp_package
        package_file.package
      end
      strong_memoize_attr :temp_package

      def package
        project_packages = package_file.package.project.packages
        package = project_packages.with_package_type(:helm)
                                  .with_name(metadata['name'])
                                  .with_version(metadata['version'])
                                  .not_pending_destruction
                                  .last
        package || temp_package
      end
      strong_memoize_attr :package

      def metadata
        ::Packages::Helm::ExtractFileMetadataService.new(package_file).execute
      end
      strong_memoize_attr :metadata

      def file_name
        ""#{metadata['name']}-#{metadata['version']}.tgz""
      end

      # used by ExclusiveLeaseGuard
      def lease_key
        ""packages:helm:process_file_service:package_file:#{package_file.id}""
      end

      # used by ExclusiveLeaseGuard
      def lease_timeout
        DEFAULT_LEASE_TIMEOUT
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::Helm::ProcessFileService, feature_category: :package_registry do
  let(:package) { create(:helm_package, without_package_files: true, status: 'processing') }
  let!(:package_file) { create(:helm_package_file, without_loaded_metadatum: true, package: package) }
  let(:channel) { 'stable' }
  let(:service) { described_class.new(channel, package_file) }

  let(:expected) do
    {
      'apiVersion' => 'v2',
      'description' => 'File, Block, and Object Storage Services for your Cloud-Native Environment',
      'icon' => 'https://rook.io/images/rook-logo.svg',
      'name' => 'rook-ceph',
      'sources' => ['https://github.com/rook/rook'],
      'version' => 'v1.5.8'
    }
  end

  describe '#execute' do
    subject(:execute) { service.execute }

    context 'without a file' do
      let(:package_file) { nil }

      it 'returns error', :aggregate_failures do
        expect { execute }
          .to not_change { Packages::Package.count }
          .and not_change { Packages::PackageFile.count }
          .and not_change { Packages::Helm::FileMetadatum.count }
          .and raise_error(Packages::Helm::ProcessFileService::ExtractionError, 'Helm chart was not processed - package_file is not set')
      end
    end

    context 'with existing package' do
      let!(:existing_package) { create(:helm_package, project: package.project, name: 'rook-ceph', version: 'v1.5.8') }

      it 'reuses existing package', :aggregate_failures do
        expect { execute }
          .to change { Packages::Package.count }.from(2).to(1)
          .and not_change { package.name }
          .and not_change { package.version }
          .and not_change { package.status }
          .and not_change { Packages::PackageFile.count }
          .and change { package_file.file_name }.from(package_file.file_name).to(""#{expected['name']}-#{expected['version']}.tgz"")
          .and change { Packages::Helm::FileMetadatum.count }.from(1).to(2)
          .and change { package_file.helm_file_metadatum }.from(nil)

        expect { package.reload }
          .to raise_error(ActiveRecord::RecordNotFound)

        expect(package_file.helm_file_metadatum.channel).to eq(channel)
        expect(package_file.helm_file_metadatum.metadata).to eq(expected)
      end

      context 'marked as pending_destruction' do
        before do
          existing_package.pending_destruction!
        end

        it 'reuses the processing package' do
          expect { execute }
            .to not_change { Packages::Package.count }
            .and not_change { Packages::PackageFile.count }
            .and change { Packages::Helm::FileMetadatum.count }.by(1)
        end
      end
    end

    context 'with a valid file' do
      it 'processes file', :aggregate_failures do
        expect { execute }
          .to not_change { Packages::Package.count }
          .and change { package.name }.from(package.name).to(expected['name'])
          .and change { package.version }.from(package.version).to(expected['version'])
          .and change { package.status }.from('processing').to('default')
          .and not_change { Packages::PackageFile.count }
          .and change { package_file.file_name }.from(package_file.file_name).to(""#{expected['name']}-#{expected['version']}.tgz"")
          .and change { Packages::Helm::FileMetadatum.count }.by(1)
          .and change { package_file.helm_file_metadatum }.from(nil)

        expect(package_file.helm_file_metadatum.channel).to eq(channel)
        expect(package_file.helm_file_metadatum.metadata).to eq(expected)
      end
    end

    context 'without Chart.yaml' do
      before do
        expect_next_instances_of(Gem::Package::TarReader::Entry, 14) do |entry|
          expect(entry).to receive(:full_name).exactly(:once).and_wrap_original do |m, *args|
            m.call(*args) + '_suffix'
          end
        end
      end

      it { expect { execute }.to raise_error(Packages::Helm::ExtractFileMetadataService::ExtractionError, 'Chart.yaml not found within a directory') }
    end

    context 'with Chart.yaml at root' do
      before do
        expect_next_instances_of(Gem::Package::TarReader::Entry, 14) do |entry|
          expect(entry).to receive(:full_name).exactly(:once).and_return('Chart.yaml')
        end
      end

      it { expect { execute }.to raise_error(Packages::Helm::ExtractFileMetadataService::ExtractionError, 'Chart.yaml not found within a directory') }
    end

    context 'with an invalid YAML' do
      before do
        expect_next_instance_of(Gem::Package::TarReader::Entry) do |entry|
          expect(entry).to receive(:read).and_return('{')
        end
      end

      it { expect { execute }.to raise_error(Packages::Helm::ExtractFileMetadataService::ExtractionError, 'Error while parsing Chart.yaml: (<unknown>): did not find expected node content while parsing a flow node at line 2 column 1') }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
  module Npm
    class CreatePackageService < ::Packages::CreatePackageService
      include Gitlab::Utils::StrongMemoize
      include ExclusiveLeaseGuard

      PACKAGE_JSON_NOT_ALLOWED_FIELDS = %w[readme readmeFilename licenseText contributors exports].freeze
      DEFAULT_LEASE_TIMEOUT = 1.hour.to_i

      def execute
        return error('Version is empty.', 400) if version.blank?
        return error('Attachment data is empty.', 400) if attachment['data'].blank?
        return error('Package already exists.', 403) if current_package_exists?
        return error('Package protected.', 403) if current_package_protected?
        return error('File is too large.', 400) if file_size_exceeded?

        package = try_obtain_lease do
          ApplicationRecord.transaction { create_npm_package! }
        end

        return error('Could not obtain package lease. Please try again.', 400) unless package

        package
      end

      private

      def create_npm_package!
        package = create_package!(:npm, name: name, version: version)

        ::Packages::CreatePackageFileService.new(package, file_params).execute
        ::Packages::CreateDependencyService.new(package, package_dependencies).execute
        ::Packages::Npm::CreateTagService.new(package, dist_tag).execute

        create_npm_metadatum!(package)

        package
      end

      def create_npm_metadatum!(package)
        package.create_npm_metadatum!(package_json: package_json)
      rescue ActiveRecord::RecordInvalid => e
        if package.npm_metadatum && package.npm_metadatum.errors.where(:package_json, :too_large).any? # rubocop: disable CodeReuse/ActiveRecord
          Gitlab::ErrorTracking.track_exception(e, field_sizes: field_sizes_for_error_tracking)
        end

        raise
      end

      def current_package_exists?
        project.packages
               .npm
               .with_name(name)
               .with_version(version)
               .not_pending_destruction
               .exists?
      end

      def current_package_protected?
        return false if Feature.disabled?(:packages_protected_packages, project)

        user_project_authorization_access_level = current_user.max_member_access_for_project(project.id)
        project.package_protection_rules.push_protected_from?(access_level: user_project_authorization_access_level, package_name: name, package_type: :npm)
      end

      def name
        params[:name]
      end

      def version
        params[:versions].each_key.first
      end
      strong_memoize_attr :version

      def version_data
        params[:versions][version]
      end

      def package_json
        version_data.except(*PACKAGE_JSON_NOT_ALLOWED_FIELDS)
      end

      def dist_tag
        params['dist-tags'].each_key.first
      end

      def package_file_name
        ""#{name}-#{version}.tgz""
      end
      strong_memoize_attr :package_file_name

      def attachment
        params['_attachments'][package_file_name]
      end
      strong_memoize_attr :attachment

      # TODO (technical debt): Extract the package size calculation to its own component and unit test it separately.
      def calculated_package_file_size
        # This calculation is based on:
        # 1. 4 chars in a Base64 encoded string are 3 bytes in the original string. Meaning 1 char is 0.75 bytes.
        # 2. The encoded string may have 1 or 2 extra '=' chars used for padding. Each padding char means 1 byte less in the original string.
        # Reference:
        # - https://blog.aaronlenoir.com/2017/11/10/get-original-length-from-base-64-string/
        # - https://en.wikipedia.org/wiki/Base64#Decoding_Base64_with_padding
        encoded_data = attachment['data']
        ((encoded_data.length * 0.75) - encoded_data[-2..].count('=')).to_i
      end
      strong_memoize_attr :calculated_package_file_size

      def file_params
        {
          file: CarrierWaveStringFile.new(Base64.decode64(attachment['data'])),
          size: calculated_package_file_size,
          file_sha1: version_data[:dist][:shasum],
          file_name: package_file_name,
          build: params[:build]
        }
      end

      def package_dependencies
        _version, versions_data = params[:versions].first
        versions_data
      end

      def file_size_exceeded?
        project.actual_limits.exceeded?(:npm_max_file_size, calculated_package_file_size)
      end

      # used by ExclusiveLeaseGuard
      def lease_key
        ""packages:npm:create_package_service:packages:#{project.id}_#{name}_#{version}""
      end

      # used by ExclusiveLeaseGuard
      def lease_timeout
        DEFAULT_LEASE_TIMEOUT
      end

      def field_sizes
        package_json.transform_values do |value|
          value.to_s.size
        end
      end
      strong_memoize_attr :field_sizes

      def filtered_field_sizes
        field_sizes.select do |_, size|
          size >= ::Packages::Npm::Metadatum::MIN_PACKAGE_JSON_FIELD_SIZE_FOR_ERROR_TRACKING
        end
      end
      strong_memoize_attr :filtered_field_sizes

      def largest_fields
        field_sizes
            .sort_by { |a| a[1] }
            .reverse[0..::Packages::Npm::Metadatum::NUM_FIELDS_FOR_ERROR_TRACKING - 1]
            .to_h
      end
      strong_memoize_attr :largest_fields

      def field_sizes_for_error_tracking
        filtered_field_sizes.empty? ? largest_fields : filtered_field_sizes
      end
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::Npm::CreatePackageService, feature_category: :package_registry do
  let(:service) { described_class.new(project, user, params) }

  subject { service.execute }

  describe '#execute' do
    include ExclusiveLeaseHelpers

    let_it_be(:namespace) { create(:namespace) }
    let_it_be_with_reload(:project) { create(:project, namespace: namespace) }
    let_it_be(:user) { project.owner }

    let(:version) { '1.0.1' }

    let(:params) do
      Gitlab::Json.parse(fixture_file('packages/npm/payload.json')
          .gsub('@root/npm-test', package_name)
          .gsub('1.0.1', version)).with_indifferent_access
    end

    let(:package_name) { ""@#{namespace.path}/my-app"" }
    let(:version_data) { params.dig('versions', version) }
    let(:lease_key) { ""packages:npm:create_package_service:packages:#{project.id}_#{package_name}_#{version}"" }

    shared_examples 'valid package' do
      it 'creates a package' do
        expect { subject }
          .to change { Packages::Package.count }.by(1)
          .and change { Packages::Package.npm.count }.by(1)
          .and change { Packages::Tag.count }.by(1)
          .and change { Packages::Npm::Metadatum.count }.by(1)
      end

      it_behaves_like 'assigns the package creator' do
        let(:package) { subject }
      end

      it { is_expected.to be_valid }

      it 'creates a package with name and version' do
        package = subject

        expect(package.name).to eq(package_name)
        expect(package.version).to eq(version)
      end

      it { expect(subject.npm_metadatum.package_json).to eq(version_data) }

      it { expect(subject.name).to eq(package_name) }
      it { expect(subject.version).to eq(version) }

      context 'with build info' do
        let_it_be(:job) { create(:ci_build, user: user) }
        let(:params) { super().merge(build: job) }

        it_behaves_like 'assigns build to package'
        it_behaves_like 'assigns status to package'

        it 'creates a package file build info' do
          expect { subject }.to change { Packages::PackageFileBuildInfo.count }.by(1)
        end
      end

      context 'when the npm metadatum creation results in a size error' do
        shared_examples 'a package json structure size too large error' do
          it 'does not create the package' do
            expect(Gitlab::ErrorTracking).to receive(:track_exception).with(
              instance_of(ActiveRecord::RecordInvalid),
              field_sizes: expected_field_sizes
            )

            expect { subject }.to raise_error(ActiveRecord::RecordInvalid, /structure is too large/)
              .and not_change { Packages::Package.count }
              .and not_change { Packages::Package.npm.count }
              .and not_change { Packages::Tag.count }
              .and not_change { Packages::Npm::Metadatum.count }
          end
        end

        context 'when some of the field sizes are above the error tracking size' do
          let(:package_json) do
            params[:versions][version].except(*::Packages::Npm::CreatePackageService::PACKAGE_JSON_NOT_ALLOWED_FIELDS)
          end

          # Only the fields that exceed the field size limit should be passed to error tracking
          let(:expected_field_sizes) do
            {
              'test' => ('test' * 10000).size,
              'field2' => ('a' * (::Packages::Npm::Metadatum::MIN_PACKAGE_JSON_FIELD_SIZE_FOR_ERROR_TRACKING + 1)).size
            }
          end

          before do
            params[:versions][version][:test] = 'test' * 10000
            params[:versions][version][:field1] =
              'a' * (::Packages::Npm::Metadatum::MIN_PACKAGE_JSON_FIELD_SIZE_FOR_ERROR_TRACKING - 1)
            params[:versions][version][:field2] =
              'a' * (::Packages::Npm::Metadatum::MIN_PACKAGE_JSON_FIELD_SIZE_FOR_ERROR_TRACKING + 1)
          end

          it_behaves_like 'a package json structure size too large error'
        end

        context 'when all of the field sizes are below the error tracking size' do
          let(:package_json) do
            params[:versions][version].except(*::Packages::Npm::CreatePackageService::PACKAGE_JSON_NOT_ALLOWED_FIELDS)
          end

          let(:expected_size) { ('a' * (::Packages::Npm::Metadatum::MIN_PACKAGE_JSON_FIELD_SIZE_FOR_ERROR_TRACKING - 1)).size }
          # Only the five largest fields should be passed to error tracking
          let(:expected_field_sizes) do
            {
              'field1' => expected_size,
              'field2' => expected_size,
              'field3' => expected_size,
              'field4' => expected_size,
              'field5' => expected_size
            }
          end

          before do
            5.times do |i|
              params[:versions][version][""field#{i + 1}""] =
                'a' * (::Packages::Npm::Metadatum::MIN_PACKAGE_JSON_FIELD_SIZE_FOR_ERROR_TRACKING - 1)
            end
          end

          it_behaves_like 'a package json structure size too large error'
        end
      end

      context 'when the npm metadatum creation results in a different error' do
        it 'does not track the error' do
          error_message = 'boom'
          invalid_npm_metadatum_error = ActiveRecord::RecordInvalid.new(
            build(:npm_metadatum).tap do |metadatum|
              metadatum.errors.add(:base, error_message)
            end
          )

          allow_next_instance_of(::Packages::Package) do |package|
            allow(package).to receive(:create_npm_metadatum!).and_raise(invalid_npm_metadatum_error)
          end

          expect(Gitlab::ErrorTracking).not_to receive(:track_exception)

          expect { subject }.to raise_error(ActiveRecord::RecordInvalid, /#{error_message}/)
        end
      end

      described_class::PACKAGE_JSON_NOT_ALLOWED_FIELDS.each do |field|
        context ""with not allowed #{field} field"" do
          before do
            params[:versions][version][field] = 'test'
          end

          it 'is persisted without the field' do
            expect { subject }
              .to change { Packages::Package.count }.by(1)
              .and change { Packages::Package.npm.count }.by(1)
              .and change { Packages::Tag.count }.by(1)
              .and change { Packages::Npm::Metadatum.count }.by(1)
            expect(subject.npm_metadatum.package_json[field]).to be_blank
          end
        end
      end
    end

    context 'scoped package' do
      it_behaves_like 'valid package'
    end

    context 'when user is no project member' do
      let_it_be(:user) { create(:user) }

      it_behaves_like 'valid package'
    end

    context 'scoped package not following the naming convention' do
      let(:package_name) { '@any-scope/package' }

      it_behaves_like 'valid package'
    end

    context 'unscoped package' do
      let(:package_name) { 'unscoped-package' }

      it_behaves_like 'valid package'
    end

    context 'package already exists' do
      let(:package_name) { ""@#{namespace.path}/my_package"" }
      let!(:existing_package) { create(:npm_package, project: project, name: package_name, version: '1.0.1') }

      it { expect(subject[:http_status]).to eq 403 }
      it { expect(subject[:message]).to be 'Package already exists.' }

      context 'marked as pending_destruction' do
        before do
          existing_package.pending_destruction!
        end

        it 'creates a new package' do
          expect { subject }
            .to change { Packages::Package.count }.by(1)
            .and change { Packages::Package.npm.count }.by(1)
            .and change { Packages::Tag.count }.by(1)
            .and change { Packages::Npm::Metadatum.count }.by(1)
        end
      end
    end

    describe 'max file size validation' do
      let(:max_file_size) { 5.bytes }

      shared_examples_for 'max file size validation failure' do
        it 'returns a 400 error', :aggregate_failures do
          expect(subject[:http_status]).to eq 400
          expect(subject[:message]).to be 'File is too large.'
        end
      end

      before do
        project.actual_limits.update!(npm_max_file_size: max_file_size)
      end

      context 'when max file size is exceeded' do
        # NOTE: The base64 encoded package data in the fixture file is the ""hello\n"" string, whose byte size is 6.
        it_behaves_like 'max file size validation failure'
      end

      context 'when file size is faked by setting the attachment length param to a lower size' do
        let(:params) { super().deep_merge!({ _attachments: { ""#{package_name}-#{version}.tgz"" => { data: encoded_package_data, length: 1 } } }) }

        # TODO (technical debt): Extract the package size calculation outside the service and add separate specs for it.
        # Right now we have several contexts here to test the calculation's different scenarios.
        context 'when encoded package data is not padded' do
          # 'Hello!' (size = 6 bytes) => 'SGVsbG8h'
          let(:encoded_package_data) { 'SGVsbG8h' }

          it_behaves_like 'max file size validation failure'
        end

        context ""when encoded package data is padded with '='"" do
          let(:max_file_size) { 4.bytes }
          # 'Hello' (size = 5 bytes) => 'SGVsbG8='
          let(:encoded_package_data) { 'SGVsbG8=' }

          it_behaves_like 'max file size validation failure'
        end

        context ""when encoded package data is padded with '=='"" do
          let(:max_file_size) { 3.bytes }
          # 'Hell' (size = 4 bytes) => 'SGVsbA=='
          let(:encoded_package_data) { 'SGVsbA==' }

          it_behaves_like 'max file size validation failure'
        end
      end
    end

    context 'with invalid name' do
      where(:package_name) do
        [
          '@inv@lid_scope/package',
          '@scope/sub/group',
          '@scope/../../package',
          '@scope%2e%2e%2fpackage'
        ]
      end

      with_them do
        it { expect { subject }.to raise_error(ActiveRecord::RecordInvalid) }
      end
    end

    context 'with empty versions' do
      let(:params) { super().merge!({ versions: {} }) }

      it { expect(subject[:http_status]).to eq 400 }
      it { expect(subject[:message]).to eq 'Version is empty.' }
    end

    context 'with invalid versions' do
      where(:version) do
        [
          '1',
          '1.2',
          '1./2.3',
          '../../../../../1.2.3',
          '%2e%2e%2f1.2.3'
        ]
      end

      with_them do
        it { expect { subject }.to raise_error(ActiveRecord::RecordInvalid, ""Validation failed: Version #{Gitlab::Regex.semver_regex_message}"") }
      end
    end

    context 'with empty attachment data' do
      let(:params) { super().merge({ _attachments: { ""#{package_name}-#{version}.tgz"" => { data: '' } } }) }

      it { expect(subject[:http_status]).to eq 400 }
      it { expect(subject[:message]).to eq 'Attachment data is empty.' }
    end

    it 'obtains a lease to create a new package' do
      expect_to_obtain_exclusive_lease(lease_key, timeout: described_class::DEFAULT_LEASE_TIMEOUT)

      subject
    end

    context 'when the lease is already taken' do
      before do
        stub_exclusive_lease_taken(lease_key, timeout: described_class::DEFAULT_LEASE_TIMEOUT)
      end

      it { expect(subject[:http_status]).to eq 400 }
      it { expect(subject[:message]).to eq 'Could not obtain package lease. Please try again.' }
    end

    context 'when feature flag :packages_protected_packages disabled' do
      let_it_be_with_reload(:package_protection_rule) { create(:package_protection_rule, package_type: :npm, project: project) }

      before do
        stub_feature_flags(packages_protected_packages: false)
      end

      context 'with matching package protection rule for all roles' do
        using RSpec::Parameterized::TableSyntax

        let(:package_name_pattern_no_match) { ""#{package_name}_no_match"" }

        where(:package_name_pattern, :push_protected_up_to_access_level) do
          ref(:package_name)                  | :developer
          ref(:package_name)                  | :owner
          ref(:package_name_pattern_no_match) | :developer
          ref(:package_name_pattern_no_match) | :owner
        end

        with_them do
          before do
            package_protection_rule.update!(package_name_pattern: package_name_pattern, push_protected_up_to_access_level: push_protected_up_to_access_level)
          end

          it_behaves_like 'valid package'
        end
      end
    end

    context 'with package protection rule for different roles and package_name_patterns' do
      using RSpec::Parameterized::TableSyntax

      let_it_be_with_reload(:package_protection_rule) { create(:package_protection_rule, package_type: :npm, project: project) }
      let_it_be(:project_developer) { create(:user).tap { |u| project.add_developer(u) } }
      let_it_be(:project_maintainer) { create(:user).tap { |u| project.add_maintainer(u) } }

      let(:project_owner) { project.owner }
      let(:package_name_pattern_no_match) { ""#{package_name}_no_match"" }

      let(:service) { described_class.new(project, current_user, params) }

      shared_examples 'protected package' do
        it { is_expected.to include http_status: 403, message: 'Package protected.' }

        it 'does not create any npm-related package records' do
          expect { subject }
            .to not_change { Packages::Package.count }
            .and not_change { Packages::Package.npm.count }
            .and not_change { Packages::Tag.count }
            .and not_change { Packages::Npm::Metadatum.count }
        end
      end

      where(:package_name_pattern, :push_protected_up_to_access_level, :current_user, :shared_examples_name) do
        ref(:package_name)                  | :developer  | ref(:project_developer)  | 'protected package'
        ref(:package_name)                  | :developer  | ref(:project_owner)      | 'valid package'
        ref(:package_name)                  | :maintainer | ref(:project_maintainer) | 'protected package'
        ref(:package_name)                  | :owner      | ref(:project_owner)      | 'protected package'
        ref(:package_name_pattern_no_match) | :developer  | ref(:project_owner)      | 'valid package'
        ref(:package_name_pattern_no_match) | :owner      | ref(:project_owner)      | 'valid package'
      end

      with_them do
        before do
          package_protection_rule.update!(package_name_pattern: package_name_pattern, push_protected_up_to_access_level: push_protected_up_to_access_level)
        end

        it_behaves_like params[:shared_examples_name]
      end
    end

    describe '#lease_key' do
      subject { service.send(:lease_key) }

      it 'returns an unique key' do
        is_expected.to eq lease_key
      end
    end
  end

  context 'when many of the same packages are created at the same time', :delete do
    let(:namespace) { create(:namespace) }
    let(:project) { create(:project, namespace: namespace) }
    let(:user) { project.owner }

    let(:version) { '1.0.1' }

    let(:params) do
      Gitlab::Json.parse(
        fixture_file('packages/npm/payload.json')
          .gsub('@root/npm-test', package_name)
          .gsub('1.0.1', version)
      ).with_indifferent_access
    end

    let(:package_name) { ""@#{namespace.path}/my-app"" }
    let(:service) { described_class.new(project, user, params) }

    subject { service.execute }

    it 'only creates one package' do
      expect { create_packages(project, user, params) }.to change { Packages::Package.count }.by(1)
    end

    context 'with different versions' do
      it 'creates all packages' do
        expect { create_packages_with_versions(project, user, params) }.to change { Packages::Package.count }.by(5)
      end
    end

    def create_packages(project, user, params)
      with_threads do
        described_class.new(project, user, params).execute
      end
    end

    def create_packages_with_versions(project, user, params)
      with_threads do |i|
        # Modify the package's version
        modified_params = Gitlab::Json.parse(params.to_json
          .gsub(version, ""1.0.#{i}"")).with_indifferent_access

        described_class.new(project, user, modified_params).execute
      end
    end

    def with_threads(count: 5, &block)
      return unless block

      # create a race condition - structure from https://blog.arkency.com/2015/09/testing-race-conditions/
      wait_for_it = true

      threads = Array.new(count) do |i|
        Thread.new do
          # A loop to make threads busy until we `join` them
          true while wait_for_it

          yield(i)
        end
      end

      wait_for_it = false
      threads.each(&:join)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Npm
    class GenerateMetadataService
      include API::Helpers::RelatedResourcesHelpers
      include Gitlab::Utils::StrongMemoize

      # Allowed fields are those defined in the abbreviated form
      # defined here: https://github.com/npm/registry/blob/master/docs/responses/package-metadata.md#abbreviated-version-object
      # except: name, version, dist, dependencies and xDependencies. Those are generated by this service.
      PACKAGE_JSON_ALLOWED_FIELDS = %w[deprecated bin directories dist engines _hasShrinkwrap].freeze

      def initialize(name, packages)
        @name = name
        @packages = packages
        @dependencies = {}
        @dependency_ids = Hash.new { |h, key| h[key] = {} }
      end

      def execute(only_dist_tags: false)
        ServiceResponse.success(payload: metadata(only_dist_tags))
      end

      private

      attr_reader :name, :packages, :dependencies, :dependency_ids

      def metadata(only_dist_tags)
        result = { dist_tags: dist_tags }

        unless only_dist_tags
          result[:name] = name
          result[:versions] = versions
        end

        result
      end

      def versions
        package_versions = {}

        packages.each_batch do |relation|
          load_dependencies(relation)
          load_dependency_ids(relation)

          batched_packages = relation.preload_files
                             .preload_npm_metadatum

          batched_packages.each do |package|
            package_file = package.installable_package_files.last

            next unless package_file

            package_versions[package.version] = build_package_version(package, package_file)
          end
        end

        package_versions
      end

      def dist_tags
        build_package_tags.tap { |t| t['latest'] ||= sorted_versions.last }
      end

      def build_package_tags
        package_tags.to_h { |tag| [tag.name, tag.package.version] }
      end

      def build_package_version(package, package_file)
        abbreviated_package_json(package).merge(
          name: package.name,
          version: package.version,
          dist: {
            shasum: package_file.file_sha1,
            tarball: tarball_url(package, package_file)
          }
        ).tap do |package_version|
          package_version.merge!(build_package_dependencies(package))
        end
      end

      def tarball_url(package, package_file)
        expose_url api_v4_projects_packages_npm_package_name___file_name_path(
          { id: package.project_id, package_name: package.name, file_name: package_file.file_name }, true
        )
      end

      def build_package_dependencies(package)
        dependency_ids[package.id].each_with_object(Hash.new { |h, key| h[key] = {} }) do |(type, ids), memo|
          ids.each do |id|
            memo[inverted_dependency_types[type]].merge!(dependencies[id])
          end
        end
      end

      def inverted_dependency_types
        Packages::DependencyLink.dependency_types.invert.stringify_keys
      end
      strong_memoize_attr :inverted_dependency_types

      def sorted_versions
        versions = packages.pluck_versions.compact
        VersionSorter.sort(versions)
      end

      def package_tags
        Packages::Tag.for_package_ids(packages)
                     .preload_package
      end

      def abbreviated_package_json(package)
        json = package.npm_metadatum&.package_json || {}
        json.slice(*PACKAGE_JSON_ALLOWED_FIELDS)
      end

      def load_dependencies(packages)
        Packages::Dependency
          .id_in(
            Packages::DependencyLink
              .for_packages(packages)
              .select_dependency_id
          )
          .id_not_in(dependencies.keys)
          .each_batch do |relation|
            relation.each do |dependency|
              dependencies[dependency.id] = { dependency.name => dependency.version_pattern }
            end
          end
      end

      def load_dependency_ids(packages)
        Packages::DependencyLink
          .dependency_ids_grouped_by_type(packages)
          .each_batch(column: :package_id) do |relation|
            relation.each do |dependency_link|
              dependency_ids[dependency_link.package_id] = dependency_link.dependency_ids_by_type
            end
          end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Packages::Npm::GenerateMetadataService, feature_category: :package_registry do
  using RSpec::Parameterized::TableSyntax

  let_it_be(:project) { create(:project) }
  let_it_be(:package_name) { ""@#{project.root_namespace.path}/test"" }
  let_it_be(:package1) { create(:npm_package, version: '2.0.4', project: project, name: package_name) }
  let_it_be(:package2) { create(:npm_package, version: '2.0.6', project: project, name: package_name) }
  let_it_be(:latest_package) { create(:npm_package, version: '2.0.11', project: project, name: package_name) }

  let(:packages) { project.packages.npm.with_name(package_name) }
  let(:metadata) { described_class.new(package_name, packages).execute }

  describe '#versions' do
    let_it_be(:version_schema) { 'public_api/v4/packages/npm_package_version' }
    let_it_be(:package_json) do
      {
        name: package_name,
        version: '2.0.4',
        deprecated: 'warning!',
        bin: './cli.js',
        directories: ['lib'],
        engines: { npm: '^7.5.6' },
        _hasShrinkwrap: false,
        dist: {
          tarball: 'http://localhost/tarball.tgz',
          shasum: '1234567890'
        },
        custom_field: 'foo_bar'
      }
    end

    subject { metadata[:versions] }

    where(:has_dependencies, :has_metadatum) do
      true  | true
      false | true
      true  | false
      false | false
    end

    with_them do
      if params[:has_dependencies]
        ::Packages::DependencyLink.dependency_types.each_key do |dependency_type| # rubocop:disable RSpec/UselessDynamicDefinition -- `dependency_type` used in `let_it_be`
          let_it_be(""package_dependency_link_for_#{dependency_type}"") do
            create(:packages_dependency_link, package: package1, dependency_type: dependency_type)
          end
        end
      end

      if params[:has_metadatum]
        let_it_be(:package_metadatadum) { create(:npm_metadatum, package: package1, package_json: package_json) }
      end

      it { is_expected.to be_a(Hash) }
      it { expect(subject[package1.version].with_indifferent_access).to match_schema(version_schema) }
      it { expect(subject[package2.version].with_indifferent_access).to match_schema(version_schema) }
      it { expect(subject[package1.version]['custom_field']).to be_blank }

      context 'for dependencies' do
        ::Packages::DependencyLink.dependency_types.each_key do |dependency_type|
          if params[:has_dependencies]
            it { expect(subject.dig(package1.version, dependency_type.to_s)).to be_any }
          else
            it { expect(subject.dig(package1.version, dependency_type)).to be nil }
          end

          it { expect(subject.dig(package2.version, dependency_type)).to be nil }
        end

        context 'when generate dependencies' do
          let(:packages) { ::Packages::Package.where(id: package1.id) }

          it 'loads grouped dependency links', :aggregate_failures do
            expect(::Packages::DependencyLink).to receive(:dependency_ids_grouped_by_type).and_call_original
            expect(::Packages::Package).not_to receive(:including_dependency_links)

            subject
          end
        end
      end

      context 'for metadatum' do
        ::Packages::Npm::GenerateMetadataService::PACKAGE_JSON_ALLOWED_FIELDS.each do |metadata_field|
          if params[:has_metadatum]
            it { expect(subject.dig(package1.version, metadata_field)).not_to be nil }
          else
            it { expect(subject.dig(package1.version, metadata_field)).to be nil }
          end

          it { expect(subject.dig(package2.version, metadata_field)).to be nil }
        end
      end

      it 'avoids N+1 database queries' do
        check_n_plus_one do
          create_list(:npm_package, 5, project: project, name: package_name).each do |npm_package|
            next unless has_dependencies

            ::Packages::DependencyLink.dependency_types.each_key do |dependency_type|
              create(:packages_dependency_link, package: npm_package, dependency_type: dependency_type)
            end
          end
        end
      end
    end

    context 'with package files pending destruction' do
      let_it_be(:package_file_pending_destruction) do
        create(:package_file, :pending_destruction, package: package2, file_sha1: 'pending_destruction_sha1')
      end

      let(:shasums) { subject.values.map { |v| v.dig(:dist, :shasum) } }

      it 'does not return them' do
        expect(shasums).not_to include(package_file_pending_destruction.file_sha1)
      end
    end
  end

  describe '#dist_tags' do
    subject { metadata[:dist_tags] }

    context 'for packages without tags' do
      it { is_expected.to be_a(Hash) }
      it { expect(subject['latest']).to eq(latest_package.version) }

      it 'avoids N+1 database queries' do
        check_n_plus_one(only_dist_tags: true) do
          create_list(:npm_package, 5, project: project, name: package_name)
        end
      end
    end

    context 'for packages with tags' do
      let_it_be(:package_tag1) { create(:packages_tag, package: package1, name: 'release_a') }
      let_it_be(:package_tag2) { create(:packages_tag, package: package1, name: 'test_release') }
      let_it_be(:package_tag3) { create(:packages_tag, package: package2, name: 'release_b') }
      let_it_be(:package_tag4) { create(:packages_tag, package: latest_package, name: 'release_c') }
      let_it_be(:package_tag5) { create(:packages_tag, package: latest_package, name: 'latest') }

      it { is_expected.to be_a(Hash) }
      it { expect(subject[package_tag1.name]).to eq(package1.version) }
      it { expect(subject[package_tag2.name]).to eq(package1.version) }
      it { expect(subject[package_tag3.name]).to eq(package2.version) }
      it { expect(subject[package_tag4.name]).to eq(latest_package.version) }
      it { expect(subject[package_tag5.name]).to eq(latest_package.version) }

      it 'avoids N+1 database queries' do
        check_n_plus_one(only_dist_tags: true) do
          create_list(:npm_package, 5, project: project, name: package_name).each_with_index do |npm_package, index|
            create(:packages_tag, package: npm_package, name: ""tag_#{index}"")
          end
        end
      end
    end
  end

  context 'when passing only_dist_tags: true' do
    subject { described_class.new(package_name, packages).execute(only_dist_tags: true) }

    it 'returns only dist tags' do
      expect(subject.payload.keys).to contain_exactly(:dist_tags)
    end
  end

  def check_n_plus_one(only_dist_tags: false)
    pkgs = project.packages.npm.with_name(package_name).preload_files
    control = ActiveRecord::QueryRecorder.new do
      described_class.new(package_name, pkgs).execute(only_dist_tags: only_dist_tags)
    end

    yield

    pkgs = project.packages.npm.with_name(package_name).preload_files

    expect do
      described_class.new(package_name, pkgs).execute(only_dist_tags: only_dist_tags)
    end.not_to exceed_query_limit(control)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Npm
    class DeprecatePackageService < BaseService
      Deprecated = Struct.new(:package_id, :message)
      BATCH_SIZE = 50

      def initialize(project, params)
        super(project, nil, params)
      end

      def execute(async: false)
        return ::Packages::Npm::DeprecatePackageWorker.perform_async(project.id, filtered_params) if async

        packages.select(:id, :version).each_batch(of: BATCH_SIZE) do |relation|
          deprecated_metadatum = handle_batch(relation)
          update_metadatum(deprecated_metadatum)
        end
      end

      private

      # To avoid passing the whole metadata to the worker
      def filtered_params
        {
          package_name: params[:package_name],
          versions: params[:versions].transform_values { |version| version.slice(:deprecated) }
        }
      end

      def packages
        ::Packages::Npm::PackageFinder
          .new(params['package_name'], project: project)
          .execute
      end

      def handle_batch(relation)
        relation
          .preload_npm_metadatum
          .filter_map { |package| deprecate(package) }
      end

      def deprecate(package)
        deprecation_message = params.dig('versions', package.version, 'deprecated')
        return if deprecation_message.nil?

        npm_metadatum = package.npm_metadatum
        return if identical?(npm_metadatum.package_json['deprecated'], deprecation_message)

        Deprecated.new(npm_metadatum.package_id, deprecation_message)
      end

      def identical?(package_json_deprecated, deprecation_message)
        package_json_deprecated == deprecation_message ||
          (package_json_deprecated.nil? && deprecation_message.empty?)
      end

      def update_metadatum(deprecated_metadatum)
        return if deprecated_metadatum.empty?

        deprecation_message = deprecated_metadatum.first.message

        ::Packages::Npm::Metadatum
          .package_id_in(deprecated_metadatum.map(&:package_id))
          .update_all(update_clause(deprecation_message))
      end

      def update_clause(deprecation_message)
        if deprecation_message.empty?
          ""package_json = package_json - 'deprecated'""
        else
          [""package_json = jsonb_set(package_json, '{deprecated}', ?)"", deprecation_message.to_json]
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Npm::DeprecatePackageService, feature_category: :package_registry do
  let_it_be(:namespace) { create(:namespace) }
  let_it_be(:project) { create(:project, namespace: namespace) }

  let_it_be(:package_name) { ""@#{namespace.path}/my-app"" }
  let_it_be_with_reload(:package_1) do
    create(:npm_package, project: project, name: package_name, version: '1.0.1').tap do |package|
      create(:npm_metadatum, package: package)
    end
  end

  let_it_be(:package_2) do
    create(:npm_package, project: project, name: package_name, version: '1.0.2').tap do |package|
      create(:npm_metadatum, package: package)
    end
  end

  let(:service) { described_class.new(project, params) }

  subject(:execute) { service.execute }

  describe '#execute' do
    context 'when passing deprecatation message' do
      let(:params) do
        {
          'package_name' => package_name,
          'versions' => {
            '1.0.1' => {
              'name' => package_name,
              'deprecated' => 'This version is deprecated'
            },
            '1.0.2' => {
              'name' => package_name,
              'deprecated' => 'This version is deprecated'
            }
          }
        }
      end

      before do
        package_json = package_2.npm_metadatum.package_json
        package_2.npm_metadatum.update!(package_json: package_json.merge('deprecated' => 'old deprecation message'))
      end

      it 'adds or updates the deprecated field' do
        expect { execute }
          .to change { package_1.reload.npm_metadatum.package_json['deprecated'] }.to('This version is deprecated')
          .and change { package_2.reload.npm_metadatum.package_json['deprecated'] }
            .from('old deprecation message').to('This version is deprecated')
      end

      it 'executes 5 queries' do
        queries = ActiveRecord::QueryRecorder.new do
          execute
        end

        # 1. each_batch lower bound
        # 2. each_batch upper bound
        # 3. SELECT packages_packages.id, packages_packages.version FROM packages_packages
        # 4. SELECT packages_npm_metadata.* FROM packages_npm_metadata
        # 5. UPDATE packages_npm_metadata SET package_json =
        expect(queries.count).to eq(5)
      end
    end

    context 'when passing deprecated as empty string' do
      let(:params) do
        {
          'package_name' => package_name,
          'versions' => {
            '1.0.1' => {
              'name' => package_name,
              'deprecated' => ''
            }
          }
        }
      end

      before do
        package_json = package_1.npm_metadatum.package_json
        package_1.npm_metadatum.update!(package_json: package_json.merge('deprecated' => 'This version is deprecated'))
      end

      it 'removes the deprecation warning' do
        expect { execute }
          .to change { package_1.reload.npm_metadatum.package_json['deprecated'] }
            .from('This version is deprecated').to(nil)
      end
    end

    context 'when passing async: true to execute' do
      let(:params) do
        {
          package_name: package_name,
          versions: {
            '1.0.1': {
              deprecated: 'This version is deprecated'
            }
          }
        }
      end

      it 'calls the worker and return' do
        expect(::Packages::Npm::DeprecatePackageWorker).to receive(:perform_async).with(project.id, params)
        expect(service).not_to receive(:packages)

        service.execute(async: true)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Packages
  module Npm
    class CreateMetadataCacheService
      include Gitlab::Utils::StrongMemoize
      include ExclusiveLeaseGuard

      # used by ExclusiveLeaseGuard
      DEFAULT_LEASE_TIMEOUT = 1.hour.to_i.freeze

      def initialize(project, package_name)
        @project = project
        @package_name = package_name
      end

      def execute
        try_obtain_lease do
          Packages::Npm::MetadataCache
            .find_or_build(package_name: package_name, project_id: project.id)
            .update!(
              file: CarrierWaveStringFile.new(metadata_content),
              size: metadata_content.bytesize
            )
        end
      end

      private

      attr_reader :package_name, :project

      def metadata_content
        ::API::Entities::NpmPackage.represent(metadata.payload).to_json
      end
      strong_memoize_attr :metadata_content

      def packages
        ::Packages::Npm::PackageFinder
          .new(package_name, project: project)
          .execute
      end

      def metadata
        Packages::Npm::GenerateMetadataService.new(package_name, packages).execute
      end

      # used by ExclusiveLeaseGuard
      def lease_key
        ""packages:npm:create_metadata_cache_service:metadata_caches:#{project.id}_#{package_name}""
      end

      # used by ExclusiveLeaseGuard
      def lease_timeout
        DEFAULT_LEASE_TIMEOUT
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Packages::Npm::CreateMetadataCacheService, :clean_gitlab_redis_shared_state, feature_category: :package_registry do
  include ExclusiveLeaseHelpers

  let_it_be(:project) { create(:project) }
  let_it_be(:package_name) { ""@#{project.root_namespace.path}/npm-test"" }
  let_it_be(:package) { create(:npm_package, version: '1.0.0', project: project, name: package_name) }

  let(:lease_key) { ""packages:npm:create_metadata_cache_service:metadata_caches:#{project.id}_#{package_name}"" }
  let(:service) { described_class.new(project, package_name) }

  describe '#execute' do
    let(:npm_metadata_cache) { Packages::Npm::MetadataCache.last }

    subject { service.execute }

    it 'creates a new metadata cache', :aggregate_failures do
      expect { subject }.to change { Packages::Npm::MetadataCache.count }.by(1)

      metadata = Gitlab::Json.parse(npm_metadata_cache.file.read)

      expect(npm_metadata_cache.package_name).to eq(package_name)
      expect(npm_metadata_cache.project_id).to eq(project.id)
      expect(npm_metadata_cache.size).to eq(metadata.to_json.bytesize)
      expect(metadata['name']).to eq(package_name)
      expect(metadata['versions'].keys).to contain_exactly('1.0.0')
    end

    context 'with existing metadata cache' do
      let_it_be(:npm_metadata_cache) { create(:npm_metadata_cache, package_name: package_name, project_id: project.id) }
      let_it_be(:metadata) { Gitlab::Json.parse(npm_metadata_cache.file.read) }
      let_it_be(:metadata_size) { npm_metadata_cache.size }
      let_it_be(:tag_name) { 'new-tag' }
      let_it_be(:tag) { create(:packages_tag, package: package, name: tag_name) }

      it 'does not create a new metadata cache' do
        expect { subject }.to change { Packages::Npm::MetadataCache.count }.by(0)
      end

      it 'updates the metadata cache', :aggregate_failures do
        subject

        new_metadata = Gitlab::Json.parse(npm_metadata_cache.file.read)

        expect(new_metadata).not_to eq(metadata)
        expect(new_metadata['dist-tags'].keys).to include(tag_name)
        expect(npm_metadata_cache.reload.size).not_to eq(metadata_size)
      end
    end

    it 'obtains a lease to create a new metadata cache' do
      expect_to_obtain_exclusive_lease(lease_key, timeout: described_class::DEFAULT_LEASE_TIMEOUT)

      subject
    end

    context 'when the lease is already taken' do
      before do
        stub_exclusive_lease_taken(lease_key, timeout: described_class::DEFAULT_LEASE_TIMEOUT)
      end

      it 'does not create a new metadata cache' do
        expect { subject }.to change { Packages::Npm::MetadataCache.count }.by(0)
      end

      it 'returns nil' do
        expect(subject).to be_nil
      end
    end
  end

  describe '#lease_key' do
    subject { service.send(:lease_key) }

    it 'returns an unique key' do
      is_expected.to eq lease_key
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
  module Npm
    class CreateTagService
      include Gitlab::Utils::StrongMemoize

      attr_reader :package, :tag_name

      def initialize(package, tag_name)
        @package = package
        @tag_name = tag_name
      end

      def execute
        if existing_tag.present?
          existing_tag.update_column(:package_id, package.id)
          existing_tag
        else
          package.tags.create!(name: tag_name)
        end
      end

      private

      def existing_tag
        Packages::TagsFinder
            .new(package.project, package.name, package_type: package.package_type)
            .find_by_name(tag_name)
      end
      strong_memoize_attr :existing_tag
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Packages::Npm::CreateTagService, feature_category: :package_registry do
  let(:package) { create(:npm_package) }
  let(:tag_name) { 'test-tag' }

  describe '#execute' do
    subject { described_class.new(package, tag_name).execute }

    shared_examples 'it creates the tag' do
      it { expect { subject }.to change { Packages::Tag.count }.by(1) }
      it { expect(subject.name).to eq(tag_name) }

      it 'adds tag to the package' do
        tag = subject
        expect(package.reload.tags).to match_array([tag])
      end
    end

    context 'with no existing tag name' do
      it_behaves_like 'it creates the tag'
    end

    context 'with exisiting tag name' do
      let!(:package_tag2) { create(:packages_tag, package: package2, name: tag_name) }

      context 'on package with different name' do
        let!(:package2) { create(:npm_package, project: package.project) }

        it_behaves_like 'it creates the tag'
      end

      context 'on different package type' do
        let!(:package2) { create(:conan_package, project: package.project, name: 'conan_package_name', version: package.version) }

        it_behaves_like 'it creates the tag'
      end

      context 'on same package with different version' do
        let!(:package2) { create(:npm_package, project: package.project, name: package.name, version: '5.0.0-testing') }

        it { expect { subject }.to not_change { Packages::Tag.count } }
        it { expect(subject.name).to eq(tag_name) }

        it 'adds tag to the package' do
          tag = subject
          expect(package.reload.tags).to match_array([tag])
          expect(package2.reload.tags).to be_empty
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Boards
  class DestroyService < Boards::BaseService
    def execute(board)
      board.destroy!

      ServiceResponse.success
    end

    private

    def boards
      parent.boards
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Boards::DestroyService, feature_category: :team_planning do
  context 'with project board' do
    let_it_be(:parent) { create(:project) }

    let(:boards) { parent.boards }
    let(:board_factory) { :board }

    it_behaves_like 'board destroy service'
  end

  context 'with group board' do
    let_it_be(:parent) { create(:group) }

    let(:boards) { parent.boards }
    let(:board_factory) { :board }

    it_behaves_like 'board destroy service'
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Boards
  class CreateService < Boards::BaseService
    def execute
      unless can_create_board?
        return ServiceResponse.error(message: ""You don't have the permission to create a board for this resource."")
      end

      create_board!
    end

    private

    def can_create_board?
      parent_board_collection.empty? || parent.multiple_issue_boards_available?
    end

    def create_board!
      board = parent_board_collection.create(params)

      unless board.persisted?
        return ServiceResponse.error(message: ""There was an error when creating a board."", payload: board)
      end

      board.tap do |created_board|
        created_board.lists.create(list_type: :backlog)
        created_board.lists.create(list_type: :closed)
      end

      ServiceResponse.success(payload: board)
    end

    def parent_board_collection
      parent.boards
    end
  end
end

Boards::CreateService.prepend_mod_with('Boards::CreateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Boards::CreateService, feature_category: :team_planning do
  describe '#execute' do
    context 'when board parent is a project' do
      let(:parent) { create(:project) }

      subject(:service) { described_class.new(parent, double) }

      it_behaves_like 'boards create service'
    end

    context 'when board parent is a group' do
      let(:parent) { create(:group) }

      subject(:service) { described_class.new(parent, double) }

      it_behaves_like 'boards create service'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Boards
  module Lists
    class MoveService < Boards::BaseService
      def execute(list)
        @board = list.board
        @old_position = list.position
        @new_position = params[:position]

        return false unless list.movable?
        return false unless valid_move?

        list.with_lock do
          reorder_intermediate_lists
          update_list_position(list)
        end
      end

      private

      attr_reader :board, :old_position, :new_position

      def valid_move?
        new_position.present? && new_position != old_position && new_position.between?(0, max_position)
      end

      def max_position
        board.lists.movable.maximum(:position)
      end

      def reorder_intermediate_lists
        if old_position < new_position
          decrement_intermediate_lists
        else
          increment_intermediate_lists
        end
      end

      # rubocop: disable CodeReuse/ActiveRecord
      def decrement_intermediate_lists
        board.lists.movable.where('position > ?',  old_position)
                           .where('position <= ?', new_position)
                           .update_all('position = position - 1')
      end
      # rubocop: enable CodeReuse/ActiveRecord

      # rubocop: disable CodeReuse/ActiveRecord
      def increment_intermediate_lists
        board.lists.movable.where('position >= ?', new_position)
                           .where('position < ?',  old_position)
                           .update_all('position = position + 1')
      end
      # rubocop: enable CodeReuse/ActiveRecord

      def update_list_position(list)
        list.update_attribute(:position, new_position)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Boards::Lists::MoveService, feature_category: :team_planning do
  describe '#execute' do
    context 'when board parent is a project' do
      let(:project) { create(:project) }
      let(:board)   { create(:board, project: project) }
      let(:user)    { create(:user) }

      let(:parent) { project }

      it_behaves_like 'lists move service'
    end

    context 'when board parent is a group' do
      let(:group) { create(:group) }
      let(:board)   { create(:board, group: group) }
      let(:user)    { create(:user) }

      let(:parent) { group }

      it_behaves_like 'lists move service'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Boards
  module Lists
    # overridden in EE for board lists and also for epic board lists.
    class DestroyService < Boards::Lists::BaseDestroyService
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Boards::Lists::DestroyService, feature_category: :team_planning do
  let_it_be(:user) { create(:user) }

  let(:list_type) { :list }

  describe '#execute' do
    context 'when board parent is a project' do
      let_it_be(:project) { create(:project) }
      let_it_be(:board) { create(:board, project: project) }
      let_it_be(:list) { create(:list, board: board) }
      let_it_be(:closed_list) { board.lists.closed.first }

      let(:params) do
        { board: board }
      end

      let(:parent) { project }

      it_behaves_like 'lists destroy service'
    end

    context 'when board parent is a group' do
      let_it_be(:group) { create(:group) }
      let_it_be(:board) { create(:board, group: group) }
      let_it_be(:list) { create(:list, board: board) }
      let_it_be(:closed_list) { board.lists.closed.first }

      let(:params) do
        { board: board }
      end

      let(:parent) { group }

      it_behaves_like 'lists destroy service'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Boards
  module Lists
    class UpdateService < Boards::Lists::BaseUpdateService
      def can_read?(list)
        Ability.allowed?(current_user, :read_issue_board_list, parent)
      end

      def can_admin?(list)
        Ability.allowed?(current_user, :admin_issue_board_list, parent)
      end
    end
  end
end

Boards::Lists::UpdateService.prepend_mod_with('Boards::Lists::UpdateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Boards::Lists::UpdateService, feature_category: :team_planning do
  let_it_be(:user) { create(:user) }

  let!(:list) { create(:list, board: board, position: 0) }
  let!(:list2) { create(:list, board: board, position: 1) }

  describe '#execute' do
    let(:service) { described_class.new(board.resource_parent, user, params) }

    context 'when position parameter is present' do
      let(:params) { { position: 1 } }

      context 'for projects' do
        let(:project) { create(:project, :private) }
        let(:board) { create(:board, project: project) }

        it_behaves_like 'moving list'
      end

      context 'for groups' do
        let(:group) { create(:group, :private) }
        let(:board) { create(:board, group: group) }

        it_behaves_like 'moving list'
      end
    end

    context 'when collapsed parameter is present' do
      let(:params) { { collapsed: true } }

      context 'for projects' do
        let(:project) { create(:project, :private) }
        let(:board) { create(:board, project: project) }

        it_behaves_like 'updating list preferences'
      end

      context 'for groups' do
        let(:project) { create(:project, :private) }
        let(:board) { create(:board, project: project) }

        it_behaves_like 'updating list preferences'
      end
    end

    context 'when position and collapsed are both present' do
      let(:params) { { collapsed: true, position: 1 } }

      context 'for projects' do
        let(:project) { create(:project, :private) }
        let(:board) { create(:board, project: project) }

        it_behaves_like 'moving list'
        it_behaves_like 'updating list preferences'
      end

      context 'for groups' do
        let(:group) { create(:group, :private) }
        let(:board) { create(:board, group: group) }

        it_behaves_like 'moving list'
        it_behaves_like 'updating list preferences'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Boards
  module Lists
    class ListService < Boards::BaseService
      def execute(board, create_default_lists: true)
        if create_default_lists && !board.lists.backlog.exists?
          board.lists.create(list_type: :backlog)
        end

        lists = board.lists.preload_associated_models
        lists = lists.with_types(available_list_types_for(board))

        return lists.id_in(params[:list_id]) if params[:list_id].present?

        lists
      end

      private

      def available_list_types_for(board)
        licensed_list_types(board) + visible_lists(board)
      end

      def licensed_list_types(board)
        [List.list_types[:label]]
      end

      def visible_lists(board)
        [].tap do |visible|
          visible << ::List.list_types[:backlog] unless board.hide_backlog_list?
          visible << ::List.list_types[:closed] unless board.hide_closed_list?
        end
      end
    end
  end
end

Boards::Lists::ListService.prepend_mod_with('Boards::Lists::ListService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Boards::Lists::ListService, feature_category: :team_planning do
  let_it_be(:user) { create(:user) }
  let_it_be(:group) { create(:group) }

  RSpec.shared_examples 'FOSS lists only' do
    context 'when board contains a non FOSS list' do
      # This scenario may happen when there used to be an EE license and user downgraded
      let_it_be(:backlog_list) { board.lists.backlog.first }
      let_it_be(:milestone) { create(:milestone, group: group) }
      let_it_be(:assignee_list) do
        list = build(:list, board: board, user_id: user.id, list_type: List.list_types[:assignee], position: 0)
        list.save!(validate: false)
        list
      end

      let_it_be(:milestone_list) do
        list = build(:list, board: board, milestone_id: milestone.id, list_type: List.list_types[:milestone], position: 1) # rubocop:disable Layout/LineLength
        list.save!(validate: false)
        list
      end

      it ""returns only FOSS board's lists"" do
        # just making sure these non FOSS lists actually exist on the board
        expect(board.lists.with_types([List.list_types[:assignee], List.list_types[:milestone]]).count).to eq 2
        # check that the FOSS lists are not returned from the service
        expect(service.execute(board)).to match_array [backlog_list, list, board.lists.closed.first]
      end
    end
  end

  describe '#execute' do
    let(:service) { described_class.new(parent, user) }

    context 'when board parent is a project' do
      let_it_be(:project) { create(:project, group: group) }
      let_it_be_with_reload(:board) { create(:board, project: project) }
      let_it_be(:label) { create(:label, project: project) }
      let_it_be(:list) { create(:list, board: board, label: label) }
      let_it_be(:unrelated_list) { create(:list) }

      let(:parent) { project }

      it_behaves_like 'lists list service'
      it_behaves_like 'FOSS lists only'
    end

    context 'when board parent is a group' do
      let_it_be_with_reload(:board) { create(:board, group: group) }
      let_it_be(:label) { create(:group_label, group: group) }
      let_it_be(:list) { create(:list, board: board, label: label) }
      let_it_be(:unrelated_list) { create(:list) }

      let(:parent) { group }

      it_behaves_like 'lists list service'
      it_behaves_like 'FOSS lists only'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Boards
  module Lists
    class CreateService < Boards::Lists::BaseCreateService
    end
  end
end

Boards::Lists::CreateService.prepend_mod_with('Boards::Lists::CreateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Boards::Lists::CreateService, feature_category: :team_planning do
  context 'when board parent is a project' do
    let_it_be(:parent) { create(:project) }
    let_it_be(:board) { create(:board, project: parent) }
    let_it_be(:label) { create(:label, project: parent, name: 'in-progress') }

    it_behaves_like 'board lists create service'
  end

  context 'when board parent is a group' do
    let_it_be(:parent) { create(:group) }
    let_it_be(:board) { create(:board, group: parent) }
    let_it_be(:label) { create(:group_label, group: parent, name: 'in-progress') }

    it_behaves_like 'board lists create service'
  end

  def create_list(params)
    create(:list, params.merge(board: board))
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Boards
  module Visits
    class CreateService < Boards::BaseService
      def execute(board)
        return unless current_user && Gitlab::Database.read_write?
        return unless board

        model.visited!(current_user, board)
      end

      private

      def model
        return BoardGroupRecentVisit if parent.is_a?(Group)

        BoardProjectRecentVisit
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Boards::Visits::CreateService, feature_category: :team_planning do
  describe '#execute' do
    let(:user) { create(:user) }

    context 'when a project board' do
      let_it_be(:project) { create(:project) }
      let_it_be(:board)   { create(:board, project: project) }

      let_it_be(:model) { BoardProjectRecentVisit }

      it_behaves_like 'boards recent visit create service'
    end

    context 'when a group board' do
      let_it_be(:group) { create(:group) }
      let_it_be(:board) { create(:board, group: group) }
      let_it_be(:model) { BoardGroupRecentVisit }

      it_behaves_like 'boards recent visit create service'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Boards
  module Issues
    class MoveService < Boards::BaseItemMoveService
      def execute_multiple(issues)
        return execute_multiple_empty_result if issues.empty?

        handled_issues = []
        last_inserted_issue_id = nil
        count = issues.each.inject(0) do |moved_count, issue|
          issue_modification_params = issuable_params(issue)
          next moved_count if issue_modification_params.empty?

          if last_inserted_issue_id
            issue_modification_params[:move_between_ids] = move_below(last_inserted_issue_id)
          end

          last_inserted_issue_id = issue.id
          handled_issue = move_single_issuable(issue, issue_modification_params)
          handled_issues << present_issue_entity(handled_issue) if handled_issue
          handled_issue && handled_issue.valid? ? moved_count + 1 : moved_count
        end

        {
          count: count,
          success: count == issues.size,
          issues: handled_issues
        }
      end

      private

      def present_issue_entity(issue)
        ::API::Entities::Issue.represent(issue)
      end

      def execute_multiple_empty_result
        @execute_multiple_empty_result ||= {
          count: 0,
          success: false,
          issues: []
        }
      end

      def move_below(id)
        move_between_ids({ move_after_id: nil, move_before_id: id })
      end

      def board
        @board ||= parent.boards.find(params[:board_id])
      end

      def update(issue, issue_modification_params)
        ::Issues::UpdateService.new(container: issue.project, current_user: current_user, params: issue_modification_params).execute(issue)
      end

      def moving_to_list_items_relation
        Boards::Issues::ListService.new(board.resource_parent, current_user, board_id: board.id, id: moving_to_list.id).execute
      end
    end
  end
end

Boards::Issues::MoveService.prepend_mod_with('Boards::Issues::MoveService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Boards::Issues::MoveService, feature_category: :team_planning do
  describe '#execute' do
    context 'when parent is a project' do
      let(:user) { create(:user) }
      let(:project) { create(:project) }
      let(:board1) { create(:board, project: project) }
      let(:board2) { create(:board, project: project) }

      let(:bug) { create(:label, project: project, name: 'Bug') }
      let(:development) { create(:label, project: project, name: 'Development') }
      let(:testing) { create(:label, project: project, name: 'Testing') }
      let(:regression) { create(:label, project: project, name: 'Regression') }

      let!(:list1)   { create(:list, board: board1, label: development, position: 0) }
      let!(:list2)   { create(:list, board: board1, label: testing, position: 1) }
      let!(:closed)  { create(:closed_list, board: board1) }

      let(:parent) { project }

      before do
        parent.add_developer(user)
      end

      it_behaves_like 'issues move service'
    end

    context 'when parent is a group' do
      let(:user) { create(:user) }
      let(:group) { create(:group) }
      let(:project) { create(:project, namespace: group) }
      let(:board1) { create(:board, group: group) }
      let(:board2) { create(:board, group: group) }

      let(:bug) { create(:group_label, group: group, name: 'Bug') }
      let(:development) { create(:group_label, group: group, name: 'Development') }
      let(:testing) { create(:group_label, group: group, name: 'Testing') }
      let(:regression) { create(:group_label, group: group, name: 'Regression') }

      let!(:list1)   { create(:list, board: board1, label: development, position: 0) }
      let!(:list2)   { create(:list, board: board1, label: testing, position: 1) }
      let!(:closed)  { create(:closed_list, board: board1) }

      let(:parent) { group }

      before do
        parent.add_developer(user)
      end

      it_behaves_like 'issues move service', true
    end

    describe '#execute_multiple' do
      let_it_be(:group)  { create(:group) }
      let_it_be(:user)   { create(:user) }
      let_it_be(:project) { create(:project, namespace: group) }
      let_it_be(:board1) { create(:board, group: group) }
      let_it_be(:development) { create(:group_label, group: group, name: 'Development') }
      let_it_be(:testing) { create(:group_label, group: group, name: 'Testing') }
      let_it_be(:list1) { create(:list, board: board1, label: development, position: 0) }
      let_it_be(:list2) { create(:list, board: board1, label: testing, position: 1) }

      let(:params) { { board_id: board1.id, from_list_id: list1.id, to_list_id: list2.id } }

      before do
        project.add_developer(user)
      end

      it 'returns the expected result if list of issues is empty' do
        expect(described_class.new(group, user, params).execute_multiple([])).to eq({ count: 0, success: false, issues: [] })
      end

      context 'moving multiple issues' do
        let(:issue1) { create(:labeled_issue, project: project, labels: [development]) }
        let(:issue2) { create(:labeled_issue, project: project, labels: [development]) }

        it 'moves multiple issues from one list to another' do
          expect(described_class.new(group, user, params).execute_multiple([issue1, issue2])).to be_truthy

          expect(issue1.labels).to eq([testing])
          expect(issue2.labels).to eq([testing])
        end
      end

      context 'moving a single issue' do
        let(:issue1) { create(:labeled_issue, project: project, labels: [development]) }

        it 'moves one issue' do
          expect(described_class.new(group, user, params).execute_multiple([issue1])).to be_truthy

          expect(issue1.labels).to eq([testing])
        end
      end

      context 'moving issues visually after an existing issue' do
        let(:existing_issue) { create(:labeled_issue, project: project, labels: [testing], relative_position: 10) }
        let(:issue1) { create(:labeled_issue, project: project, labels: [development]) }
        let(:issue2) { create(:labeled_issue, project: project, labels: [development]) }

        let(:move_params) do
          params.dup.tap do |hash|
            hash[:move_before_id] = existing_issue.id
          end
        end

        it 'moves one issue' do
          expect(described_class.new(group, user, move_params).execute_multiple([issue1, issue2])).to be_truthy

          expect(issue1.labels).to eq([testing])
          expect(issue2.labels).to eq([testing])

          expect(issue1.relative_position > existing_issue.relative_position).to eq(true)
          expect(issue2.relative_position > issue1.relative_position).to eq(true)
        end
      end

      context 'moving issues visually before an existing issue' do
        let(:existing_issue) { create(:labeled_issue, project: project, labels: [testing], relative_position: 10) }
        let(:issue1) { create(:labeled_issue, project: project, labels: [development]) }
        let(:issue2) { create(:labeled_issue, project: project, labels: [development]) }

        let(:move_params) do
          params.dup.tap do |hash|
            hash[:move_after_id] = existing_issue.id
          end
        end

        it 'moves one issue' do
          expect(described_class.new(group, user, move_params).execute_multiple([issue1, issue2])).to be_truthy

          expect(issue1.labels).to eq([testing])
          expect(issue2.labels).to eq([testing])

          expect(issue2.relative_position < existing_issue.relative_position).to eq(true)
          expect(issue1.relative_position < issue2.relative_position).to eq(true)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Boards
  module Issues
    class ListService < Boards::BaseItemsListService
      include Gitlab::Utils::StrongMemoize

      def self.valid_params
        IssuesFinder.valid_params
      end

      # It is a class method because we cannot apply it
      # prior to knowing how many items should be fetched for a list.
      def self.initialize_relative_positions(board, current_user, issues)
        if Gitlab::Database.read_write? && !board.disabled_for?(current_user)
          Issue.move_nulls_to_end(issues)
        end
      end

      private

      def order(items)
        return items.order_closed_at_desc if list&.closed?

        items.order_by_relative_position
      end

      def finder
        IssuesFinder.new(current_user, filter_params)
      end

      def board
        @board ||= parent.boards.find(params[:board_id])
      end

      def filter_params
        set_scope
        set_non_archived
        set_issue_types

        super
      end

      def set_scope
        params[:include_subgroups] = board.group_board?
      end

      def set_non_archived
        params[:non_archived] = parent.is_a?(Group)
      end

      def set_issue_types
        params[:issue_types] ||= Issue::TYPES_FOR_BOARD_LIST
      end

      def item_model
        Issue
      end
    end
  end
end

Boards::Issues::ListService.prepend_mod_with('Boards::Issues::ListService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Boards::Issues::ListService, feature_category: :team_planning do
  describe '#execute' do
    let_it_be(:user) { create(:user) }

    context 'when parent is a project' do
      let_it_be(:project) { create(:project, :empty_repo) }
      let_it_be(:board)   { create(:board, project: project) }

      let_it_be(:m1) { create(:milestone, project: project) }
      let_it_be(:m2) { create(:milestone, project: project) }

      let_it_be(:bug) { create(:label, project: project, name: 'Bug') }
      let_it_be(:development) { create(:label, project: project, name: 'Development') }
      let_it_be(:testing) { create(:label, project: project, name: 'Testing') }
      let_it_be(:p1) { create(:label, title: 'P1', project: project, priority: 1) }
      let_it_be(:p2) { create(:label, title: 'P2', project: project, priority: 2) }
      let_it_be(:p3) { create(:label, title: 'P3', project: project, priority: 3) }

      let_it_be(:backlog) { board.lists.backlog.first }
      let_it_be(:list1)   { create(:list, board: board, label: development, position: 0) }
      let_it_be(:list2)   { create(:list, board: board, label: testing, position: 1) }
      let_it_be(:closed)  { board.lists.closed.first }

      let_it_be(:opened_issue1) { create(:labeled_issue, project: project, milestone: m1, title: 'Issue 1', labels: [bug]) }
      let_it_be(:opened_issue2) { create(:labeled_issue, project: project, milestone: m2, title: 'Issue 2', labels: [p2]) }
      let_it_be(:reopened_issue1) { create(:issue, :opened, project: project, title: 'Reopened Issue 1') }

      let_it_be(:list1_issue1) { create(:labeled_issue, project: project, milestone: m1, labels: [p2, development]) }
      let_it_be(:list1_issue2) { create(:labeled_issue, project: project, milestone: m2, labels: [development]) }
      let_it_be(:list1_issue3) { create(:labeled_issue, project: project, milestone: m1, labels: [development, p1]) }
      let_it_be(:list2_issue1) { create(:labeled_issue, project: project, milestone: m1, labels: [testing]) }

      let_it_be(:closed_issue1) { create(:labeled_issue, :closed, project: project, labels: [bug], closed_at: 1.day.ago) }
      let_it_be(:closed_issue2) { create(:labeled_issue, :closed, project: project, labels: [p3], closed_at: 2.days.ago) }
      let_it_be(:closed_issue3) { create(:issue, :closed, project: project, closed_at: 1.week.ago) }
      let_it_be(:closed_issue4) { create(:labeled_issue, :closed, project: project, labels: [p1], closed_at: 1.year.ago) }
      let_it_be(:closed_issue5) { create(:labeled_issue, :closed, project: project, labels: [development], closed_at: 2.years.ago) }

      let(:parent) { project }

      before do
        project.add_developer(user)
      end

      it_behaves_like 'issues list service'

      context 'when project is archived' do
        before do
          project.update!(archived: true)
        end

        it_behaves_like 'issues list service'
      end

      context 'when filtering' do
        let_it_be(:incident) do
          create(
            :labeled_issue,
            :incident,
            project: project,
            milestone: m1,
            labels: [development, p1]
          )
        end

        context 'when filtering by type' do
          it 'only returns the specified type' do
            params = { board_id: board.id, id: list1.id, issue_types: 'incident' }

            expect(described_class.new(parent, user, params).execute).to eq [incident]
          end
        end

        context 'when filtering by negated type' do
          it 'only returns the specified type' do
            params = { board_id: board.id, id: list1.id, not: { issue_types: ['issue'] } }

            expect(described_class.new(parent, user, params).execute).to contain_exactly(incident)
          end
        end
      end
    end

    context 'when parent is a group' do
      let(:project) { create(:project, :empty_repo, namespace: group) }
      let(:project1) { create(:project, :empty_repo, namespace: group) }
      let(:project_archived) { create(:project, :empty_repo, :archived, namespace: group) }

      let(:m1) { create(:milestone, group: group) }
      let(:m2) { create(:milestone, group: group) }

      let(:bug) { create(:group_label, group: group, name: 'Bug') }
      let(:development) { create(:group_label, group: group, name: 'Development') }
      let(:testing) { create(:group_label, group: group, name: 'Testing') }

      let(:p1) { create(:group_label, title: 'P1', group: group) }
      let(:p2) { create(:group_label, title: 'P2', group: group) }
      let(:p3) { create(:group_label, title: 'P3', group: group) }

      let(:p1_project) { create(:label, title: 'P1_project', project: project, priority: 1) }
      let(:p2_project) { create(:label, title: 'P2_project', project: project, priority: 2) }
      let(:p3_project) { create(:label, title: 'P3_project', project: project, priority: 3) }

      let(:p1_project1) { create(:label, title: 'P1_project1', project: project1, priority: 1) }
      let(:p2_project1) { create(:label, title: 'P2_project1', project: project1, priority: 2) }
      let(:p3_project1) { create(:label, title: 'P3_project1', project: project1, priority: 3) }

      let!(:backlog) { board.lists.backlog.first }
      let!(:list1)   { create(:list, board: board, label: development, position: 0) }
      let!(:list2)   { create(:list, board: board, label: testing, position: 1) }
      let!(:closed)  { board.lists.closed.first }

      let!(:opened_issue1) { create(:labeled_issue, project: project, milestone: m1, title: 'Issue 1', labels: [bug]) }
      let!(:opened_issue2) { create(:labeled_issue, project: project, milestone: m2, title: 'Issue 2', labels: [p2, p2_project]) }
      let!(:opened_issue3) { create(:labeled_issue, project: project_archived, milestone: m1, title: 'Issue 3', labels: [bug]) }
      let!(:reopened_issue1) { create(:issue, state: 'opened', project: project, title: 'Reopened Issue 1', closed_at: Time.current) }

      let!(:list1_issue1) { create(:labeled_issue, project: project, milestone: m1, labels: [p2, p2_project, development]) }
      let!(:list1_issue2) { create(:labeled_issue, project: project, milestone: m2, labels: [development]) }
      let!(:list1_issue3) { create(:labeled_issue, project: project1, milestone: m1, labels: [development, p1, p1_project1]) }
      let!(:list2_issue1) { create(:labeled_issue, project: project1, milestone: m1, labels: [testing]) }

      let!(:closed_issue1) { create(:labeled_issue, :closed, project: project, labels: [bug], closed_at: 1.day.ago) }
      let!(:closed_issue2) { create(:labeled_issue, :closed, project: project, labels: [p3, p3_project], closed_at: 2.days.ago) }
      let!(:closed_issue3) { create(:issue, :closed, project: project1, closed_at: 1.week.ago) }
      let!(:closed_issue4) { create(:labeled_issue, :closed, project: project1, labels: [p1, p1_project1], closed_at: 1.year.ago) }
      let!(:closed_issue5) { create(:labeled_issue, :closed, project: project1, labels: [development], closed_at: 2.years.ago) }

      before do
        group.add_developer(user)
      end

      context 'when the group has no parent' do
        let(:parent) { group }
        let(:group) { create(:group) }
        let(:board) { create(:board, group: group) }

        it_behaves_like 'issues list service'
      end

      context 'when the group is an ancestor' do
        let(:parent) { create(:group) }
        let(:group) { create(:group, parent: parent) }
        let(:board) { create(:board, group: parent) }

        before do
          parent.add_developer(user)
        end

        it_behaves_like 'issues list service'
      end
    end
  end

  describe '.initialize_relative_positions' do
    let_it_be(:user) { create(:user) }
    let_it_be(:project) { create(:project, :empty_repo) }
    let_it_be(:board) { create(:board, project: project) }

    let(:issue) { create(:issue, project: project, relative_position: nil) }

    context ""when 'Gitlab::Database::read_write?' is true"" do
      before do
        allow(Gitlab::Database).to receive(:read_write?).and_return(true)
      end

      context 'user cannot move issues' do
        it 'does not initialize the relative positions of issues' do
          described_class.initialize_relative_positions(board, user, [issue])

          expect(issue.relative_position).to eq nil
        end
      end

      context 'user can move issues' do
        before do
          project.add_developer(user)
        end

        it 'initializes the relative positions of issues' do
          described_class.initialize_relative_positions(board, user, [issue])

          expect(issue.relative_position).not_to eq nil
        end
      end
    end

    context ""when 'Gitlab::Database::read_write?' is false"" do
      before do
        allow(Gitlab::Database).to receive(:read_write?).and_return(false)
      end

      it 'does not initialize the relative positions of issues' do
        described_class.initialize_relative_positions(board, user, [issue])

        expect(issue.relative_position).to eq nil
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Boards
  module Issues
    class CreateService < Boards::BaseService
      attr_accessor :project

      def initialize(parent, project, user, params = {})
        @project = project

        super(parent, user, params)
      end

      def execute
        create_issue(params.merge(issue_params))
      end

      private

      def issue_params
        { label_ids: [list.label_id] }
      end

      def board
        @board ||= parent.boards.find(params.delete(:board_id))
      end

      def list
        @list ||= board.lists.find(params.delete(:list_id))
      end

      def create_issue(params)
        # NOTE: We are intentionally not doing a spam/CAPTCHA check for issues created via boards.
        # See https://gitlab.com/gitlab-org/gitlab/-/issues/29400#note_598479184 for more context.
        ::Issues::CreateService.new(container: project, current_user: current_user, params: params, perform_spam_check: false).execute
      end
    end
  end
end

Boards::Issues::CreateService.prepend_mod_with('Boards::Issues::CreateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Boards::Issues::CreateService, feature_category: :team_planning do
  describe '#execute' do
    let(:project) { create(:project) }
    let(:board)   { create(:board, project: project) }
    let(:user)    { create(:user) }
    let(:label)   { create(:label, project: project, name: 'in-progress') }
    let!(:list)   { create(:list, board: board, label: label, position: 0) }

    subject(:service) { described_class.new(board.resource_parent, project, user, board_id: board.id, list_id: list.id, title: 'New issue') }

    before do
      project.add_developer(user)
    end

    it 'delegates the create proceedings to Issues::CreateService' do
      expect_next_instance_of(Issues::CreateService) do |instance|
        expect(instance).to receive(:execute).once
      end

      service.execute
    end

    it 'creates a new issue' do
      expect { service.execute }.to change(project.issues, :count).by(1)
    end

    it 'adds the label of the list to the issue' do
      result = service.execute

      expect(result).to be_success
      expect(result[:issue].labels).to contain_exactly(label)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Submodules
  class UpdateService < Commits::CreateService
    include Gitlab::Utils::StrongMemoize

    def initialize(*args)
      super

      @start_branch = @branch_name
      @commit_sha = params[:commit_sha].presence
      @submodule = params[:submodule].presence
      @commit_message = params[:commit_message].presence || ""Update submodule #{@submodule} with oid #{@commit_sha}""
    end

    def validate!
      super

      raise ValidationError, 'The repository is empty' if repository.empty?
    end

    def execute
      super
    rescue StandardError => e
      error(e.message)
    end

    def create_commit!
      repository.update_submodule(
        current_user,
        @submodule,
        @commit_sha,
        message: @commit_message,
        branch: @branch_name
      )
    rescue ArgumentError, TypeError
      raise ValidationError, 'Invalid parameters'
    end
  end
end

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Submodules::UpdateService, feature_category: :source_code_management do
  let(:project) { create(:project, :repository) }
  let(:repository) { project.repository }
  let(:user) { create(:user, :commit_email) }
  let(:branch_name) { project.default_branch }
  let(:submodule) { 'six' }
  let(:commit_sha) { 'e25eda1fece24ac7a03624ed1320f82396f35bd8' }
  let(:commit_message) { 'whatever' }
  let(:current_sha) { repository.blob_at('HEAD', submodule).id }
  let(:commit_params) do
    {
      submodule: submodule,
      commit_message: commit_message,
      commit_sha: commit_sha,
      branch_name: branch_name
    }
  end

  subject { described_class.new(project, user, commit_params) }

  describe ""#execute"" do
    shared_examples 'returns error result' do
      it do
        result = subject.execute

        expect(result[:status]).to eq :error
        expect(result[:message]).to eq error_message
      end
    end

    context 'when the user is not authorized' do
      it_behaves_like 'returns error result' do
        let(:error_message) { 'You are not allowed to push into this branch' }
      end
    end

    context 'when the user is authorized' do
      before do
        project.add_maintainer(user)
      end

      context 'when the branch is protected' do
        before do
          create(:protected_branch, :no_one_can_push, project: project, name: branch_name)
        end

        it_behaves_like 'returns error result' do
          let(:error_message) { 'You are not allowed to push into this branch' }
        end
      end

      context 'validations' do
        context 'when submodule' do
          context 'is empty' do
            let(:submodule) { '' }

            it_behaves_like 'returns error result' do
              let(:error_message) { 'Invalid parameters' }
            end
          end

          context 'is not present' do
            let(:submodule) { nil }

            it_behaves_like 'returns error result' do
              let(:error_message) { 'Invalid parameters' }
            end
          end

          context 'is invalid' do
            let(:submodule) { 'VERSION' }

            it_behaves_like 'returns error result' do
              let(:error_message) { 'Invalid submodule path' }
            end
          end

          context 'does not exist' do
            let(:submodule) { 'non-existent-submodule' }

            it_behaves_like 'returns error result' do
              let(:error_message) { 'Invalid submodule path' }
            end
          end

          # Can be re-enabled when problem from https://gitlab.com/gitlab-org/gitlab/-/issues/413964#note_1421909142
          # is fixed
          # context 'has traversal path' do
          #   let(:submodule) { '../six' }

          #   it_behaves_like 'returns error result' do
          #     let(:error_message) { 'Invalid submodule path' }
          #   end
          # end
        end

        context 'commit_sha' do
          context 'is empty' do
            let(:commit_sha) { '' }

            it_behaves_like 'returns error result' do
              let(:error_message) { 'Invalid parameters' }
            end
          end

          context 'is not present' do
            let(:commit_sha) { nil }

            it_behaves_like 'returns error result' do
              let(:error_message) { 'Invalid parameters' }
            end
          end

          context 'is invalid' do
            let(:commit_sha) { '1' }

            it_behaves_like 'returns error result' do
              let(:error_message) { 'Invalid parameters' }
            end
          end

          context 'is the same as the current ref' do
            let(:commit_sha) { current_sha }

            it_behaves_like 'returns error result' do
              let(:error_message) { ""The submodule #{submodule} is already at #{commit_sha}"" }
            end
          end
        end

        context 'branch_name' do
          context 'is empty' do
            let(:branch_name) { '' }

            it_behaves_like 'returns error result' do
              let(:error_message) { 'You can only create or edit files when you are on a branch' }
            end
          end

          context 'is not present' do
            let(:branch_name) { nil }

            it_behaves_like 'returns error result' do
              let(:error_message) { 'Invalid parameters' }
            end
          end

          context 'does not exist' do
            let(:branch_name) { 'non/existent-branch' }

            it_behaves_like 'returns error result' do
              let(:error_message) { 'You can only create or edit files when you are on a branch' }
            end
          end

          context 'when commit message is empty' do
            let(:commit_message) { '' }

            it 'a default commit message is set' do
              message = ""Update submodule #{submodule} with oid #{commit_sha}""

              expect(repository).to receive(:update_submodule).with(any_args, hash_including(message: message))

              subject.execute
            end
          end
        end
      end

      context 'when there is an unexpected error' do
        before do
          allow(repository).to receive(:update_submodule).and_raise(StandardError, 'error message')
        end

        it_behaves_like 'returns error result' do
          let(:error_message) { 'error message' }
        end
      end

      it 'updates the submodule reference' do
        result = subject.execute

        expect(result[:status]).to eq :success
        expect(result[:result]).to eq repository.head_commit.id
        expect(repository.blob_at('HEAD', submodule).id).to eq commit_sha
      end

      context 'when submodule is inside a directory' do
        let(:submodule) { 'test_inside_folder/another_folder/six' }
        let(:branch_name) { 'submodule_inside_folder' }

        it 'updates the submodule reference' do
          expect(repository.blob_at(branch_name, submodule).id).not_to eq commit_sha

          subject.execute

          expect(repository.blob_at(branch_name, submodule).id).to eq commit_sha
        end
      end

      context 'when repository is empty' do
        let(:project) { create(:project, :empty_repo) }
        let(:branch_name) { 'master' }

        it_behaves_like 'returns error result' do
          let(:error_message) { 'The repository is empty' }
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# This service copies AwardEmoji from one Awardable to another.
#
# It expects the calling code to have performed the necessary authorization
# checks in order to allow the copy to happen.
module AwardEmojis
  class CopyService
    def initialize(from_awardable, to_awardable)
      raise ArgumentError, 'Awardables must be different' if from_awardable == to_awardable

      @from_awardable = from_awardable
      @to_awardable = to_awardable
    end

    def execute
      from_awardable.award_emoji.find_each do |award|
        new_award = award.dup
        new_award.awardable = to_awardable
        new_award.save!
      end

      ServiceResponse.success
    end

    private

    attr_accessor :from_awardable, :to_awardable
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe AwardEmojis::CopyService, feature_category: :team_planning do
  let_it_be(:from_awardable) do
    create(
      :issue,
      award_emoji: [
        build(:award_emoji, name: 'thumbsup'),
        build(:award_emoji, name: 'thumbsdown')
      ])
  end

  describe '#initialize' do
    it 'validates that we cannot copy AwardEmoji to the same Awardable' do
      expect { described_class.new(from_awardable, from_awardable) }.to raise_error(ArgumentError)
    end
  end

  describe '#execute' do
    let(:to_awardable) { create(:issue) }

    subject(:execute_service) { described_class.new(from_awardable, to_awardable).execute }

    it 'copies AwardEmojis', :aggregate_failures do
      expect { execute_service }.to change { AwardEmoji.count }.by(2)
      expect(to_awardable.award_emoji.map(&:name)).to match_array(%w[thumbsup thumbsdown])
    end

    it 'returns success', :aggregate_failures do
      expect(execute_service).to be_kind_of(ServiceResponse)
      expect(execute_service).to be_success
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Class for retrieving information about emoji awarded _by_ a particular user.
module AwardEmojis
  class CollectUserEmojiService
    attr_reader :current_user

    # current_user - The User to generate the data for.
    def initialize(current_user = nil)
      @current_user = current_user
    end

    def execute
      return [] unless current_user

      # We want the resulting data set to be an Array containing the emoji names
      # in descending order, based on how often they were awarded.
      AwardEmoji
        .award_counts_for_user(current_user)
        .map { |name, _| { name: name } }
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe AwardEmojis::CollectUserEmojiService, feature_category: :team_planning do
  describe '#execute' do
    it 'returns an Array containing the awarded emoji names' do
      user = create(:user)

      create(:award_emoji, user: user, name: 'thumbsup')
      create(:award_emoji, user: user, name: 'thumbsup')
      create(:award_emoji, user: user, name: 'thumbsdown')

      awarded = described_class.new(user).execute

      expect(awarded).to eq([{ name: 'thumbsup' }, { name: 'thumbsdown' }])
    end

    it 'returns an empty Array when no user is given' do
      awarded = described_class.new.execute

      expect(awarded).to be_empty
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module AwardEmojis
  class AddService < AwardEmojis::BaseService
    include Gitlab::Utils::StrongMemoize

    def execute
      unless awardable.user_can_award?(current_user)
        return error('User cannot add emoji reactions to awardable', status: :forbidden)
      end

      unless awardable.emoji_awardable?
        return error('Awardable cannot add emoji reactions', status: :unprocessable_entity)
      end

      award = awardable.award_emoji.create(name: name, user: current_user)

      if award.persisted?
        after_create(award)
        success(award: award)
      else
        error(award.errors.full_messages, award: award)
      end
    end

    private

    def after_create(award)
      TodoService.new.new_award_emoji(todoable, current_user) if todoable

      execute_hooks(award, 'award')
    end

    def todoable
      strong_memoize(:todoable) do
        case awardable
        when Note
          # We don't create todos for personal snippet comments for now
          awardable.noteable unless awardable.for_personal_snippet?
        when MergeRequest, Issue
          awardable
        else
          # No todos for all other awardables
          nil
        end
      end
    end
  end
end

AwardEmojis::AddService.prepend_mod_with('AwardEmojis::AddService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe AwardEmojis::AddService, feature_category: :team_planning do
  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project) }
  let_it_be(:awardable) { create(:note, project: project) }

  let(:name) { 'thumbsup' }

  subject(:service) { described_class.new(awardable, name, user) }

  describe '#execute' do
    context 'when user is not authorized' do
      it 'does not add an emoji' do
        expect { service.execute }.not_to change { AwardEmoji.count }
      end

      it 'returns an error state' do
        result = service.execute

        expect(result[:status]).to eq(:error)
        expect(result[:http_status]).to eq(:forbidden)
      end
    end

    context 'when user is authorized' do
      before do
        project.add_developer(user)
      end

      it 'creates an award emoji' do
        expect { service.execute }.to change { AwardEmoji.count }.by(1)
      end

      it 'returns the award emoji' do
        result = service.execute

        expect(result[:award]).to be_kind_of(AwardEmoji)
      end

      it 'return a success status' do
        result = service.execute

        expect(result[:status]).to eq(:success)
      end

      it 'sets the correct properties on the award emoji' do
        award = service.execute[:award]

        expect(award.name).to eq(name)
        expect(award.user).to eq(user)
      end

      it 'executes hooks' do
        expect(service).to receive(:execute_hooks).with(kind_of(AwardEmoji), 'award')

        service.execute
      end

      describe 'marking Todos as done' do
        subject { service.execute }

        include_examples 'creating award emojis marks Todos as done'
      end

      context 'when the awardable cannot have emoji awarded to it' do
        before do
          expect(awardable).to receive(:emoji_awardable?).and_return(false)
        end

        it 'does not add an emoji' do
          expect { service.execute }.not_to change { AwardEmoji.count }
        end

        it 'returns an error status' do
          result = service.execute

          expect(result[:status]).to eq(:error)
          expect(result[:http_status]).to eq(:unprocessable_entity)
        end
      end

      context 'when the awardable is invalid' do
        before do
          expect_next_instance_of(AwardEmoji) do |award|
            expect(award).to receive(:valid?).and_return(false)
            expect(award).to receive_message_chain(:errors, :full_messages).and_return(['Error 1', 'Error 2'])
          end
        end

        it 'does not add an emoji' do
          expect { service.execute }.not_to change { AwardEmoji.count }
        end

        it 'returns an error status' do
          result = service.execute

          expect(result[:status]).to eq(:error)
        end

        it 'returns an error message' do
          result = service.execute

          expect(result[:message]).to eq('Error 1 and Error 2')
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module AwardEmojis
  class BaseService < ::BaseService
    attr_accessor :awardable, :name

    def initialize(awardable, name, current_user)
      @awardable = awardable
      @name = normalize_name(name)

      super(awardable.project, current_user)
    end

    def execute_hooks(award_emoji, action)
      return unless awardable.project&.has_active_hooks?(:emoji_hooks)

      hook_data = Gitlab::DataBuilder::Emoji.build(award_emoji, current_user, action)
      awardable.project.execute_hooks(hook_data, :emoji_hooks)
    end

    private

    def normalize_name(name)
      TanukiEmoji.find_by_alpha_code(name)&.name || name
    end

    # Provide more error state data than what BaseService allows.
    # - An array of errors
    # - The `AwardEmoji` if present
    def error(errors, award: nil, status: nil)
      errors = Array.wrap(errors)

      super(errors.to_sentence.presence, status).merge({
        award: award,
        errors: errors
      })
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe AwardEmojis::BaseService, feature_category: :team_planning do
  let_it_be(:group) { create(:group) }
  let_it_be(:project) { create(:project, group: group) }
  let_it_be(:current_user) { create(:user) }
  let_it_be_with_reload(:awardable) { create(:note, project: project) }

  let(:emoji_name) { 'horse' }

  describe '.initialize' do
    subject { described_class }

    it 'uses same emoji name if not an alias' do
      expect(subject.new(awardable, emoji_name, current_user).name).to eq(emoji_name)
    end

    it 'uses emoji original name if its an alias' do
      emoji_alias = 'small_airplane'
      emoji_name = 'airplane_small'

      expect(subject.new(awardable, emoji_alias, current_user).name).to eq(emoji_name)
    end
  end

  describe '.execute_hooks' do
    let(:award_emoji) { create(:award_emoji, awardable: awardable) }
    let(:action) { 'award' }

    subject { described_class.new(awardable, emoji_name, current_user) }

    context 'with no emoji hooks configured' do
      it 'does not build hook_data' do
        expect(Gitlab::DataBuilder::Emoji).not_to receive(:build)
        expect(award_emoji.awardable.project).not_to receive(:execute_hooks)

        subject.execute_hooks(award_emoji, action)
      end
    end

    context 'with emoji hooks configured' do
      it 'builds hook_data and calls execute_hooks for project' do
        hook_data = {}
        create(:project_hook, project: project, emoji_events: true)
        expect(Gitlab::DataBuilder::Emoji).to receive(:build).and_return(hook_data)
        expect(award_emoji.awardable.project).to receive(:execute_hooks).with(hook_data, :emoji_hooks)

        subject.execute_hooks(award_emoji, action)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module AwardEmojis
  class DestroyService < AwardEmojis::BaseService
    def execute
      unless awardable.user_can_award?(current_user)
        return error('User cannot destroy emoji on the awardable', status: :forbidden)
      end

      awards = AwardEmojisFinder.new(awardable, name: name, awarded_by: current_user).execute

      if awards.empty?
        return error(""User has not awarded emoji of type #{name} on the awardable"", status: :forbidden)
      end

      award = awards.destroy_all.first # rubocop: disable Cop/DestroyAll
      after_destroy(award)

      success(award: award)
    end

    private

    def after_destroy(award)
      execute_hooks(award, 'revoke')
    end
  end
end

AwardEmojis::DestroyService.prepend_mod_with('AwardEmojis::DestroyService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe AwardEmojis::DestroyService, feature_category: :team_planning do
  let_it_be(:user) { create(:user) }
  let_it_be(:awardable) { create(:note) }
  let_it_be(:project) { awardable.project }

  let(:name) { 'thumbsup' }
  let!(:award_from_other_user) do
    create(:award_emoji, name: name, awardable: awardable, user: create(:user))
  end

  subject(:service) { described_class.new(awardable, name, user) }

  describe '#execute' do
    shared_examples_for 'a service that does not authorize the user' do |error:|
      it 'does not remove the emoji' do
        expect { service.execute }.not_to change { AwardEmoji.count }
      end

      it 'returns an error state' do
        result = service.execute

        expect(result[:status]).to eq(:error)
        expect(result[:http_status]).to eq(:forbidden)
      end

      it 'returns a nil award' do
        result = service.execute

        expect(result).to have_key(:award)
        expect(result[:award]).to be_nil
      end

      it 'returns the error' do
        result = service.execute

        expect(result[:message]).to eq(error)
        expect(result[:errors]).to eq([error])
      end
    end

    context 'when user is not authorized' do
      it_behaves_like 'a service that does not authorize the user',
        error: 'User cannot destroy emoji on the awardable'
    end

    context 'when the user is authorized' do
      before do
        project.add_developer(user)
      end

      context 'when user has not awarded an emoji to the awardable' do
        let!(:award_from_user) { create(:award_emoji, name: name, user: user) }

        it_behaves_like 'a service that does not authorize the user',
          error: 'User has not awarded emoji of type thumbsup on the awardable'
      end

      context 'when user has awarded an emoji to the awardable' do
        let!(:award_from_user) { create(:award_emoji, name: name, awardable: awardable, user: user) }

        it 'removes the emoji' do
          expect { service.execute }.to change { AwardEmoji.count }.by(-1)
        end

        it 'returns a success status' do
          result = service.execute

          expect(result[:status]).to eq(:success)
        end

        it 'returns no errors' do
          result = service.execute

          expect(result).not_to have_key(:error)
          expect(result).not_to have_key(:errors)
        end

        it 'returns the destroyed award' do
          result = service.execute

          expect(result[:award]).to eq(award_from_user)
          expect(result[:award]).to be_destroyed
        end

        it 'executes hooks' do
          expect(service).to receive(:execute_hooks).with(award_from_user, 'revoke')

          service.execute
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module AwardEmojis
  class ToggleService < AwardEmojis::BaseService
    def execute
      if awardable.awarded_emoji?(name, current_user)
        DestroyService.new(awardable, name, current_user).execute
      else
        AddService.new(awardable, name, current_user).execute
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe AwardEmojis::ToggleService, feature_category: :team_planning do
  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project, :public) }
  let_it_be(:awardable) { create(:note, project: project) }

  let(:name) { 'thumbsup' }

  subject(:service) { described_class.new(awardable, name, user) }

  describe '#execute' do
    context 'when user has awarded an emoji' do
      let!(:award_from_other_user) { create(:award_emoji, name: name, awardable: awardable, user: create(:user)) }
      let!(:award) { create(:award_emoji, name: name, awardable: awardable, user: user) }

      it 'calls AwardEmojis::DestroyService' do
        expect(AwardEmojis::AddService).not_to receive(:new)

        expect_next_instance_of(AwardEmojis::DestroyService) do |service|
          expect(service).to receive(:execute)
        end

        service.execute
      end

      it 'destroys an AwardEmoji' do
        expect { service.execute }.to change { AwardEmoji.count }.by(-1)
      end

      it 'returns the result of DestroyService#execute' do
        mock_result = double(foo: true)

        expect_next_instance_of(AwardEmojis::DestroyService) do |service|
          expect(service).to receive(:execute).and_return(mock_result)
        end

        result = service.execute

        expect(result).to eq(mock_result)
      end
    end

    context 'when user has not awarded an emoji' do
      it 'calls AwardEmojis::AddService' do
        expect_next_instance_of(AwardEmojis::AddService) do |service|
          expect(service).to receive(:execute)
        end

        expect(AwardEmojis::DestroyService).not_to receive(:new)

        service.execute
      end

      it 'creates an AwardEmoji' do
        expect { service.execute }.to change { AwardEmoji.count }.by(1)
      end

      it 'returns the result of AddService#execute' do
        mock_result = double(foo: true)

        expect_next_instance_of(AwardEmojis::AddService) do |service|
          expect(service).to receive(:execute).and_return(mock_result)
        end

        result = service.execute

        expect(result).to eq(mock_result)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module VsCode
  module Settings
    class CreateOrUpdateService
      def initialize(current_user:, params: {})
        @current_user = current_user
        @params = params
      end

      def execute
        # The GitLab VSCode settings API does not support creating or updating
        # machines.
        return ServiceResponse.success(payload: DEFAULT_MACHINE) if @params[:setting_type] == 'machines'

        setting = VsCodeSetting.by_user(current_user).by_setting_type(params[:setting_type]).first

        if setting.nil?
          merged_params = params.merge(user: current_user, uuid: SecureRandom.uuid)
          setting = VsCodeSetting.new(merged_params)
        else
          setting.content = params[:content]
          setting.uuid = SecureRandom.uuid
        end

        if setting.save
          ServiceResponse.success(payload: setting)
        else
          ServiceResponse.error(
            message: setting.errors.full_messages.to_sentence,
            payload: { setting: setting }
          )
        end
      end

      private

      attr_reader :current_user, :params
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe VsCode::Settings::CreateOrUpdateService, feature_category: :web_ide do
  describe '#execute' do
    let_it_be(:user) { create(:user) }

    let(:opts) do
      {
        setting_type: ""settings"",
        content: '{ ""editor.fontSize"": 12 }'
      }
    end

    subject { described_class.new(current_user: user, params: opts).execute }

    context 'when setting_type is machines' do
      it 'returns default machine as a successful response' do
        opts = { setting_type: ""machines"", machines: '[]' }
        result = described_class.new(current_user: user, params: opts).execute

        expect(result.payload).to eq(VsCode::Settings::DEFAULT_MACHINE)
      end
    end

    it 'creates a new record when a record with the setting does not exist' do
      expect { subject }.to change { User.find(user.id).vscode_settings.count }.from(0).to(1)
      record = User.find(user.id).vscode_settings.by_setting_type('settings').first
      expect(record.content).to eq('{ ""editor.fontSize"": 12 }')
    end

    it 'updates the existing record if setting exists' do
      setting = create(:vscode_setting, user: user)

      expect { subject }.to change {
        VsCode::Settings::VsCodeSetting.find(setting.id).content
      }.from(setting.content).to(opts[:content])
    end

    it 'fails if an invalid value is passed' do
      invalid_opts = { setting_type: nil, content: nil }
      result = described_class.new(current_user: user, params: invalid_opts).execute

      expect(result.status).to eq(:error)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module VsCode
  module Settings
    class DeleteService
      def initialize(current_user:)
        @current_user = current_user
      end

      def execute
        VsCodeSetting.by_user(current_user).delete_all

        ServiceResponse.success
      end

      private

      attr_reader :current_user
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe VsCode::Settings::DeleteService, feature_category: :web_ide do
  describe '#execute' do
    let_it_be(:user) { create(:user) }
    let_it_be(:other_user) { create(:user) }
    let_it_be(:setting_one) { create(:vscode_setting, user: user) }
    let_it_be(:setting_two) { create(:vscode_setting, setting_type: 'extensions', user: user) }
    let_it_be(:setting_three) { create(:vscode_setting, setting_type: 'extensions', user: other_user) }

    subject { described_class.new(current_user: user).execute }

    it 'deletes all vscode_settings belonging to the current user' do
      expect { subject }
        .to change { User.find(user.id).vscode_settings.count }.from(2).to(0)
        .and not_change { User.find(other_user.id).vscode_settings.count }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Milestones
  class FindOrCreateService
    attr_accessor :project, :current_user, :params

    def initialize(project, user, params = {})
      @project = project
      @current_user = user
      @params = params.dup
    end

    def execute
      find_milestone || create_milestone
    end

    private

    # rubocop: disable CodeReuse/ActiveRecord
    def find_milestone
      groups = project.group&.self_and_ancestors_ids
      Milestone.for_projects_and_groups([project.id], groups).find_by(title: params[""title""])
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def create_milestone
      return unless current_user.can?(:admin_milestone, project)

      new_milestone if new_milestone.persisted?
    end

    def new_milestone
      @new_milestone ||= CreateService.new(project, current_user, params).execute
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Milestones::FindOrCreateService, feature_category: :team_planning do
  describe '#execute' do
    subject(:service) { described_class.new(project, user, params) }

    let(:user)    { create(:user) }
    let(:group)   { create(:group) }
    let(:project) { create(:project, namespace: group) }
    let(:params) do
      {
        title: '1.0',
        description: 'First Release',
        start_date: Date.today,
        due_date: Date.today + 1.month
      }.with_indifferent_access
    end

    context 'when finding milestone on project level' do
      let!(:existing_project_milestone) { create(:milestone, project: project, title: '1.0') }

      it 'returns existing milestone' do
        expect(service.execute).to eq(existing_project_milestone)
      end
    end

    context 'when finding milestone on group level' do
      let!(:existing_group_milestone) { create(:milestone, group: group, title: '1.0') }

      it 'returns existing milestone' do
        expect(service.execute).to eq(existing_group_milestone)
      end
    end

    context 'when not finding milestone' do
      context 'when user has permissions' do
        before do
          project.add_developer(user)
        end

        context 'when params are valid' do
          it 'creates a new milestone at project level using params' do
            expect { service.execute }.to change(project.milestones, :count).by(1)

            milestone = project.reload.milestones.last

            expect(milestone.title).to eq(params[:title])
            expect(milestone.description).to eq(params[:description])
            expect(milestone.start_date).to eq(params[:start_date])
            expect(milestone.due_date).to eq(params[:due_date])
          end
        end

        context 'when params are not valid' do
          before do
            params[:start_date] = Date.today + 2.months
          end

          it 'returns nil' do
            expect(service.execute).to be_nil
          end
        end
      end

      context 'when user does not have permissions' do
        before do
          project.add_guest(user)
        end

        it 'does not create a new milestone' do
          expect { service.execute }.not_to change(project.milestones, :count)
        end

        it 'returns nil' do
          expect(service.execute).to be_nil
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Milestones
  class MergeRequestsCountService < BaseCountService
    def initialize(milestone)
      @milestone = milestone
    end

    def cache_key
      ""milestone_merge_requests_count_#{@milestone.milestoneish_id}""
    end

    def relation_for_count
      @milestone.merge_requests
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Milestones::MergeRequestsCountService, :use_clean_rails_memory_store_caching,
  feature_category: :team_planning do
  let_it_be(:project) { create(:project, :empty_repo) }
  let_it_be(:milestone) { create(:milestone, project: project) }

  before_all do
    create(:merge_request, milestone: milestone, source_project: project)
    create(:merge_request, :closed, milestone: milestone, source_project: project)
  end

  subject { described_class.new(milestone) }

  it_behaves_like 'a counter caching service'

  it 'counts all merge requests' do
    expect(subject.count).to eq(2)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Milestones
  class ClosedIssuesCountService < BaseCountService
    def initialize(milestone)
      @milestone = milestone
    end

    def cache_key
      ""milestone_closed_issues_count_#{@milestone.milestoneish_id}""
    end

    def relation_for_count
      @milestone.issues.closed
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Milestones::ClosedIssuesCountService, :use_clean_rails_memory_store_caching,
  feature_category: :team_planning do
  let(:project) { create(:project) }
  let(:milestone) { create(:milestone, project: project) }

  before do
    create(:issue, milestone: milestone, project: project)
    create(:issue, :confidential, milestone: milestone, project: project)

    create(:issue, :closed, milestone: milestone, project: project)
    create(:issue, :closed, :confidential, milestone: milestone, project: project)
  end

  subject { described_class.new(milestone) }

  it_behaves_like 'a counter caching service'

  it 'counts closed issues including confidential' do
    expect(subject.count).to eq(2)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Milestones
  class PromoteService < Milestones::BaseService
    PromoteMilestoneError = Class.new(StandardError)

    def execute(milestone)
      check_project_milestone!(milestone)

      Milestone.transaction do
        group_milestone = clone_project_milestone(milestone)

        move_children_to_group_milestone(group_milestone)

        # Destroy all milestones with same title across projects
        destroy_old_milestones(milestone)

        # Rollback if milestone is not valid
        unless group_milestone.valid?
          raise_error(group_milestone.errors.full_messages.to_sentence)
        end

        group_milestone
      end
    end

    private

    def milestone_ids_for_merge(group_milestone)
      # Pluck need to be used here instead of select so the array of ids
      # is persistent after old milestones gets deleted.
      @milestone_ids_for_merge ||= begin
        search_params = { title: group_milestone.title, project_ids: group_project_ids, state: 'all' }
        milestones = MilestonesFinder.new(search_params).execute
        milestones.pluck_primary_key
      end
    end

    def move_children_to_group_milestone(group_milestone)
      milestone_ids_for_merge(group_milestone).in_groups_of(100, false) do |milestone_ids|
        update_children(group_milestone, milestone_ids)
      end
    end

    def check_project_milestone!(milestone)
      raise_error(s_('PromoteMilestone|Only project milestones can be promoted.')) unless milestone.project_milestone?
    end

    def clone_project_milestone(milestone)
      params = milestone.slice(:title, :description, :start_date, :due_date, :state_event)

      create_service = CreateService.new(group, current_user, params)

      milestone = create_service.execute

      # milestone won't be valid here because of duplicated title
      milestone.save(validate: false)

      milestone
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def update_children(group_milestone, milestone_ids)
      issues = Issue.where(project_id: group_project_ids, milestone_id: milestone_ids)
      merge_requests = MergeRequest.where(source_project_id: group_project_ids, milestone_id: milestone_ids)

      [issues, merge_requests].each do |issuable_collection|
        issuable_collection.update_all(milestone_id: group_milestone.id)
      end
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def group
      @group ||= parent.group || raise_error(s_('PromoteMilestone|Project does not belong to a group.'))
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def destroy_old_milestones(milestone)
      Milestone.where(id: milestone_ids_for_merge(milestone)).destroy_all # rubocop: disable Cop/DestroyAll
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def group_project_ids
      group.projects.select(:id)
    end

    def raise_error(message)
      raise PromoteMilestoneError, s_(""PromoteMilestone|Promotion failed - %{message}"") % { message: message }
    end
  end
end

Milestones::PromoteService.prepend_mod_with('Milestones::PromoteService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Milestones::PromoteService, feature_category: :team_planning do
  let(:group) { create(:group) }
  let(:project) { create(:project, namespace: group) }
  let(:user) { create(:user) }
  let(:milestone_title) { 'project milestone' }
  let(:milestone) { create(:milestone, project: project, title: milestone_title) }
  let(:service) { described_class.new(project, user) }

  describe '#execute' do
    before do
      group.add_maintainer(user)
    end

    context 'validations' do
      it 'raises error if milestone does not belong to a project' do
        allow(milestone).to receive(:project_milestone?).and_return(false)

        expect { service.execute(milestone) }.to raise_error(described_class::PromoteMilestoneError)
      end

      it 'raises error if project does not belong to a group' do
        project.update!(namespace: user.namespace)

        expect { service.execute(milestone) }.to raise_error(described_class::PromoteMilestoneError)
      end

      it 'does not promote milestone and update issuables if promoted milestone is not valid' do
        issue = create(:issue, milestone: milestone, project: project)
        merge_request = create(:merge_request, milestone: milestone, source_project: project)
        allow_next_instance_of(Milestone) do |instance|
          allow(instance).to receive(:valid?).and_return(false)
        end

        expect { service.execute(milestone) }.to raise_error(described_class::PromoteMilestoneError)

        expect(milestone.reload).to be_persisted
        expect(issue.reload.milestone).to eq(milestone)
        expect(merge_request.reload.milestone).to eq(milestone)
      end
    end

    context 'without duplicated milestone titles across projects' do
      it 'promotes project milestone to group milestone' do
        promoted_milestone = service.execute(milestone)

        expect(promoted_milestone).to be_group_milestone
      end

      it 'does not update issuables without milestone with the new promoted milestone' do
        issue_without_milestone = create(:issue, project: project, milestone: nil)
        merge_request_without_milestone = create(:merge_request, milestone: nil, source_project: project)

        service.execute(milestone)

        expect(issue_without_milestone.reload.milestone).to be_nil
        expect(merge_request_without_milestone.reload.milestone).to be_nil
      end

      it 'sets issuables with new promoted milestone' do
        issue = create(:issue, milestone: milestone, project: project)
        merge_request = create(:merge_request, milestone: milestone, source_project: project)

        promoted_milestone = service.execute(milestone)

        expect(promoted_milestone).to be_group_milestone
        expect(issue.reload.milestone).to eq(promoted_milestone)
        expect(merge_request.reload.milestone).to eq(promoted_milestone)
      end
    end

    context 'with duplicated milestone titles across projects' do
      let(:project_2) { create(:project, namespace: group) }
      let!(:milestone_2) { create(:milestone, project: project_2, title: milestone_title) }

      it 'deletes project milestones with the same title' do
        promoted_milestone = service.execute(milestone)

        expect(promoted_milestone).to be_group_milestone
        expect(promoted_milestone).to be_valid
        expect(Milestone.exists?(milestone.id)).to be_falsy
        expect(Milestone.exists?(milestone_2.id)).to be_falsy
      end

      it 'does not update issuables without milestone with the new promoted milestone' do
        issue_without_milestone_1 = create(:issue, project: project, milestone: nil)
        issue_without_milestone_2 = create(:issue, project: project_2, milestone: nil)
        merge_request_without_milestone_1 = create(:merge_request, milestone: nil, source_project: project)
        merge_request_without_milestone_2 = create(:merge_request, milestone: nil, source_project: project_2)

        service.execute(milestone)

        expect(issue_without_milestone_1.reload.milestone).to be_nil
        expect(issue_without_milestone_2.reload.milestone).to be_nil
        expect(merge_request_without_milestone_1.reload.milestone).to be_nil
        expect(merge_request_without_milestone_2.reload.milestone).to be_nil
      end

      it 'sets all issuables with new promoted milestone' do
        issue = create(:issue, milestone: milestone, project: project)
        issue_2 = create(:issue, milestone: milestone_2, project: project_2)
        merge_request = create(:merge_request, milestone: milestone, source_project: project)
        merge_request_2 = create(:merge_request, milestone: milestone_2, source_project: project_2)

        promoted_milestone = service.execute(milestone)

        expect(issue.reload.milestone).to eq(promoted_milestone)
        expect(issue_2.reload.milestone).to eq(promoted_milestone)
        expect(merge_request.reload.milestone).to eq(promoted_milestone)
        expect(merge_request_2.reload.milestone).to eq(promoted_milestone)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Milestones
  class IssuesCountService < BaseCountService
    def initialize(milestone)
      @milestone = milestone
    end

    def cache_key
      ""milestone_total_issues_count_#{@milestone.milestoneish_id}""
    end

    def relation_for_count
      @milestone.issues
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Milestones::IssuesCountService, :use_clean_rails_memory_store_caching,
  feature_category: :team_planning do
  let(:project) { create(:project) }
  let(:milestone) { create(:milestone, project: project) }

  before do
    create(:issue, milestone: milestone, project: project)
    create(:issue, :confidential, milestone: milestone, project: project)

    create(:issue, :closed, milestone: milestone, project: project)
    create(:issue, :closed, milestone: milestone, project: project)
  end

  subject { described_class.new(milestone) }

  it_behaves_like 'a counter caching service'

  it 'counts all issues including confidential' do
    expect(subject.count).to eq(4)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Milestones::TransferService class
#
# Used for recreating the missing group milestones at project level when
# transferring a project to a new namespace
#
module Milestones
  class TransferService
    attr_reader :current_user, :old_group, :project

    def initialize(current_user, old_group, project)
      @current_user = current_user
      @old_group = old_group
      @project = project
    end

    def execute
      return unless old_group.present?

      Milestone.transaction do
        milestones_to_transfer.find_each do |milestone|
          new_milestone = find_or_create_milestone(milestone)

          update_issues_milestone(milestone, new_milestone)
          update_merge_requests_milestone(milestone.id, new_milestone&.id)

          delete_milestone_counts_caches(milestone)
          delete_milestone_counts_caches(new_milestone)
        end
      end
    end

    private

    # rubocop: disable CodeReuse/ActiveRecord
    def milestones_to_transfer
      Milestone.from_union([group_milestones_applied_to_issues, group_milestones_applied_to_merge_requests])
        .reorder(nil)
        .distinct
    end
    # rubocop: enable CodeReuse/ActiveRecord

    # rubocop: disable CodeReuse/ActiveRecord
    def group_milestones_applied_to_issues
      Milestone.joins(:issues)
        .where(
          issues: { project_id: project.id },
          group_id: old_group.self_and_ancestors
        )
    end
    # rubocop: enable CodeReuse/ActiveRecord

    # rubocop: disable CodeReuse/ActiveRecord
    def group_milestones_applied_to_merge_requests
      Milestone.joins(:merge_requests)
        .where(
          merge_requests: { target_project_id: project.id },
          group_id: old_group.self_and_ancestors
        )
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def find_or_create_milestone(milestone)
      params = milestone.attributes.slice('title', 'description', 'start_date', 'due_date', 'state')

      FindOrCreateService.new(project, current_user, params).execute
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def update_issues_milestone(old_milestone, new_milestone)
      Issue.where(project: project, milestone_id: old_milestone.id)
        .update_all(milestone_id: new_milestone&.id)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    # rubocop: disable CodeReuse/ActiveRecord
    def update_merge_requests_milestone(old_milestone_id, new_milestone_id)
      MergeRequest.where(project: project, milestone_id: old_milestone_id)
        .update_all(milestone_id: new_milestone_id)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def delete_milestone_counts_caches(milestone)
      return unless milestone

      Milestones::IssuesCountService.new(milestone).delete_cache
      Milestones::ClosedIssuesCountService.new(milestone).delete_cache
      Milestones::MergeRequestsCountService.new(milestone).delete_cache
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Milestones::TransferService, feature_category: :team_planning do
  describe '#execute' do
    subject(:service) { described_class.new(user, old_group, project) }

    context 'when old_group is present' do
      let(:user) { create(:admin) }
      let(:new_group) { create(:group) }
      let(:old_group) { create(:group) }
      let(:project) { create(:project, namespace: old_group) }
      let(:group_milestone) { create(:milestone, :closed, group: old_group) }
      let(:group_milestone2) { create(:milestone, group: old_group) }
      let(:project_milestone) { create(:milestone, project: project) }
      let!(:issue_with_group_milestone) { create(:issue, project: project, milestone: group_milestone) }
      let!(:issue_with_project_milestone) { create(:issue, project: project, milestone: project_milestone) }
      let!(:mr_with_group_milestone) { create(:merge_request, source_project: project, source_branch: 'branch-1', milestone: group_milestone) }
      let!(:mr_with_project_milestone) { create(:merge_request, source_project: project, source_branch: 'branch-2', milestone: project_milestone) }

      before do
        new_group.add_maintainer(user)
        project.add_maintainer(user)
        # simulate project transfer
        project.update!(group: new_group)
      end

      context 'without existing milestone at the new group level' do
        it 'recreates the missing group milestones at project level' do
          expect { service.execute }.to change(project.milestones, :count).by(1)
        end

        it 'applies new project milestone to issues with group milestone' do
          service.execute
          new_milestone = issue_with_group_milestone.reload.milestone

          expect(new_milestone).not_to eq(group_milestone)
          expect(new_milestone.title).to eq(group_milestone.title)
          expect(new_milestone.project_milestone?).to be_truthy
          expect(new_milestone.state).to eq(""closed"")
        end

        context 'when milestone is from an ancestor group' do
          let(:old_group_ancestor) { create(:group) }
          let(:old_group) { create(:group, parent: old_group_ancestor) }
          let(:group_milestone) { create(:milestone, group: old_group_ancestor) }

          it 'recreates the missing group milestones at project level' do
            expect { service.execute }.to change(project.milestones, :count).by(1)
          end
        end

        it 'deletes milestone counters cache for both milestones' do
          new_milestone = create(:milestone, project: project, title: group_milestone.title)

          expect_next_instance_of(Milestones::IssuesCountService, group_milestone) do |service|
            expect(service).to receive(:delete_cache).and_call_original
          end
          expect_next_instance_of(Milestones::ClosedIssuesCountService, group_milestone) do |service|
            expect(service).to receive(:delete_cache).and_call_original
          end
          expect_next_instance_of(Milestones::MergeRequestsCountService, group_milestone) do |service|
            expect(service).to receive(:delete_cache).and_call_original
          end
          expect_next_instance_of(Milestones::IssuesCountService, new_milestone) do |service|
            expect(service).to receive(:delete_cache).and_call_original
          end
          expect_next_instance_of(Milestones::ClosedIssuesCountService, new_milestone) do |service|
            expect(service).to receive(:delete_cache).and_call_original
          end
          expect_next_instance_of(Milestones::MergeRequestsCountService, new_milestone) do |service|
            expect(service).to receive(:delete_cache).and_call_original
          end

          service.execute
        end

        it 'does not apply new project milestone to issues with project milestone' do
          service.execute

          expect(issue_with_project_milestone.reload.milestone).to eq(project_milestone)
        end

        it 'applies new project milestone to merge_requests with group milestone' do
          service.execute
          new_milestone = mr_with_group_milestone.reload.milestone

          expect(new_milestone).not_to eq(group_milestone)
          expect(new_milestone.title).to eq(group_milestone.title)
          expect(new_milestone.project_milestone?).to be_truthy
          expect(new_milestone.state).to eq(""closed"")
        end

        it 'does not apply new project milestone to issuables with project milestone' do
          service.execute

          expect(mr_with_project_milestone.reload.milestone).to eq(project_milestone)
        end

        it 'does not recreate missing group milestones that are not applied to issues or merge requests' do
          service.execute
          new_milestone_title = project.reload.milestones.pluck(:title)

          expect(new_milestone_title).to include(group_milestone.title)
          expect(new_milestone_title).not_to include(group_milestone2.title)
        end

        context 'when find_or_create_milestone returns nil' do
          before do
            allow_next_instance_of(Milestones::FindOrCreateService) do |instance|
              allow(instance).to receive(:execute).and_return(nil)
            end
          end

          it 'removes issues group milestone' do
            service.execute

            expect(mr_with_group_milestone.reload.milestone).to be_nil
          end

          it 'removes merge requests group milestone' do
            service.execute

            expect(issue_with_group_milestone.reload.milestone).to be_nil
          end
        end
      end

      context 'with existing milestone at the new group level' do
        let!(:existing_milestone) { create(:milestone, group: new_group, title: group_milestone.title) }

        it 'does not create a new milestone' do
          expect { service.execute }.not_to change(project.milestones, :count)
        end

        it 'applies existing milestone to issues with group milestone' do
          service.execute

          expect(issue_with_group_milestone.reload.milestone).to eq(existing_milestone)
        end

        it 'applies existing milestone to merge_requests with group milestone' do
          service.execute

          expect(mr_with_group_milestone.reload.milestone).to eq(existing_milestone)
        end
      end
    end
  end

  context 'when old_group is not present' do
    let(:user)        { create(:admin) }
    let(:old_group)   { project.group }
    let(:project)     { create(:project, namespace: user.namespace) }

    it 'returns nil' do
      expect(described_class.new(user, old_group, project).execute).to be_nil
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Milestones
  class CloseService < Milestones::BaseService
    def execute(milestone)
      if milestone.close && milestone.project_milestone?
        event_service.close_milestone(milestone, current_user)
      end

      milestone
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Milestones::CloseService, feature_category: :team_planning do
  let(:user) { create(:user) }
  let(:project) { create(:project) }
  let(:milestone) { create(:milestone, title: ""Milestone v1.2"", project: project) }

  before do
    project.add_maintainer(user)
  end

  describe '#execute' do
    before do
      described_class.new(project, user, {}).execute(milestone)
    end

    it { expect(milestone).to be_valid }
    it { expect(milestone).to be_closed }

    describe 'event' do
      let(:event) { Event.recent.first }

      it { expect(event.milestone).to be_truthy }
      it { expect(event.target).to eq(milestone) }
      it { expect(event.action_name).to eq('closed') }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Milestones
  class DestroyService < Milestones::BaseService
    def execute(milestone)
      Milestone.transaction do
        update_params = { milestone_id: nil, skip_milestone_email: true }

        milestone.issues.each do |issue|
          Issues::UpdateService.new(container: parent, current_user: current_user, params: update_params).execute(issue)
        end

        milestone.merge_requests.each do |merge_request|
          MergeRequests::UpdateService.new(project: parent, current_user: current_user, params: update_params).execute(merge_request)
        end

        log_destroy_event_for(milestone)

        milestone.destroy
      end
    end

    def log_destroy_event_for(milestone)
      return if milestone.group_milestone?

      event_service.destroy_milestone(milestone, current_user)

      Event.for_milestone_id(milestone.id).each do |event|
        event.target_id = nil
        event.save
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Milestones::DestroyService, feature_category: :team_planning do
  let(:user) { create(:user) }
  let(:project) { create(:project, :repository) }
  let(:milestone) { create(:milestone, title: 'Milestone v1.0', project: project) }

  before do
    project.add_maintainer(user)
  end

  def service
    described_class.new(project, user, {})
  end

  describe '#execute' do
    it 'deletes milestone' do
      service.execute(milestone)

      expect { milestone.reload }.to raise_error ActiveRecord::RecordNotFound
    end

    context 'with an existing merge request' do
      let!(:issue) { create(:issue, project: project, milestone: milestone) }
      let!(:merge_request) { create(:merge_request, source_project: project, milestone: milestone) }

      it 'deletes milestone id from issuables' do
        service.execute(milestone)

        expect(issue.reload.milestone).to be_nil
        expect(merge_request.reload.milestone).to be_nil
      end
    end

    it 'logs destroy event' do
      service.execute(milestone)

      event = Event.where(project_id: milestone.project_id, target_type: 'Milestone')

      expect(event.count).to eq(1)
    end

    context 'group milestones' do
      let(:group) { create(:group) }
      let(:group_milestone) { create(:milestone, group: group) }

      before do
        project.update!(namespace: group)
        group.add_developer(user)
      end

      it { expect(service.execute(group_milestone)).to eq(group_milestone) }

      it 'deletes milestone id from issuables' do
        issue = create(:issue, project: project, milestone: group_milestone)
        merge_request = create(:merge_request, source_project: project, milestone: group_milestone)

        service.execute(group_milestone)

        expect(issue.reload.milestone).to be_nil
        expect(merge_request.reload.milestone).to be_nil
      end

      it 'does not log destroy event' do
        expect { service.execute(group_milestone) }.not_to change { Event.count }
      end
    end

    context 'when a release is tied to a milestone' do
      it 'destroys the milestone but not the associated release' do
        release = create(
          :release,
          tag: 'v1.0',
          project: project,
          milestones: [milestone]
        )

        expect { service.execute(milestone) }.not_to change { Release.count }
        expect(release.reload).to be_persisted
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Milestones
  class UpdateService < Milestones::BaseService
    def execute(milestone)
      state = params[:state_event]

      case state
      when 'activate'
        Milestones::ReopenService.new(parent, current_user, {}).execute(milestone)
      when 'close'
        Milestones::CloseService.new(parent, current_user, {}).execute(milestone)
      end

      if params.present?
        milestone.assign_attributes(params.except(:state_event))
      end

      if milestone.changed?
        before_update(milestone)
      end

      milestone.save
      milestone
    end

    private

    def before_update(milestone)
      milestone.check_for_spam(user: current_user, action: :update)
    end
  end
end

Milestones::UpdateService.prepend_mod_with('Milestones::UpdateService')

```","# frozen_string_literal: true
require 'spec_helper'

RSpec.describe Milestones::UpdateService, feature_category: :team_planning do
  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project) }
  let_it_be(:milestone) { create(:milestone, project: project) }
  let_it_be(:params) { { title: 'New Title' } }

  subject(:update_milestone) { described_class.new(project, user, params) }

  describe '#execute' do
    context 'when state_event is ""activate""' do
      let(:params) { { state_event: 'activate' } }

      it 'calls Milestones::ReopenService' do
        reopen_service = instance_double(Milestones::ReopenService)
        expect(Milestones::ReopenService).to receive(:new).with(project, user, {}).and_return(reopen_service)
        expect(reopen_service).to receive(:execute).with(milestone)

        update_milestone.execute(milestone)
      end
    end

    context 'when state_event is ""close""' do
      let(:params) { { state_event: 'close' } }

      it 'calls Milestones::CloseService' do
        close_service = instance_double(Milestones::CloseService)
        expect(Milestones::CloseService).to receive(:new).with(project, user, {}).and_return(close_service)
        expect(close_service).to receive(:execute).with(milestone)

        update_milestone.execute(milestone)
      end
    end

    context 'when params are present' do
      it 'assigns the params to the milestone' do
        expect(milestone).to receive(:assign_attributes).with(params.except(:state_event))

        update_milestone.execute(milestone)
      end
    end

    context 'when milestone is changed' do
      before do
        allow(milestone).to receive(:changed?).and_return(true)
      end

      it 'calls before_update' do
        expect(update_milestone).to receive(:before_update).with(milestone)

        update_milestone.execute(milestone)
      end
    end

    context 'when milestone is not changed' do
      before do
        allow(milestone).to receive(:changed?).and_return(false)
      end

      it 'does not call before_update' do
        expect(update_milestone).not_to receive(:before_update)

        update_milestone.execute(milestone)
      end
    end

    it 'saves the milestone' do
      expect(milestone).to receive(:save)

      update_milestone.execute(milestone)
    end

    it 'returns the milestone' do
      expect(update_milestone.execute(milestone)).to eq(milestone)
    end
  end

  describe '#before_update' do
    it 'checks for spam' do
      expect(milestone).to receive(:check_for_spam).with(user: user, action: :update)

      update_milestone.send(:before_update, milestone)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Milestones
  class CreateService < Milestones::BaseService
    def execute
      milestone = parent.milestones.new(params)

      before_create(milestone)

      if milestone.save && milestone.project_milestone?
        event_service.open_milestone(milestone, current_user)
      end

      milestone
    end

    private

    def before_create(milestone)
      milestone.check_for_spam(user: current_user, action: :create)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Milestones::CreateService, feature_category: :team_planning do
  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project) }
  let_it_be(:params) { { title: 'New Milestone', description: 'Description' } }

  subject(:create_milestone) { described_class.new(project, user, params) }

  describe '#execute' do
    context 'when milestone is saved successfully' do
      it 'creates a new milestone' do
        expect { create_milestone.execute }.to change { Milestone.count }.by(1)
      end

      it 'opens the milestone if it is a project milestone' do
        expect_next_instance_of(EventCreateService) do |instance|
          expect(instance).to receive(:open_milestone)
        end

        create_milestone.execute
      end

      it 'returns the created milestone' do
        milestone = create_milestone.execute
        expect(milestone).to be_a(Milestone)
        expect(milestone.title).to eq('New Milestone')
        expect(milestone.description).to eq('Description')
      end
    end

    context 'when milestone fails to save' do
      before do
        allow_next_instance_of(Milestone) do |instance|
          allow(instance).to receive(:save).and_return(false)
        end
      end

      it 'does not create a new milestone' do
        expect { create_milestone.execute }.not_to change { Milestone.count }
      end

      it 'does not open the milestone' do
        expect(EventCreateService).not_to receive(:open_milestone)

        create_milestone.execute
      end

      it 'returns the unsaved milestone' do
        milestone = create_milestone.execute
        expect(milestone).to be_a(Milestone)
        expect(milestone.title).to eq('New Milestone')
        expect(milestone.persisted?).to be_falsey
      end
    end

    it 'calls before_create method' do
      expect(create_milestone).to receive(:before_create)
      create_milestone.execute
    end
  end

  describe '#before_create' do
    it 'checks for spam' do
      milestone = build(:milestone)
      expect(milestone).to receive(:check_for_spam).with(user: user, action: :create)
      subject.send(:before_create, milestone)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Applications
  class CreateService
    attr_reader :current_user, :params

    def initialize(current_user, params)
      @current_user = current_user
      @params = params.except(:ip_address)
    end

    # EE would override and use `request` arg
    def execute(request)
      @application = Doorkeeper::Application.new(params)

      unless params[:scopes].present?
        @application.errors.add(:base, _(""Scopes can't be blank""))

        return @application
      end

      @application.save
      @application
    end
  end
end

Applications::CreateService.prepend_mod_with('Applications::CreateService')

```","# frozen_string_literal: true

require ""spec_helper""

RSpec.describe ::Applications::CreateService do
  include TestRequestHelpers

  let(:user) { create(:user) }

  subject { described_class.new(user, params) }

  context 'when scopes are present' do
    let(:params) { attributes_for(:application, scopes: ['read_user']) }

    it { expect { subject.execute(test_request) }.to change { Doorkeeper::Application.count }.by(1) }
  end

  context 'when scopes are missing' do
    let(:params) { attributes_for(:application) }

    it { expect { subject.execute(test_request) }.not_to change { Doorkeeper::Application.count } }

    it 'includes blank scopes error message' do
      application = subject.execute(test_request)

      expect(application.errors.full_messages).to include ""Scopes can't be blank""
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module JiraConnect
  class CreateAsymmetricJwtService
    ARGUMENT_ERROR_MESSAGE = 'jira_connect_installation is not a proxy installation'

    def initialize(jira_connect_installation, event: :installed)
      raise ArgumentError, ARGUMENT_ERROR_MESSAGE unless jira_connect_installation.proxy?

      @jira_connect_installation = jira_connect_installation
      @event = event
    end

    def execute
      JWT.encode(jwt_claims, private_key, 'RS256', jwt_headers)
    end

    private

    def jwt_claims
      { aud: aud_claim, iss: iss_claim, qsh: qsh_claim }
    end

    def aud_claim
      @jira_connect_installation.audience_url
    end

    def iss_claim
      @jira_connect_installation.client_key
    end

    def qsh_claim
      Atlassian::Jwt.create_query_string_hash(
        audience_event_url,
        'POST',
        @jira_connect_installation.audience_url
      )
    end

    def audience_event_url
      return @jira_connect_installation.audience_uninstalled_event_url if @event == :uninstalled

      @jira_connect_installation.audience_installed_event_url
    end

    def private_key
      @private_key ||= OpenSSL::PKey::RSA.generate(3072)
    end

    def public_key_storage
      @public_key_storage ||= JiraConnect::PublicKey.create!(key: private_key.public_key)
    end

    def jwt_headers
      { kid: public_key_storage.uuid }
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe JiraConnect::CreateAsymmetricJwtService, feature_category: :integrations do
  describe '#execute' do
    let_it_be(:jira_connect_installation) { create(:jira_connect_installation) }

    let(:service) { described_class.new(jira_connect_installation) }

    subject(:jwt_token) { service.execute }

    it 'raises an error' do
      expect { jwt_token }.to raise_error(ArgumentError, 'jira_connect_installation is not a proxy installation')
    end

    context 'with proxy installation' do
      let_it_be(:jira_connect_installation) { create(:jira_connect_installation, instance_url: 'https://gitlab.test') }

      let(:public_key_id) { Atlassian::Jwt.decode(jwt_token, nil, false, algorithm: 'RS256').last['kid'] }
      let(:public_key_cdn) { 'https://gitlab.com/-/jira_connect/public_keys/' }
      let(:event_url) { 'https://gitlab.test/-/jira_connect/events/installed' }
      let(:jwt_verification_claims) do
        {
          aud: 'https://gitlab.test/-/jira_connect',
          iss: jira_connect_installation.client_key,
          qsh: Atlassian::Jwt.create_query_string_hash(event_url, 'POST', 'https://gitlab.test/-/jira_connect')
        }
      end

      subject(:jwt_token) { service.execute }

      shared_examples 'produces a valid JWT' do
        it 'produces a valid JWT' do
          public_key = OpenSSL::PKey.read(JiraConnect::PublicKey.find(public_key_id).key)
          options = jwt_verification_claims.except(:qsh).merge({ verify_aud: true, verify_iss: true,
                                                                 algorithm: 'RS256' })

          decoded_token = Atlassian::Jwt.decode(jwt_token, public_key, true, options).first

          expect(decoded_token).to eq(jwt_verification_claims.stringify_keys)
        end
      end

      it 'stores the public key' do
        expect { JiraConnect::PublicKey.find(public_key_id) }.not_to raise_error
      end

      it_behaves_like 'produces a valid JWT'

      context 'with uninstalled event option' do
        let(:service) { described_class.new(jira_connect_installation, event: :uninstalled) }
        let(:event_url) { 'https://gitlab.test/-/jira_connect/events/uninstalled' }

        it_behaves_like 'produces a valid JWT'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module JiraConnect
  class SyncService
    def initialize(project)
      self.project = project
    end

    # Parameters: see Atlassian::JiraConnect::Client#send_info
    # Includes: update_sequence_id, commits, branches, merge_requests, pipelines
    def execute(**args)
      preload_reviewers_for_merge_requests(args[:merge_requests]) if args.key?(:merge_requests)

      JiraConnectInstallation.for_project(project).flat_map do |installation|
        client = Atlassian::JiraConnect::Client.new(installation.base_url, installation.shared_secret)

        responses = client.send_info(project: project, **args)

        responses.each { |r| log_response(r) }
      end
    end

    private

    attr_accessor :project

    def log_response(response)
      message = {
        message: 'response from jira dev_info api',
        integration: 'JiraConnect',
        project_id: project.id,
        project_path: project.full_path,
        jira_response: response&.to_json
      }

      has_errors = response && (response['errorMessage'].present? || response['errorMessages'].present?)

      if has_errors
        logger.error(message)
      else
        logger.info(message)
      end
    end

    def logger
      Gitlab::IntegrationsLogger
    end

    def preload_reviewers_for_merge_requests(merge_requests)
      ActiveRecord::Associations::Preloader.new(
        records: merge_requests, associations: [:approvals, { merge_request_reviewers: :reviewer }]
      ).call
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe JiraConnect::SyncService, feature_category: :integrations do
  include AfterNextHelpers

  describe '#execute' do
    let_it_be(:project) { create(:project, :repository) }
    let_it_be(:merge_request) { create(:merge_request, source_project: project) }
    let_it_be(:merge_request_reviewer) { create(:merge_request_reviewer, merge_request: merge_request) }

    let(:client) { Atlassian::JiraConnect::Client }
    let(:info) { { a: 'Some', b: 'Info', merge_requests: [merge_request] } }

    subject do
      described_class.new(project).execute(**info)
    end

    before do
      create(:jira_connect_subscription, namespace: project.namespace)
    end

    def store_info(return_values = [{ 'status': 'success' }])
      receive(:send_info).with(project: project, **info).and_return(return_values)
    end

    def expect_log(type, message)
      expect(Gitlab::IntegrationsLogger)
        .to receive(type).with(
          {
            message: 'response from jira dev_info api',
            integration: 'JiraConnect',
            project_id: project.id,
            project_path: project.full_path,
            jira_response: message&.to_json
          }
        )
    end

    it 'calls Atlassian::JiraConnect::Client#store_dev_info and logs the response' do
      expect_next(client).to store_info

      expect_log(:info, { 'status': 'success' })

      subject
    end

    it 'does not execute any queries for preloaded reviewers' do
      expect_next(client).to store_info

      expect_log(:info, { 'status': 'success' })

      amount = ActiveRecord::QueryRecorder
        .new { info[:merge_requests].flat_map(&:merge_request_reviewers).map(&:reviewer) }
        .count

      expect(amount).to be_zero

      subject
    end

    context 'when a request returns errors' do
      it 'logs each response as an error' do
        expect_next(client).to store_info(
          [
            { 'errorMessages' => ['some error message'] },
            { 'errorMessage' => 'a single error message' },
            { 'errorMessages' => [] },
            { 'errorMessage' => '' }
          ])

        expect_log(:error, { 'errorMessages' => ['some error message'] })
        expect_log(:error, { 'errorMessage' => 'a single error message' })

        subject
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Files
  class BaseService < Commits::CreateService
    FileChangedError = Class.new(StandardError)

    def initialize(*args)
      super

      git_user = Gitlab::Git::User.from_gitlab(current_user) if current_user.present?

      @author_email = commit_email(git_user)
      @author_name = params[:author_name] || git_user&.name
      @commit_message = params[:commit_message]
      @last_commit_sha = params[:last_commit_sha]

      @file_path = params[:file_path]
      @previous_path = params[:previous_path]

      @file_content = params[:file_content]
      @file_content = Base64.decode64(@file_content) if params[:file_content_encoding] == 'base64'

      @execute_filemode = params[:execute_filemode]
    end

    def file_has_changed?(path, commit_id)
      return false unless commit_id

      last_commit_from_branch = get_last_commit_for_path(ref: @start_branch, path: path)

      return false unless last_commit_from_branch

      last_commit_from_commit_id = get_last_commit_for_path(ref: commit_id, path: path)

      return false unless last_commit_from_commit_id

      last_commit_from_branch.sha != last_commit_from_commit_id.sha
    end

    private

    def get_last_commit_for_path(ref:, path:)
      Gitlab::Git::Commit.last_for_path(@start_project.repository, ref, path, literal_pathspec: true)
    end

    def commit_email(git_user)
      return params[:author_email] if params[:author_email].present?
      return unless current_user

      namespace_commit_email = current_user.namespace_commit_email_for_project(@start_project)

      return namespace_commit_email.email.email if namespace_commit_email

      git_user.email
    end
  end
end

```","# frozen_string_literal: true

require ""spec_helper""

RSpec.describe Files::BaseService, feature_category: :source_code_management do
  let_it_be(:group) { create(:group) }
  let_it_be(:project) { create(:project, group: group) }
  let_it_be(:user) { create(:user) }
  let(:params) { {} }

  subject(:author_email) { described_class.new(project, user, params).instance_variable_get(:@author_email) }

  before do
    group.add_developer(user)
  end

  context 'with no namespace_commit_emails' do
    it 'sets @author_email to user default email' do
      expect(author_email).to eq(user.email)
    end
  end

  context 'with an author_email in params and namespace_commit_email' do
    let(:params) { { author_email: 'email_from_params@example.com' } }

    before do
      create(:namespace_commit_email, user: user, namespace: group)
    end

    it 'gives precedence to the parameter value for @author_email' do
      expect(author_email).to eq('email_from_params@example.com')
    end
  end

  context 'with a project namespace_commit_email' do
    it 'sets @author_email to the project namespace_commit_email' do
      namespace_commit_email = create(:namespace_commit_email, user: user, namespace: project.project_namespace)

      expect(author_email).to eq(namespace_commit_email.email.email)
    end
  end

  context 'with a group namespace_commit_email' do
    it 'sets @author_email to the group namespace_commit_email' do
      namespace_commit_email = create(:namespace_commit_email, user: user, namespace: group)

      expect(author_email).to eq(namespace_commit_email.email.email)
    end
  end

  context 'with a project and group namespace_commit_email' do
    it 'sets @author_email to the project namespace_commit_email' do
      namespace_commit_email = create(:namespace_commit_email, user: user, namespace: project.project_namespace)
      create(:namespace_commit_email, user: user, namespace: group)

      expect(author_email).to eq(namespace_commit_email.email.email)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Files
  class MultiService < Files::BaseService
    UPDATE_FILE_ACTIONS = %w[update move delete chmod].freeze

    def create_commit!
      transformer = Lfs::FileTransformer.new(project, repository, @branch_name)

      actions = actions_after_lfs_transformation(transformer, params[:actions])
      actions = transform_move_actions(actions)

      commit_actions!(actions)
    end

    private

    def actions_after_lfs_transformation(transformer, actions)
      actions.map do |action|
        if action[:action] == 'create'
          result = transformer.new_file(action[:file_path], action[:content], encoding: action[:encoding])
          action[:content] = result.content
          action[:encoding] = result.encoding
        end

        action
      end
    end

    # When moving a file, `content: nil` means ""use the contents of the previous
    # file"", while `content: ''` means ""move the file and set it to empty""
    def transform_move_actions(actions)
      actions.map do |action|
        action[:infer_content] = true if action[:content].nil?

        action
      end
    end

    def commit_actions!(actions)
      repository.commit_files(
        current_user,
        message: @commit_message,
        branch_name: @branch_name,
        actions: actions,
        author_email: @author_email,
        author_name: @author_name,
        start_project: @start_project,
        start_branch_name: @start_branch,
        start_sha: @start_sha,
        force: force?
      )
    rescue ArgumentError => e
      raise_error(e)
    end

    def validate!
      super

      params[:actions].each { |action| validate_file_status!(action) }
    end

    def validate_file_status!(action)
      return unless UPDATE_FILE_ACTIONS.include?(action[:action])

      file_path = action[:previous_path] || action[:file_path]

      if file_has_changed?(file_path, action[:last_commit_id])
        raise_error(""The file has changed since you started editing it: #{file_path}"")
      end
    end
  end
end

```","# frozen_string_literal: true

require ""spec_helper""

RSpec.describe Files::MultiService, feature_category: :source_code_management do
  subject { described_class.new(project, user, commit_params) }

  let(:project) { create(:project, :repository) }
  let(:repository) { project.repository }
  let(:user) { create(:user) }
  let(:branch_name) { project.default_branch }
  let(:original_file_path) { 'files/ruby/popen.rb' }
  let(:new_file_path) { 'files/ruby/popen.rb' }
  let(:file_content) { 'New content' }
  let(:action) { 'update' }
  let(:commit_message) { 'Update File' }

  let!(:original_commit_id) do
    Gitlab::Git::Commit.last_for_path(project.repository, branch_name, original_file_path).sha
  end

  let(:branch_commit_id) do
    Gitlab::Git::Commit.find(project.repository, branch_name).sha
  end

  let(:default_action) do
    {
      action: action,
      file_path: new_file_path,
      previous_path: original_file_path,
      content: file_content,
      last_commit_id: original_commit_id
    }
  end

  let(:actions) { [default_action] }

  let(:commit_params) do
    {
      commit_message: commit_message,
      branch_name: branch_name,
      start_branch: branch_name,
      actions: actions
    }
  end

  before do
    project.add_maintainer(user)
  end

  describe '#execute' do
    context 'with a valid action' do
      it 'returns a hash with the :success status' do
        results = subject.execute

        expect(results[:status]).to eq(:success)
      end
    end

    context 'with an invalid action' do
      let(:action) { 'rename' }

      it 'returns a hash with the :error status' do
        results = subject.execute

        expect(results[:status]).to eq(:error)
        expect(results[:message]).to match(/Unknown action/)
      end
    end

    describe 'Updating files' do
      context 'when the file has been previously updated' do
        before do
          update_file(original_file_path)
        end

        it 'rejects the commit' do
          results = subject.execute

          expect(results[:status]).to eq(:error)
          expect(results[:message]).to match(new_file_path)
        end
      end

      context 'when file not changed, but later commit id is used' do
        let(:actions) { [default_action.merge(last_commit_id: branch_commit_id)] }

        it 'accepts the commit' do
          results = subject.execute

          expect(results[:status]).to eq(:success)
        end
      end

      context 'when the file have not been modified' do
        it 'accepts the commit' do
          results = subject.execute

          expect(results[:status]).to eq(:success)
        end
      end
    end

    describe 'changing execute_filemode of a file' do
      let(:commit_message) { 'Chmod +x file' }
      let(:file_path) { original_file_path }
      let(:default_action) do
        {
          action: 'chmod',
          file_path: file_path,
          execute_filemode: true
        }
      end

      it 'accepts the commit' do
        results = subject.execute

        expect(results[:status]).to eq(:success)
      end

      it 'updates the execute_filemode of the file' do
        expect { subject.execute }.to change { repository.blob_at_branch(branch_name, file_path).mode }.from('100644').to('100755')
      end

      context ""when the file doesn't exists"" do
        let(:file_path) { 'files/wrong_path.rb' }

        it 'rejects the commit' do
          results = subject.execute

          expect(results[:status]).to eq(:error)
          expect(results[:message]).to eq(""A file with this name doesn't exist"")
        end
      end
    end

    context 'when moving a file' do
      let(:action) { 'move' }
      let(:new_file_path) { 'files/ruby/new_popen.rb' }

      let(:result) { subject.execute }
      let(:blob) { repository.blob_at_branch(branch_name, new_file_path) }

      context 'when original file has been updated' do
        before do
          update_file(original_file_path)
        end

        it 'rejects the commit' do
          expect(result[:status]).to eq(:error)
          expect(result[:message]).to match(original_file_path)
        end
      end

      context 'when original file has not been updated' do
        it 'moves the file' do
          expect(result[:status]).to eq(:success)
          expect(blob).to be_present
          expect(blob.data).to eq(file_content)
        end

        context 'when content is nil' do
          let(:file_content) { nil }

          it 'moves the existing content untouched' do
            original_content = repository.blob_at_branch(branch_name, original_file_path).data

            expect(result[:status]).to eq(:success)
            expect(blob).to be_present
            expect(blob.data).to eq(original_content)
          end
        end

        context 'when content is an empty string' do
          let(:file_content) { '' }

          it 'moves the file and empties it' do
            expect(result[:status]).to eq(:success)
            expect(blob).not_to be_nil
            expect(blob.data).to eq('')
          end
        end
      end
    end

    context 'when creating a file matching an LFS filter' do
      let(:action) { 'create' }
      let(:branch_name) { 'lfs' }
      let(:new_file_path) { 'test_file.lfs' }

      before do
        allow(project).to receive(:lfs_enabled?).and_return(true)
      end

      it 'creates an LFS pointer' do
        subject.execute

        blob = repository.blob_at('lfs', new_file_path)

        expect(blob.data).to start_with(Gitlab::Git::LfsPointerFile::VERSION_LINE)
      end

      it ""creates an LfsObject with the file's content"" do
        subject.execute

        expect(LfsObject.last.file.read).to eq file_content
      end

      context 'with base64 encoded content' do
        let(:raw_file_content) { 'Raw content' }
        let(:file_content) { Base64.encode64(raw_file_content) }
        let(:actions) { [default_action.merge(encoding: 'base64')] }

        it 'creates an LFS pointer' do
          subject.execute

          blob = repository.blob_at('lfs', new_file_path)

          expect(blob.data).to start_with(Gitlab::Git::LfsPointerFile::VERSION_LINE)
        end

        it ""creates an LfsObject with the file's content"" do
          subject.execute

          expect(LfsObject.last.file.read).to eq raw_file_content
        end
      end

      it 'links the LfsObject to the project' do
        expect do
          subject.execute
        end.to change { project.lfs_objects.count }.by(1)
      end
    end

    context 'when file status validation is skipped' do
      let(:action) { 'create' }
      let(:new_file_path) { 'files/ruby/new_file.rb' }

      it 'does not check the last commit' do
        expect(Gitlab::Git::Commit).not_to receive(:last_for_path)

        subject.execute
      end

      it 'creates the file' do
        subject.execute

        blob = project.repository.blob_at_branch(branch_name, new_file_path)

        expect(blob).to be_present
      end
    end

    context 'when force is set to true and branch already exists' do
      let(:commit_params) do
        {
          commit_message: commit_message,
          branch_name: 'feature',
          start_branch: 'master',
          actions: actions,
          force: true
        }
      end

      it 'is still a success' do
        expect(subject.execute[:status]).to eq(:success)
      end
    end
  end

  def update_file(path)
    params = {
      file_path: path,
      start_branch: branch_name,
      branch_name: branch_name,
      commit_message: 'Update file',
      file_content: 'New content'
    }

    Files::UpdateService.new(project, user, params).execute
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Files
  class UpdateService < Files::BaseService
    def create_commit!
      repository.update_file(
        current_user,
        @file_path,
        @file_content,
        message: @commit_message,
        branch_name: @branch_name,
        previous_path: @previous_path,
        author_email: @author_email,
        author_name: @author_name,
        start_project: @start_project,
        start_branch_name: @start_branch,
        execute_filemode: @execute_filemode
      )
    end

    private

    def validate!
      super

      if file_has_changed?(@file_path, @last_commit_sha)
        raise FileChangedError, _('You are attempting to update a file that has changed since you started editing it.')
      end
    end
  end
end

```","# frozen_string_literal: true

require ""spec_helper""

RSpec.describe Files::UpdateService, feature_category: :source_code_management do
  subject { described_class.new(project, user, commit_params) }

  let(:project) { create(:project, :repository) }
  let(:user) { create(:user, :commit_email) }
  let(:file_path) { 'files/ruby/popen.rb' }
  let(:new_contents) { 'New Content' }
  let(:branch_name) { project.default_branch }
  let(:last_commit_sha) { nil }
  let(:commit) { project.repository.commit }

  let(:commit_params) do
    {
      file_path: file_path,
      commit_message: ""Update File"",
      file_content: new_contents,
      file_content_encoding: ""text"",
      last_commit_sha: last_commit_sha,
      start_project: project,
      start_branch: project.default_branch,
      branch_name: branch_name
    }
  end

  before do
    project.add_maintainer(user)
  end

  describe ""#execute"" do
    context ""when the file's last commit sha is earlier than the latest change for that branch"" do
      let(:last_commit_sha) { Gitlab::Git::Commit.last_for_path(project.repository, project.default_branch, file_path).parent_id }

      it ""returns a hash with the correct error message and a :error status"" do
        expect { subject.execute }
          .to raise_error(
            Files::UpdateService::FileChangedError,
            ""You are attempting to update a file that has changed since you started editing it.""
          )
      end
    end

    context ""when the file's last commit sha does match the supplied last_commit_sha"" do
      let(:last_commit_sha) { Gitlab::Git::Commit.last_for_path(project.repository, project.default_branch, file_path).sha }

      it ""returns a hash with the :success status"" do
        results = subject.execute

        expect(results[:status]).to match(:success)
      end

      it ""updates the file with the new contents"" do
        subject.execute

        results = project.repository.blob_at_branch(project.default_branch, file_path)

        expect(results.data).to eq(new_contents)
      end

      it 'uses the commit email' do
        subject.execute

        expect(user.commit_email).not_to eq(user.email)
        expect(commit.author_email).to eq(user.commit_email)
        expect(commit.committer_email).to eq(user.commit_email)
      end
    end

    context ""when the last_commit_sha is not supplied"" do
      it ""returns a hash with the :success status"" do
        results = subject.execute

        expect(results[:status]).to match(:success)
      end

      it ""updates the file with the new contents"" do
        subject.execute

        results = project.repository.blob_at_branch(project.default_branch, file_path)

        expect(results.data).to eq(new_contents)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Files
  class CreateService < Files::BaseService
    def create_commit!
      transformer = Lfs::FileTransformer.new(project, repository, @branch_name)

      result = transformer.new_file(@file_path, @file_content)

      create_transformed_commit(result.content)
    end

    private

    def create_transformed_commit(content_or_lfs_pointer)
      repository.create_file(
        current_user,
        @file_path,
        content_or_lfs_pointer,
        message: @commit_message,
        branch_name: @branch_name,
        author_email: @author_email,
        author_name: @author_name,
        start_project: @start_project,
        start_branch_name: @start_branch,
        execute_filemode: @execute_filemode)
    end
  end
end

```","# frozen_string_literal: true

require ""spec_helper""

RSpec.describe Files::CreateService, feature_category: :source_code_management do
  let(:project) { create(:project, :repository) }
  let(:repository) { project.repository }
  let(:user) { create(:user, :commit_email) }
  let(:file_content) { 'Test file content' }
  let(:branch_name) { project.default_branch }
  let(:start_branch) { branch_name }

  let(:commit_params) do
    {
      file_path: file_path,
      commit_message: ""Update File"",
      file_content: file_content,
      file_content_encoding: ""text"",
      start_project: project,
      start_branch: start_branch,
      branch_name: branch_name
    }
  end

  let(:commit) { repository.head_commit }

  subject { described_class.new(project, user, commit_params) }

  before do
    project.add_maintainer(user)
  end

  describe ""#execute"" do
    context 'when file matches LFS filter' do
      let(:file_path) { 'test_file.lfs' }
      let(:branch_name) { 'lfs' }

      context 'with LFS disabled' do
        it 'skips gitattributes check' do
          expect(repository).not_to receive(:attributes_at)

          subject.execute
        end

        it ""doesn't create LFS pointers"" do
          subject.execute

          blob = repository.blob_at('lfs', file_path)

          expect(blob.data).not_to start_with(Gitlab::Git::LfsPointerFile::VERSION_LINE)
          expect(blob.data).to eq(file_content)
        end
      end

      context 'with LFS enabled' do
        before do
          allow(project).to receive(:lfs_enabled?).and_return(true)
        end

        it 'creates an LFS pointer' do
          subject.execute

          blob = repository.blob_at('lfs', file_path)

          expect(blob.data).to start_with(Gitlab::Git::LfsPointerFile::VERSION_LINE)
        end

        it ""creates an LfsObject with the file's content"" do
          subject.execute

          expect(LfsObject.last.file.read).to eq file_content
        end

        it 'links the LfsObject to the project' do
          expect do
            subject.execute
          end.to change { project.lfs_objects.count }.by(1)
        end
      end
    end
  end

  context 'commit attribute' do
    let(:file_path) { 'test-commit-attributes.txt' }

    it 'uses the commit email' do
      subject.execute

      expect(user.commit_email).not_to eq(user.email)
      expect(commit.author_email).to eq(user.commit_email)
      expect(commit.committer_email).to eq(user.commit_email)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Files
  class DeleteService < Files::BaseService
    def create_commit!
      repository.delete_file(
        current_user,
        @file_path,
        message: @commit_message,
        branch_name: @branch_name,
        author_email: @author_email,
        author_name: @author_name,
        start_project: @start_project,
        start_branch_name: @start_branch)
    end

    private

    def validate!
      super

      if file_has_changed?(@file_path, @last_commit_sha)
        raise FileChangedError, _(""You are attempting to delete a file that has been previously updated."")
      end
    end
  end
end

```","# frozen_string_literal: true

require ""spec_helper""

RSpec.describe Files::DeleteService, feature_category: :source_code_management do
  subject { described_class.new(project, user, commit_params) }

  let(:project) { create(:project, :repository) }
  let(:user) { create(:user, :commit_email) }
  let(:file_path) { 'files/ruby/popen.rb' }
  let(:branch_name) { project.default_branch }
  let(:last_commit_sha) { nil }
  let(:commit) { project.repository.head_commit }

  let(:commit_params) do
    {
      file_path: file_path,
      commit_message: ""Delete File"",
      last_commit_sha: last_commit_sha,
      start_project: project,
      start_branch: project.default_branch,
      branch_name: branch_name
    }
  end

  shared_examples 'successfully deletes the file' do
    it 'returns a hash with the :success status' do
      results = subject.execute

      expect(results[:status]).to match(:success)
    end

    it 'deletes the file' do
      subject.execute

      blob = project.repository.blob_at_branch(project.default_branch, file_path)

      expect(blob).to be_nil
    end

    it 'uses the commit email' do
      subject.execute

      expect(user.commit_email).not_to eq(user.email)
      expect(commit.author_email).to eq(user.commit_email)
      expect(commit.committer_email).to eq(user.commit_email)
    end
  end

  before do
    project.add_maintainer(user)
  end

  describe ""#execute"" do
    context ""when the file's last commit is earlier than the latest commit for this branch"" do
      let(:last_commit_sha) { Gitlab::Git::Commit.last_for_path(project.repository, project.default_branch, file_path).parent_id }

      it ""returns a hash with the correct error message and a :error status"" do
        expect { subject.execute }.to raise_error(
          Files::UpdateService::FileChangedError,
          ""You are attempting to delete a file that has been previously updated.""
        )
      end
    end

    context ""when the file's last commit sha does match the supplied last_commit_sha"" do
      let(:last_commit_sha) { Gitlab::Git::Commit.last_for_path(project.repository, project.default_branch, file_path).sha }

      it_behaves_like 'successfully deletes the file'
    end

    context ""when the last_commit_sha is not supplied"" do
      it_behaves_like 'successfully deletes the file'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WikiPages
  # There are 3 notions of 'action' that inheriting classes must implement:
  #
  # - external_action: the action we report to external clients with webhooks
  # - usage_counter_action: the action that we count in out internal counters
  # - event_action: what we record as the value of `Event#action`
  class BaseService < ::BaseContainerService
    private

    def execute_hooks(page)
      page_data = payload(page)
      container.execute_hooks(page_data, :wiki_page_hooks)
      container.execute_integrations(page_data, :wiki_page_hooks)
      increment_usage
      create_wiki_event(page)
    end

    # Passed to web-hooks, and send to external consumers.
    def external_action
      raise NotImplementedError
    end

    # Passed to the WikiPageCounter to count events.
    # Must be one of WikiPageCounter::KNOWN_EVENTS
    def usage_counter_action
      raise NotImplementedError
    end

    # Used to create `Event` records.
    # Must be a valid value for `Event#action`
    def event_action
      raise NotImplementedError
    end

    def payload(page)
      Gitlab::DataBuilder::WikiPage.build(page, current_user, external_action)
    end

    # This method throws an error if the action is an unanticipated value.
    def increment_usage
      Gitlab::UsageDataCounters::WikiPageCounter.count(usage_counter_action)
    end

    def create_wiki_event(page)
      response = WikiPages::EventCreateService
        .new(current_user)
        .execute(slug_for_page(page), page, event_action, fingerprint(page))

      log_error(response.message) if response.error?
    end

    def slug_for_page(page)
      page.slug
    end

    def fingerprint(page)
      page.sha
    end
  end
end

WikiPages::BaseService.prepend_mod_with('WikiPages::BaseService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WikiPages::BaseService, feature_category: :wiki do
  let(:project) { double('project') }
  let(:user) { double('user') }

  describe '#increment_usage' do
    counter = Gitlab::UsageDataCounters::WikiPageCounter
    error = counter::UnknownEvent

    let(:subject) { bad_service_class.new(container: project, current_user: user) }

    context 'the class implements usage_counter_action incorrectly' do
      let(:bad_service_class) do
        Class.new(described_class) do
          def usage_counter_action
            :bad_event
          end
        end
      end

      it 'raises an error on unknown events' do
        expect { subject.send(:increment_usage) }.to raise_error(error)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WikiPages
  class EventCreateService
    # @param [User] author The event author
    def initialize(author)
      raise ArgumentError, 'author must not be nil' unless author

      @author = author
    end

    def execute(slug, page, action, event_fingerprint)
      wiki_page_meta = WikiPage::Meta.find_or_create(slug, page)

      event = ::EventCreateService.new.wiki_event(wiki_page_meta, author, action, event_fingerprint)

      ServiceResponse.success(payload: { event: event })
    rescue ::EventCreateService::IllegalActionError, ::ActiveRecord::ActiveRecordError => e
      ServiceResponse.error(message: e.message, payload: { error: e })
    end

    private

    attr_reader :author
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WikiPages::EventCreateService, feature_category: :wiki do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }

  subject { described_class.new(user) }

  describe '#execute' do
    let_it_be(:page) { create(:wiki_page, project: project) }

    let(:slug) { generate(:sluggified_title) }
    let(:action) { :created }
    let(:fingerprint) { page.sha }
    let(:response) { subject.execute(slug, page, action, fingerprint) }

    context 'the user is nil' do
      subject { described_class.new(nil) }

      it 'raises an error on construction' do
        expect { subject }.to raise_error ArgumentError
      end
    end

    context 'the action is illegal' do
      let(:action) { :illegal_action }

      it 'returns an error' do
        expect(response).to be_error
      end

      it 'does not create an event' do
        expect { response }.not_to change(Event, :count)
      end
    end

    it 'returns a successful response' do
      expect(response).to be_success
    end

    context 'the action is a deletion' do
      let(:action) { :destroyed }

      it 'does not synchronize the wiki metadata timestamps with the git commit' do
        expect_next_instance_of(WikiPage::Meta) do |instance|
          expect(instance).not_to receive(:synch_times_with_page)
        end

        response
      end
    end

    it 'creates a wiki page event' do
      expect { response }.to change(Event, :count).by(1)
    end

    it 'returns an event in the payload' do
      expect(response.payload).to include(event: have_attributes(author: user, wiki_page?: true, action: 'created'))
    end

    it 'records the slug for the page' do
      response
      meta = WikiPage::Meta.find_or_create(page.slug, page)

      expect(meta.slugs.pluck(:slug)).to include(slug)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WikiPages
  class DestroyService < WikiPages::BaseService
    def execute(page)
      if page.delete
        execute_hooks(page)
        ServiceResponse.success(payload: { page: page })
      else
        ServiceResponse.error(
          message: _('Could not delete wiki page'), payload: { page: page }
        )
      end
    end

    def usage_counter_action
      :delete
    end

    def external_action
      'delete'
    end

    def event_action
      :destroyed
    end

    def fingerprint(page)
      page.wiki.repository.head_commit.sha
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WikiPages::DestroyService, feature_category: :wiki do
  it_behaves_like 'WikiPages::DestroyService#execute', :project
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WikiPages
  class UpdateService < WikiPages::BaseService
    UpdateError = Class.new(StandardError)

    def execute(page)
      # this class is not thread safe!
      @old_slug = page.slug

      if page.wiki.capture_git_error(event_action) { page.update(@params) }
        execute_hooks(page)
        ServiceResponse.success(payload: { page: page })
      else
        raise UpdateError, _('Could not update wiki page')
      end
    rescue UpdateError, WikiPage::PageChangedError, WikiPage::PageRenameError => e
      page.update_attributes(@params) # rubocop:disable Rails/ActiveRecordAliases

      ServiceResponse.error(
        message: e.message,
        payload: { page: page }
      )
    end

    def usage_counter_action
      :update
    end

    def external_action
      'update'
    end

    def event_action
      :updated
    end

    def slug_for_page(page)
      @old_slug.presence || super
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WikiPages::UpdateService, feature_category: :wiki do
  it_behaves_like 'WikiPages::UpdateService#execute', :project

  describe '#execute' do
    let_it_be(:project) { create(:project) }

    let(:page) { create(:wiki_page, project: project) }

    subject(:service) { described_class.new(container: project) }

    context 'when wiki create fails due to git error' do
      let(:wiki_git_error) { 'Could not update wiki page' }

      it 'catches the thrown error and returns a ServiceResponse error' do
        allow_next_instance_of(WikiPage) do |instance|
          allow(instance).to receive(:update).and_raise(Gitlab::Git::CommandError.new(wiki_git_error))
        end

        result = service.execute(page)
        expect(result).to be_error
        expect(result.message).to eq(wiki_git_error)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WikiPages
  class CreateService < WikiPages::BaseService
    def execute
      wiki = Wiki.for_container(container, current_user)
      page = WikiPage.new(wiki)

      wiki.capture_git_error(event_action) do
        page.create(@params)
      end

      if page.persisted?
        execute_hooks(page)
        ServiceResponse.success(payload: { page: page })
      else
        ServiceResponse.error(message: _('Could not create wiki page'), payload: { page: page })
      end
    end

    def usage_counter_action
      :create
    end

    def external_action
      'create'
    end

    def event_action
      :created
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe WikiPages::CreateService, feature_category: :wiki do
  it_behaves_like 'WikiPages::CreateService#execute', :project

  describe '#execute' do
    let_it_be(:project) { create(:project) }

    subject(:service) { described_class.new(container: project) }

    context 'when wiki create fails due to git error' do
      let(:wiki_git_error) { 'Could not create wiki page' }

      it 'catches the thrown error and returns a ServiceResponse error' do
        allow_next_instance_of(WikiPage) do |instance|
          allow(instance).to receive(:create).and_raise(Gitlab::Git::CommandError.new(wiki_git_error))
        end

        result = service.execute
        expect(result).to be_error
        expect(result.message).to eq(wiki_git_error)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Lfs
  # Lfs::PushService pushes the LFS objects associated with a project to a
  # remote URL
  class PushService < BaseService
    include Gitlab::Utils::StrongMemoize

    # Match the canonical LFS client's batch size:
    # https://github.com/git-lfs/git-lfs/blob/master/tq/transfer_queue.go#L19
    BATCH_SIZE = 100

    def execute
      lfs_objects_relation.each_batch(of: BATCH_SIZE) do |objects|
        push_objects!(objects)
      end

      success
    rescue StandardError => err
      Gitlab::ErrorTracking.log_exception(err, extra_context)
      error(err.message)
    end

    private

    def extra_context
      { project_id: project.id, user_id: current_user&.id }.compact
    end

    # Currently we only set repository_type for design repository objects, so
    # push mirroring must send objects with a `nil` repository type - but if the
    # wiki repository uses LFS, its objects will also be sent. This will be
    # addressed by https://gitlab.com/gitlab-org/gitlab/-/issues/250346
    def lfs_objects_relation
      project.lfs_objects_for_repository_types(nil, :project)
    end

    def push_objects!(objects)
      rsp = lfs_client.batch!('upload', objects)
      objects = objects.index_by(&:oid)

      rsp.fetch('objects', []).each do |spec|
        actions = spec['actions']
        object = objects[spec['oid']]

        upload_object!(object, spec) if actions&.key?('upload')
        verify_object!(object, spec) if actions&.key?('verify')
      end
    end

    def upload_object!(object, spec)
      authenticated = spec['authenticated']
      upload = spec.dig('actions', 'upload')

      # The server wants us to upload the object but something is wrong
      unless object && object.size == spec['size'].to_i
        log_error(""Couldn't match object #{spec['oid']}/#{spec['size']}"")
        return
      end

      lfs_client.upload!(object, upload, authenticated: authenticated)
    end

    def verify_object!(object, spec)
      authenticated = spec['authenticated']
      verify = spec.dig('actions', 'verify')

      lfs_client.verify!(object, verify, authenticated: authenticated)
    end

    def url
      params.fetch(:url)
    end

    def credentials
      params.fetch(:credentials)
    end

    def lfs_client
      strong_memoize(:lfs_client) do
        Gitlab::Lfs::Client.new(url, credentials: credentials)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Lfs::PushService, feature_category: :source_code_management do
  let(:logger) { service.send(:logger) }
  let(:lfs_client) { service.send(:lfs_client) }

  let_it_be(:project) { create(:forked_project_with_submodules) }
  let_it_be(:remote_mirror) { create(:remote_mirror, project: project, enabled: true) }

  let(:params) { { url: remote_mirror.bare_url, credentials: remote_mirror.credentials } }

  subject(:service) { described_class.new(project, nil, params) }

  describe ""#execute"" do
    let_it_be(:lfs_object) { create_linked_lfs_object(project, :project) }

    it 'uploads the object when upload is requested' do
      stub_lfs_batch(lfs_object)

      expect(lfs_client)
        .to receive(:upload!)
        .with(lfs_object, upload_action_spec(lfs_object), authenticated: true)

      expect(service.execute).to eq(status: :success)
    end

    it 'does not upload the object when upload is not requested' do
      stub_lfs_batch(lfs_object, upload: false)

      expect(lfs_client).not_to receive(:upload!)

      expect(service.execute).to eq(status: :success)
    end

    it 'verifies the upload if requested' do
      stub_lfs_batch(lfs_object, verify: true)

      expect(lfs_client).to receive(:upload!)
      expect(lfs_client)
        .to receive(:verify!)
        .with(lfs_object, verify_action_spec(lfs_object), authenticated: true)

      expect(service.execute).to eq(status: :success)
    end

    it 'skips verification if requested but upload fails' do
      stub_lfs_batch(lfs_object, verify: true)

      expect(lfs_client).to receive(:upload!) { raise 'failed' }
      expect(lfs_client).not_to receive(:verify!)
      expect(service.execute).to eq(status: :error, message: 'failed')
    end

    it 'returns a failure when submitting a batch fails' do
      expect(lfs_client).to receive(:batch!) { raise 'failed' }

      expect(Gitlab::ErrorTracking).to receive(:log_exception).and_call_original
      expect(service.execute).to eq(status: :error, message: 'failed')
    end

    it 'returns a failure when submitting an upload fails' do
      stub_lfs_batch(lfs_object)
      expect(lfs_client).to receive(:upload!) { raise 'failed' }

      expect(Gitlab::ErrorTracking).to receive(:log_exception).and_call_original
      expect(service.execute).to eq(status: :error, message: 'failed')
    end

    context 'non-project-repository LFS objects' do
      let_it_be(:nil_lfs_object) { create_linked_lfs_object(project, nil) }
      let_it_be(:wiki_lfs_object) { create_linked_lfs_object(project, :wiki) }
      let_it_be(:design_lfs_object) { create_linked_lfs_object(project, :design) }

      it 'only tries to upload the project-repository LFS object' do
        stub_lfs_batch(nil_lfs_object, lfs_object, upload: false)

        expect(service.execute).to eq(status: :success)
      end
    end
  end

  it 'does nothing if there are no LFS objects' do
    expect(lfs_client).not_to receive(:upload!)

    expect(service.execute).to eq(status: :success)
  end

  def create_linked_lfs_object(project, type)
    create(:lfs_objects_project, project: project, repository_type: type).lfs_object
  end

  def stub_lfs_batch(*objects, upload: true, verify: false)
    expect(lfs_client)
      .to receive(:batch!).with('upload', containing_exactly(*objects))
      .and_return('transfer' => 'basic', 'objects' => objects.map { |o| object_spec(o, upload: upload, verify: verify) })
  end

  def batch_spec(*objects, upload: true, verify: false)
    { 'transfer' => 'basic', 'objects' => objects.map { |o| object_spec(o, upload: upload) } }
  end

  def object_spec(object, upload: true, verify: false)
    { 'oid' => object.oid, 'size' => object.size, 'authenticated' => true, 'actions' => {} }.tap do |spec|
      spec['actions']['upload'] = upload_action_spec(object) if upload
      spec['actions']['verify'] = verify_action_spec(object) if verify
    end
  end

  def upload_action_spec(object)
    { 'href' => ""https://example.com/#{object.oid}/#{object.size}"", 'header' => { 'Key' => 'value' } }
  end

  def verify_action_spec(object)
    { 'href' => ""https://example.com/#{object.oid}/#{object.size}/verify"", 'header' => { 'Key' => 'value' } }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Lfs
  class UnlockFileService < BaseService
    def execute
      unless can?(current_user, :push_code, project)
        raise Gitlab::GitAccess::ForbiddenError, _('You have no permissions')
      end

      unlock_file
    rescue Gitlab::GitAccess::ForbiddenError => ex
      error(ex.message, 403)
    rescue ActiveRecord::RecordNotFound
      error(_('Lock not found'), 404)
    rescue StandardError => ex
      error(ex.message, 500)
    end

    private

    def unlock_file
      forced = params[:force] == true

      if lock.can_be_unlocked_by?(current_user, forced)
        lock.destroy!

        success(lock: lock, http_status: :ok)
      elsif forced
        error(_('You must have maintainer access to force delete a lock'), 403)
      else
        error(_(""%{lock_path} is locked by GitLab User %{lock_user_id}"") % { lock_path: lock.path, lock_user_id: lock.user_id }, 403)
      end
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def lock
      return @lock if defined?(@lock)

      @lock = if params[:id].present?
                project.lfs_file_locks.find(params[:id])
              elsif params[:path].present?
                project.lfs_file_locks.find_by!(path: params[:path])
              end
    end
    # rubocop: enable CodeReuse/ActiveRecord
  end
end

Lfs::UnlockFileService.prepend_mod_with('Lfs::UnlockFileService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Lfs::UnlockFileService, feature_category: :source_code_management do
  let(:project)      { create(:project) }
  let(:current_user) { create(:user) }
  let(:lock_author)  { create(:user) }
  let!(:lock)        { create(:lfs_file_lock, user: lock_author, project: project) }
  let(:params)       { {} }

  subject { described_class.new(project, current_user, params) }

  describe '#execute' do
    context 'when not authorized' do
      it ""doesn't succeed"" do
        result = subject.execute

        expect(result[:status]).to eq(:error)
        expect(result[:http_status]).to eq(403)
        expect(result[:message]).to eq(_('You have no permissions'))
      end
    end

    context 'when authorized' do
      before do
        project.add_developer(current_user)
      end

      context 'when lock does not exists' do
        let(:params) { { id: 123 } }

        it ""doesn't succeed"" do
          result = subject.execute

          expect(result[:status]).to eq(:error)
          expect(result[:http_status]).to eq(404)
        end
      end

      context 'when unlocked by the author' do
        let(:current_user) { lock_author }
        let(:params) { { id: lock.id } }

        it ""succeeds"" do
          result = subject.execute

          expect(result[:status]).to eq(:success)
          expect(result[:lock]).to be_present
        end
      end

      context 'when unlocked by a different user' do
        let(:current_user) { create(:user) }
        let(:params) { { id: lock.id } }

        it ""doesn't succeed"" do
          result = subject.execute

          expect(result[:status]).to eq(:error)
          expect(result[:message]).to match(/is locked by GitLab User #{lock_author.id}/)
          expect(result[:http_status]).to eq(403)
        end
      end

      context 'when forced' do
        let(:developer) { create(:user) }
        let(:maintainer) { create(:user) }

        before do
          project.add_developer(developer)
          project.add_maintainer(maintainer)
        end

        context 'by a regular user' do
          let(:current_user) { developer }
          let(:params) do
            { id: lock.id,
              force: true }
          end

          it ""doesn't succeed"" do
            result = subject.execute

            expect(result[:status]).to eq(:error)
            expect(result[:message]).to eq(_('You must have maintainer access to force delete a lock'))
            expect(result[:http_status]).to eq(403)
          end
        end

        context 'by a maintainer user' do
          let(:current_user) { maintainer }
          let(:params) do
            { id: lock.id,
              force: true }
          end

          it ""succeeds"" do
            result = subject.execute

            expect(result[:status]).to eq(:success)
            expect(result[:lock]).to be_present
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Lfs
  # Usage: Calling `new_file` check to see if a file should be in LFS and
  #        return a transformed result with `content` and `encoding` to commit.
  #
  #        The `repository` passed to the initializer can be a Repository or
  #        class that inherits from Repository.
  #
  #        The `repository_type` property will be one of the types named in
  #        `Gitlab::GlRepository.types`, and is recorded on the `LfsObjectsProject`
  #        in order to identify the repository location of the blob.
  #
  #        For LFS an LfsObject linked to the project is stored and an LFS
  #        pointer returned. If the file isn't in LFS the untransformed content
  #        is returned to save in the commit.
  #
  # transformer = Lfs::FileTransformer.new(project, repository, @branch_name)
  # content_or_lfs_pointer = transformer.new_file(file_path, content).content
  # create_transformed_commit(content_or_lfs_pointer)
  #
  class FileTransformer
    attr_reader :project, :repository, :repository_type, :branch_name

    def initialize(project, repository, branch_name)
      @project = project
      @repository = repository
      @repository_type = repository.repo_type.name
      @branch_name = branch_name
    end

    def new_file(file_path, file_content, encoding: nil, detect_content_type: false)
      if project.lfs_enabled? && lfs_file?(file_path)
        file_content = parse_file_content(file_content, encoding: encoding)
        lfs_pointer_file = Gitlab::Git::LfsPointerFile.new(file_content)
        lfs_object = create_lfs_object!(lfs_pointer_file, file_content, detect_content_type)

        link_lfs_object!(lfs_object)

        Result.new(content: lfs_pointer_file.pointer, encoding: 'text')
      else
        Result.new(content: file_content, encoding: encoding)
      end
    end

    class Result
      attr_reader :content, :encoding

      def initialize(content:, encoding:)
        @content = content
        @encoding = encoding
      end
    end

    private

    def lfs_file?(file_path)
      cached_attributes.attributes(file_path)['filter'] == 'lfs'
    end

    def cached_attributes
      @cached_attributes ||= repository.attributes_at(branch_name)
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def create_lfs_object!(lfs_pointer_file, file_content, detect_content_type)
      LfsObject.find_or_create_by(oid: lfs_pointer_file.sha256, size: lfs_pointer_file.size) do |lfs_object|
        lfs_object.file = if detect_content_type && (content_type = Gitlab::Utils::MimeType.from_string(file_content))
                            CarrierWaveStringFile.new_file(
                              file_content: file_content,
                              filename: '',
                              content_type: content_type
                            )
                          else
                            CarrierWaveStringFile.new(file_content)
                          end
      end
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def link_lfs_object!(lfs_object)
      LfsObjectsProject.safe_find_or_create_by!(
        project: project,
        lfs_object: lfs_object,
        repository_type: repository_type
      )
    end

    def parse_file_content(file_content, encoding: nil)
      return file_content.read if file_content.respond_to?(:read)
      return Base64.decode64(file_content) if encoding == 'base64'

      file_content
    end
  end
end

```","# frozen_string_literal: true

require ""spec_helper""

RSpec.describe Lfs::FileTransformer, feature_category: :source_code_management do
  let(:project) { create(:project, :repository, :wiki_repo) }
  let(:repository) { project.repository }
  let(:file_content) { 'Test file content' }
  let(:branch_name) { 'lfs' }
  let(:file_path) { 'test_file.lfs' }

  subject { described_class.new(project, repository, branch_name) }

  describe '#new_file' do
    context 'with lfs disabled' do
      before do
        allow(project).to receive(:lfs_enabled?).and_return(false)
      end

      it 'skips gitattributes check' do
        expect(repository.raw).not_to receive(:blob_at)

        subject.new_file(file_path, file_content)
      end

      it 'returns untransformed content' do
        result = subject.new_file(file_path, file_content)

        expect(result.content).to eq(file_content)
      end

      it 'returns untransformed encoding' do
        result = subject.new_file(file_path, file_content, encoding: 'base64')

        expect(result.encoding).to eq('base64')
      end
    end

    context 'with lfs enabled' do
      before do
        allow(project).to receive(:lfs_enabled?).and_return(true)
      end

      it 'reuses cached gitattributes' do
        second_file = 'another_file.lfs'

        expect(repository.raw).to receive(:blob_at).with(branch_name, '.gitattributes').once

        subject.new_file(file_path, file_content)
        subject.new_file(second_file, file_content)
      end

      it ""creates an LfsObject with the file's content"" do
        subject.new_file(file_path, file_content)

        expect(LfsObject.last.file.read).to eq file_content
      end

      it 'returns an LFS pointer' do
        result = subject.new_file(file_path, file_content)

        expect(result.content).to start_with(Gitlab::Git::LfsPointerFile::VERSION_LINE)
      end

      it 'returns LFS pointer encoding as text' do
        result = subject.new_file(file_path, file_content, encoding: 'base64')

        expect(result.encoding).to eq('text')
      end

      context 'when an actual file is passed' do
        let(:file) { Tempfile.new(file_path) }

        before do
          file.write(file_content)
          file.rewind
        end

        after do
          file.unlink
        end

        it ""creates an LfsObject with the file's content"" do
          subject.new_file(file_path, file)

          expect(LfsObject.last.file.read).to eq file_content
        end

        context 'when repository is a design repository' do
          let(:file_path) { ""/#{DesignManagement.designs_directory}/test_file.lfs"" }
          let(:repository) { project.design_repository }

          it ""creates an LfsObject with the file's content"" do
            subject.new_file(file_path, file)

            expect(LfsObject.last.file.read).to eq(file_content)
          end

          it 'saves the correct repository_type to LfsObjectsProject' do
            subject.new_file(file_path, file)

            expect(project.lfs_objects_projects.first.repository_type).to eq('design')
          end
        end

        context 'when content type detection enabled' do
          let(:detect_content_type) { true }

          before do
            allow(Gitlab::Utils::MimeType).to receive(:from_string).with(file_content).and_return(mime_type)
          end

          context 'when mime type detected' do
            let(:mime_type) { 'image/tiff' }

            it 'creates a file with custom content type' do
              expect(CarrierWaveStringFile).to receive(:new_file).with({
                file_content: file_content,
                filename: anything,
                content_type: mime_type
              })

              subject.new_file(file_path, file, detect_content_type: detect_content_type)
            end
          end

          context 'when mime type not detected' do
            let(:mime_type) { nil }

            it 'creates a file with default content type' do
              expect(CarrierWaveStringFile).to receive(:new).with(file_content)

              subject.new_file(file_path, file, detect_content_type: detect_content_type)
            end
          end
        end
      end

      context ""when doesn't use LFS"" do
        let(:file_path) { 'other.filetype' }

        it ""doesn't create LFS pointers"" do
          new_content = subject.new_file(file_path, file_content).content

          expect(new_content).not_to start_with(Gitlab::Git::LfsPointerFile::VERSION_LINE)
          expect(new_content).to eq(file_content)
        end
      end

      it 'links LfsObjects to project' do
        expect do
          subject.new_file(file_path, file_content)
        end.to change { project.lfs_objects.count }.by(1)
      end

      it 'saves the repository_type to LfsObjectsProject' do
        subject.new_file(file_path, file_content)

        expect(project.lfs_objects_projects.first.repository_type).to eq('project')
      end

      context 'when LfsObject already exists' do
        let(:lfs_pointer) { Gitlab::Git::LfsPointerFile.new(file_content) }

        before do
          create(:lfs_object, oid: lfs_pointer.sha256, size: lfs_pointer.size)
        end

        it 'links LfsObjects to project' do
          expect do
            subject.new_file(file_path, file_content)
          end.to change { project.lfs_objects.count }.by(1)
        end
      end

      context 'when the LfsObject is already linked to project' do
        before do
          subject.new_file(file_path, file_content)
        end

        shared_examples 'a new LfsObject is not created' do
          it do
            expect do
              second_service.new_file(file_path, file_content)
            end.not_to change { project.lfs_objects.count }
          end
        end

        context 'and the service is called again with the same repository type' do
          let(:second_service) { described_class.new(project, repository, branch_name) }

          include_examples 'a new LfsObject is not created'

          it 'does not create a new LfsObjectsProject record' do
            expect do
              second_service.new_file(file_path, file_content)
            end.not_to change { project.lfs_objects_projects.count }
          end
        end

        context 'and the service is called again with a different repository type' do
          let(:second_service) { described_class.new(project, project.wiki.repository, branch_name) }

          before do
            expect(second_service).to receive(:lfs_file?).and_return(true)
          end

          include_examples 'a new LfsObject is not created'

          it 'creates a new LfsObjectsProject record' do
            expect do
              second_service.new_file(file_path, file_content)
            end.to change { project.lfs_objects_projects.count }.by(1)
          end

          it 'sets the correct repository_type on the new LfsObjectsProject record' do
            second_service.new_file(file_path, file_content)

            repository_types = project.lfs_objects_projects.order(:id).pluck(:repository_type)

            expect(repository_types).to eq(%w[project wiki])
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Lfs
  class LocksFinderService < BaseService
    def execute
      success(locks: find_locks)
    rescue StandardError => ex
      error(ex.message, 500)
    end

    private

    # rubocop: disable CodeReuse/ActiveRecord
    def find_locks
      options = params.slice(:id, :path).to_h.compact.symbolize_keys

      project.lfs_file_locks.where(options)
    end
    # rubocop: enable CodeReuse/ActiveRecord
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Lfs::LocksFinderService, feature_category: :source_code_management do
  let(:project) { create(:project) }
  let(:user)    { create(:user) }
  let(:params)  { {} }

  subject { described_class.new(project, user, params) }

  shared_examples 'no results' do
    it 'returns an empty list' do
      result = subject.execute

      expect(result[:status]).to eq(:success)
      expect(result[:locks]).to be_blank
    end
  end

  describe '#execute' do
    let!(:lock_1) { create(:lfs_file_lock, project: project) }
    let!(:lock_2) { create(:lfs_file_lock, project: project, path: 'README') }

    context 'find by id' do
      context 'with results' do
        let(:params) do
          { id: lock_1.id }
        end

        it 'returns the record' do
          result = subject.execute

          expect(result[:status]).to eq(:success)
          expect(result[:locks].size).to eq(1)
          expect(result[:locks].first).to eq(lock_1)
        end
      end

      context 'without results' do
        let(:params) do
          { id: 123 }
        end

        include_examples 'no results'
      end
    end

    context 'find by path' do
      context 'with results' do
        let(:params) do
          { path: lock_1.path }
        end

        it 'returns the record' do
          result = subject.execute

          expect(result[:status]).to eq(:success)
          expect(result[:locks].size).to eq(1)
          expect(result[:locks].first).to eq(lock_1)
        end
      end

      context 'without results' do
        let(:params) do
          { path: 'not-found' }
        end

        include_examples 'no results'
      end
    end

    context 'find all' do
      context 'with results' do
        it 'returns all the records' do
          result = subject.execute

          expect(result[:status]).to eq(:success)
          expect(result[:locks].size).to eq(2)
        end
      end

      context 'without results' do
        before do
          LfsFileLock.delete_all
        end

        include_examples 'no results'
      end
    end

    context 'when an error is raised' do
      it ""doesn't succeed"" do
        allow_next_instance_of(described_class) do |instance|
          allow(instance).to receive(:find_locks).and_raise(StandardError)
        end

        result = subject.execute

        expect(result[:status]).to eq(:error)
        expect(result[:locks]).to be_blank
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Lfs
  class LockFileService < BaseService
    def execute
      unless can?(current_user, :push_code, project)
        raise Gitlab::GitAccess::ForbiddenError, 'You have no permissions'
      end

      create_lock!
    rescue ActiveRecord::RecordNotUnique
      error('already locked', 409, current_lock)
    rescue Gitlab::GitAccess::ForbiddenError => ex
      error(ex.message, 403)
    rescue StandardError => ex
      error(ex.message, 500)
    end

    private

    # rubocop: disable CodeReuse/ActiveRecord
    def current_lock
      project.lfs_file_locks.find_by(path: params[:path])
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def create_lock!
      lock = project.lfs_file_locks.create!(user: current_user,
                                            path: params[:path])

      success(http_status: 201, lock: lock)
    end

    def error(message, http_status, lock = nil)
      {
        status: :error,
        message: message,
        http_status: http_status,
        lock: lock
      }
    end
  end
end

Lfs::LockFileService.prepend_mod_with('Lfs::LockFileService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Lfs::LockFileService, feature_category: :source_code_management do
  let(:project)      { create(:project) }
  let(:current_user) { create(:user) }

  subject { described_class.new(project, current_user, params) }

  describe '#execute' do
    let(:params) { { path: 'README.md' } }

    context 'when not authorized' do
      it ""doesn't succeed"" do
        result = subject.execute

        expect(result[:status]).to eq(:error)
        expect(result[:http_status]).to eq(403)
        expect(result[:message]).to eq('You have no permissions')
      end
    end

    context 'when authorized' do
      before do
        project.add_developer(current_user)
      end

      context 'with an existent lock' do
        let!(:lock) { create(:lfs_file_lock, project: project) }

        it ""doesn't succeed"" do
          expect(subject.execute[:status]).to eq(:error)
        end

        it ""doesn't create the Lock"" do
          expect do
            subject.execute
          end.not_to change { LfsFileLock.count }
        end
      end

      context 'without an existent lock' do
        it ""succeeds"" do
          expect(subject.execute[:status]).to eq(:success)
        end

        it ""creates the Lock"" do
          expect do
            subject.execute
          end.to change { LfsFileLock.count }.by(1)
        end
      end

      context 'when an error is raised' do
        it ""doesn't succeed"" do
          allow_next_instance_of(described_class) do |instance|
            allow(instance).to receive(:create_lock!).and_raise(StandardError)
          end

          expect(subject.execute[:status]).to eq(:error)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Keys
  class LastUsedService
    TIMEOUT = 1.day

    attr_reader :key

    # key - The Key for which to update the last used timestamp.
    def initialize(key)
      @key = key
    end

    def execute
      return unless update?

      # We _only_ want to update last_used_at and not also updated_at (which
      # would be updated when using #touch).
      key.update_column(:last_used_at, Time.zone.now)
    end

    def execute_async
      return unless update?

      ::SshKeys::UpdateLastUsedAtWorker.perform_async(key.id)
    end

    def update?
      return false if ::Gitlab::Database.read_only?

      last_used = key.last_used_at
      last_used.blank? || last_used <= TIMEOUT.ago
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Keys::LastUsedService, feature_category: :source_code_management do
  describe '#execute', :clean_gitlab_redis_shared_state do
    context 'when it has not been used recently' do
      let(:key) { create(:key, last_used_at: 1.year.ago) }
      let(:time) { Time.zone.now }

      it 'updates the key' do
        travel_to(time) { described_class.new(key).execute }

        expect(key.reload.last_used_at).to be_like_time(time)
      end
    end

    context 'when it has been used recently' do
      let(:time) { 1.minute.ago }
      let(:key) { create(:key, last_used_at: time) }

      it 'does not update the key' do
        described_class.new(key).execute

        expect(key.reload.last_used_at).to be_like_time(time)
      end
    end
  end

  describe '#execute_async', :clean_gitlab_redis_shared_state do
    context 'when it has not been used recently' do
      let(:key) { create(:key, last_used_at: 1.year.ago) }
      let(:time) { Time.zone.now }

      it 'schedules a job to update last_used_at' do
        expect(::SshKeys::UpdateLastUsedAtWorker).to receive(:perform_async)

        travel_to(time) { described_class.new(key).execute_async }
      end
    end

    context 'when it has been used recently' do
      let(:key) { create(:key, last_used_at: 1.minute.ago) }

      it 'does not schedule a job to update last_used_at' do
        expect(::SshKeys::UpdateLastUsedAtWorker).not_to receive(:perform_async)

        described_class.new(key).execute_async
      end
    end
  end

  describe '#update?', :clean_gitlab_redis_shared_state do
    it 'returns true when no last used timestamp is present' do
      key = build(:key, last_used_at: nil)
      service = described_class.new(key)

      expect(service.update?).to eq(true)
    end

    it 'returns true when the key needs to be updated' do
      key = build(:key, last_used_at: 1.year.ago)
      service = described_class.new(key)

      expect(service.update?).to eq(true)
    end

    it 'returns false when the key does not yet need to be updated' do
      key = build(:key, last_used_at: 1.minute.ago)
      service = described_class.new(key)

      expect(service.update?).to eq(false)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Keys
  class ExpiryNotificationService < ::Keys::BaseService
    attr_accessor :keys, :expiring_soon

    def initialize(user, params)
      @keys = params[:keys]
      @expiring_soon = params[:expiring_soon]

      super
    end

    def execute
      return unless allowed?

      if expiring_soon
        trigger_expiring_soon_notification
      else
        trigger_expired_notification
      end
    end

    private

    def allowed?
      user.can?(:receive_notifications)
    end

    def trigger_expiring_soon_notification
      notification_service.ssh_key_expiring_soon(user, keys.map(&:fingerprint))

      keys.update_all(before_expiry_notification_delivered_at: Time.current.utc)
    end

    def trigger_expired_notification
      notification_service.ssh_key_expired(user, keys.map(&:fingerprint))

      keys.update_all(expiry_notification_delivered_at: Time.current.utc)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Keys::ExpiryNotificationService, feature_category: :source_code_management do
  let_it_be_with_reload(:user) { create(:user) }

  let(:params) { { keys: user.keys, expiring_soon: expiring_soon } }

  subject { described_class.new(user, params) }

  shared_examples 'sends a notification' do
    it do
      perform_enqueued_jobs do
        subject.execute
      end
      should_email(user)
    end
  end

  shared_examples 'uses notification service to send email to the user' do |notification_method|
    it do
      expect_next_instance_of(NotificationService) do |notification_service|
        expect(notification_service).to receive(notification_method).with(key.user, [key.fingerprint])
      end

      subject.execute
    end
  end

  shared_examples 'does not send notification' do
    it do
      perform_enqueued_jobs do
        subject.execute
      end
      should_not_email(user)
    end
  end

  shared_context 'block user' do
    before do
      user.block!
    end
  end

  context 'with key expiring today', :mailer do
    let_it_be_with_reload(:key) { create(:key, expires_at: 10.minutes.from_now, user: user) }

    let(:expiring_soon) { false }

    context 'when user has permission to receive notification' do
      it_behaves_like 'sends a notification'

      it_behaves_like 'uses notification service to send email to the user', :ssh_key_expired

      it 'updates notified column' do
        expect { subject.execute }.to change { key.reload.expiry_notification_delivered_at }
      end
    end

    context 'when user does NOT have permission to receive notification' do
      include_context 'block user'

      it_behaves_like 'does not send notification'

      it 'does not update notified column' do
        expect { subject.execute }.not_to change { key.reload.expiry_notification_delivered_at }
      end
    end
  end

  context 'with key expiring soon', :mailer do
    let_it_be_with_reload(:key) { create(:key, expires_at: 3.days.from_now, user: user) }

    let(:expiring_soon) { true }

    context 'when user has permission to receive notification' do
      it_behaves_like 'sends a notification'

      it_behaves_like 'uses notification service to send email to the user', :ssh_key_expiring_soon

      it 'updates notified column' do
        expect { subject.execute }.to change { key.reload.before_expiry_notification_delivered_at }
      end
    end

    context 'when user does NOT have permission to receive notification' do
      include_context 'block user'

      it_behaves_like 'does not send notification'

      it 'does not update notified column' do
        expect { subject.execute }.not_to change { key.reload.before_expiry_notification_delivered_at }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Keys
  class RevokeService < ::Keys::DestroyService
    def execute(key)
      key.transaction do
        unverify_associated_signatures(key)

        raise ActiveRecord::Rollback unless super(key)
      end
    end

    private

    def unverify_associated_signatures(key)
      key.ssh_signatures.each_batch do |batch|
        batch.update_all(
          verification_status: CommitSignatures::SshSignature.verification_statuses[:revoked_key],
          updated_at: Time.zone.now
        )
      end
    end
  end
end

Keys::DestroyService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Keys::RevokeService, feature_category: :source_code_management do
  let(:user) { create(:user) }

  subject(:service) { described_class.new(user) }

  it 'destroys a key' do
    key = create(:key)

    expect { service.execute(key) }.to change { key.persisted? }.from(true).to(false)
  end

  it 'unverifies associated signatures' do
    key = create(:key)
    signature = create(:ssh_signature, key: key)

    expect do
      service.execute(key)
    end.to change { signature.reload.key }.from(key).to(nil)
      .and change { signature.reload.verification_status }.from('verified').to('revoked_key')
  end

  it 'does not unverifies signatures if destroy fails' do
    key = create(:key)
    signature = create(:ssh_signature, key: key)

    expect(key).to receive(:destroy).and_return(false)

    expect { service.execute(key) }.not_to change { signature.reload.verification_status }
    expect(key).to be_persisted
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Keys
  class DestroyService < ::Keys::BaseService
    def execute(key)
      return unless destroy_possible?(key)

      destroy(key)
    end

    private

    # overridden in EE::Keys::DestroyService
    def destroy_possible?(key)
      true
    end

    def destroy(key)
      key.destroy
    end
  end
end

Keys::DestroyService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Keys::DestroyService, feature_category: :source_code_management do
  let(:user) { create(:user) }

  subject { described_class.new(user) }

  it 'destroys a key' do
    key = create(:personal_key)

    expect { subject.execute(key) }.to change(Key, :count).by(-1)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Keys
  class CreateService < ::Keys::BaseService
    attr_accessor :current_user

    def initialize(current_user, params = {})
      @current_user = current_user
      @params = params
      @ip_address = @params.delete(:ip_address)
      @user = params.delete(:user) || current_user
    end

    def execute
      key = user.keys.create(params)
      notification_service.new_key(key) if key.persisted?
      key
    end
  end
end

Keys::CreateService.prepend_mod_with('Keys::CreateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Keys::CreateService, feature_category: :source_code_management do
  let(:user) { create(:user) }
  let(:params) { attributes_for(:key) }

  subject { described_class.new(user, params) }

  context 'notification', :mailer do
    it 'sends a notification' do
      perform_enqueued_jobs do
        subject.execute
      end
      should_email(user)
    end
  end

  it 'creates a key' do
    expect { subject.execute }.to change { user.keys.where(params).count }.by(1)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Members
  class InviteMemberBuilder < StandardMemberBuilder
    def execute
      if user_by_email
        find_or_initialize_member_by_user(user_by_email.id)
      else
        source.members_and_requesters.find_or_initialize_by(invite_email: invitee) # rubocop:disable CodeReuse/ActiveRecord
      end
    end

    private

    def user_by_email
      source.users_by_emails([invitee])[invitee]
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Members::InviteMemberBuilder, feature_category: :groups_and_projects do
  let_it_be(:source) { create(:group) }
  let_it_be(:existing_member) { create(:group_member) }

  let(:existing_members) { { existing_member.user.id => existing_member } }

  describe '#execute' do
    context 'when user record found by email' do
      it 'returns member from existing members hash' do
        expect(described_class.new(source, existing_member.user.email, existing_members).execute).to eq existing_member
      end

      it 'builds a new member' do
        user = create(:user)

        member = described_class.new(source, user.email, existing_members).execute

        expect(member).to be_new_record
        expect(member.user).to eq user
      end
    end
  end

  context 'when no existing users found by the email' do
    it 'finds existing member' do
      member = create(:group_member, :invited, source: source)

      expect(described_class.new(source, member.invite_email, existing_members).execute).to eq member
    end

    it 'builds a new member' do
      email = 'test@example.com'

      member = described_class.new(source, email, existing_members).execute

      expect(member).to be_new_record
      expect(member.invite_email).to eq email
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Members
  class InvitationReminderEmailService
    include Gitlab::Utils::StrongMemoize

    attr_reader :invitation

    MAX_INVITATION_LIFESPAN = 14.0
    REMINDER_RATIO = [2, 5, 10].freeze

    def initialize(invitation)
      @invitation = invitation
    end

    def execute
      reminder_index = days_on_which_to_send_reminders.index(days_after_invitation_sent)
      return unless reminder_index

      invitation.send_invitation_reminder(reminder_index)
    end

    private

    def days_after_invitation_sent
      (Date.today - invitation.created_at.to_date).to_i
    end

    def days_on_which_to_send_reminders
      # Don't send any reminders if the invitation has expired or expires today
      return [] if invitation.expires_at && invitation.expires_at <= Date.today

      # Calculate the number of days on which to send reminders based on the MAX_INVITATION_LIFESPAN and the REMINDER_RATIO
      REMINDER_RATIO.map { |number_of_days| ((number_of_days * invitation_lifespan_in_days) / MAX_INVITATION_LIFESPAN).ceil }.uniq
    end

    def invitation_lifespan_in_days
      # When the invitation lifespan is more than 14 days or does not expire, send the reminders within 14 days
      strong_memoize(:invitation_lifespan_in_days) do
        if invitation.expires_at
          [(invitation.expires_at - invitation.created_at.to_date).to_i, MAX_INVITATION_LIFESPAN].min
        else
          MAX_INVITATION_LIFESPAN
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Members::InvitationReminderEmailService, feature_category: :groups_and_projects do
  describe 'sending invitation reminders' do
    subject { described_class.new(invitation).execute }

    let_it_be(:frozen_time) { Date.today.beginning_of_day }
    let_it_be(:invitation) { build(:group_member, :invited, created_at: frozen_time) }

    before do
      invitation.expires_at = frozen_time + expires_at_days.days if expires_at_days
    end

    using RSpec::Parameterized::TableSyntax

    where(:expires_at_days, :send_reminder_at_days) do
      0   | []
      1   | []
      2   | [1]
      3   | [1, 2]
      4   | [1, 2, 3]
      5   | [1, 2, 4]
      6   | [1, 3, 5]
      7   | [1, 3, 5]
      8   | [2, 3, 6]
      9   | [2, 4, 7]
      10  | [2, 4, 8]
      11  | [2, 4, 8]
      12  | [2, 5, 9]
      13  | [2, 5, 10]
      14  | [2, 5, 10]
      15  | [2, 5, 10]
      nil | [2, 5, 10]
    end

    with_them do
      # Create an invitation today with an expiration date from 0 to 10 days in the future or without an expiration date
      # We chose 10 days here, because we fetch invitations that were created at most 10 days ago.
      11.times do |day|
        it 'sends an invitation reminder only on the expected days' do
          next if day > (expires_at_days || 10) # We don't need to test after the invitation has already expired

          # We are traveling in a loop from today to 10 days from now
          travel_to(frozen_time + day.days) do
            # Given an expiration date and the number of days after the creation of the invitation based on the current day in the loop, a reminder may be sent
            if (reminder_index = send_reminder_at_days.index(day))
              expect(invitation).to receive(:send_invitation_reminder).with(reminder_index)
            else
              expect(invitation).not_to receive(:send_invitation_reminder)
            end

            subject
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Members
  class BaseService < ::BaseService
    # current_user - The user that performs the action
    # params - A hash of parameters
    def initialize(current_user = nil, params = {})
      @current_user = current_user
      @params = params

      # could be a string, force to an integer, part of fix
      # https://gitlab.com/gitlab-org/gitlab/-/issues/219496
      # Allow the ArgumentError to be raised if it can't be converted to an integer.
      @params[:access_level] = Integer(@params[:access_level]) if @params[:access_level]
    end

    def after_execute(args)
      # overridden in EE::Members modules
    end

    private

    def update_member_permission(member)
      case member
      when GroupMember
        :update_group_member
      when ProjectMember
        :update_project_member
      else
        raise ""Unknown member type: #{member}!""
      end
    end

    def override_member_permission(member)
      case member
      when GroupMember
        :override_group_member
      when ProjectMember
        :override_project_member
      else
        raise ""Unknown member type: #{member}!""
      end
    end

    def action_member_permission(action, member)
      case action
      when :update
        update_member_permission(member)
      when :override
        override_member_permission(member)
      else
        raise ""Unknown action '#{action}' on #{member}!""
      end
    end

    def resolve_access_request_todos(member)
      todo_service.resolve_access_request_todos(member)
    end

    def enqueue_delete_todos(member)
      type = member.is_a?(GroupMember) ? 'Group' : 'Project'
      # don't enqueue immediately to prevent todos removal in case of a mistake
      member.run_after_commit_or_now do
        TodosDestroyer::EntityLeaveWorker.perform_in(Todo::WAIT_FOR_DELETE, member.user_id, member.source_id, type)
      end
    end

    def cannot_assign_owner_responsibilities_to_member_in_project?(member)
      # The purpose of this check is -
      # We can have direct members who are ""Owners"" in a project going forward and
      # we do not want Maintainers of the project updating/adding/removing other ""Owners""
      # within the project.
      # Only OWNERs in a project should be able to manage any action around OWNERship in that project.
      member.is_a?(ProjectMember) &&
        !can?(current_user, :manage_owners, member.source)
    end

    alias_method :cannot_revoke_owner_responsibilities_from_member_in_project?,
                 :cannot_assign_owner_responsibilities_to_member_in_project?
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Members::BaseService, feature_category: :groups_and_projects do
  let_it_be(:access_requester) { create(:group_member) }

  describe '#resolve_access_request_todos' do
    it 'calls the resolve_access_request_todos of todo service' do
      expect_next_instance_of(TodoService) do |todo_service|
        expect(todo_service)
          .to receive(:resolve_access_request_todos).with(access_requester)
      end

      described_class.new.send(:resolve_access_request_todos, access_requester)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Members
  class UnassignIssuablesService
    attr_reader :user, :entity

    def initialize(user, entity)
      @user = user
      @entity = entity
    end

    def execute
      return unless entity && user

      project_ids = entity.is_a?(Group) ? entity.all_projects.select(:id) : [entity.id]

      user.issue_assignees.on_issues(Issue.in_projects(project_ids).select(:id)).delete_all
      user.merge_request_assignees.in_projects(project_ids).delete_all

      user.invalidate_cache_counts
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Members::UnassignIssuablesService, feature_category: :groups_and_projects do
  let_it_be(:group) { create(:group, :private) }
  let_it_be(:project) { create(:project, group: group) }
  let_it_be(:user, reload: true) { create(:user) }
  let_it_be(:assigned_issue1, reload: true) { create(:issue, project: project, assignees: [user]) }
  let_it_be(:assigned_issue2, reload: true) { create(:issue, project: project, assignees: [user]) }

  let!(:assigned_merge_request1) { create(:merge_request, :simple, :closed, target_project: project, source_project: project, assignees: [user], title: 'Test1') }
  let!(:assigned_merge_request2) { create(:merge_request, :simple, :opened, target_project: project, source_project: project, assignees: [user], title: 'Test2') }

  describe '#execute' do
    RSpec.shared_examples 'un-assigning issuables' do |issue_count, mr_count, open_issue_count, open_mr_count|
      it 'removes issuable assignments', :aggregate_failures do
        expect(user.assigned_issues.count).to eq(issue_count)
        expect(user.assigned_merge_requests.count).to eq(mr_count)

        subject

        expect(user.assigned_issues.count).to eq(0)
        expect(user.assigned_merge_requests.count).to eq(0)
      end

      it 'invalidates user cache', :aggregate_failures, :clean_gitlab_redis_cache do
        expect(user.assigned_open_merge_requests_count).to eq(open_mr_count)
        expect(user.assigned_open_issues_count).to eq(open_issue_count)

        subject

        expect(user.assigned_open_merge_requests_count).to eq(0)
        expect(user.assigned_open_issues_count).to eq(0)
      end
    end

    context 'when a user leaves a project' do
      before do
        project.add_maintainer(user)
      end

      subject { described_class.new(user, project).execute }

      it_behaves_like 'un-assigning issuables', 2, 2, 2, 1
    end

    context 'when a user leaves a group' do
      let_it_be(:project2) { create(:project, group: group) }

      let_it_be(:assigned_issue3, reload: true) { create(:issue, project: project2, assignees: [user]) }
      let_it_be(:assigned_issue4, reload: true) { create(:issue, project: project2, assignees: [user]) }

      let!(:assigned_merge_request3) { create(:merge_request, :simple, :closed, target_project: project2, source_project: project2, assignees: [user], title: 'Test1') }
      let!(:assigned_merge_request4) { create(:merge_request, :simple, :opened, target_project: project2, source_project: project2, assignees: [user], title: 'Test2') }

      before do
        group.add_maintainer(user)
      end

      subject { described_class.new(user, group).execute }

      it_behaves_like 'un-assigning issuables', 4, 4, 4, 2
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Members
  class StandardMemberBuilder
    def initialize(source, invitee, existing_members)
      @source = source
      @invitee = invitee
      @existing_members = existing_members
    end

    def execute
      find_or_initialize_member_by_user(invitee.id)
    end

    private

    attr_reader :source, :invitee, :existing_members

    def find_or_initialize_member_by_user(user_id)
      existing_members[user_id] || source.members_and_requesters.build(user_id: user_id) # rubocop:disable CodeReuse/ActiveRecord
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Members::StandardMemberBuilder, feature_category: :groups_and_projects do
  let_it_be(:source) { create(:group) }
  let_it_be(:existing_member) { create(:group_member) }

  let(:existing_members) { { existing_member.user.id => existing_member } }

  describe '#execute' do
    it 'returns member from existing members hash' do
      expect(described_class.new(source, existing_member.user, existing_members).execute).to eq existing_member
    end

    it 'builds a new member' do
      user = create(:user)

      member = described_class.new(source, user, existing_members).execute

      expect(member).to be_new_record
      expect(member.user).to eq user
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Members
  # This class serves as more of an app-wide way we add/create members
  # All roads to add members should take this path.
  class CreatorService
    class << self
      def parsed_access_level(access_level)
        access_levels.fetch(access_level) { access_level.to_i }
      end

      def access_levels
        Gitlab::Access.sym_options_with_owner
      end

      # Add members to sources with passed access option
      #
      # access can be an integer representing a access code
      # or symbol like :maintainer representing role
      #
      # Ex.
      #   add_members(
      #     sources,
      #     user_ids,
      #     Member::MAINTAINER
      #   )
      #
      #   add_members(
      #     sources,
      #     user_ids,
      #     :maintainer
      #   )
      #
      # @param sources [Group, Project, Array<Group>, Array<Project>, Group::ActiveRecord_Relation,
      # Project::ActiveRecord_Relation] - Can't be an array of source ids because we don't know the type of source.
      # @return Array<Member>
      def add_members(sources, invitees, access_level, **args)
        return [] unless invitees.present?

        sources = Array.wrap(sources) if sources.is_a?(ApplicationRecord) # For single source

        Gitlab::Database::QueryAnalyzers::PreventCrossDatabaseModification.temporary_ignore_tables_in_transaction(
          %w[users user_preferences user_details emails identities], url: 'https://gitlab.com/gitlab-org/gitlab/-/issues/424276'
        ) do
          Member.transaction do
            sources.flat_map do |source|
              # If this user is attempting to manage Owner members and doesn't have permission, do not allow
              current_user = args[:current_user]
              next [] if managing_owners?(current_user, access_level) && cannot_manage_owners?(source, current_user)

              emails, users, existing_members = parse_users_list(source, invitees)

              common_arguments = {
                source: source,
                access_level: access_level,
                existing_members: existing_members
              }.merge(parsed_args(args))

              members = emails.map do |email|
                new(invitee: email, builder: InviteMemberBuilder, **common_arguments).execute
              end

              members += users.map do |user|
                new(invitee: user, **common_arguments).execute
              end

              members
            end
          end
        end
      end

      def add_member(source, invitee, access_level, **args)
        add_members(source, [invitee], access_level, **args).first
      end

      private

      def parsed_args(args)
        {
          current_user: args[:current_user],
          expires_at: args[:expires_at],
          ldap: args[:ldap]
        }
      end

      def managing_owners?(current_user, access_level)
        current_user && Gitlab::Access.sym_options_with_owner[access_level] == Gitlab::Access::OWNER
      end

      def parse_users_list(source, list)
        emails = []
        user_ids = []
        users = []
        existing_members = {}

        list.each do |item|
          case item
          when User
            users << item
          when Integer
            user_ids << item
          when /\A\d+\Z/
            user_ids << item.to_i
          when Devise.email_regexp
            emails << item
          end
        end

        # the below will automatically discard invalid user_ids
        users.concat(User.id_in(user_ids)) if user_ids.present?
        # de-duplicate just in case as there is no controlling if user records and ids are sent multiple times
        users.uniq!

        users_by_emails = source.users_by_emails(emails) # preloads our request store for all emails
        # in case emails belong to a user that is being invited by user or user_id, remove them from
        # emails and let users/user_ids handle it.
        parsed_emails = emails.select do |email|
          user = users_by_emails[email]
          !user || (users.exclude?(user) && user_ids.exclude?(user.id))
        end

        if users.present? || users_by_emails.present?
          # helps not have to perform another query per user id to see if the member exists later on when fetching
          existing_members = source.members_and_requesters.with_user(users + users_by_emails.values).index_by(&:user_id)
        end

        [parsed_emails, users, existing_members]
      end
    end

    def initialize(invitee:, builder: StandardMemberBuilder, **args)
      @invitee = invitee
      @builder = builder
      @args = args
      @access_level = self.class.parsed_access_level(args[:access_level])
    end

    private_class_method :new

    def execute
      find_or_build_member
      commit_member
      after_commit_tasks

      member
    end

    private

    delegate :new_record?, to: :member
    attr_reader :invitee, :access_level, :member, :args, :builder

    def assign_member_attributes
      member.attributes = member_attributes
    end

    def commit_member
      return add_commit_error unless can_commit_member?

      assign_member_attributes

      return add_member_role_error if member_role_too_high?

      commit_changes
    end

    def can_commit_member?
      # There is no current user for bulk actions, in which case anything is allowed
      return true if skip_authorization?

      if new_record?
        can_create_new_member?
      else
        can_update_existing_member?
      end
    end

    # overridden in Members::Groups::CreatorService
    def member_role_too_high?
      false
    end

    def can_create_new_member?
      raise NotImplementedError
    end

    def can_update_existing_member?
      raise NotImplementedError
    end

    # Populates the attributes of a member.
    #
    # This logic resides in a separate method so that EE can extend this logic,
    # without having to patch the `add_members` method directly.
    def member_attributes
      {
        created_by: member.created_by || current_user,
        access_level: access_level,
        expires_at: args[:expires_at]
      }
    end

    def commit_changes
      if member.request?
        approve_request
      elsif member.changed?
        # Calling #save triggers callbacks even if there is no change on object.
        # This previously caused an incident due to the hard to predict
        # behaviour caused by the large number of callbacks.
        # See https://gitlab.com/gitlab-com/gl-infra/production/-/issues/6351
        # and https://gitlab.com/gitlab-org/gitlab/-/merge_requests/80920#note_911569038
        # for details.
        member.save
      end
    end

    def after_commit_tasks
      # hook for overriding in other uses
    end

    def approve_request
      ::Members::ApproveAccessRequestService.new(current_user, access_level: access_level)
                                            .execute(
                                              member,
                                              skip_authorization: ldap || skip_authorization?,
                                              skip_log_audit_event: ldap
                                            )
    end

    def current_user
      args[:current_user]
    end

    def skip_authorization?
      !current_user
    end

    def add_commit_error
      msg = if new_record?
              _('not authorized to create member')
            else
              _('not authorized to update member')
            end

      member.errors.add(:base, msg)
    end

    def add_member_role_error
      msg = _(""the member access level can't be higher than the current user's one"")

      member.errors.add(:base, msg)
    end

    def find_or_build_member
      @member = builder.new(source, invitee, existing_members).execute
    end

    def ldap
      args[:ldap] || false
    end

    def source
      args[:source]
    end

    def existing_members
      args[:existing_members] || {}
    end
  end
end

Members::CreatorService.prepend_mod_with('Members::CreatorService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Members::CreatorService, feature_category: :groups_and_projects do
  let_it_be(:source, reload: true) { create(:group, :public) }
  let_it_be(:member_type) { GroupMember }
  let_it_be(:user) { create(:user) }
  let_it_be(:current_user) { create(:user) }

  describe '#execute' do
    it 'raises error for new member on authorization check implementation' do
      expect do
        described_class.add_member(source, user, :maintainer, current_user: current_user)
      end.to raise_error(NotImplementedError)
    end

    it 'raises error for an existing member on authorization check implementation' do
      source.add_developer(user)

      expect do
        described_class.add_member(source, user, :maintainer, current_user: current_user)
      end.to raise_error(NotImplementedError)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Members
  class InviteService < Members::CreateService
    extend ::Gitlab::Utils::Override

    def initialize(*args)
      super

      @invites += parsed_emails

      @errors = {}
    end

    private

    alias_method :formatted_errors, :errors

    def parsed_emails
      # can't put this in the initializer since `invites_from_params` is called in super class
      # and needs it
      @parsed_emails ||= (formatted_param(params[:email]) || [])
    end

    def formatted_param(parameter)
      parameter&.split(',')&.uniq&.flatten
    end

    def validate_invitable!
      super

      return if params[:email].blank?

      # we need the below due to add_member hitting Members::CreatorService.parse_users_list and ignoring invalid emails
      # ideally we wouldn't need this, but we can't really change the add_members method
      invalid_emails.each { |email| errors[email] = s_('AddMember|Invite email is invalid') }
    end

    def invalid_emails
      parsed_emails.each_with_object([]) do |email, invalid|
        next if Member.valid_email?(email)

        invalid << email
        @invites.delete(email)
      end
    end

    override :blank_invites_message
    def blank_invites_message
      s_('AddMember|Invites cannot be blank')
    end

    override :add_error_for_member
    def add_error_for_member(member, existing_errors)
      errors[invited_object(member)] = all_member_errors(member, existing_errors).to_sentence
    end

    def invited_object(member)
      return member.invite_email if member.invite_email

      # There is a case where someone was invited by email, but the `user` record exists.
      # The member record returned will not have an invite_email attribute defined since
      # the CreatorService finds `user` record sometimes by email.
      # At that point we lose the info of whether this invite was done by `user` or by email.
      # Here we will give preference to check invites by user_id first.
      # There is also a case where a user could be invited by their email and
      # at the same time via the API in the same request.
      # This would would mean the same user is invited as user_id and email.
      # However, that isn't as likely from the UI at least since the token generator checks
      # for that case and doesn't allow email being used if the user exists as a record already.
      if member.user_id.to_s.in?(invites)
        member.user.username
      else
        member.user.all_emails.detect { |email| email.in?(invites) }
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Members::InviteService, :aggregate_failures, :clean_gitlab_redis_shared_state, :sidekiq_inline,
  feature_category: :groups_and_projects do
  let_it_be(:project, reload: true) { create(:project) }
  let_it_be(:user) { project.first_owner }
  let_it_be(:project_user) { create(:user) }
  let_it_be(:user_invited_by_id) { create(:user) }
  let_it_be(:namespace) { project.namespace }

  let(:params) { {} }
  let(:base_params) { { access_level: Gitlab::Access::GUEST, source: project, invite_source: '_invite_source_' } }

  subject(:result) { described_class.new(user, base_params.merge(params)).execute }

  context 'when there is a valid member invited' do
    let(:params) { { email: 'email@example.org' } }

    it 'successfully creates a member' do
      expect_to_create_members(count: 1)
      expect(result[:status]).to eq(:success)
    end

    it_behaves_like 'records an onboarding progress action', :user_added
  end

  context 'when email belongs to an existing user as a confirmed secondary email' do
    let(:secondary_email) { create(:email, :confirmed, email: 'secondary@example.com', user: project_user) }
    let(:params) { { email: secondary_email.email } }

    it 'adds an existing user to members', :aggregate_failures do
      expect_to_create_members(count: 1)
      expect(result[:status]).to eq(:success)
      expect(project.users).to include project_user
      expect(project.members.last).not_to be_invite
    end
  end

  context 'when email belongs to an existing user as an unconfirmed secondary email' do
    let(:unconfirmed_secondary_email) { create(:email, email: 'secondary@example.com', user: project_user) }
    let(:params) { { email: unconfirmed_secondary_email.email } }

    it 'does not link the email with any user and successfully creates a member as an invite for that email' do
      expect_to_create_members(count: 1)
      expect(result[:status]).to eq(:success)
      expect(project.users).not_to include project_user
      expect(project.members.last).to be_invite
    end
  end

  context 'when invites are passed as array' do
    context 'with emails' do
      let(:params) { { email: %w[email@example.org email2@example.org] } }

      it 'successfully creates members' do
        expect_to_create_members(count: 2)
        expect(result[:status]).to eq(:success)
      end
    end

    context 'with user_id as integers' do
      let(:params) { { user_id: [project_user.id, user_invited_by_id.id] } }

      it 'successfully creates members' do
        expect_to_create_members(count: 2)
        expect(result[:status]).to eq(:success)
      end
    end

    context 'with user_id as strings' do
      let(:params) { { user_id: [project_user.id.to_s, user_invited_by_id.id.to_s] } }

      it 'successfully creates members' do
        expect_to_create_members(count: 2)
        expect(result[:status]).to eq(:success)
      end
    end

    context 'with a mixture of emails and user_id' do
      let(:params) do
        { user_id: [project_user.id, user_invited_by_id.id], email: %w[email@example.org email2@example.org] }
      end

      it 'successfully creates members' do
        expect_to_create_members(count: 4)
        expect(result[:status]).to eq(:success)
      end
    end
  end

  context 'with multiple invites passed as strings' do
    context 'with emails' do
      let(:params) { { email: 'email@example.org,email2@example.org' } }

      it 'successfully creates members' do
        expect_to_create_members(count: 2)
        expect(result[:status]).to eq(:success)
      end
    end

    context 'with user_id' do
      let(:params) { { user_id: ""#{project_user.id},#{user_invited_by_id.id}"" } }

      it 'successfully creates members' do
        expect_to_create_members(count: 2)
        expect(result[:status]).to eq(:success)
      end
    end

    context 'with a mixture of emails and user_id' do
      let(:params) do
        { user_id: ""#{project_user.id},#{user_invited_by_id.id}"", email: 'email@example.org,email2@example.org' }
      end

      it 'successfully creates members' do
        expect_to_create_members(count: 4)
        expect(result[:status]).to eq(:success)
      end
    end
  end

  context 'when invites formats are mixed' do
    context 'when user_id is an array and emails is a string' do
      let(:params) do
        { user_id: [project_user.id, user_invited_by_id.id], email: 'email@example.org,email2@example.org' }
      end

      it 'successfully creates members' do
        expect_to_create_members(count: 4)
        expect(result[:status]).to eq(:success)
      end
    end

    context 'when user_id is a string and emails is an array' do
      let(:params) do
        { user_id: ""#{project_user.id},#{user_invited_by_id.id}"", email: %w[email@example.org email2@example.org] }
      end

      it 'successfully creates members' do
        expect_to_create_members(count: 4)
        expect(result[:status]).to eq(:success)
      end
    end
  end

  context 'when invites are passed in different formats' do
    context 'when emails are passed as an empty string' do
      let(:params) { { email: '' } }

      it 'returns an error' do
        expect_not_to_create_members
        expect(result[:message]).to eq('Invites cannot be blank')
      end
    end

    context 'when user_id are passed as an empty string' do
      let(:params) { { user_id: '' } }

      it 'returns an error' do
        expect_not_to_create_members
        expect(result[:message]).to eq('Invites cannot be blank')
      end
    end

    context 'when user_id and emails are both passed as empty strings' do
      let(:params) { { user_id: '', email: '' } }

      it 'returns an error' do
        expect_not_to_create_members
        expect(result[:message]).to eq('Invites cannot be blank')
      end
    end

    context 'when user_id is passed as an integer' do
      let(:params) { { user_id: project_user.id } }

      it 'successfully creates member' do
        expect_to_create_members(count: 1)
        expect(result[:status]).to eq(:success)
      end
    end

    context 'when invite params are not included' do
      it 'returns an error' do
        expect_not_to_create_members
        expect(result[:message]).to eq('Invites cannot be blank')
      end
    end
  end

  context 'when email is not a valid email format' do
    context 'with singular email' do
      let(:params) { { email: '_bogus_' } }

      it 'returns an error' do
        expect_not_to_create_members
        expect(result[:status]).to eq(:error)
        expect(result[:message][params[:email]]).to eq(""Invite email is invalid"")
      end

      it_behaves_like 'does not record an onboarding progress action'
    end

    context 'with user_id and singular invalid email' do
      let(:params) { { user_id: project_user.id, email: '_bogus_' } }

      it 'has partial success' do
        expect_to_create_members(count: 1)
        expect(project.users).to include project_user

        expect(result[:status]).to eq(:error)
        expect(result[:message][params[:email]]).to eq(""Invite email is invalid"")
      end
    end

    context 'with email that has trailing spaces' do
      let(:params) { { email: ' foo@bar.com ' } }

      it 'returns an error' do
        expect_not_to_create_members
        expect(result[:status]).to eq(:error)
        expect(result[:message][params[:email]]).to eq(""Invite email is invalid"")
      end

      it_behaves_like 'does not record an onboarding progress action'
    end
  end

  context 'with duplicate invites' do
    context 'with duplicate emails' do
      let(:params) { { email: 'email@example.org,email@example.org' } }

      it 'only creates one member per unique invite' do
        expect_to_create_members(count: 1)
        expect(result[:status]).to eq(:success)
      end
    end

    context 'with duplicate user ids' do
      let(:params) { { user_id: ""#{project_user.id},#{project_user.id}"" } }

      it 'only creates one member per unique invite' do
        expect_to_create_members(count: 1)
        expect(result[:status]).to eq(:success)
      end
    end

    context 'with duplicate member by adding as user id and email' do
      let(:params) { { user_id: project_user.id, email: project_user.email } }

      it 'only creates one member per unique invite' do
        expect_to_create_members(count: 1)
        expect(result[:status]).to eq(:success)
      end
    end
  end

  context 'when observing invite limits' do
    context 'with emails and in general' do
      let_it_be(:emails) { Array(1..101).map { |n| ""email#{n}@example.com"" } }

      context 'when over the allowed default limit of emails' do
        let(:params) { { email: emails } }

        it 'limits the number of emails to 100' do
          expect_not_to_create_members
          expect(result[:message]).to eq('Too many users specified (limit is 100)')
        end
      end

      context 'when over the allowed custom limit of emails' do
        let(:params) { { email: 'email@example.org,email2@example.org', limit: 1 } }

        it 'limits the number of emails to the limit supplied' do
          expect_not_to_create_members
          expect(result[:message]).to eq('Too many users specified (limit is 1)')
        end
      end

      context 'when limit allowed is disabled via limit param' do
        let(:params) { { email: emails, limit: -1 } }

        it 'does not limit number of emails' do
          expect_to_create_members(count: 101)
          expect(result[:status]).to eq(:success)
        end
      end
    end

    context 'with user_id' do
      let(:user_id) { 1.upto(101).to_a.join(',') }
      let(:params) { { user_id: user_id } }

      it 'limits the number of users to 100' do
        expect_not_to_create_members
        expect(result[:message]).to eq('Too many users specified (limit is 100)')
      end
    end
  end

  context 'with an existing user' do
    context 'with email' do
      let(:params) { { email: project_user.email } }

      it 'adds an existing user to members' do
        expect_to_create_members(count: 1)
        expect(result[:status]).to eq(:success)
        expect(project.users).to include project_user
      end
    end

    context 'with unconfirmed primary email' do
      let_it_be(:unconfirmed_user) { create(:user, :unconfirmed) }

      let(:params) { { email: unconfirmed_user.email } }

      it 'adds a new member as an invite for unconfirmed primary email' do
        expect_to_create_members(count: 1)
        expect(result[:status]).to eq(:success)
        expect(project.users).not_to include unconfirmed_user
        expect(project.members.last).to be_invite
      end
    end

    context 'with user_id' do
      let(:params) { { user_id: project_user.id } }

      it_behaves_like 'records an onboarding progress action', :user_added

      it 'adds an existing user to members' do
        expect_to_create_members(count: 1)
        expect(result[:status]).to eq(:success)
        expect(project.users).to include project_user
      end
    end
  end

  context 'when access level is not valid' do
    context 'with email' do
      let(:params) { { email: project_user.email, access_level: -1 } }

      it 'returns an error' do
        expect_not_to_create_members
        expect(result[:message][project_user.email]).to eq(""Access level is not included in the list"")
      end
    end

    context 'with user_id' do
      let(:params) { { user_id: user_invited_by_id.id, access_level: -1 } }

      it 'returns an error' do
        expect_not_to_create_members
        expect(result[:message][user_invited_by_id.username]).to eq(""Access level is not included in the list"")
      end
    end

    context 'with a mix of user_id and email' do
      let(:params) { { user_id: user_invited_by_id.id, email: project_user.email, access_level: -1 } }

      it 'returns errors' do
        expect_not_to_create_members
        expect(result[:message][project_user.email]).to eq(""Access level is not included in the list"")
        expect(result[:message][user_invited_by_id.username]).to eq(""Access level is not included in the list"")
      end
    end
  end

  context 'when member already exists' do
    context 'with email' do
      let!(:invited_member) { create(:project_member, :guest, :invited, project: project) }
      let(:params) do
        { email: ""#{invited_member.invite_email},#{project_user.email}"", access_level: ProjectMember::MAINTAINER }
      end

      it 'adds new email and allows already invited members to be re-invited by email and updates the member access' do
        expect_to_create_members(count: 1)
        expect(result[:status]).to eq(:success)
        expect(project.users).to include project_user
        expect(invited_member.reset.access_level).to eq ProjectMember::MAINTAINER
      end
    end

    context 'when email is already a member with a user on the project' do
      let!(:existing_member) { create(:project_member, :guest, project: project) }
      let(:params) { { email: existing_member.user.email.to_s, access_level: ProjectMember::MAINTAINER } }

      it 'allows re-invite of an already invited email and updates the access_level' do
        expect { result }.not_to change(ProjectMember, :count)
        expect(result[:status]).to eq(:success)
        expect(existing_member.reset.access_level).to eq ProjectMember::MAINTAINER
      end

      context 'when email belongs to an existing user as a confirmed secondary email' do
        let(:secondary_email) { create(:email, :confirmed, email: 'secondary@example.com', user: existing_member.user) }
        let(:params) { { email: secondary_email.email.to_s } }

        it 'allows re-invite to an already invited email' do
          expect_to_create_members(count: 0)
          expect(result[:status]).to eq(:success)
        end
      end
    end

    context 'with user_id that already exists' do
      let!(:existing_member) { create(:project_member, project: project, user: project_user) }
      let(:params) { { user_id: existing_member.user_id } }

      it 'does not add the member again and is successful' do
        expect_to_create_members(count: 0)
        expect(project.users).to include project_user
      end
    end

    context 'with user_id that already exists with a lower access_level' do
      let!(:existing_member) { create(:project_member, :developer, project: project, user: project_user) }
      let(:params) { { user_id: existing_member.user_id, access_level: ProjectMember::MAINTAINER } }

      it 'does not add the member again and updates the access_level' do
        expect_to_create_members(count: 0)
        expect(project.users).to include project_user
        expect(existing_member.reset.access_level).to eq ProjectMember::MAINTAINER
      end
    end

    context 'with user_id that already exists with a higher access_level' do
      let!(:existing_member) { create(:project_member, :developer, project: project, user: project_user) }
      let(:params) { { user_id: existing_member.user_id, access_level: ProjectMember::GUEST } }

      it 'does not add the member again and updates the access_level' do
        expect_to_create_members(count: 0)
        expect(project.users).to include project_user
        expect(existing_member.reset.access_level).to eq ProjectMember::GUEST
      end
    end

    context 'with user_id that already exists in a parent group' do
      let_it_be(:group) { create(:group) }
      let_it_be(:group_member) { create(:group_member, :developer, source: group, user: project_user) }
      let_it_be(:project, reload: true) { create(:project, group: group) }
      let_it_be(:user) { project.creator }

      before_all do
        project.add_maintainer(user)
      end

      context 'when access_level is lower than inheriting member' do
        let(:params) { { user_id: group_member.user_id, access_level: ProjectMember::GUEST } }

        it 'does not add the member and returns an error' do
          msg = ""Access level should be greater than or equal "" \
                ""to Developer inherited membership from group #{group.name}""

          expect_not_to_create_members
          expect(result[:message][project_user.username]).to eq msg
        end
      end

      context 'when access_level is the same as the inheriting member' do
        let(:params) { { user_id: group_member.user_id, access_level: ProjectMember::DEVELOPER } }

        it 'adds the member with correct access_level' do
          expect_to_create_members(count: 1)
          expect(project.users).to include project_user
          expect(project.project_members.last.access_level).to eq ProjectMember::DEVELOPER
        end
      end

      context 'when access_level is greater than the inheriting member' do
        let(:params) { { user_id: group_member.user_id, access_level: ProjectMember::MAINTAINER } }

        it 'adds the member with correct access_level' do
          expect_to_create_members(count: 1)
          expect(project.users).to include project_user
          expect(project.project_members.last.access_level).to eq ProjectMember::MAINTAINER
        end
      end
    end
  end

  def expect_to_create_members(count:)
    expect { result }.to change(ProjectMember, :count).by(count)
  end

  def expect_not_to_create_members
    expect { result }.not_to change(ProjectMember, :count)
    expect(result[:status]).to eq(:error)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Members
  class DestroyService < Members::BaseService
    include Gitlab::ExclusiveLeaseHelpers

    def execute(
      member,
      skip_authorization: false,
      skip_subresources: false,
      unassign_issuables: false,
      destroy_bot: false,
      skip_saml_identity: false
    )

      unless skip_authorization
        raise Gitlab::Access::AccessDeniedError unless authorized?(member, destroy_bot)

        raise Gitlab::Access::AccessDeniedError if destroying_member_with_owner_access_level?(member) &&
          cannot_revoke_owner_responsibilities_from_member_in_project?(member)
      end

      @skip_auth = skip_authorization

      if a_group_owner?(member)
        process_destroy_of_group_owner_member(member, skip_subresources, skip_saml_identity)
      else
        destroy_member(member)
        destroy_data_related_to_member(member, skip_subresources, skip_saml_identity)
      end

      enqueue_jobs_that_needs_to_be_run_only_once_per_hierarchy(member, unassign_issuables)

      member
    end

    # We use this to mark recursive calls made to this service from within the same service.
    # We do this so as to help us run some tasks that needs to be run only once per hierarchy, and not recursively.
    def mark_as_recursive_call
      @recursive_call = true
    end

    private

    # These actions need to be executed only once per hierarchy because the underlying services
    # apply these actions to the entire hierarchy anyway, so there is no need to execute them recursively.
    def enqueue_jobs_that_needs_to_be_run_only_once_per_hierarchy(member, unassign_issuables)
      return if recursive_call?

      enqueue_cleanup_jobs_once_per_heirarchy(member, unassign_issuables)
    end

    def enqueue_cleanup_jobs_once_per_heirarchy(member, unassign_issuables)
      enqueue_delete_todos(member)
      enqueue_unassign_issuables(member) if unassign_issuables
    end

    def recursive_call?
      @recursive_call == true
    end

    def process_destroy_of_group_owner_member(member, skip_subresources, skip_saml_identity)
      # Deleting 2 different group owners via the API in quick succession could lead to
      # wrong results for the `last_owner?` check due to race conditions. To prevent this
      # we wrap both the last_owner? check and the deletes of owners within a lock.
      last_group_owner = true

      in_lock(""delete_members:#{member.source.class}:#{member.source.id}"", sleep_sec: 0.1.seconds) do
        break if member.source.last_owner?(member.user)

        last_group_owner = false
        destroy_member(member)
      end

      # deletion of related data does not have to be within the lock.
      destroy_data_related_to_member(member, skip_subresources, skip_saml_identity) unless last_group_owner
    end

    def destroy_member(member)
      member.destroy
    end

    def destroy_data_related_to_member(member, skip_subresources, skip_saml_identity)
      member.user&.invalidate_cache_counts
      delete_member_associations(member, skip_subresources, skip_saml_identity)
    end

    def a_group_owner?(member)
      member.is_a?(GroupMember) && member.owner?
    end

    def delete_member_associations(member, skip_subresources, skip_saml_identity)
      if member.request? && member.user != current_user
        notification_service.decline_access_request(member)
      end

      delete_subresources(member) unless skip_subresources
      delete_project_invitations_by(member) unless skip_subresources
      resolve_access_request_todos(member)

      after_execute(member: member, skip_saml_identity: skip_saml_identity)
    end

    def authorized?(member, destroy_bot)
      return can_destroy_bot_member?(member) if destroy_bot

      if member.request?
        return can_destroy_member_access_request?(member) || can_withdraw_member_access_request?(member)
      end

      can_destroy_member?(member)
    end

    def delete_subresources(member)
      return unless member.is_a?(GroupMember) && member.user && member.group

      delete_project_members(member)
      delete_subgroup_members(member)
      delete_invited_members(member)
    end

    def delete_project_members(member)
      groups = member.group.self_and_descendants

      destroy_project_members(ProjectMember.in_namespaces(groups).with_user(member.user))
    end

    def delete_subgroup_members(member)
      groups = member.group.descendants

      destroy_group_members(GroupMember.of_groups(groups).with_user(member.user))
    end

    def delete_invited_members(member)
      groups = member.group.self_and_descendants

      destroy_group_members(GroupMember.of_groups(groups).not_accepted_invitations_by_user(member.user))

      destroy_project_members(ProjectMember.in_namespaces(groups).not_accepted_invitations_by_user(member.user))
    end

    def destroy_project_members(members)
      members.each do |project_member|
        service = self.class.new(current_user)
        service.mark_as_recursive_call
        service.execute(project_member, skip_authorization: @skip_auth)
      end
    end

    def destroy_group_members(members)
      members.each do |group_member|
        service = self.class.new(current_user)
        service.mark_as_recursive_call
        service.execute(group_member, skip_authorization: @skip_auth, skip_subresources: true)
      end
    end

    def delete_project_invitations_by(member)
      return unless member.is_a?(ProjectMember) && member.user && member.project

      members_to_delete = member.project.members.not_accepted_invitations_by_user(member.user)
      destroy_project_members(members_to_delete)
    end

    def can_destroy_member?(member)
      can?(current_user, destroy_member_permission(member), member)
    end

    def can_destroy_bot_member?(member)
      can?(current_user, destroy_bot_member_permission(member), member)
    end

    def can_destroy_member_access_request?(member)
      can?(current_user, :admin_member_access_request, member.source)
    end

    def can_withdraw_member_access_request?(member)
      can?(current_user, :withdraw_member_access_request, member)
    end

    def destroying_member_with_owner_access_level?(member)
      member.owner?
    end

    def destroy_member_permission(member)
      case member
      when GroupMember
        :destroy_group_member
      when ProjectMember
        :destroy_project_member
      else
        raise ""Unknown member type: #{member}!""
      end
    end

    def destroy_bot_member_permission(member)
      raise ""Unsupported bot member type: #{member}"" unless member.is_a?(ProjectMember)

      :destroy_project_bot_member
    end

    def enqueue_unassign_issuables(member)
      source_type = member.is_a?(GroupMember) ? 'Group' : 'Project'

      member.run_after_commit_or_now do
        MembersDestroyer::UnassignIssuablesWorker.perform_async(member.user_id, member.source_id, source_type)
      end
    end
  end
end

Members::DestroyService.prepend_mod_with('Members::DestroyService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Members::DestroyService, feature_category: :groups_and_projects do
  let(:current_user) { create(:user) }
  let(:member_user) { create(:user) }
  let(:group) { create(:group, :public) }
  let(:group_project) { create(:project, :public, group: group) }
  let(:opts) { {} }

  shared_examples 'a service raising ActiveRecord::RecordNotFound' do
    it 'raises ActiveRecord::RecordNotFound' do
      expect { described_class.new(current_user).execute(member) }.to raise_error(ActiveRecord::RecordNotFound)
    end
  end

  shared_examples 'a service raising Gitlab::Access::AccessDeniedError' do
    it 'raises Gitlab::Access::AccessDeniedError' do
      expect { described_class.new(current_user).execute(member) }.to raise_error(Gitlab::Access::AccessDeniedError)
    end
  end

  shared_examples 'a service destroying a member' do
    before do
      type = member.is_a?(GroupMember) ? 'Group' : 'Project'
      expect(TodosDestroyer::EntityLeaveWorker).to receive(:perform_in).with(Todo::WAIT_FOR_DELETE, member.user_id, member.source_id, type)
      expect(MembersDestroyer::UnassignIssuablesWorker).to receive(:perform_async).with(member.user_id, member.source_id, type) if opts[:unassign_issuables]
    end

    it 'destroys the member' do
      expect { described_class.new(current_user).execute(member, **opts) }.to change { member.source.members_and_requesters.count }.by(-1)
    end

    it 'destroys member notification_settings' do
      if member_user.notification_settings.any?
        expect { described_class.new(current_user).execute(member, **opts) }
          .to change { member_user.notification_settings.count }.by(-1)
      else
        expect { described_class.new(current_user).execute(member, **opts) }
          .not_to change { member_user.notification_settings.count }
      end
    end

    it 'resolves the access request todos for the owner' do
      expect_next_instance_of(described_class) do |instance|
        expect(instance).to receive(:resolve_access_request_todos).with(member)
      end

      described_class.new(current_user).execute(member, **opts)
    end
  end

  shared_examples 'a service destroying a member with access' do
    it_behaves_like 'a service destroying a member'

    it 'invalidates cached counts for assigned issues and merge requests', :aggregate_failures, :sidekiq_might_not_need_inline do
      create(:issue, project: group_project, assignees: [member_user])
      create(:merge_request, source_project: group_project, assignees: [member_user])
      create(:todo, :pending, project: group_project, user: member_user)
      create(:todo, :done, project: group_project, user: member_user)

      expect(member_user.assigned_open_merge_requests_count).to be(1)
      expect(member_user.assigned_open_issues_count).to be(1)
      expect(member_user.todos_pending_count).to be(1)
      expect(member_user.todos_done_count).to be(1)

      service = described_class.new(current_user)

      if opts[:unassign_issuables]
        expect(service).to receive(:enqueue_unassign_issuables).with(member)
      end

      service.execute(member, **opts)

      expect(member_user.assigned_open_merge_requests_count).to be(0)
      expect(member_user.assigned_open_issues_count).to be(0)
      expect(member_user.todos_pending_count).to be(0)
      expect(member_user.todos_done_count).to be(0)

      unless opts[:unassign_issuables]
        expect(member_user.assigned_merge_requests.opened.count).to be(1)
        expect(member_user.assigned_issues.opened.count).to be(1)
      end
    end
  end

  shared_examples 'a service destroying an access request of another user' do
    it_behaves_like 'a service destroying a member'

    it 'calls Member#after_decline_request' do
      expect_any_instance_of(NotificationService).to receive(:decline_access_request).with(member)

      described_class.new(current_user).execute(member, **opts)
    end
  end

  shared_examples 'a service destroying an access request of self' do
    it_behaves_like 'a service destroying a member'

    context 'when current user is the member' do
      it 'does not call Member#after_decline_request' do
        expect_any_instance_of(NotificationService).not_to receive(:decline_access_request).with(member)

        described_class.new(current_user).execute(member, **opts)
      end
    end
  end

  context 'With ExclusiveLeaseHelpers' do
    include ExclusiveLeaseHelpers

    let(:lock_key) do
      ""delete_members:#{member_to_delete.source.class}:#{member_to_delete.source.id}""
    end

    let(:timeout) { 1.minute }
    let(:service_object) { described_class.new(current_user) }

    subject(:destroy_member) { service_object.execute(member_to_delete, **opts) }

    context 'for group members' do
      before do
        group.add_owner(current_user)
      end

      context 'deleting group owners' do
        let!(:member_to_delete) { group.add_owner(member_user) }

        context 'locking to avoid race conditions' do
          it 'tries to perform the delete within a lock' do
            expect_to_obtain_exclusive_lease(lock_key, timeout: timeout)

            destroy_member
          end

          context 'based on status of the lock' do
            context 'when lock is obtained' do
              it 'destroys the membership' do
                expect_to_obtain_exclusive_lease(lock_key, timeout: timeout)

                expect { destroy_member }.to change { group.members.count }.by(-1)
              end
            end

            context 'when the lock cannot be obtained' do
              before do
                stub_exclusive_lease_taken(lock_key, timeout: timeout)
              end

              it 'raises error' do
                expect { destroy_member }.to raise_error(Gitlab::ExclusiveLeaseHelpers::FailedToObtainLockError)
              end
            end
          end
        end
      end

      context 'deleting group members that are not owners' do
        let!(:member_to_delete) { group.add_developer(member_user) }

        it 'does not try to perform the deletion of the member within a lock' do
          # We need to account for other places involved in the Member deletion process that
          # uses ExclusiveLease.

          # 1. `UpdateHighestRole` concern uses locks to peform work
          # whenever a Member is committed, so that needs to be accounted for.
          lock_key_for_update_highest_role = ""update_highest_role:#{member_to_delete.user_id}""

          expect(Gitlab::ExclusiveLease)
            .to receive(:new).with(lock_key_for_update_highest_role, timeout: 10.minutes.to_i).and_call_original

          # 2. `Users::RefreshAuthorizedProjectsService` also uses locks to perform work,
          # whenever a user's authorizations has to be refreshed, so that needs to be accounted for as well.
          lock_key_for_authorizations_refresh = ""refresh_authorized_projects:#{member_to_delete.user_id}""

          expect(Gitlab::ExclusiveLease)
            .to receive(:new).with(lock_key_for_authorizations_refresh, timeout: 1.minute.to_i).and_call_original

          # We do not use any locks for the member deletion process, from within this service.
          expect(Gitlab::ExclusiveLease)
            .not_to receive(:new).with(lock_key, timeout: timeout)

          destroy_member
        end

        it 'destroys the membership' do
          expect { destroy_member }.to change { group.members.count }.by(-1)
        end
      end
    end

    context 'for project members' do
      shared_examples_for 'deletes the project member without using a lock' do
        it 'does not try to perform the deletion of a project member within a lock' do
          # We need to account for other places involved in the Member deletion process that
          # uses ExclusiveLease.

          # 1. `UpdateHighestRole` concern uses locks to peform work
          # whenever a Member is committed, so that needs to be accounted for.
          lock_key_for_update_highest_role = ""update_highest_role:#{member_to_delete.user_id}""

          expect(Gitlab::ExclusiveLease)
            .to receive(:new).with(lock_key_for_update_highest_role, timeout: 10.minutes.to_i).and_call_original

          # 2. `AuthorizedProjectUpdate::ProjectRecalculatePerUserWorker` also uses locks to perform work,
          # whenever a user's authorizations has to be refreshed, so that needs to be accounted for as well.
          lock_key_for_authorizations_refresh =
            ""authorized_project_update/project_recalculate_worker/projects/#{member_to_delete.project.id}""

          expect(Gitlab::ExclusiveLease)
            .to receive(:new).with(lock_key_for_authorizations_refresh, timeout: 10.seconds).and_call_original

          # We do not use any locks for the member deletion process, from within this service.
          expect(Gitlab::ExclusiveLease)
            .not_to receive(:new).with(lock_key, timeout: timeout)

          destroy_member
        end

        it 'destroys the membership' do
          expect { destroy_member }.to change { entity.members.count }.by(-1)
        end
      end

      before do
        group_project.add_owner(current_user)
      end

      context 'deleting project owners' do
        context 'deleting project owners' do
          let!(:member_to_delete) { entity.add_owner(member_user) }

          it_behaves_like 'deletes the project member without using a lock' do
            let(:entity) { group_project }
          end
        end
      end

      context 'deleting project members that are not owners' do
        let!(:member_to_delete) { group_project.add_developer(member_user) }

        it_behaves_like 'deletes the project member without using a lock' do
          let(:entity) { group_project }
        end
      end
    end
  end

  context 'with a member with access' do
    before do
      group_project.update_attribute(:visibility_level, Gitlab::VisibilityLevel::PRIVATE)
      group.update_attribute(:visibility_level, Gitlab::VisibilityLevel::PRIVATE)
    end

    context 'when current user cannot destroy the given member' do
      context 'with a project member' do
        let(:member) { group_project.members.find_by(user_id: member_user.id) }

        context 'when current user does not have any membership management permissions' do
          before do
            group_project.add_developer(member_user)
          end

          it_behaves_like 'a service raising Gitlab::Access::AccessDeniedError'

          context 'when skipping authorisation' do
            it_behaves_like 'a service destroying a member with access' do
              let(:opts) { { skip_authorization: true, unassign_issuables: true } }
            end
          end
        end

        context 'when a project maintainer tries to destroy a project owner' do
          before do
            group_project.add_owner(member_user)
          end

          it_behaves_like 'a service raising Gitlab::Access::AccessDeniedError'

          context 'when skipping authorisation' do
            it_behaves_like 'a service destroying a member with access' do
              let(:opts) { { skip_authorization: true, unassign_issuables: true } }
            end
          end
        end
      end
    end

    context 'with a group member' do
      let(:member) { group.members.find_by(user_id: member_user.id) }

      before do
        group.add_developer(member_user)
      end

      it_behaves_like 'a service raising Gitlab::Access::AccessDeniedError'

      context 'when skipping authorisation' do
        it_behaves_like 'a service destroying a member with access' do
          let(:opts) { { skip_authorization: true, unassign_issuables: true } }
        end
      end
    end

    context 'when current user can destroy the given member' do
      before do
        group_project.add_maintainer(current_user)
        group.add_owner(current_user)
      end

      context 'with a project member' do
        let(:member) { group_project.members.find_by(user_id: member_user.id) }

        before do
          group_project.add_developer(member_user)
        end

        it_behaves_like 'a service destroying a member with access'

        context 'unassign issuables' do
          it_behaves_like 'a service destroying a member with access' do
            let(:opts) { { unassign_issuables: true } }
          end
        end
      end

      context 'with a project bot member' do
        let(:member) { group_project.members.find_by(user_id: member_user.id) }
        let(:member_user) { create(:user, :project_bot) }

        before do
          group_project.add_maintainer(member_user)
        end

        context 'when the destroy_bot flag is true' do
          it_behaves_like 'a service destroying a member with access' do
            let(:opts) { { destroy_bot: true } }
          end
        end

        context 'when the destroy_bot flag is not specified' do
          it_behaves_like 'a service raising Gitlab::Access::AccessDeniedError'
        end
      end

      context 'with a group member' do
        let(:member) { group.members.find_by(user_id: member_user.id) }

        before do
          group.add_developer(member_user)
        end

        it_behaves_like 'a service destroying a member with access'

        context 'unassign issuables' do
          it_behaves_like 'a service destroying a member with access' do
            let(:opts) { { unassign_issuables: true } }
          end
        end
      end
    end
  end

  context 'with an access requester' do
    before do
      group_project.update!(request_access_enabled: true)
      group.update!(request_access_enabled: true)
      group_project.request_access(member_user)
      group.request_access(member_user)
    end

    context 'when current user cannot destroy the given access requester' do
      it_behaves_like 'a service raising Gitlab::Access::AccessDeniedError' do
        let(:member) { group_project.requesters.find_by(user_id: member_user.id) }
      end

      it_behaves_like 'a service destroying a member' do
        let(:opts) { { skip_authorization: true, skip_subresources: true } }
        let(:member) { group_project.requesters.find_by(user_id: member_user.id) }
      end

      it_behaves_like 'a service raising Gitlab::Access::AccessDeniedError' do
        let(:member) { group.requesters.find_by(user_id: member_user.id) }
      end

      it_behaves_like 'a service destroying a member' do
        let(:opts) { { skip_authorization: true, skip_subresources: true } }
        let(:member) { group.requesters.find_by(user_id: member_user.id) }
      end
    end

    context 'when current user can destroy the given access requester' do
      let(:opts) { { skip_subresources: true } }

      before do
        group_project.add_maintainer(current_user)
        group.add_owner(current_user)
      end

      it_behaves_like 'a service destroying an access request of another user' do
        let(:member) { group_project.requesters.find_by(user_id: member_user.id) }
      end

      it_behaves_like 'a service destroying an access request of another user' do
        let(:member) { group.requesters.find_by(user_id: member_user.id) }
      end
    end

    context 'on withdrawing their own access request' do
      let(:opts) { { skip_subresources: true } }
      let(:current_user) { member_user }

      it_behaves_like 'a service destroying an access request of self' do
        let(:member) { group_project.requesters.find_by(user_id: member_user.id) }
      end

      it_behaves_like 'a service destroying an access request of self' do
        let(:member) { group.requesters.find_by(user_id: member_user.id) }
      end
    end
  end

  context 'with an invited user' do
    let(:project_invited_member) { create(:project_member, :invited, project: group_project) }
    let(:group_invited_member) { create(:group_member, :invited, group: group) }

    context 'when current user cannot destroy the given invited user' do
      it_behaves_like 'a service raising Gitlab::Access::AccessDeniedError' do
        let(:member) { project_invited_member }
      end

      it_behaves_like 'a service destroying a member' do
        let(:opts) { { skip_authorization: true } }
        let(:member) { project_invited_member }
      end

      it_behaves_like 'a service raising Gitlab::Access::AccessDeniedError' do
        let(:member) { group_invited_member }
      end

      it_behaves_like 'a service destroying a member' do
        let(:opts) { { skip_authorization: true } }
        let(:member) { group_invited_member }
      end
    end

    context 'when current user can destroy the given invited user' do
      before do
        group_project.add_maintainer(current_user)
        group.add_owner(current_user)
      end

      # Regression spec for issue: https://gitlab.com/gitlab-org/gitlab-foss/issues/32504
      it_behaves_like 'a service destroying a member' do
        let(:member) { project_invited_member }
      end

      it_behaves_like 'a service destroying a member' do
        let(:member) { group_invited_member }
      end
    end
  end

  context 'subresources' do
    let_it_be_with_reload(:user) { create(:user) }
    let_it_be_with_reload(:member_user) { create(:user) }

    let_it_be_with_reload(:group) { create(:group, :public) }
    let_it_be_with_reload(:subgroup) { create(:group, parent: group) }
    let_it_be(:private_subgroup) { create(:group, :private, parent: group, name: 'private_subgroup') }
    let_it_be(:private_subgroup_with_direct_membership) { create(:group, :private, parent: group) }
    let_it_be_with_reload(:subsubgroup) { create(:group, parent: subgroup) }

    let_it_be_with_reload(:group_project) { create(:project, :public, group: group) }
    let_it_be_with_reload(:control_project) { create(:project, :private, group: subsubgroup) }
    let_it_be_with_reload(:subsubproject) { create(:project, :public, group: subsubgroup) }

    let_it_be(:private_subgroup_project) do
      create(:project, :private, group: private_subgroup, name: 'private_subgroup_project')
    end

    let_it_be(:private_subgroup_with_direct_membership_project) do
      create(:project, :private, group: private_subgroup_with_direct_membership, name: 'private_subgroup_project')
    end

    context 'with memberships' do
      before do
        subgroup.add_developer(member_user)
        subsubgroup.add_developer(member_user)
        subsubproject.add_developer(member_user)
        group_project.add_developer(member_user)
        control_project.add_maintainer(user)
        private_subgroup_with_direct_membership.add_developer(member_user)
        group.add_owner(user)

        @group_member = create(:group_member, :developer, group: group, user: member_user)
      end

      let_it_be(:todo_in_public_group_project) do
        create(:todo, :pending,
          project: group_project,
          user: member_user,
          target: create(:issue, project: group_project)
        )
      end

      let_it_be(:mr_in_public_group_project) do
        create(:merge_request, source_project: group_project, assignees: [member_user])
      end

      let_it_be(:todo_in_private_subgroup_project) do
        create(:todo, :pending,
          project: private_subgroup_project,
          user: member_user,
          target: create(:issue, project: private_subgroup_project)
        )
      end

      let_it_be(:mr_in_private_subgroup_project) do
        create(:merge_request, source_project: private_subgroup_project, assignees: [member_user])
      end

      let_it_be(:todo_in_public_subsubgroup_project) do
        create(:todo, :pending,
          project: subsubproject,
          user: member_user,
          target: create(:issue, project: subsubproject)
        )
      end

      let_it_be(:mr_in_public_subsubgroup_project) do
        create(:merge_request, source_project: subsubproject, assignees: [member_user])
      end

      let_it_be(:todo_in_private_subgroup_with_direct_membership_project) do
        create(:todo, :pending,
          project: private_subgroup_with_direct_membership_project,
          user: member_user,
          target: create(:issue, project: private_subgroup_with_direct_membership_project)
        )
      end

      let_it_be(:mr_in_private_subgroup_with_direct_membership_project) do
        create(:merge_request,
          source_project: private_subgroup_with_direct_membership_project,
          assignees: [member_user]
        )
      end

      context 'with skipping of subresources' do
        subject(:execute_service) { described_class.new(user).execute(@group_member, skip_subresources: true) }

        before do
          execute_service
        end

        it 'removes the group membership' do
          expect(group.members.map(&:user)).not_to include(member_user)
        end

        it 'does not remove the project membership' do
          expect(group_project.members.map(&:user)).to include(member_user)
        end

        it 'does not remove the subgroup membership' do
          expect(subgroup.members.map(&:user)).to include(member_user)
        end

        it 'does not remove the subsubgroup membership' do
          expect(subsubgroup.members.map(&:user)).to include(member_user)
        end

        it 'does not remove the subsubproject membership' do
          expect(subsubproject.members.map(&:user)).to include(member_user)
        end

        it 'does not remove the user from the control project' do
          expect(control_project.members.map(&:user)).to include(user)
        end

        context 'todos', :sidekiq_inline do
          it 'removes todos for which the user no longer has access' do
            expect(member_user.todos).to include(
              todo_in_public_group_project,
              todo_in_public_subsubgroup_project,
              todo_in_private_subgroup_with_direct_membership_project
            )

            expect(member_user.todos).not_to include(todo_in_private_subgroup_project)
          end
        end

        context 'issuables', :sidekiq_inline do
          subject(:execute_service) do
            described_class.new(user).execute(@group_member, skip_subresources: true, unassign_issuables: true)
          end

          it 'removes assigned issuables, even in subresources' do
            expect(member_user.assigned_merge_requests).to be_empty
          end
        end
      end

      context 'without skipping of subresources' do
        subject(:execute_service) { described_class.new(user).execute(@group_member, skip_subresources: false) }

        before do
          execute_service
        end

        it 'removes the project membership' do
          expect(group_project.members.map(&:user)).not_to include(member_user)
        end

        it 'removes the group membership' do
          expect(group.members.map(&:user)).not_to include(member_user)
        end

        it 'removes the subgroup membership' do
          expect(subgroup.members.map(&:user)).not_to include(member_user)
        end

        it 'removes the subsubgroup membership' do
          expect(subsubgroup.members.map(&:user)).not_to include(member_user)
        end

        it 'removes the subsubproject membership' do
          expect(subsubproject.members.map(&:user)).not_to include(member_user)
        end

        it 'does not remove the user from the control project' do
          expect(control_project.members.map(&:user)).to include(user)
        end

        context 'todos', :sidekiq_inline do
          it 'removes todos for which the user no longer has access' do
            expect(member_user.todos).to include(
              todo_in_public_group_project,
              todo_in_public_subsubgroup_project
            )

            expect(member_user.todos).not_to include(
              todo_in_private_subgroup_project,
              todo_in_private_subgroup_with_direct_membership_project
            )
          end
        end

        context 'issuables', :sidekiq_inline do
          subject(:execute_service) do
            described_class.new(user).execute(@group_member, skip_subresources: false, unassign_issuables: true)
          end

          it 'removes assigned issuables' do
            expect(member_user.assigned_merge_requests).to be_empty
          end
        end
      end
    end

    context 'with invites' do
      before do
        create(:group_member, :developer, group: subsubgroup, user: member_user)
        create(:project_member, :invited, project: group_project, created_by: member_user)
        create(:group_member, :invited, group: group, created_by: member_user)
        create(:project_member, :invited, project: subsubproject, created_by: member_user)
        create(:group_member, :invited, group: subgroup, created_by: member_user)

        subsubproject.add_developer(member_user)
        control_project.add_maintainer(user)
        group.add_owner(user)

        @group_member = create(:group_member, :developer, group: group, user: member_user)
      end

      context 'with skipping of subresources' do
        before do
          described_class.new(user).execute(@group_member, skip_subresources: true)
        end

        it 'does not remove group members invited by deleted user' do
          expect(group.members.not_accepted_invitations_by_user(member_user)).not_to be_empty
        end

        it 'does not remove project members invited by deleted user' do
          expect(group_project.members.not_accepted_invitations_by_user(member_user)).not_to be_empty
        end

        it 'does not remove subgroup members invited by deleted user' do
          expect(subgroup.members.not_accepted_invitations_by_user(member_user)).not_to be_empty
        end

        it 'does not remove subproject members invited by deleted user' do
          expect(subsubproject.members.not_accepted_invitations_by_user(member_user)).not_to be_empty
        end
      end

      context 'without skipping of subresources' do
        before do
          described_class.new(user).execute(@group_member, skip_subresources: false)
        end

        it 'removes group members invited by deleted user' do
          expect(group.members.not_accepted_invitations_by_user(member_user)).to be_empty
        end

        it 'removes project members invited by deleted user' do
          expect(group_project.members.not_accepted_invitations_by_user(member_user)).to be_empty
        end

        it 'removes subgroup members invited by deleted user' do
          expect(subgroup.members.not_accepted_invitations_by_user(member_user)).to be_empty
        end

        it 'removes subproject members invited by deleted user' do
          expect(subsubproject.members.not_accepted_invitations_by_user(member_user)).to be_empty
        end
      end
    end
  end

  context 'deletion of invitations created by deleted project member' do
    let(:user) { project.first_owner }
    let(:member_user) { create(:user) }

    let(:project) { create(:project) }

    before do
      create(:project_member, :invited, project: project, created_by: member_user)

      project_member = create(:project_member, :maintainer, user: member_user, project: project)

      described_class.new(user).execute(project_member)
    end

    it 'removes project members invited by deleted user' do
      expect(project.members.not_accepted_invitations_by_user(member_user)).to be_empty
    end
  end

  describe '#mark_as_recursive_call' do
    it 'marks the instance as recursive' do
      service = described_class.new(current_user)
      service.mark_as_recursive_call

      expect(service.send(:recursive_call?)).to eq(true)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Members
  class RequestAccessService < Members::BaseService
    def execute(source)
      raise Gitlab::Access::AccessDeniedError unless can_request_access?(source)

      source.members.create(
        access_level: Gitlab::Access::DEVELOPER,
        user: current_user,
        requested_at: Time.current.utc)
    end

    private

    def can_request_access?(source)
      can?(current_user, :request_access, source)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Members::RequestAccessService, feature_category: :groups_and_projects do
  let(:user) { create(:user) }

  shared_examples 'a service raising Gitlab::Access::AccessDeniedError' do
    it 'raises Gitlab::Access::AccessDeniedError' do
      expect { described_class.new(user).execute(source) }.to raise_error(Gitlab::Access::AccessDeniedError)
    end
  end

  shared_examples 'a service creating a access request' do
    it 'succeeds' do
      expect { described_class.new(user).execute(source) }.to change { source.requesters.count }.by(1)
    end

    it 'returns a <Source>Member' do
      member = described_class.new(user).execute(source)

      expect(member).to be_a ""#{source.class}Member"".constantize
      expect(member.requested_at).to be_present
    end
  end

  context 'when source is nil' do
    it_behaves_like 'a service raising Gitlab::Access::AccessDeniedError' do
      let(:source) { nil }
    end
  end

  context 'when current user cannot request access to the project' do
    %i[project group].each do |source_type|
      it_behaves_like 'a service raising Gitlab::Access::AccessDeniedError' do
        let(:source) { create(source_type, :private) }
      end
    end
  end

  context 'when access requests are disabled' do
    %i[project group].each do |source_type|
      it_behaves_like 'a service raising Gitlab::Access::AccessDeniedError' do
        let(:source) { create(source_type, :public, :request_access_disabled) }
      end
    end
  end

  context 'when current user can request access to the project' do
    %i[project group].each do |source_type|
      it_behaves_like 'a service creating a access request' do
        let(:source) { create(source_type, :public) }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Members
  class UpdateService < Members::BaseService
    # @param members [Member, Array<Member>]
    # returns the updated member(s)
    def execute(members, permission: :update)
      members = Array.wrap(members)

      old_access_level_expiry_map = members.to_h do |member|
        [member.id, { human_access: member.human_access, expires_at: member.expires_at }]
      end

      updated_members = update_members(members, permission)
      Member.transaction do
        updated_members.each { |member| post_update(member, permission, old_access_level_expiry_map) }
      end

      prepare_response(members)
    end

    private

    def update_members(members, permission)
      # `filter_map` avoids the `post_update` call for the member that resulted in no change
      Member.transaction do
        members.filter_map { |member| update_member(member, permission) }
      end
    rescue ActiveRecord::RecordInvalid
      []
    end

    def update_member(member, permission)
      raise Gitlab::Access::AccessDeniedError unless has_update_permissions?(member, permission)

      member.attributes = params
      return unless member.changed?

      member.expiry_notified_at = nil if member.expires_at_changed?
      member.tap(&:save!)
    end

    def post_update(member, permission, old_access_level_expiry_map)
      old_access_level = old_access_level_expiry_map[member.id][:human_access]
      old_expiry = old_access_level_expiry_map[member.id][:expires_at]

      after_execute(action: permission, old_access_level: old_access_level, old_expiry: old_expiry, member: member)
      enqueue_delete_todos(member) if downgrading_to_guest? # Deletes only confidential issues todos for guests
    end

    def prepare_response(members)
      errored_members = members.select { |member| member.errors.any? }
      if errored_members.present?
        error_message = errored_members.flat_map { |member| member.errors.full_messages }.uniq.to_sentence
        return error(error_message, pass_back: { members: errored_members })
      end

      success(members: members)
    end

    def has_update_permissions?(member, permission)
      can?(current_user, action_member_permission(permission, member), member) &&
        !prevent_upgrade_to_owner?(member) &&
        !prevent_downgrade_from_owner?(member)
    end

    def downgrading_to_guest?
      params[:access_level] == Gitlab::Access::GUEST
    end

    def upgrading_to_owner?
      params[:access_level] == Gitlab::Access::OWNER
    end

    def downgrading_from_owner?(member)
      member.owner?
    end

    def prevent_upgrade_to_owner?(member)
      upgrading_to_owner? && cannot_assign_owner_responsibilities_to_member_in_project?(member)
    end

    def prevent_downgrade_from_owner?(member)
      downgrading_from_owner?(member) && cannot_revoke_owner_responsibilities_from_member_in_project?(member)
    end
  end
end

Members::UpdateService.prepend_mod_with('Members::UpdateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Members::UpdateService, feature_category: :groups_and_projects do
  let_it_be(:project) { create(:project, :public) }
  let_it_be(:group) { create(:group, :public) }
  let_it_be(:current_user) { create(:user) }
  let_it_be(:member_user1) { create(:user) }
  let_it_be(:member_user2) { create(:user) }
  let_it_be(:member_users) { [member_user1, member_user2] }
  let_it_be(:permission) { :update }
  let_it_be(:access_level) { Gitlab::Access::MAINTAINER }
  let(:members) { source.members_and_requesters.where(user_id: member_users).to_a }
  let(:update_service) { described_class.new(current_user, params) }
  let(:params) { { access_level: access_level } }
  let(:updated_members) { subject[:members] }

  before do
    member_users.first.tap do |member_user|
      expires_at = 10.days.from_now
      project.add_member(member_user, Gitlab::Access::DEVELOPER, expires_at: expires_at)
      group.add_member(member_user, Gitlab::Access::DEVELOPER, expires_at: expires_at)
    end

    member_users[1..].each do |member_user|
      project.add_developer(member_user)
      group.add_developer(member_user)
    end
  end

  shared_examples 'a service raising Gitlab::Access::AccessDeniedError' do
    it 'raises Gitlab::Access::AccessDeniedError' do
      expect { subject }
        .to raise_error(Gitlab::Access::AccessDeniedError)
    end
  end

  shared_examples 'current user cannot update the given members' do
    it_behaves_like 'a service raising Gitlab::Access::AccessDeniedError' do
      let_it_be(:source) { project }
    end

    it_behaves_like 'a service raising Gitlab::Access::AccessDeniedError' do
      let_it_be(:source) { group }
    end
  end

  shared_examples 'returns error status when params are invalid' do
    let_it_be(:params) { { expires_at: 2.days.ago } }

    specify do
      expect(subject[:status]).to eq(:error)
    end
  end

  shared_examples 'a service updating members' do
    it 'updates the members' do
      new_access_levels = updated_members.map(&:access_level)

      expect(updated_members).not_to be_empty
      expect(updated_members).to all(be_valid)
      expect(new_access_levels).to all(be access_level)
    end

    it 'returns success status' do
      expect(subject.fetch(:status)).to eq(:success)
    end

    it 'invokes after_execute with correct args' do
      members.each do |member|
        expect(update_service).to receive(:after_execute).with(
          action: permission,
          old_access_level: member.human_access,
          old_expiry: member.expires_at,
          member: member
        )
      end

      subject
    end

    it 'authorization update callback is triggered' do
      expect(members).to all(receive(:refresh_member_authorized_projects).once)

      subject
    end

    it 'does not enqueues todos for deletion' do
      members.each do |member|
        expect(TodosDestroyer::EntityLeaveWorker)
          .not_to receive(:perform_in).with(Todo::WAIT_FOR_DELETE, member.user_id, member.source_id, source.class.name)
      end

      subject
    end

    context 'when members are downgraded to guest' do
      shared_examples 'schedules to delete confidential todos' do
        it do
          members.each do |member|
            expect(TodosDestroyer::EntityLeaveWorker)
              .to receive(:perform_in)
                    .with(Todo::WAIT_FOR_DELETE, member.user_id, member.source_id, source.class.name).once
          end

          new_access_levels = updated_members.map(&:access_level)
          expect(updated_members).to all(be_valid)
          expect(new_access_levels).to all(be Gitlab::Access::GUEST)
        end
      end

      context 'with Gitlab::Access::GUEST level as a string' do
        let_it_be(:params) { { access_level: Gitlab::Access::GUEST.to_s } }

        it_behaves_like 'schedules to delete confidential todos'
      end

      context 'with Gitlab::Access::GUEST level as an integer' do
        let_it_be(:params) { { access_level: Gitlab::Access::GUEST } }

        it_behaves_like 'schedules to delete confidential todos'
      end
    end

    context 'when access_level is invalid' do
      let_it_be(:params) { { access_level: 'invalid' } }

      it 'raises an error' do
        expect { described_class.new(current_user, params) }
          .to raise_error(ArgumentError, 'invalid value for Integer(): ""invalid""')
      end
    end

    context 'when members update results in no change' do
      let(:params) { { access_level: members.first.access_level } }

      it 'does not invoke update! and post_update' do
        expect(update_service).not_to receive(:save!)
        expect(update_service).not_to receive(:post_update)

        expect(subject[:status]).to eq(:success)
      end

      it 'authorization update callback is not triggered' do
        members.each { |member| expect(member).not_to receive(:refresh_member_authorized_projects) }

        subject
      end
    end
  end

  shared_examples 'updating a project' do
    let_it_be(:group_project) { create(:project, group: create(:group)) }
    let_it_be(:source) { group_project }

    before do
      member_users.each { |member_user| group_project.add_developer(member_user) }
    end

    context 'as a project maintainer' do
      before do
        group_project.add_maintainer(current_user)
      end

      it_behaves_like 'a service updating members'

      context 'when member update results in an error' do
        it_behaves_like 'a service returning an error'
      end

      context 'and updating members to OWNER' do
        it_behaves_like 'a service raising Gitlab::Access::AccessDeniedError' do
          let_it_be(:access_level) { Gitlab::Access::OWNER }
        end
      end

      context 'and updating themselves to OWNER' do
        let(:members) { source.members_and_requesters.find_by!(user_id: current_user.id) }

        it_behaves_like 'a service raising Gitlab::Access::AccessDeniedError' do
          let_it_be(:access_level) { Gitlab::Access::OWNER }
        end
      end

      context 'and downgrading members from OWNER' do
        before do
          member_users.each { |member_user| group_project.add_owner(member_user) }
        end

        it_behaves_like 'a service raising Gitlab::Access::AccessDeniedError' do
          let_it_be(:access_level) { Gitlab::Access::MAINTAINER }
        end
      end
    end

    context 'when current_user is considered an owner in the project via inheritance' do
      before do
        group_project.group.add_owner(current_user)
      end

      context 'and can update members to OWNER' do
        before do
          member_users.each { |member_user| group_project.add_developer(member_user) }
        end

        it_behaves_like 'a service updating members' do
          let_it_be(:access_level) { Gitlab::Access::OWNER }
        end
      end

      context 'and can downgrade members from OWNER' do
        before do
          member_users.each { |member_user| group_project.add_owner(member_user) }
        end

        it_behaves_like 'a service updating members' do
          let_it_be(:access_level) { Gitlab::Access::MAINTAINER }
        end
      end
    end

    context 'when project members expiration date is updated with expiry_notified_at' do
      let_it_be(:params) { { expires_at: 20.days.from_now } }

      before do
        group_project.group.add_owner(current_user)
        members.each do |member|
          member.update!(expiry_notified_at: Date.today)
        end
      end

      it ""clear expiry_notified_at"" do
        subject

        members.each do |member|
          expect(member.reload.expiry_notified_at).to be_nil
        end
      end
    end
  end

  shared_examples 'updating a group' do
    let_it_be(:source) { group }

    before do
      group.add_owner(current_user)
    end

    it_behaves_like 'a service updating members'

    context 'when member update results in an error' do
      it_behaves_like 'a service returning an error'
    end

    context 'when group members expiration date is updated' do
      let_it_be(:params) { { expires_at: 20.days.from_now } }
      let(:notification_service) { instance_double(NotificationService) }

      before do
        allow(NotificationService).to receive(:new).and_return(notification_service)
      end

      it 'emails the users that their group membership expiry has changed' do
        members.each do |member|
          expect(notification_service).to receive(:updated_group_member_expiration).with(member)
        end

        subject
      end
    end

    context 'when group members expiration date is updated with expiry_notified_at' do
      let_it_be(:params) { { expires_at: 20.days.from_now } }

      before do
        members.each do |member|
          member.update!(expiry_notified_at: Date.today)
        end
      end

      it ""clear expiry_notified_at"" do
        subject

        members.each do |member|
          expect(member.reload.expiry_notified_at).to be_nil
        end
      end
    end
  end

  subject { update_service.execute(members, permission: permission) }

  shared_examples 'a service returning an error' do
    it_behaves_like 'returns error status when params are invalid'

    context 'when a member update results in invalid record' do
      let(:member2) { members.second }

      before do
        allow(member2).to receive(:save!) do
          member2.errors.add(:user_id)
          member2.errors.add(:access_level)
        end.and_raise(ActiveRecord::RecordInvalid)
      end

      it 'returns the error' do
        response = subject

        expect(response[:status]).to eq(:error)
        expect(response[:message]).to eq('User is invalid and Access level is invalid')
      end

      it 'rollbacks back the entire update' do
        old_access_levels = members.pluck(:access_level)

        subject

        expect(members.each(&:reset).pluck(:access_level)).to eq(old_access_levels)
      end
    end
  end

  it_behaves_like 'current user cannot update the given members'
  it_behaves_like 'updating a project'
  it_behaves_like 'updating a group'

  context 'with a single member' do
    let(:members) { create(:group_member, group: group) }

    before do
      group.add_owner(current_user)
    end

    it 'returns the correct response' do
      expect(subject[:members]).to contain_exactly(members)
    end
  end

  context 'when current user is an admin', :enable_admin_mode do
    let_it_be(:current_user) { create(:admin) }
    let_it_be(:source) { group }

    context 'when all owners are being downgraded' do
      before do
        member_users.each { |member_user| group.add_owner(member_user) }
      end

      it_behaves_like 'a service raising Gitlab::Access::AccessDeniedError'
    end

    context 'when all blocked owners are being downgraded' do
      before do
        member_users.each do |member_user|
          group.add_owner(member_user)
          member_user.block
        end
      end

      it_behaves_like 'a service raising Gitlab::Access::AccessDeniedError'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Members
  class CreateService < Members::BaseService
    BlankInvitesError = Class.new(StandardError)
    TooManyInvitesError = Class.new(StandardError)
    MembershipLockedError = Class.new(StandardError)

    DEFAULT_INVITE_LIMIT = 100

    attr_reader :membership_locked

    def initialize(*args)
      super

      @errors = []
      @invites = invites_from_params
      @source = params[:source]
    end

    def execute
      raise Gitlab::Access::AccessDeniedError unless can?(current_user, create_member_permission(source), source)

      if adding_at_least_one_owner && cannot_assign_owner_responsibilities_to_member_in_project?
        raise Gitlab::Access::AccessDeniedError
      end

      validate_invite_source!
      validate_invitable!

      add_members
      after_add_hooks

      enqueue_onboarding_progress_action

      publish_event!

      result
    rescue BlankInvitesError, TooManyInvitesError, MembershipLockedError => e
      Gitlab::ErrorTracking.log_exception(e, class: self.class.to_s, user_id: current_user.id)
      error(e.message)
    end

    def single_member
      members.last
    end

    private

    attr_reader :source, :errors, :invites, :member_created_namespace_id, :members

    def adding_at_least_one_owner
      params[:access_level] == Gitlab::Access::OWNER
    end

    def cannot_assign_owner_responsibilities_to_member_in_project?
      source.is_a?(Project) && !current_user.can?(:manage_owners, source)
    end

    def invites_from_params
      # String, Nil, Array, Integer
      return params[:user_id] if params[:user_id].is_a?(Array)
      return [] unless params[:user_id]

      params[:user_id].to_s.split(',').uniq
    end

    def validate_invite_source!
      raise ArgumentError, s_('AddMember|No invite source provided.') unless invite_source.present?
    end

    def validate_invitable!
      raise BlankInvitesError, blank_invites_message if invites.blank?

      return unless user_limit && invites.size > user_limit

      message = format(s_(""AddMember|Too many users specified (limit is %{user_limit})""), user_limit: user_limit)
      raise TooManyInvitesError, message
    end

    def blank_invites_message
      s_('AddMember|No users specified.')
    end

    def add_members
      @members = creator_service.add_members(
        source, invites, params[:access_level], **create_params
      )

      members.each { |member| process_result(member) }
    end

    def creator_service
      ""Members::#{source.class.to_s.pluralize}::CreatorService"".constantize
    end

    def create_params
      {
        expires_at: params[:expires_at],
        current_user: current_user
      }
    end

    def process_result(member)
      existing_errors = member.errors.full_messages

      # calling invalid? clears any errors that were added outside of the
      # rails validation process
      if member.invalid? || existing_errors.present?
        add_error_for_member(member, existing_errors)
      else
        after_execute(member: member)
        @member_created_namespace_id ||= member.namespace_id
      end
    end

    # overridden
    def add_error_for_member(member, existing_errors)
      prefix = ""#{member.user.username}: "" if member.user.present?

      errors << ""#{prefix}#{all_member_errors(member, existing_errors).to_sentence}""
    end

    def all_member_errors(member, existing_errors)
      existing_errors.concat(member.errors.full_messages).uniq
    end

    def after_add_hooks
      # overridden in subclasses/ee
    end

    def after_execute(member:)
      super

      track_invite_source(member)
    end

    def track_invite_source(member)
      Gitlab::Tracking.event(
        self.class.name,
        'create_member',
        label: invite_source,
        property: tracking_property(member),
        user: current_user
      )
    end

    def invite_source
      params[:invite_source]
    end

    def tracking_property(member)
      # ideally invites go down the invite service class instead, but there is nothing that limits an invite
      # from being used in this class and if you send emails as a comma separated list to the api/members
      # endpoint, it will support invites
      member.invite? ? 'net_new_user' : 'existing_user'
    end

    def user_limit
      limit = params.fetch(:limit, DEFAULT_INVITE_LIMIT)

      limit && limit < 0 ? nil : limit
    end

    def enqueue_onboarding_progress_action
      return unless at_least_one_member_created?

      Onboarding::UserAddedWorker.perform_async(member_created_namespace_id)
    end

    def at_least_one_member_created?
      member_created_namespace_id.present?
    end

    def result
      if errors.any?
        error(formatted_errors)
      else
        success
      end
    end

    def formatted_errors
      errors.to_sentence
    end

    def publish_event!
      return unless at_least_one_member_created?

      Gitlab::EventStore.publish(
        Members::MembersAddedEvent.new(data: {
          source_id: source.id,
          source_type: source.class.name
        })
      )
    end

    def create_member_permission(source)
      case source
      when Group
        :admin_group_member
      when Project
        :admin_project_member
      else
        raise ""Unknown source type: #{source.class}!""
      end
    end
  end
end

Members::CreateService.prepend_mod_with('Members::CreateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Members::CreateService, :aggregate_failures, :clean_gitlab_redis_cache, :clean_gitlab_redis_shared_state, :sidekiq_inline,
  feature_category: :groups_and_projects do
  let_it_be(:source, reload: true) { create(:project) }
  let_it_be(:user) { create(:user) }
  let_it_be(:member) { create(:user) }
  let_it_be(:user_invited_by_id) { create(:user) }
  let_it_be(:user_id) { member.id.to_s }
  let_it_be(:access_level) { Gitlab::Access::GUEST }

  let(:additional_params) { { invite_source: '_invite_source_' } }
  let(:params) { { user_id: user_id, access_level: access_level }.merge(additional_params) }
  let(:current_user) { user }

  subject(:execute_service) { described_class.new(current_user, params.merge({ source: source })).execute }

  before do
    case source
    when Project
      source.add_maintainer(user)
      Onboarding::Progress.onboard(source.namespace)
    when Group
      source.add_owner(user)
      Onboarding::Progress.onboard(source)
    end
  end

  context 'when the current user does not have permission to create members' do
    let(:current_user) { create(:user) }

    it 'raises a Gitlab::Access::AccessDeniedError' do
      expect { execute_service }.to raise_error(Gitlab::Access::AccessDeniedError)
    end

    context 'when a project maintainer attempts to add owners' do
      let(:access_level) { Gitlab::Access::OWNER }

      before do
        source.add_maintainer(current_user)
      end

      it 'raises a Gitlab::Access::AccessDeniedError' do
        expect { execute_service }.to raise_error(Gitlab::Access::AccessDeniedError)
      end
    end
  end

  context 'when passing an invalid source' do
    let_it_be(:source) { Object.new }

    it 'raises a RuntimeError' do
      expect { execute_service }.to raise_error(RuntimeError, 'Unknown source type: Object!')
    end
  end

  context 'when passing valid parameters' do
    it 'adds a user to members' do
      expect(execute_service[:status]).to eq(:success)
      expect(source.users).to include member
      expect(Onboarding::Progress.completed?(source.namespace, :user_added)).to be(true)
    end

    context 'when user_id is passed as an integer' do
      let(:user_id) { member.id }

      it 'successfully creates member' do
        expect(execute_service[:status]).to eq(:success)
        expect(source.users).to include member
        expect(Onboarding::Progress.completed?(source.namespace, :user_added)).to be(true)
      end
    end

    context 'with user_id as an array of integers' do
      let(:user_id) { [member.id, user_invited_by_id.id] }

      it 'successfully creates members' do
        expect(execute_service[:status]).to eq(:success)
        expect(source.users).to include(member, user_invited_by_id)
        expect(Onboarding::Progress.completed?(source.namespace, :user_added)).to be(true)
      end
    end

    context 'with user_id as an array of strings' do
      let(:user_id) { [member.id.to_s, user_invited_by_id.id.to_s] }

      it 'successfully creates members' do
        expect(execute_service[:status]).to eq(:success)
        expect(source.users).to include(member, user_invited_by_id)
        expect(Onboarding::Progress.completed?(source.namespace, :user_added)).to be(true)
      end
    end

    context 'when executing on a group' do
      let_it_be(:source) { create(:group) }

      it 'adds a user to members' do
        expect(execute_service[:status]).to eq(:success)
        expect(source.users).to include member
        expect(Onboarding::Progress.completed?(source, :user_added)).to be(true)
      end

      it 'triggers a members added event' do
        expect(Gitlab::EventStore)
          .to receive(:publish)
          .with(an_instance_of(Members::MembersAddedEvent))
          .and_call_original

        expect(execute_service[:status]).to eq(:success)
      end
    end

    context 'when only one user fails validations' do
      let_it_be(:source) { create(:project, group: create(:group)) }
      let(:user_id) { [member.id, user_invited_by_id.id] }

      before do
        # validations will fail because we try to invite them to the project as a guest
        source.group.add_developer(member)
      end

      it 'triggers the members added and authorizations changed events' do
        expect(Gitlab::EventStore)
          .to receive(:publish)
                .with(an_instance_of(ProjectAuthorizations::AuthorizationsChangedEvent))
                .and_call_original

        expect(Gitlab::EventStore)
          .to receive(:publish)
          .with(an_instance_of(Members::MembersAddedEvent))
          .and_call_original

        expect(execute_service[:status]).to eq(:error)
        expect(execute_service[:message])
          .to include 'Access level should be greater than or equal to Developer inherited membership from group'
        expect(source.users).not_to include(member)
        expect(source.users).to include(user_invited_by_id)
      end
    end

    context 'when all users fail validations' do
      let_it_be(:source) { create(:project, group: create(:group)) }
      let(:user_id) { [member.id, user_invited_by_id.id] }

      before do
        # validations will fail because we try to invite them to the project as a guest
        source.group.add_developer(member)
        source.group.add_developer(user_invited_by_id)
      end

      it 'does not trigger the members added event' do
        expect(Gitlab::EventStore)
          .not_to receive(:publish)
          .with(an_instance_of(Members::MembersAddedEvent))

        expect(execute_service[:status]).to eq(:error)
        expect(execute_service[:message])
          .to include 'Access level should be greater than or equal to Developer inherited membership from group'
        expect(source.users).not_to include(member, user_invited_by_id)
      end
    end
  end

  context 'when passing no user ids' do
    let(:user_id) { '' }

    it 'does not add a member' do
      expect(Gitlab::ErrorTracking)
        .to receive(:log_exception)
              .with(an_instance_of(described_class::BlankInvitesError), class: described_class.to_s, user_id: user.id)
      expect(Gitlab::EventStore)
        .not_to receive(:publish)
        .with(an_instance_of(Members::MembersAddedEvent))

      expect(execute_service[:status]).to eq(:error)
      expect(execute_service[:message]).to eq(s_('AddMember|No users specified.'))
      expect(source.users).not_to include member
      expect(Onboarding::Progress.completed?(source.namespace, :user_added)).to be(false)
    end
  end

  context 'when passing many user ids' do
    let(:user_id) { 1.upto(101).to_a.join(',') }

    it 'limits the number of users to 100' do
      expect(Gitlab::ErrorTracking)
        .to receive(:log_exception)
              .with(an_instance_of(described_class::TooManyInvitesError), class: described_class.to_s, user_id: user.id)

      expect(execute_service[:status]).to eq(:error)
      expect(execute_service[:message]).to be_present
      expect(source.users).not_to include member
      expect(Onboarding::Progress.completed?(source.namespace, :user_added)).to be(false)
    end
  end

  context 'when passing an invalid access level' do
    let(:access_level) { -1 }

    it 'does not add a member' do
      expect(execute_service[:status]).to eq(:error)
      expect(execute_service[:message]).to include(""#{member.username}: Access level is not included in the list"")
      expect(source.users).not_to include member
      expect(Onboarding::Progress.completed?(source.namespace, :user_added)).to be(false)
    end
  end

  context 'when passing an existing invite user id' do
    let(:invited_member) { create(:project_member, :guest, :invited, project: source) }
    let(:user_id) { invited_member.invite_email }
    let(:access_level) { ProjectMember::MAINTAINER }

    it 'allows already invited members to be re-invited by email and updates the member access' do
      expect(execute_service[:status]).to eq(:success)
      expect(invited_member.reset.access_level).to eq ProjectMember::MAINTAINER
      expect(Onboarding::Progress.completed?(source.namespace, :user_added)).to be(true)
    end
  end

  context 'when adding a project_bot' do
    let_it_be(:project_bot) { create(:user, :project_bot) }

    let(:user_id) { project_bot.id }

    context 'when project_bot is already a member' do
      before do
        source.add_developer(project_bot)
      end

      it 'does not update the member' do
        expect(execute_service[:status]).to eq(:error)
        expect(execute_service[:message]).to eq(""#{project_bot.username}: not authorized to update member"")
        expect(Onboarding::Progress.completed?(source.namespace, :user_added)).to be(false)
      end
    end

    context 'when project_bot is not already a member' do
      it 'adds the member' do
        expect(execute_service[:status]).to eq(:success)
        expect(source.users).to include project_bot
        expect(Onboarding::Progress.completed?(source.namespace, :user_added)).to be(true)
      end
    end
  end

  context 'when tracking the invite source', :snowplow do
    context 'when invite_source is not passed' do
      let(:additional_params) { {} }

      it 'raises an error' do
        expect { execute_service }.to raise_error(ArgumentError, 'No invite source provided.')

        expect_no_snowplow_event
      end
    end

    context 'when invite_source is passed' do
      it 'tracks the invite source from params' do
        execute_service

        expect_snowplow_event(
          category: described_class.name,
          action: 'create_member',
          label: '_invite_source_',
          property: 'existing_user',
          user: user
        )
      end

      context 'with an already existing member' do
        before do
          source.add_developer(member)
        end

        it 'tracks the invite source from params' do
          execute_service

          expect_snowplow_event(
            category: described_class.name,
            action: 'create_member',
            label: '_invite_source_',
            property: 'existing_user',
            user: user
          )
        end
      end
    end

    context 'when it is a net_new_user' do
      let(:additional_params) { { invite_source: '_invite_source_', user_id: 'email@example.org' } }

      it 'tracks the invite source from params' do
        execute_service

        expect_snowplow_event(
          category: described_class.name,
          action: 'create_member',
          label: '_invite_source_',
          property: 'net_new_user',
          user: user
        )
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Members
  class ImportProjectTeamService < BaseService
    ImportProjectTeamForbiddenError = Class.new(StandardError)

    def initialize(*args)
      super

      @errors = {}
    end

    def execute
      check_target_and_source_projects_exist!
      check_user_permissions!

      import_project_team
      process_import_result

      result
    rescue ArgumentError, ImportProjectTeamForbiddenError => e
      ServiceResponse.error(message: e.message, reason: :unprocessable_entity)
    end

    private

    attr_reader :members, :params, :current_user, :errors, :result

    def import_project_team
      @members = target_project.team.import(source_project, current_user)

      if members.is_a?(Array)
        members.each { |member| check_member_validity(member) }
      else
        @result = ServiceResponse.error(message: 'Import failed', reason: :unprocessable_entity)
      end
    end

    def check_target_and_source_projects_exist!
      if target_project.blank?
        raise ArgumentError, 'Target project does not exist'
      elsif source_project.blank?
        raise ArgumentError, 'Source project does not exist'
      end
    end

    def check_user_permissions!
      return if can?(current_user, :read_project_member, source_project) &&
        can?(current_user, :import_project_members_from_another_project, target_project)

      raise ImportProjectTeamForbiddenError, 'Forbidden'
    end

    def check_member_validity(member)
      return if member.valid?

      errors[member.user.username] = member.errors.full_messages.to_sentence
    end

    def process_import_result
      @result ||= if errors.any?
                    ServiceResponse.error(message: errors, payload: { total_members_count: members.size })
                  else
                    ServiceResponse.success(message: 'Successfully imported')
                  end
    end

    def target_project_id
      params[:id]
    end

    def source_project_id
      params[:project_id]
    end

    def target_project
      @target_project ||= Project.find_by_id(target_project_id)
    end

    def source_project
      @source_project ||= Project.find_by_id(source_project_id)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Members::ImportProjectTeamService, feature_category: :groups_and_projects do
  describe '#execute' do
    let_it_be(:source_project) { create(:project) }
    let_it_be(:target_project) { create(:project) }
    let_it_be(:user) { create(:user) }

    let(:source_project_id) { source_project.id }
    let(:target_project_id) { target_project.id }

    subject(:import) { described_class.new(user, { id: target_project_id, project_id: source_project_id }) }

    before_all do
      source_project.add_guest(user)
      target_project.add_maintainer(user)
    end

    context 'when project team members are imported successfully' do
      it 'returns a successful response' do
        result = import.execute

        expect(result).to be_a(ServiceResponse)
        expect(result.success?).to be(true)
        expect(result.message).to eq('Successfully imported')
      end
    end

    context 'when the project team import fails' do
      context 'when the target project cannot be found' do
        let(:target_project_id) { non_existing_record_id }

        it 'returns unsuccessful response' do
          result = import.execute

          expect(result).to be_a(ServiceResponse)
          expect(result.error?).to be(true)
          expect(result.message).to eq('Target project does not exist')
          expect(result.reason).to eq(:unprocessable_entity)
        end
      end

      context 'when the source project cannot be found' do
        let(:source_project_id) { non_existing_record_id }

        it 'returns unsuccessful response' do
          result = import.execute

          expect(result).to be_a(ServiceResponse)
          expect(result.error?).to be(true)
          expect(result.message).to eq('Source project does not exist')
          expect(result.reason).to eq(:unprocessable_entity)
        end
      end

      context 'when the user doing the import does not exist' do
        let(:user) { nil }

        it 'returns unsuccessful response' do
          result = import.execute

          expect(result).to be_a(ServiceResponse)
          expect(result.error?).to be(true)
          expect(result.message).to eq('Forbidden')
          expect(result.reason).to eq(:unprocessable_entity)
        end
      end

      context 'when the user does not have permission to read the source project members' do
        let(:source_project_id) { create(:project, :private).id }

        it 'returns unsuccessful response' do
          result = import.execute

          expect(result).to be_a(ServiceResponse)
          expect(result.error?).to be(true)
          expect(result.message).to eq('Forbidden')
          expect(result.reason).to eq(:unprocessable_entity)
        end
      end

      context 'when the user does not have permission to admin the target project' do
        let(:target_project_id) { create(:project).id }

        it 'returns unsuccessful response' do
          result = import.execute

          expect(result).to be_a(ServiceResponse)
          expect(result.error?).to be(true)
          expect(result.message).to eq('Forbidden')
          expect(result.reason).to eq(:unprocessable_entity)
        end
      end

      context 'when the source and target project are valid but the ProjectTeam#import command fails' do
        before do
          allow_next_instance_of(ProjectTeam) do |project_team|
            allow(project_team).to receive(:import).and_return(false)
          end
        end

        it 'returns unsuccessful response' do
          result = import.execute

          expect(result).to be_a(ServiceResponse)
          expect(result.error?).to be(true)
          expect(result.message).to eq('Import failed')
          expect(result.reason).to eq(:unprocessable_entity)
        end
      end

      context 'when one of the imported project members is invalid' do
        it 'returns unsuccessful response' do
          project_bot = create(:user, :project_bot)
          source_project.add_developer(project_bot)

          result = import.execute

          expect(result).to be_a(ServiceResponse)
          expect(result.error?).to be(true)
          message = { project_bot.username => 'User project bots cannot be added to other groups / projects' }
          expect(result.message).to eq(message)
          expect(result.payload[:total_members_count]).to eq(2)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Members
  class ApproveAccessRequestService < Members::BaseService
    def execute(access_requester, skip_authorization: false, skip_log_audit_event: false)
      validate_access!(access_requester) unless skip_authorization

      access_requester.access_level = params[:access_level] if params[:access_level]
      access_requester.accept_request(current_user)

      after_execute(member: access_requester, skip_log_audit_event: skip_log_audit_event)

      access_requester
    end

    private

    def after_execute(member:, skip_log_audit_event:)
      super

      resolve_access_request_todos(member)
    end

    def validate_access!(access_requester)
      raise Gitlab::Access::AccessDeniedError unless can_approve_access_requester?(access_requester)

      if approving_member_with_owner_access_level?(access_requester) &&
        cannot_assign_owner_responsibilities_to_member_in_project?(access_requester)
        raise Gitlab::Access::AccessDeniedError
      end
    end

    def can_approve_access_requester?(access_requester)
      can?(current_user, :admin_member_access_request, access_requester.source)
    end

    def approving_member_with_owner_access_level?(access_requester)
      access_level_value = params[:access_level] || access_requester.access_level

      access_level_value == Gitlab::Access::OWNER
    end
  end
end

Members::ApproveAccessRequestService.prepend_mod_with('Members::ApproveAccessRequestService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Members::ApproveAccessRequestService, feature_category: :groups_and_projects do
  let(:project) { create(:project, :public) }
  let(:group) { create(:group, :public) }
  let(:current_user) { create(:user) }
  let(:access_requester_user) { create(:user) }
  let(:access_requester) { source.requesters.find_by!(user_id: access_requester_user.id) }
  let(:opts) { {} }
  let(:params) { {} }
  let(:custom_access_level) { Gitlab::Access::MAINTAINER }

  shared_examples 'a service raising Gitlab::Access::AccessDeniedError' do
    it 'raises Gitlab::Access::AccessDeniedError' do
      expect do
        described_class.new(current_user, params).execute(access_requester, **opts)
      end.to raise_error(Gitlab::Access::AccessDeniedError)
    end
  end

  shared_examples 'a service approving an access request' do
    it 'succeeds' do
      expect do
        described_class.new(current_user, params).execute(access_requester, **opts)
      end.to change { source.requesters.count }.by(-1)
    end

    it 'returns a <Source>Member' do
      member = described_class.new(current_user, params).execute(access_requester, **opts)

      expect(member).to be_a ""#{source.class}Member"".constantize
      expect(member.requested_at).to be_nil
    end

    it 'calls the method to resolve access request for the approver' do
      expect_next_instance_of(described_class) do |instance|
        expect(instance).to receive(:resolve_access_request_todos).with(access_requester)
      end

      described_class.new(current_user, params).execute(access_requester, **opts)
    end

    it 'resolves the todos for the access requests' do
      expect_next_instance_of(TodoService) do |instance|
        expect(instance).to receive(:resolve_access_request_todos).with(access_requester)
      end

      described_class.new(current_user, params).execute(access_requester, **opts)
    end

    context 'with a custom access level' do
      let(:params) { { access_level: custom_access_level } }

      it 'returns a ProjectMember with the custom access level' do
        member = described_class.new(current_user, params).execute(access_requester, **opts)

        expect(member.access_level).to eq(custom_access_level)
      end
    end
  end

  context 'when an access requester is found' do
    before do
      project.request_access(access_requester_user)
      group.request_access(access_requester_user)
    end

    context 'when current user is nil' do
      let(:user) { nil }

      context 'and :ldap option is not given' do
        it_behaves_like 'a service raising Gitlab::Access::AccessDeniedError' do
          let(:source) { project }
        end

        it_behaves_like 'a service raising Gitlab::Access::AccessDeniedError' do
          let(:source) { group }
        end
      end

      context 'and :skip_authorization option is false' do
        let(:opts) { { skip_authorization: false } }

        it_behaves_like 'a service raising Gitlab::Access::AccessDeniedError' do
          let(:source) { project }
        end

        it_behaves_like 'a service raising Gitlab::Access::AccessDeniedError' do
          let(:source) { group }
        end
      end

      context 'and :skip_authorization option is true' do
        let(:opts) { { skip_authorization: true } }

        it_behaves_like 'a service approving an access request' do
          let(:source) { project }
        end

        it_behaves_like 'a service approving an access request' do
          let(:source) { group }
        end
      end
    end

    context 'when current user cannot approve access request to the project' do
      it_behaves_like 'a service raising Gitlab::Access::AccessDeniedError' do
        let(:source) { project }
      end

      it_behaves_like 'a service raising Gitlab::Access::AccessDeniedError' do
        let(:source) { group }
      end
    end

    context 'when current user can approve access request to the project' do
      before do
        project.add_maintainer(current_user)
        group.add_owner(current_user)
      end

      it_behaves_like 'a service approving an access request' do
        let(:source) { project }
      end

      it_behaves_like 'a service approving an access request' do
        let(:source) { group }
      end
    end

    context 'in a project' do
      let_it_be(:group_project) { create(:project, :public, group: create(:group, :public)) }

      let(:source) { group_project }
      let(:custom_access_level) { Gitlab::Access::OWNER }
      let(:params) { { access_level: custom_access_level } }

      before do
        group_project.request_access(access_requester_user)
      end

      context 'maintainers' do
        before do
          group_project.add_maintainer(current_user)
        end

        context 'cannot approve the access request of a requester to give them OWNER permissions' do
          it_behaves_like 'a service raising Gitlab::Access::AccessDeniedError'
        end
      end

      context 'owners' do
        before do
          # so that `current_user` is considered an `OWNER` in the project via inheritance.
          group_project.group.add_owner(current_user)
        end

        context 'can approve the access request of a requester to give them OWNER permissions' do
          it_behaves_like 'a service approving an access request'
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Members
  module Projects
    class CreatorService < Members::CreatorService
      class << self
        def cannot_manage_owners?(source, current_user)
          !Ability.allowed?(current_user, :manage_owners, source)
        end
      end

      private

      def can_create_new_member?
        return false if assigning_project_member_with_owner_access_level? &&
          cannot_assign_owner_responsibilities_to_member_in_project?

        # This access check(`admin_project_member`) will write to safe request store cache for the user being added.
        # This means any operations inside the same request will need to purge that safe request
        # store cache if operations are needed to be done inside the same request that checks max member access again on
        # that user.
        current_user.can?(:admin_project_member, member.project) || adding_the_creator_as_owner_in_a_personal_project?
      end

      def can_update_existing_member?
        # rubocop:disable Layout/EmptyLineAfterGuardClause
        raise ::Gitlab::Access::AccessDeniedError if assigning_project_member_with_owner_access_level? &&
          cannot_assign_owner_responsibilities_to_member_in_project?
        # rubocop:enable Layout/EmptyLineAfterGuardClause

        current_user.can?(:update_project_member, member)
      end

      def adding_the_creator_as_owner_in_a_personal_project?
        # this condition is reached during testing setup a lot due to use of `.add_member`
        member.project.personal_namespace_holder?(member.user)
      end

      def assigning_project_member_with_owner_access_level?
        return true if member && member.owner?

        access_level == Gitlab::Access::OWNER
      end

      def cannot_assign_owner_responsibilities_to_member_in_project?
        member.is_a?(ProjectMember) && !current_user.can?(:manage_owners, member.source)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Members::Projects::CreatorService, feature_category: :groups_and_projects do
  let_it_be(:source, reload: true) { create(:project, :public) }
  let_it_be(:source2, reload: true) { create(:project, :public) }
  let_it_be(:user) { create(:user) }

  describe '.access_levels' do
    it 'returns Gitlab::Access.sym_options_with_owner' do
      expect(described_class.access_levels).to eq(Gitlab::Access.sym_options_with_owner)
    end
  end

  it_behaves_like 'owner management'

  describe '.add_members' do
    it_behaves_like 'bulk member creation' do
      let_it_be(:source_type) { Project }
      let_it_be(:member_type) { ProjectMember }
    end
  end

  describe '.add_member' do
    it_behaves_like 'member creation' do
      let_it_be(:member_type) { ProjectMember }
    end

    context 'authorized projects update' do
      it 'schedules a single project authorization update job when called multiple times' do
        stub_feature_flags(do_not_run_safety_net_auth_refresh_jobs: false)

        expect(AuthorizedProjectUpdate::UserRefreshFromReplicaWorker).to receive(:bulk_perform_in).once

        1.upto(3) do
          described_class.add_member(source, user, :maintainer)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Members
  module Groups
    class CreatorService < Members::CreatorService
      class << self
        def cannot_manage_owners?(source, current_user)
          source.max_member_access_for_user(current_user) < Gitlab::Access::OWNER
        end
      end

      private

      def can_create_new_member?
        current_user.can?(:admin_group_member, member.group)
      end

      def can_update_existing_member?
        current_user.can?(:update_group_member, member)
      end
    end
  end
end

Members::Groups::CreatorService.prepend_mod_with('Members::Groups::CreatorService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Members::Groups::CreatorService, feature_category: :groups_and_projects do
  let_it_be(:source, reload: true) { create(:group, :public) }
  let_it_be(:source2, reload: true) { create(:group, :public) }
  let_it_be(:user) { create(:user) }

  describe '.access_levels' do
    it 'returns Gitlab::Access.options_with_owner' do
      expect(described_class.access_levels).to eq(Gitlab::Access.sym_options_with_owner)
    end
  end

  it_behaves_like 'owner management'

  describe '.add_members' do
    it_behaves_like 'bulk member creation' do
      let_it_be(:source_type) { Group }
      let_it_be(:member_type) { GroupMember }
    end
  end

  describe '.add_member' do
    it_behaves_like 'member creation' do
      let_it_be(:member_type) { GroupMember }
    end

    context 'authorized projects update' do
      it 'schedules a single project authorization update job when called multiple times' do
        # this is inline with the overridden behaviour in stubbed_member.rb
        worker_instance = AuthorizedProjectsWorker.new
        expect(AuthorizedProjectsWorker).to receive(:new).once.and_return(worker_instance)
        expect(worker_instance).to receive(:perform).with(user.id)

        1.upto(3) do
          described_class.add_member(source, user, :maintainer)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module AlertManagement
  class ProcessPrometheusAlertService
    extend ::Gitlab::Utils::Override
    include ::AlertManagement::AlertProcessing
    include ::AlertManagement::Responses

    def initialize(project, payload, integration: nil)
      @project = project
      @payload = payload
      @integration = integration
    end

    def execute
      return bad_request unless incoming_payload.has_required_attributes?

      process_alert
      return bad_request unless alert.persisted?

      complete_post_processing_tasks

      success(alert)
    end

    private

    attr_reader :project, :payload, :integration

    override :incoming_payload
    def incoming_payload
      strong_memoize(:incoming_payload) do
        Gitlab::AlertManagement::Payload.parse(
          project,
          payload,
          integration: integration,
          monitoring_tool: Gitlab::AlertManagement::Payload::MONITORING_TOOLS[:prometheus]
        )
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe AlertManagement::ProcessPrometheusAlertService, feature_category: :incident_management do
  let_it_be(:project, reload: true) { create(:project, :repository) }

  let(:service) { described_class.new(project, payload) }

  describe '#execute' do
    include_context 'incident management settings enabled'

    subject(:execute) { service.execute }

    before do
      stub_licensed_features(oncall_schedules: false, generic_alert_fingerprinting: false)
    end

    context 'when alert payload is valid' do
      let_it_be(:starts_at) { '2020-04-27T10:10:22.265949279Z' }
      let_it_be(:title) { 'Alert title' }
      let_it_be(:fingerprint) { [starts_at, title, 'vector(1)'].join('/') }
      let_it_be(:source) { 'Prometheus' }

      let(:prometheus_status) { 'firing' }
      let(:payload) do
        {
          'status' => prometheus_status,
          'labels' => {
            'alertname' => 'GitalyFileServerDown',
            'channel' => 'gitaly',
            'pager' => 'pagerduty',
            'severity' => 's1'
          },
          'annotations' => {
            'description' => 'Alert description',
            'runbook' => 'troubleshooting/gitaly-down.md',
            'title' => title
          },
          'startsAt' => starts_at,
          'endsAt' => '2020-04-27T10:20:22.265949279Z',
          'generatorURL' => 'http://8d467bd4607a:9090/graph?g0.expr=vector%281%29&g0.tab=1'
        }
      end

      it_behaves_like 'processes new firing alert'
      include_examples 'handles race condition in alert creation'

      context 'with resolving payload' do
        let(:prometheus_status) { 'resolved' }

        it_behaves_like 'processes recovery alert'
      end

      context 'environment given' do
        let(:environment) { create(:environment, project: project) }
        let(:alert) { project.alert_management_alerts.last }

        before do
          payload['labels']['gitlab_environment_name'] = environment.name
        end

        it 'sets the environment' do
          execute

          expect(alert.environment).to eq(environment)
        end
      end
    end

    context 'when alert payload is invalid' do
      let(:payload) { {} }

      it_behaves_like 'alerts service responds with an error and takes no actions', :bad_request
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module AlertManagement
  class CreateAlertIssueService
    include Gitlab::Utils::StrongMemoize

    DEFAULT_ALERT_TITLE = ::Gitlab::AlertManagement::Payload::Generic::DEFAULT_TITLE
    DEFAULT_INCIDENT_TITLE = 'New: Incident'

    # @param alert [AlertManagement::Alert]
    # @param user [User]
    def initialize(alert, user)
      @alert = alert
      @user = user
    end

    def execute
      return error_no_permissions unless allowed?
      return error_issue_already_exists if alert.issue

      result = create_incident
      return result unless result.success?

      issue = result[:issue]
      perform_after_create_tasks(issue)

      result
    end

    private

    attr_reader :alert, :user

    delegate :project, to: :alert

    def allowed?
      user.can?(:create_issue, project)
    end

    def create_incident
      ::IncidentManagement::Incidents::CreateService.new(
        project,
        user,
        title: alert_presenter.title,
        description: alert_presenter.issue_description,
        severity: alert.severity,
        alert: alert
      ).execute
    end

    def update_title_for(issue)
      return unless issue.title == DEFAULT_ALERT_TITLE

      issue.update!(title: ""#{DEFAULT_INCIDENT_TITLE} #{issue.iid}"")
    end

    def perform_after_create_tasks(issue)
      update_title_for(issue)

      SystemNoteService.new_alert_issue(alert, issue, user)
    end

    def error(message, issue = nil)
      ServiceResponse.error(payload: { issue: issue }, message: message)
    end

    def error_issue_already_exists
      error(_('An issue already exists'))
    end

    def error_no_permissions
      error(_('You have no permissions'))
    end

    def alert_presenter
      strong_memoize(:alert_presenter) do
        alert.present
      end
    end
  end
end

AlertManagement::CreateAlertIssueService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe AlertManagement::CreateAlertIssueService, feature_category: :incident_management do
  let_it_be(:user) { create(:user) }
  let_it_be(:group) { create(:group) }
  let_it_be(:project) { create(:project, group: group) }
  let_it_be(:payload) do
    {
      'startsAt' => '2020-04-27T10:10:22.265949279Z',
      'generatorURL' => 'http://8d467bd4607a:9090/graph?g0.expr=vector%281%29&g0.tab=1'
    }
  end

  let_it_be(:generic_alert, reload: true) { create(:alert_management_alert, :triggered, project: project, payload: payload) }
  let_it_be(:prometheus_alert, reload: true) { create(:alert_management_alert, :triggered, :prometheus, project: project, payload: payload) }

  let(:alert) { generic_alert }
  let(:alert_presenter) { alert.present }
  let(:created_issue) { Issue.last! }

  describe '#execute' do
    subject(:execute) { described_class.new(alert, user).execute }

    before do
      allow(user).to receive(:can?).and_call_original
      allow(user).to receive(:can?)
        .with(:create_issue, project)
        .and_return(can_create)
    end

    shared_examples 'creating an alert issue' do
      it 'creates an issue' do
        expect { execute }.to change { project.issues.count }.by(1)
      end

      it 'returns a created issue' do
        expect(execute.payload).to eq(issue: created_issue)
      end

      it 'has a successful status' do
        expect(execute).to be_success
      end

      it 'sets alert.issue_id in the same ActiveRecord query execution' do
        execute

        expect(alert.issue_id).to eq(created_issue.id)
      end

      it 'creates a system note' do
        expect { execute }.to change { alert.reload.notes.count }.by(1)
      end
    end

    shared_examples 'setting an issue attributes' do
      before do
        execute
      end

      it 'sets issue author to the current user' do
        expect(created_issue.author).to eq(user)
      end

      it 'sets the issue title' do
        expect(created_issue.title).to eq(alert.title)
      end

      it 'sets the issue description' do
        expect(created_issue.description).to include(alert_presenter.send(:issue_summary_markdown).strip)
      end
    end

    context 'when a user is allowed to create an issue' do
      let(:can_create) { true }

      before do
        project.add_developer(user)
      end

      it 'checks permissions' do
        execute
        expect(user).to have_received(:can?).with(:create_issue, project).exactly(2).times
      end

      context 'with alert severity' do
        using RSpec::Parameterized::TableSyntax

        where(:alert_severity, :incident_severity) do
          'critical' | 'critical'
          'high'     | 'high'
          'medium'   | 'medium'
          'low'      | 'low'
          'info'     | 'unknown'
          'unknown'  | 'unknown'
        end

        with_them do
          before do
            alert.update!(severity: alert_severity)
            execute
          end

          it 'sets the correct severity level' do
            expect(created_issue.severity).to eq(incident_severity)
          end
        end
      end

      context 'when the alert is prometheus alert' do
        let(:alert) { prometheus_alert }
        let(:issue) { subject.payload[:issue] }

        it_behaves_like 'creating an alert issue'
        it_behaves_like 'setting an issue attributes'
      end

      context 'when the alert is generic' do
        let(:alert) { generic_alert }
        let(:issue) { subject.payload[:issue] }
        let(:default_alert_title) { described_class::DEFAULT_ALERT_TITLE }

        it_behaves_like 'creating an alert issue'
        it_behaves_like 'setting an issue attributes'

        context 'when alert title matches the default title exactly' do
          before do
            generic_alert.update!(title: default_alert_title)
          end

          it 'updates issue title with the IID' do
            execute

            expect(created_issue.title).to eq(""New: Incident #{created_issue.iid}"")
          end
        end

        context 'when the alert title contains the default title' do
          let(:non_default_alert_title) { ""Not #{default_alert_title}"" }

          before do
            generic_alert.update!(title: non_default_alert_title)
          end

          it 'does not change issue title' do
            execute

            expect(created_issue.title).to eq(non_default_alert_title)
          end
        end
      end

      context 'when issue cannot be created' do
        let(:alert) { generic_alert }

        before do
          # Invalid alert
          alert.update_columns(title: '')
        end

        it 'has an unsuccessful status' do
          expect(execute).to be_error
          expect(execute.errors).to contain_exactly(""Title can't be blank"")
        end
      end

      context 'when alert cannot be updated' do
        let(:alert) { create(:alert_management_alert, :with_validation_errors, :triggered, project: project, payload: payload) }

        it 'responds with error' do
          expect(execute).to be_error
          expect(execute.errors).to contain_exactly('Hosts hosts array is over 255 chars')
        end
      end

      context 'when alert already has an attached issue' do
        let!(:issue) { create(:issue, project: project) }

        before do
          alert.update!(issue_id: issue.id)
        end

        it 'does not create yet another issue' do
          expect { execute }.not_to change(Issue, :count)
        end

        it 'responds with error' do
          expect(execute).to be_error
          expect(execute.message).to eq(_('An issue already exists'))
        end
      end
    end

    context 'when a user is not allowed to create an issue' do
      let(:can_create) { false }

      it 'checks permissions' do
        execute
        expect(user).to have_received(:can?).with(:create_issue, project)
      end

      it 'responds with error' do
        expect(execute).to be_error
        expect(execute.message).to eq(_('You have no permissions'))
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module AlertManagement
  module HttpIntegrations
    class DestroyService
      # @param integration [AlertManagement::HttpIntegration]
      # @param current_user [User]
      def initialize(integration, current_user)
        @integration = integration
        @current_user = current_user
      end

      def execute
        return error_no_permissions unless allowed?
        return error_legacy_prometheus unless destroy_allowed?

        if integration.destroy
          success
        else
          error(integration.errors.full_messages.to_sentence)
        end
      end

      private

      attr_reader :integration, :current_user

      def allowed?
        current_user&.can?(:admin_operations, integration)
      end

      # Prevents downtime while migrating from Integrations::Prometheus.
      # Remove with https://gitlab.com/gitlab-org/gitlab/-/issues/409734
      def destroy_allowed?
        !(integration.legacy? && integration.prometheus?)
      end

      def error(message)
        ServiceResponse.error(message: message)
      end

      def success
        ServiceResponse.success(payload: { integration: integration })
      end

      def error_no_permissions
        error(_('You have insufficient permissions to remove this HTTP integration'))
      end

      def error_legacy_prometheus
        error(_('Legacy Prometheus integrations cannot currently be removed'))
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe AlertManagement::HttpIntegrations::DestroyService, feature_category: :incident_management do
  let_it_be(:user_with_permissions) { create(:user) }
  let_it_be(:user_without_permissions) { create(:user) }
  let_it_be(:project) { create(:project) }

  let!(:integration) { create(:alert_management_http_integration, project: project) }
  let(:current_user) { user_with_permissions }
  let(:params) { {} }
  let(:service) { described_class.new(integration, current_user) }

  before_all do
    project.add_maintainer(user_with_permissions)
  end

  describe '#execute' do
    shared_examples 'error response' do |message|
      it 'has an informative message' do
        expect(response).to be_error
        expect(response.message).to eq(message)
      end
    end

    subject(:response) { service.execute }

    context 'when the current_user is anonymous' do
      let(:current_user) { nil }

      it_behaves_like 'error response', 'You have insufficient permissions to remove this HTTP integration'
    end

    context 'when current_user does not have permission to create integrations' do
      let(:current_user) { user_without_permissions }

      it_behaves_like 'error response', 'You have insufficient permissions to remove this HTTP integration'
    end

    context 'when an error occurs during removal' do
      before do
        allow(integration).to receive(:destroy).and_return(false)
        integration.errors.add(:name, 'cannot be removed')
      end

      it_behaves_like 'error response', 'Name cannot be removed'
    end

    context 'when destroying a legacy Prometheus integration' do
      let_it_be(:existing_integration) { create(:alert_management_prometheus_integration, :legacy, project: project) }
      let!(:integration) { existing_integration }

      it_behaves_like 'error response', 'Legacy Prometheus integrations cannot currently be removed'
    end

    it 'successfully returns the integration' do
      expect(response).to be_success

      integration_result = response.payload[:integration]
      expect(integration_result).to be_a(::AlertManagement::HttpIntegration)
      expect(integration_result.name).to eq(integration.name)
      expect(integration_result.active).to eq(integration.active)
      expect(integration_result.token).to eq(integration.token)
      expect(integration_result.endpoint_identifier).to eq(integration.endpoint_identifier)

      expect { integration.reload }.to raise_error ActiveRecord::RecordNotFound
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module AlertManagement
  module HttpIntegrations
    class UpdateService < BaseService
      # @param integration [AlertManagement::HttpIntegration]
      # @param current_user [User]
      # @param params [Hash]
      def initialize(integration, current_user, params)
        @integration = integration

        super(integration.project, current_user, params)
      end

      def execute
        return error_no_permissions unless allowed?

        integration.transaction do
          if integration.update(permitted_params.merge(token_params))
            @response = success(integration)

            if type_update? && too_many_integrations?(integration)
              @response = error_multiple_integrations

              raise ActiveRecord::Rollback
            end
          else
            @response = error_on_save(integration)
          end
        end

        @response
      end

      private

      attr_reader :integration

      def token_params
        return {} unless params[:regenerate_token]

        { token: nil }
      end

      def type_update?
        params[:type_identifier].present?
      end

      def error_no_permissions
        error(_('You have insufficient permissions to update this HTTP integration'))
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe AlertManagement::HttpIntegrations::UpdateService, feature_category: :incident_management do
  let_it_be(:user_with_permissions) { create(:user) }
  let_it_be(:user_without_permissions) { create(:user) }
  let_it_be(:project) { create(:project) }
  let_it_be_with_reload(:integration) { create(:alert_management_http_integration, :inactive, project: project, name: 'Old Name') }

  let(:current_user) { user_with_permissions }
  let(:params) { {} }

  let(:service) { described_class.new(integration, current_user, params) }

  before_all do
    project.add_maintainer(user_with_permissions)
  end

  describe '#execute' do
    shared_examples 'error response' do |message|
      it 'has an informative message' do
        expect(response).to be_error
        expect(response.message).to eq(message)
      end
    end

    subject(:response) { service.execute }

    context 'when the current_user is anonymous' do
      let(:current_user) { nil }

      it_behaves_like 'error response', 'You have insufficient permissions to update this HTTP integration'
    end

    context 'when current_user does not have permission to create integrations' do
      let(:current_user) { user_without_permissions }

      it_behaves_like 'error response', 'You have insufficient permissions to update this HTTP integration'
    end

    context 'when an error occurs during update' do
      let(:params) { { name: '' } }

      it_behaves_like 'error response', ""Name can't be blank""
    end

    context 'with name param' do
      let(:params) { { name: 'New Name' } }

      it 'successfully updates the integration' do
        expect(response).to be_success
        expect(response.payload[:integration].name).to eq('New Name')
      end
    end

    context 'with active param' do
      let(:params) { { active: true } }

      it 'successfully updates the integration' do
        expect(response).to be_success
        expect(response.payload[:integration]).to be_active
      end
    end

    context 'with regenerate_token flag' do
      let(:params) { { regenerate_token: true } }

      it 'successfully updates the integration' do
        previous_token = integration.token

        expect(response).to be_success
        expect(response.payload[:integration].token).not_to eq(previous_token)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module AlertManagement
  module HttpIntegrations
    class CreateService < BaseService
      def execute
        return error_no_permissions unless allowed?

        ::AlertManagement::HttpIntegration.transaction do
          integration = project.alert_management_http_integrations.build(permitted_params)

          if integration.save
            @response = success(integration)

            if too_many_integrations?(integration)
              @response = error_multiple_integrations

              raise ActiveRecord::Rollback
            end
          else
            @response = error_on_save(integration)
          end
        end

        @response
      end

      private

      def error_no_permissions
        error(_('You have insufficient permissions to create an HTTP integration for this project'))
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe AlertManagement::HttpIntegrations::CreateService, feature_category: :incident_management do
  let_it_be(:user_with_permissions) { create(:user) }
  let_it_be(:user_without_permissions) { create(:user) }
  let_it_be_with_reload(:project) { create(:project) }

  let(:current_user) { user_with_permissions }
  let(:params) { {} }

  let(:service) { described_class.new(project, current_user, params) }

  before_all do
    project.add_maintainer(user_with_permissions)
  end

  describe '#execute' do
    shared_examples 'error response' do |message|
      it 'has an informative message' do
        expect(response).to be_error
        expect(response.message).to eq(message)
      end
    end

    subject(:response) { service.execute }

    context 'when the current_user is anonymous' do
      let(:current_user) { nil }

      it_behaves_like 'error response', 'You have insufficient permissions to create an HTTP integration for this project'
    end

    context 'when current_user does not have permission to create integrations' do
      let(:current_user) { user_without_permissions }

      it_behaves_like 'error response', 'You have insufficient permissions to create an HTTP integration for this project'
    end

    context 'when an error occurs during update' do
      it_behaves_like 'error response', ""Name can't be blank""
    end

    context 'with valid params' do
      let(:params) { { name: 'New HTTP Integration', active: true } }

      it 'successfully creates an integration' do
        expect(response).to be_success

        integration = response.payload[:integration]
        expect(integration).to be_a(::AlertManagement::HttpIntegration)
        expect(integration.name).to eq('New HTTP Integration')
        expect(integration).to be_active
        expect(integration.token).to be_present
        expect(integration.endpoint_identifier).to be_present
      end

      context 'with an existing HTTP integration' do
        let_it_be(:http_integration) { create(:alert_management_http_integration, project: project) }

        it_behaves_like 'error response', 'Multiple integrations of a single type are not supported for this project'

        context 'when creating a different type of integration' do
          let(:params) { { type_identifier: :prometheus, name: 'Prometheus' } }

          it 'is successful' do
            expect(response).to be_success
            expect(response.payload[:integration]).to be_a(::AlertManagement::HttpIntegration)
          end
        end
      end

      context 'with an existing Prometheus integration' do
        let_it_be(:http_integration) { create(:alert_management_prometheus_integration, project: project) }

        context 'when creating a different type of integration' do
          it 'is successful' do
            expect(response).to be_success
            expect(response.payload[:integration]).to be_a(::AlertManagement::HttpIntegration)
          end
        end

        context 'when creating the same time of integration' do
          let(:params) { { type_identifier: :prometheus, name: 'Prometheus' } }

          it_behaves_like 'error response', 'Multiple integrations of a single type are not supported for this project'
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module AlertManagement
  module MetricImages
    class UploadService < BaseService
      attr_reader :alert, :file, :url, :url_text, :metric

      def initialize(alert, current_user, params = {})
        super

        @alert = alert
        @file = params.fetch(:file)
        @url = params.fetch(:url, nil)
        @url_text = params.fetch(:url_text, nil)
      end

      def execute
        unless can_upload_metrics?
          return ServiceResponse.error(
            message: _(""You are not authorized to upload metric images""),
            http_status: :forbidden
          )
        end

        metric = AlertManagement::MetricImage.new(
          alert: alert,
          file: file,
          url: url,
          url_text: url_text
        )

        if metric.save
          ServiceResponse.success(payload: { metric: metric, alert: alert })
        else
          ServiceResponse.error(message: metric.errors.full_messages.join(', '), http_status: :bad_request)
        end
      end

      private

      def can_upload_metrics?
        current_user&.can?(:upload_alert_management_metric_image, alert)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe AlertManagement::MetricImages::UploadService, feature_category: :metrics do
  subject(:service) { described_class.new(alert, current_user, params) }

  let_it_be_with_refind(:project) { create(:project) }
  let_it_be_with_refind(:alert) { create(:alert_management_alert, project: project) }
  let_it_be_with_refind(:current_user) { create(:user) }

  let(:params) do
    {
      file: fixture_file_upload('spec/fixtures/rails_sample.jpg', 'image/jpg'),
      url: 'https://www.gitlab.com'
    }
  end

  describe '#execute' do
    subject { service.execute }

    shared_examples 'uploads the metric' do
      it 'uploads the metric and returns a success' do
        expect { subject }.to change(AlertManagement::MetricImage, :count).by(1)
        expect(subject.success?).to eq(true)
        expect(subject.payload).to match({ metric: instance_of(AlertManagement::MetricImage), alert: alert })
      end
    end

    shared_examples 'no metric saved, an error given' do |message|
      it 'returns an error and does not upload', :aggregate_failures do
        expect(subject.success?).to eq(false)
        expect(subject.message).to match(a_string_matching(message))
        expect(AlertManagement::MetricImage.count).to eq(0)
      end
    end

    context 'user does not have permissions' do
      it_behaves_like 'no metric saved, an error given', 'You are not authorized to upload metric images'
    end

    context 'user has permissions' do
      before_all do
        project.add_developer(current_user)
      end

      it_behaves_like 'uploads the metric'

      context 'no url given' do
        let(:params) do
          {
            file: fixture_file_upload('spec/fixtures/rails_sample.jpg', 'image/jpg')
          }
        end

        it_behaves_like 'uploads the metric'
      end

      context 'record invalid' do
        let(:params) do
          {
            file: fixture_file_upload('spec/fixtures/doc_sample.txt', 'text/plain'),
            url: 'https://www.gitlab.com'
          }
        end

        it_behaves_like 'no metric saved, an error given', /File does not have a supported extension. Only png, jpg, jpeg, gif, bmp, tiff, ico, and webp are supported/ # rubocop: disable Layout/LineLength
      end

      context 'user is guest' do
        before_all do
          project.add_guest(current_user)
        end

        it_behaves_like 'no metric saved, an error given', 'You are not authorized to upload metric images'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module AlertManagement
  module Alerts
    class UpdateService < ::BaseProjectService
      include Gitlab::Utils::StrongMemoize

      # @param alert [AlertManagement::Alert]
      # @param current_user [User]
      # @param params [Hash] Attributes of the alert
      def initialize(alert, current_user, params)
        @alert = alert
        @param_errors = []
        @status = params.delete(:status)

        super(project: alert.project, current_user: current_user, params: params)
      end

      def execute
        return error_no_permissions unless allowed?

        filter_params
        return error_invalid_params if param_errors.any?

        # Save old assignees for system notes
        old_assignees = alert.assignees.to_a

        if alert.update(params)
          handle_changes(old_assignees: old_assignees)

          success
        else
          error(alert.errors.full_messages.to_sentence)
        end
      end

      private

      attr_reader :alert, :param_errors, :status

      def allowed?
        current_user&.can?(:update_alert_management_alert, alert)
      end

      def todo_service
        strong_memoize(:todo_service) do
          TodoService.new
        end
      end

      def success
        ServiceResponse.success(payload: { alert: alert })
      end

      def error(message)
        ServiceResponse.error(payload: { alert: alert }, message: message)
      end

      def error_no_permissions
        error(_('You have no permissions'))
      end

      def error_invalid_params
        error(param_errors.to_sentence)
      end

      def add_param_error(message)
        param_errors << message
      end

      def param_errors?
        params.empty? && status.blank?
      end

      def filter_params
        param_errors << _('Please provide attributes to update') if param_errors?

        filter_status
        filter_assignees
        filter_duplicate
      end

      def handle_changes(old_assignees:)
        handle_assignement(old_assignees) if params[:assignees]
        handle_status_change if params[:status_event]
      end

      # ----- Assignee-related behavior ------
      def filter_assignees
        return if params[:assignees].nil?

        # Always take first assignee while multiple are not currently supported
        params[:assignees] = Array(params[:assignees].first)

        param_errors << _('Assignee has no permissions') if unauthorized_assignees?
      end

      def unauthorized_assignees?
        params[:assignees]&.any? { |user| !user.can?(:read_alert_management_alert, alert) }
      end

      def handle_assignement(old_assignees)
        assign_todo(old_assignees)
        add_assignee_system_note(old_assignees)
      end

      def assign_todo(old_assignees)
        todo_service.reassigned_assignable(alert, current_user, old_assignees)
      end

      def add_assignee_system_note(old_assignees)
        SystemNoteService.change_issuable_assignees(alert, project, current_user, old_assignees)
      end

      # ------ Status-related behavior -------
      def filter_status
        return unless status

        status_event = alert.status_event_for(status)

        unless status_event
          param_errors << _('Invalid status')
          return
        end

        params[:status_event] = status_event
      end

      def handle_status_change
        add_status_change_system_note
        resolve_todos if alert.resolved?
      end

      def add_status_change_system_note
        SystemNoteService.change_alert_status(alert, current_user)
      end

      def resolve_todos
        todo_service.resolve_todos_for_target(alert, current_user)
      end

      def filter_duplicate
        # Only need to check if changing to a not-resolved status
        return if params[:status_event].blank? || params[:status_event] == :resolve
        return unless alert.resolved?

        param_errors << unresolved_alert_error if duplicate_alert?
      end

      def duplicate_alert?
        return if alert.fingerprint.blank?

        unresolved_alert.present?
      end

      def unresolved_alert
        strong_memoize(:unresolved_alert) do
          AlertManagement::Alert.find_unresolved_alert(project, alert.fingerprint)
        end
      end

      def unresolved_alert_error
        _('An %{link_start}alert%{link_end} with the same fingerprint is already open. ' \
          'To change the status of this alert, resolve the linked alert.'
         ) % unresolved_alert_url_params
      end

      def unresolved_alert_url_params
        alert_path = Gitlab::Routing.url_helpers.details_project_alert_management_path(project, unresolved_alert)

        {
          link_start: '<a href=""%{url}"">'.html_safe % { url: alert_path },
          link_end: '</a>'.html_safe
        }
      end
    end
  end
end

AlertManagement::Alerts::UpdateService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe AlertManagement::Alerts::UpdateService, feature_category: :incident_management do
  let_it_be(:user_with_permissions) { create(:user) }
  let_it_be(:other_user_with_permissions) { create(:user) }
  let_it_be(:user_without_permissions) { create(:user) }
  let_it_be(:project) { create(:project) }
  let_it_be(:alert, reload: true) { create(:alert_management_alert, :triggered, project: project) }

  let(:current_user) { user_with_permissions }
  let(:params) { {} }

  let(:service) { described_class.new(alert, current_user, params) }

  before_all do
    project.add_developer(user_with_permissions)
    project.add_developer(other_user_with_permissions)
  end

  describe '#execute' do
    shared_examples 'does not add a todo' do
      specify { expect { response }.not_to change(Todo, :count) }
    end

    shared_examples 'does not add a system note' do
      specify { expect { response }.not_to change(Note, :count) }
    end

    shared_examples 'adds a system note' do |note_matcher = nil|
      specify do
        expect { response }.to change { alert.reload.notes.count }.by(1)
        expect(alert.notes.last.note).to match(note_matcher) if note_matcher
      end
    end

    shared_examples 'error response' do |message|
      it_behaves_like 'does not add a todo'
      it_behaves_like 'does not add a system note'

      it 'has an informative message' do
        expect(response).to be_error
        expect(response.message).to eq(message)
      end
    end

    subject(:response) { service.execute }

    context 'when the current_user is nil' do
      let(:current_user) { nil }

      it_behaves_like 'error response', 'You have no permissions'
    end

    context 'when current_user does not have permission to update alerts' do
      let(:current_user) { user_without_permissions }

      it_behaves_like 'error response', 'You have no permissions'
    end

    context 'when no parameters are included' do
      it_behaves_like 'error response', 'Please provide attributes to update'
    end

    context 'when an error occurs during update' do
      let(:params) { { title: nil } }

      it_behaves_like 'error response', ""Title can't be blank""
    end

    shared_examples 'title update' do
      it_behaves_like 'does not add a todo'
      it_behaves_like 'does not add a system note'

      it 'updates the attribute' do
        original_title = alert.title

        expect { response }.to change { alert.title }.from(original_title).to(expected_title)
        expect(response).to be_success
      end
    end

    context 'when a model attribute is included without assignees' do
      let(:params) { { title: 'This is an updated alert.' } }
      let(:expected_title) { params[:title] }

      it_behaves_like 'title update'
    end

    context 'when alert is resolved and another existing unresolved alert' do
      let!(:alert) { create(:alert_management_alert, :resolved, project: project) }
      let!(:existing_alert) { create(:alert_management_alert, :triggered, project: project) }

      let(:params) { { title: 'This is an updated alert.' } }
      let(:expected_title) { params[:title] }

      it_behaves_like 'title update'
    end

    context 'when assignees are included' do
      shared_examples 'adds a todo' do
        let(:assignee) { expected_assignees.first }

        specify do
          expect { response }.to change { assignee.reload.todos.count }.by(1)
          expect(assignee.todos.last.author).to eq(current_user)
        end
      end

      shared_examples 'successful assignment' do
        it_behaves_like 'adds a system note'
        it_behaves_like 'adds a todo'

        after do
          alert.assignees = []
        end

        specify do
          expect { response }.to change { alert.reload.assignees }.from([]).to(expected_assignees)
          expect(response).to be_success
        end
      end

      let(:expected_assignees) { params[:assignees] }

      context 'when the assignee is the current user' do
        let(:params) { { assignees: [current_user] } }

        it_behaves_like 'successful assignment'
      end

      context 'when the assignee has read permissions' do
        let(:params) { { assignees: [other_user_with_permissions] } }

        it_behaves_like 'successful assignment'
      end

      context 'when the assignee does not have read permissions' do
        let(:params) { { assignees: [user_without_permissions] } }

        it_behaves_like 'error response', 'Assignee has no permissions'
      end

      context 'when user is already assigned' do
        let(:params) { { assignees: [user_with_permissions] } }

        before do
          alert.assignees << user_with_permissions
        end

        it_behaves_like 'does not add a system note'
        it_behaves_like 'does not add a todo'
      end

      context 'with multiple users included' do
        let(:params) { { assignees: [user_with_permissions, user_without_permissions] } }
        let(:expected_assignees) { [user_with_permissions] }

        it_behaves_like 'successful assignment'
      end
    end

    context 'when a status is included' do
      let(:params) { { status: new_status } }
      let(:new_status) { :acknowledged }

      it 'successfully changes the status' do
        expect { response }.to change { alert.acknowledged? }.to(true)
        expect(response).to be_success
        expect(response.payload[:alert]).to eq(alert)
      end

      it_behaves_like 'adds a system note'

      context 'with unknown status' do
        let(:new_status) { :unknown_status }

        it_behaves_like 'error response', 'Invalid status'
      end

      context 'with resolving status' do
        let(:new_status) { :resolved }

        it 'changes the status' do
          expect { response }.to change { alert.resolved? }.to(true)
        end

        it ""resolves the current user's related todos"" do
          todo = create(:todo, :pending, target: alert, user: current_user, project: alert.project)

          expect { response }.to change { todo.reload.state }.from('pending').to('done')
        end
      end

      context 'with existing unresolved alert' do
        context 'with fingerprints' do
          let_it_be(:existing_alert) { create(:alert_management_alert, :triggered, fingerprint: alert.fingerprint, project: project) }

          it 'does not query for existing alerts' do
            expect(::AlertManagement::Alert).not_to receive(:find_unresolved_alert)

            response
          end

          context 'when status was resolved' do
            let_it_be(:alert) { create(:alert_management_alert, :resolved, :with_fingerprint, project: project) }
            let_it_be(:existing_alert) { create(:alert_management_alert, :triggered, fingerprint: alert.fingerprint, project: project) }

            let(:url) { Gitlab::Routing.url_helpers.details_project_alert_management_path(project, existing_alert) }
            let(:link) { ActionController::Base.helpers.link_to(_('alert'), url) }
            let(:message) do
              ""An #{link} with the same fingerprint is already open. "" \
              'To change the status of this alert, resolve the linked alert.'
            end

            it_behaves_like 'does not add a todo'
            it_behaves_like 'does not add a system note'

            it 'has an informative message' do
              expect(response).to be_error
              expect(response.message).to eq(message)
            end
          end
        end

        context 'without fingerprints' do
          let_it_be(:existing_alert) { create(:alert_management_alert, :triggered, fingerprint: alert.fingerprint, project: project) }

          it 'successfully changes the status' do
            expect { response }.to change { alert.acknowledged? }.to(true)
            expect(response).to be_success
            expect(response.payload[:alert]).to eq(alert)
          end

          it_behaves_like 'adds a system note'
        end
      end

      context 'two existing closed alerts' do
        let_it_be(:alert) { create(:alert_management_alert, :resolved, :with_fingerprint, project: project) }
        let_it_be(:existing_alert) { create(:alert_management_alert, :resolved, fingerprint: alert.fingerprint, project: project) }

        it 'successfully changes the status' do
          expect { response }.to change { alert.acknowledged? }.to(true)
          expect(response).to be_success
          expect(response.payload[:alert]).to eq(alert)
        end

        it_behaves_like 'adds a system note'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module AlertManagement
  module Alerts
    module Todo
      class CreateService
        # @param alert [AlertManagement::Alert]
        # @param current_user [User]
        def initialize(alert, current_user)
          @alert = alert
          @current_user = current_user
        end

        def execute
          return error_no_permissions unless allowed?

          todos = TodoService.new.mark_todo(alert, current_user)
          todo = todos&.first

          return error_existing_todo unless todo

          success(todo)
        end

        private

        attr_reader :alert, :current_user

        def allowed?
          current_user&.can?(:update_alert_management_alert, alert)
        end

        def error(message)
          ServiceResponse.error(payload: { alert: alert, todo: nil }, message: message)
        end

        def success(todo)
          ServiceResponse.success(payload: { alert: alert, todo: todo })
        end

        def error_no_permissions
          error(_('You have insufficient permissions to create a Todo for this alert'))
        end

        def error_existing_todo
          error(_('You already have pending todo for this alert'))
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe AlertManagement::Alerts::Todo::CreateService, feature_category: :incident_management do
  let_it_be(:user) { create(:user) }
  let_it_be(:alert) { create(:alert_management_alert) }

  let(:current_user) { user }

  describe '#execute' do
    subject(:result) { described_class.new(alert, current_user).execute }

    shared_examples 'permissions error' do
      it 'returns an error', :aggregate_failures do
        expect(result.error?).to be(true)
        expect(result.message).to eq('You have insufficient permissions to create a Todo for this alert')
        expect(result.payload[:todo]).to be(nil)
        expect(result.payload[:alert]).to be(alert)
      end
    end

    context 'when the user is anonymous' do
      let(:current_user) { nil }

      it_behaves_like 'permissions error'
    end

    context 'when the user does not have permission' do
      it_behaves_like 'permissions error'
    end

    context 'when user has permission' do
      before do
        alert.project.add_developer(user)
      end

      it 'creates a todo' do
        expect { result }.to change { Todo.count }.by(1)
      end

      it 'returns the alert and todo in the payload', :aggregate_failures do
        expect(result.success?).to be(true)
        expect(result.payload[:alert][:id]).to be(alert.id)
        expect(result.payload[:todo][:id]).to be(Todo.last.id)
      end

      context 'when the user has a marked todo for the alert' do
        let_it_be(:todo_params) do
          { project: alert.project,
            target: alert,
            user: user,
            action: Todo::MARKED }
        end

        context 'when todo is pending' do
          before_all do
            create(:todo, :pending, **todo_params)
          end

          before do
            stub_feature_flags(multiple_todos: false)
          end

          it 'does not create a todo' do
            expect { result }.not_to change { Todo.count }
          end

          it 'returns an error', :aggregate_failures do
            expect(result.error?).to be(true)
            expect(result.message).to be('You already have pending todo for this alert')
            expect(result.payload[:todo]).to be(nil)
            expect(result.payload[:alert]).to be(alert)
          end
        end

        context 'when todo is done' do
          before do
            create(:todo, :done, **todo_params)
          end

          it { expect(result.success?).to be(true) }
          it { expect { result }.to change { Todo.count }.by(1) }
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Suggestions
  class OutdateService
    def execute(merge_request)
      # rubocop: disable CodeReuse/ActiveRecord
      suggestions = merge_request.suggestions.active.includes(:note)

      suggestions.find_in_batches(batch_size: 100) do |group|
        outdatable_suggestion_ids = group.select do |suggestion|
          suggestion.outdated?(cached: false)
        end.map(&:id)

        Suggestion.where(id: outdatable_suggestion_ids).update_all(outdated: true)
      end
      # rubocop: enable CodeReuse/ActiveRecord
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Suggestions::OutdateService, feature_category: :code_suggestions do
  describe '#execute' do
    let(:merge_request) { create(:merge_request) }
    let(:project) { merge_request.target_project }
    let(:user) { merge_request.author }
    let(:file_path) { 'files/ruby/popen.rb' }
    let(:branch_name) { project.default_branch }
    let(:diff_file) { suggestion.diff_file }
    let(:position) { build_position(file_path, comment_line) }
    let(:note) do
      create(
        :diff_note_on_merge_request,
        noteable: merge_request,
        position: position,
        project: project
      )
    end

    def build_position(path, line)
      Gitlab::Diff::Position.new(
        old_path: path,
        new_path: path,
        old_line: nil,
        new_line: line,
        diff_refs: merge_request.diff_refs
      )
    end

    def commit_changes(file_path, new_content)
      params = {
        file_path: file_path,
        commit_message: ""Update File"",
        file_content: new_content,
        start_project: project,
        start_branch: project.default_branch,
        branch_name: branch_name
      }

      Files::UpdateService.new(project, user, params).execute
    end

    def update_file_line(diff_file, change_line, content)
      new_lines = diff_file.new_blob.data.lines
      new_lines[change_line..change_line] = content
      result = commit_changes(diff_file.file_path, new_lines.join)
      newrev = result[:result]

      expect(result[:status]).to eq(:success)
      expect(newrev).to be_present

      # Ensure all memoized data is cleared in order
      # to generate the new merge_request_diff.
      MergeRequest.find(merge_request.id).reload_diff(user)

      note.reload
    end

    before do
      project.add_maintainer(user)
    end

    subject { described_class.new.execute(merge_request) }

    context 'when there is a change within multi-line suggestion range' do
      let(:comment_line) { 9 }
      let(:lines_above) { 8 } # suggesting to change lines 1..9
      let(:change_line) { 2 } # line 2 is within the range
      let!(:suggestion) do
        create(:suggestion, :content_from_repo, note: note, lines_above: lines_above)
      end

      it 'updates the outdatable suggestion record' do
        update_file_line(diff_file, change_line, ""# foo\nbar\n"")

        # Make sure note is still active
        expect(note.active?).to be(true)

        expect { subject }.to change { suggestion.reload.outdated }
          .from(false).to(true)
      end
    end

    context 'when there is no change within multi-line suggestion range' do
      let(:comment_line) { 9 }
      let(:lines_above) { 3 } # suggesting to change lines 6..9
      let(:change_line) { 2 } # line 2 is not within the range
      let!(:suggestion) do
        create(:suggestion, :content_from_repo, note: note, lines_above: lines_above)
      end

      subject { described_class.new.execute(merge_request) }

      it 'does not outdates suggestion record' do
        update_file_line(diff_file, change_line, ""# foo\nbar\n"")

        # Make sure note is still active
        expect(note.active?).to be(true)

        expect { subject }.not_to change { suggestion.reload.outdated }.from(false)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Suggestions
  class ApplyService < ::BaseService
    def initialize(current_user, *suggestions, message: nil)
      @current_user = current_user
      @message = message
      @suggestion_set = Gitlab::Suggestions::SuggestionSet.new(suggestions)
    end

    def execute
      if suggestion_set.valid?
        result
      else
        error(suggestion_set.error_message)
      end
    end

    private

    attr_reader :current_user, :suggestion_set

    def result
      multi_service.execute.tap do |result|
        update_suggestions(result)
      end
    end

    def update_suggestions(result)
      return unless result[:status] == :success

      Suggestion.id_in(suggestion_set.suggestions)
        .update_all(commit_id: result[:result], applied: true)

      Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter
        .track_apply_suggestion_action(user: current_user, suggestions: suggestion_set.suggestions)
    end

    def author
      authors = suggestion_set.authors

      return unless authors.one?

      Gitlab::Git::User.from_gitlab(authors.first)
    end

    def multi_service
      params = {
        commit_message: commit_message,
        branch_name: suggestion_set.branch,
        start_branch: suggestion_set.branch,
        actions: suggestion_set.actions,
        author_name: author&.name,
        author_email: author&.email
      }

      ::Files::MultiService.new(suggestion_set.source_project, current_user, params)
    end

    def commit_message
      Gitlab::Suggestions::CommitMessage.new(current_user, suggestion_set, @message).message
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Suggestions::ApplyService, feature_category: :code_suggestions do
  include ProjectForksHelper

  def build_position(**optional_args)
    args = { old_path: ""files/ruby/popen.rb"",
             new_path: ""files/ruby/popen.rb"",
             old_line: nil,
             new_line: 9,
             diff_refs: merge_request.diff_refs,
             **optional_args }

    Gitlab::Diff::Position.new(args)
  end

  def create_suggestion(args)
    position_args = args.slice(:old_path, :new_path, :old_line, :new_line)
    content_args = args.slice(:from_content, :to_content)

    position = build_position(**position_args)

    diff_note = create(
      :diff_note_on_merge_request,
      noteable: merge_request,
      position: position,
      project: project
    )

    suggestion_args = { note: diff_note }.merge(content_args)

    create(:suggestion, :content_from_repo, suggestion_args)
  end

  def apply(suggestions, custom_message = nil)
    result = apply_service.new(user, *suggestions, message: custom_message).execute

    suggestions.map(&:reload)

    expect(result[:status]).to eq(:success)
  end

  shared_examples 'successfully creates commit and updates suggestions' do
    it 'updates the files with the new content' do
      apply(suggestions)

      suggestions.each do |suggestion|
        path = suggestion.diff_file.file_path
        blob = project.repository.blob_at_branch(merge_request.source_branch, path)

        expect(blob.data).to eq(expected_content_by_path[path.to_sym])
      end
    end

    it 'updates suggestion applied and commit_id columns' do
      expect(suggestions.map(&:applied)).to all(be false)
      expect(suggestions.map(&:commit_id)).to all(be nil)

      apply(suggestions)

      expect(suggestions.map(&:applied)).to all(be true)
      expect(suggestions.map(&:commit_id)).to all(be_present)
    end

    it 'created commit has users email and name' do
      apply(suggestions)

      commit = project.repository.commit
      author = suggestions.first.note.author

      expect(user.commit_email).not_to eq(user.email)
      expect(commit.author_email).to eq(author.commit_email_or_default)
      expect(commit.committer_email).to eq(user.commit_email)
      expect(commit.author_name).to eq(author.name)
      expect(commit.committer_name).to eq(user.name)
    end

    it 'tracks apply suggestion event' do
      expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
        .to receive(:track_apply_suggestion_action)
        .with(user: user, suggestions: suggestions)

      apply(suggestions)
    end

    context 'when a custom suggestion commit message' do
      before do
        project.update!(suggestion_commit_message: message)

        apply(suggestions)
      end

      context 'is not specified' do
        let(:message) { '' }

        it 'uses the default commit message' do
          expect(project.repository.commit.message).to(
            match(/\AApply #{suggestions.size} suggestion\(s\) to \d+ file\(s\)\z/)
          )
        end
      end

      context 'is specified' do
        let(:message) do
          'refactor: %{project_name} %{branch_name} %{username}'
        end

        it 'generates a custom commit message' do
          expect(project.repository.commit.message).to(
            eq(""refactor: Project_1 master test.user"")
          )
        end
      end
    end

    context 'with a user suggested commit message' do
      let(:message) { ""i'm a custom commit message!"" }

      it ""uses the user's commit message"" do
        apply(suggestions, message)

        expect(project.repository.commit.message).to(eq(message))
      end
    end
  end

  subject(:apply_service) { described_class }

  let_it_be(:user) do
    create(:user, :commit_email, name: 'Test User', username: 'test.user')
  end

  let(:project) do
    create(:project, :repository, path: 'project-1', name: 'Project_1')
  end

  let(:merge_request) do
    create(:merge_request,
      source_project: project, target_project: project, source_branch: 'master')
  end

  let(:position) { build_position }

  let(:diff_note) do
    create(:diff_note_on_merge_request,
      noteable: merge_request, position: position, project: project)
  end

  let(:suggestion) do
    create(:suggestion, :content_from_repo,
      note: diff_note, to_content: ""      raise RuntimeError, 'Explosion'\n      # explosion?\n"")
  end

  let(:suggestion2) do
    create_suggestion(
      to_content: ""      *** SUGGESTION CHANGE ***\n"",
      new_line: 15)
  end

  let(:suggestion3) do
    create_suggestion(
      to_content: ""      *** ANOTHER SUGGESTION CHANGE ***\n"",
      old_path: ""files/ruby/regex.rb"",
      new_path: ""files/ruby/regex.rb"",
      new_line: 22)
  end

  let(:suggestions) { [suggestion, suggestion2, suggestion3] }

  context 'patch is appliable' do
    let(:popen_content) do
      <<-CONTENT.strip_heredoc
        require 'fileutils'
        require 'open3'

        module Popen
          extend self

          def popen(cmd, path=nil)
            unless cmd.is_a?(Array)
              raise RuntimeError, 'Explosion'
              # explosion?
            end

            path ||= Dir.pwd

            vars = {
              *** SUGGESTION CHANGE ***
            }

            options = {
              chdir: path
            }

            unless File.directory?(path)
              FileUtils.mkdir_p(path)
            end

            @cmd_output = """"
            @cmd_status = 0

            Open3.popen3(vars, *cmd, options) do |stdin, stdout, stderr, wait_thr|
              @cmd_output << stdout.read
              @cmd_output << stderr.read
              @cmd_status = wait_thr.value.exitstatus
            end

            return @cmd_output, @cmd_status
          end
        end
      CONTENT
    end

    let(:regex_content) do
      <<-CONTENT.strip_heredoc
        module Gitlab
          module Regex
            extend self

            def username_regex
              default_regex
            end

            def project_name_regex
              /\\A[a-zA-Z0-9][a-zA-Z0-9_\\-\\. ]*\\z/
            end

            def name_regex
              /\\A[a-zA-Z0-9_\\-\\. ]*\\z/
            end

            def path_regex
              default_regex
            end

            def archive_formats_regex
              *** ANOTHER SUGGESTION CHANGE ***
            end

            def git_reference_regex
              # Valid git ref regex, see:
              # https://www.kernel.org/pub/software/scm/git/docs/git-check-ref-format.html
              %r{
                (?!
                   (?# doesn't begins with)
                   \\/|                    (?# rule #6)
                   (?# doesn't contain)
                   .*(?:
                      [\\\/.]\\\.|            (?# rule #1,3)
                      \\/\\/|               (?# rule #6)
                      @\\{|                (?# rule #8)
                      \\\\                  (?# rule #9)
                   )
                )
                [^\\000-\\040\\177~^:?*\\[]+  (?# rule #4-5)
                (?# doesn't end with)
                (?<!\\.lock)               (?# rule #1)
                (?<![\\/.])                (?# rule #6-7)
              }x
            end

            protected

            def default_regex
              /\\A[.?]?[a-zA-Z0-9][a-zA-Z0-9_\\-\\.]*(?<!\\.git)\\z/
            end
          end
        end
      CONTENT
    end

    let(:expected_content_by_path) do
      {
        ""files/ruby/popen.rb"": popen_content,
        ""files/ruby/regex.rb"": regex_content
      }
    end

    context 'non-fork project' do
      before do
        project.add_maintainer(user)
      end

      it_behaves_like 'successfully creates commit and updates suggestions'

      context 'when it fails to apply because a file was changed' do
        before do
          params = {
            file_path: suggestion3.diff_file.file_path,
            start_branch: suggestion3.branch,
            branch_name: suggestion3.branch,
            commit_message: 'Update file',
            file_content: 'New content'
          }

          # Reload the suggestion so it's memoized values get reset after the
          # file was changed.
          suggestion3.reload

          Files::UpdateService.new(project, user, params).execute
        end

        it 'returns error message' do
          result = apply_service.new(user, suggestion, suggestion3, suggestion2).execute

          expect(result).to eq(message: 'A file has been changed.', status: :error)
        end
      end

      context 'when HEAD from position is different from source branch HEAD on repo' do
        it 'returns error message' do
          allow(suggestion).to receive(:appliable?).and_return(true)
          allow(suggestion.position).to receive(:head_sha).and_return('old-sha')
          allow(suggestion.noteable).to receive(:source_branch_sha).and_return('new-sha')

          result = apply_service.new(user, suggestion).execute

          expect(result).to eq(message: 'A file has been changed.', status: :error)
        end
      end

      context 'single suggestion' do
        let(:author) { suggestions.first.note.author }
        let(:commit) { project.repository.commit }

        context 'author of suggestion applies suggestion' do
          before do
            suggestion.note.update!(author_id: user.id)

            apply(suggestions)
          end

          it 'created commit by same author and committer' do
            expect(user.commit_email).to eq(author.commit_email_or_default)
            expect(author).to eq(user)
            expect(commit.author_email).to eq(author.commit_email_or_default)
            expect(commit.committer_email).to eq(user.commit_email)
            expect(commit.author_name).to eq(author.name)
            expect(commit.committer_name).to eq(user.name)
          end
        end

        context 'another user applies suggestion' do
          before do
            apply(suggestions)
          end

          it 'created commit has authors info and commiters info' do
            expect(user.commit_email).not_to eq(user.email)
            expect(author).not_to eq(user)
            expect(commit.author_email).to eq(author.commit_email_or_default)
            expect(commit.committer_email).to eq(user.commit_email)
            expect(commit.author_name).to eq(author.name)
            expect(commit.committer_name).to eq(user.name)
          end
        end
      end

      context 'multiple suggestions' do
        let(:author_emails) { suggestions.map { |s| s.note.author.commit_email_or_default } }
        let(:first_author) { suggestion.note.author }
        let(:commit) { project.repository.commit }

        context 'when all the same author' do
          before do
            apply(suggestions)
          end

          it 'uses first authors information' do
            expect(author_emails).to include(first_author.commit_email_or_default).exactly(3)
            expect(commit.author_email).to eq(first_author.commit_email_or_default)
          end
        end

        context 'when all different authors' do
          before do
            suggestion2.note.update!(author_id: create(:user).id)
            suggestion3.note.update!(author_id: create(:user).id)
            apply(suggestions)
          end

          it 'uses committers information' do
            expect(commit.author_email).to eq(user.commit_email)
            expect(commit.committer_email).to eq(user.commit_email)
          end
        end
      end

      context 'multiple suggestions applied sequentially' do
        def apply_suggestion(suggestion)
          suggestion.reload
          merge_request.reload
          merge_request.clear_memoized_shas

          result = apply_service.new(user, suggestion).execute
          suggestion.reload
          expect(result[:status]).to eq(:success)

          refresh = MergeRequests::RefreshService.new(project: project, current_user: user)
          refresh.execute(
            merge_request.diff_head_sha,
            suggestion.commit_id,
            merge_request.source_branch_ref
          )

          result
        end

        def fetch_raw_diff(suggestion)
          project.reload.commit(suggestion.commit_id)
            .diffs.diff_files.first.diff.diff
        end

        it 'applies multiple suggestions in subsequent versions correctly' do
          suggestion1 = create_suggestion(
            from_content: ""\n"",
            to_content: ""# v1 change\n"",
            old_line: nil,
            new_line: 13)

          suggestion2 = create_suggestion(
            from_content: ""      @cmd_output << stderr.read\n"",
            to_content: ""# v2 change\n"",
            old_line: 24,
            new_line: 31)

          apply_suggestion(suggestion1)
          apply_suggestion(suggestion2)

          suggestion1_diff = fetch_raw_diff(suggestion1)
          suggestion2_diff = fetch_raw_diff(suggestion2)

          expected_suggestion1_diff = <<-CONTENT.strip_heredoc
            @@ -10,7 +10,7 @@ module Popen
                 end

                 path ||= Dir.pwd
            -
            +# v1 change
                 vars = {
                   ""PWD"" => path
                 }
          CONTENT
          expected_suggestion2_diff = <<-CONTENT.strip_heredoc
            @@ -28,7 +28,7 @@ module Popen

                 Open3.popen3(vars, *cmd, options) do |stdin, stdout, stderr, wait_thr|
                   @cmd_output << stdout.read
            -      @cmd_output << stderr.read
            +# v2 change
                   @cmd_status = wait_thr.value.exitstatus
                 end
          CONTENT
          expect(suggestion1_diff.strip).to eq(expected_suggestion1_diff.strip)
          expect(suggestion2_diff.strip).to eq(expected_suggestion2_diff.strip)
        end
      end

      context 'multi-line suggestion' do
        let(:popen_content) do
          <<~CONTENT.strip_heredoc
            require 'fileutils'
            require 'open3'

            module Popen
              extend self

            # multi
            # line

                vars = {
                  ""PWD"" => path
                }

                options = {
                  chdir: path
                }

                unless File.directory?(path)
                  FileUtils.mkdir_p(path)
                end

                @cmd_output = """"
                @cmd_status = 0

                Open3.popen3(vars, *cmd, options) do |stdin, stdout, stderr, wait_thr|
                  @cmd_output << stdout.read
                  @cmd_output << stderr.read
                  @cmd_status = wait_thr.value.exitstatus
                end

                return @cmd_output, @cmd_status
              end
            end
          CONTENT
        end

        let(:expected_content_by_path) do
          {
            ""files/ruby/popen.rb"": popen_content
          }
        end

        let(:suggestion) do
          create(:suggestion, :content_from_repo,
            note: diff_note, lines_above: 2, lines_below: 3, to_content: ""# multi\n# line\n"")
        end

        let(:suggestions) { [suggestion] }

        it_behaves_like 'successfully creates commit and updates suggestions'
      end

      context 'remove an empty line suggestion' do
        let(:popen_content) do
          <<~CONTENT.strip_heredoc
            require 'fileutils'
            require 'open3'

            module Popen
              extend self

              def popen(cmd, path=nil)
                unless cmd.is_a?(Array)
                  raise RuntimeError, ""System commands must be given as an array of strings""
                end

                path ||= Dir.pwd
                vars = {
                  ""PWD"" => path
                }

                options = {
                  chdir: path
                }

                unless File.directory?(path)
                  FileUtils.mkdir_p(path)
                end

                @cmd_output = """"
                @cmd_status = 0

                Open3.popen3(vars, *cmd, options) do |stdin, stdout, stderr, wait_thr|
                  @cmd_output << stdout.read
                  @cmd_output << stderr.read
                  @cmd_status = wait_thr.value.exitstatus
                end

                return @cmd_output, @cmd_status
              end
            end
          CONTENT
        end

        let(:expected_content_by_path) do
          {
            ""files/ruby/popen.rb"": popen_content
          }
        end

        let(:suggestion) do
          create_suggestion(to_content: """", new_line: 13)
        end

        let(:suggestions) { [suggestion] }

        it_behaves_like 'successfully creates commit and updates suggestions'
      end
    end

    context 'fork-project' do
      let(:project) { create(:project, :public, :repository) }

      let(:forked_project) do
        fork_project_with_submodules(project, user)
      end

      let(:merge_request) do
        create(
          :merge_request,
          source_branch: 'conflict-resolvable-fork',
          source_project: forked_project,
          target_branch: 'conflict-start',
          target_project: project
        )
      end

      let!(:diff_note) do
        create(
          :diff_note_on_merge_request,
          noteable: merge_request,
          position: position,
          project: project
        )
      end

      before do
        project.add_maintainer(user)
      end

      it 'updates file in the source project' do
        expect(Files::MultiService).to receive(:new)
          .with(merge_request.source_project, user, anything)
          .and_call_original

        apply_service.new(user, suggestion).execute
      end
    end
  end

  context 'no permission' do
    let(:merge_request) do
      create(:merge_request, source_project: project, target_project: project)
    end

    let(:diff_note) do
      create(:diff_note_on_merge_request,
        noteable: merge_request, position: position, project: project)
    end

    context 'user cannot write in project repo' do
      before do
        project.add_reporter(user)
      end

      it 'returns error' do
        result = apply_service.new(user, suggestion).execute

        expect(result).to eq(
          message: ""You are not allowed to push into this branch"",
          status: :error
        )
      end
    end
  end

  context 'patch is not appliable' do
    let(:merge_request) do
      create(:merge_request, source_project: project, target_project: project)
    end

    let(:diff_note) do
      create(:diff_note_on_merge_request,
        noteable: merge_request, position: position, project: project)
    end

    before do
      project.add_maintainer(user)
    end

    shared_examples_for 'service not tracking apply suggestion event' do
      it 'does not track apply suggestion event' do
        expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
          .not_to receive(:track_apply_suggestion_action)

        result
      end
    end

    context 'diff file was not found' do
      let(:result) { apply_service.new(user, suggestion).execute }

      before do
        expect(suggestion.note).to receive(:latest_diff_file).and_return(nil)
      end

      it 'returns error message' do
        expect(result).to eq(message: 'A file was not found.', status: :error)
      end

      it_behaves_like 'service not tracking apply suggestion event'
    end

    context 'when not all suggestions belong to the same branch' do
      let(:merge_request2) do
        create(
          :merge_request,
          :conflict,
          source_project: project,
          target_project: project
        )
      end

      let(:position2) do
        Gitlab::Diff::Position.new(
          old_path: ""files/ruby/popen.rb"",
          new_path: ""files/ruby/popen.rb"",
          old_line: nil,
          new_line: 15,
          diff_refs: merge_request2.diff_refs
        )
      end

      let(:diff_note2) do
        create(
          :diff_note_on_merge_request,
          noteable: merge_request2,
          position: position2,
          project: project
        )
      end

      let(:other_branch_suggestion) { create(:suggestion, note: diff_note2) }
      let(:result) { apply_service.new(user, suggestion, other_branch_suggestion).execute }

      it 'renders error message' do
        expect(result).to eq(
          message: 'Suggestions must all be on the same branch.',
          status: :error
        )
      end

      it_behaves_like 'service not tracking apply suggestion event'
    end

    context 'suggestion is not appliable' do
      let(:inapplicable_reason) { ""Can't apply this suggestion."" }
      let(:result) { apply_service.new(user, suggestion).execute }

      before do
        expect(suggestion).to receive(:appliable?).and_return(false)
        expect(suggestion).to receive(:inapplicable_reason).and_return(inapplicable_reason)
      end

      it 'returns error message' do
        expect(result).to eq(message: inapplicable_reason, status: :error)
      end

      it_behaves_like 'service not tracking apply suggestion event'
    end

    context 'lines of suggestions overlap' do
      let(:suggestion) do
        create_suggestion(
          to_content: ""      raise RuntimeError, 'Explosion'\n      # explosion?\n"")
      end

      let(:overlapping_suggestion) do
        create_suggestion(to_content: ""I Overlap!"")
      end

      let(:result) { apply_service.new(user, suggestion, overlapping_suggestion).execute }

      it 'returns error message' do
        expect(result).to eq(
          message: 'Suggestions are not applicable as their lines cannot overlap.',
          status: :error
        )
      end

      it_behaves_like 'service not tracking apply suggestion event'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Suggestions
  class CreateService
    def initialize(note)
      @note = note
    end

    def execute
      return unless @note.supports_suggestion?

      suggestions = Gitlab::Diff::SuggestionsParser.parse(
        @note.note,
        project: @note.project,
        position: @note.position
      )

      rows = suggestions.map.with_index do |suggestion, index|
        creation_params = suggestion.to_hash.slice(
          :from_content,
          :to_content,
          :lines_above,
          :lines_below
        )

        creation_params.merge!(note_id: @note.id, relative_order: index)
      end

      rows.in_groups_of(100, false) do |rows|
        ApplicationRecord.legacy_bulk_insert('suggestions', rows) # rubocop:disable Gitlab/BulkInsert
      end

      Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter.track_add_suggestion_action(note: @note)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Suggestions::CreateService, feature_category: :code_suggestions do
  let(:project_with_repo) { create(:project, :repository) }
  let(:merge_request) do
    create(
      :merge_request,
      source_project: project_with_repo,
      target_project: project_with_repo
    )
  end

  def build_position(args = {})
    default_args = { old_path: ""files/ruby/popen.rb"",
                     new_path: ""files/ruby/popen.rb"",
                     old_line: nil,
                     new_line: 14,
                     diff_refs: merge_request.diff_refs }

    Gitlab::Diff::Position.new(default_args.merge(args))
  end

  let(:position) { build_position }

  let(:markdown) do
    <<-MARKDOWN.strip_heredoc
        ```suggestion
          foo
          bar
        ```

        ```
          nothing
        ```

        ```suggestion
          xpto
          baz
        ```

        ```thing
          this is not a suggestion, it's a thing
        ```

        ```suggestion:-3+2
          # multi-line suggestion 1
        ```

        ```suggestion:-5
          # multi-line suggestion 1
        ```
    MARKDOWN
  end

  subject { described_class.new(note) }

  shared_examples_for 'service not tracking add suggestion event' do
    it 'does not track add suggestion event' do
      expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
        .not_to receive(:track_add_suggestion_action)

      subject.execute
    end
  end

  describe '#execute' do
    context 'should not try to parse suggestions' do
      context 'when not a diff note for merge requests' do
        let(:note) do
          create(:diff_note_on_commit, project: project_with_repo, note: markdown)
        end

        it 'does not try to parse suggestions' do
          expect(Gitlab::Diff::SuggestionsParser).not_to receive(:parse)

          subject.execute
        end

        it_behaves_like 'service not tracking add suggestion event'
      end

      context 'when diff note is not for text' do
        let(:note) do
          create(
            :diff_note_on_merge_request,
            project: project_with_repo,
            noteable: merge_request,
            position: position,
            note: markdown
          )
        end

        before do
          allow(note).to receive(:on_text?) { false }
        end

        it 'does not try to parse suggestions' do
          expect(Gitlab::Diff::SuggestionsParser).not_to receive(:parse)

          subject.execute
        end

        it_behaves_like 'service not tracking add suggestion event'
      end
    end

    context 'when diff file is not found' do
      let(:note) do
        create(
          :diff_note_on_merge_request,
          project: project_with_repo,
          noteable: merge_request,
          position: position,
          note: markdown
        )
      end

      before do
        expect_next_instance_of(DiffNote) do |diff_note|
          expect(diff_note).to receive(:latest_diff_file).once { nil }
        end
      end

      it 'creates no suggestion' do
        expect { subject.execute }.not_to change(Suggestion, :count)
      end

      it_behaves_like 'service not tracking add suggestion event'
    end

    context 'should create suggestions' do
      let(:note) do
        create(
          :diff_note_on_merge_request,
          project: project_with_repo,
          noteable: merge_request,
          position: position,
          note: markdown
        )
      end

      let(:expected_suggestions) do
        Gitlab::Diff::SuggestionsParser.parse(
          markdown,
          project: note.project,
          position: note.position
        )
      end

      it 'persists suggestion records' do
        expect { subject.execute }.to change { note.suggestions.count }
          .from(0).to(expected_suggestions.size)
      end

      it 'persists suggestions data correctly' do
        subject.execute

        suggestions = note.suggestions.order(:relative_order)

        suggestions.zip(expected_suggestions) do |suggestion, expected_suggestion|
          expected_data = expected_suggestion.to_hash

          expect(suggestion.from_content).to eq(expected_data[:from_content])
          expect(suggestion.to_content).to eq(expected_data[:to_content])
          expect(suggestion.lines_above).to eq(expected_data[:lines_above])
          expect(suggestion.lines_below).to eq(expected_data[:lines_below])
        end
      end

      it 'tracks add suggestion event' do
        expect(Gitlab::UsageDataCounters::MergeRequestActivityUniqueCounter)
          .to receive(:track_add_suggestion_action)
          .with(note: note)

        subject.execute
      end

      context 'outdated position note' do
        let!(:outdated_diff) { merge_request.merge_request_diff }
        let!(:latest_diff) { merge_request.create_merge_request_diff }
        let(:outdated_position) { build_position(diff_refs: outdated_diff.diff_refs) }
        let(:position) { build_position(diff_refs: latest_diff.diff_refs) }

        it 'uses the correct position when creating the suggestion' do
          expect(Gitlab::Diff::SuggestionsParser).to receive(:parse)
            .with(note.note, project: note.project, position: note.position)
            .and_call_original

          subject.execute
        end
      end

      context 'when a patch removes an empty line' do
        let(:markdown) do
          <<-MARKDOWN.strip_heredoc
              ```suggestion
              ```
          MARKDOWN
        end

        let(:position) { build_position(new_line: 13) }

        it 'creates an appliable suggestion' do
          subject.execute

          suggestion = note.suggestions.last

          expect(suggestion).to be_appliable
          expect(suggestion.from_content).to eq(""\n"")
          expect(suggestion.to_content).to eq("""")
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Mattermost
  class CreateTeamService < ::BaseService
    def initialize(group, current_user)
      @group = group
      @current_user = current_user
    end

    def execute
      # The user that creates the team will be Team Admin
      ::Mattermost::Team.new(current_user).create(**@group.mattermost_team_params)
    rescue ::Mattermost::ClientError => e
      @group.errors.add(:mattermost_team, e.message)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Mattermost::CreateTeamService, feature_category: :integrations do
  let(:user) { create(:user) }
  let(:group) { create(:group) }

  subject { described_class.new(group, user) }

  it 'creates a team' do
    expect_next_instance_of(::Mattermost::Team) do |instance|
      expect(instance).to receive(:create).with(name: anything, display_name: anything, type: anything)
    end

    subject.execute
  end

  it 'adds an error if a team could not be created' do
    expect_next_instance_of(::Mattermost::Team) do |instance|
      expect(instance).to receive(:create).and_raise(::Mattermost::ClientError, 'client error')
    end

    subject.execute

    expect(group.errors).to be_present
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Branches
  class ValidateNewService < BaseService
    def initialize(project)
      @project = project
    end

    def execute(branch_name, force: false)
      return error('Branch name is invalid') unless valid_name?(branch_name)

      if branch_exist?(branch_name) && !force
        return error('Branch already exists')
      end

      success
    rescue Gitlab::Git::PreReceiveError => ex
      error(ex.message)
    end

    private

    def valid_name?(branch_name)
      Gitlab::GitRefValidator.validate(branch_name)
    end

    def branch_exist?(branch_name)
      project.repository.branch_exists?(branch_name)
    end
  end
end

Branches::ValidateNewService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Branches::ValidateNewService, feature_category: :source_code_management do
  let(:project) { create(:project, :repository) }

  subject(:service) { described_class.new(project) }

  describe '#execute' do
    context 'validation' do
      it 'returns error with an invalid branch name' do
        result = service.execute('refs/heads/invalid_branch')

        expect(result[:status]).to eq(:error)
        expect(result[:message]).to eq('Branch name is invalid')
      end

      it 'returns success with a valid branch name' do
        result = service.execute('valid_branch_name')

        expect(result[:status]).to eq(:success)
      end
    end

    context 'branch exist' do
      it 'returns error when branch exists' do
        result = service.execute('master')

        expect(result[:status]).to eq(:error)
        expect(result[:message]).to eq('Branch already exists')
      end

      it 'returns success when branch name is available' do
        result = service.execute('valid_branch_name')

        expect(result[:status]).to eq(:success)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Branches
  class DeleteMergedService < BaseService
    def async_execute
      DeleteMergedBranchesWorker.perform_async(project.id, current_user.id)
    end

    def execute
      raise Gitlab::Access::AccessDeniedError unless can?(current_user, :push_code, project)

      branches = project.repository.merged_branch_names
      # Prevent deletion of branches relevant to open merge requests
      branches -= merge_request_branch_names
      # Prevent deletion of protected branches
      branches = branches.reject { |branch| ProtectedBranch.protected?(project, branch) }

      branches.each do |branch|
        ::Branches::DeleteService.new(project, current_user).execute(branch)
      end
    end

    private

    # rubocop: disable CodeReuse/ActiveRecord
    def merge_request_branch_names
      # reorder(nil) is necessary for SELECT DISTINCT because default scope adds an ORDER BY
      source_names = project.origin_merge_requests.opened.reorder(nil).distinct.pluck(:source_branch)
      target_names = project.merge_requests.opened.reorder(nil).distinct.pluck(:target_branch)
      (source_names + target_names).uniq
    end
    # rubocop: enable CodeReuse/ActiveRecord
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Branches::DeleteMergedService, feature_category: :source_code_management do
  include ProjectForksHelper

  subject(:service) { described_class.new(project, project.first_owner) }

  let(:project) { create(:project, :repository) }

  describe '#execute' do
    it 'deletes a branch that was merged' do
      service.execute

      expect(project.repository.branch_names).not_to include('improve/awesome')
    end

    it 'keeps branch that is unmerged' do
      service.execute

      expect(project.repository.branch_names).to include('feature')
    end

    it 'keeps ""master""' do
      service.execute

      expect(project.repository.branch_names).to include('master')
    end

    it 'keeps protected branches' do
      create(:protected_branch, project: project, name: 'improve/awesome')

      service.execute

      expect(project.repository.branch_names).to include('improve/awesome')
    end

    it 'keeps wildcard protected branches' do
      create(:protected_branch, project: project, name: 'improve/*')

      service.execute

      expect(project.repository.branch_names).to include('improve/awesome')
    end

    it 'ignores protected tags' do
      create(:protected_tag, project: project, name: 'improve/*')

      service.execute

      expect(project.repository.branch_names).not_to include('improve/awesome')
    end

    context 'user without rights' do
      let(:user) { create(:user) }

      it 'cannot execute' do
        expect { described_class.new(project, user).execute }.to raise_error(Gitlab::Access::AccessDeniedError)
      end
    end

    context 'open merge requests' do
      it 'does not delete branches from open merge requests' do
        forked_project = fork_project(project)
        create(:merge_request, :opened, source_project: project, target_project: project, source_branch: 'branch-merged', target_branch: 'master')
        create(:merge_request, :opened, source_project: forked_project, target_project: project, target_branch: 'improve/awesome', source_branch: 'master')

        service.execute

        expect(project.repository.branch_names).to include('branch-merged')
        expect(project.repository.branch_names).to include('improve/awesome')
      end
    end
  end

  describe '#async_execute' do
    it 'calls DeleteMergedBranchesWorker async' do
      expect(DeleteMergedBranchesWorker).to receive(:perform_async)

      service.async_execute
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Branches
  class DivergingCommitCountsService
    def initialize(repository)
      @repository = repository
      @cache = Gitlab::RepositoryCache.new(repository)
    end

    def call(branch)
      diverging_commit_counts(branch)
    end

    private

    attr_reader :repository, :cache

    delegate :raw_repository, to: :repository

    def diverging_commit_counts(branch)
      @root_ref_hash ||= raw_repository.commit(repository.root_ref).id
      cache.fetch(:""diverging_commit_counts_#{branch.name}"") do
        number_commits_behind, number_commits_ahead =
          raw_repository.diverging_commit_count(
            @root_ref_hash,
            branch.dereferenced_target.sha)

        { behind: number_commits_behind, ahead: number_commits_ahead }
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Branches::DivergingCommitCountsService, feature_category: :source_code_management do
  let(:project) { create(:project, :repository) }
  let(:repository) { project.repository }

  describe '#call' do
    let(:diverged_branch) { repository.find_branch('fix') }
    let(:root_ref_sha) { repository.raw_repository.commit(repository.root_ref).id }
    let(:diverged_branch_sha) { diverged_branch.dereferenced_target.sha }

    let(:service) { described_class.new(repository) }

    it 'returns the commit counts behind and ahead of default branch' do
      result = service.call(diverged_branch)

      expect(result).to eq(behind: 29, ahead: 2)
    end

    it 'calls diverging_commit_count without max count' do
      expect(repository.raw_repository)
        .to receive(:diverging_commit_count)
        .with(root_ref_sha, diverged_branch_sha)
        .and_return([29, 2])

      service.call(diverged_branch)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Branches
  class CreateService < BaseService
    def initialize(project, user = nil, params = {})
      super(project, user, params)

      @errors = []
    end

    def execute(branch_name, ref, create_default_branch_if_empty: true)
      create_default_branch if create_default_branch_if_empty && project.empty_repo?

      result = branch_validation_service.execute(branch_name)

      return result if result[:status] == :error

      create_branch(branch_name, ref)
    end

    def bulk_create(branches)
      reset_errors

      created_branches =
        branches
          .then { |branches| only_valid_branches(branches) }
          .then { |branches| create_branches(branches) }
          .then { |branches| expire_branches_cache(branches) }

      return error(errors) if errors.present?

      success(branches: created_branches)
    end

    private

    attr_reader :errors

    def reset_errors
      @errors = []
    end

    def only_valid_branches(branches)
      branches.select do |branch_name, _ref|
        result = branch_validation_service.execute(branch_name)

        if result[:status] == :error
          errors << result[:message]
          next
        end

        true
      end
    end

    def create_branches(branches)
      branches.filter_map do |branch_name, ref|
        result = create_branch(branch_name, ref, expire_cache: false)

        if result[:status] == :error
          errors << result[:message]
          next
        end

        result[:branch]
      end
    end

    def expire_branches_cache(branches)
      repository.expire_branches_cache if branches.present?

      branches
    end

    def create_branch(branch_name, ref, expire_cache: true)
      new_branch = repository.add_branch(current_user, branch_name, ref, expire_cache: expire_cache)

      if new_branch
        success(branch: new_branch)
      else
        error(""Failed to create branch '#{branch_name}': invalid reference name '#{ref}'"")
      end
    rescue Gitlab::Git::CommandError => e
      error(""Failed to create branch '#{branch_name}': #{e}"")
    rescue Gitlab::Git::PreReceiveError => e
      Gitlab::ErrorTracking.log_exception(e, pre_receive_message: e.raw_message, branch_name: branch_name, ref: ref)
      error(e.message)
    end

    def create_default_branch
      project.repository.create_file(
        current_user,
        '/README.md',
        '',
        message: 'Add README.md',
        branch_name: project.default_branch_or_main
      )
    end

    def branch_validation_service
      @branch_validation_service ||= ::Branches::ValidateNewService.new(project)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Branches::CreateService, :use_clean_rails_redis_caching, feature_category: :source_code_management do
  subject(:service) { described_class.new(project, user) }

  let_it_be(:project) { create(:project_empty_repo) }
  let_it_be(:user) { create(:user) }

  describe '#bulk_create' do
    subject { service.bulk_create(branches) }

    let_it_be(:project) { create(:project, :custom_repo, files: { 'foo/a.txt' => 'foo' }) }

    let(:branches) { { 'branch' => 'master', 'another_branch' => 'master' } }

    it 'creates two branches' do
      expect(subject[:status]).to eq(:success)
      expect(subject[:branches].map(&:name)).to match_array(%w[branch another_branch])

      expect(project.repository.branch_exists?('branch')).to be_truthy
      expect(project.repository.branch_exists?('another_branch')).to be_truthy
    end

    context 'when branches are empty' do
      let(:branches) { {} }

      it 'is successful' do
        expect(subject[:status]).to eq(:success)
        expect(subject[:branches]).to eq([])
      end
    end

    context 'when incorrect reference is provided' do
      let(:branches) { { 'new-feature' => 'unknown' } }

      before do
        allow(project.repository).to receive(:add_branch).and_return(false)
      end

      it 'returns an error with a reference name' do
        err_msg = 'Failed to create branch \'new-feature\': invalid reference name \'unknown\''

        expect(subject[:status]).to eq(:error)
        expect(subject[:message]).to match_array([err_msg])
      end
    end

    context 'when branch already exists' do
      let(:branches) { { 'master' => 'master' } }

      it 'returns an error' do
        expect(subject[:status]).to eq(:error)
        expect(subject[:message]).to match_array(['Branch already exists'])
      end
    end

    context 'when PreReceiveError exception' do
      let(:branches) { { 'error' => 'master' } }

      it 'logs and returns an error if there is a PreReceiveError exception' do
        error_message = 'pre receive error'
        raw_message = ""GitLab: #{error_message}""
        pre_receive_error = Gitlab::Git::PreReceiveError.new(raw_message)

        allow(project.repository).to receive(:add_branch).and_raise(pre_receive_error)

        expect(Gitlab::ErrorTracking).to receive(:log_exception).with(
          pre_receive_error,
          pre_receive_message: raw_message,
          branch_name: 'error',
          ref: 'master'
        )

        expect(subject[:status]).to eq(:error)
        expect(subject[:message]).to match_array([error_message])
      end
    end

    context 'when multiple errors occur' do
      let(:branches) { { 'master' => 'master', '' => 'master', 'failed_branch' => 'master' } }

      it 'returns all errors' do
        allow(project.repository).to receive(:add_branch).with(
          user,
          'failed_branch',
          'master',
          expire_cache: false
        ).and_return(false)

        expect(subject[:status]).to eq(:error)
        expect(subject[:message]).to match_array(
          [
            'Branch already exists',
            'Branch name is invalid',
            ""Failed to create branch 'failed_branch': invalid reference name 'master'""
          ]
        )
      end
    end

    context 'without N+1 for Redis cache' do
      let(:branches) { { 'branch1' => 'master', 'branch2' => 'master', 'branch3' => 'master' } }

      it 'does not trigger Redis recreation' do
        project.repository.expire_branches_cache

        control = RedisCommands::Recorder.new(pattern: ':branch_names:') { subject }

        expect(control).not_to exceed_redis_command_calls_limit(:sadd, 1)
      end
    end

    context 'without N+1 branch cache expiration' do
      let(:branches) { { 'branch_1' => 'master', 'branch_2' => 'master', 'branch_3' => 'master' } }

      it 'triggers branch cache expiration only once' do
        expect(project.repository).to receive(:expire_branches_cache).once

        subject
      end

      context 'when branches were not added' do
        let(:branches) { { 'master' => 'master' } }

        it 'does not trigger branch expiration' do
          expect(project.repository).not_to receive(:expire_branches_cache)

          subject
        end
      end
    end
  end

  describe '#execute' do
    context 'when repository is empty' do
      it 'creates master branch' do
        result = service.execute('my-feature', 'master')

        expect(result[:status]).to eq(:success)
        expect(result[:branch].name).to eq('my-feature')
        expect(project.repository.branch_exists?('master')).to be_truthy
      end

      it 'creates another-feature branch' do
        service.execute('another-feature', 'master')

        expect(project.repository.branch_exists?('another-feature')).to be_truthy
      end
    end

    context 'when branch already exists' do
      it 'returns an error' do
        result = service.execute('master', 'master')

        expect(result[:status]).to eq(:error)
        expect(result[:message]).to eq('Branch already exists')
      end
    end

    context 'when incorrect reference is provided' do
      before do
        allow(project.repository).to receive(:add_branch).and_return(false)
      end

      it 'returns an error with a reference name' do
        err_msg = 'Failed to create branch \'new-feature\': invalid reference name \'unknown\''
        result = service.execute('new-feature', 'unknown')

        expect(result[:status]).to eq(:error)
        expect(result[:message]).to eq(err_msg)
      end
    end

    it 'logs and returns an error if there is a PreReceiveError exception' do
      error_message = 'pre receive error'
      raw_message = ""GitLab: #{error_message}""
      pre_receive_error = Gitlab::Git::PreReceiveError.new(raw_message)

      allow(project.repository).to receive(:add_branch).and_raise(pre_receive_error)

      expect(Gitlab::ErrorTracking).to receive(:log_exception).with(
        pre_receive_error,
        pre_receive_message: raw_message,
        branch_name: 'new-feature',
        ref: 'unknown'
      )

      result = service.execute('new-feature', 'unknown')

      expect(result[:status]).to eq(:error)
      expect(result[:message]).to eq(error_message)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Branches
  class DeleteService < BaseService
    def execute(branch_name)
      repository = project.repository
      branch = repository.find_branch(branch_name)

      unless current_user.can?(:push_code, project)
        return ServiceResponse.error(
          message: 'You dont have push access to repo',
          http_status: 405)
      end

      unless branch
        return ServiceResponse.error(
          message: 'No such branch',
          http_status: 404)
      end

      if repository.rm_branch(current_user, branch_name)
        unlock_artifacts(branch_name)
        ServiceResponse.success(message: 'Branch was deleted')
      else
        ServiceResponse.error(
          message: 'Failed to remove branch',
          http_status: 400)
      end
    rescue Gitlab::Git::PreReceiveError, Gitlab::Git::CommandError => ex
      ServiceResponse.error(message: ex.message, http_status: 400)
    end

    private

    def unlock_artifacts(branch_name)
      Ci::RefDeleteUnlockArtifactsWorker.perform_async(project.id, current_user.id, ""#{::Gitlab::Git::BRANCH_REF_PREFIX}#{branch_name}"")
    end
  end
end

Branches::DeleteService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Branches::DeleteService, feature_category: :source_code_management do
  let(:project) { create(:project, :repository) }
  let(:repository) { project.repository }
  let(:user) { create(:user) }

  subject(:service) { described_class.new(project, user) }

  shared_examples 'a deleted branch' do |branch_name|
    before do
      allow(Ci::RefDeleteUnlockArtifactsWorker).to receive(:perform_async)
    end

    it 'removes the branch' do
      expect(branch_exists?(branch_name)).to be true

      result = service.execute(branch_name)

      expect(result.status).to eq :success
      expect(branch_exists?(branch_name)).to be false
    end

    it 'calls the RefDeleteUnlockArtifactsWorker' do
      expect(Ci::RefDeleteUnlockArtifactsWorker).to receive(:perform_async).with(project.id, user.id, ""refs/heads/#{branch_name}"")

      service.execute(branch_name)
    end
  end

  describe '#execute' do
    context 'when user has access to push to repository' do
      before do
        project.add_developer(user)
      end

      it_behaves_like 'a deleted branch', 'feature'

      context 'when Gitlab::Git::CommandError is raised' do
        before do
          allow(repository).to receive(:rm_branch) do
            raise Gitlab::Git::CommandError, 'Could not update patch'
          end
        end

        it 'handles and returns error' do
          result = service.execute('feature')

          expect(result.status).to eq(:error)
          expect(result.message).to eq('Could not update patch')
        end
      end
    end

    context 'when user does not have access to push to repository' do
      it 'does not remove branch' do
        expect(branch_exists?('feature')).to be true

        result = service.execute('feature')

        expect(result.status).to eq :error
        expect(result.message).to eq 'You dont have push access to repo'
        expect(branch_exists?('feature')).to be true
      end
    end
  end

  def branch_exists?(branch_name)
    repository.ref_exists?(""refs/heads/#{branch_name}"")
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module NamespaceSettings
  class UpdateService
    include ::Gitlab::Allowable

    attr_reader :current_user, :group, :settings_params

    def initialize(current_user, group, settings)
      @current_user = current_user
      @group = group
      @settings_params = settings
    end

    def execute
      validate_resource_access_token_creation_allowed_param

      validate_settings_param_for_root_group(
        param_key: :prevent_sharing_groups_outside_hierarchy,
        user_policy: :change_prevent_sharing_groups_outside_hierarchy
      )
      validate_settings_param_for_root_group(
        param_key: :new_user_signups_cap,
        user_policy: :change_new_user_signups_cap
      )
      validate_settings_param_for_root_group(
        param_key: :default_branch_protection,
        user_policy: :update_default_branch_protection
      )
      validate_settings_param_for_root_group(
        param_key: :default_branch_protection_defaults,
        user_policy: :update_default_branch_protection
      )

      handle_default_branch_protection unless settings_params[:default_branch_protection].blank?

      if group.namespace_settings
        group.namespace_settings.attributes = settings_params
      else
        group.build_namespace_settings(settings_params)
      end
    end

    private

    def handle_default_branch_protection
      # We are migrating default_branch_protection from an integer
      # column to a jsonb column. While completing the rest of the
      # work, we want to start translating the updates sent to the
      # existing column into the json. Eventually, we will be updating
      # the jsonb column directly and deprecating the original update
      # path. Until then, we want to sync up both columns.
      protection = Gitlab::Access::BranchProtection.new(settings_params.delete(:default_branch_protection).to_i)
      settings_params[:default_branch_protection_defaults] = protection.to_hash
    end

    def validate_resource_access_token_creation_allowed_param
      return if settings_params[:resource_access_token_creation_allowed].nil?

      unless can?(current_user, :admin_group, group)
        settings_params.delete(:resource_access_token_creation_allowed)
        group.namespace_settings.errors.add(:resource_access_token_creation_allowed, _('can only be changed by a group admin.'))
      end
    end

    def validate_settings_param_for_root_group(param_key:, user_policy:)
      return if settings_params[param_key].nil?

      unless can?(current_user, user_policy, group)
        settings_params.delete(param_key)
        group.namespace_settings.errors.add(param_key, _('can only be changed by a group admin.'))
      end

      unless group.root?
        settings_params.delete(param_key)
        group.namespace_settings.errors.add(param_key, _('only available on top-level groups.'))
      end
    end
  end
end

NamespaceSettings::UpdateService.prepend_mod_with('NamespaceSettings::UpdateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe NamespaceSettings::UpdateService, feature_category: :groups_and_projects do
  let(:user) { create(:user) }
  let(:group) { create(:group) }
  let(:settings) { {} }

  subject(:service) { described_class.new(user, group, settings) }

  describe ""#execute"" do
    context ""group has no namespace_settings"" do
      before do
        group.namespace_settings.destroy!
      end

      it ""builds out a new namespace_settings record"" do
        expect do
          service.execute
        end.to change { NamespaceSetting.count }.by(1)
      end
    end

    context ""group has a namespace_settings"" do
      before do
        service.execute
      end

      it ""doesn't create a new namespace_setting record"" do
        expect do
          service.execute
        end.not_to change { NamespaceSetting.count }
      end
    end

    context ""updating :default_branch_name"" do
      let(:example_branch_name) { ""example_branch_name"" }
      let(:settings) { { default_branch_name: example_branch_name } }

      it ""changes settings"" do
        expect { service.execute }
          .to change { group.namespace_settings.default_branch_name }
                .from(nil).to(example_branch_name)
      end
    end

    context 'when default_branch_protection is updated' do
      let(:namespace_settings) { group.namespace_settings }
      let(:expected) { ::Gitlab::Access::BranchProtection.protected_against_developer_pushes.stringify_keys }
      let(:settings) { { default_branch_protection: ::Gitlab::Access::PROTECTION_DEV_CAN_MERGE } }

      before do
        group.add_owner(user)
      end

      it ""updates default_branch_protection_defaults from the default_branch_protection param"" do
        expect { service.execute }
          .to change { namespace_settings.default_branch_protection_defaults }
                .from({}).to(expected)
      end
    end

    context 'when default_branch_protection_defaults is updated' do
      let(:namespace_settings) { group.namespace_settings }
      let(:branch_protection) { ::Gitlab::Access::BranchProtection.protected_against_developer_pushes.stringify_keys }
      let(:expected) { branch_protection }
      let(:settings) { { default_branch_protection_defaults: branch_protection } }

      context 'when the user has the ability to update' do
        before do
          allow(Ability).to receive(:allowed?).with(user, :update_default_branch_protection, group).and_return(true)
        end

        context 'when group is root' do
          before do
            allow(group).to receive(:root?).and_return(true)
          end

          it ""updates default_branch_protection_defaults from the default_branch_protection param"" do
            expect { service.execute }
              .to change { namespace_settings.default_branch_protection_defaults }
                    .from({}).to(expected)
          end
        end

        context 'when group is not root' do
          before do
            allow(group).to receive(:root?).and_return(false)
          end

          it ""does not update default_branch_protection_defaults and adds an error to the namespace_settings"", :aggregate_failures do
            expect { service.execute }.not_to change { namespace_settings.default_branch_protection_defaults }
            expect(group.namespace_settings.errors[:default_branch_protection_defaults]).to include('only available on top-level groups.')
          end
        end
      end

      context 'when the user does not have the ability to update' do
        before do
          allow(Ability).to receive(:allowed?).with(user, :update_default_branch_protection, group).and_return(false)
        end

        it ""does not update default_branch_protection_defaults and adds an error to the namespace_settings"", :aggregate_failures do
          expect { service.execute }.not_to change { namespace_settings.default_branch_protection_defaults }
          expect(group.namespace_settings.errors[:default_branch_protection_defaults]).to include('can only be changed by a group admin.')
        end
      end
    end

    context ""updating :resource_access_token_creation_allowed"" do
      let(:settings) { { resource_access_token_creation_allowed: false } }

      context 'when user is a group owner' do
        before do
          group.add_owner(user)
        end

        it ""changes settings"" do
          expect { service.execute }
            .to change { group.namespace_settings.resource_access_token_creation_allowed }
                  .from(true).to(false)
        end
      end

      context 'when user is not a group owner' do
        before do
          group.add_developer(user)
        end

        it ""does not change settings"" do
          expect { service.execute }.not_to change { group.namespace_settings.resource_access_token_creation_allowed }
        end

        it 'returns the group owner error' do
          service.execute
          expect(group.namespace_settings.errors.messages[:resource_access_token_creation_allowed]).to include('can only be changed by a group admin.')
        end
      end
    end

    describe 'validating settings param for root group' do
      using RSpec::Parameterized::TableSyntax

      where(:setting_key, :setting_changes_from, :setting_changes_to) do
        :prevent_sharing_groups_outside_hierarchy | false | true
        :new_user_signups_cap | nil | 100
      end

      with_them do
        let(:settings) do
          { setting_key => setting_changes_to }
        end

        context 'when user is not a group owner' do
          before do
            group.add_maintainer(user)
          end

          it 'does not change settings' do
            expect { service.execute }.not_to change { group.namespace_settings.public_send(setting_key) }
          end

          it 'returns the group owner error' do
            service.execute

            expect(group.namespace_settings.errors.messages[setting_key]).to include('can only be changed by a group admin.')
          end
        end

        context 'with a subgroup' do
          let(:subgroup) { create(:group, parent: group) }

          before do
            group.add_owner(user)
          end

          it 'does not change settings' do
            service = described_class.new(user, subgroup, settings)

            expect { service.execute }.not_to change { group.namespace_settings.public_send(setting_key) }

            expect(subgroup.namespace_settings.errors.messages[setting_key]).to include('only available on top-level groups.')
          end
        end

        context 'when user is a group owner' do
          before do
            group.add_owner(user)
          end

          it 'changes settings' do
            expect { service.execute }
              .to change { group.namespace_settings.public_send(setting_key) }
                    .from(setting_changes_from).to(setting_changes_to)
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ObjectStorage
  class DeleteStaleDirectUploadsService < BaseService
    MAX_EXEC_DURATION = 250.seconds.freeze

    def initialize; end

    def execute
      total_pending_entries = ObjectStorage::PendingDirectUpload.count
      total_deleted_stale_entries = 0

      timeout = false
      start = Time.current

      ObjectStorage::PendingDirectUpload.each do |pending_upload|
        if pending_upload.stale?
          pending_upload.delete
          total_deleted_stale_entries += 1
        end

        if (Time.current - start) > MAX_EXEC_DURATION
          timeout = true
          break
        end
      end

      success(
        total_pending_entries: total_pending_entries,
        total_deleted_stale_entries: total_deleted_stale_entries,
        execution_timeout: timeout
      )
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ObjectStorage::DeleteStaleDirectUploadsService, :direct_uploads, :clean_gitlab_redis_shared_state, feature_category: :shared do
  let(:service) { described_class.new }

  describe '#execute', :aggregate_failures do
    subject(:execute_result) { service.execute }

    let(:location_identifier) { JobArtifactUploader.storage_location_identifier }
    let(:fog_connection) { stub_artifacts_object_storage(JobArtifactUploader, direct_upload: true) }

    let(:stale_path_1) { 'stale/path/123' }
    let!(:stale_object_1) do
      fog_connection.directories
        .new(key: location_identifier.to_s)
        .files
        .create( # rubocop:disable Rails/SaveBang
          key: stale_path_1,
          body: 'something'
        )
    end

    let(:stale_path_2) { 'stale/path/456' }
    let!(:stale_object_2) do
      fog_connection.directories
        .new(key: location_identifier.to_s)
        .files
        .create( # rubocop:disable Rails/SaveBang
          key: stale_path_2,
          body: 'something'
        )
    end

    let(:non_stale_path) { 'nonstale/path/123' }
    let!(:non_stale_object) do
      fog_connection.directories
        .new(key: location_identifier.to_s)
        .files
        .create( # rubocop:disable Rails/SaveBang
          key: non_stale_path,
          body: 'something'
        )
    end

    it 'only deletes stale entries', :aggregate_failures do
      prepare_pending_direct_upload(stale_path_1, 5.hours.ago)
      prepare_pending_direct_upload(stale_path_2, 4.hours.ago)
      prepare_pending_direct_upload(non_stale_path, 3.minutes.ago)

      expect(execute_result).to eq(
        status: :success,
        total_pending_entries: 3,
        total_deleted_stale_entries: 2,
        execution_timeout: false
      )

      expect_not_to_have_pending_direct_upload(stale_path_1)
      expect_pending_uploaded_object_not_to_exist(stale_path_1)

      expect_not_to_have_pending_direct_upload(stale_path_2)
      expect_pending_uploaded_object_not_to_exist(stale_path_2)

      expect_to_have_pending_direct_upload(non_stale_path)
      expect_pending_uploaded_object_to_exist(non_stale_path)
    end

    context 'when a stale entry does not have a matching object in the storage' do
      it 'does not fail and still remove the stale entry' do
        stale_no_object_path = 'some/other/path'
        prepare_pending_direct_upload(stale_path_1, 5.hours.ago)
        prepare_pending_direct_upload(stale_no_object_path, 5.hours.ago)

        expect(execute_result[:status]).to eq(:success)

        expect_not_to_have_pending_direct_upload(stale_path_1)
        expect_pending_uploaded_object_not_to_exist(stale_path_1)

        expect_not_to_have_pending_direct_upload(stale_no_object_path)
      end
    end

    context 'when timeout happens' do
      before do
        stub_const(""#{described_class}::MAX_EXEC_DURATION"", 0.seconds)

        prepare_pending_direct_upload(stale_path_1, 5.hours.ago)
        prepare_pending_direct_upload(stale_path_2, 4.hours.ago)
      end

      it 'completes the current iteration and reports information about total entries' do
        expect(execute_result).to eq(
          status: :success,
          total_pending_entries: 2,
          total_deleted_stale_entries: 1,
          execution_timeout: true
        )

        expect_not_to_have_pending_direct_upload(stale_path_1)
        expect_pending_uploaded_object_not_to_exist(stale_path_1)

        expect_to_have_pending_direct_upload(stale_path_2)
        expect_pending_uploaded_object_to_exist(stale_path_2)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Todos
  class AllowedTargetFilterService
    include Gitlab::Allowable

    def initialize(todos, current_user)
      @todos = todos
      @current_user = current_user
    end

    def execute
      Preloaders::UserMaxAccessLevelInProjectsPreloader.new(@todos.map(&:project).compact, @current_user).execute

      @todos.select { |todo| can?(@current_user, :read_todo, todo) }
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Todos::AllowedTargetFilterService, feature_category: :team_planning do
  include DesignManagementTestHelpers

  let_it_be(:authorized_group) { create(:group, :private) }
  let_it_be(:authorized_project) { create(:project, group: authorized_group) }
  let_it_be(:unauthorized_group) { create(:group, :private) }
  let_it_be(:unauthorized_project) { create(:project, group: unauthorized_group) }
  let_it_be(:user) { create(:user) }

  let_it_be(:authorized_issue) { create(:issue, project: authorized_project) }
  let_it_be(:authorized_issue_todo) { create(:todo, project: authorized_project, target: authorized_issue, user: user) }
  let_it_be(:authorized_note) { create(:note, noteable: authorized_issue, project: authorized_project) }
  let_it_be(:authorized_note_todo) { create(:todo, project: authorized_project, target: authorized_issue, note: authorized_note, user: user) }
  let_it_be(:confidential_issue) { create(:issue, :confidential, project: authorized_project) }
  let_it_be(:confidential_issue_todo) { create(:todo, project: authorized_project, target: confidential_issue, user: user) }
  let_it_be(:confidential_note) { create(:note, :confidential, noteable: confidential_issue, project: authorized_project) }
  let_it_be(:confidential_note_todo) { create(:todo, project: authorized_project, target: authorized_issue, note: confidential_note, user: user) }
  let_it_be(:unauthorized_issue) { create(:issue, project: unauthorized_project) }
  let_it_be(:unauthorized_issue_todo) { create(:todo, project: unauthorized_project, target: unauthorized_issue, user: user) }
  let_it_be(:authorized_design) { create(:design, issue: authorized_issue) }
  let_it_be(:authorized_design_todo) { create(:todo, project: authorized_project, target: authorized_design, user: user) }
  let_it_be(:unauthorized_design) { create(:design, issue: unauthorized_issue) }
  let_it_be(:unauthorized_design_todo) { create(:todo, project: unauthorized_project, target: unauthorized_design, user: user) }
  let_it_be(:unauthorized_note) { create(:note, noteable: unauthorized_issue, project: unauthorized_project) }
  let_it_be(:unauthorized_note_todo) { create(:todo, project: unauthorized_project, target: unauthorized_issue, note: unauthorized_note, user: user) }

  # Cannot use let_it_be with MRs
  let(:authorized_mr) { create(:merge_request, source_project: authorized_project) }
  let(:authorized_mr_todo) { create(:todo, project: authorized_project, user: user, target: authorized_mr) }
  let(:unauthorized_mr) { create(:merge_request, source_project: unauthorized_project) }
  let(:unauthorized_mr_todo) { create(:todo, project: unauthorized_project, user: user, target: unauthorized_mr) }

  describe '#execute' do
    let(:all_todos) { authorized_todos + unauthorized_todos }

    subject(:execute_service) { described_class.new(all_todos, user).execute }

    shared_examples 'allowed Todos filter' do
      before do
        enable_design_management
      end

      it { is_expected.to match_array(authorized_todos) }
    end

    context 'with reporter user' do
      before_all do
        authorized_group.add_reporter(user)
      end

      it_behaves_like 'allowed Todos filter' do
        let(:authorized_todos) do
          [
            authorized_mr_todo,
            authorized_issue_todo,
            confidential_issue_todo,
            confidential_note_todo,
            authorized_design_todo
          ]
        end

        let(:unauthorized_todos) do
          [
            unauthorized_mr_todo,
            unauthorized_issue_todo,
            unauthorized_note_todo,
            unauthorized_design_todo
          ]
        end
      end
    end

    context 'with guest user' do
      before_all do
        authorized_group.add_guest(user)
      end

      it_behaves_like 'allowed Todos filter' do
        let(:authorized_todos) do
          [
            authorized_issue_todo,
            authorized_design_todo
          ]
        end

        let(:unauthorized_todos) do
          [
            authorized_mr_todo,
            confidential_issue_todo,
            confidential_note_todo,
            unauthorized_mr_todo,
            unauthorized_issue_todo,
            unauthorized_note_todo,
            unauthorized_design_todo
          ]
        end
      end
    end

    context 'with a non-member user' do
      it_behaves_like 'allowed Todos filter' do
        let(:authorized_todos) { [] }

        let(:unauthorized_todos) do
          [
            authorized_issue_todo,
            authorized_design_todo,
            authorized_mr_todo,
            confidential_issue_todo,
            confidential_note_todo,
            unauthorized_mr_todo,
            unauthorized_issue_todo,
            unauthorized_note_todo,
            unauthorized_design_todo
          ]
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Todos
  module Destroy
    class UnauthorizedFeaturesService < ::Todos::Destroy::BaseService
      attr_reader :project_id, :user_id

      BATCH_SIZE = 1000

      def initialize(project_id, user_id = nil)
        @project_id = project_id
        @user_id = user_id
      end

      # rubocop: disable CodeReuse/ActiveRecord
      def execute
        return if user_id && authorized_users.where(user_id: user_id).exists?

        related_todos.each_batch(of: BATCH_SIZE) do |batch|
          pending_delete = without_authorized(batch).includes(:target, :user).reject do |todo|
            Ability.allowed?(todo.user, :read_todo, todo, scope: :user)
          end
          Todo.where(id: pending_delete).delete_all if pending_delete.present?
        end
      end
      # rubocop: enable CodeReuse/ActiveRecord

      private

      def without_authorized(items)
        items.not_in_users(authorized_users)
      end

      def authorized_users
        ProjectAuthorization.select(:user_id).for_project(project_ids)
      end

      def related_todos
        base_scope = Todo.for_project(project_id)
        base_scope = base_scope.for_user(user_id) if user_id
        base_scope
      end

      # Compatibility for #authorized_users in this class we always work
      # with 1 project for queries efficiency
      def project_ids
        [project_id]
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Todos::Destroy::UnauthorizedFeaturesService, feature_category: :team_planning do
  let_it_be(:project, reload: true) { create(:project, :public, :repository) }
  let_it_be(:issue)          { create(:issue, project: project) }
  let_it_be(:mr)             { create(:merge_request, source_project: project) }
  let_it_be(:user)           { create(:user) }
  let_it_be(:another_user)   { create(:user) }
  let_it_be(:project_member) do
    create(:user).tap do |user|
      project.add_developer(user)
    end
  end

  let!(:todo_mr_non_member)      { create(:todo, user: user, target: mr, project: project) }
  let!(:todo_mr_non_member2)     { create(:todo, user: another_user, target: mr, project: project) }
  let!(:todo_mr_member)          { create(:todo, user: project_member, target: mr, project: project) }
  let!(:todo_issue_non_member)   { create(:todo, user: user, target: issue, project: project) }
  let!(:todo_issue_non_member2)  { create(:todo, user: another_user, target: issue, project: project) }
  let!(:todo_issue_member)       { create(:todo, user: project_member, target: issue, project: project) }
  let!(:commit_todo_non_member)  { create(:on_commit_todo, user: user, project: project) }
  let!(:commit_todo_non_member2) { create(:on_commit_todo, user: another_user, project: project) }
  let!(:commit_todo_member)      { create(:on_commit_todo, user: project_member, project: project) }

  context 'when user_id is provided' do
    subject { described_class.new(project.id, user.id).execute }

    context 'when all features have same visibility as the project' do
      it 'removes only user issue todos' do
        expect { subject }.not_to change { Todo.count }
      end
    end

    context 'when issues are visible only to project members but the user is a member' do
      before do
        project.project_feature.update!(issues_access_level: ProjectFeature::PRIVATE)
        project.add_developer(user)
      end

      it 'does not remove any todos' do
        expect { subject }.not_to change { Todo.count }
      end
    end

    context 'when issues are visible only to project members' do
      before do
        project.project_feature.update!(issues_access_level: ProjectFeature::PRIVATE)
      end

      it 'removes only user issue todos' do
        expect { subject }.to change { Todo.count }.from(9).to(8)
      end
    end

    context 'when mrs, builds and repository are visible only to project members' do
      before do
        # builds and merge requests cannot have higher visibility than repository
        project.project_feature.update!(merge_requests_access_level: ProjectFeature::PRIVATE)
        project.project_feature.update!(builds_access_level: ProjectFeature::PRIVATE)
        project.project_feature.update!(repository_access_level: ProjectFeature::PRIVATE)
      end

      it 'removes only user mr and commit todos' do
        expect { subject }.to change { Todo.count }.from(9).to(7)
      end
    end

    context 'when mrs are visible only to project members' do
      before do
        project.project_feature.update!(merge_requests_access_level: ProjectFeature::PRIVATE)
      end

      it 'removes only user merge request todo' do
        expect { subject }.to change { Todo.count }.from(9).to(8)
      end
    end

    context 'when mrs and issues are visible only to project members' do
      before do
        project.project_feature.update!(issues_access_level: ProjectFeature::PRIVATE)
        project.project_feature.update!(merge_requests_access_level: ProjectFeature::PRIVATE)
      end

      it 'removes only user merge request and issue todos' do
        expect { subject }.to change { Todo.count }.from(9).to(7)
      end
    end
  end

  context 'when user_id is not provided' do
    subject { described_class.new(project.id).execute }

    context 'when all features have same visibility as the project' do
      it 'does not remove any todos' do
        expect { subject }.not_to change { Todo.count }
      end
    end

    context 'when issues are visible only to project members' do
      before do
        project.project_feature.update!(issues_access_level: ProjectFeature::PRIVATE)
      end

      it 'removes only non members issue todos' do
        expect { subject }.to change { Todo.count }.from(9).to(7)
      end
    end

    context 'when mrs, builds and repository are visible only to project members' do
      before do
        # builds and merge requests cannot have higher visibility than repository
        project.project_feature.update!(merge_requests_access_level: ProjectFeature::PRIVATE)
        project.project_feature.update!(builds_access_level: ProjectFeature::PRIVATE)
        project.project_feature.update!(repository_access_level: ProjectFeature::PRIVATE)
      end

      it 'removes only non members mr and commit todos' do
        expect { subject }.to change { Todo.count }.from(9).to(5)
      end
    end

    context 'when mrs are visible only to project members' do
      before do
        project.project_feature.update!(merge_requests_access_level: ProjectFeature::PRIVATE)
      end

      it 'removes only non members merge request todos' do
        expect { subject }.to change { Todo.count }.from(9).to(7)
      end
    end

    context 'when mrs and issues are visible only to project members' do
      before do
        project.project_feature.update!(issues_access_level: ProjectFeature::PRIVATE)
        project.project_feature.update!(merge_requests_access_level: ProjectFeature::PRIVATE)
      end

      it 'removes only non members merge request and issue todos' do
        expect { subject }.to change { Todo.count }.from(9).to(5)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Todos
  module Destroy
    class DestroyedIssuableService
      BATCH_SIZE = 100

      # Since we are moving towards work items, in some instances we create todos with
      # `target_type: WorkItem` in other instances we still create todos with `target_type: Issue`
      # So when an issue/work item is deleted, we just make sure to delete todos for both target types
      BOUND_TARGET_TYPES = %w[Issue WorkItem].freeze

      def initialize(target_id, target_type)
        @target_id = target_id
        @target_type = BOUND_TARGET_TYPES.include?(target_type) ? BOUND_TARGET_TYPES : target_type
      end

      def execute
        inner_query = Todo.select(:id).for_target(target_id).for_type(target_type).limit(BATCH_SIZE)

        delete_query = <<~SQL
        DELETE FROM ""#{Todo.table_name}""
        WHERE id IN (#{inner_query.to_sql})
        RETURNING user_id
        SQL

        loop do
          result = Todo.connection.execute(delete_query)

          break if result.cmd_tuples == 0

          user_ids = result.map { |row| row['user_id'] }.uniq

          invalidate_todos_cache_counts(user_ids)
        end
      end

      private

      attr_reader :target_id, :target_type

      def invalidate_todos_cache_counts(user_ids)
        user_ids.each do |id|
          # Only build a user instance since we only need its ID for
          # `User#invalidate_todos_cache_counts` to work.
          User.new(id: id).invalidate_todos_cache_counts
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Todos::Destroy::DestroyedIssuableService, feature_category: :team_planning do
  describe '#execute' do
    let_it_be(:user) { create(:user) }

    subject { described_class.new(target.id, target.class.name).execute }

    context 'when target is merge request' do
      let_it_be(:target) { create(:merge_request) }
      let_it_be(:pending_todo) { create(:todo, :pending, project: target.project, target: target, user: user) }
      let_it_be(:done_todo) { create(:todo, :done, project: target.project, target: target, user: user) }

      it 'deletes todos for specified target ID and type' do
        control_count = ActiveRecord::QueryRecorder.new { subject }.count

        # Create more todos for the target
        create(:todo, :pending, project: target.project, target: target, user: user)
        create(:todo, :pending, project: target.project, target: target, user: user)
        create(:todo, :done, project: target.project, target: target, user: user)
        create(:todo, :done, project: target.project, target: target, user: user)

        expect { subject }.not_to exceed_query_limit(control_count)
      end

      it 'invalidates todos cache counts of todo users', :use_clean_rails_redis_caching do
        expect { subject }
          .to change { pending_todo.user.todos_pending_count }.from(1).to(0)
                .and change { done_todo.user.todos_done_count }.from(1).to(0)
      end
    end

    context 'when target is an work item' do
      let_it_be(:target) { create(:work_item) }
      let_it_be(:todo1) { create(:todo, :pending, project: target.project, target: target, user: user) }
      let_it_be(:todo2) { create(:todo, :done, project: target.project, target: target, user: user) }
      # rubocop: disable Cop/AvoidBecomes
      let_it_be(:todo3) { create(:todo, :pending, project: target.project, target: target.becomes(Issue), user: user) }
      let_it_be(:todo4) { create(:todo, :done, project: target.project, target: target.becomes(Issue), user: user) }
      # rubocop: enable Cop/AvoidBecomes

      it 'deletes todos' do
        expect { subject }.to change(Todo, :count).by(-4)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Todos
  module Destroy
    # Service class for deleting todos that belongs to a deleted/archived design.
    class DesignService
      attr_reader :design_ids

      def initialize(design_ids)
        @design_ids = design_ids
      end

      def execute
        todos.delete_all
      end

      private

      def todos
        Todo.for_target(deleted_designs.select(:design_id)).for_type(DesignManagement::Design)
      end

      def deleted_designs
        DesignManagement::Action.by_design(design_ids).by_event(:deletion)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Todos::Destroy::DesignService, feature_category: :design_management do
  let_it_be(:user)     { create(:user) }
  let_it_be(:user_2)   { create(:user) }
  let_it_be(:design)   { create(:design) }
  let_it_be(:design_2) { create(:design) }
  let_it_be(:design_3) { create(:design) }

  let_it_be(:create_action)   { create(:design_action, design: design) }
  let_it_be(:create_action_2) { create(:design_action, design: design_2) }

  describe '#execute' do
    before do
      create(:todo, user: user, target: design)
      create(:todo, user: user_2, target: design)
      create(:todo, user: user, target: design_2)
      create(:todo, user: user, target: design_3)
    end

    subject { described_class.new([design.id, design_2.id, design_3.id]).execute }

    context 'when the design has been archived' do
      let_it_be(:archive_action) { create(:design_action, design: design, event: :deletion) }
      let_it_be(:archive_action_2) { create(:design_action, design: design_3, event: :deletion) }

      it 'removes todos for that design' do
        expect { subject }.to change { Todo.count }.from(4).to(1)
      end
    end

    context 'when no design has been archived' do
      it 'does not remove any todos' do
        expect { subject }.not_to change { Todo.count }.from(4)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Todos
  module Destroy
    class GroupPrivateService < ::Todos::Destroy::BaseService
      extend ::Gitlab::Utils::Override

      attr_reader :group

      def initialize(group_id)
        @group = Group.find_by_id(group_id)
      end

      def execute
        return unless todos_to_remove?

        delete_todos
      end

      private

      def delete_todos
        authorized_users = Member.from_union(
          [
            group.descendant_project_members_with_inactive.select(:user_id),
            group.members_with_parents.select(:user_id)
          ],
          remove_duplicates: false
        ).select(:user_id)

        todos.not_in_users(authorized_users).delete_all
      end

      def todos
        Todo.for_group(group.id)
      end

      def todos_to_remove?
        group&.private?
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Todos::Destroy::GroupPrivateService, feature_category: :team_planning do
  let(:group)         { create(:group, :public) }
  let(:project)       { create(:project, group: group) }
  let(:user)          { create(:user) }
  let(:group_member)  { create(:user) }
  let(:project_member)  { create(:user) }

  let!(:todo_non_member)         { create(:todo, user: user, group: group) }
  let!(:todo_another_non_member) { create(:todo, user: user, group: group) }
  let!(:todo_group_member)       { create(:todo, user: group_member, group: group) }
  let!(:todo_project_member)     { create(:todo, user: project_member, group: group) }

  describe '#execute', :aggregate_failures do
    before do
      group.add_developer(group_member)
      project.add_developer(project_member)
    end

    subject { described_class.new(group.id).execute }

    context 'when a group set to private' do
      before do
        group.update!(visibility_level: Gitlab::VisibilityLevel::PRIVATE)
      end

      it 'removes todos only for users who are not group users' do
        expect { subject }.to change { Todo.count }.from(4).to(2)

        expect(user.todos).to be_empty
        expect(group_member.todos).to match_array([todo_group_member])
        expect(project_member.todos).to match_array([todo_project_member])
      end

      context 'with nested groups' do
        let(:parent_group) { create(:group) }
        let(:subgroup)     { create(:group, :private, parent: group) }
        let(:subproject)   { create(:project, group: subgroup) }

        let(:parent_member)  { create(:user) }
        let(:subgroup_member)  { create(:user) }
        let(:subgproject_member) { create(:user) }

        let!(:todo_parent_member)     { create(:todo, user: parent_member, group: group) }
        let!(:todo_subgroup_member)   { create(:todo, user: subgroup_member, group: group) }
        let!(:todo_subproject_member) { create(:todo, user: subgproject_member, group: group) }

        before do
          group.update!(parent: parent_group)

          parent_group.add_developer(parent_member)
          subgroup.add_developer(subgroup_member)
          subproject.add_developer(subgproject_member)
        end

        it 'removes todos only for users who are not group users' do
          expect { subject }.to change { Todo.count }.from(7).to(4)

          expect(parent_member.todos).to contain_exactly(todo_parent_member)
          expect(subgroup_member.todos).to be_empty
          expect(subgproject_member.todos).to contain_exactly(todo_subproject_member)
        end
      end

      context 'with member via group share' do
        let(:invited_group) { create(:group) }
        let(:invited_group_member) { create(:user).tap { |u| invited_group.add_guest(u) } }

        let!(:todo_invited_group_member) { create(:todo, user: invited_group_member, group: group) }

        it 'does not remove todos for users invited to the group' do
          create(:group_group_link, shared_group: group, shared_with_group: invited_group)

          expect { subject }.to change { Todo.count }.from(5).to(3)

          expect(invited_group_member.todos).to contain_exactly(todo_invited_group_member)
        end

        it 'does not remove todos for users invited to an ancestor group' do
          parent_group = create(:group)
          group.update!(parent: parent_group)

          create(:group_group_link, shared_group: parent_group, shared_with_group: invited_group)

          expect { subject }.to change { Todo.count }.from(5).to(3)

          expect(invited_group_member.todos).to contain_exactly(todo_invited_group_member)
        end
      end
    end

    context 'when group is not private' do
      it 'does not remove any todos' do
        expect { subject }.not_to change { Todo.count }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Todos
  module Destroy
    class ProjectPrivateService < ::Todos::Destroy::BaseService
      extend ::Gitlab::Utils::Override

      attr_reader :project

      def initialize(project_id)
        @project = Project.find_by_id(project_id)
      end

      def execute
        return unless todos_to_remove?

        delete_todos
      end

      private

      def delete_todos
        authorized_users = ProjectAuthorization.select(:user_id).for_project(project_ids)

        todos.not_in_users(authorized_users).delete_all
      end

      def todos
        Todo.for_project(project.id)
      end

      def project_ids
        project.id
      end

      def todos_to_remove?
        project&.private?
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Todos::Destroy::ProjectPrivateService, feature_category: :team_planning do
  let(:group)          { create(:group, :public) }
  let(:project)        { create(:project, :public, group: group) }
  let(:user)           { create(:user) }
  let(:project_member) { create(:user) }
  let(:group_member)   { create(:user) }

  let!(:todo_non_member)   { create(:todo, user: user, project: project) }
  let!(:todo2_non_member)  { create(:todo, user: user, project: project) }
  let!(:todo_member)       { create(:todo, user: project_member, project: project) }
  let!(:todo_group_member) { create(:todo, user: group_member, project: project) }

  describe '#execute' do
    before do
      project.add_developer(project_member)
      group.add_developer(group_member)
    end

    subject { described_class.new(project.id).execute }

    context 'when a project set to private' do
      before do
        project.update!(visibility_level: Gitlab::VisibilityLevel::PRIVATE)
      end

      it 'removes issue todos for a user who is not a member' do
        expect { subject }.to change { Todo.count }.from(4).to(2)

        expect(user.todos).to be_empty
        expect(project_member.todos).to match_array([todo_member])
        expect(group_member.todos).to match_array([todo_group_member])
      end
    end

    context 'when project is not private' do
      it 'does not remove any todos' do
        expect { subject }.not_to change { Todo.count }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Todos
  module Destroy
    class EntityLeaveService < ::Todos::Destroy::BaseService
      extend ::Gitlab::Utils::Override

      attr_reader :user, :entity

      def initialize(user_id, entity_id, entity_type)
        unless %w[Group Project].include?(entity_type)
          raise ArgumentError, ""#{entity_type} is not an entity user can leave""
        end

        @user = UserFinder.new(user_id).find_by_id
        @entity = entity_type.constantize.find_by(id: entity_id) # rubocop: disable CodeReuse/ActiveRecord
      end

      def execute
        return unless entity && user

        # if at least reporter, all entities including confidential issues can be accessed
        return if user_has_reporter_access?

        remove_confidential_resource_todos
        remove_group_todos

        if entity.private?
          remove_project_todos
        else
          enqueue_private_features_worker
        end
      end

      private

      def enqueue_private_features_worker
        projects.each do |project|
          TodosDestroyer::PrivateFeaturesWorker.perform_async(project.id, user.id)
        end
      end

      def remove_confidential_resource_todos
        # Deletes todos for confidential issues
        Todo
          .for_target(confidential_issues.select(:id))
          .for_type(Issue.name)
          .for_user(user)
          .delete_all

        # Deletes todos for internal notes on unauthorized projects
        Todo
          .for_type(Issue.name)
          .for_internal_notes
          .for_project(non_authorized_reporter_projects) # Only Reporter+ can read internal notes
          .for_user(user)
          .delete_all
      end

      def remove_project_todos
        # Issues are viewable by guests (even in private projects), so remove those todos
        # from projects without guest access
        Todo
          .for_project(non_authorized_guest_projects)
          .for_user(user)
          .delete_all

        # MRs require reporter access, so remove those todos that are not authorized
        Todo
          .for_project(non_authorized_reporter_projects)
          .for_type(MergeRequest.name)
          .for_user(user)
          .delete_all
      end

      def remove_group_todos
        return unless entity.is_a?(Namespace)

        Todo
          .for_group(unauthorized_private_groups)
          .for_user(user)
          .delete_all
      end

      def projects
        condition = case entity
                    when Project
                      { id: entity.id }
                    when Namespace
                      { namespace_id: non_authorized_reporter_groups }
                    end

        Project.where(condition) # rubocop: disable CodeReuse/ActiveRecord
      end

      def authorized_reporter_projects
        user.authorized_projects(Gitlab::Access::REPORTER).select(:id)
      end

      def authorized_guest_projects
        user.authorized_projects(Gitlab::Access::GUEST).select(:id)
      end

      def non_authorized_reporter_projects
        projects.id_not_in(authorized_reporter_projects)
      end

      def non_authorized_guest_projects
        projects.id_not_in(authorized_guest_projects)
      end

      def authorized_reporter_groups
        GroupsFinder.new(user, min_access_level: Gitlab::Access::REPORTER).execute.select(:id)
      end

      # rubocop: disable CodeReuse/ActiveRecord
      def unauthorized_private_groups
        return [] unless entity.is_a?(Namespace)

        groups = entity.self_and_descendants.private_only

        groups.select(:id)
          .id_not_in(GroupsFinder.new(user, all_available: false).execute.select(:id).reorder(nil))
      end
      # rubocop: enable CodeReuse/ActiveRecord

      def non_authorized_reporter_groups
        entity.self_and_descendants.select(:id)
          .id_not_in(authorized_reporter_groups)
      end

      def user_has_reporter_access?
        return unless entity.is_a?(Namespace)

        entity.member?(User.find(user.id), Gitlab::Access::REPORTER)
      end

      def confidential_issues
        assigned_ids = IssueAssignee.select(:issue_id).for_assignee(user)

        Issue
          .in_projects(projects)
          .confidential_only
          .not_in_projects(authorized_reporter_projects)
          .not_authored_by(user)
          .id_not_in(assigned_ids)
      end
    end
  end
end

Todos::Destroy::EntityLeaveService.prepend_mod_with('Todos::Destroy::EntityLeaveService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Todos::Destroy::EntityLeaveService, feature_category: :team_planning do
  let_it_be(:user, reload: true) { create(:user) }
  let_it_be(:user2, reload: true) { create(:user) }
  let_it_be_with_refind(:group) { create(:group, :private) }
  let_it_be(:project) { create(:project, :private, group: group) }

  let(:issue) { create(:issue, project: project) }
  let(:issue_c) { create(:issue, project: project, confidential: true) }
  let!(:todo_group_user) { create(:todo, user: user, group: group) }
  let!(:todo_group_user2) { create(:todo, user: user2, group: group) }
  let(:mr) { create(:merge_request, source_project: project) }
  let!(:todo_mr_user) { create(:todo, user: user, target: mr, project: project) }
  let!(:todo_issue_user) { create(:todo, user: user, target: issue, project: project) }
  let!(:todo_issue_c_user) { create(:todo, user: user, target: issue_c, project: project) }
  let!(:todo_issue_c_user2) { create(:todo, user: user2, target: issue_c, project: project) }
  let(:internal_note) { create(:note, noteable: issue, project: project, confidential: true) }
  let!(:todo_for_internal_note) do
    create(:todo, user: user, target: issue, project: project, note: internal_note)
  end

  shared_examples 'using different access permissions' do
    before do
      set_access(project, user, project_access) if project_access
      set_access(group, user, group_access) if group_access
    end

    it params[:method].to_s.humanize(capitalize: false) do
      send(method_name)
    end
  end

  shared_examples 'does not remove any todos' do
    it { does_not_remove_any_todos }
  end

  shared_examples 'removes confidential issues and internal notes todos' do
    it { removes_confidential_issues_and_internal_notes_todos }
  end

  shared_examples 'removes only internal notes todos' do
    it { removes_only_internal_notes_todos }
  end

  def does_not_remove_any_todos
    expect { subject }.not_to change { Todo.count }
  end

  def removes_only_internal_notes_todos
    expect { subject }.to change { Todo.count }.from(7).to(6)
  end

  def removes_confidential_issues_and_internal_notes_todos
    expect { subject }.to change { Todo.count }.from(7).to(5)
  end

  def removes_confidential_issues_and_internal_notes_and_merge_request_todos
    expect { subject }.to change { Todo.count }.from(7).to(4)
    expect(user.todos).to match_array([todo_issue_user, todo_group_user])
  end

  def set_access(object, user, access_name)
    case access_name
    when :developer
      object.add_developer(user)
    when :reporter
      object.add_reporter(user)
    when :guest
      object.add_guest(user)
    end
  end

  describe '#execute' do
    describe 'updating a Project' do
      subject { described_class.new(user.id, project.id, 'Project').execute }

      # a private project in a private group is valid
      context 'when project is private' do
        context 'when user is not a member of the project' do
          it 'removes project todos for the provided user' do
            expect { subject }.to change { Todo.count }.from(7).to(3)

            expect(user.todos).to match_array([todo_group_user])
            expect(user2.todos).to match_array([todo_issue_c_user2, todo_group_user2])
          end
        end

        context 'access permissions' do
          where(:group_access, :project_access, :method_name) do
            [
              [nil,       :reporter, :does_not_remove_any_todos],
              [nil,       :guest,    :removes_confidential_issues_and_internal_notes_and_merge_request_todos],
              [:reporter, nil,       :does_not_remove_any_todos],
              [:guest,    nil,       :removes_confidential_issues_and_internal_notes_and_merge_request_todos],
              [:guest,    :reporter, :does_not_remove_any_todos],
              [:guest,    :guest,    :removes_confidential_issues_and_internal_notes_and_merge_request_todos]
            ]
          end

          with_them do
            it_behaves_like 'using different access permissions'
          end
        end
      end

      # a private project in an internal/public group is valid
      context 'when project is private in an internal/public group' do
        let_it_be(:group) { create(:group, :internal) }
        let_it_be(:project) { create(:project, :private, group: group) }

        context 'when user is not a member of the project' do
          it 'removes project todos for the provided user' do
            expect { subject }.to change { Todo.count }.from(7).to(3)

            expect(user.todos).to match_array([todo_group_user])
            expect(user2.todos).to match_array([todo_issue_c_user2, todo_group_user2])
          end
        end

        context 'access permissions' do
          where(:group_access, :project_access, :method_name) do
            [
              [nil,       :reporter, :does_not_remove_any_todos],
              [nil,       :guest,    :removes_confidential_issues_and_internal_notes_and_merge_request_todos],
              [:reporter, nil,       :does_not_remove_any_todos],
              [:guest,    nil,       :removes_confidential_issues_and_internal_notes_and_merge_request_todos],
              [:guest,    :reporter, :does_not_remove_any_todos],
              [:guest,    :guest,    :removes_confidential_issues_and_internal_notes_and_merge_request_todos]
            ]
          end

          with_them do
            it_behaves_like 'using different access permissions'
          end
        end
      end

      # an internal project in an internal/public group is valid
      context 'when project is not private' do
        let(:group)   { create(:group, :internal) }
        let(:project) { create(:project, :internal, group: group) }
        let(:issue)   { create(:issue, project: project) }
        let(:issue_c) { create(:issue, project: project, confidential: true) }

        it 'enqueues the PrivateFeaturesWorker' do
          expect(TodosDestroyer::PrivateFeaturesWorker)
            .to receive(:perform_async).with(project.id, user.id)

          subject
        end

        context 'confidential issues' do
          context 'when a user is not an author of confidential issue' do
            it_behaves_like 'removes confidential issues and internal notes todos'
          end

          context 'when a user is an author of confidential issue' do
            before do
              issue_c.update!(author: user)
            end

            it_behaves_like 'removes only internal notes todos'
          end

          context 'when a user is an assignee of confidential issue' do
            before do
              issue_c.assignees << user
            end

            it_behaves_like 'removes only internal notes todos'
          end

          context 'access permissions' do
            where(:group_access, :project_access, :method_name) do
              [
                [nil,       :reporter, :does_not_remove_any_todos],
                [nil,       :guest,    :removes_confidential_issues_and_internal_notes_todos],
                [:reporter, nil,       :does_not_remove_any_todos],
                [:guest,    nil,       :removes_confidential_issues_and_internal_notes_todos],
                [:guest,    :reporter, :does_not_remove_any_todos],
                [:guest,    :guest,    :removes_confidential_issues_and_internal_notes_todos]
              ]
            end

            with_them do
              it_behaves_like 'using different access permissions'
            end
          end
        end

        context 'feature visibility check' do
          context 'when issues are visible only to project members' do
            before do
              project.project_feature.update!(issues_access_level: ProjectFeature::PRIVATE)
            end

            it 'removes only users issue todos' do
              expect { subject }.to change { Todo.count }.from(7).to(5)
            end
          end
        end
      end
    end

    describe 'updating a Group' do
      subject { described_class.new(user.id, group.id, 'Group').execute }

      context 'when group is private' do
        context 'when a user leaves a group' do
          it 'removes group and subproject todos for the user' do
            expect { subject }.to change { Todo.count }.from(7).to(2)

            expect(user.todos).to be_empty
            expect(user2.todos).to match_array([todo_issue_c_user2, todo_group_user2])
          end
        end

        context 'access permissions' do
          where(:group_access, :project_access, :method_name) do
            [
              [nil,       :reporter, :does_not_remove_any_todos],
              [nil,       :guest,    :removes_confidential_issues_and_internal_notes_and_merge_request_todos],
              [:reporter, nil,       :does_not_remove_any_todos],
              [:guest,    nil,       :removes_confidential_issues_and_internal_notes_and_merge_request_todos],
              [:guest,    :reporter, :does_not_remove_any_todos],
              [:guest,    :guest,    :removes_confidential_issues_and_internal_notes_and_merge_request_todos]
            ]
          end

          with_them do
            it_behaves_like 'using different access permissions'
          end
        end

        context 'with nested groups' do
          let_it_be_with_refind(:parent_group) { create(:group, :public) }
          let_it_be_with_refind(:parent_subgroup) { create(:group) }
          let_it_be(:subgroup) { create(:group, :private, parent: group) }
          let_it_be(:subgroup2) { create(:group, :private, parent: group) }
          let_it_be(:subproject) { create(:project, group: subgroup) }
          let_it_be(:subproject2) { create(:project, group: subgroup2) }

          let!(:todo_subproject_user) { create(:todo, user: user, project: subproject) }
          let!(:todo_subproject2_user) { create(:todo, user: user, project: subproject2) }
          let!(:todo_subgroup_user) { create(:todo, user: user, group: subgroup) }
          let!(:todo_subgroup2_user) { create(:todo, user: user, group: subgroup2) }
          let!(:todo_subproject_user2) { create(:todo, user: user2, project: subproject) }
          let!(:todo_subpgroup_user2)  { create(:todo, user: user2, group: subgroup) }
          let!(:todo_parent_group_user) { create(:todo, user: user, group: parent_group) }
          let(:subproject_internal_note) { create(:note, noteable: issue, project: project, confidential: true) }
          let!(:todo_for_internal_subproject_note) do
            create(:todo, user: user, target: issue, project: project, note: subproject_internal_note)
          end

          before do
            group.update!(parent: parent_group)
          end

          context 'when the user is not a member of any groups/projects' do
            it 'removes todos for the user including subprojects todos' do
              expect { subject }.to change { Todo.count }.from(15).to(5)

              expect(user.todos).to eq([todo_parent_group_user])
              expect(user2.todos)
                .to match_array(
                  [todo_issue_c_user2, todo_group_user2, todo_subproject_user2, todo_subpgroup_user2]
                )
            end
          end

          context 'when the user is member of a parent group' do
            before do
              parent_group.add_developer(user)
            end

            it_behaves_like 'does not remove any todos'
          end

          context 'when the user is member of a subgroup' do
            before do
              subgroup.add_developer(user)
            end

            it 'does not remove group and subproject todos' do
              expect { subject }.to change { Todo.count }.from(15).to(8)

              expect(user.todos)
                .to match_array(
                  [todo_group_user, todo_subgroup_user, todo_subproject_user, todo_parent_group_user]
                )
              expect(user2.todos)
                .to match_array(
                  [todo_issue_c_user2, todo_group_user2, todo_subproject_user2, todo_subpgroup_user2]
                )
            end
          end

          context 'when the user is member of a child project' do
            before do
              subproject.add_developer(user)
            end

            it 'does not remove subproject and group todos' do
              expect { subject }.to change { Todo.count }.from(15).to(8)

              expect(user.todos)
                .to match_array(
                  [todo_subgroup_user, todo_group_user, todo_subproject_user, todo_parent_group_user]
                )
              expect(user2.todos)
                .to match_array(
                  [todo_issue_c_user2, todo_group_user2, todo_subproject_user2, todo_subpgroup_user2]
                )
            end
          end
        end
      end

      context 'when group is not private' do
        let(:group)   { create(:group, :internal) }
        let(:project) { create(:project, :internal, group: group) }
        let(:issue)   { create(:issue, project: project) }
        let(:issue_c) { create(:issue, project: project, confidential: true) }

        it 'enqueues the PrivateFeaturesWorker' do
          expect(TodosDestroyer::PrivateFeaturesWorker)
            .to receive(:perform_async).with(project.id, user.id)

          subject
        end

        context 'access permissions' do
          where(:group_access, :project_access, :method_name) do
            [
              [nil,       nil,       :removes_confidential_issues_and_internal_notes_todos],
              [nil,       :reporter, :does_not_remove_any_todos],
              [nil,       :guest,    :removes_confidential_issues_and_internal_notes_todos],
              [:reporter, nil,       :does_not_remove_any_todos],
              [:guest,    nil,       :removes_confidential_issues_and_internal_notes_todos],
              [:guest,    :reporter, :does_not_remove_any_todos],
              [:guest,    :guest,    :removes_confidential_issues_and_internal_notes_todos]
            ]
          end

          with_them do
            it_behaves_like 'using different access permissions'
          end
        end
      end
    end

    context 'when entity type is not valid' do
      it 'raises an exception' do
        expect { described_class.new(user.id, group.id, 'GroupWrongly').execute }
          .to raise_error(ArgumentError)
      end
    end

    context 'when entity was not found' do
      it 'does not remove any todos' do
        expect { described_class.new(user.id, non_existing_record_id, 'Group').execute }
          .not_to change { Todo.count }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Todos
  module Destroy
    # Service class for deleting todos that belongs to confidential issues.
    # It deletes todos for users that are not at least reporters, issue author or assignee.
    #
    # Accepts issue_id or project_id as argument.
    # When issue_id is passed it deletes matching todos for one confidential issue.
    # When project_id is passed it deletes matching todos for all confidential issues of the project.
    class ConfidentialIssueService < ::Todos::Destroy::BaseService
      attr_reader :issues

      def initialize(issue_id: nil, project_id: nil)
        @issues =
          if issue_id
            Issue.id_in(issue_id)
          elsif project_id
            project_confidential_issues(project_id)
          end
      end

      def execute
        return unless todos_to_remove?

        ::Gitlab::Database.allow_cross_joins_across_databases(
          url: 'https://gitlab.com/gitlab-org/gitlab/-/issues/422045') do
          delete_todos
        end
      end

      private

      def delete_todos
        authorized_users = ProjectAuthorization.select(:user_id)
          .for_project(project_ids)
          .non_guests

        todos.not_in_users(authorized_users).delete_all
      end

      def project_confidential_issues(project_id)
        project = Project.find(project_id)

        project.issues.confidential_only
      end

      # rubocop: disable CodeReuse/ActiveRecord
      def todos
        Todo.joins_issue_and_assignees
          .for_target(issues)
          .merge(Issue.confidential_only)
          .where('todos.user_id != issues.author_id')
          .where('todos.user_id != issue_assignees.user_id')
      end
      # rubocop: enable CodeReuse/ActiveRecord

      def todos_to_remove?
        issues&.any?(&:confidential?)
      end

      def project_ids
        issues&.distinct&.select(:project_id)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Todos::Destroy::ConfidentialIssueService, feature_category: :team_planning do
  let(:project)        { create(:project, :public) }
  let(:user)           { create(:user) }
  let(:author)         { create(:user) }
  let(:assignee)       { create(:user) }
  let(:guest)          { create(:user) }
  let(:project_member) { create(:user) }
  let(:issue_1)        { create(:issue, :confidential, project: project, author: author, assignees: [assignee]) }

  describe '#execute' do
    before do
      project.add_developer(project_member)
      project.add_guest(guest)

      # todos not to be deleted
      create(:todo, user: project_member, target: issue_1, project: project)
      create(:todo, user: author, target: issue_1, project: project)
      create(:todo, user: assignee, target: issue_1, project: project)
      create(:todo, user: user, project: project)
      # Todos to be deleted
      create(:todo, user: guest, target: issue_1, project: project)
      create(:todo, user: user, target: issue_1, project: project)
    end

    subject { described_class.new(issue_id: issue_1.id).execute }

    context 'when issue_id parameter is present' do
      context 'when provided issue is confidential' do
        it 'removes issue todos for users who can not access the confidential issue' do
          expect { subject }.to change { Todo.count }.from(6).to(4)
        end
      end

      context 'when provided issue is not confidential' do
        it 'does not remove any todos' do
          issue_1.update!(confidential: false)

          expect { subject }.not_to change { Todo.count }
        end
      end
    end

    context 'when project_id parameter is present' do
      subject { described_class.new(issue_id: nil, project_id: project.id).execute }

      it 'removes issues todos for users that cannot access confidential issues' do
        issue_2 = create(:issue, :confidential, project: project)
        issue_3 = create(:issue, :confidential, project: project, author: author, assignees: [assignee])
        issue_4 = create(:issue, project: project)
        # Todos not to be deleted
        create(:todo, user: guest, target: issue_1, project: project)
        create(:todo, user: assignee, target: issue_1, project: project)
        create(:todo, user: project_member, target: issue_2, project: project)
        create(:todo, user: author, target: issue_3, project: project)
        create(:todo, user: user, target: issue_4, project: project)
        create(:todo, user: user, project: project)
        # Todos to be deleted
        create(:todo, user: user, target: issue_1, project: project)
        create(:todo, user: guest, target: issue_2, project: project)

        expect { subject }.to change { Todo.count }.from(14).to(10)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Events
  class DestroyService
    BATCH_SIZE = 50

    def initialize(project)
      @project = project
    end

    def execute
      loop do
        count = delete_events_in_batches
        break if count < BATCH_SIZE
      end

      ServiceResponse.success(message: 'Events were deleted.')
    rescue StandardError => e
      ServiceResponse.error(message: e.message)
    end

    private

    attr_reader :project

    def delete_events_in_batches
      project.events.limit(BATCH_SIZE).delete_all
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Events::DestroyService, feature_category: :user_profile do
  subject(:service) { described_class.new(project) }

  let_it_be(:project, reload: true) { create(:project, :repository) }
  let_it_be(:another_project) { create(:project) }
  let_it_be(:merge_request) { create(:merge_request, source_project: project) }
  let_it_be(:user) { create(:user) }

  let!(:unrelated_event) { create(:event, :merged, project: another_project, target: another_project, author: user) }

  before do
    create(:event, :created, project: project, target: project, author: user)
    create(:event, :created, project: project, target: merge_request, author: user)
    create(:event, :merged, project: project, target: merge_request, author: user)
  end

  let(:events) { project.events }

  describe '#execute', :aggregate_failures do
    it 'deletes the events' do
      response = nil

      expect { response = subject.execute }.to change(Event, :count).by(-3)

      expect(response).to be_success
      expect(unrelated_event.reload).to be_present
    end

    context 'batch delete' do
      before do
        stub_const(""#{described_class}::BATCH_SIZE"", 2)
      end

      it 'splits delete queries into batches' do
        expect(project).to receive(:events).twice.and_call_original

        subject.execute
      end
    end

    context 'when an error is raised while deleting the records' do
      before do
        allow(project).to receive_message_chain(:events, :limit, :delete_all).and_raise(ActiveRecord::ActiveRecordError, 'custom error')
      end

      it 'returns error' do
        response = subject.execute

        expect(response).to be_error
        expect(response.message).to eq 'custom error'
      end

      it 'does not delete events' do
        expect { subject.execute }.not_to change(Event, :count)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Events
  class RenderService < BaseRenderer
    def execute(events, atom_request: false)
      notes = events.map(&:note).compact

      render_notes(notes, atom_request)
    end

    private

    def render_notes(notes, atom_request)
      Notes::RenderService
        .new(current_user)
        .execute(notes, render_options(atom_request))
    end

    def render_options(atom_request)
      return {} unless atom_request

      { only_path: false, xhtml: true }
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Events::RenderService, feature_category: :user_profile do
  describe '#execute' do
    let!(:note) { build(:note) }
    let!(:event) { build(:event, target: note, project: note.project) }
    let!(:user) { build(:user) }

    context 'when the request format is atom' do
      it 'renders the note inside events' do
        expect(Banzai::ObjectRenderer).to receive(:new)
          .with(user: user, redaction_context: { only_path: false, xhtml: true })
          .and_call_original

        expect_any_instance_of(Banzai::ObjectRenderer)
          .to receive(:render).with([note], :note)

        described_class.new(user).execute([event], atom_request: true)
      end
    end

    context 'when the request format is not atom' do
      it 'renders the note inside events' do
        expect(Banzai::ObjectRenderer).to receive(:new)
          .with(user: user, redaction_context: {})
          .and_call_original

        expect_any_instance_of(Banzai::ObjectRenderer)
          .to receive(:render).with([note], :note)

        described_class.new(user).execute([event], atom_request: false)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Import
  class FogbugzService < Import::BaseService
    attr_reader :client, :params, :current_user

    def execute(credentials)
      url = credentials[:uri]

      if blocked_url?(url)
        return log_and_return_error(""Invalid URL: #{url}"", _(""Invalid URL: %{url}"") % { url: url }, :bad_request)
      end

      unless authorized?
        return log_and_return_error(
          ""You don't have permissions to import this project"",
          _(""You don't have permissions to import this project""),
          :unauthorized
        )
      end

      unless repo
        return log_and_return_error(
          ""Project #{repo_id} could not be found"",
          s_(""Fogbugz|Project %{repo} could not be found"") % { repo: repo_id },
          :unprocessable_entity)
      end

      project = create_project(credentials)

      if project.persisted?
        success(project)
      elsif project.errors[:import_source_disabled].present?
        error(project.errors[:import_source_disabled], :forbidden)
      else
        error(project_save_error(project), :unprocessable_entity)
      end
    rescue StandardError => e
      log_and_return_error(
        ""Fogbugz import failed due to an error: #{e}"",
        s_(""Fogbugz|Fogbugz import failed due to an error: %{error}"" % { error: e }),
        :bad_request)
    end

    private

    def create_project(credentials)
      Gitlab::FogbugzImport::ProjectCreator.new(
        repo,
        project_name,
        target_namespace,
        current_user,
        credentials,
        umap
      ).execute
    end

    def repo_id
      @repo_id ||= params[:repo_id]
    end

    def repo
      @repo ||= client.repo(repo_id)
    end

    def project_name
      @project_name ||= params[:new_name].presence || repo.name
    end

    def namespace_path
      @namespace_path ||= params[:target_namespace].presence || current_user.namespace_path
    end

    def target_namespace
      @target_namespace ||= find_or_create_namespace(namespace_path, current_user.namespace_path)
    end

    def umap
      @umap ||= params[:umap]
    end

    def allow_local_requests?
      Gitlab::CurrentSettings.allow_local_requests_from_web_hooks_and_services?
    end

    def blocked_url?(url)
      Gitlab::UrlBlocker.blocked_url?(
        url,
        allow_localhost: allow_local_requests?,
        allow_local_network: allow_local_requests?,
        schemes: %w[http https]
      )
    end

    def log_and_return_error(message, translated_message, error_type)
      log_error(message)
      error(translated_message, error_type)
    end

    def log_error(message)
      Gitlab::Import::Logger.error(
        message: 'Import failed due to a Fogbugz error',
        error: message
      )
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Import::FogbugzService, feature_category: :importers do
  let_it_be(:user) { create(:user) }

  let(:base_uri) { ""https://test:7990"" }
  let(:token) { ""asdasd12345"" }
  let(:repo_id) { ""fogbugz_id"" }
  let(:repo) { instance_double(Gitlab::FogbugzImport::Repository, name: 'test', raw_data: nil) }

  let(:client) { instance_double(Gitlab::FogbugzImport::Client) }
  let(:credentials) { { uri: base_uri, token: token } }
  let(:params) { { repo_id: repo_id } }

  subject { described_class.new(client, user, params) }

  before do
    allow(subject).to receive(:authorized?).and_return(true)
    stub_application_setting(import_sources: ['fogbugz'])
  end

  context 'when no repo is found' do
    before do
      allow(client).to receive(:repo).with(repo_id).and_return(nil)
    end

    it 'returns an error' do
      result = subject.execute(credentials)

      expect(result).to include(
        message: ""Project #{repo_id} could not be found"",
        status: :error,
        http_status: :unprocessable_entity
      )
    end
  end

  context 'when import source is disabled' do
    before do
      stub_application_setting(import_sources: nil)
      allow(client).to receive(:repo).with(repo_id).and_return(repo)
    end

    it 'returns forbidden' do
      result = subject.execute(credentials)

      expect(result).to include(
        status: :error,
        http_status: :forbidden
      )
    end
  end

  context 'when user is unauthorized' do
    before do
      allow(subject).to receive(:authorized?).and_return(false)
    end

    it 'returns an error' do
      result = subject.execute(credentials)

      expect(result).to include(
        message: ""You don't have permissions to import this project"",
        status: :error,
        http_status: :unauthorized
      )
    end
  end

  context 'verify url' do
    shared_examples 'denies local request' do
      before do
        allow(client).to receive(:repo).with(repo_id).and_return(repo)
      end

      it 'does not allow requests' do
        result = subject.execute(credentials)
        expect(result[:status]).to eq(:error)
        expect(result[:message]).to include(""Invalid URL:"")
      end
    end

    context 'when host is localhost' do
      let(:base_uri) { 'http://localhost:3000' }

      include_examples 'denies local request'
    end

    context 'when host is on local network' do
      let(:base_uri) { 'https://192.168.0.191' }

      include_examples 'denies local request'
    end

    context 'when host is ftp protocol' do
      let(:base_uri) { 'ftp://testing' }

      include_examples 'denies local request'
    end
  end

  context 'when import starts succesfully' do
    before do
      allow(client).to receive(:repo).with(repo_id).and_return(
        instance_double(Gitlab::FogbugzImport::Repository, name: 'test', raw_data: nil)
      )
    end

    it 'returns success' do
      result = subject.execute(credentials)

      expect(result[:status]).to eq(:success)
      expect(result[:project].name).to eq('test')
    end
  end

  context 'when import fails to start' do
    let(:error_messages_array) { instance_double(Array, join: ""something went wrong"") }
    let(:errors_double) { instance_double(ActiveModel::Errors, full_messages: error_messages_array, :[] => nil) }
    let(:project_double) { instance_double(Project, persisted?: false, errors: errors_double) }
    let(:project_creator) { instance_double(Gitlab::FogbugzImport::ProjectCreator, execute: project_double) }

    before do
      allow(Gitlab::FogbugzImport::ProjectCreator).to receive(:new).and_return(project_creator)
      allow(client).to receive(:repo).with(repo_id).and_return(
        instance_double(Gitlab::FogbugzImport::Repository, name: 'test', raw_data: nil)
      )
    end

    it 'returns error' do
      result = subject.execute(credentials)

      expect(result[:status]).to eq(:error)
      expect(result[:message]).to eq(""something went wrong"")
    end
  end

  it 'returns error for unknown error causes' do
    message = 'Not Implemented'
    exception = StandardError.new(message)

    allow(client).to receive(:repo).and_raise(exception)

    expect(subject.execute(credentials)).to include({
      status: :error,
      message: ""Fogbugz import failed due to an error: #{message}""
    })
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Import
  class PrepareService < ::BaseService
    def execute
      uploader = UploadService.new(project, params[:file]).execute

      if uploader
        enqueue_import(uploader.upload)

        ServiceResponse.success(message: success_message)
      else
        ServiceResponse.error(message: _('File upload error.'))
      end
    end

    private

    def enqueue_import(upload)
      worker.perform_async(current_user.id, project.id, upload.id)
    end

    def worker
      raise NotImplementedError
    end

    def success_message
      raise NotImplementedError
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Import::PrepareService, feature_category: :importers do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }

  let(:file) { double }
  let(:upload_service) { double }
  let(:uploader) { double }
  let(:upload) { double }

  let(:service) { described_class.new(project, user, file: file) }

  subject { service.execute }

  context 'when file is uploaded correctly' do
    let(:upload_id) { 99 }

    before do
      mock_upload
    end

    it 'raises NotImplemented error for worker' do
      expect { subject }.to raise_error(NotImplementedError)
    end

    context 'when a job is enqueued' do
      before do
        worker = double

        allow(service).to receive(:worker).and_return(worker)
        allow(worker).to receive(:perform_async)
      end

      it 'raises NotImplemented error for success_message when a job is enqueued' do
        expect { subject }.to raise_error(NotImplementedError)
      end

      it 'returns a success respnse when a success_message is implemented' do
        message = 'It works!'

        allow(service).to receive(:success_message).and_return(message)

        result = subject

        expect(result).to be_success
        expect(result.message).to eq(message)
      end
    end
  end

  context 'when file upload fails' do
    before do
      mock_upload(false)
    end

    it 'returns an error message' do
      result = subject

      expect(result[:status]).to eq(:error)
      expect(result[:message]).to eq('File upload error.')
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Import
  class ValidateRemoteGitEndpointService
    # Validates if the remote endpoint is a valid GIT repository
    # Only smart protocol is supported
    # Validation rules are taken from https://git-scm.com/docs/http-protocol#_smart_clients

    GIT_SERVICE_NAME = ""git-upload-pack""
    GIT_EXPECTED_FIRST_PACKET_LINE = ""# service=#{GIT_SERVICE_NAME}""
    GIT_BODY_MESSAGE_REGEXP = /^[0-9a-f]{4}#{GIT_EXPECTED_FIRST_PACKET_LINE}/
    # https://github.com/git/git/blob/master/Documentation/technical/protocol-common.txt#L56-L59
    GIT_PROTOCOL_PKT_LEN = 4
    GIT_MINIMUM_RESPONSE_LENGTH = GIT_PROTOCOL_PKT_LEN + GIT_EXPECTED_FIRST_PACKET_LINE.length
    EXPECTED_CONTENT_TYPE = ""application/x-#{GIT_SERVICE_NAME}-advertisement""
    INVALID_BODY_MESSAGE = 'Not a git repository: Invalid response body'
    INVALID_CONTENT_TYPE_MESSAGE = 'Not a git repository: Invalid content-type'

    def initialize(params)
      @params = params
    end

    def execute
      uri = Gitlab::Utils.parse_url(@params[:url])

      if !uri || !uri.hostname || Project::VALID_IMPORT_PROTOCOLS.exclude?(uri.scheme)
        return ServiceResponse.error(message: ""#{@params[:url]} is not a valid URL"")
      end

      return ServiceResponse.success if uri.scheme == 'git'

      uri.fragment = nil
      url = Gitlab::Utils.append_path(uri.to_s, ""/info/refs?service=#{GIT_SERVICE_NAME}"")

      response, response_body = http_get_and_extract_first_chunks(url)

      validate(uri, response, response_body)
    rescue *Gitlab::HTTP::HTTP_ERRORS => err
      error_result(""HTTP #{err.class.name.underscore} error: #{err.message}"")
    rescue StandardError => err
      ServiceResponse.error(
        message: ""Internal #{err.class.name.underscore} error: #{err.message}"",
        reason: 500
      )
    end

    private

    def http_get_and_extract_first_chunks(url)
      # We are interested only in the first chunks of the response
      # So we're using stream_body: true and breaking when receive enough body
      response = nil
      response_body = ''

      Gitlab::HTTP.get(url, stream_body: true, follow_redirects: false, basic_auth: auth) do |response_chunk|
        response = response_chunk
        response_body += response_chunk
        break if GIT_MINIMUM_RESPONSE_LENGTH <= response_body.length
      end

      [response, response_body]
    end

    def auth
      unless @params[:user].to_s.blank?
        {
          username: @params[:user],
          password: @params[:password]
        }
      end
    end

    def validate(uri, response, response_body)
      return status_code_error(uri, response) unless status_code_is_valid?(response)
      return error_result(INVALID_CONTENT_TYPE_MESSAGE) unless content_type_is_valid?(response)
      return error_result(INVALID_BODY_MESSAGE) unless response_body_is_valid?(response_body)

      ServiceResponse.success
    end

    def status_code_error(uri, response)
      http_code = response.http_response.code.to_i
      message = response.http_response.message || Rack::Utils::HTTP_STATUS_CODES[http_code]

      error_result(
        ""#{uri} endpoint error: #{http_code}#{message.presence&.prepend(' ')}"",
        http_code
      )
    end

    def error_result(message, reason = nil)
      ServiceResponse.error(message: message, reason: reason)
    end

    def status_code_is_valid?(response)
      response.http_response.code == '200'
    end

    def content_type_is_valid?(response)
      response.http_response['content-type'] == EXPECTED_CONTENT_TYPE
    end

    def response_body_is_valid?(response_body)
      response_body.match?(GIT_BODY_MESSAGE_REGEXP)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Import::ValidateRemoteGitEndpointService, feature_category: :importers do
  include StubRequests

  let_it_be(:base_url) { 'http://demo.host/path' }
  let_it_be(:endpoint_url) { ""#{base_url}/info/refs?service=git-upload-pack"" }
  let_it_be(:endpoint_error_message) { ""#{base_url} endpoint error:"" }
  let_it_be(:body_error_message) { described_class::INVALID_BODY_MESSAGE }
  let_it_be(:content_type_error_message) { described_class::INVALID_CONTENT_TYPE_MESSAGE }

  describe '#execute' do
    let(:valid_response) do
      { status: 200,
        body: '001e# service=git-upload-pack',
        headers: { 'Content-Type': 'application/x-git-upload-pack-advertisement' } }
    end

    it 'correctly handles URLs with fragment' do
      allow(Gitlab::HTTP).to receive(:get)

      described_class.new(url: ""#{base_url}#somehash"").execute

      expect(Gitlab::HTTP).to have_received(:get).with(endpoint_url, basic_auth: nil, stream_body: true, follow_redirects: false)
    end

    context 'when uri is using git:// protocol' do
      subject { described_class.new(url: 'git://demo.host/repo') }

      it 'returns success' do
        result = subject.execute

        expect(result).to be_a(ServiceResponse)
        expect(result.success?).to be(true)
      end
    end

    context 'when uri is using an invalid protocol' do
      subject { described_class.new(url: 'ssh://demo.host/repo') }

      it 'reports error when invalid URL is provided' do
        result = subject.execute

        expect(result).to be_a(ServiceResponse)
        expect(result.error?).to be(true)
      end
    end

    context 'when uri is invalid' do
      subject { described_class.new(url: 'http:example.com') }

      it 'reports error when invalid URL is provided' do
        result = subject.execute

        expect(result).to be_a(ServiceResponse)
        expect(result.error?).to be(true)
      end
    end

    context 'when receiving HTTP response' do
      subject { described_class.new(url: base_url) }

      it 'returns success when HTTP response is valid and contains correct payload' do
        stub_full_request(endpoint_url, method: :get).to_return(valid_response)

        result = subject.execute

        expect(result).to be_a(ServiceResponse)
        expect(result.success?).to be(true)
      end

      it 'reports error when status code is not 200' do
        error_response = { status: 401 }
        stub_full_request(endpoint_url, method: :get).to_return(error_response)

        result = subject.execute

        expect(result).to be_a(ServiceResponse)
        expect(result.error?).to be(true)
        expect(result.message).to eq(""#{endpoint_error_message} #{error_response[:status]}"")
      end

      it 'reports error when invalid URL is provided' do
        result = described_class.new(url: 1).execute

        expect(result).to be_a(ServiceResponse)
        expect(result.error?).to be(true)
        expect(result.message).to eq('1 is not a valid URL')
      end

      it 'reports error when required header is missing' do
        stub_full_request(endpoint_url, method: :get).to_return(valid_response.merge({ headers: nil }))

        result = subject.execute

        expect(result).to be_a(ServiceResponse)
        expect(result.error?).to be(true)
        expect(result.message).to eq(content_type_error_message)
      end

      it 'reports error when body is too short' do
        stub_full_request(endpoint_url, method: :get).to_return(valid_response.merge({ body: 'invalid content' }))

        result = subject.execute

        expect(result).to be_a(ServiceResponse)
        expect(result.error?).to be(true)
        expect(result.message).to eq(body_error_message)
      end

      it 'reports error when body is in invalid format' do
        stub_full_request(endpoint_url, method: :get).to_return(valid_response.merge({ body: 'invalid long content with no git respons whatshowever' }))

        result = subject.execute

        expect(result).to be_a(ServiceResponse)
        expect(result.error?).to be(true)
        expect(result.message).to eq(body_error_message)
      end

      it 'reports error when http exceptions are raised' do
        err = SocketError.new('dummy message')
        stub_full_request(endpoint_url, method: :get).to_raise(err)

        result = subject.execute

        expect(result).to be_a(ServiceResponse)
        expect(result.error?).to be(true)
        expect(result.message).to eq(""HTTP #{err.class.name.underscore} error: #{err.message}"")
      end

      it 'reports error when other exceptions are raised' do
        err = StandardError.new('internal dummy message')
        stub_full_request(endpoint_url, method: :get).to_raise(err)

        result = subject.execute

        expect(result).to be_a(ServiceResponse)
        expect(result.error?).to be(true)
        expect(result.message).to eq(""Internal #{err.class.name.underscore} error: #{err.message}"")
      end
    end

    it 'passes basic auth when credentials are provided' do
      allow(Gitlab::HTTP).to receive(:get)

      described_class.new(url: ""#{base_url}#somehash"", user: 'user', password: 'password').execute

      expect(Gitlab::HTTP).to have_received(:get).with(endpoint_url, basic_auth: { username: 'user', password: 'password' }, stream_body: true, follow_redirects: false)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Import
  class BitbucketServerService < Import::BaseService
    attr_reader :client, :params, :current_user

    def execute(credentials)
      if blocked_url?
        return log_and_return_error(""Invalid URL: #{url}"", :bad_request)
      end

      unless authorized?
        return log_and_return_error(""You don't have permissions to import this project"", :unauthorized)
      end

      unless repo
        return log_and_return_error(""Project %{project_repo} could not be found"" % { project_repo: ""#{project_key}/#{repo_slug}"" }, :unprocessable_entity)
      end

      project = create_project(credentials)

      track_access_level('bitbucket')

      if project.persisted?
        success(project)
      elsif project.errors[:import_source_disabled].present?
        error(project.errors[:import_source_disabled], :forbidden)
      else
        log_and_return_error(project_save_error(project), :unprocessable_entity)
      end
    rescue BitbucketServer::Connection::ConnectionError => e
      log_and_return_error(""Import failed due to a BitBucket Server error: #{e}"", :bad_request)
    end

    private

    def create_project(credentials)
      Gitlab::BitbucketServerImport::ProjectCreator.new(
        project_key,
        repo_slug,
        repo,
        project_name,
        target_namespace,
        current_user,
        credentials,
        timeout_strategy
      ).execute
    end

    def repo
      @repo ||= client.repo(project_key, repo_slug)
    end

    def project_name
      @project_name ||= params[:new_name].presence || repo.name
    end

    def namespace_path
      @namespace_path ||= params[:new_namespace].presence || current_user.namespace_path
    end

    def target_namespace
      @target_namespace ||= find_or_create_namespace(namespace_path, current_user.namespace_path)
    end

    def repo_slug
      @repo_slug ||= params[:bitbucket_server_repo]
    end

    def project_key
      @project_key ||= params[:bitbucket_server_project]
    end

    def url
      @url ||= params[:bitbucket_server_url]
    end

    def timeout_strategy
      @timeout_strategy ||= params[:timeout_strategy] || ProjectImportData::PESSIMISTIC_TIMEOUT
    end

    def allow_local_requests?
      Gitlab::CurrentSettings.allow_local_requests_from_web_hooks_and_services?
    end

    def blocked_url?
      Gitlab::UrlBlocker.blocked_url?(
        url,
        allow_localhost: allow_local_requests?,
        allow_local_network: allow_local_requests?,
        schemes: %w[http https]
      )
    end

    def log_and_return_error(message, error_type)
      log_error(message)
      error(_(message), error_type)
    end

    def log_error(message)
      Gitlab::Import::Logger.error(
        message: 'Import failed due to a BitBucket Server error',
        error: message
      )
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Import::BitbucketServerService, feature_category: :importers do
  let_it_be(:user) { create(:user) }

  let(:base_uri) { ""https://test:7990"" }
  let(:token) { ""asdasd12345"" }
  let(:secret) { ""sekrettt"" }
  let(:project_key) { 'TES' }
  let(:repo_slug) { 'vim' }
  let(:repo) do
    {
      name: 'vim',
      description: 'test',
      visibility_level: Gitlab::VisibilityLevel::PUBLIC,
      browse_url: 'http://repo.com/repo/repo',
      clone_url: 'http://repo.com/repo/repo.git'
    }
  end

  let(:client) { double(BitbucketServer::Client) }

  let(:credentials) { { base_uri: base_uri, user: user, password: token } }
  let(:params) { { bitbucket_server_url: base_uri, bitbucket_server_username: user, personal_access_token: token, bitbucket_server_project: project_key, bitbucket_server_repo: repo_slug } }

  subject { described_class.new(client, user, params) }

  before do
    allow(subject).to receive(:authorized?).and_return(true)
  end

  context 'execute' do
    before do
      allow(subject).to receive(:authorized?).and_return(true)
      allow(client).to receive(:repo).with(project_key, repo_slug).and_return(double(repo))
    end

    it 'tracks an access level event' do
      subject.execute(credentials)

      expect_snowplow_event(
        category: 'Import::BitbucketServerService',
        action: 'create',
        label: 'import_access_level',
        user: user,
        extra: { import_type: 'bitbucket', user_role: 'Owner' }
      )
    end
  end

  context 'when no repo is found' do
    before do
      allow(subject).to receive(:authorized?).and_return(true)
      allow(client).to receive(:repo).and_return(nil)
    end

    it 'returns an error' do
      result = subject.execute(credentials)

      expect(result).to include(
        message: ""Project #{project_key}/#{repo_slug} could not be found"",
        status: :error,
        http_status: :unprocessable_entity
      )
    end
  end

  context 'when import source is disabled' do
    before do
      stub_application_setting(import_sources: nil)
      allow(subject).to receive(:authorized?).and_return(true)
      allow(client).to receive(:repo).with(project_key, repo_slug).and_return(double(repo))
    end

    it 'returns forbidden' do
      result = subject.execute(credentials)

      expect(result).to include(
        status: :error,
        http_status: :forbidden
      )
    end
  end

  context 'when user is unauthorized' do
    before do
      allow(subject).to receive(:authorized?).and_return(false)
    end

    it 'returns an error' do
      result = subject.execute(credentials)

      expect(result).to include(
        message: ""You don't have permissions to import this project"",
        status: :error,
        http_status: :unauthorized
      )
    end
  end

  context 'verify url' do
    shared_examples 'denies local request' do
      before do
        allow(client).to receive(:repo).with(project_key, repo_slug).and_return(double(repo))
      end

      it 'does not allow requests' do
        result = subject.execute(credentials)
        expect(result[:status]).to eq(:error)
        expect(result[:message]).to include(""Invalid URL:"")
      end
    end

    context 'when host is localhost' do
      before do
        allow(subject).to receive(:url).and_return('https://localhost:3000')
      end

      include_examples 'denies local request'
    end

    context 'when host is on local network' do
      before do
        allow(subject).to receive(:url).and_return('https://192.168.0.191')
      end

      include_examples 'denies local request'
    end

    context 'when host is ftp protocol' do
      before do
        allow(subject).to receive(:url).and_return('ftp://testing')
      end

      include_examples 'denies local request'
    end
  end

  it 'raises an exception for unknown error causes' do
    exception = StandardError.new('Not Implemented')

    allow(client).to receive(:repo).and_raise(exception)

    expect(Gitlab::Import::Logger).not_to receive(:error)

    expect { subject.execute(credentials) }.to raise_error(exception)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Import
  class GithubService < Import::BaseService
    include ActiveSupport::NumberHelper
    include Gitlab::Utils::StrongMemoize

    attr_accessor :client
    attr_reader :params, :current_user

    def execute(access_params, provider)
      context_error = validate_context
      return context_error if context_error

      project = create_project(access_params, provider)
      track_access_level('github')

      if project.persisted?
        store_import_settings(project, access_params)
        success(project)
      elsif project.errors[:import_source_disabled].present?
        error(project.errors[:import_source_disabled], :forbidden)
      else
        error(project_save_error(project), :unprocessable_entity)
      end
    rescue Octokit::Error => e
      log_error(e)
    end

    def create_project(access_params, provider)
      Gitlab::LegacyGithubImport::ProjectCreator.new(
        repo,
        project_name,
        target_namespace,
        current_user,
        type: provider,
        **access_params
      ).execute(extra_project_attrs)
    end

    def repo
      @repo ||= client.repository(params[:repo_id].to_i)
    end

    def project_name
      @project_name ||= params[:new_name].presence || repo[:name]
    end

    def target_namespace
      @target_namespace ||= Namespace.find_by_full_path(target_namespace_path)
    end

    def extra_project_attrs
      {}
    end

    def oversized?
      repository_size_limit > 0 && repo[:size] > repository_size_limit
    end

    def oversize_error_message
      _('""%{repository_name}"" size (%{repository_size}) is larger than the limit of %{limit}.') % {
        repository_name: repo[:name],
        repository_size: number_to_human_size(repo[:size]),
        limit: number_to_human_size(repository_size_limit)
      }
    end

    def repository_size_limit
      strong_memoize :repository_size_limit do
        namespace_limit = target_namespace.repository_size_limit.to_i

        if namespace_limit > 0
          namespace_limit
        else
          Gitlab::CurrentSettings.repository_size_limit.to_i
        end
      end
    end

    def url
      @url ||= params[:github_hostname]
    end

    def allow_local_requests?
      Gitlab::CurrentSettings.allow_local_requests_from_web_hooks_and_services?
    end

    def blocked_url?
      Gitlab::UrlBlocker.blocked_url?(
        url,
        allow_localhost: allow_local_requests?,
        allow_local_network: allow_local_requests?,
        schemes: %w[http https]
      )
    end

    private

    def validate_context
      if blocked_url?
        log_and_return_error(""Invalid URL: #{url}"", _(""Invalid URL: %{url}"") % { url: url }, :bad_request)
      elsif target_namespace.nil?
        error(_('Namespace or group to import repository into does not exist.'), :unprocessable_entity)
      elsif !authorized?
        error(_('You are not allowed to import projects in this namespace.'), :unprocessable_entity)
      elsif oversized?
        error(oversize_error_message, :unprocessable_entity)
      end
    end

    def target_namespace_path
      raise ArgumentError, 'Target namespace is required' if params[:target_namespace].blank?

      params[:target_namespace]
    end

    def log_error(exception)
      Gitlab::GithubImport::Logger.error(
        message: 'Import failed due to a GitHub error',
        status: exception.response_status,
        error: exception.response_body
      )

      error(_('Import failed due to a GitHub error: %{original} (HTTP %{code})') % { original: exception.response_body, code: exception.response_status }, :unprocessable_entity)
    end

    def log_and_return_error(message, translated_message, http_status)
      Gitlab::GithubImport::Logger.error(
        message: 'Error while attempting to import from GitHub',
        error: message
      )

      error(translated_message, http_status)
    end

    def store_import_settings(project, access_params)
      Gitlab::GithubImport::Settings
        .new(project)
        .write(
          timeout_strategy: params[:timeout_strategy] || ProjectImportData::PESSIMISTIC_TIMEOUT,
          optional_stages: params[:optional_stages],
          additional_access_tokens: access_params[:additional_access_tokens]
        )
    end
  end
end

Import::GithubService.prepend_mod_with('Import::GithubService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Import::GithubService, feature_category: :importers do
  let_it_be(:user) { create(:user) }
  let_it_be(:token) { 'complex-token' }
  let_it_be(:access_params) do
    {
      github_access_token: 'github-complex-token',
      additional_access_tokens: %w[foo bar]
    }
  end

  let(:settings) { instance_double(Gitlab::GithubImport::Settings) }
  let(:user_namespace_path) { user.namespace_path }
  let(:optional_stages) { nil }
  let(:timeout_strategy) { ""optimistic"" }
  let(:params) do
    {
      repo_id: 123,
      new_name: 'new_repo',
      target_namespace: user_namespace_path,
      optional_stages: optional_stages,
      timeout_strategy: timeout_strategy
    }
  end

  let(:client) { Gitlab::GithubImport::Client.new(token) }
  let(:project_double) { instance_double(Project, persisted?: true) }

  subject(:github_importer) { described_class.new(client, user, params) }

  before do
    allow(Gitlab::GithubImport::Settings).to receive(:new).with(project_double).and_return(settings)
    allow(settings)
      .to receive(:write)
      .with(
        optional_stages: optional_stages,
        additional_access_tokens: access_params[:additional_access_tokens],
        timeout_strategy: timeout_strategy
      )
  end

  context 'do not raise an exception on input error' do
    let(:exception) { Octokit::ClientError.new(status: 404, body: 'Not Found') }

    before do
      expect(client).to receive(:repository).and_raise(exception)
    end

    it 'logs the original error' do
      expect(Gitlab::Import::Logger).to receive(:error).with({
        message: 'Import failed due to a GitHub error',
        status: 404,
        error: 'Not Found'
      }).and_call_original

      subject.execute(access_params, :github)
    end

    it 'returns an error with message and code' do
      result = subject.execute(access_params, :github)

      expect(result).to include(
        message: 'Import failed due to a GitHub error: Not Found (HTTP 404)',
        status: :error,
        http_status: :unprocessable_entity
      )
    end
  end

  it 'raises an exception for unknown error causes' do
    exception = StandardError.new('Not Implemented')

    expect(client).to receive(:repository).and_raise(exception)

    expect(Gitlab::Import::Logger).not_to receive(:error)

    expect { subject.execute(access_params, :github) }.to raise_error(exception)
  end

  context 'repository size validation' do
    let(:repository_double) { { name: 'repository', size: 99 } }

    before do
      allow(subject).to receive(:authorized?).and_return(true)
      expect(client).to receive(:repository).and_return(repository_double)

      allow_next_instance_of(Gitlab::LegacyGithubImport::ProjectCreator) do |creator|
        allow(creator).to receive(:execute).and_return(project_double)
      end
    end

    context 'when there is no repository size limit defined' do
      it 'skips the check, succeeds, and tracks an access level' do
        expect(subject.execute(access_params, :github)).to include(status: :success)
        expect(settings)
          .to have_received(:write)
          .with(optional_stages: nil,
            additional_access_tokens: access_params[:additional_access_tokens],
            timeout_strategy: timeout_strategy
          )
        expect_snowplow_event(
          category: 'Import::GithubService',
          action: 'create',
          label: 'import_access_level',
          user: user,
          extra: { import_type: 'github', user_role: 'Owner' }
        )
      end
    end

    context 'when the target namespace repository size limit is defined' do
      let_it_be(:group) { create(:group, repository_size_limit: 100) }

      before do
        params[:target_namespace] = group.full_path
      end

      it 'succeeds when the repository is smaller than the limit' do
        expect(subject.execute(access_params, :github)).to include(status: :success)
        expect(settings)
          .to have_received(:write)
          .with(
            optional_stages: nil,
            additional_access_tokens: access_params[:additional_access_tokens],
            timeout_strategy: timeout_strategy
          )
        expect_snowplow_event(
          category: 'Import::GithubService',
          action: 'create',
          label: 'import_access_level',
          user: user,
          extra: { import_type: 'github', user_role: 'Not a member' }
        )
      end

      it 'returns error when the repository is larger than the limit' do
        repository_double[:size] = 101

        expect(subject.execute(access_params, :github)).to include(size_limit_error)
      end
    end

    context 'when target namespace repository limit is not defined' do
      let_it_be(:group) { create(:group) }

      before do
        stub_application_setting(repository_size_limit: 100)
      end

      context 'when application size limit is defined' do
        it 'succeeds when the repository is smaller than the limit' do
          expect(subject.execute(access_params, :github)).to include(status: :success)
          expect(settings)
            .to have_received(:write)
            .with(
              optional_stages: nil,
              additional_access_tokens: access_params[:additional_access_tokens],
              timeout_strategy: timeout_strategy
            )
          expect_snowplow_event(
            category: 'Import::GithubService',
            action: 'create',
            label: 'import_access_level',
            user: user,
            extra: { import_type: 'github', user_role: 'Owner' }
          )
        end

        it 'returns error when the repository is larger than the limit' do
          repository_double[:size] = 101

          expect(subject.execute(access_params, :github)).to include(size_limit_error)
        end
      end
    end

    context 'when optional stages params present' do
      let(:optional_stages) do
        {
          single_endpoint_issue_events_import: true,
          single_endpoint_notes_import: 'false',
          attachments_import: false,
          collaborators_import: true
        }
      end

      it 'saves optional stages choice to import_data' do
        subject.execute(access_params, :github)

        expect(settings)
          .to have_received(:write)
          .with(
            optional_stages: optional_stages,
            additional_access_tokens: access_params[:additional_access_tokens],
            timeout_strategy: timeout_strategy
          )
      end
    end

    context 'when timeout strategy param is present' do
      let(:timeout_strategy) { 'pessimistic' }

      it 'saves timeout strategy to import_data' do
        subject.execute(access_params, :github)

        expect(settings)
          .to have_received(:write)
          .with(
            optional_stages: optional_stages,
            additional_access_tokens: access_params[:additional_access_tokens],
            timeout_strategy: timeout_strategy
          )
      end
    end

    context 'when additional access tokens are present' do
      it 'saves additional access tokens to import_data' do
        subject.execute(access_params, :github)

        expect(settings)
          .to have_received(:write)
          .with(
            optional_stages: optional_stages,
            additional_access_tokens: %w[foo bar],
            timeout_strategy: timeout_strategy
          )
      end
    end
  end

  context 'when import source is disabled' do
    let(:repository_double) do
      {
        name: 'vim',
        description: 'test',
        full_name: 'test/vim',
        clone_url: 'http://repo.com/repo/repo.git',
        private: false,
        has_wiki?: false
      }
    end

    before do
      stub_application_setting(import_sources: nil)
      allow(client).to receive(:repository).and_return(repository_double)
    end

    it 'returns forbidden' do
      result = subject.execute(access_params, :github)

      expect(result).to include(
        status: :error,
        http_status: :forbidden
      )
    end
  end

  context 'when a blocked/local URL is used as github_hostname' do
    let(:message) { 'Error while attempting to import from GitHub' }
    let(:error) { ""Invalid URL: #{url}"" }

    before do
      stub_application_setting(allow_local_requests_from_web_hooks_and_services: false)
    end

    where(url: %w[https://localhost https://10.0.0.1])

    with_them do
      it 'returns and logs an error' do
        allow(github_importer).to receive(:url).and_return(url)

        expect(Gitlab::Import::Logger).to receive(:error).with({
                                                                 message: message,
                                                                 error: error
                                                               }).and_call_original
        expect(github_importer.execute(access_params, :github)).to include(blocked_url_error(url))
      end
    end
  end

  context 'when target_namespace is blank' do
    before do
      params[:target_namespace] = ''
    end

    it 'raises an exception' do
      expect { subject.execute(access_params, :github) }.to raise_error(ArgumentError, 'Target namespace is required')
    end
  end

  context 'when namespace to import repository into does not exist' do
    before do
      params[:target_namespace] = 'unknown_path'
    end

    it 'returns an error' do
      expect(github_importer.execute(access_params, :github)).to include(not_existed_namespace_error)
    end
  end

  context 'when user has no permissions to import repository into the specified namespace' do
    let_it_be(:group) { create(:group) }

    before do
      params[:target_namespace] = group.full_path
    end

    it 'returns an error' do
      expect(github_importer.execute(access_params, :github)).to include(taken_namespace_error)
    end
  end

  def size_limit_error
    {
      status: :error,
      http_status: :unprocessable_entity,
      message: '""repository"" size (101 B) is larger than the limit of 100 B.'
    }
  end

  def blocked_url_error(url)
    {
      status: :error,
      http_status: :bad_request,
      message: ""Invalid URL: #{url}""
    }
  end

  def not_existed_namespace_error
    {
      status: :error,
      http_status: :unprocessable_entity,
      message: 'Namespace or group to import repository into does not exist.'
    }
  end

  def taken_namespace_error
    {
      status: :error,
      http_status: :unprocessable_entity,
      message: 'You are not allowed to import projects in this namespace.'
    }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Creates a new project with an associated project export file to be imported
# The associated project export file might be associated with different strategies
# to acquire the file to be imported, the default file_acquisition_strategy
# is uploading a file (Import::GitlabProjects::FileAcquisitionStrategies::FileUpload)
module Import
  module GitlabProjects
    class CreateProjectService
      include ActiveModel::Validations
      include ::Services::ReturnServiceResponses

      validates_presence_of :path, :namespace

      # Creates a new CreateProjectService.
      #
      # @param [User] current_user
      # @param [Hash] :params
      # @param [Import::GitlabProjects::FileAcquisitionStrategies::*] :file_acquisition_strategy
      def initialize(current_user, params:, file_acquisition_strategy: FileAcquisitionStrategies::FileUpload)
        @current_user = current_user
        @params = params.dup
        @strategy = file_acquisition_strategy.new(current_user: current_user, params: params)
      end

      # Creates a project with the strategy parameters
      #
      # @return [Services::ServiceReponse]
      def execute
        return error(errors.full_messages) unless valid?
        return error(project.errors.full_messages) unless project.saved?

        success(project)
      rescue StandardError => e
        error(e.message)
      end

      # Cascade the validation to strategy
      def valid?
        super && strategy.valid?
      end

      # Merge with strategy's errors
      def errors
        super.tap { _1.merge!(strategy.errors) }
      end

      def read_attribute_for_validation(key)
        params[key]
      end

      private

      attr_reader :current_user, :params, :strategy

      def error(messages)
        messages = Array.wrap(messages)
        message = messages.shift
        super(message, :bad_request, pass_back: { other_errors: messages })
      end

      def project
        @project ||= ::Projects::GitlabProjectsImportService.new(
          current_user,
          project_params,
          params[:override]
        ).execute
      end

      def project_params
        {
          name: params[:name],
          path: params[:path],
          namespace_id: params[:namespace].id,
          overwrite: params[:overwrite],
          import_type: 'gitlab_project'
        }.merge(strategy.project_params)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Import::GitlabProjects::CreateProjectService, :aggregate_failures, feature_category: :importers do
  let(:fake_file_acquisition_strategy) do
    Class.new do
      attr_reader :errors

      def initialize(...)
        @errors = ActiveModel::Errors.new(self)
      end

      def valid?
        true
      end

      def project_params
        {}
      end
    end
  end

  let(:params) do
    {
      path: 'path',
      namespace: user.namespace,
      name: 'name'
    }
  end

  let_it_be(:user) { create(:user) }

  subject { described_class.new(user, params: params, file_acquisition_strategy: FakeStrategy) }

  before do
    stub_const('FakeStrategy', fake_file_acquisition_strategy)
    stub_application_setting(import_sources: ['gitlab_project'])
  end

  describe 'validation' do
    it { expect(subject).to be_valid }

    it 'validates presence of path' do
      params[:path] = nil

      invalid = described_class.new(user, params: params, file_acquisition_strategy: FakeStrategy)

      expect(invalid).not_to be_valid
      expect(invalid.errors.full_messages).to include(""Path can't be blank"")
    end

    it 'validates presence of name' do
      params[:namespace] = nil

      invalid = described_class.new(user, params: params, file_acquisition_strategy: FakeStrategy)

      expect(invalid).not_to be_valid
      expect(invalid.errors.full_messages).to include(""Namespace can't be blank"")
    end

    it 'is invalid if the strategy is invalid' do
      expect_next_instance_of(FakeStrategy) do |strategy|
        allow(strategy).to receive(:valid?).and_return(false)
        allow(strategy).to receive(:errors).and_wrap_original do |original|
          original.call.tap do |errors|
            errors.add(:base, ""some error"")
          end
        end
      end

      invalid = described_class.new(user, params: params, file_acquisition_strategy: FakeStrategy)

      expect(invalid).not_to be_valid
      expect(invalid.errors.full_messages).to include(""some error"")
      expect(invalid.errors.full_messages).to include(""some error"")
    end
  end

  describe '#execute' do
    it 'creates a project successfully' do
      response = nil
      expect { response = subject.execute }
        .to change(Project, :count).by(1)

      expect(response).to be_success
      expect(response.http_status).to eq(:ok)
      expect(response.payload).to be_instance_of(Project)
      expect(response.payload.name).to eq('name')
      expect(response.payload.path).to eq('path')
      expect(response.payload.namespace).to eq(user.namespace)

      project = Project.last
      expect(project.name).to eq('name')
      expect(project.path).to eq('path')
      expect(project.namespace_id).to eq(user.namespace.id)
      expect(project.import_type).to eq('gitlab_project')
    end

    context 'when the project creation raises an error' do
      it 'fails to create a project' do
        expect_next_instance_of(Projects::GitlabProjectsImportService) do |service|
          expect(service).to receive(:execute).and_raise(StandardError, ""failed to create project"")
        end

        response = nil
        expect { response = subject.execute }
          .to change(Project, :count).by(0)

        expect(response).to be_error
        expect(response.http_status).to eq(:bad_request)
        expect(response.message).to eq(""failed to create project"")
        expect(response.payload).to eq(other_errors: [])
      end
    end

    context 'when the validation fail' do
      it 'fails to create a project' do
        params.delete(:path)

        response = nil
        expect { response = subject.execute }
          .to change(Project, :count).by(0)

        expect(response).to be_error
        expect(response.http_status).to eq(:bad_request)
        expect(response.message).to eq(""Path can't be blank"")
        expect(response.payload).to eq(other_errors: [])
      end

      context 'when the project contains multiple errors' do
        it 'fails to create a project' do
          params.merge!(name: '_ an invalid name _', path: '_ an invalid path _')

          response = nil
          expect { response = subject.execute }
            .to change(Project, :count).by(0)

          expect(response).to be_error
          expect(response.http_status).to eq(:bad_request)
          expect(response.message).to eq(
            'Project namespace path must not start or end with a special character and must not contain consecutive ' \
            'special characters.'
          )
          expect(response.payload).to eq(
            other_errors: [
              %(Project namespace path can contain only letters, digits, '_', '-' and '.'. Cannot start with '-', end in '.git' or end in '.atom'),
              %(Path can contain only letters, digits, '_', '-' and '.'. Cannot start with '-', end in '.git' or end in '.atom'),
              %(Path must not start or end with a special character and must not contain consecutive special characters.)
            ])
        end
      end
    end

    context 'when the strategy adds project parameters' do
      before do
        expect_next_instance_of(FakeStrategy) do |strategy|
          expect(strategy).to receive(:project_params).and_return(name: 'the strategy name')
        end

        subject.valid?
      end

      it 'merges the strategy project parameters' do
        response = nil
        expect { response = subject.execute }
          .to change(Project, :count).by(1)

        expect(response).to be_success
        expect(response.http_status).to eq(:ok)
        expect(response.payload).to be_instance_of(Project)
        expect(response.payload.name).to eq('the strategy name')
        expect(response.payload.path).to eq('path')
        expect(response.payload.namespace).to eq(user.namespace)

        project = Project.last
        expect(project.name).to eq('the strategy name')
        expect(project.path).to eq('path')
        expect(project.namespace_id).to eq(user.namespace.id)
        expect(project.import_type).to eq('gitlab_project')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Import
  module GitlabProjects
    module FileAcquisitionStrategies
      class FileUpload
        include ActiveModel::Validations

        validate :uploaded_file

        def initialize(params:, current_user: nil)
          @params = params
        end

        def project_params
          @project_params ||= @params.slice(:file)
        end

        def file
          @file ||= @params[:file]
        end

        private

        def uploaded_file
          return if file.present? && file.is_a?(UploadedFile)

          errors.add(:file, 'must be uploaded')
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Import::GitlabProjects::FileAcquisitionStrategies::FileUpload, :aggregate_failures, feature_category: :importers do
  let(:file) { UploadedFile.new(File.join('spec', 'features', 'projects', 'import_export', 'test_project_export.tar.gz')) }

  describe 'validation' do
    it 'validates presence of file' do
      valid = described_class.new(params: { file: file })
      expect(valid).to be_valid

      invalid = described_class.new(params: {})
      expect(invalid).not_to be_valid
      expect(invalid.errors.full_messages).to include(""File must be uploaded"")
    end
  end

  describe '#project_params' do
    it 'returns the file to upload in the params' do
      subject = described_class.new(params: { file: file })

      expect(subject.project_params).to eq(file: file)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Import
  module GitlabProjects
    module FileAcquisitionStrategies
      class RemoteFileS3
        include ActiveModel::Validations
        include Gitlab::Utils::StrongMemoize

        def self.allow_local_requests?
          ::Gitlab::CurrentSettings.allow_local_requests_from_web_hooks_and_services?
        end

        validates_presence_of :region, :bucket_name, :file_key, :access_key_id, :secret_access_key
        validates :file_url, addressable_url: {
          schemes: %w[https],
          allow_localhost: allow_local_requests?,
          allow_local_network: allow_local_requests?,
          dns_rebind_protection: true
        }

        validates_with RemoteFileValidator

        # The import itself has a limit of 24h, since the URL is created before the import starts
        # we add an expiration a bit longer to ensure it won't expire during the import.
        URL_EXPIRATION = 28.hours.seconds

        def initialize(params:, current_user: nil)
          @params = params
        end

        def project_params
          @project_parms ||= {
            import_export_upload: ::ImportExportUpload.new(remote_import_url: file_url)
          }
        end

        def file_url
          @file_url ||= s3_object&.presigned_url(:get, expires_in: URL_EXPIRATION.to_i)
        end

        def content_type
          @content_type ||= s3_object&.content_type
        end

        def content_length
          @content_length ||= s3_object&.content_length.to_i
        end

        # Make the validated params/methods accessible
        def read_attribute_for_validation(key)
          return file_url if key == :file_url

          params[key]
        end

        private

        attr_reader :params

        def s3_object
          strong_memoize(:s3_object) do
            build_s3_options
          end
        end

        def build_s3_options
          object = Aws::S3::Object.new(
            params[:bucket_name],
            params[:file_key],
            client: Aws::S3::Client.new(
              region: params[:region],
              access_key_id: params[:access_key_id],
              secret_access_key: params[:secret_access_key]
            )
          )

          # Force validate if the object exists and is accessible
          # Some exceptions are only raised when trying to access the object data
          unless object.exists?
            errors.add(:base, ""File not found '#{params[:file_key]}' in '#{params[:bucket_name]}'"")
            return
          end

          object
        rescue StandardError => e
          errors.add(:base, ""Failed to open '#{params[:file_key]}' in '#{params[:bucket_name]}': #{e.message}"")
          nil
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Import::GitlabProjects::FileAcquisitionStrategies::RemoteFileS3, :aggregate_failures, feature_category: :importers do
  let(:region_name) { 'region_name' }
  let(:bucket_name) { 'bucket_name' }
  let(:file_key) { 'file_key' }
  let(:access_key_id) { 'access_key_id' }
  let(:secret_access_key) { 'secret_access_key' }
  let(:file_exists) { true }
  let(:content_type) { 'application/x-tar' }
  let(:content_length) { 10.megabytes }
  let(:presigned_url) { 'https://external.file.path/file.tar.gz?PRESIGNED=true&TOKEN=some-token' }

  let(:s3_double) do
    instance_double(
      Aws::S3::Object,
      exists?: file_exists,
      content_type: content_type,
      content_length: content_length,
      presigned_url: presigned_url
    )
  end

  let(:params) do
    {
      region: region_name,
      bucket_name: bucket_name,
      file_key: file_key,
      access_key_id: access_key_id,
      secret_access_key: secret_access_key
    }
  end

  subject { described_class.new(params: params) }

  before do
    # Avoid network requests
    expect(Aws::S3::Client).to receive(:new).and_return(double)
    expect(Aws::S3::Object).to receive(:new).and_return(s3_double)

    stub_application_setting(max_import_remote_file_size: 10)
  end

  describe 'validation' do
    it { expect(subject).to be_valid }

    %i[region bucket_name file_key access_key_id secret_access_key].each do |key|
      context ""#{key} validation"" do
        before do
          params[key] = nil
        end

        it ""validates presence of #{key}"" do
          expect(subject).not_to be_valid
          expect(subject.errors.full_messages)
            .to include(""#{key.to_s.humanize} can't be blank"")
        end
      end
    end

    context 'content-length validation' do
      let(:content_length) { 11.megabytes }

      it 'validates the remote content-length' do
        expect(subject).not_to be_valid
        expect(subject.errors.full_messages)
          .to include('Content length is too big (should be at most 10 MiB)')
      end
    end

    context 'content-type validation' do
      let(:content_type) { 'unknown' }

      it 'validates the remote content-type' do
        expect(subject).not_to be_valid
        expect(subject.errors.full_messages)
          .to include(""Content type 'unknown' not allowed. (Allowed: application/gzip, application/x-tar, application/x-gzip)"")
      end
    end

    context 'file_url validation' do
      let(:presigned_url) { 'ftp://invalid.url/file.tar.gz' }

      it 'validates the file_url scheme' do
        expect(subject).not_to be_valid
        expect(subject.errors.full_messages)
          .to include(""File url is blocked: Only allowed schemes are https"")
      end

      context 'when localhost urls are not allowed' do
        let(:presigned_url) { 'https://localhost:3000/file.tar.gz' }

        it 'validates the file_url' do
          stub_application_setting(allow_local_requests_from_web_hooks_and_services: false)

          expect(subject).not_to be_valid
          expect(subject.errors.full_messages)
            .to include(""File url is blocked: Requests to localhost are not allowed"")
        end
      end
    end

    context 'when the remote file does not exist' do
      it 'foo' do
        expect(s3_double).to receive(:exists?).and_return(false)

        expect(subject).not_to be_valid
        expect(subject.errors.full_messages)
          .to include(""File not found 'file_key' in 'bucket_name'"")
      end
    end

    context 'when it fails to build the s3 object' do
      it 'foo' do
        expect(s3_double).to receive(:exists?).and_raise(StandardError, ""some error"")

        expect(subject).not_to be_valid
        expect(subject.errors.full_messages)
          .to include(""Failed to open 'file_key' in 'bucket_name': some error"")
      end
    end
  end

  describe '#project_params' do
    it 'returns import_export_upload in the params' do
      subject = described_class.new(params: { remote_import_url: presigned_url })

      expect(subject.project_params).to match(
        import_export_upload: an_instance_of(::ImportExportUpload)
      )
      expect(subject.project_params[:import_export_upload]).to have_attributes(
        remote_import_url: presigned_url
      )
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Import
  module GitlabProjects
    module FileAcquisitionStrategies
      class RemoteFile
        include ActiveModel::Validations

        def self.allow_local_requests?
          ::Gitlab::CurrentSettings.allow_local_requests_from_web_hooks_and_services?
        end

        validates :file_url, addressable_url: {
          schemes: %w[https],
          allow_localhost: allow_local_requests?,
          allow_local_network: allow_local_requests?,
          dns_rebind_protection: true
        }

        validates_with RemoteFileValidator, if: -> { !s3_request? }

        def initialize(params:, current_user: nil)
          @params = params
        end

        def project_params
          @project_parms ||= {
            import_export_upload: ::ImportExportUpload.new(remote_import_url: file_url)
          }
        end

        def file_url
          @file_url ||= params[:remote_import_url]
        end

        def content_type
          @content_type ||= headers['content-type']
        end

        def content_length
          @content_length ||= headers['content-length'].to_i
        end

        private

        attr_reader :params

        def s3_request?
          headers['Server'] == 'AmazonS3' && headers['x-amz-request-id'].present?
        end

        def headers
          return {} if file_url.blank?

          @headers ||= Gitlab::HTTP.head(file_url, timeout: 1.second).headers
        rescue StandardError => e
          errors.add(:base, ""Failed to retrive headers: #{e.message}"")

          {}
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::Import::GitlabProjects::FileAcquisitionStrategies::RemoteFile, :aggregate_failures, feature_category: :importers do
  let(:remote_url) { 'https://external.file.path/file.tar.gz' }
  let(:params) { { remote_import_url: remote_url } }

  subject { described_class.new(params: params) }

  before do
    stub_application_setting(max_import_remote_file_size: 10)

    stub_headers_for(remote_url, {
      'content-length' => 10.megabytes,
      'content-type' => 'application/gzip'
    })
  end

  describe 'validation' do
    it { expect(subject).to be_valid }

    context 'file_url validation' do
      let(:remote_url) { 'ftp://invalid.url/file.tar.gz' }

      it 'validates the file_url scheme' do
        expect(subject).not_to be_valid
        expect(subject.errors.full_messages)
          .to include(""File url is blocked: Only allowed schemes are https"")
      end

      context 'when localhost urls are not allowed' do
        let(:remote_url) { 'https://localhost:3000/file.tar.gz' }

        it 'validates the file_url' do
          stub_application_setting(allow_local_requests_from_web_hooks_and_services: false)

          expect(subject).not_to be_valid
          expect(subject.errors.full_messages)
            .to include(""File url is blocked: Requests to localhost are not allowed"")
        end
      end
    end

    context 'when the HTTP request fails to recover the headers' do
      it 'adds the error message' do
        expect(Gitlab::HTTP)
          .to receive(:head)
          .and_raise(StandardError, 'request invalid')

        expect(subject).not_to be_valid
        expect(subject.errors.full_messages)
          .to include('Failed to retrive headers: request invalid')
      end
    end

    context 'when request is not from an S3 server' do
      it 'validates the remote content-length' do
        stub_application_setting(max_import_remote_file_size: 1)

        expect(subject).not_to be_valid
        expect(subject.errors.full_messages)
          .to include('Content length is too big (should be at most 1 MiB)')
      end

      it 'validates the remote content-type' do
        stub_headers_for(remote_url, { 'content-type' => 'unknown' })

        expect(subject).not_to be_valid
        expect(subject.errors.full_messages)
          .to include(""Content type 'unknown' not allowed. (Allowed: application/gzip, application/x-tar, application/x-gzip)"")
      end
    end

    context 'when request is from an S3 server' do
      it 'does not validate the remote content-length or content-type' do
        stub_headers_for(
          remote_url,
          'Server' => 'AmazonS3',
          'x-amz-request-id' => 'some-id',
          'content-length' => 11.gigabytes,
          'content-type' => 'unknown'
        )

        expect(subject).to be_valid
      end
    end
  end

  describe '#project_params' do
    it 'returns import_export_upload in the params' do
      subject = described_class.new(params: { remote_import_url: remote_url })

      expect(subject.project_params).to match(
        import_export_upload: an_instance_of(::ImportExportUpload)
      )
      expect(subject.project_params[:import_export_upload]).to have_attributes(
        remote_import_url: remote_url
      )
    end
  end

  def stub_headers_for(url, headers = {})
    allow(Gitlab::HTTP)
      .to receive(:head)
      .with(remote_url, timeout: 1.second)
      .and_return(double(headers: headers)) # rubocop: disable RSpec/VerifiedDoubles
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Import
  module Github
    class GistsImportService < ::BaseService
      def initialize(user, client, params)
        @current_user = user
        @params = params
        @client = client
      end

      def execute
        return error('Import already in progress', 422) if import_status.started?

        check_user_token
        start_import
        success
      rescue Octokit::Unauthorized
        error('Access denied to the GitHub account.', 401)
      end

      private

      def import_status
        @import_status ||= Gitlab::GithubGistsImport::Status.new(current_user.id)
      end

      def encrypted_token
        Gitlab::CryptoHelper.aes256_gcm_encrypt(params[:github_access_token])
      end

      def start_import
        Gitlab::GithubGistsImport::StartImportWorker.perform_async(current_user.id, encrypted_token)
        import_status.start!
      end

      def check_user_token
        @client.octokit.user.present?
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Import::Github::GistsImportService, feature_category: :importers do
  subject(:import) { described_class.new(user, client, params) }

  let_it_be(:user) { create(:user) }
  let(:params) { { github_access_token: 'token' } }
  let(:import_status) { instance_double('Gitlab::GithubGistsImport::Status') }
  let(:client) { Gitlab::GithubImport::Client.new(params[:github_access_token]) }
  let(:octokit_user) { { login: 'user_login' } }

  describe '#execute', :aggregate_failures do
    before do
      allow(Gitlab::GithubGistsImport::Status).to receive(:new).and_return(import_status)
      allow(client.octokit).to receive(:user).and_return(octokit_user)
    end

    context 'when import in progress' do
      let(:expected_result) do
        {
          status: :error,
          http_status: 422,
          message: 'Import already in progress'
        }
      end

      it 'returns error' do
        expect(import_status).to receive(:started?).and_return(true)
        expect(import.execute).to eq(expected_result)
      end
    end

    context 'when import was not started' do
      it 'returns success' do
        encrypted_token = Gitlab::CryptoHelper.aes256_gcm_encrypt(params[:github_access_token])
        expect(import_status).to receive(:started?).and_return(false)
        expect(Gitlab::CryptoHelper)
          .to receive(:aes256_gcm_encrypt).with(params[:github_access_token])
          .and_return(encrypted_token)
        expect(Gitlab::GithubGistsImport::StartImportWorker)
          .to receive(:perform_async).with(user.id, encrypted_token)
        expect(import_status).to receive(:start!)

        expect(import.execute).to eq({ status: :success })
      end
    end

    context 'when user token is invalid' do
      before do
        allow(client.octokit).to receive(:user).and_raise(Octokit::Unauthorized)
        allow(import_status).to receive(:started?).and_return(false)
      end

      let(:expected_result) do
        {
          http_status: 401,
          message: 'Access denied to the GitHub account.',
          status: :error
        }
      end

      it 'returns 401 error' do
        expect(import.execute).to eq(expected_result)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Import
  module Github
    class CancelProjectImportService < ::BaseService
      def execute
        return error('Not Found', :not_found) unless authorized_to_read?
        return error('Unauthorized access', :forbidden) unless authorized_to_cancel?

        if project.import_state.completed?
          error(cannot_cancel_error_message, :bad_request)
        else
          project.import_state.cancel
          metrics.track_canceled_import

          success(project: project)
        end
      end

      private

      def authorized_to_read?
        can?(current_user, :read_project, project)
      end

      def authorized_to_cancel?
        can?(current_user, :owner_access, project)
      end

      def cannot_cancel_error_message
        format(
          _('The import cannot be canceled because it is %{project_status}'),
          project_status: project.import_state.status
        )
      end

      def metrics
        @metrics ||= Gitlab::Import::Metrics.new(:github_importer, project)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Import::Github::CancelProjectImportService, feature_category: :importers do
  subject(:import_cancel) { described_class.new(project, project.owner) }

  let_it_be(:user) { create(:user) }
  let_it_be_with_reload(:project) { create(:project, :import_started, import_type: 'github', import_url: 'https://fake.url') }

  describe '.execute' do
    context 'when user is an owner' do
      context 'when import is in progress' do
        it 'update import state to be canceled' do
          expect(import_cancel.execute).to eq({ status: :success, project: project })
        end

        it 'tracks canceled imports' do
          metrics_double = instance_double('Gitlab::Import::Metrics')

          expect(Gitlab::Import::Metrics)
            .to receive(:new)
            .with(:github_importer, project)
            .and_return(metrics_double)
          expect(metrics_double).to receive(:track_canceled_import)

          import_cancel.execute
        end
      end

      context 'when import is finished' do
        let(:expected_result) do
          {
            status: :error,
            http_status: :bad_request,
            message: 'The import cannot be canceled because it is finished'
          }
        end

        before do
          project.import_state.finish!
        end

        it 'returns error' do
          expect(import_cancel.execute).to eq(expected_result)
        end
      end
    end

    context 'when user is not allowed to read project' do
      it 'returns 404' do
        expect(described_class.new(project, user).execute)
          .to eq({ status: :error, http_status: :not_found, message: 'Not Found' })
      end
    end

    context 'when user is not allowed to cancel project' do
      before do
        project.add_developer(user)
      end

      it 'returns 403' do
        expect(described_class.new(project, user).execute)
          .to eq({ status: :error, http_status: :forbidden, message: 'Unauthorized access' })
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Import
  module Github
    module Notes
      class CreateService < ::Notes::CreateService
        # Github does not have support to quick actions in notes (like /assign)
        # Therefore, when importing notes we skip the quick actions processing
        def quick_actions_supported?(_note)
          false
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Import::Github::Notes::CreateService, feature_category: :importers do
  it 'does not support quick actions' do
    project = create(:project, :repository)
    user = create(:user)
    merge_request = create(:merge_request, source_project: project)

    project.add_maintainer(user)

    note = described_class.new(
      project,
      user,
      note: '/close',
      noteable_type: 'MergeRequest',
      noteable_id: merge_request.id
    ).execute

    expect(note.note).to eq('/close')
    expect(note.noteable.closed?).to be(false)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module QuickActions
  class TargetService < BaseService
    def execute(type, type_iid)
      case type&.downcase
      when 'workitem'
        work_item(type_iid)
      when 'issue'
        issue(type_iid)
      when 'mergerequest'
        merge_request(type_iid)
      when 'commit'
        commit(type_iid)
      end
    end

    private

    # rubocop: disable CodeReuse/ActiveRecord
    def work_item(type_iid)
      WorkItems::WorkItemsFinder.new(current_user, project_id: project.id).find_by(iid: type_iid)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    # rubocop: disable CodeReuse/ActiveRecord
    def issue(type_iid)
      return project.issues.build if type_iid.nil?

      IssuesFinder.new(current_user, project_id: project.id).find_by(iid: type_iid) || project.issues.build
    end
    # rubocop: enable CodeReuse/ActiveRecord

    # rubocop: disable CodeReuse/ActiveRecord
    def merge_request(type_iid)
      return project.merge_requests.build if type_iid.nil?

      MergeRequestsFinder.new(current_user, project_id: project.id).find_by(iid: type_iid) || project.merge_requests.build
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def commit(type_iid)
      project.commit(type_iid)
    end
  end
end

QuickActions::TargetService.prepend_mod_with('QuickActions::TargetService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe QuickActions::TargetService, feature_category: :team_planning do
  let(:project) { create(:project) }
  let(:user) { create(:user) }
  let(:service) { described_class.new(project, user) }

  before do
    project.add_maintainer(user)
  end

  describe '#execute' do
    shared_examples 'no target' do |type_iid:|
      it 'returns nil' do
        target = service.execute(type, type_iid)

        expect(target).to be_nil
      end
    end

    shared_examples 'find target' do
      it 'returns the target' do
        found_target = service.execute(type, target_iid)

        expect(found_target).to eq(target)
      end
    end

    shared_examples 'build target' do |type_iid:|
      it 'builds a new target' do
        target = service.execute(type, type_iid)

        expect(target.project).to eq(project)
        expect(target).to be_new_record
      end
    end

    context 'for issue' do
      let(:target) { create(:issue, project: project) }
      let(:target_iid) { target.iid }
      let(:type) { 'Issue' }

      it_behaves_like 'find target'
      it_behaves_like 'build target', type_iid: nil
      it_behaves_like 'build target', type_iid: -1
    end

    context 'for work item' do
      let(:target) { create(:work_item, :task, project: project) }
      let(:target_iid) { target.iid }
      let(:type) { 'WorkItem' }

      it_behaves_like 'find target'
    end

    context 'for merge request' do
      let(:target) { create(:merge_request, source_project: project) }
      let(:target_iid) { target.iid }
      let(:type) { 'MergeRequest' }

      it_behaves_like 'find target'
      it_behaves_like 'build target', type_iid: nil
      it_behaves_like 'build target', type_iid: -1
    end

    context 'for commit' do
      let(:project) { create(:project, :repository) }
      let(:target) { project.commit.parent }
      let(:target_iid) { target.sha }
      let(:type) { 'Commit' }

      it_behaves_like 'find target'
      it_behaves_like 'no target', type_iid: 'invalid_sha'

      context 'with nil target_iid' do
        let(:target) { project.commit }
        let(:target_iid) { nil }

        it_behaves_like 'find target'
      end
    end

    context 'for unknown type' do
      let(:type) { 'unknown' }

      it_behaves_like 'no target', type_iid: :unused
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module QuickActions
  class InterpretService < BaseService
    include Gitlab::Utils::StrongMemoize
    include Gitlab::QuickActions::Dsl
    include Gitlab::QuickActions::IssueActions
    include Gitlab::QuickActions::IssuableActions
    include Gitlab::QuickActions::IssueAndMergeRequestActions
    include Gitlab::QuickActions::MergeRequestActions
    include Gitlab::QuickActions::CommitActions
    include Gitlab::QuickActions::CommonActions
    include Gitlab::QuickActions::RelateActions
    include Gitlab::QuickActions::WorkItemActions

    attr_reader :quick_action_target

    # Counts how many commands have been executed.
    # Used to display relevant feedback on UI when a note
    # with only commands has been processed.
    attr_accessor :commands_executed_count

    # Takes an quick_action_target and returns an array of all the available commands
    # represented with .to_h
    def available_commands(quick_action_target)
      @quick_action_target = quick_action_target

      self.class.command_definitions.map do |definition|
        next unless definition.available?(self)

        definition.to_h(self)
      end.compact
    end

    # Takes a text and interprets the commands that are extracted from it.
    # Returns the content without commands, a hash of changes to be applied to a record
    # and a string containing the execution_message to show to the user.
    def execute(content, quick_action_target, only: nil)
      return [content, {}, ''] unless current_user.can?(:use_quick_actions)

      @quick_action_target = quick_action_target
      @updates = {}
      @execution_message = {}

      content, commands = extractor.extract_commands(content, only: only)
      extract_updates(commands)

      [content, @updates, execution_messages_for(commands), command_names(commands)]
    end

    # Takes a text and interprets the commands that are extracted from it.
    # Returns the content without commands, and array of changes explained.
    # `keep_actions: true` will keep the quick actions in the content.
    def explain(content, quick_action_target, keep_actions: false)
      return [content, []] unless current_user.can?(:use_quick_actions)

      @quick_action_target = quick_action_target

      content, commands = extractor(keep_actions).extract_commands(content)
      commands = explain_commands(commands)
      [content, commands]
    end

    private

    def failed_parse(message)
      raise Gitlab::QuickActions::CommandDefinition::ParseError, message
    end

    def extractor(keep_actions = false)
      Gitlab::QuickActions::Extractor.new(self.class.command_definitions, keep_actions: keep_actions)
    end

    # Find users for commands like /assign
    #
    # eg. /assign me and @jane and jack
    def extract_users(params)
      Gitlab::QuickActions::UsersExtractor
        .new(current_user, project: project, group: group, target: quick_action_target, text: params)
        .execute

    rescue Gitlab::QuickActions::UsersExtractor::Error => err
      extract_users_failed(err)
    end

    def extract_users_failed(err)
      case err
      when Gitlab::QuickActions::UsersExtractor::MissingError
        failed_parse(format(_(""Failed to find users for %{missing}""), missing: err.message))
      when Gitlab::QuickActions::UsersExtractor::TooManyRefsError
        failed_parse(format(_('Too many references. Quick actions are limited to at most %{max_count} user references'),
                 max_count: err.limit))
      when Gitlab::QuickActions::UsersExtractor::TooManyFoundError
        failed_parse(format(_(""Too many users found. Quick actions are limited to at most %{max_count} users""),
                 max_count: err.limit))
      else
        Gitlab::ErrorTracking.track_and_raise_for_dev_exception(err)
        failed_parse(_('Something went wrong'))
      end
    end

    def find_milestones(project, params = {})
      group_ids = project.group.self_and_ancestors.select(:id) if project.group

      MilestonesFinder.new(params.merge(project_ids: [project.id], group_ids: group_ids)).execute
    end

    def parent
      project || group
    end

    def group
      strong_memoize(:group) do
        quick_action_target.group if quick_action_target.respond_to?(:group)
      end
    end

    def find_labels(labels_params = nil)
      extract_references(labels_params, :label) | find_labels_by_name_no_tilde(labels_params)
    end

    def find_labels_by_name_no_tilde(labels_params)
      return Label.none if label_with_tilde?(labels_params)

      finder_params = { include_ancestor_groups: true }
      finder_params[:project_id] = project.id if project
      finder_params[:group_id] = group.id if group
      finder_params[:name] = extract_label_names(labels_params) if labels_params

      LabelsFinder.new(current_user, finder_params).execute
    end

    def label_with_tilde?(labels_params)
      labels_params&.include?('~')
    end

    def extract_label_names(labels_params)
      # '""A"" ""A B C"" A B' => [""A"", ""A B C"", ""A"", ""B""]
      labels_params.scan(/""([^""]+)""|([^ ]+)/).flatten.compact
    end

    def find_label_references(labels_param, format = :id)
      labels_to_reference(find_labels(labels_param), format)
    end

    def labels_to_reference(labels, format = :id)
      labels.map { |l| l.to_reference(format: format) }
    end

    def find_label_ids(labels_param)
      find_labels(labels_param).map(&:id)
    end

    def explain_commands(commands)
      map_commands(commands, :explain)
    end

    def execution_messages_for(commands)
      map_commands(commands, :execute_message).join(' ')
    end

    def map_commands(commands, method)
      commands.map do |name_or_alias, arg|
        definition = self.class.definition_by_name(name_or_alias)
        next unless definition

        case method
        when :explain
          definition.explain(self, arg)
        when :execute_message
          @execution_message[definition.name.to_sym] || definition.execute_message(self, arg)
        end
      end.compact
    end

    def command_names(commands)
      commands.flatten.map do |name|
        definition = self.class.definition_by_name(name)
        next unless definition

        name
      end.compact
    end

    def extract_updates(commands)
      commands.each do |name, arg|
        definition = self.class.definition_by_name(name)
        next unless definition

        definition.execute(self, arg)
        usage_ping_tracking(definition.name, arg)
      end
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def extract_references(arg, type)
      return [] unless arg

      ext = Gitlab::ReferenceExtractor.new(project, current_user)

      ext.analyze(arg, author: current_user, group: group)

      ext.references(type)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def usage_ping_tracking(quick_action_name, arg)
      Gitlab::UsageDataCounters::QuickActionActivityUniqueCounter.track_unique_action(
        quick_action_name.to_s,
        args: arg&.strip,
        user: current_user
      )
    end

    def can?(ability, object)
      Ability.allowed?(current_user, ability, object)
    end
  end
end

QuickActions::InterpretService.prepend_mod_with('QuickActions::InterpretService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe QuickActions::InterpretService, feature_category: :team_planning do
  include AfterNextHelpers

  let_it_be(:group) { create(:group, :crm_enabled) }
  let_it_be(:public_project) { create(:project, :public, group: group) }
  let_it_be(:repository_project) { create(:project, :repository) }
  let_it_be(:project) { public_project }
  let_it_be(:developer) { create(:user) }
  let_it_be(:developer2) { create(:user) }
  let_it_be(:developer3) { create(:user) }
  let_it_be_with_reload(:issue) { create(:issue, project: project) }
  let_it_be(:inprogress) { create(:label, project: project, title: 'In Progress') }
  let_it_be(:helmchart) { create(:label, project: project, title: 'Helm Chart Registry') }
  let_it_be(:bug) { create(:label, project: project, title: 'Bug') }

  let(:milestone) { create(:milestone, project: project, title: '9.10') }
  let(:commit) { create(:commit, project: project) }
  let(:current_user) { developer }

  subject(:service) { described_class.new(project, current_user) }

  before_all do
    public_project.add_developer(developer)
    repository_project.add_developer(developer)
  end

  before do
    stub_licensed_features(
      multiple_issue_assignees: false,
      multiple_merge_request_reviewers: false,
      multiple_merge_request_assignees: false
    )
  end

  describe '#execute' do
    let_it_be(:work_item) { create(:work_item, :task, project: project) }
    let(:merge_request) { create(:merge_request, source_project: project) }

    shared_examples 'reopen command' do
      it 'returns state_event: ""reopen"" if content contains /reopen' do
        issuable.close!
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(state_event: 'reopen')
      end

      it 'returns the reopen message' do
        issuable.close!
        _, _, message = service.execute(content, issuable)

        expect(message).to eq(""Reopened this #{issuable.to_ability_name.humanize(capitalize: false)}."")
      end
    end

    shared_examples 'close command' do
      it 'returns state_event: ""close"" if content contains /close' do
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(state_event: 'close')
      end

      it 'returns the close message' do
        _, _, message = service.execute(content, issuable)

        expect(message).to eq(""Closed this #{issuable.to_ability_name.humanize(capitalize: false)}."")
      end
    end

    shared_examples 'title command' do
      it 'populates title: ""A brand new title"" if content contains /title A brand new title' do
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(title: 'A brand new title')
      end

      it 'returns the title message' do
        _, _, message = service.execute(content, issuable)

        expect(message).to eq(%(Changed the title to ""A brand new title"".))
      end
    end

    shared_examples 'milestone command' do
      it 'fetches milestone and populates milestone_id if content contains /milestone' do
        milestone # populate the milestone
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(milestone_id: milestone.id)
      end

      it 'returns the milestone message' do
        milestone # populate the milestone
        _, _, message = service.execute(content, issuable)

        expect(message).to eq(""Set the milestone to #{milestone.to_reference}."")
      end

      it 'returns empty milestone message when milestone is wrong' do
        _, _, message = service.execute('/milestone %wrong-milestone', issuable)

        expect(message).to be_empty
      end
    end

    shared_examples 'remove_milestone command' do
      it 'populates milestone_id: nil if content contains /remove_milestone' do
        issuable.update!(milestone_id: milestone.id)
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(milestone_id: nil)
      end

      it 'returns removed milestone message' do
        issuable.update!(milestone_id: milestone.id)
        _, _, message = service.execute(content, issuable)

        expect(message).to eq(""Removed #{milestone.to_reference} milestone."")
      end
    end

    shared_examples 'label command' do
      it 'fetches label ids and populates add_label_ids if content contains /label' do
        bug # populate the label
        inprogress # populate the label
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to match(add_label_ids: contain_exactly(bug.id, inprogress.id))
      end

      it 'returns the label message' do
        bug # populate the label
        inprogress # populate the label
        _, _, message = service.execute(content, issuable)

        # Compare message without making assumptions about ordering.
        expect(message).to match %r{Added ~"".*"" ~"".*"" labels.}
        expect(message).to include(bug.to_reference(format: :name))
        expect(message).to include(inprogress.to_reference(format: :name))
      end
    end

    shared_examples 'multiple label command' do
      it 'fetches label ids and populates add_label_ids if content contains multiple /label' do
        bug # populate the label
        inprogress # populate the label
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(add_label_ids: [inprogress.id, bug.id])
      end
    end

    shared_examples 'multiple label with same argument' do
      it 'prevents duplicate label ids and populates add_label_ids if content contains multiple /label' do
        inprogress # populate the label
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(add_label_ids: [inprogress.id])
      end
    end

    shared_examples 'multiword label name starting without ~' do
      it 'fetches label ids and populates add_label_ids if content contains /label' do
        _, updates = service.execute(content, issuable)

        expect(updates).to eq(add_label_ids: [helmchart.id])
      end
    end

    shared_examples 'label name is included in the middle of another label name' do
      it 'ignores the sublabel when the content contains the includer label name' do
        create(:label, project: project, title: 'Chart')

        _, updates = service.execute(content, issuable)

        expect(updates).to eq(add_label_ids: [helmchart.id])
      end
    end

    shared_examples 'unlabel command' do
      it 'fetches label ids and populates remove_label_ids if content contains /unlabel' do
        issuable.update!(label_ids: [inprogress.id]) # populate the label
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(remove_label_ids: [inprogress.id])
      end

      it 'returns the unlabel message' do
        issuable.update!(label_ids: [inprogress.id]) # populate the label
        _, _, message = service.execute(content, issuable)

        expect(message).to eq(""Removed #{inprogress.to_reference(format: :name)} label."")
      end
    end

    shared_examples 'multiple unlabel command' do
      it 'fetches label ids and populates remove_label_ids if content contains  mutiple /unlabel' do
        issuable.update!(label_ids: [inprogress.id, bug.id]) # populate the label
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(remove_label_ids: [inprogress.id, bug.id])
      end
    end

    shared_examples 'unlabel command with no argument' do
      it 'populates label_ids: [] if content contains /unlabel with no arguments' do
        issuable.update!(label_ids: [inprogress.id]) # populate the label
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(label_ids: [])
      end
    end

    shared_examples 'relabel command' do
      it 'populates label_ids: [] if content contains /relabel' do
        issuable.update!(label_ids: [bug.id]) # populate the label
        inprogress # populate the label
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(label_ids: [inprogress.id])
      end

      it 'returns the relabel message' do
        issuable.update!(label_ids: [bug.id]) # populate the label
        inprogress # populate the label
        _, _, message = service.execute(content, issuable)

        expect(message).to eq(""Replaced all labels with #{inprogress.to_reference(format: :name)} label."")
      end
    end

    shared_examples 'todo command' do
      it 'populates todo_event: ""add"" if content contains /todo' do
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(todo_event: 'add')
      end

      it 'returns the todo message' do
        _, _, message = service.execute(content, issuable)

        expect(message).to eq('Added a to do.')
      end
    end

    shared_examples 'done command' do
      it 'populates todo_event: ""done"" if content contains /done' do
        TodoService.new.mark_todo(issuable, developer)
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(todo_event: 'done')
      end

      it 'returns the done message' do
        TodoService.new.mark_todo(issuable, developer)
        _, _, message = service.execute(content, issuable)

        expect(message).to eq('Marked to do as done.')
      end
    end

    shared_examples 'subscribe command' do
      it 'populates subscription_event: ""subscribe"" if content contains /subscribe' do
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(subscription_event: 'subscribe')
      end

      it 'returns the subscribe message' do
        _, _, message = service.execute(content, issuable)

        expect(message).to eq(""Subscribed to this #{issuable.to_ability_name.humanize(capitalize: false)}."")
      end
    end

    shared_examples 'unsubscribe command' do
      it 'populates subscription_event: ""unsubscribe"" if content contains /unsubscribe' do
        issuable.subscribe(developer, project)
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(subscription_event: 'unsubscribe')
      end

      it 'returns the unsubscribe message' do
        issuable.subscribe(developer, project)
        _, _, message = service.execute(content, issuable)

        expect(message).to eq(""Unsubscribed from this #{issuable.to_ability_name.humanize(capitalize: false)}."")
      end
    end

    shared_examples 'due command' do
      let(:expected_date) { Date.new(2016, 8, 28) }

      it 'populates due_date: Date.new(2016, 8, 28) if content contains /due 2016-08-28' do
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(due_date: expected_date)
      end

      it 'returns due_date message: Date.new(2016, 8, 28) if content contains /due 2016-08-28' do
        _, _, message = service.execute(content, issuable)

        expect(message).to eq(""Set the due date to #{expected_date.to_fs(:medium)}."")
      end
    end

    shared_examples 'remove_due_date command' do
      before do
        issuable.update!(due_date: Date.today)
      end

      it 'populates due_date: nil if content contains /remove_due_date' do
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(due_date: nil)
      end

      it 'returns Removed the due date' do
        _, _, message = service.execute(content, issuable)

        expect(message).to eq('Removed the due date.')
      end
    end

    shared_examples 'draft command' do
      it 'returns wip_event: ""draft""' do
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(wip_event: 'draft')
      end

      it 'returns the draft message' do
        _, _, message = service.execute(content, issuable)

        expect(message).to eq(""Marked this #{issuable.to_ability_name.humanize(capitalize: false)} as a draft."")
      end
    end

    shared_examples 'draft/ready command no action' do
      it 'returns the no action message if there is no change to the status' do
        _, _, message = service.execute(content, issuable)

        expect(message).to eq(""No change to this #{issuable.to_ability_name.humanize(capitalize: false)}'s draft status."")
      end
    end

    shared_examples 'ready command' do
      it 'returns wip_event: ""ready""' do
        issuable.update!(title: issuable.draft_title)
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(wip_event: 'ready')
      end

      it 'returns the ready message' do
        issuable.update!(title: issuable.draft_title)
        _, _, message = service.execute(content, issuable)

        expect(message).to eq(""Marked this #{issuable.to_ability_name.humanize(capitalize: false)} as ready."")
      end
    end

    shared_examples 'estimate command' do
      it 'populates time_estimate: 3600 if content contains /estimate 1h' do
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(time_estimate: 3600)
      end

      it 'returns the time_estimate formatted message' do
        _, _, message = service.execute('/estimate 79d', issuable)

        expect(message).to eq('Set time estimate to 3mo 3w 4d.')
      end
    end

    shared_examples 'spend command' do
      it 'populates spend_time: 3600 if content contains /spend 1h' do
        freeze_time do
          _, updates, _ = service.execute(content, issuable)

          expect(updates).to eq(spend_time: {
                                  duration: 3600,
                                  user_id: developer.id,
                                  spent_at: DateTime.current
                                })
        end
      end
    end

    shared_examples 'spend command with negative time' do
      it 'populates spend_time: -7200 if content contains -120m' do
        freeze_time do
          _, updates, _ = service.execute(content, issuable)

          expect(updates).to eq(spend_time: {
                                  duration: -7200,
                                  user_id: developer.id,
                                  spent_at: DateTime.current
                                })
        end
      end

      it 'returns the spend_time message including the formatted duration and verb' do
        _, _, message = service.execute(content, issuable)

        expect(message).to eq('Subtracted 2h spent time.')
      end
    end

    shared_examples 'spend command with valid date' do
      it 'populates spend time: 1800 with date in date type format' do
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(spend_time: {
                                duration: 1800,
                                user_id: developer.id,
                                spent_at: Date.parse(date)
                              })
      end
    end

    shared_examples 'spend command with invalid date' do
      it 'will not create any note and timelog' do
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq({})
      end
    end

    shared_examples 'spend command with future date' do
      it 'will not create any note and timelog' do
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq({})
      end
    end

    shared_examples 'remove_estimate command' do
      it 'populates time_estimate: 0 if content contains /remove_estimate' do
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(time_estimate: 0)
      end

      it 'returns the remove_estimate message' do
        _, _, message = service.execute(content, issuable)

        expect(message).to eq('Removed time estimate.')
      end
    end

    shared_examples 'remove_time_spent command' do
      it 'populates spend_time: :reset if content contains /remove_time_spent' do
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(spend_time: { duration: :reset, user_id: developer.id })
      end

      it 'returns the remove_time_spent message' do
        _, _, message = service.execute(content, issuable)

        expect(message).to eq('Removed spent time.')
      end
    end

    shared_examples 'lock command' do
      let(:issue) { create(:issue, project: project, discussion_locked: false) }
      let(:merge_request) { create(:merge_request, source_project: project, discussion_locked: false) }

      it 'returns discussion_locked: true if content contains /lock' do
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(discussion_locked: true)
      end

      it 'returns the lock discussion message' do
        _, _, message = service.execute(content, issuable)

        expect(message).to eq('Locked the discussion.')
      end
    end

    shared_examples 'unlock command' do
      let(:issue) { create(:issue, project: project, discussion_locked: true) }
      let(:merge_request) { create(:merge_request, source_project: project, discussion_locked: true) }

      it 'returns discussion_locked: true if content contains /unlock' do
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(discussion_locked: false)
      end

      it 'returns the unlock discussion message' do
        _, _, message = service.execute(content, issuable)

        expect(message).to eq('Unlocked the discussion.')
      end
    end

    shared_examples 'failed command' do |error_msg|
      let(:match_msg) { error_msg ? eq(error_msg) : be_empty }

      it 'populates {} if content contains an unsupported command' do
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to be_empty
      end

      it ""returns #{error_msg || 'an empty'} message"" do
        _, _, message = service.execute(content, issuable)

        expect(message).to match_msg
      end
    end

    shared_examples 'merge immediately command' do
      let(:project) { repository_project }

      it 'runs merge command if content contains /merge' do
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(merge: merge_request.diff_head_sha)
      end

      it 'returns them merge message' do
        _, _, message = service.execute(content, issuable)

        expect(message).to eq('Merged this merge request.')
      end
    end

    shared_examples 'merge automatically command' do
      let(:project) { repository_project }

      before do
        stub_licensed_features(merge_request_approvers: true) if Gitlab.ee?
      end

      it 'runs merge command if content contains /merge and returns merge message' do
        _, updates, message = service.execute(content, issuable)

        expect(updates).to eq(merge: merge_request.diff_head_sha)

        if Gitlab.ee?
          expect(message).to eq('Scheduled to merge this merge request (Merge when checks pass).')
        else
          expect(message).to eq('Scheduled to merge this merge request (Merge when pipeline succeeds).')
        end
      end
    end

    shared_examples 'award command' do
      it 'toggle award 100 emoji if content contains /award :100:' do
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(emoji_award: ""100"")
      end

      it 'returns the award message' do
        _, _, message = service.execute(content, issuable)

        expect(message).to eq('Toggled :100: emoji award.')
      end
    end

    shared_examples 'duplicate command' do
      it 'fetches issue and populates canonical_issue_id if content contains /duplicate issue_reference' do
        issue_duplicate # populate the issue
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(canonical_issue_id: issue_duplicate.id)
      end

      it 'returns the duplicate message' do
        _, _, message = service.execute(content, issuable)

        expect(message).to eq(""Closed this issue. Marked as related to, and a duplicate of, #{issue_duplicate.to_reference(project)}."")
      end

      it 'includes duplicate reference' do
        _, explanations = service.explain(content, issuable)

        expect(explanations).to eq([""Closes this issue. Marks as related to, and a duplicate of, #{issue_duplicate.to_reference(project)}.""])
      end
    end

    shared_examples 'copy_metadata command' do
      it 'fetches issue or merge request and copies labels and milestone if content contains /copy_metadata reference' do
        source_issuable # populate the issue
        todo_label # populate this label
        inreview_label # populate this label
        _, updates, _ = service.execute(content, issuable)

        expect(updates[:add_label_ids]).to match_array([inreview_label.id, todo_label.id])

        if source_issuable.milestone
          expect(updates[:milestone_id]).to eq(source_issuable.milestone.id)
        else
          expect(updates).not_to have_key(:milestone_id)
        end
      end

      it 'returns the copy metadata message' do
        _, _, message = service.execute(""/copy_metadata #{source_issuable.to_reference}"", issuable)

        expect(message).to eq(""Copied labels and milestone from #{source_issuable.to_reference}."")
      end
    end

    describe 'move issue command' do
      it 'returns the move issue message' do
        _, _, message = service.execute(""/move #{project.full_path}"", issue)

        expect(message).to eq(""Moved this issue to #{project.full_path}."")
      end

      it 'returns move issue failure message when the referenced issue is not found' do
        _, _, message = service.execute('/move invalid', issue)

        expect(message).to eq(_(""Failed to move this issue because target project doesn't exist.""))
      end
    end

    shared_examples 'confidential command' do
      it 'marks issue as confidential if content contains /confidential' do
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(confidential: true)
      end

      it 'returns the confidential message' do
        _, _, message = service.execute(content, issuable)

        expect(message).to eq('Made this issue confidential.')
      end

      context 'when issuable is already confidential' do
        before do
          issuable.update!(confidential: true)
        end

        it 'returns an error message' do
          _, _, message = service.execute(content, issuable)

          expect(message).to eq('Could not apply confidential command.')
        end

        it 'is not part of the available commands' do
          expect(service.available_commands(issuable)).not_to include(a_hash_including(name: :confidential))
        end
      end
    end

    shared_examples 'approve command unavailable' do
      it 'is not part of the available commands' do
        expect(service.available_commands(issuable)).not_to include(a_hash_including(name: :approve))
      end
    end

    shared_examples 'unapprove command unavailable' do
      it 'is not part of the available commands' do
        expect(service.available_commands(issuable)).not_to include(a_hash_including(name: :unapprove))
      end
    end

    shared_examples 'shrug command' do
      it 'appends ¯\_(ツ)_/¯ to the comment' do
        new_content, _, _ = service.execute(content, issuable)

        expect(new_content).to end_with(described_class::SHRUG)
      end
    end

    shared_examples 'tableflip command' do
      it 'appends (╯°□°)╯︵ ┻━┻ to the comment' do
        new_content, _, _ = service.execute(content, issuable)

        expect(new_content).to end_with(described_class::TABLEFLIP)
      end
    end

    shared_examples 'tag command' do
      it 'tags a commit' do
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(tag_name: tag_name, tag_message: tag_message)
      end

      it 'returns the tag message' do
        _, _, message = service.execute(content, issuable)

        if tag_message.present?
          expect(message).to eq(%(Tagged this commit to #{tag_name} with ""#{tag_message}"".))
        else
          expect(message).to eq(""Tagged this commit to #{tag_name}."")
        end
      end
    end

    shared_examples 'assign command' do
      it 'assigns to me' do
        cmd = '/assign me'

        _, updates, _ = service.execute(cmd, issuable)

        expect(updates).to eq(assignee_ids: [current_user.id])
      end

      it 'does not assign to group members' do
        grp = create(:group)
        grp.add_developer(developer)
        grp.add_developer(developer2)

        cmd = ""/assign #{grp.to_reference}""

        _, updates, message = service.execute(cmd, issuable)

        expect(updates).to be_blank
        expect(message).to include('Failed to find users')
      end

      context 'when there are too many references' do
        before do
          stub_const('Gitlab::QuickActions::UsersExtractor::MAX_QUICK_ACTION_USERS', 2)
        end

        it 'says what went wrong' do
          cmd = '/assign her and you, me and them'

          _, updates, message = service.execute(cmd, issuable)

          expect(updates).to be_blank
          expect(message).to include('Too many references. Quick actions are limited to at most 2 user references')
        end
      end

      context 'when the user extractor raises an uninticipated error' do
        before do
          allow_next(Gitlab::QuickActions::UsersExtractor)
            .to receive(:execute).and_raise(Gitlab::QuickActions::UsersExtractor::Error)
        end

        it 'tracks the exception in dev, and reports a generic message in production' do
          expect(Gitlab::ErrorTracking).to receive(:track_and_raise_for_dev_exception).twice

          _, updates, message = service.execute('/assign some text', issuable)

          expect(updates).to be_blank
          expect(message).to include('Something went wrong')
        end
      end

      it 'assigns to users with escaped underscores' do
        user = create(:user)
        base = user.username
        user.update!(username: ""#{base}_new"")
        issuable.project.add_developer(user)

        cmd = ""/assign @#{base}\\_new""

        _, updates, _ = service.execute(cmd, issuable)

        expect(updates).to eq(assignee_ids: [user.id])
      end

      it 'assigns to a single user' do
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(assignee_ids: [developer.id])
      end

      it 'returns the assign message' do
        _, _, message = service.execute(content, issuable)

        expect(message).to eq(""Assigned #{developer.to_reference}."")
      end

      context 'when the reference does not match the exact case' do
        let(:user) { create(:user) }
        let(:content) { ""/assign #{user.to_reference.upcase}"" }

        it 'assigns to the user' do
          issuable.project.add_developer(user)

          _, updates, message = service.execute(content, issuable)

          expect(content).not_to include(user.to_reference)
          expect(updates).to eq(assignee_ids: [user.id])
          expect(message).to eq(""Assigned #{user.to_reference}."")
        end
      end

      context 'when the user has a private profile' do
        let(:user) { create(:user, :private_profile) }
        let(:content) { ""/assign #{user.to_reference}"" }

        it 'assigns to the user' do
          issuable.project.add_developer(user)

          _, updates, message = service.execute(content, issuable)

          expect(updates).to eq(assignee_ids: [user.id])
          expect(message).to eq(""Assigned #{user.to_reference}."")
        end
      end
    end

    shared_examples 'assign_reviewer command' do
      it 'assigns a reviewer to a single user' do
        _, updates, message = service.execute(content, issuable)

        expect(updates).to eq(reviewer_ids: [developer.id])
        expect(message).to eq(""Assigned #{developer.to_reference} as reviewer."")
      end
    end

    shared_examples 'unassign_reviewer command' do
      it 'removes a single reviewer' do
        _, updates, message = service.execute(content, issuable)

        expect(updates).to eq(reviewer_ids: [])
        expect(message).to eq(""Removed reviewer #{developer.to_reference}."")
      end
    end

    it_behaves_like 'reopen command' do
      let(:content) { '/reopen' }
      let(:issuable) { issue }
    end

    it_behaves_like 'reopen command' do
      let(:content) { '/reopen' }
      let(:issuable) { merge_request }
    end

    it_behaves_like 'close command' do
      let(:content) { '/close' }
      let(:issuable) { issue }
    end

    it_behaves_like 'close command' do
      let(:content) { '/close' }
      let(:issuable) { merge_request }
    end

    context 'merge command' do
      let(:service) { described_class.new(project, developer, { merge_request_diff_head_sha: merge_request.diff_head_sha }) }
      let(:merge_request) { create(:merge_request, source_project: repository_project) }

      it_behaves_like 'merge immediately command' do
        let(:content) { '/merge' }
        let(:issuable) { merge_request }
      end

      context 'when the head pipeline of merge request is running' do
        before do
          create(:ci_pipeline, :detached_merge_request_pipeline, merge_request: merge_request)
          merge_request.update_head_pipeline
        end

        it_behaves_like 'merge automatically command' do
          let(:content) { '/merge' }
          let(:issuable) { merge_request }
        end
      end

      context 'can not be merged when logged user does not have permissions' do
        let(:service) { described_class.new(project, create(:user)) }

        it_behaves_like 'failed command', 'Could not apply merge command.' do
          let(:content) { ""/merge"" }
          let(:issuable) { merge_request }
        end
      end

      context 'can not be merged when sha does not match' do
        let(:service) { described_class.new(project, developer, { merge_request_diff_head_sha: 'othersha' }) }

        it_behaves_like 'failed command', 'Branch has been updated since the merge was requested.' do
          let(:content) { ""/merge"" }
          let(:issuable) { merge_request }
        end
      end

      context 'when sha is missing' do
        let(:project) { repository_project }
        let(:service) { described_class.new(project, developer, {}) }

        it_behaves_like 'failed command', 'The `/merge` quick action requires the SHA of the head of the branch.' do
          let(:content) { ""/merge"" }
          let(:issuable) { merge_request }
        end
      end

      context 'issue can not be merged' do
        it_behaves_like 'failed command', 'Could not apply merge command.' do
          let(:content) { ""/merge"" }
          let(:issuable) { issue }
        end
      end

      context 'non persisted merge request  cant be merged' do
        it_behaves_like 'failed command', 'Could not apply merge command.' do
          let(:content) { ""/merge"" }
          let(:issuable) { build(:merge_request) }
        end
      end

      context 'not persisted merge request can not be merged' do
        it_behaves_like 'failed command', 'Could not apply merge command.' do
          let(:content) { ""/merge"" }
          let(:issuable) { build(:merge_request, source_project: project) }
        end
      end
    end

    it_behaves_like 'title command' do
      let(:content) { '/title A brand new title' }
      let(:issuable) { issue }
    end

    it_behaves_like 'title command' do
      let(:content) { '/title A brand new title' }
      let(:issuable) { merge_request }
    end

    it_behaves_like 'failed command' do
      let(:content) { '/title' }
      let(:issuable) { issue }
    end

    context 'assign command with one user' do
      it_behaves_like 'assign command' do
        let(:content) { ""/assign @#{developer.username}"" }
        let(:issuable) { issue }
      end

      it_behaves_like 'assign command' do
        let(:content) { ""/assign @#{developer.username}"" }
        let(:issuable) { create(:incident, project: project) }
      end

      it_behaves_like 'assign command' do
        let(:content) { ""/assign @#{developer.username}"" }
        let(:issuable) { merge_request }
      end
    end

    # CE does not have multiple assignees
    context 'assign command with multiple assignees' do
      before do
        project.add_developer(developer2)
      end

      # There's no guarantee that the reference extractor will preserve
      # the order of the mentioned users since this is dependent on the
      # order in which rows are returned. We just ensure that at least
      # one of the mentioned users is assigned.
      shared_examples 'assigns to one of the two users' do
        let(:content) { ""/assign @#{developer.username} @#{developer2.username}"" }

        it 'assigns to a single user' do
          _, updates, message = service.execute(content, issuable)

          expect(updates[:assignee_ids].count).to eq(1)
          assignee = updates[:assignee_ids].first
          expect([developer.id, developer2.id]).to include(assignee)

          user = assignee == developer.id ? developer : developer2

          expect(message).to match(""Assigned #{user.to_reference}."")
        end
      end

      it_behaves_like 'assigns to one of the two users' do
        let(:content) { ""/assign @#{developer.username} @#{developer2.username}"" }
        let(:issuable) { issue }
      end

      it_behaves_like 'assigns to one of the two users' do
        let(:content) { ""/assign @#{developer.username} @#{developer2.username}"" }
        let(:issuable) { merge_request }
      end
    end

    context 'assign command with me alias' do
      it_behaves_like 'assign command' do
        let(:content) { '/assign me' }
        let(:issuable) { issue }
      end

      it_behaves_like 'assign command' do
        let(:content) { '/assign me' }
        let(:issuable) { merge_request }
      end
    end

    context 'assign command with me alias and whitespace' do
      it_behaves_like 'assign command' do
        let(:content) { '/assign  me ' }
        let(:issuable) { issue }
      end

      it_behaves_like 'assign command' do
        let(:content) { '/assign  me ' }
        let(:issuable) { merge_request }
      end
    end

    it_behaves_like 'failed command', 'a parse error' do
      let(:content) { '/assign @abcd1234' }
      let(:issuable) { issue }
      let(:match_msg) { eq ""Could not apply assign command. Failed to find users for '@abcd1234'."" }
    end

    it_behaves_like 'failed command', ""Failed to assign a user because no user was found."" do
      let(:content) { '/assign' }
      let(:issuable) { issue }
    end

    describe 'assign_reviewer command' do
      let(:content) { ""/assign_reviewer @#{developer.username}"" }
      let(:issuable) { merge_request }

      context 'with one user' do
        it_behaves_like 'assign_reviewer command'
      end

      context 'with an issue instead of a merge request' do
        let(:issuable) { issue }

        it_behaves_like 'failed command', 'Could not apply assign_reviewer command.'
      end

      # CE does not have multiple reviewers
      context 'assign command with multiple assignees' do
        before do
          project.add_developer(developer2)
        end

        # There's no guarantee that the reference extractor will preserve
        # the order of the mentioned users since this is dependent on the
        # order in which rows are returned. We just ensure that at least
        # one of the mentioned users is assigned.
        context 'assigns to one of the two users' do
          let(:content) { ""/assign_reviewer @#{developer.username} @#{developer2.username}"" }

          it 'assigns to a single reviewer' do
            _, updates, message = service.execute(content, issuable)

            expect(updates[:reviewer_ids].count).to eq(1)
            reviewer = updates[:reviewer_ids].first
            expect([developer.id, developer2.id]).to include(reviewer)

            user = reviewer == developer.id ? developer : developer2

            expect(message).to match(""Assigned #{user.to_reference} as reviewer."")
          end
        end
      end

      context 'with ""me"" alias' do
        let(:content) { '/assign_reviewer me' }

        it_behaves_like 'assign_reviewer command'
      end

      context 'with an alias and whitespace' do
        let(:content) { '/assign_reviewer  me ' }

        it_behaves_like 'assign_reviewer command'
      end

      context 'with @all' do
        let(:content) { ""/assign_reviewer @all"" }

        it_behaves_like 'failed command', 'a parse error' do
          let(:match_msg) { eq ""Could not apply assign_reviewer command. Failed to find users for '@all'."" }
        end
      end

      context 'with an incorrect user' do
        let(:content) { '/assign_reviewer @abcd1234' }

        it_behaves_like 'failed command', 'a parse error' do
          let(:match_msg) { eq ""Could not apply assign_reviewer command. Failed to find users for '@abcd1234'."" }
        end
      end

      context 'with the ""reviewer"" alias' do
        let(:content) { ""/reviewer @#{developer.username}"" }

        it_behaves_like 'assign_reviewer command'
      end

      context 'with the ""request_review"" alias' do
        let(:content) { ""/request_review @#{developer.username}"" }

        it_behaves_like 'assign_reviewer command'
      end

      context 'with no user' do
        let(:content) { '/assign_reviewer' }

        it_behaves_like 'failed command', ""Failed to assign a reviewer because no user was specified.""
      end

      context 'with extra text' do
        let(:content) { ""/assign_reviewer #{developer.to_reference} do it!"" }

        it_behaves_like 'failed command', 'a parse error' do
          let(:match_msg) { eq ""Could not apply assign_reviewer command. Failed to find users for 'do' and 'it!'."" }
        end
      end
    end

    describe 'unassign_reviewer command' do
      # CE does not have multiple reviewers, so basically anything
      # after /unassign_reviewer (including whitespace) will remove
      # all the current reviewers.
      let(:issuable) { create(:merge_request, reviewers: [developer]) }
      let(:content) { ""/unassign_reviewer @#{developer.username}"" }

      context 'with one user' do
        it_behaves_like 'unassign_reviewer command'
      end

      context 'with an issue instead of a merge request' do
        let(:issuable) { issue }

        it_behaves_like 'failed command', 'Could not apply unassign_reviewer command.'
      end

      context 'with anything after the command' do
        let(:content) { '/unassign_reviewer supercalifragilisticexpialidocious' }

        it_behaves_like 'unassign_reviewer command'
      end

      context 'with the ""remove_reviewer"" alias' do
        let(:content) { ""/remove_reviewer @#{developer.username}"" }

        it_behaves_like 'unassign_reviewer command'
      end

      context 'with no user' do
        let(:content) { '/unassign_reviewer' }

        it_behaves_like 'unassign_reviewer command'
      end
    end

    context 'unassign command' do
      let(:content) { '/unassign' }

      context 'Issue' do
        it 'populates assignee_ids: [] if content contains /unassign' do
          issue.update!(assignee_ids: [developer.id])
          _, updates, _ = service.execute(content, issue)

          expect(updates).to eq(assignee_ids: [])
        end

        it 'returns the unassign message for all the assignee if content contains /unassign' do
          issue.update!(assignee_ids: [developer.id, developer2.id])
          _, _, message = service.execute(content, issue)

          expect(message).to eq(""Removed assignees #{developer.to_reference} and #{developer2.to_reference}."")
        end
      end

      context 'Merge Request' do
        it 'populates assignee_ids: [] if content contains /unassign' do
          merge_request.update!(assignee_ids: [developer.id])
          _, updates, _ = service.execute(content, merge_request)

          expect(updates).to eq(assignee_ids: [])
        end

        it 'returns the unassign message for all the assignee if content contains /unassign' do
          merge_request.update!(assignee_ids: [developer.id, developer2.id])
          _, _, message = service.execute(content, merge_request)

          expect(message).to eq(""Removed assignees #{developer.to_reference} and #{developer2.to_reference}."")
        end
      end
    end

    context 'project milestones' do
      before do
        milestone
      end

      it_behaves_like 'milestone command' do
        let(:content) { ""/milestone %#{milestone.title}"" }
        let(:issuable) { issue }
      end

      it_behaves_like 'milestone command' do
        let(:content) { ""/milestone %#{milestone.title}"" }
        let(:issuable) { merge_request }
      end
    end

    context 'only group milestones available' do
      let_it_be(:ancestor_group) { create(:group) }
      let_it_be(:group) { create(:group, parent: ancestor_group) }
      let_it_be(:project) { create(:project, :public, namespace: group) }
      let_it_be(:milestone) { create(:milestone, group: ancestor_group, title: '10.0') }

      before_all do
        project.add_developer(developer)
      end

      it_behaves_like 'milestone command' do
        let(:content) { ""/milestone %#{milestone.title}"" }
        let(:issuable) { issue }
      end

      it_behaves_like 'milestone command' do
        let(:content) { ""/milestone %#{milestone.title}"" }
        let(:issuable) { merge_request }
      end
    end

    it_behaves_like 'remove_milestone command' do
      let(:content) { '/remove_milestone' }
      let(:issuable) { issue }
    end

    it_behaves_like 'remove_milestone command' do
      let(:content) { '/remove_milestone' }
      let(:issuable) { merge_request }
    end

    it_behaves_like 'label command' do
      let(:content) { %(/label ~""#{inprogress.title}"" ~#{bug.title} ~unknown) }
      let(:issuable) { issue }
    end

    it_behaves_like 'label command' do
      let(:content) { %(/label ~""#{inprogress.title}"" ~#{bug.title} ~unknown) }
      let(:issuable) { merge_request }
    end

    context 'with a colon label' do
      let(:bug) { create(:label, project: project, title: 'Category:Bug') }
      let(:inprogress) { create(:label, project: project, title: 'status:in:progress') }

      context 'when quoted' do
        let(:content) { %(/label ~""#{inprogress.title}"" ~""#{bug.title}"" ~unknown) }

        it_behaves_like 'label command' do
          let(:issuable) { merge_request }
        end

        it_behaves_like 'label command' do
          let(:issuable) { issue }
        end
      end

      context 'when unquoted' do
        let(:content) { %(/label ~#{inprogress.title} ~#{bug.title} ~unknown) }

        it_behaves_like 'label command' do
          let(:issuable) { merge_request }
        end

        it_behaves_like 'label command' do
          let(:issuable) { issue }
        end
      end
    end

    context 'with a scoped label' do
      let(:bug) { create(:label, :scoped, project: project) }
      let(:inprogress) { create(:label, project: project, title: 'three::part::label') }

      context 'when quoted' do
        let(:content) { %(/label ~""#{inprogress.title}"" ~""#{bug.title}"" ~unknown) }

        it_behaves_like 'label command' do
          let(:issuable) { merge_request }
        end

        it_behaves_like 'label command' do
          let(:issuable) { issue }
        end
      end

      context 'when unquoted' do
        let(:content) { %(/label ~#{inprogress.title} ~#{bug.title} ~unknown) }

        it_behaves_like 'label command' do
          let(:issuable) { merge_request }
        end

        it_behaves_like 'label command' do
          let(:issuable) { issue }
        end
      end
    end

    it_behaves_like 'multiple label command' do
      let(:content) { %(/label ~""#{inprogress.title}"" \n/label ~#{bug.title}) }
      let(:issuable) { issue }
    end

    it_behaves_like 'multiple label with same argument' do
      let(:content) { %(/label ~""#{inprogress.title}"" \n/label ~#{inprogress.title}) }
      let(:issuable) { issue }
    end

    it_behaves_like 'multiword label name starting without ~' do
      let(:content) { %(/label ""#{helmchart.title}"") }
      let(:issuable) { issue }
    end

    it_behaves_like 'multiword label name starting without ~' do
      let(:content) { %(/label ""#{helmchart.title}"") }
      let(:issuable) { merge_request }
    end

    it_behaves_like 'label name is included in the middle of another label name' do
      let(:content) { %(/label ~""#{helmchart.title}"") }
      let(:issuable) { issue }
    end

    it_behaves_like 'label name is included in the middle of another label name' do
      let(:content) { %(/label ~""#{helmchart.title}"") }
      let(:issuable) { merge_request }
    end

    it_behaves_like 'unlabel command' do
      let(:content) { %(/unlabel ~""#{inprogress.title}"") }
      let(:issuable) { issue }
    end

    it_behaves_like 'unlabel command' do
      let(:content) { %(/unlabel ~""#{inprogress.title}"") }
      let(:issuable) { merge_request }
    end

    it_behaves_like 'multiple unlabel command' do
      let(:content) { %(/unlabel ~""#{inprogress.title}"" \n/unlabel ~#{bug.title}) }
      let(:issuable) { issue }
    end

    it_behaves_like 'unlabel command with no argument' do
      let(:content) { %(/unlabel) }
      let(:issuable) { issue }
    end

    it_behaves_like 'unlabel command with no argument' do
      let(:content) { %(/unlabel) }
      let(:issuable) { merge_request }
    end

    it_behaves_like 'relabel command' do
      let(:content) { %(/relabel ~""#{inprogress.title}"") }
      let(:issuable) { issue }
    end

    it_behaves_like 'relabel command' do
      let(:content) { %(/relabel ~""#{inprogress.title}"") }
      let(:issuable) { merge_request }
    end

    it_behaves_like 'done command' do
      let(:content) { '/done' }
      let(:issuable) { issue }
    end

    it_behaves_like 'done command' do
      let(:content) { '/done' }
      let(:issuable) { merge_request }
    end

    it_behaves_like 'done command' do
      let(:content) { '/done' }
      let(:issuable) { work_item }
    end

    it_behaves_like 'subscribe command' do
      let(:content) { '/subscribe' }
      let(:issuable) { issue }
    end

    it_behaves_like 'subscribe command' do
      let(:content) { '/subscribe' }
      let(:issuable) { merge_request }
    end

    it_behaves_like 'subscribe command' do
      let(:content) { '/subscribe' }
      let(:issuable) { work_item }
    end

    it_behaves_like 'unsubscribe command' do
      let(:content) { '/unsubscribe' }
      let(:issuable) { issue }
    end

    it_behaves_like 'unsubscribe command' do
      let(:content) { '/unsubscribe' }
      let(:issuable) { merge_request }
    end

    it_behaves_like 'unsubscribe command' do
      let(:content) { '/unsubscribe' }
      let(:issuable) { work_item }
    end

    it_behaves_like 'failed command', 'Could not apply due command.' do
      let(:content) { '/due 2016-08-28' }
      let(:issuable) { merge_request }
    end

    it_behaves_like 'remove_due_date command' do
      let(:content) { '/remove_due_date' }
      let(:issuable) { issue }
    end

    it_behaves_like 'draft command' do
      let(:content) { '/draft' }
      let(:issuable) { merge_request }
    end

    it_behaves_like 'draft/ready command no action' do
      let(:content) { '/draft' }
      let(:issuable) { merge_request }

      before do
        issuable.update!(title: issuable.draft_title)
      end
    end

    it_behaves_like 'draft/ready command no action' do
      let(:content) { '/ready' }
      let(:issuable) { merge_request }
    end

    it_behaves_like 'ready command' do
      let(:content) { '/ready' }
      let(:issuable) { merge_request }
    end

    it_behaves_like 'failed command', 'Could not apply remove_due_date command.' do
      let(:content) { '/remove_due_date' }
      let(:issuable) { merge_request }
    end

    it_behaves_like 'estimate command' do
      let(:content) { '/estimate 1h' }
      let(:issuable) { issue }
    end

    it_behaves_like 'estimate command' do
      let(:content) { '/estimate_time 1h' }
      let(:issuable) { issue }
    end

    it_behaves_like 'failed command' do
      let(:content) { '/estimate' }
      let(:issuable) { issue }
    end

    context 'when provided an invalid estimate' do
      let(:content) { '/estimate abc' }
      let(:issuable) { issue }

      it 'populates {} if content contains an unsupported command' do
        _, updates, _ = service.execute(content, issuable)

        expect(updates[:time_estimate]).to be_nil
      end

      it ""returns empty message"" do
        _, _, message = service.execute(content, issuable)

        expect(message).to be_empty
      end
    end

    it_behaves_like 'spend command' do
      let(:content) { '/spend 1h' }
      let(:issuable) { issue }
    end

    it_behaves_like 'spend command' do
      let(:content) { '/spent 1h' }
      let(:issuable) { issue }
    end

    it_behaves_like 'spend command' do
      let(:content) { '/spend_time 1h' }
      let(:issuable) { issue }
    end

    it_behaves_like 'spend command with negative time' do
      let(:content) { '/spend -120m' }
      let(:issuable) { issue }
    end

    it_behaves_like 'spend command with negative time' do
      let(:content) { '/spent -120m' }
      let(:issuable) { issue }
    end

    it_behaves_like 'spend command with valid date' do
      let(:date) { '2016-02-02' }
      let(:content) { ""/spend 30m #{date}"" }
      let(:issuable) { issue }
    end

    it_behaves_like 'spend command with valid date' do
      let(:date) { '2016-02-02' }
      let(:content) { ""/spent 30m #{date}"" }
      let(:issuable) { issue }
    end

    it_behaves_like 'spend command with invalid date' do
      let(:content) { '/spend 30m 17-99-99' }
      let(:issuable) { issue }
    end

    it_behaves_like 'spend command with invalid date' do
      let(:content) { '/spent 30m 17-99-99' }
      let(:issuable) { issue }
    end

    it_behaves_like 'spend command with future date' do
      let(:content) { '/spend 30m 6017-10-10' }
      let(:issuable) { issue }
    end

    it_behaves_like 'spend command with future date' do
      let(:content) { '/spent 30m 6017-10-10' }
      let(:issuable) { issue }
    end

    it_behaves_like 'failed command' do
      let(:content) { '/spend' }
      let(:issuable) { issue }
    end

    it_behaves_like 'failed command' do
      let(:content) { '/spent' }
      let(:issuable) { issue }
    end

    it_behaves_like 'failed command' do
      let(:content) { '/spend abc' }
      let(:issuable) { issue }
    end

    it_behaves_like 'failed command' do
      let(:content) { '/spent abc' }
      let(:issuable) { issue }
    end

    it_behaves_like 'remove_estimate command' do
      let(:content) { '/remove_estimate' }
      let(:issuable) { issue }
    end

    it_behaves_like 'remove_estimate command' do
      let(:content) { '/remove_time_estimate' }
      let(:issuable) { issue }
    end

    it_behaves_like 'remove_time_spent command' do
      let(:content) { '/remove_time_spent' }
      let(:issuable) { issue }
    end

    context '/confidential' do
      it_behaves_like 'confidential command' do
        let(:content) { '/confidential' }
        let(:issuable) { issue }
      end

      it_behaves_like 'confidential command' do
        let(:content) { '/confidential' }
        let(:issuable) { create(:incident, project: project) }
      end

      context 'when non-member is creating a new issue' do
        let(:service) { described_class.new(project, create(:user)) }

        it_behaves_like 'confidential command' do
          let(:content) { '/confidential' }
          let(:issuable) { build(:issue, project: project) }
        end
      end
    end

    it_behaves_like 'lock command' do
      let(:content) { '/lock' }
      let(:issuable) { issue }
    end

    it_behaves_like 'lock command' do
      let(:content) { '/lock' }
      let(:issuable) { merge_request }
    end

    it_behaves_like 'unlock command' do
      let(:content) { '/unlock' }
      let(:issuable) { issue }
    end

    it_behaves_like 'unlock command' do
      let(:content) { '/unlock' }
      let(:issuable) { merge_request }
    end

    context '/todo' do
      let(:content) { '/todo' }

      context 'if issuable is an Issue' do
        it_behaves_like 'todo command' do
          let(:issuable) { issue }
        end
      end

      context 'if issuable is a work item' do
        it_behaves_like 'todo command' do
          let(:issuable) { work_item }
        end
      end

      context 'if issuable is a MergeRequest' do
        it_behaves_like 'todo command' do
          let(:issuable) { merge_request }
        end
      end

      context 'if issuable is a Commit' do
        it_behaves_like 'failed command', 'Could not apply todo command.' do
          let(:issuable) { commit }
        end
      end
    end

    context '/due command' do
      it 'returns invalid date format message when the due date is invalid' do
        issue = build(:issue, project: project)

        _, _, message = service.execute('/due invalid date', issue)

        expect(message).to eq(_('Failed to set due date because the date format is invalid.'))
      end

      it_behaves_like 'due command' do
        let(:content) { '/due 2016-08-28' }
        let(:issuable) { issue }
      end

      it_behaves_like 'due command' do
        let(:content) { '/due tomorrow' }
        let(:issuable) { issue }
        let(:expected_date) { Date.tomorrow }
      end

      it_behaves_like 'due command' do
        let(:content) { '/due 5 days from now' }
        let(:issuable) { issue }
        let(:expected_date) { 5.days.from_now.to_date }
      end

      it_behaves_like 'due command' do
        let(:content) { '/due in 2 days' }
        let(:issuable) { issue }
        let(:expected_date) { 2.days.from_now.to_date }
      end
    end

    context '/copy_metadata command' do
      let(:todo_label) { create(:label, project: project, title: 'To Do') }
      let(:inreview_label) { create(:label, project: project, title: 'In Review') }

      it 'is available when the user is a developer' do
        expect(service.available_commands(issue)).to include(a_hash_including(name: :copy_metadata))
      end

      context 'when the user does not have permission' do
        let(:guest) { create(:user) }
        let(:service) { described_class.new(project, guest) }

        it 'is not available' do
          expect(service.available_commands(issue)).not_to include(a_hash_including(name: :copy_metadata))
        end
      end

      it_behaves_like 'failed command' do
        let(:content) { '/copy_metadata' }
        let(:issuable) { issue }
      end

      it_behaves_like 'copy_metadata command' do
        let(:source_issuable) { create(:labeled_issue, project: project, labels: [inreview_label, todo_label]) }

        let(:content) { ""/copy_metadata #{source_issuable.to_reference}"" }
        let(:issuable) { build(:issue, project: project) }
      end

      it_behaves_like 'copy_metadata command' do
        let(:source_issuable) { create(:labeled_issue, project: project, labels: [inreview_label, todo_label]) }

        let(:content) { ""/copy_metadata #{source_issuable.to_reference}"" }
        let(:issuable) { issue }
      end

      context 'when the parent issuable has a milestone' do
        it_behaves_like 'copy_metadata command' do
          let(:source_issuable) { create(:labeled_issue, project: project, labels: [todo_label, inreview_label], milestone: milestone) }

          let(:content) { ""/copy_metadata #{source_issuable.to_reference(project)}"" }
          let(:issuable) { issue }
        end
      end

      context 'when more than one issuable is passed' do
        it_behaves_like 'copy_metadata command' do
          let(:source_issuable) { create(:labeled_issue, project: project, labels: [inreview_label, todo_label]) }
          let(:other_label) { create(:label, project: project, title: 'Other') }
          let(:other_source_issuable) { create(:labeled_issue, project: project, labels: [other_label]) }

          let(:content) { ""/copy_metadata #{source_issuable.to_reference} #{other_source_issuable.to_reference}"" }
          let(:issuable) { issue }
        end
      end

      context 'cross project references' do
        it_behaves_like 'failed command' do
          let(:other_project) { create(:project, :public) }
          let(:source_issuable) { create(:labeled_issue, project: other_project, labels: [todo_label, inreview_label]) }
          let(:content) { ""/copy_metadata #{source_issuable.to_reference(project)}"" }
          let(:issuable) { issue }
        end

        it_behaves_like 'failed command' do
          let(:content) { ""/copy_metadata imaginary##{non_existing_record_iid}"" }
          let(:issuable) { issue }
        end

        it_behaves_like 'failed command' do
          let(:other_project) { create(:project, :private) }
          let(:source_issuable) { create(:issue, project: other_project) }

          let(:content) { ""/copy_metadata #{source_issuable.to_reference(project)}"" }
          let(:issuable) { issue }
        end
      end
    end

    context '/duplicate command' do
      it_behaves_like 'duplicate command' do
        let(:issue_duplicate) { create(:issue, project: project) }
        let(:content) { ""/duplicate #{issue_duplicate.to_reference}"" }
        let(:issuable) { issue }
      end

      it_behaves_like 'failed command' do
        let(:content) { '/duplicate' }
        let(:issuable) { issue }
      end

      context 'cross project references' do
        it_behaves_like 'duplicate command' do
          let(:other_project) { create(:project, :public) }
          let(:issue_duplicate) { create(:issue, project: other_project) }
          let(:content) { ""/duplicate #{issue_duplicate.to_reference(project)}"" }
          let(:issuable) { issue }
        end

        it_behaves_like 'failed command', _('Failed to mark this issue as a duplicate because referenced issue was not found.') do
          let(:content) { ""/duplicate imaginary##{non_existing_record_iid}"" }
          let(:issuable) { issue }
        end

        it_behaves_like 'failed command', _('Failed to mark this issue as a duplicate because referenced issue was not found.') do
          let(:other_project) { create(:project, :private) }
          let(:issue_duplicate) { create(:issue, project: other_project) }

          let(:content) { ""/duplicate #{issue_duplicate.to_reference(project)}"" }
          let(:issuable) { issue }
        end
      end
    end

    context 'when current_user cannot :admin_issue' do
      let(:visitor) { create(:user) }
      let(:issue) { create(:issue, project: project, author: visitor) }
      let(:service) { described_class.new(project, visitor) }

      it_behaves_like 'failed command', 'Could not apply assign command.' do
        let(:content) { ""/assign @#{developer.username}"" }
        let(:issuable) { issue }
      end

      it_behaves_like 'failed command', 'Could not apply unassign command.' do
        let(:content) { '/unassign' }
        let(:issuable) { issue }
      end

      it_behaves_like 'failed command', 'Could not apply milestone command.' do
        let(:content) { ""/milestone %#{milestone.title}"" }
        let(:issuable) { issue }
      end

      it_behaves_like 'failed command', 'Could not apply remove_milestone command.' do
        let(:content) { '/remove_milestone' }
        let(:issuable) { issue }
      end

      it_behaves_like 'failed command', 'Could not apply label command.' do
        let(:content) { %(/label ~""#{inprogress.title}"" ~#{bug.title} ~unknown) }
        let(:issuable) { issue }
      end

      it_behaves_like 'failed command', 'Could not apply unlabel command.' do
        let(:content) { %(/unlabel ~""#{inprogress.title}"") }
        let(:issuable) { issue }
      end

      it_behaves_like 'failed command', 'Could not apply relabel command.' do
        let(:content) { %(/relabel ~""#{inprogress.title}"") }
        let(:issuable) { issue }
      end

      it_behaves_like 'failed command', 'Could not apply due command.' do
        let(:content) { '/due tomorrow' }
        let(:issuable) { issue }
      end

      it_behaves_like 'failed command', 'Could not apply remove_due_date command.' do
        let(:content) { '/remove_due_date' }
        let(:issuable) { issue }
      end

      it_behaves_like 'failed command', 'Could not apply confidential command.' do
        let(:content) { '/confidential' }
        let(:issuable) { issue }
      end

      it_behaves_like 'failed command', 'Could not apply lock command.' do
        let(:content) { '/lock' }
        let(:issuable) { issue }
      end

      it_behaves_like 'failed command', 'Could not apply unlock command.' do
        let(:content) { '/unlock' }
        let(:issuable) { issue }
      end
    end

    context '/award command' do
      it_behaves_like 'award command' do
        let(:content) { '/award :100:' }
        let(:issuable) { issue }
      end

      it_behaves_like 'award command' do
        let(:content) { '/award :100:' }
        let(:issuable) { merge_request }
      end

      it_behaves_like 'award command' do
        let(:content) { '/award :100:' }
        let(:issuable) { work_item }
      end

      context 'ignores command with no argument' do
        it_behaves_like 'failed command' do
          let(:content) { '/award' }
          let(:issuable) { issue }
        end

        it_behaves_like 'failed command' do
          let(:content) { '/award' }
          let(:issuable) { work_item }
        end
      end

      context 'ignores non-existing / invalid  emojis' do
        it_behaves_like 'failed command' do
          let(:content) { '/award noop' }
          let(:issuable) { issue }
        end

        it_behaves_like 'failed command' do
          let(:content) { '/award :lorem_ipsum:' }
          let(:issuable) { issue }
        end

        it_behaves_like 'failed command' do
          let(:content) { '/award :lorem_ipsum:' }
          let(:issuable) { work_item }
        end
      end

      context 'if issuable is a Commit' do
        let(:content) { '/award :100:' }
        let(:issuable) { commit }

        it_behaves_like 'failed command', 'Could not apply award command.'
      end
    end

    context '/shrug command' do
      it_behaves_like 'shrug command' do
        let(:content) { '/shrug people are people' }
        let(:issuable) { issue }
      end

      it_behaves_like 'shrug command' do
        let(:content) { '/shrug' }
        let(:issuable) { issue }
      end
    end

    context '/tableflip command' do
      it_behaves_like 'tableflip command' do
        let(:content) { '/tableflip curse your sudden but enviable betrayal' }
        let(:issuable) { issue }
      end

      it_behaves_like 'tableflip command' do
        let(:content) { '/tableflip' }
        let(:issuable) { issue }
      end
    end

    context '/target_branch command' do
      let(:non_empty_project) { create(:project, :repository) }
      let(:another_merge_request) { create(:merge_request, author: developer, source_project: non_empty_project) }
      let(:service) { described_class.new(non_empty_project, developer) }

      it 'updates target_branch if /target_branch command is executed' do
        _, updates, _ = service.execute('/target_branch merge-test', merge_request)

        expect(updates).to eq(target_branch: 'merge-test')
      end

      it 'handles blanks around param' do
        _, updates, _ = service.execute('/target_branch  merge-test     ', merge_request)

        expect(updates).to eq(target_branch: 'merge-test')
      end

      context 'ignores command with no argument' do
        it_behaves_like 'failed command', 'Could not apply target_branch command.' do
          let(:content) { '/target_branch' }
          let(:issuable) { another_merge_request }
        end
      end

      context 'ignores non-existing target branch' do
        it_behaves_like 'failed command', 'Could not apply target_branch command.' do
          let(:content) { '/target_branch totally_non_existing_branch' }
          let(:issuable) { another_merge_request }
        end
      end

      it 'returns the target_branch message' do
        _, _, message = service.execute('/target_branch merge-test', merge_request)

        expect(message).to eq('Set target branch to merge-test.')
      end
    end

    context '/board_move command' do
      let_it_be(:todo) { create(:label, project: project, title: 'To Do') }
      let_it_be(:inreview) { create(:label, project: project, title: 'In Review') }
      let(:content) { %(/board_move ~""#{inreview.title}"") }

      let_it_be(:board) { create(:board, project: project) }
      let_it_be(:todo_list) { create(:list, board: board, label: todo) }
      let_it_be(:inreview_list) { create(:list, board: board, label: inreview) }
      let_it_be(:inprogress_list) { create(:list, board: board, label: inprogress) }

      it 'populates remove_label_ids for all current board columns' do
        issue.update!(label_ids: [todo.id, inprogress.id])

        _, updates, _ = service.execute(content, issue)

        expect(updates[:remove_label_ids]).to match_array([todo.id, inprogress.id])
      end

      it 'populates add_label_ids with the id of the given label' do
        _, updates, _ = service.execute(content, issue)

        expect(updates[:add_label_ids]).to eq([inreview.id])
      end

      it 'does not include the given label id in remove_label_ids' do
        issue.update!(label_ids: [todo.id, inreview.id])

        _, updates, _ = service.execute(content, issue)

        expect(updates[:remove_label_ids]).to match_array([todo.id])
      end

      it 'does not remove label ids that are not lists on the board' do
        issue.update!(label_ids: [todo.id, bug.id])

        _, updates, _ = service.execute(content, issue)

        expect(updates[:remove_label_ids]).to match_array([todo.id])
      end

      it 'returns board_move message' do
        issue.update!(label_ids: [todo.id, inprogress.id])

        _, _, message = service.execute(content, issue)

        expect(message).to eq(""Moved issue to ~#{inreview.id} column in the board."")
      end

      context 'if the project has multiple boards' do
        let(:issuable) { issue }

        before do
          create(:board, project: project)
        end

        it_behaves_like 'failed command', 'Could not apply board_move command.'
      end

      context 'if the given label does not exist' do
        let(:issuable) { issue }
        let(:content) { '/board_move ~""Fake Label""' }

        it_behaves_like 'failed command', 'Failed to move this issue because label was not found.'
      end

      context 'if multiple labels are given' do
        let(:issuable) { issue }
        let(:content) { %(/board_move ~""#{inreview.title}"" ~""#{todo.title}"") }

        it_behaves_like 'failed command', 'Failed to move this issue because only a single label can be provided.'
      end

      context 'if the given label is not a list on the board' do
        let(:issuable) { issue }
        let(:content) { %(/board_move ~""#{bug.title}"") }

        it_behaves_like 'failed command', 'Failed to move this issue because label was not found.'
      end

      context 'if issuable is not an Issue' do
        let(:issuable) { merge_request }

        it_behaves_like 'failed command', 'Could not apply board_move command.'
      end
    end

    context '/tag command' do
      let(:issuable) { commit }

      context 'ignores command with no argument' do
        it_behaves_like 'failed command' do
          let(:content) { '/tag' }
        end
      end

      context 'tags a commit with a tag name' do
        it_behaves_like 'tag command' do
          let(:tag_name) { 'v1.2.3' }
          let(:tag_message) { nil }
          let(:content) { ""/tag #{tag_name}"" }
        end
      end

      context 'tags a commit with a tag name and message' do
        it_behaves_like 'tag command' do
          let(:tag_name) { 'v1.2.3' }
          let(:tag_message) { 'Stable release' }
          let(:content) { ""/tag #{tag_name} #{tag_message}"" }
        end
      end
    end

    it 'limits to commands passed' do
      content = ""/shrug test\n/close""

      text, commands = service.execute(content, issue, only: [:shrug])

      expect(commands).to be_empty
      expect(text).to eq(""test #{described_class::SHRUG}\n/close"")
    end

    it 'preserves leading whitespace' do
      content = "" - list\n\n/close\n\ntest\n\n""

      text, _ = service.execute(content, issue)

      expect(text).to eq("" - list\n\ntest"")
    end

    it 'tracks MAU for commands' do
      content = ""/shrug test\n/assign me\n/milestone %4""

      expect(Gitlab::UsageDataCounters::QuickActionActivityUniqueCounter)
        .to receive(:track_unique_action)
        .with('shrug', args: 'test', user: developer)

      expect(Gitlab::UsageDataCounters::QuickActionActivityUniqueCounter)
        .to receive(:track_unique_action)
        .with('assign', args: 'me', user: developer)

      expect(Gitlab::UsageDataCounters::QuickActionActivityUniqueCounter)
        .to receive(:track_unique_action)
        .with('milestone', args: '%4', user: developer)

      service.execute(content, issue)
    end

    context '/create_merge_request command' do
      let(:branch_name) { '1-feature' }
      let(:content) { ""/create_merge_request #{branch_name}"" }
      let(:issuable) { issue }

      context 'if issuable is not an Issue' do
        let(:issuable) { merge_request }

        it_behaves_like 'failed command', 'Could not apply create_merge_request command.'
      end

      context ""when logged user cannot create_merge_requests in the project"" do
        let(:project) { create(:project, :archived) }

        before do
          project.add_developer(developer)
        end

        it_behaves_like 'failed command', 'Could not apply create_merge_request command.'
      end

      context 'when logged user cannot push code to the project' do
        let(:project) { create(:project, :private) }
        let(:service) { described_class.new(project, create(:user)) }

        it_behaves_like 'failed command', 'Could not apply create_merge_request command.'
      end

      it 'populates create_merge_request with branch_name and issue iid' do
        _, updates, _ = service.execute(content, issuable)

        expect(updates).to eq(create_merge_request: { branch_name: branch_name, issue_iid: issuable.iid })
      end

      it 'returns the create_merge_request message' do
        _, _, message = service.execute(content, issuable)

        expect(message).to eq(""Created branch '#{branch_name}' and a merge request to resolve this issue."")
      end
    end

    context 'submit_review command' do
      using RSpec::Parameterized::TableSyntax

      where(:note) do
        [
          'I like it',
          '/submit_review'
        ]
      end

      with_them do
        let(:content) { '/submit_review' }
        let!(:draft_note) { create(:draft_note, note: note, merge_request: merge_request, author: developer) }

        it 'submits the users current review' do
          _, _, message = service.execute(content, merge_request)

          expect { draft_note.reload }.to raise_error(ActiveRecord::RecordNotFound)
          expect(message).to eq('Submitted the current review.')
        end
      end

      context 'when parameters are passed' do
        context 'with approve parameter' do
          it 'calls MergeRequests::ApprovalService service' do
            expect_next_instance_of(
              MergeRequests::ApprovalService, project: merge_request.project, current_user: current_user
            ) do |service|
              expect(service).to receive(:execute).with(merge_request)
            end

            _, _, message = service.execute('/submit_review approve', merge_request)

            expect(message).to eq('Submitted the current review.')
          end
        end

        context 'with review state parameter' do
          it 'calls MergeRequests::UpdateReviewerStateService service' do
            expect_next_instance_of(
              MergeRequests::UpdateReviewerStateService, project: merge_request.project, current_user: current_user
            ) do |service|
              expect(service).to receive(:execute).with(merge_request, 'requested_changes')
            end

            _, _, message = service.execute('/submit_review requested_changes', merge_request)

            expect(message).to eq('Submitted the current review.')
          end
        end
      end
    end

    context 'request_changes command' do
      let(:merge_request) { create(:merge_request, source_project: project) }
      let(:content) { '/request_changes' }

      context ""when `mr_request_changes` feature flag is disabled"" do
        before do
          stub_feature_flags(mr_request_changes: false)
        end

        it 'does not call MergeRequests::UpdateReviewerStateService' do
          expect(MergeRequests::UpdateReviewerStateService).not_to receive(:new)

          service.execute(content, merge_request)
        end
      end

      context ""when the user is a reviewer"" do
        before do
          create(:merge_request_reviewer, merge_request: merge_request, reviewer: current_user)
        end

        it 'calls MergeRequests::UpdateReviewerStateService with requested_changes' do
          expect_next_instance_of(
            MergeRequests::UpdateReviewerStateService,
            project: project, current_user: current_user
          ) do |service|
            expect(service).to receive(:execute).with(merge_request, ""requested_changes"").and_return({ status: :success })
          end

          _, _, message = service.execute(content, merge_request)

          expect(message).to eq('Changes requested to the current merge request.')
        end

        it 'returns error message from MergeRequests::UpdateReviewerStateService' do
          expect_next_instance_of(
            MergeRequests::UpdateReviewerStateService,
            project: project, current_user: current_user
          ) do |service|
            expect(service).to receive(:execute).with(merge_request, ""requested_changes"").and_return({ status: :error, message: 'Error' })
          end

          _, _, message = service.execute(content, merge_request)

          expect(message).to eq('Error')
        end
      end

      context ""when the user is not a reviewer"" do
        it 'does not call MergeRequests::UpdateReviewerStateService' do
          expect(MergeRequests::UpdateReviewerStateService).not_to receive(:new)

          service.execute(content, merge_request)
        end
      end

      it_behaves_like 'approve command unavailable' do
        let(:issuable) { issue }
      end
    end

    it_behaves_like 'issues link quick action', :relate do
      let(:user) { developer }
    end

    context 'unlink command' do
      let_it_be(:private_issue) { create(:issue, project: create(:project, :private)) }
      let_it_be(:other_issue) { create(:issue, project: project) }
      let(:content) { ""/unlink #{other_issue.to_reference(issue)}"" }

      subject(:unlink_issues) { service.execute(content, issue) }

      shared_examples 'command with failure' do
        it 'does not destroy issues relation' do
          expect { unlink_issues }.not_to change { IssueLink.count }
        end

        it 'return correct execution message' do
          expect(unlink_issues[2]).to eq('No linked issue matches the provided parameter.')
        end
      end

      context 'when command includes linked issue' do
        let_it_be(:link1) { create(:issue_link, source: issue, target: other_issue) }
        let_it_be(:link2) { create(:issue_link, source: issue, target: private_issue) }

        it 'executes command successfully' do
          expect { unlink_issues }.to change { IssueLink.count }.by(-1)
          expect(unlink_issues[2]).to eq(""Removed link with #{other_issue.to_reference(issue)}."")
          expect(issue.notes.last.note).to eq(""removed the relation with #{other_issue.to_reference}"")
          expect(other_issue.notes.last.note).to eq(""removed the relation with #{issue.to_reference}"")
        end

        context 'when user has no access' do
          let(:content) { ""/unlink #{private_issue.to_reference(issue)}"" }

          it_behaves_like 'command with failure'
        end
      end

      context 'when provided issue is not linked' do
        it_behaves_like 'command with failure'
      end
    end

    context 'invite_email command' do
      let_it_be(:issuable) { issue }

      it_behaves_like 'failed command', ""No email participants were added. Either none were provided, or they already exist."" do
        let(:content) { '/invite_email' }
      end

      context 'with existing email participant' do
        let(:content) { '/invite_email a@gitlab.com' }

        before do
          issuable.issue_email_participants.create!(email: ""a@gitlab.com"")
        end

        it_behaves_like 'failed command', ""No email participants were added. Either none were provided, or they already exist.""
      end

      context 'with new email participants' do
        let(:content) { '/invite_email a@gitlab.com b@gitlab.com' }

        subject(:add_emails) { service.execute(content, issuable) }

        it 'returns message' do
          _, _, message = add_emails

          expect(message).to eq('Added a@gitlab.com and b@gitlab.com.')
        end

        it 'adds 2 participants' do
          expect { add_emails }.to change { issue.issue_email_participants.count }.by(2)
        end

        context 'with mixed case email' do
          let(:content) { '/invite_email FirstLast@GitLab.com' }

          it 'returns correctly cased message' do
            _, _, message = add_emails

            expect(message).to eq('Added FirstLast@GitLab.com.')
          end
        end

        context 'with invalid email' do
          let(:content) { '/invite_email a@gitlab.com bad_email' }

          it 'only adds valid emails' do
            expect { add_emails }.to change { issue.issue_email_participants.count }.by(1)
          end
        end

        context 'with existing email' do
          let(:content) { '/invite_email a@gitlab.com existing@gitlab.com' }

          it 'only adds new emails' do
            issue.issue_email_participants.create!(email: 'existing@gitlab.com')

            expect { add_emails }.to change { issue.issue_email_participants.count }.by(1)
          end

          it 'only adds new (case insensitive) emails' do
            issue.issue_email_participants.create!(email: 'EXISTING@gitlab.com')

            expect { add_emails }.to change { issue.issue_email_participants.count }.by(1)
          end
        end

        context 'with duplicate email' do
          let(:content) { '/invite_email a@gitlab.com a@gitlab.com' }

          it 'only adds unique new emails' do
            expect { add_emails }.to change { issue.issue_email_participants.count }.by(1)
          end
        end

        context 'with more than 6 emails' do
          let(:content) { '/invite_email a@gitlab.com b@gitlab.com c@gitlab.com d@gitlab.com e@gitlab.com f@gitlab.com g@gitlab.com' }

          it 'only adds 6 new emails' do
            expect { add_emails }.to change { issue.issue_email_participants.count }.by(6)
          end
        end

        context 'with feature flag disabled' do
          before do
            stub_feature_flags(issue_email_participants: false)
          end

          it 'does not add any participants' do
            expect { add_emails }.not_to change { issue.issue_email_participants.count }
          end
        end
      end

      it 'is part of the available commands' do
        expect(service.available_commands(issuable)).to include(a_hash_including(name: :invite_email))
      end

      context 'with non-persisted issue' do
        let(:issuable) { build(:issue) }

        it 'is not part of the available commands' do
          expect(service.available_commands(issuable)).not_to include(a_hash_including(name: :invite_email))
        end
      end
    end

    context 'severity command' do
      let_it_be_with_reload(:issuable) { create(:incident, project: project) }

      subject(:set_severity) { service.execute(content, issuable) }

      it_behaves_like 'failed command', 'No severity matches the provided parameter' do
        let(:content) { '/severity something' }
      end

      shared_examples 'updates the severity' do |new_severity|
        it do
          expect { set_severity }.to change { issuable.severity }.from('unknown').to(new_severity)
        end
      end

      context 'when quick action is used on creation' do
        let(:content) { '/severity s3' }
        let(:issuable) { build(:incident, project: project) }

        it_behaves_like 'updates the severity', 'medium'

        context 'issuable does not support severity' do
          let(:issuable) { build(:issue, project: project) }

          it_behaves_like 'failed command', ''
        end
      end

      context 'severity given with S format' do
        let(:content) { '/severity s3' }

        it_behaves_like 'updates the severity', 'medium'
      end

      context 'severity given with number format' do
        let(:content) { '/severity 3' }

        it_behaves_like 'updates the severity', 'medium'
      end

      context 'severity given with text format' do
        let(:content) { '/severity medium' }

        it_behaves_like 'updates the severity', 'medium'
      end

      context 'an issuable that does not support severity' do
        let_it_be_with_reload(:issuable) { create(:issue, project: project) }

        it_behaves_like 'failed command', 'Could not apply severity command.' do
          let(:content) { '/severity s3' }
        end
      end
    end

    context 'approve command' do
      let(:merge_request) { create(:merge_request, source_project: project) }
      let(:content) { '/approve' }

      it 'approves the current merge request' do
        service.execute(content, merge_request)

        expect(merge_request.approved_by_users).to eq([developer])
      end

      context ""when the user can't approve"" do
        before do
          project.team.truncate
          project.add_guest(developer)
        end

        it 'does not approve the MR' do
          service.execute(content, merge_request)

          expect(merge_request.approved_by_users).to be_empty
        end
      end

      it_behaves_like 'approve command unavailable' do
        let(:issuable) { issue }
      end
    end

    context 'unapprove command' do
      let!(:merge_request) { create(:merge_request, source_project: project) }
      let(:content) { '/unapprove' }

      before do
        service.execute('/approve', merge_request)
      end

      it 'unapproves the current merge request' do
        service.execute(content, merge_request)

        expect(merge_request.approved_by_users).to be_empty
      end

      it 'calls MergeRequests::UpdateReviewerStateService' do
        expect_next_instance_of(
          MergeRequests::UpdateReviewerStateService,
          project: project, current_user: current_user
        ) do |service|
          expect(service).to receive(:execute).with(merge_request, ""unreviewed"")
        end

        service.execute(content, merge_request)
      end

      context ""when the user can't unapprove"" do
        before do
          project.team.truncate
          project.add_guest(developer)
        end

        it 'does not unapprove the MR' do
          service.execute(content, merge_request)

          expect(merge_request.approved_by_users).to eq([developer])
        end

        it_behaves_like 'unapprove command unavailable' do
          let(:issuable) { issue }
        end
      end
    end

    context 'crm_contact commands' do
      let_it_be(:new_contact) { create(:contact, group: group) }
      let_it_be(:existing_contact) { create(:contact, group: group) }

      let(:add_command) { service.execute(""/add_contacts #{new_contact.email}"", issue) }
      let(:remove_command) { service.execute(""/remove_contacts #{existing_contact.email}"", issue) }

      before do
        issue.project.group.add_developer(developer)
        create(:issue_customer_relations_contact, issue: issue, contact: existing_contact)
      end

      it 'add_contacts command adds the contact' do
        _, updates, message = add_command

        expect(updates).to eq(add_contacts: [new_contact.email])
        expect(message).to eq('One or more contacts were successfully added.')
      end

      it 'remove_contacts command removes the contact' do
        _, updates, message = remove_command

        expect(updates).to eq(remove_contacts: [existing_contact.email])
        expect(message).to eq('One or more contacts were successfully removed.')
      end
    end

    context 'when using an alias' do
      it 'returns the correct execution message' do
        content = ""/labels ~#{bug.title}""

        _, _, message = service.execute(content, issue)

        expect(message).to eq(""Added ~\""Bug\"" label."")
      end
    end

    it_behaves_like 'quick actions that change work item type'

    context '/set_parent command' do
      let_it_be(:parent) { create(:work_item, :issue, project: project) }
      let_it_be(:work_item) { create(:work_item, :task, project: project) }
      let_it_be(:parent_ref) { parent.to_reference(project) }

      let(:content) { ""/set_parent #{parent_ref}"" }

      it 'returns success message' do
        _, _, message = service.execute(content, work_item)

        expect(message).to eq('Work item parent set successfully')
      end

      it 'sets correct update params' do
        _, updates, _ = service.execute(content, work_item)

        expect(updates).to eq(set_parent: parent)
      end
    end
  end

  describe '#explain' do
    let(:service) { described_class.new(project, developer) }
    let(:merge_request) { create(:merge_request, source_project: project) }

    describe 'close command' do
      let(:content) { '/close' }

      it 'includes issuable name' do
        content_result, explanations = service.explain(content, issue)

        expect(content_result).to eq('')
        expect(explanations).to eq(['Closes this issue.'])
      end
    end

    describe 'reopen command' do
      let(:content) { '/reopen' }
      let(:merge_request) { create(:merge_request, :closed, source_project: project) }

      it 'includes issuable name' do
        _, explanations = service.explain(content, merge_request)

        expect(explanations).to eq(['Reopens this merge request.'])
      end
    end

    describe 'title command' do
      let(:content) { '/title This is new title' }

      it 'includes new title' do
        _, explanations = service.explain(content, issue)

        expect(explanations).to eq(['Changes the title to ""This is new title"".'])
      end
    end

    describe 'assign command' do
      shared_examples 'assigns developer' do
        it 'tells us we will assign the developer' do
          _, explanations = service.explain(content, merge_request)

          expect(explanations).to eq([""Assigns @#{developer.username}.""])
        end
      end

      context 'when using a reference' do
        let(:content) { ""/assign @#{developer.username}"" }

        include_examples 'assigns developer'
      end

      context 'when using a bare username' do
        let(:content) { ""/assign #{developer.username}"" }

        include_examples 'assigns developer'
      end

      context 'when using me' do
        let(:content) { ""/assign me"" }

        include_examples 'assigns developer'
      end

      context 'when there are unparseable arguments' do
        let(:arg) { ""#{developer.username} to this issue"" }
        let(:content) { ""/assign #{arg}"" }

        it 'tells us why we cannot do that' do
          _, explanations = service.explain(content, merge_request)

          expect(explanations)
            .to contain_exactly ""Problem with assign command: Failed to find users for 'to', 'this', and 'issue'.""
        end
      end
    end

    describe 'unassign command' do
      let(:content) { '/unassign' }
      let(:issue) { create(:issue, project: project, assignees: [developer]) }

      it 'includes current assignee reference' do
        _, explanations = service.explain(content, issue)

        expect(explanations).to eq([""Removes assignee @#{developer.username}.""])
      end
    end

    describe 'unassign_reviewer command' do
      let(:content) { '/unassign_reviewer' }
      let(:merge_request) { create(:merge_request, source_project: project, reviewers: [developer]) }

      it 'includes current assignee reference' do
        _, explanations = service.explain(content, merge_request)

        expect(explanations).to eq([""Removes reviewer @#{developer.username}.""])
      end
    end

    describe 'assign_reviewer command' do
      let(:content) { ""/assign_reviewer #{developer.to_reference}"" }
      let(:merge_request) { create(:merge_request, source_project: project, assignees: [developer]) }

      it 'includes only the user reference' do
        _, explanations = service.explain(content, merge_request)

        expect(explanations).to eq([""Assigns #{developer.to_reference} as reviewer.""])
      end
    end

    describe 'milestone command' do
      let(:content) { '/milestone %wrong-milestone' }
      let!(:milestone) { create(:milestone, project: project, title: '9.10') }

      it 'is empty when milestone reference is wrong' do
        _, explanations = service.explain(content, issue)

        expect(explanations).to eq([])
      end
    end

    describe 'remove milestone command' do
      let(:content) { '/remove_milestone' }
      let(:merge_request) { create(:merge_request, source_project: project, milestone: milestone) }

      it 'includes current milestone name' do
        _, explanations = service.explain(content, merge_request)

        expect(explanations).to eq(['Removes %""9.10"" milestone.'])
      end
    end

    describe 'label command' do
      let(:content) { '/label ~missing' }
      let!(:label) { create(:label, project: project) }

      it 'is empty when there are no correct labels' do
        _, explanations = service.explain(content, issue)

        expect(explanations).to eq([])
      end
    end

    describe 'unlabel command' do
      let(:content) { '/unlabel' }

      it 'says all labels if no parameter provided' do
        merge_request.update!(label_ids: [bug.id])
        _, explanations = service.explain(content, merge_request)

        expect(explanations).to eq([_('Removes all labels.')])
      end
    end

    describe 'relabel command' do
      let(:content) { ""/relabel #{bug.title}"" }
      let(:feature) { create(:label, project: project, title: 'Feature') }

      it 'includes label name' do
        issue.update!(label_ids: [feature.id])
        _, explanations = service.explain(content, issue)

        expect(explanations).to eq([""Replaces all labels with ~#{bug.id} label.""])
      end
    end

    describe 'subscribe command' do
      let(:content) { '/subscribe' }

      it 'includes issuable name' do
        _, explanations = service.explain(content, issue)

        expect(explanations).to eq(['Subscribes to this issue.'])
      end
    end

    describe 'unsubscribe command' do
      let(:content) { '/unsubscribe' }

      it 'includes issuable name' do
        merge_request.subscribe(developer, project)
        _, explanations = service.explain(content, merge_request)

        expect(explanations).to eq(['Unsubscribes from this merge request.'])
      end
    end

    describe 'due command' do
      let(:content) { '/due April 1st 2016' }

      it 'includes the date' do
        _, explanations = service.explain(content, issue)

        expect(explanations).to eq(['Sets the due date to Apr 1, 2016.'])
      end
    end

    describe 'draft command set' do
      let(:content) { '/draft' }

      it 'includes the new status' do
        _, explanations = service.explain(content, merge_request)

        expect(explanations).to match_array(['Marks this merge request as a draft.'])
      end

      it 'includes the no change message when status unchanged' do
        merge_request.update!(title: merge_request.draft_title)
        _, explanations = service.explain(content, merge_request)

        expect(explanations).to match_array([""No change to this merge request's draft status.""])
      end
    end

    describe 'ready command' do
      let(:content) { '/ready' }

      it 'includes the new status' do
        merge_request.update!(title: merge_request.draft_title)
        _, explanations = service.explain(content, merge_request)

        expect(explanations).to match_array(['Marks this merge request as ready.'])
      end

      it 'includes the no change message when status unchanged' do
        _, explanations = service.explain(content, merge_request)

        expect(explanations).to match_array([""No change to this merge request's draft status.""])
      end
    end

    describe 'award command' do
      let(:content) { '/award :confetti_ball: ' }

      it 'includes the emoji' do
        _, explanations = service.explain(content, issue)

        expect(explanations).to eq(['Toggles :confetti_ball: emoji award.'])
      end
    end

    describe 'estimate command' do
      context 'positive estimation' do
        let(:content) { '/estimate 79d' }

        it 'includes the formatted duration' do
          _, explanations = service.explain(content, merge_request)

          expect(explanations).to eq(['Sets time estimate to 3mo 3w 4d.'])
        end
      end

      context 'zero estimation' do
        let(:content) { '/estimate 0' }

        it 'includes the formatted duration' do
          _, explanations = service.explain(content, merge_request)

          expect(explanations).to eq(['Removes time estimate.'])
        end
      end

      context 'negative estimation' do
        let(:content) { '/estimate -79d' }

        it 'does not explain' do
          _, explanations = service.explain(content, merge_request)

          expect(explanations).to be_empty
        end
      end

      context 'invalid estimation' do
        let(:content) { '/estimate a' }

        it 'does not explain' do
          _, explanations = service.explain(content, merge_request)

          expect(explanations).to be_empty
        end
      end
    end

    describe 'spend command' do
      it 'includes the formatted duration and proper verb when using /spend' do
        _, explanations = service.explain('/spend -120m', issue)

        expect(explanations).to eq(['Subtracts 2h spent time.'])
      end

      it 'includes the formatted duration and proper verb when using /spent' do
        _, explanations = service.explain('/spent -120m', issue)

        expect(explanations).to eq(['Subtracts 2h spent time.'])
      end
    end

    describe 'target branch command' do
      let(:content) { '/target_branch my-feature ' }

      it 'includes the branch name' do
        _, explanations = service.explain(content, merge_request)

        expect(explanations).to eq(['Sets target branch to my-feature.'])
      end
    end

    describe 'board move command' do
      let(:content) { ""/board_move ~#{bug.title}"" }
      let!(:board) { create(:board, project: project) }

      it 'includes the label name' do
        _, explanations = service.explain(content, issue)

        expect(explanations).to eq([""Moves issue to ~#{bug.id} column in the board.""])
      end
    end

    describe 'move issue to another project command' do
      let(:content) { '/move test/project' }

      it 'includes the project name' do
        _, explanations = service.explain(content, issue)

        expect(explanations).to eq([""Moves this issue to test/project.""])
      end
    end

    describe 'tag a commit' do
      describe 'with a tag name' do
        context 'without a message' do
          let(:content) { '/tag v1.2.3' }

          it 'includes the tag name only' do
            _, explanations = service.explain(content, commit)

            expect(explanations).to eq([""Tags this commit to v1.2.3.""])
          end
        end

        context 'with an empty message' do
          let(:content) { '/tag v1.2.3 ' }

          it 'includes the tag name only' do
            _, explanations = service.explain(content, commit)

            expect(explanations).to eq([""Tags this commit to v1.2.3.""])
          end
        end
      end

      describe 'with a tag name and message' do
        let(:content) { '/tag v1.2.3 Stable release' }

        it 'includes the tag name and message' do
          _, explanations = service.explain(content, commit)

          expect(explanations).to eq([""Tags this commit to v1.2.3 with \""Stable release\"".""])
        end
      end
    end

    describe 'create a merge request' do
      context 'with no branch name' do
        let(:content) { '/create_merge_request' }

        it 'uses the default branch name' do
          _, explanations = service.explain(content, issue)

          expect(explanations).to eq([_('Creates a branch and a merge request to resolve this issue.')])
        end

        it 'returns the execution message using the default branch name' do
          _, _, message = service.execute(content, issue)

          expect(message).to eq(_('Created a branch and a merge request to resolve this issue.'))
        end
      end

      context 'with a branch name' do
        let(:content) { '/create_merge_request foo' }

        it 'uses the given branch name' do
          _, explanations = service.explain(content, issue)

          expect(explanations).to eq([""Creates branch 'foo' and a merge request to resolve this issue.""])
        end

        it 'returns the execution message using the given branch name' do
          _, _, message = service.execute(content, issue)

          expect(message).to eq(""Created branch 'foo' and a merge request to resolve this issue."")
        end
      end
    end

    describe ""#commands_executed_count"" do
      it 'counts commands executed' do
        content = ""/close and \n/assign me and \n/title new title""

        service.execute(content, issue)

        expect(service.commands_executed_count).to eq(3)
      end
    end

    describe 'crm commands' do
      let(:add_contacts) { '/add_contacts' }
      let(:remove_contacts) { '/remove_contacts' }

      before_all do
        group.add_developer(developer)
      end

      context 'when group has no contacts' do
        it '/add_contacts is not available' do
          _, explanations = service.explain(add_contacts, issue)

          expect(explanations).to be_empty
        end
      end

      context 'when group has contacts' do
        let!(:contact) { create(:contact, group: group) }

        it '/add_contacts is available' do
          _, explanations = service.explain(add_contacts, issue)

          expect(explanations).to contain_exactly(""Add customer relation contact(s)."")
        end

        context 'when issue has no contacts' do
          it '/remove_contacts is not available' do
            _, explanations = service.explain(remove_contacts, issue)

            expect(explanations).to be_empty
          end
        end

        context 'when issue has contacts' do
          let!(:issue_contact) { create(:issue_customer_relations_contact, issue: issue, contact: contact) }

          it '/remove_contacts is available' do
            _, explanations = service.explain(remove_contacts, issue)

            expect(explanations).to contain_exactly(""Remove customer relation contact(s)."")
          end
        end
      end
    end

    context 'with keep_actions' do
      let(:content) { '/close' }

      it 'keeps quick actions' do
        content_result, explanations = service.explain(content, issue, keep_actions: true)

        expect(content_result).to eq(""\n/close"")
        expect(explanations).to eq(['Closes this issue.'])
      end

      it 'removes the quick action' do
        content_result, explanations = service.explain(content, issue, keep_actions: false)

        expect(content_result).to eq('')
        expect(explanations).to eq(['Closes this issue.'])
      end
    end

    describe 'type command' do
      let_it_be(:project) { create(:project, :private) }
      let_it_be(:work_item) { create(:work_item, :task, project: project) }

      let(:command) { '/type issue' }

      it 'has command available' do
        _, explanations = service.explain(command, work_item)

        expect(explanations)
          .to contain_exactly(""Converts work item to issue. Widgets not supported in new type are removed."")
      end
    end

    describe 'relate and unlink commands' do
      let_it_be(:other_issue) { create(:issue, project: project).to_reference(issue) }
      let(:relate_content) { ""/relate #{other_issue}"" }
      let(:unlink_content) { ""/unlink #{other_issue}"" }

      context 'when user has permissions' do
        it '/relate command is available' do
          _, explanations = service.explain(relate_content, issue)

          expect(explanations).to eq([""Marks this issue as related to #{other_issue}.""])
        end

        it '/unlink command is available' do
          _, explanations = service.explain(unlink_content, issue)

          expect(explanations).to eq([""Removes link with #{other_issue}.""])
        end
      end

      context 'when user has insufficient permissions' do
        before do
          allow(Ability).to receive(:allowed?).and_call_original
          allow(Ability).to receive(:allowed?).with(current_user, :admin_issue_link, issue).and_return(false)
        end

        it '/relate command is not available' do
          _, explanations = service.explain(relate_content, issue)

          expect(explanations).to be_empty
        end

        it '/unlink command is not available' do
          _, explanations = service.explain(unlink_content, issue)

          expect(explanations).to be_empty
        end
      end
    end

    describe 'promote_to command' do
      let(:content) { '/promote_to issue' }

      context 'when work item supports promotion' do
        let_it_be(:task) { build(:work_item, :task, project: project) }

        it 'includes the value' do
          _, explanations = service.explain(content, task)
          expect(explanations).to eq(['Promotes work item to issue.'])
        end
      end

      context 'when work item does not support promotion' do
        let_it_be(:incident) { build(:work_item, :incident, project: project) }

        it 'does not include the value' do
          _, explanations = service.explain(content, incident)
          expect(explanations).to be_empty
        end
      end
    end

    describe '/set_parent command' do
      let_it_be(:parent) { create(:work_item, :issue, project: project) }
      let_it_be(:work_item) { create(:work_item, :task, project: project) }
      let_it_be(:parent_ref) { parent.to_reference(project) }

      let(:command) { ""/set_parent #{parent_ref}"" }

      shared_examples 'command is available' do
        it 'explanation contains correct message' do
          _, explanations = service.explain(command, work_item)

          expect(explanations)
            .to contain_exactly(""Change work item's parent to #{parent_ref}."")
        end

        it 'contains command' do
          expect(service.available_commands(work_item)).to include(a_hash_including(name: :set_parent))
        end
      end

      shared_examples 'command is not available' do
        it 'explanation is empty' do
          _, explanations = service.explain(command, work_item)

          expect(explanations).to eq([])
        end

        it 'does not contain command' do
          expect(service.available_commands(work_item)).not_to include(a_hash_including(name: :set_parent))
        end
      end

      context 'when user can admin link' do
        it_behaves_like 'command is available'

        context 'when work item type does not support a parent' do
          let_it_be(:work_item) { build(:work_item, :incident, project: project) }

          it_behaves_like 'command is not available'
        end
      end

      context 'when user cannot admin link' do
        subject(:service) { described_class.new(project, create(:user)) }

        it_behaves_like 'command is not available'
      end
    end

    describe '/add_child command' do
      let_it_be(:child) { create(:work_item, :issue, project: project) }
      let_it_be(:work_item) { create(:work_item, :objective, project: project) }
      let_it_be(:child_ref) { child.to_reference(project) }

      let(:command) { ""/add_child #{child_ref}"" }

      shared_examples 'command is available' do
        it 'explanation contains correct message' do
          _, explanations = service.explain(command, work_item)

          expect(explanations)
            .to contain_exactly(""Add #{child_ref} to this work item as child(ren)."")
        end

        it 'contains command' do
          expect(service.available_commands(work_item)).to include(a_hash_including(name: :add_child))
        end
      end

      shared_examples 'command is not available' do
        it 'explanation is empty' do
          _, explanations = service.explain(command, work_item)

          expect(explanations).to eq([])
        end

        it 'does not contain command' do
          expect(service.available_commands(work_item)).not_to include(a_hash_including(name: :add_child))
        end
      end

      context 'when user can admin link' do
        it_behaves_like 'command is available'

        context 'when work item type does not support children' do
          let_it_be(:work_item) { build(:work_item, :key_result, project: project) }

          it_behaves_like 'command is not available'
        end
      end

      context 'when user cannot admin link' do
        subject(:service) { described_class.new(project, create(:user)) }

        it_behaves_like 'command is not available'
      end
    end
  end

  describe '#available_commands' do
    context 'when Guest is creating a new issue' do
      let_it_be(:guest) { create(:user) }

      let(:issue) { build(:issue, project: public_project) }
      let(:service) { described_class.new(project, guest) }

      before_all do
        public_project.add_guest(guest)
      end

      it 'includes commands to set metadata' do
        # milestone action is only available when project has a milestone
        milestone

        available_commands = service.available_commands(issue)

        expect(available_commands).to include(
          a_hash_including(name: :label),
          a_hash_including(name: :milestone),
          a_hash_including(name: :copy_metadata),
          a_hash_including(name: :assign),
          a_hash_including(name: :due)
        )
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Issues
  class ExportCsvService < ExportCsv::BaseService
    include Gitlab::Routing.url_helpers
    include GitlabRoutingHelper

    def initialize(relation, resource_parent, user = nil)
      super(relation, resource_parent)

      @labels = objects.labels_hash.transform_values { |labels| labels.sort.join(',').presence }
    end

    def email(mail_to_user)
      Notify.issues_csv_email(mail_to_user, resource_parent, csv_data, csv_builder.status).deliver_now
    end

    private

    def associations_to_preload
      [:work_item_type, :author, :assignees, :timelogs, :milestone, { project: { namespace: :route } }]
    end

    def header_to_value_hash
      {
        'Title' => 'title',
        'Description' => 'description',
        'Issue ID' => 'iid',
        'URL' => -> (issue) { issue_url(issue) },
        'State' => -> (issue) { issue.closed? ? 'Closed' : 'Open' },
        'Author' => 'author_name',
        'Author Username' => -> (issue) { issue.author&.username },
        'Assignee' => -> (issue) { issue.assignees.map(&:name).join(', ') },
        'Assignee Username' => -> (issue) { issue.assignees.map(&:username).join(', ') },
        'Confidential' => -> (issue) { issue.confidential? ? 'Yes' : 'No' },
        'Locked' => -> (issue) { issue.discussion_locked? ? 'Yes' : 'No' },
        'Due Date' => -> (issue) { issue.due_date&.to_fs(:csv) },
        'Created At (UTC)' => -> (issue) { issue.created_at&.to_fs(:csv) },
        'Updated At (UTC)' => -> (issue) { issue.updated_at&.to_fs(:csv) },
        'Closed At (UTC)' => -> (issue) { issue.closed_at&.to_fs(:csv) },
        'Milestone' => -> (issue) { issue.milestone&.title },
        'Weight' => -> (issue) { issue.weight },
        'Labels' => -> (issue) { issue_labels(issue) },
        'Time Estimate' => ->(issue) { issue.time_estimate.to_fs(:csv) },
        'Time Spent' => -> (issue) { issue_time_spent(issue) }
      }
    end

    def issue_labels(issue)
      @labels[issue.id]
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def issue_time_spent(issue)
      issue.timelogs.sum(&:time_spent)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def preload_associations_in_batches?
      Feature.enabled?(:export_csv_preload_in_batches, resource_parent)
    end
  end
end

Issues::ExportCsvService.prepend_mod_with('Issues::ExportCsvService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issues::ExportCsvService, :with_license, feature_category: :team_planning do
  let_it_be(:user) { create(:user) }
  let_it_be(:group) { create(:group) }
  let_it_be(:project) { create(:project, :public, group: group) }
  let_it_be(:issue) { create(:issue, project: project, author: user) }
  let_it_be(:bad_issue) { create(:issue, project: project, author: user) }

  subject { described_class.new(Issue.all, project) }

  it 'renders csv to string' do
    expect(subject.csv_data).to be_a String
  end

  describe '#email' do
    it 'emails csv' do
      expect { subject.email(user) }.to change(ActionMailer::Base.deliveries, :count)
    end

    it 'renders with a target filesize' do
      expect_next_instance_of(CsvBuilder) do |csv_builder|
        expect(csv_builder).to receive(:render).with(described_class::TARGET_FILESIZE).once
      end

      subject.email(user)
    end
  end

  def csv
    CSV.parse(subject.csv_data, headers: true)
  end

  context 'includes' do
    let_it_be(:milestone) { create(:milestone, title: 'v1.0', project: project) }
    let_it_be(:idea_label) { create(:label, project: project, title: 'Idea') }
    let_it_be(:feature_label) { create(:label, project: project, title: 'Feature') }

    before_all do
      # Creating a timelog touches the updated_at timestamp of issue,
      # so create these first.
      issue.timelogs.create!(time_spent: 360, user: user)
      issue.timelogs.create!(time_spent: 200, user: user)
      issue.update!(
        milestone: milestone,
        assignees: [user],
        description: 'Issue with details',
        state: :opened,
        due_date: DateTime.new(2014, 3, 2),
        created_at: DateTime.new(2015, 4, 3, 2, 1, 0),
        updated_at: DateTime.new(2016, 5, 4, 3, 2, 1),
        closed_at: DateTime.new(2017, 6, 5, 4, 3, 2),
        weight: 4,
        discussion_locked: true,
        labels: [feature_label, idea_label],
        time_estimate: 72000
      )
    end

    shared_examples 'exports CSVs for issues' do
      it 'includes the columns required for import' do
        expect(csv.headers).to include('Title', 'Description')
      end

      it 'returns two issues' do
        expect(csv.count).to eq(2)
      end

      specify 'iid' do
        expect(csv[0]['Issue ID']).to eq issue.iid.to_s
      end

      specify 'url' do
        expect(csv[0]['URL']).to match(/http.*#{project.full_path}.*#{issue.iid}/)
      end

      specify 'title' do
        expect(csv[0]['Title']).to eq issue.title
      end

      specify 'state' do
        expect(csv[0]['State']).to eq 'Open'
      end

      specify 'description' do
        expect(csv[0]['Description']).to eq issue.description
        expect(csv[1]['Description']).to eq nil
      end

      specify 'author name' do
        expect(csv[0]['Author']).to eq issue.author_name
      end

      specify 'author username' do
        expect(csv[0]['Author Username']).to eq issue.author.username
      end

      specify 'assignee name' do
        expect(csv[0]['Assignee']).to eq user.name
        expect(csv[1]['Assignee']).to eq ''
      end

      specify 'assignee username' do
        expect(csv[0]['Assignee Username']).to eq user.username
        expect(csv[1]['Assignee Username']).to eq ''
      end

      specify 'confidential' do
        expect(csv[0]['Confidential']).to eq 'No'
      end

      specify 'milestone' do
        expect(csv[0]['Milestone']).to eq issue.milestone.title
        expect(csv[1]['Milestone']).to eq nil
      end

      specify 'labels' do
        expect(csv[0]['Labels']).to eq 'Feature,Idea'
        expect(csv[1]['Labels']).to eq nil
      end

      specify 'due_date' do
        expect(csv[0]['Due Date']).to eq '2014-03-02'
        expect(csv[1]['Due Date']).to eq nil
      end

      specify 'created_at' do
        expect(csv[0]['Created At (UTC)']).to eq '2015-04-03 02:01:00'
      end

      specify 'updated_at' do
        expect(csv[0]['Updated At (UTC)']).to eq '2016-05-04 03:02:01'
      end

      specify 'closed_at' do
        expect(csv[0]['Closed At (UTC)']).to eq '2017-06-05 04:03:02'
        expect(csv[1]['Closed At (UTC)']).to eq nil
      end

      specify 'discussion_locked' do
        expect(csv[0]['Locked']).to eq 'Yes'
      end

      specify 'weight' do
        expect(csv[0]['Weight']).to eq '4'
      end

      specify 'time estimate' do
        expect(csv[0]['Time Estimate']).to eq '72000'
        expect(csv[1]['Time Estimate']).to eq '0'
      end

      specify 'time spent' do
        expect(csv[0]['Time Spent']).to eq '560'
        expect(csv[1]['Time Spent']).to eq '0'
      end

      context 'with issues filtered by labels and project' do
        subject do
          described_class.new(
            IssuesFinder.new(user, project_id: project.id, label_name: %w[Idea Feature]).execute,
            project
          )
        end

        it 'returns only filtered objects' do
          expect(csv.count).to eq(1)
          expect(csv[0]['Issue ID']).to eq issue.iid.to_s
        end
      end

      context 'with label links' do
        let(:labeled_issues) { create_list(:labeled_issue, 2, project: project, author: user, labels: [feature_label, idea_label]) }

        it 'does not run a query for each label link' do
          control_count = ActiveRecord::QueryRecorder.new { csv }.count

          labeled_issues

          expect { csv }.not_to exceed_query_limit(control_count)
          expect(csv.count).to eq(4)
        end

        it 'returns the labels in sorted order' do
          labeled_issues

          labeled_rows = csv.select { |entry| labeled_issues.map(&:iid).include?(entry['Issue ID'].to_i) }
          expect(labeled_rows.count).to eq(2)
          expect(labeled_rows.map { |entry| entry['Labels'] }).to all(eq(""Feature,Idea""))
        end
      end
    end

    context 'with export_csv_preload_in_batches feature flag disabled' do
      before do
        stub_feature_flags(export_csv_preload_in_batches: false)
      end

      it_behaves_like 'exports CSVs for issues'
    end

    context 'with export_csv_preload_in_batches feature flag enabled' do
      it_behaves_like 'exports CSVs for issues'
    end
  end

  context 'with minimal details' do
    it 'renders labels as nil' do
      expect(csv[0]['Labels']).to eq nil
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Issues
  class ReferencedMergeRequestsService < Issues::BaseService
    # rubocop: disable CodeReuse/ActiveRecord
    def execute(issue)
      referenced = referenced_merge_requests(issue)
      closed_by = closed_by_merge_requests(issue)

      ActiveRecord::Associations::Preloader.new(
        records: referenced + closed_by,
        associations: { head_pipeline: { project: [:route, { namespace: :route }] } }
      ).call

      [sort_by_iid(referenced), sort_by_iid(closed_by)]
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def referenced_merge_requests(issue)
      merge_requests = extract_merge_requests(issue)

      cross_project_filter = -> (merge_requests) do
        merge_requests.select { |mr| mr.target_project == project }
      end

      Ability.merge_requests_readable_by_user(
        merge_requests,
        current_user,
        filters: {
          read_cross_project: cross_project_filter
        }
      )
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def closed_by_merge_requests(issue)
      return [] unless issue.open?

      merge_requests = extract_merge_requests(issue, filter: :system).select(&:open?)

      return [] if merge_requests.empty?

      ids = MergeRequestsClosingIssues.where(merge_request_id: merge_requests.map(&:id), issue_id: issue.id).pluck(:merge_request_id)
      merge_requests.select { |mr| mr.id.in?(ids) }
    end
    # rubocop: enable CodeReuse/ActiveRecord

    private

    def extract_merge_requests(issue, filter: nil)
      ext = issue.all_references(current_user)
      notes = issue_notes(issue)
      notes = notes.select(&filter) if filter

      notes.each do |note|
        note.all_references(current_user, extractor: ext)
      end

      ext.merge_requests
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def issue_notes(issue)
      @issue_notes ||= {}
      @issue_notes[issue] ||= issue.notes.includes(:author)
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def sort_by_iid(merge_requests)
      Gitlab::IssuableSorter.sort(project, merge_requests) { |mr| mr.iid.to_s }
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issues::ReferencedMergeRequestsService, feature_category: :team_planning do
  def create_referencing_mr(attributes = {})
    create(:merge_request, attributes).tap do |merge_request|
      create(:note, :system, project: project, noteable: issue, author: user, note: merge_request.to_reference(full: true))
    end
  end

  def create_closing_mr(attributes = {})
    create_referencing_mr(attributes).tap do |merge_request|
      create(:merge_requests_closing_issues, issue: issue, merge_request: merge_request)
    end
  end

  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project, :public, :repository) }
  let_it_be(:other_project) { create(:project, :public, :repository) }
  let_it_be(:issue) { create(:issue, author: user, project: project) }

  let_it_be(:closing_mr) { create_closing_mr(source_project: project) }
  let_it_be(:closing_mr_other_project) { create_closing_mr(source_project: other_project) }

  let_it_be(:referencing_mr) { create_referencing_mr(source_project: project, source_branch: 'csv') }
  let_it_be(:referencing_mr_other_project) { create_referencing_mr(source_project: other_project, source_branch: 'csv') }

  let(:service) { described_class.new(container: project, current_user: user) }

  describe '#execute' do
    it 'returns a list of sorted merge requests' do
      mrs, closed_by_mrs = service.execute(issue)

      expect(mrs).to eq([closing_mr, referencing_mr, closing_mr_other_project, referencing_mr_other_project])
      expect(closed_by_mrs).to eq([closing_mr, closing_mr_other_project])
    end

    context 'performance' do
      it 'does not run extra queries when extra namespaces are included', :use_clean_rails_memory_store_caching do
        service.execute(issue) # warm cache
        control_count = ActiveRecord::QueryRecorder.new { service.execute(issue) }.count

        third_project = create(:project, :public)
        create_closing_mr(source_project: third_project)
        service.execute(issue) # warm cache

        expect { service.execute(issue) }.not_to exceed_query_limit(control_count)
      end

      it 'preloads the head pipeline for each merge request, and its routes' do
        # Hack to ensure no data is preserved on issue before starting the spec,
        # to avoid false negatives
        reloaded_issue = Issue.find(issue.id)

        pipeline_routes = lambda do |merge_requests|
          merge_requests.map { |mr| mr.head_pipeline&.project&.full_path }
        end

        closing_mr_other_project.update!(head_pipeline: create(:ci_pipeline))
        control_count = ActiveRecord::QueryRecorder.new { service.execute(reloaded_issue).each(&pipeline_routes) }

        closing_mr.update!(head_pipeline: create(:ci_pipeline))

        expect { service.execute(issue).each(&pipeline_routes) }
          .not_to exceed_query_limit(control_count)
      end

      it 'only loads issue notes once' do
        expect(issue).to receive(:notes).once.and_call_original

        service.execute(issue)
      end
    end
  end

  describe '#referenced_merge_requests' do
    it 'returns the referenced merge requests' do
      expect(service.referenced_merge_requests(issue)).to match_array([
                                                                        closing_mr,
                                                                        closing_mr_other_project,
                                                                        referencing_mr,
                                                                        referencing_mr_other_project
                                                                      ])
    end

    it 'excludes cross project references if the user cannot read cross project' do
      allow(Ability).to receive(:allowed?).and_call_original
      expect(Ability).to receive(:allowed?).with(user, :read_cross_project).at_least(:once).and_return(false)

      expect(service.referenced_merge_requests(issue)).not_to include(closing_mr_other_project)
      expect(service.referenced_merge_requests(issue)).not_to include(referencing_mr_other_project)
    end

    context 'performance' do
      it 'does not run a query for each note author', :use_clean_rails_memory_store_caching do
        service.referenced_merge_requests(issue) # warm cache
        control_count = ActiveRecord::QueryRecorder.new { service.referenced_merge_requests(issue) }.count

        create(:note, project: project, noteable: issue, author: create(:user))
        service.referenced_merge_requests(issue) # warm cache

        expect { service.referenced_merge_requests(issue) }.not_to exceed_query_limit(control_count)
      end
    end
  end

  describe '#closed_by_merge_requests' do
    let(:closed_issue) { build(:issue, :closed, project: project) }

    it 'returns the open merge requests that close this issue' do
      create_closing_mr(source_project: project, state: 'closed')

      expect(service.closed_by_merge_requests(issue)).to match_array([closing_mr, closing_mr_other_project])
    end

    it 'returns an empty array when the current issue is closed already' do
      expect(service.closed_by_merge_requests(closed_issue)).to eq([])
    end

    context 'performance' do
      it 'does not run a query for each note author', :use_clean_rails_memory_store_caching do
        service.closed_by_merge_requests(issue) # warm cache
        control_count = ActiveRecord::QueryRecorder.new { service.closed_by_merge_requests(issue) }.count

        create(:note, :system, project: project, noteable: issue, author: create(:user))
        service.closed_by_merge_requests(issue) # warm cache

        expect { service.closed_by_merge_requests(issue) }.not_to exceed_query_limit(control_count)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# This service fetches all branches containing the current issue's ID, except for
# those with a merge request open referencing the current issue.
module Issues
  class RelatedBranchesService < Issues::BaseService
    def execute(issue)
      branch_names_with_mrs = branches_with_merge_request_for(issue)
      branches = branches_with_iid_of(issue).reject { |b| branch_names_with_mrs.include?(b[:name]) }

      branches.map { |branch| branch_data(branch) }
    end

    private

    def branch_data(branch)
      {
        name: branch[:name],
        pipeline_status: pipeline_status(branch)
      }
    end

    def pipeline_status(branch)
      pipeline = project.latest_pipeline(branch[:name], branch[:target])
      pipeline.detailed_status(current_user) if can?(current_user, :read_pipeline, pipeline)
    end

    def branches_with_merge_request_for(issue)
      Issues::ReferencedMergeRequestsService
        .new(container: project, current_user: current_user)
        .referenced_merge_requests(issue)
        .map(&:source_branch)
    end

    def branches_with_iid_of(issue)
      branch_ref_regex = /\A#{Gitlab::Git::BRANCH_REF_PREFIX}#{issue.iid}-(?!\d+-stable)/i

      return [] unless project.repository.exists?

      project.repository.list_refs(
        [Gitlab::Git::BRANCH_REF_PREFIX + ""#{issue.iid}-*""]
      ).each_with_object([]) do |ref, results|
        if ref.name.match?(branch_ref_regex)
          results << { name: ref.name.delete_prefix(Gitlab::Git::BRANCH_REF_PREFIX), target: ref.target }
        end
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issues::RelatedBranchesService, feature_category: :team_planning do
  let_it_be(:project) { create(:project, :repository, :public, public_builds: false) }
  let_it_be(:developer) { create(:user) }
  let_it_be(:issue) { create(:issue, project: project) }

  let(:user) { developer }

  subject { described_class.new(container: project, current_user: user) }

  before_all do
    project.add_developer(developer)
  end

  describe '#execute' do
    let(:branch_info) { subject.execute(issue) }

    context 'branches are available' do
      let_it_be(:pipeline) { create(:ci_pipeline, :success, project: project, ref: issue.to_branch_name) }

      before_all do
        project.repository.create_branch(issue.to_branch_name, pipeline.sha)
        project.repository.create_branch(""#{issue.iid}doesnt-match"", project.repository.root_ref)
        project.repository.create_branch(""#{issue.iid}-0-stable"", project.repository.root_ref)

        project.repository.add_tag(developer, issue.to_branch_name, pipeline.sha)
      end

      context 'when user has access to pipelines' do
        it 'selects relevant branches, along with pipeline status' do
          expect(branch_info).to contain_exactly(
            { name: issue.to_branch_name, pipeline_status: an_instance_of(Gitlab::Ci::Status::Success) }
          )
        end
      end

      context 'when user does not have access to pipelines' do
        let(:user) { create(:user) }

        it 'returns branches without pipeline status' do
          expect(branch_info).to contain_exactly(
            { name: issue.to_branch_name, pipeline_status: nil }
          )
        end
      end

      it 'excludes branches referenced in merge requests' do
        merge_request = create(:merge_request, { description: ""Closes #{issue.to_reference}"",
                                                 source_project: issue.project,
                                                 source_branch: issue.to_branch_name })
        merge_request.create_cross_references!(user)

        referenced_merge_requests = Issues::ReferencedMergeRequestsService
                                      .new(container: issue.project, current_user: user)
                                      .referenced_merge_requests(issue)

        expect(referenced_merge_requests).not_to be_empty
        expect(branch_info.pluck(:name)).not_to include(merge_request.source_branch)
      end
    end

    context 'no branches are available' do
      let(:project) { create(:project, :empty_repo) }

      it 'returns an empty array' do
        expect(branch_info).to be_empty
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Issues
  class ReopenService < Issues::BaseService
    def execute(issue, skip_authorization: false)
      return issue unless can_reopen?(issue, skip_authorization: skip_authorization)

      if issue.reopen
        event_service.reopen_issue(issue, current_user)

        if current_user.project_bot?
          log_audit_event(issue, current_user, ""#{issue.issue_type}_reopened_by_project_bot"",
            ""Reopened #{issue.issue_type.humanize(capitalize: false)} #{issue.title}"")
        end

        create_note(issue, 'reopened')
        notification_service.async.reopen_issue(issue, current_user)
        perform_incident_management_actions(issue)
        execute_hooks(issue, 'reopen')
        invalidate_cache_counts(issue, users: issue.assignees)
        issue.update_project_counter_caches
        Milestones::ClosedIssuesCountService.new(issue.milestone).delete_cache if issue.milestone
        track_incident_action(current_user, issue, :incident_reopened)
      end

      issue
    end

    private

    def can_reopen?(issue, skip_authorization: false)
      skip_authorization || can?(current_user, :reopen_issue, issue)
    end

    def perform_incident_management_actions(issue)
      return unless issue.work_item_type&.incident?

      create_timeline_event(issue)
    end

    def create_note(issue, state = issue.state)
      SystemNoteService.change_status(issue, issue.project, current_user, state, nil)
    end

    def create_timeline_event(issue)
      IncidentManagement::TimelineEvents::CreateService.reopen_incident(issue, current_user)
    end
  end
end

Issues::ReopenService.prepend_mod_with('Issues::ReopenService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issues::ReopenService, feature_category: :team_planning do
  let(:project) { create(:project) }
  let(:issue) { create(:issue, :closed, project: project) }

  describe '#execute' do
    context 'when user is not authorized to reopen issue' do
      it 'does not reopen the issue' do
        guest = create(:user)
        project.add_guest(guest)

        described_class.new(container: project, current_user: guest).execute(issue)

        expect(issue).to be_closed
      end

      context 'when skip_authorization is true' do
        it 'does close the issue even if user is not authorized' do
          non_authorized_user = create(:user)

          service = described_class.new(container: project, current_user: non_authorized_user)

          expect do
            service.execute(issue, skip_authorization: true)
          end.to change { issue.reload.state }.from('closed').to('opened')
        end
      end
    end

    context 'when user is authorized to reopen issue' do
      let(:user) { create(:user) }

      subject(:execute) { described_class.new(container: project, current_user: user).execute(issue) }

      before do
        project.add_maintainer(user)
      end

      it 'invalidates counter cache for assignees' do
        issue.assignees << user
        expect_any_instance_of(User).to receive(:invalidate_issue_cache_counts)

        execute
      end

      it 'refreshes the number of opened issues' do
        expect do
          execute

          BatchLoader::Executor.clear_current
        end.to change { project.open_issues_count }.from(0).to(1)
      end

      it 'deletes milestone issue counters cache' do
        issue.update!(milestone: create(:milestone, project: project))

        expect_next_instance_of(Milestones::ClosedIssuesCountService, issue.milestone) do |service|
          expect(service).to receive(:delete_cache).and_call_original
        end

        execute
      end

      it 'does not create timeline event' do
        expect { execute }.not_to change { issue.incident_management_timeline_events.count }
      end

      it 'does not call GroupMentionWorker' do
        expect(Integrations::GroupMentionWorker).not_to receive(:perform_async)

        issue
      end

      context 'issue is incident type' do
        let(:issue) { create(:incident, :closed, project: project) }
        let(:current_user) { user }

        it_behaves_like 'an incident management tracked event', :incident_management_incident_reopened

        it_behaves_like 'Snowplow event tracking with RedisHLL context' do
          let(:namespace) { issue.namespace }
          let(:category) { described_class.to_s }
          let(:action) { 'incident_management_incident_reopened' }
          let(:label) { 'redis_hll_counters.incident_management.incident_management_total_unique_counts_monthly' }
        end

        it 'creates a timeline event' do
          expect(IncidentManagement::TimelineEvents::CreateService)
            .to receive(:reopen_incident)
            .with(issue, current_user)
            .and_call_original

          expect { execute }.to change { issue.incident_management_timeline_events.count }.by(1)
        end
      end

      context 'when issue is not confidential' do
        let(:expected_payload) do
          include(
            event_type: 'issue',
            object_kind: 'issue',
            changes: {
              closed_at: { current: nil, previous: kind_of(Time) },
              state_id: { current: 1, previous: 2 },
              updated_at: { current: kind_of(Time), previous: kind_of(Time) }
            },
            object_attributes: include(
              state: 'opened',
              action: 'reopen'
            )
          )
        end

        it 'executes issue hooks' do
          expect(project.project_namespace).to receive(:execute_hooks).with(expected_payload, :issue_hooks)
          expect(project.project_namespace).to receive(:execute_integrations).with(expected_payload, :issue_hooks)

          execute
        end
      end

      context 'when issue is confidential' do
        let(:issue) { create(:issue, :confidential, :closed, project: project) }

        it 'executes confidential issue hooks' do
          issue_hooks = :confidential_issue_hooks
          expect(project.project_namespace).to receive(:execute_hooks).with(an_instance_of(Hash), issue_hooks)
          expect(project.project_namespace).to receive(:execute_integrations).with(an_instance_of(Hash), issue_hooks)

          execute
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Issues
  class DuplicateService < Issues::BaseService
    def execute(duplicate_issue, canonical_issue)
      return if canonical_issue == duplicate_issue
      return unless can?(current_user, :update_issue, duplicate_issue)
      return unless can?(current_user, :create_note, canonical_issue)

      create_issue_duplicate_note(duplicate_issue, canonical_issue)
      create_issue_canonical_note(canonical_issue, duplicate_issue)

      close_service.new(container: project, current_user: current_user).execute(duplicate_issue)
      duplicate_issue.update(duplicated_to: canonical_issue)

      relate_two_issues(duplicate_issue, canonical_issue)
    end

    private

    def create_issue_duplicate_note(duplicate_issue, canonical_issue)
      SystemNoteService.mark_duplicate_issue(duplicate_issue, duplicate_issue.project, current_user, canonical_issue)
    end

    def create_issue_canonical_note(canonical_issue, duplicate_issue)
      SystemNoteService.mark_canonical_issue_of_duplicate(canonical_issue, canonical_issue.project, current_user, duplicate_issue)
    end

    def relate_two_issues(duplicate_issue, canonical_issue)
      params = { target_issuable: canonical_issue }

      IssueLinks::CreateService.new(duplicate_issue, current_user, params).execute
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issues::DuplicateService, feature_category: :team_planning do
  let(:user) { create(:user) }
  let(:canonical_project) { create(:project) }
  let(:duplicate_project) { create(:project) }

  let(:canonical_issue) { create(:issue, project: canonical_project) }
  let(:duplicate_issue) { create(:issue, project: duplicate_project) }

  subject { described_class.new(container: duplicate_project, current_user: user) }

  describe '#execute' do
    context 'when the issues passed are the same' do
      it 'does nothing' do
        expect(subject).not_to receive(:close_service)
        expect(SystemNoteService).not_to receive(:mark_duplicate_issue)
        expect(SystemNoteService).not_to receive(:mark_canonical_issue_of_duplicate)

        subject.execute(duplicate_issue, duplicate_issue)
      end
    end

    context 'when the user cannot update the duplicate issue' do
      before do
        canonical_project.add_reporter(user)
      end

      it 'does nothing' do
        expect(subject).not_to receive(:close_service)
        expect(SystemNoteService).not_to receive(:mark_duplicate_issue)
        expect(SystemNoteService).not_to receive(:mark_canonical_issue_of_duplicate)

        subject.execute(duplicate_issue, canonical_issue)
      end
    end

    context 'when the user cannot comment on the canonical issue' do
      before do
        duplicate_project.add_reporter(user)
      end

      it 'does nothing' do
        expect(subject).not_to receive(:close_service)
        expect(SystemNoteService).not_to receive(:mark_duplicate_issue)
        expect(SystemNoteService).not_to receive(:mark_canonical_issue_of_duplicate)

        subject.execute(duplicate_issue, canonical_issue)
      end
    end

    context 'when the user can mark the issue as a duplicate' do
      before do
        canonical_project.add_reporter(user)
        duplicate_project.add_reporter(user)
      end

      it 'closes the duplicate issue' do
        subject.execute(duplicate_issue, canonical_issue)

        expect(duplicate_issue.reload).to be_closed
        expect(canonical_issue.reload).to be_open
      end

      it 'adds a system note to the duplicate issue' do
        expect(SystemNoteService)
          .to receive(:mark_duplicate_issue).with(duplicate_issue, duplicate_project, user, canonical_issue)

        subject.execute(duplicate_issue, canonical_issue)
      end

      it 'adds a system note to the canonical issue' do
        expect(SystemNoteService)
          .to receive(:mark_canonical_issue_of_duplicate).with(canonical_issue, canonical_project, user, duplicate_issue)

        subject.execute(duplicate_issue, canonical_issue)
      end

      it 'updates duplicate issue with canonical issue id' do
        subject.execute(duplicate_issue, canonical_issue)

        expect(duplicate_issue.reload.duplicated_to).to eq(canonical_issue)
      end

      it 'relates the duplicate issues' do
        canonical_project.add_reporter(user)
        duplicate_project.add_reporter(user)

        subject.execute(duplicate_issue, canonical_issue)

        issue_link = IssueLink.last
        expect(issue_link.source).to eq(duplicate_issue)
        expect(issue_link.target).to eq(canonical_issue)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Issues
  class SetCrmContactsService < ::BaseProjectService
    MAX_ADDITIONAL_CONTACTS = 6

    # Replacing contacts by email is not currently supported
    def execute(issue)
      @issue = issue
      @errors = []

      return error_no_permissions unless allowed?
      return error_invalid_params unless valid_params?

      @existing_ids = issue.customer_relations_contact_ids
      determine_changes if set_present?
      return error_too_many if too_many?

      @added_count = 0
      @removed_count = 0

      add if params[:add_ids].present?
      remove if params[:remove_ids].present?

      add_by_email if params[:add_emails].present?
      remove_by_email if params[:remove_emails].present?

      if issue.valid?
        GraphqlTriggers.issue_crm_contacts_updated(issue)
        issue.touch
        create_system_note
        ServiceResponse.success(payload: issue)
      else
        # The default error isn't very helpful: ""Issue customer relations contacts is invalid""
        issue.errors.delete(:issue_customer_relations_contacts)
        issue.errors.add(:issue_customer_relations_contacts, errors.to_sentence)
        ServiceResponse.error(payload: issue, message: issue.errors.full_messages.to_sentence)
      end
    end

    private

    attr_accessor :issue, :errors, :existing_ids, :added_count, :removed_count

    def determine_changes
      params[:add_ids] = params[:replace_ids] - existing_ids
      params[:remove_ids] = existing_ids - params[:replace_ids]
    end

    def add
      add_by_id(params[:add_ids])
    end

    def add_by_email
      contact_ids = ::CustomerRelations::Contact.find_ids_by_emails(project_group.root_ancestor, emails(:add_emails))
      add_by_id(contact_ids)
    end

    def emails(key)
      params[key].map do |email|
        extract_email_from_request_param(email)
      end
    end

    def add_by_id(contact_ids)
      contact_ids -= existing_ids
      contact_ids.uniq.each do |contact_id|
        issue_contact = issue.issue_customer_relations_contacts.create(contact_id: contact_id)

        if issue_contact.persisted?
          @added_count += 1
        else
          # The validation ensures that the id exists and the user has permission
          errors << ""#{contact_id}: The resource that you are attempting to access does not exist or you don't have permission to perform this action""
        end
      end
    end

    def remove
      remove_by_id(params[:remove_ids])
    end

    def remove_by_email
      contact_ids = ::CustomerRelations::IssueContact.find_contact_ids_by_emails(issue.id, emails(:remove_emails))
      remove_by_id(contact_ids)
    end

    def remove_by_id(contact_ids)
      contact_ids &= existing_ids
      @removed_count += issue.issue_customer_relations_contacts
        .where(contact_id: contact_ids) # rubocop: disable CodeReuse/ActiveRecord
        .delete_all
    end

    def extract_email_from_request_param(email_param)
      email_param.delete_prefix(::CustomerRelations::Contact.reference_prefix_quoted)
                 .delete_prefix(::CustomerRelations::Contact.reference_prefix)
                 .delete_suffix(::CustomerRelations::Contact.reference_postfix)
                 .tr('""', '')
    end

    def allowed?
      current_user&.can?(:set_issue_crm_contacts, issue)
    end

    def valid_params?
      set_present? ^ add_or_remove_present?
    end

    def set_present?
      !params[:replace_ids].nil?
    end

    def add_or_remove_present?
      add_present? || remove_present?
    end

    def add_present?
      params[:add_ids].present? || params[:add_emails].present?
    end

    def remove_present?
      params[:remove_ids].present? || params[:remove_emails].present?
    end

    def too_many?
      too_many_ids? || too_many_emails?
    end

    def too_many_ids?
      params[:add_ids] && params[:add_ids].length > MAX_ADDITIONAL_CONTACTS
    end

    def too_many_emails?
      params[:add_emails] && params[:add_emails].length > MAX_ADDITIONAL_CONTACTS
    end

    def create_system_note
      SystemNoteService.change_issuable_contacts(
        issue, issue.project, current_user, added_count, removed_count)
    end

    def error_no_permissions
      ServiceResponse.error(message: _('You have insufficient permissions to set customer relations contacts for this issue'))
    end

    def error_invalid_params
      ServiceResponse.error(message: _('You cannot combine replace_ids with add_ids or remove_ids'))
    end

    def error_too_many
      ServiceResponse.error(payload: issue, message: _(""You can only add up to %{max_contacts} contacts at one time"" % { max_contacts: MAX_ADDITIONAL_CONTACTS }))
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issues::SetCrmContactsService, feature_category: :team_planning do
  let_it_be(:user) { create(:user) }
  let_it_be(:group) { create(:group, :crm_enabled) }
  let_it_be(:project) { create(:project, group: create(:group, :crm_enabled, parent: group)) }
  let_it_be(:contacts) { create_list(:contact, 4, group: group) }
  let_it_be(:issue, reload: true) { create(:issue, project: project) }
  let_it_be(:issue_contact_1) do
    create(:issue_customer_relations_contact, issue: issue, contact: contacts[0]).contact
  end

  let_it_be(:issue_contact_2) do
    create(:issue_customer_relations_contact, issue: issue, contact: contacts[1]).contact
  end

  let(:does_not_exist_or_no_permission) { ""The resource that you are attempting to access does not exist or you don't have permission to perform this action"" }

  subject(:set_crm_contacts) do
    described_class.new(project: project, current_user: user, params: params).execute(issue)
  end

  describe '#execute' do
    shared_examples 'setting contacts' do
      it 'updates the issue with correct contacts' do
        response = set_crm_contacts

        expect(response).to be_success
        expect(issue.customer_relations_contacts).to match_array(expected_contacts)
      end
    end

    shared_examples 'adds system note' do |added_count, removed_count|
      it 'calls SystemNoteService.change_issuable_contacts with correct counts' do
        expect(SystemNoteService)
          .to receive(:change_issuable_contacts)
          .with(issue, project, user, added_count, removed_count)

        set_crm_contacts
      end
    end

    context 'when the user has no permission' do
      let(:params) { { replace_ids: [contacts[1].id, contacts[2].id] } }

      it 'returns expected error response' do
        response = set_crm_contacts

        expect(response).to be_error
        expect(response.message).to eq('You have insufficient permissions to set customer relations contacts for this issue')
      end
    end

    context 'when user has permission' do
      before do
        group.add_reporter(user)
      end

      context 'but the crm setting is disabled' do
        let(:params) { { replace_ids: [contacts[1].id, contacts[2].id] } }
        let(:subgroup_with_crm_disabled) { create(:group, parent: group) }
        let(:project_with_crm_disabled) { create(:project, group: subgroup_with_crm_disabled) }
        let(:issue_with_crm_disabled) { create(:issue, project: project_with_crm_disabled) }

        it 'returns expected error response' do
          response = described_class.new(project: project_with_crm_disabled, current_user: user, params: params).execute(issue_with_crm_disabled)

          expect(response).to be_error
          expect(response.message).to eq('You have insufficient permissions to set customer relations contacts for this issue')
        end
      end

      context 'when the contact does not exist' do
        let(:params) { { replace_ids: [non_existing_record_id] } }

        it 'returns expected error response' do
          response = set_crm_contacts

          expect(response).to be_error
          expect(response.message).to eq(""Issue customer relations contacts #{non_existing_record_id}: #{does_not_exist_or_no_permission}"")
        end
      end

      context 'when the contact belongs to a different group' do
        let(:group2) { create(:group) }
        let(:contact) { create(:contact, group: group2) }
        let(:params) { { replace_ids: [contact.id] } }

        before do
          group2.add_reporter(user)
        end

        it 'returns expected error response' do
          response = set_crm_contacts

          expect(response).to be_error
          expect(response.message).to eq(""Issue customer relations contacts #{contact.id}: #{does_not_exist_or_no_permission}"")
        end
      end

      context 'replace' do
        let(:params) { { replace_ids: [contacts[1].id, contacts[2].id] } }
        let(:expected_contacts) { [contacts[1], contacts[2]] }

        it_behaves_like 'setting contacts'
        it_behaves_like 'adds system note', 1, 1

        context 'with empty list' do
          let(:params) { { replace_ids: [] } }
          let(:expected_contacts) { [] }

          it_behaves_like 'setting contacts'
          it_behaves_like 'adds system note', 0, 2
        end
      end

      context 'add' do
        let(:added_contact) { contacts[3] }
        let(:params) { { add_ids: [added_contact.id] } }
        let(:expected_contacts) { [issue_contact_1, issue_contact_2, added_contact] }

        it_behaves_like 'setting contacts'
        it_behaves_like 'adds system note', 1, 0
      end

      context 'add by email' do
        let(:added_contact) { contacts[3] }
        let(:expected_contacts) { [issue_contact_1, issue_contact_2, added_contact] }

        context 'with pure emails in params' do
          let(:params) { { add_emails: [contacts[3].email] } }

          it_behaves_like 'setting contacts'
          it_behaves_like 'adds system note', 1, 0
        end

        context 'with autocomplete prefix emails in params' do
          let(:params) { { add_emails: [""[\""contact:\""#{contacts[3].email}\""]""] } }

          it_behaves_like 'setting contacts'
          it_behaves_like 'adds system note', 1, 0
        end
      end

      context 'remove' do
        let(:params) { { remove_ids: [contacts[0].id] } }
        let(:expected_contacts) { [contacts[1]] }

        it_behaves_like 'setting contacts'
        it_behaves_like 'adds system note', 0, 1
      end

      context 'remove by email' do
        let(:expected_contacts) { [contacts[1]] }

        context 'with pure email in params' do
          let(:params) { { remove_emails: [contacts[0].email] } }

          it_behaves_like 'setting contacts'
          it_behaves_like 'adds system note', 0, 1
        end

        context 'with autocomplete prefix and suffix email in params' do
          let(:params) { { remove_emails: [""[contact:#{contacts[0].email}]""] } }

          it_behaves_like 'setting contacts'
          it_behaves_like 'adds system note', 0, 1
        end
      end

      context 'when attempting to add more than 6' do
        let(:id) { contacts[0].id }
        let(:params) { { add_ids: [id, id, id, id, id, id, id] } }

        it 'returns expected error message' do
          response = set_crm_contacts

          expect(response).to be_error
          expect(response.message).to eq('You can only add up to 6 contacts at one time')
        end
      end

      context 'when trying to remove non-existent contact' do
        let(:params) { { remove_ids: [non_existing_record_id] } }

        it 'returns expected error message' do
          response = set_crm_contacts

          expect(response).to be_success
          expect(response.message).to be_nil
        end
      end

      context 'when combining params' do
        let(:error_invalid_params) { 'You cannot combine replace_ids with add_ids or remove_ids' }
        let(:expected_contacts) { [contacts[0], contacts[3]] }

        context 'add and remove' do
          context 'with contact ids' do
            let(:params) { { remove_ids: [contacts[1].id], add_ids: [contacts[3].id] } }

            it_behaves_like 'setting contacts'
          end

          context 'with contact emails' do
            let(:params) { { remove_emails: [contacts[1].email], add_emails: [""[\""contact:#{contacts[3].email}]""] } }

            it_behaves_like 'setting contacts'
          end
        end

        context 'replace and remove' do
          let(:params) { { replace_ids: [contacts[3].id], remove_ids: [contacts[0].id] } }

          it 'returns expected error response' do
            response = set_crm_contacts

            expect(response).to be_error
            expect(response.message).to eq(error_invalid_params)
          end
        end

        context 'replace and add' do
          let(:params) { { replace_ids: [contacts[3].id], add_ids: [contacts[1].id] } }

          it 'returns expected error response' do
            response = set_crm_contacts

            expect(response).to be_error
            expect(response.message).to eq(error_invalid_params)
          end
        end
      end

      context 'when trying to add an existing issue contact' do
        let(:params) { { add_ids: [contacts[0].id] } }

        it 'does not return an error' do
          response = set_crm_contacts

          expect(response).to be_success
        end
      end

      context 'when trying to add the same contact twice' do
        let(:params) { { add_ids: [contacts[3].id, contacts[3].id] } }

        it 'does not return an error' do
          response = set_crm_contacts

          expect(response).to be_success
        end
      end

      context 'when trying to remove a contact not attached to the issue' do
        let(:params) { { remove_ids: [contacts[3].id] } }

        it 'does not return an error' do
          response = set_crm_contacts

          expect(response).to be_success
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Issues
  class RelativePositionRebalancingService
    UPDATE_BATCH_SIZE = 100
    PREFETCH_ISSUES_BATCH_SIZE = 10_000
    SMALLEST_BATCH_SIZE = 5
    RETRIES_LIMIT = 3

    TooManyConcurrentRebalances = Class.new(StandardError)

    def initialize(projects)
      @projects_collection = (projects.is_a?(Array) ? Project.id_in(projects) : projects).select(:id).projects_order_id_asc
      @root_namespace = @projects_collection.select(:namespace_id).reorder(nil).take.root_namespace # rubocop:disable CodeReuse/ActiveRecord
      @caching = ::Gitlab::Issues::Rebalancing::State.new(@root_namespace, @projects_collection)
    end

    def execute
      # Given can_start_rebalance? and track_new_running_rebalance are not atomic
      # it can happen that we end up with more than Rebalancing::State::MAX_NUMBER_OF_CONCURRENT_REBALANCES running.
      # Considering the number of allowed Rebalancing::State::MAX_NUMBER_OF_CONCURRENT_REBALANCES is small we should be ok,
      # but should be something to consider if we'd want to scale this up.
      error_message = ""#{caching.concurrent_running_rebalances_count} concurrent re-balances currently running""
      raise TooManyConcurrentRebalances, error_message unless caching.can_start_rebalance?

      block_issue_repositioning! unless root_namespace.issue_repositioning_disabled?
      caching.track_new_running_rebalance
      index = caching.get_current_index

      loop do
        issue_ids = get_issue_ids(index, PREFETCH_ISSUES_BATCH_SIZE)
        pairs_with_index = assign_indexes(issue_ids, index)

        pairs_with_index.each_slice(UPDATE_BATCH_SIZE) do |pairs_batch|
          update_positions_with_retry(pairs_batch, 're-balance issue positions in batches ordered by position')
        end

        index = caching.get_current_index

        break if index >= caching.issue_count - 1
      end

      caching.cleanup_cache
      unblock_issue_repositioning!
    end

    private

    attr_reader :root_namespace, :projects_collection, :caching

    def block_issue_repositioning!
      Feature.enable(:block_issue_repositioning, root_namespace)
    end

    def unblock_issue_repositioning!
      Feature.disable(:block_issue_repositioning, root_namespace)
    end

    def get_issue_ids(index, limit)
      issue_ids = caching.get_cached_issue_ids(index, limit)

      # if we have a list of cached issues and no current project id cached,
      # then we successfully cached issues for all projects
      return issue_ids if issue_ids.any? && caching.get_current_project_id.blank?

      # if we got no issue ids at the start of re-balancing then we did not cache any issue ids yet
      preload_issue_ids

      caching.get_cached_issue_ids(index, limit)
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def preload_issue_ids
      index = 0
      cached_project_id = caching.get_current_project_id

      collection = projects_collection
      collection = projects_collection.where(Project.arel_table[:id].gteq(cached_project_id.to_i)) if cached_project_id.present?

      collection.each do |project|
        caching.cache_current_project_id(project.id)
        index += 1
        scope = Issue.in_projects(project).order_by_relative_position.with_non_null_relative_position.select(:id, :relative_position)

        with_retry(PREFETCH_ISSUES_BATCH_SIZE, 100) do |batch_size|
          Gitlab::Pagination::Keyset::Iterator.new(scope: scope).each_batch(of: batch_size) do |batch|
            caching.cache_issue_ids(batch)
          end
        end
      end

      caching.remove_current_project_id_cache
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def assign_indexes(ids, start_index)
      ids.each_with_index.map do |id, idx|
        [id, start_index + idx]
      end
    end

    # The method runs in a loop where we try for RETRIES_LIMIT=3 times, to run the update statement on
    # a number of records(batch size). Method gets an array of (id, value) pairs as argument that is used
    # to build the update query matching by id and updating relative_position = value. If we get a statement
    # timeout, we split the batch size in half and try(for 3 times again) to batch update on a smaller number of records.
    # On success, because we know the batch size and we always pick from the beginning of the array param,
    # we can remove first batch_size number of items from array and continue with the successful batch_size for next batches.
    # On failures we continue to split batch size to a SMALLEST_BATCH_SIZE limit, which is now set at 5.
    #
    # e.g.
    # 0. items | previous batch size|new batch size | comment
    # 1. 100   | 100                | 100           | 3 failures -> split the batch size in half
    # 2. 100   | 100                | 50            | 3 failures -> split the batch size in half again
    # 3. 100   | 50                 | 25            | 3 succeed -> so we drop 25 items 3 times, 4th fails -> split the batch size in half again
    # 5. 25    | 25                 | 12            | 3 failures -> split the batch size in half
    # 6. 25    | 12                 | 6             | 3 failures -> we exit because smallest batch size is 5 and we'll be at 3 if we split again

    def update_positions_with_retry(pairs_with_index, query_name)
      retry_batch_size = pairs_with_index.size

      until pairs_with_index.empty?
        with_retry(retry_batch_size, SMALLEST_BATCH_SIZE) do |batch_size|
          retry_batch_size = batch_size
          update_positions(pairs_with_index.first(batch_size), query_name)
          # pairs_with_index[batch_size - 1] - can be nil for last batch
          # if last batch is smaller than batch_size, so we just get the last pair.
          last_pair_in_batch = pairs_with_index[batch_size - 1] || pairs_with_index.last
          caching.cache_current_index(last_pair_in_batch.last + 1)
          pairs_with_index = pairs_with_index.drop(batch_size)
        end
      end
    end

    def update_positions(pairs_with_position, query_name)
      values = pairs_with_position.map do |id, index|
        ""(#{id}, #{start_position + (index * gap_size)})""
      end.join(', ')

      run_update_query(values, query_name)
    end

    def run_update_query(values, query_name)
      Issue.connection.exec_query(<<~SQL, query_name)
        WITH cte(cte_id, new_pos) AS MATERIALIZED (
         SELECT *
         FROM (VALUES #{values}) as t (id, pos)
        )
        UPDATE #{Issue.table_name}
        SET relative_position = cte.new_pos
        FROM cte
        WHERE cte_id = id
      SQL
    end

    def gaps
      caching.issue_count - 1
    end

    def gap_size
      RelativePositioning::MAX_GAP
    end

    def start_position
      @start_position ||= (RelativePositioning::START_POSITION - (gaps / 2) * gap_size).to_i
    end

    def with_retry(initial_batch_size, exit_batch_size)
      retries = 0
      batch_size = initial_batch_size

      begin
        yield batch_size
        retries = 0
      rescue ActiveRecord::StatementTimeout, ActiveRecord::QueryCanceled => ex
        raise ex if batch_size < exit_batch_size

        if (retries += 1) == RETRIES_LIMIT
          # shrink the batch size in half when RETRIES limit is reached and update still fails perhaps because batch size is still too big
          batch_size = (batch_size / 2).to_i
          retries = 0
        end

        retry
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issues::RelativePositionRebalancingService, :clean_gitlab_redis_shared_state, feature_category: :team_planning do
  let_it_be(:project, reload: true) { create(:project, :repository_disabled, skip_disk_validation: true) }
  let_it_be(:user) { project.creator }
  let_it_be(:start) { RelativePositioning::START_POSITION }
  let_it_be(:max_pos) { RelativePositioning::MAX_POSITION }
  let_it_be(:min_pos) { RelativePositioning::MIN_POSITION }
  let_it_be(:clump_size) { 300 }

  let_it_be(:unclumped, reload: true) do
    (1..clump_size).to_a.map do |i|
      create(:issue, project: project, author: user, relative_position: start + (1024 * i))
    end
  end

  let_it_be(:end_clump, reload: true) do
    (1..clump_size).to_a.map do |i|
      create(:issue, project: project, author: user, relative_position: max_pos - i)
    end
  end

  let_it_be(:start_clump, reload: true) do
    (1..clump_size).to_a.map do |i|
      create(:issue, project: project, author: user, relative_position: min_pos + i)
    end
  end

  let_it_be(:nil_clump, reload: true) do
    (1..100).to_a.map do |i|
      create(:issue, project: project, author: user, relative_position: nil)
    end
  end

  def issues_in_position_order
    project.reload.issues.order_by_relative_position.to_a
  end

  subject(:service) { described_class.new(Project.id_in(project)) }

  context 'execute' do
    it 're-balances a set of issues with clumps at the end and start' do
      all_issues = start_clump + unclumped + end_clump.reverse

      expect { service.execute }.not_to change { issues_in_position_order.map(&:id) }

      caching = service.send(:caching)
      all_issues.each(&:reset)

      gaps = all_issues.take(all_issues.count - 1).zip(all_issues.drop(1)).map do |a, b|
        b.relative_position - a.relative_position
      end

      expect(caching.issue_count).to eq(900)
      expect(gaps).to all(be > RelativePositioning::MIN_GAP)
      expect(all_issues.first.relative_position).to be > (RelativePositioning::MIN_POSITION * 0.9999)
      expect(all_issues.last.relative_position).to be < (RelativePositioning::MAX_POSITION * 0.9999)
      expect(project.root_namespace.issue_repositioning_disabled?).to be false
      expect(project.issues.with_null_relative_position.count).to eq(100)
    end

    it 'is idempotent' do
      expect do
        service.execute
        service.execute
      end.not_to change { issues_in_position_order.map(&:id) }
    end

    it 'acts if the flag is enabled for the root namespace' do
      issue = create(:issue, project: project, author: user, relative_position: max_pos)

      expect { service.execute }.to change { issue.reload.relative_position }
    end

    it 'acts if the flag is enabled for the group' do
      issue = create(:issue, project: project, author: user, relative_position: max_pos)
      project.update!(group: create(:group))

      expect { service.execute }.to change { issue.reload.relative_position }
    end

    it 'aborts if there are too many rebalances running' do
      caching = service.send(:caching)
      allow(caching).to receive(:rebalance_in_progress?).and_return(false)
      allow(caching).to receive(:concurrent_running_rebalances_count).and_return(10)
      allow(service).to receive(:caching).and_return(caching)

      expect { service.execute }.to raise_error(Issues::RelativePositionRebalancingService::TooManyConcurrentRebalances)
      expect(project.root_namespace.issue_repositioning_disabled?).to be false
    end

    it 'resumes a started rebalance even if there are already too many rebalances running' do
      Gitlab::Redis::SharedState.with do |redis|
        redis.sadd(""gitlab:issues-position-rebalances:running_rebalances"",
          [
            ""#{::Gitlab::Issues::Rebalancing::State::PROJECT}/#{project.id}"",
            ""1/100""
          ]
        )
      end

      caching = service.send(:caching)
      allow(caching).to receive(:concurrent_running_rebalances_count).and_return(10)
      allow(service).to receive(:caching).and_return(caching)

      expect { service.execute }.not_to raise_error
    end

    context 're-balancing is retried on statement timeout exceptions' do
      subject { service }

      it 'retries update statement' do
        call_count = 0
        allow(subject).to receive(:run_update_query) do
          call_count += 1
          if call_count < 13
            raise(ActiveRecord::QueryCanceled)
          else
            call_count = 0 if call_count == 13 + 16 # 16 = 17 sub-batches - 1 call that succeeded as part of 5th batch
            true
          end
        end

        # call math:
        # batches start at 100 and are split in half after every 3 retries if ActiveRecord::StatementTimeout exception is raised.
        # We raise ActiveRecord::StatementTimeout exception for 13 calls:
        # 1. 100 => 3 calls
        # 2. 100/2=50 => 3 calls + 3 above = 6 calls, raise ActiveRecord::StatementTimeout
        # 3. 50/2=25 => 3 calls + 6 above = 9 calls, raise ActiveRecord::StatementTimeout
        # 4. 25/2=12 => 3 calls + 9 above = 12 calls, raise ActiveRecord::StatementTimeout
        # 5. 12/2=6 => 1 call + 12 above = 13 calls, run successfully
        #
        # so out of 100 elements we created batches of 6 items => 100/6 = 17 sub-batches of 6 or less elements
        #
        # project.issues.count: 900 issues, so 9 batches of 100 => 9 * (13+16) = 261
        expect(subject).to receive(:update_positions).exactly(261).times.and_call_original

        subject.execute
      end
    end

    context 'when resuming a stopped rebalance' do
      before do
        service.send(:preload_issue_ids)
        expect(service.send(:caching).get_cached_issue_ids(0, 300)).not_to be_empty
        # simulate we already rebalanced half the issues
        index = clump_size * 3 / 2 + 1
        service.send(:caching).cache_current_index(index)
      end

      it 'rebalances the other half of issues' do
        expect(subject).to receive(:update_positions_with_retry).exactly(5).and_call_original

        subject.execute
      end
    end

    shared_examples 'no-op on the retried job' do
      it 'does not update positions in the 2nd .execute' do
        original_order = issues_in_position_order.map(&:id)

        # preloads issue ids on both runs
        expect(service).to receive(:preload_issue_ids).twice.and_call_original

        # 1st run performs rebalancing
        expect(service).to receive(:update_positions_with_retry).exactly(9).times.and_call_original
        expect { service.execute }.to raise_error(StandardError)

        # 2nd run is a no-op
        expect(service).not_to receive(:update_positions_with_retry)
        expect { service.execute }.to raise_error(StandardError)

        # order is preserved
        expect(original_order).to match_array(issues_in_position_order.map(&:id))
      end
    end

    context 'when error is raised in cache cleanup step' do
      let_it_be(:root_namespace_id) { project.root_namespace.id }

      context 'when srem fails' do
        before do
          Gitlab::Redis::SharedState.with do |redis|
            allow(redis).to receive(:srem?).and_raise(StandardError)
          end
        end

        it_behaves_like 'no-op on the retried job'
      end

      context 'when delete issues ids sorted set fails' do
        before do
          Gitlab::Redis::SharedState.with do |redis|
            allow(redis).to receive(:del).and_call_original
            allow(redis).to receive(:del)
              .with(""#{Gitlab::Issues::Rebalancing::State::REDIS_KEY_PREFIX}:#{root_namespace_id}"")
              .and_raise(StandardError)
          end
        end

        it_behaves_like 'no-op on the retried job'
      end

      context 'when delete current_index_key fails' do
        before do
          Gitlab::Redis::SharedState.with do |redis|
            allow(redis).to receive(:del).and_call_original
            allow(redis).to receive(:del)
              .with(""#{Gitlab::Issues::Rebalancing::State::REDIS_KEY_PREFIX}:#{root_namespace_id}:current_index"")
              .and_raise(StandardError)
          end
        end

        it_behaves_like 'no-op on the retried job'
      end

      context 'when setting recently finished key fails' do
        before do
          Gitlab::Redis::SharedState.with do |redis|
            allow(redis).to receive(:set).and_call_original
            allow(redis).to receive(:set)
              .with(
                ""#{Gitlab::Issues::Rebalancing::State::RECENTLY_FINISHED_REBALANCE_PREFIX}:2:#{project.id}"",
                anything,
                anything
              )
              .and_raise(StandardError)
          end
        end

        it 'reruns the next job in full' do
          original_order = issues_in_position_order.map(&:id)

          # preloads issue ids on both runs
          expect(service).to receive(:preload_issue_ids).twice.and_call_original

          # 1st run performs rebalancing
          expect(service).to receive(:update_positions_with_retry).exactly(9).times.and_call_original
          expect { service.execute }.to raise_error(StandardError)

          # 2nd run performs rebalancing in full
          expect(service).to receive(:update_positions_with_retry).exactly(9).times.and_call_original
          expect { service.execute }.to raise_error(StandardError)

          # order is preserved
          expect(original_order).to match_array(issues_in_position_order.map(&:id))
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Issues
  class BaseService < ::IssuableBaseService
    extend ::Gitlab::Utils::Override
    include IncidentManagement::UsageData
    include IssueTypeHelpers

    def hook_data(issue, action, old_associations: {})
      hook_data = issue.to_hook_data(current_user, old_associations: old_associations)
      hook_data[:object_attributes][:action] = action

      hook_data
    end

    def reopen_service
      Issues::ReopenService
    end

    def close_service
      Issues::CloseService
    end

    NO_REBALANCING_NEEDED = ((RelativePositioning::MIN_POSITION * 0.9999)..(RelativePositioning::MAX_POSITION * 0.9999))

    def rebalance_if_needed(issue)
      return unless issue
      return if issue.relative_position.nil?
      return if NO_REBALANCING_NEEDED.cover?(issue.relative_position)

      Issues::RebalancingWorker.perform_async(nil, *issue.project.self_or_root_group_ids)
    end

    private

    # overriding this because IssuableBaseService#constructor_container_arg returns { project: value }
    # Issues::ReopenService constructor signature is different now, it takes container instead of project also
    # IssuableBaseService#change_state dynamically picks one of the `Issues::ReopenService`, `Epics::ReopenService` or
    # MergeRequests::ReopenService, so we need this method to return { }container: value } for Issues::ReopenService
    def self.constructor_container_arg(value)
      { container: value }
    end

    def find_work_item_type_id(issue_type)
      work_item_type = WorkItems::Type.default_by_type(issue_type)
      work_item_type ||= WorkItems::Type.default_issue_type

      work_item_type.id
    end

    def filter_params(issue)
      super

      params.delete(:issue_type) unless create_issue_type_allowed?(issue, params[:issue_type])

      if params[:work_item_type].present? && !create_issue_type_allowed?(project, params[:work_item_type].base_type)
        params.delete(:work_item_type)
      end

      moved_issue = params.delete(:moved_issue)

      # Setting created_at, updated_at and iid is allowed only for admins and owners or
      # when moving an issue as we preserve the original issue attributes except id and iid.
      params.delete(:iid) unless current_user.can?(:set_issue_iid, project)
      params.delete(:created_at) unless moved_issue || current_user.can?(:set_issue_created_at, project)
      params.delete(:updated_at) unless moved_issue || current_user.can?(:set_issue_updated_at, project)

      # Only users with permission to handle error data can add it to issues
      params.delete(:sentry_issue_attributes) unless current_user.can?(:update_sentry_issue, project)

      issue.system_note_timestamp = params[:created_at] || params[:updated_at]
    end

    override :handle_move_between_ids
    def handle_move_between_ids(issue)
      issue.check_repositioning_allowed! if params[:move_between_ids]

      super

      rebalance_if_needed(issue)
    end

    def handle_escalation_status_change(issue)
      return unless issue.supports_escalation?

      if issue.escalation_status
        ::IncidentManagement::IssuableEscalationStatuses::AfterUpdateService.new(
          issue,
          current_user
        ).execute
      else
        ::IncidentManagement::IssuableEscalationStatuses::CreateService.new(issue).execute
      end
    end

    def issuable_for_positioning(id, positioning_scope)
      return unless id

      positioning_scope.find(id)
    end

    def create_assignee_note(issue, old_assignees)
      SystemNoteService.change_issuable_assignees(
        issue, issue.project, current_user, old_assignees)
    end

    def execute_hooks(issue, action = 'open', old_associations: {})
      issue_data  = Gitlab::Lazy.new { hook_data(issue, action, old_associations: old_associations) }
      hooks_scope = issue.confidential? ? :confidential_issue_hooks : :issue_hooks
      issue.namespace.execute_hooks(issue_data, hooks_scope)
      issue.namespace.execute_integrations(issue_data, hooks_scope)

      execute_incident_hooks(issue, issue_data) if issue.work_item_type&.incident?
      execute_group_mention_hooks(issue, issue_data) if action == 'open'
    end

    # We can remove this code after proposal in
    # https://gitlab.com/gitlab-org/gitlab/-/issues/367550#proposal is updated.
    def execute_incident_hooks(issue, issue_data)
      issue_data[:object_kind] = 'incident'
      issue_data[:event_type] = 'incident'
      issue.namespace.execute_integrations(issue_data, :incident_hooks)
    end

    def execute_group_mention_hooks(issue, issue_data)
      return unless issue.instance_of?(Issue)

      args = {
        mentionable_type: 'Issue',
        mentionable_id: issue.id,
        hook_data: issue_data,
        is_confidential: issue.confidential?
      }

      issue.run_after_commit_or_now do
        Integrations::GroupMentionWorker.perform_async(args)
      end
    end

    def update_project_counter_caches?(issue)
      super || issue.confidential_changed?
    end

    def log_audit_event(issue, user, event_type, message)
      # defined in EE
    end
  end
end

Issues::BaseService.prepend_mod_with('Issues::BaseService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issues::BaseService, feature_category: :team_planning do
  describe '#constructor_container_arg' do
    it { expect(described_class.constructor_container_arg(""some-value"")).to eq({ container: ""some-value"" }) }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Issues
  class MoveService < Issuable::Clone::BaseService
    extend ::Gitlab::Utils::Override

    MoveError = Class.new(StandardError)

    def execute(issue, target_project)
      @target_project = target_project

      verify_can_move_issue!(issue, target_project)

      super

      notify_participants

      # Updates old issue sent notifications allowing
      # to receive service desk emails on the new moved issue.
      update_service_desk_sent_notifications

      copy_email_participants
      queue_copy_designs

      new_entity
    end

    private

    attr_reader :target_project

    def verify_can_move_issue!(issue, target_project)
      unless issue.supports_move_and_clone?
        raise MoveError, s_('MoveIssue|Cannot move issues of \'%{issue_type}\' type.') % { issue_type: issue.issue_type }
      end

      unless issue.can_move?(current_user, @target_project)
        raise MoveError, s_('MoveIssue|Cannot move issue due to insufficient permissions!')
      end

      if @project == @target_project
        raise MoveError, s_('MoveIssue|Cannot move issue to project it originates from!')
      end
    end

    def update_service_desk_sent_notifications
      return unless original_entity.from_service_desk?

      original_entity
        .sent_notifications.update_all(project_id: new_entity.project_id, noteable_id: new_entity.id)
    end

    def copy_email_participants
      new_attributes = { id: nil, issue_id: new_entity.id }

      new_participants = original_entity.issue_email_participants.dup

      new_participants.each do |participant|
        participant.assign_attributes(new_attributes)
      end

      IssueEmailParticipant.bulk_insert!(new_participants)
    end

    override :update_old_entity
    def update_old_entity
      super

      rewrite_related_issues
      mark_as_moved
    end

    override :update_new_entity
    def update_new_entity
      super

      copy_contacts
    end

    def create_new_entity
      new_params = {
        id: nil,
        iid: nil,
        relative_position: relative_position,
        project: target_project,
        author: original_entity.author,
        assignee_ids: original_entity.assignee_ids,
        moved_issue: true
      }

      new_params = original_entity.serializable_hash.symbolize_keys.merge(new_params)
      new_params = new_params.merge(rewritten_old_entity_attributes)
      # spam checking is not necessary, as no new content is being created.

      # Skip creation of system notes for existing attributes of the issue. The system notes of the old
      # issue are copied over so we don't want to end up with duplicate notes.
      create_result = CreateService.new(
        container: @target_project,
        current_user: @current_user,
        params: new_params,
        perform_spam_check: false
      ).execute(skip_system_notes: true)

      raise MoveError, create_result.errors.join(', ') if create_result.error? && create_result[:issue].blank?

      create_result[:issue]
    end

    def queue_copy_designs
      return unless original_entity.designs.present?

      response = DesignManagement::CopyDesignCollection::QueueService.new(
        current_user,
        original_entity,
        new_entity
      ).execute

      log_error(response.message) if response.error?
    end

    def mark_as_moved
      original_entity.update(moved_to: new_entity)
    end

    def rewrite_related_issues
      source_issue_links = IssueLink.for_source(original_entity)
      source_issue_links.update_all(source_id: new_entity.id)

      target_issue_links = IssueLink.for_target(original_entity)
      target_issue_links.update_all(target_id: new_entity.id)
    end

    def copy_contacts
      return unless original_entity.project.root_ancestor == new_entity.project.root_ancestor

      new_entity.customer_relations_contacts = original_entity.customer_relations_contacts
    end

    def notify_participants
      notification_service.async.issue_moved(original_entity, new_entity, @current_user)
    end

    def add_note_from
      SystemNoteService.noteable_moved(
        new_entity,
        target_project,
        original_entity,
        current_user,
        direction: :from
      )
    end

    def add_note_to
      SystemNoteService.noteable_moved(
        original_entity,
        old_project,
        new_entity,
        current_user,
        direction: :to
      )
    end
  end
end

Issues::MoveService.prepend_mod_with('Issues::MoveService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issues::MoveService, feature_category: :team_planning do
  include DesignManagementTestHelpers

  let_it_be(:user) { create(:user) }
  let_it_be(:author) { create(:user) }
  let_it_be(:title) { 'Some issue' }
  let_it_be(:description) { ""Some issue description with mention to #{user.to_reference}"" }
  let_it_be(:group) { create(:group, :private) }
  let_it_be(:sub_group_1) { create(:group, :private, parent: group) }
  let_it_be(:sub_group_2) { create(:group, :private, parent: group) }
  let_it_be(:old_project) { create(:project, namespace: sub_group_1) }
  let_it_be(:new_project) { create(:project, namespace: sub_group_2) }

  let(:old_issue) do
    create(:issue, title: title, description: description, project: old_project, author: author, created_at: 1.day.ago, updated_at: 1.day.ago)
  end

  subject(:move_service) do
    described_class.new(container: old_project, current_user: user)
  end

  shared_context 'user can move issue' do
    before do
      old_project.add_reporter(user)
      new_project.add_reporter(user)
    end
  end

  describe '#execute' do
    shared_context 'issue move executed' do
      let!(:new_issue) { move_service.execute(old_issue, new_project) }
    end

    context 'when issue creation fails' do
      include_context 'user can move issue'

      before do
        allow_next_instance_of(Issues::CreateService) do |create_service|
          allow(create_service).to receive(:execute).and_return(ServiceResponse.error(message: 'some error'))
        end
      end

      it 'raises a move error' do
        expect { move_service.execute(old_issue, new_project) }.to raise_error(
          Issues::MoveService::MoveError,
          'some error'
        )
      end
    end

    context 'issue movable' do
      include_context 'user can move issue'

      it 'creates resource state event' do
        expect { move_service.execute(old_issue, new_project) }.to change(ResourceStateEvent.where(issue_id: old_issue), :count).by(1)
      end

      context 'generic issue' do
        include_context 'issue move executed'

        it 'creates a new issue in a new project' do
          expect(new_issue.project).to eq new_project
          expect(new_issue.namespace_id).to eq new_project.project_namespace_id
        end

        it 'copies issue title' do
          expect(new_issue.title).to eq title
        end

        it 'copies issue description' do
          expect(new_issue.description).to eq description
        end

        it 'adds system note to old issue at the end' do
          expect(old_issue.notes.last.note).to start_with 'moved to'
        end

        it 'adds system note to new issue at the end', :freeze_time do
          system_note = new_issue.notes.last

          expect(system_note.note).to start_with 'moved from'
          expect(system_note.created_at).to be_like_time(Time.current)
        end

        it 'closes old issue' do
          expect(old_issue.closed?).to be true
        end

        it 'persists new issue' do
          expect(new_issue.persisted?).to be true
        end

        it 'persists all changes' do
          expect(old_issue.changed?).to be false
          expect(new_issue.changed?).to be false
        end

        it 'preserves author' do
          expect(new_issue.author).to eq author
        end

        it 'creates a new internal id for issue' do
          expect(new_issue.iid).to be 1
        end

        it 'marks issue as moved' do
          expect(old_issue.moved?).to eq true
          expect(old_issue.moved_to).to eq new_issue
        end

        it 'marks issue as closed' do
          expect(old_issue.closed?).to eq true
        end

        it 'preserves create time' do
          expect(old_issue.created_at).to eq new_issue.created_at
        end
      end

      context 'issue with award emoji' do
        let!(:award_emoji) { create(:award_emoji, awardable: old_issue) }

        it 'copies the award emoji' do
          old_issue.reload
          new_issue = move_service.execute(old_issue, new_project)

          expect(old_issue.award_emoji.first.name).to eq new_issue.reload.award_emoji.first.name
        end
      end

      context 'issue with milestone' do
        let(:milestone) { create(:milestone, group: sub_group_1) }
        let(:new_project) { create(:project, namespace: sub_group_1) }

        let(:old_issue) do
          create(:issue, title: title, description: description, project: old_project, author: author, milestone: milestone)
        end

        before do
          create(:resource_milestone_event, issue: old_issue, milestone: milestone, action: :add)
        end

        it 'does not create extra milestone events' do
          new_issue = move_service.execute(old_issue, new_project)

          expect(new_issue.resource_milestone_events.count).to eq(old_issue.resource_milestone_events.count)
        end
      end

      context 'issue with due date' do
        let(:old_issue) do
          create(:issue, title: title, description: description, project: old_project, author: author, due_date: '2020-01-10')
        end

        before do
          old_issue.update!(due_date: Date.today)
          SystemNoteService.change_start_date_or_due_date(old_issue, old_project, author, old_issue.previous_changes.slice('due_date'))
        end

        it 'does not create extra system notes' do
          new_issue = move_service.execute(old_issue, new_project)

          expect(new_issue.notes.count).to eq(old_issue.notes.count)
        end
      end

      context 'issue with assignee' do
        let_it_be(:assignee) { create(:user) }

        before do
          old_issue.assignees = [assignee]
        end

        it 'preserves assignee with access to the new issue' do
          new_project.add_reporter(assignee)

          new_issue = move_service.execute(old_issue, new_project)

          expect(new_issue.assignees).to eq([assignee])
        end

        it 'ignores assignee without access to the new issue' do
          new_issue = move_service.execute(old_issue, new_project)

          expect(new_issue.assignees).to be_empty
        end
      end

      context 'issue with contacts' do
        let_it_be(:contacts) { create_list(:contact, 2, group: group) }

        before do
          old_issue.customer_relations_contacts = contacts
        end

        it 'preserves contacts' do
          new_issue = move_service.execute(old_issue, new_project)

          expect(new_issue.customer_relations_contacts).to eq(contacts)
        end

        context 'when moving to another root group' do
          let(:another_project) { create(:project, namespace: create(:group)) }

          before do
            another_project.add_reporter(user)
          end

          it 'does not preserve contacts' do
            new_issue = move_service.execute(old_issue, another_project)

            expect(new_issue.customer_relations_contacts).to be_empty
          end
        end
      end

      context 'moving to same project' do
        let(:new_project) { old_project }

        it 'raises error' do
          expect { move_service.execute(old_issue, new_project) }
            .to raise_error(StandardError, /Cannot move issue/)
        end
      end

      context 'project issue hooks' do
        let_it_be(:old_project_hook) { create(:project_hook, project: old_project, issues_events: true) }
        let_it_be(:new_project_hook) { create(:project_hook, project: new_project, issues_events: true) }

        let(:expected_new_project_hook_payload) do
          hash_including(
            event_type: 'issue',
            object_kind: 'issue',
            object_attributes: include(
              project_id: new_project.id,
              state: 'opened',
              action: 'open'
            )
          )
        end

        let(:expected_old_project_hook_payload) do
          hash_including(
            event_type: 'issue',
            object_kind: 'issue',
            changes: {
              state_id: { current: 2, previous: 1 },
              closed_at: { current: kind_of(Time), previous: nil },
              updated_at: { current: kind_of(Time), previous: kind_of(Time) }
            },
            object_attributes: include(
              id: old_issue.id,
              closed_at: kind_of(Time),
              state: 'closed',
              action: 'close'
            )
          )
        end

        it 'executes project issue hooks for both projects' do
          expect_next_instance_of(WebHookService, new_project_hook, expected_new_project_hook_payload, 'issue_hooks') do |service|
            expect(service).to receive(:async_execute).once
          end
          expect_next_instance_of(WebHookService, old_project_hook, expected_old_project_hook_payload, 'issue_hooks') do |service|
            expect(service).to receive(:async_execute).once
          end

          move_service.execute(old_issue, new_project)
        end
      end

      # These tests verify that notes are copied. More thorough tests are in
      # the unit test for Notes::CopyService.
      context 'issue with notes' do
        let!(:notes) do
          [
            create(:note, noteable: old_issue, project: old_project, created_at: 2.weeks.ago, updated_at: 1.week.ago),
            create(:note, noteable: old_issue, project: old_project)
          ]
        end

        let(:copied_notes) { new_issue.notes.limit(notes.size) } # Remove the system note added by the copy itself

        include_context 'issue move executed'

        it 'copies existing notes in order' do
          expect(copied_notes.order('id ASC').pluck(:note)).to eq(notes.map(&:note))
        end
      end

      context 'issue with a design', :clean_gitlab_redis_shared_state do
        let_it_be(:new_project) { create(:project) }

        let!(:design) { create(:design, :with_lfs_file, issue: old_issue) }
        let!(:note) { create(:diff_note_on_design, noteable: design, issue: old_issue, project: old_issue.project) }
        let(:subject) { move_service.execute(old_issue, new_project) }

        before do
          enable_design_management
        end

        it 'calls CopyDesignCollection::QueueService' do
          expect(DesignManagement::CopyDesignCollection::QueueService).to receive(:new)
            .with(user, old_issue, kind_of(Issue))
            .and_call_original

          subject
        end

        it 'logs if QueueService returns an error', :aggregate_failures do
          error_message = 'error'

          expect_next_instance_of(DesignManagement::CopyDesignCollection::QueueService) do |service|
            expect(service).to receive(:execute).and_return(
              ServiceResponse.error(message: error_message)
            )
          end
          expect(Gitlab::AppLogger).to receive(:error).with(error_message)

          subject
        end

        # Perform a small integration test to ensure the services and worker
        # can correctly create designs.
        it 'copies the design and its notes', :sidekiq_inline, :aggregate_failures do
          new_issue = subject

          expect(new_issue.designs.size).to eq(1)
          expect(new_issue.designs.first.notes.size).to eq(1)
        end
      end

      context 'issue relative position' do
        let(:subject) { move_service.execute(old_issue, new_project) }

        it_behaves_like 'copy or reset relative position'
      end

      context 'issue with escalation status' do
        it 'keeps the escalation status' do
          escalation_status = create(:incident_management_issuable_escalation_status, issue: old_issue)

          move_service.execute(old_issue, new_project)

          expect(escalation_status.reload.issue).to eq(old_issue)
        end
      end
    end

    describe 'move permissions' do
      let(:move) { move_service.execute(old_issue, new_project) }

      context 'user is reporter in both projects' do
        include_context 'user can move issue'
        it { expect { move }.not_to raise_error }
      end

      context 'user is reporter only in new project' do
        before do
          new_project.add_reporter(user)
        end

        it { expect { move }.to raise_error(StandardError, /permissions/) }
      end

      context 'user is reporter only in old project' do
        before do
          old_project.add_reporter(user)
        end

        it { expect { move }.to raise_error(StandardError, /permissions/) }
      end

      context 'user is reporter in one project and guest in another' do
        before do
          new_project.add_guest(user)
          old_project.add_reporter(user)
        end

        it { expect { move }.to raise_error(StandardError, /permissions/) }
      end

      context 'issue has already been moved' do
        include_context 'user can move issue'

        let(:moved_to_issue) { create(:issue) }

        let(:old_issue) do
          create(:issue, project: old_project, author: author, moved_to: moved_to_issue)
        end

        it { expect { move }.to raise_error(StandardError, /permissions/) }
      end

      context 'issue is not persisted' do
        include_context 'user can move issue'
        let(:old_issue) { build(:issue, project: old_project, author: author) }

        it { expect { move }.to raise_error(StandardError, /permissions/) }
      end
    end
  end

  describe '#rewrite_related_issues' do
    include_context 'user can move issue'

    let(:admin) { create(:admin) }
    let(:authorized_project) { create(:project) }
    let(:authorized_project2) { create(:project) }
    let(:unauthorized_project) { create(:project) }

    let(:authorized_issue_b) { create(:issue, project: authorized_project) }
    let(:authorized_issue_c) { create(:issue, project: authorized_project2) }
    let(:authorized_issue_d) { create(:issue, project: authorized_project2) }
    let(:unauthorized_issue) { create(:issue, project: unauthorized_project) }

    let!(:issue_link_a) { create(:issue_link, source: old_issue, target: authorized_issue_b) }
    let!(:issue_link_b) { create(:issue_link, source: old_issue, target: unauthorized_issue) }
    let!(:issue_link_c) { create(:issue_link, source: old_issue, target: authorized_issue_c) }
    let!(:issue_link_d) { create(:issue_link, source: authorized_issue_d, target: old_issue) }

    before do
      authorized_project.add_developer(user)
      authorized_project.add_developer(admin)
      authorized_project2.add_developer(user)
      authorized_project2.add_developer(admin)
    end

    context 'multiple related issues' do
      context 'when admin mode is enabled', :enable_admin_mode do
        it 'moves all related issues and retains permissions' do
          new_issue = move_service.execute(old_issue, new_project)

          expect(new_issue.related_issues(admin))
            .to match_array([authorized_issue_b, authorized_issue_c, authorized_issue_d, unauthorized_issue])

          expect(new_issue.related_issues(user))
            .to match_array([authorized_issue_b, authorized_issue_c, authorized_issue_d])

          expect(authorized_issue_d.related_issues(user))
            .to match_array([new_issue])
        end
      end

      context 'when admin mode is disabled' do
        it 'moves all related issues and retains permissions' do
          new_issue = move_service.execute(old_issue, new_project)

          expect(new_issue.related_issues(admin))
              .to match_array([authorized_issue_b, authorized_issue_c, authorized_issue_d])

          expect(new_issue.related_issues(user))
              .to match_array([authorized_issue_b, authorized_issue_c, authorized_issue_d])

          expect(authorized_issue_d.related_issues(user))
              .to match_array([new_issue])
        end
      end
    end
  end

  context 'updating sent notifications' do
    let!(:old_issue_notification_1) { create(:sent_notification, project: old_issue.project, noteable: old_issue) }
    let!(:old_issue_notification_2) { create(:sent_notification, project: old_issue.project, noteable: old_issue) }
    let!(:other_issue_notification) { create(:sent_notification, project: old_issue.project) }

    include_context 'user can move issue'

    context 'when issue is from service desk' do
      before do
        allow(old_issue).to receive(:from_service_desk?).and_return(true)
      end

      it 'updates moved issue sent notifications' do
        new_issue = move_service.execute(old_issue, new_project)

        old_issue_notification_1.reload
        old_issue_notification_2.reload
        expect(old_issue_notification_1.project_id).to eq(new_issue.project_id)
        expect(old_issue_notification_1.noteable_id).to eq(new_issue.id)
        expect(old_issue_notification_2.project_id).to eq(new_issue.project_id)
        expect(old_issue_notification_2.noteable_id).to eq(new_issue.id)
      end

      it 'does not update other issues sent notifications' do
        expect do
          move_service.execute(old_issue, new_project)
          other_issue_notification.reload
        end.not_to change { other_issue_notification.noteable_id }
      end
    end

    context 'when issue is not from service desk' do
      it 'does not update sent notifications' do
        move_service.execute(old_issue, new_project)

        old_issue_notification_1.reload
        old_issue_notification_2.reload
        expect(old_issue_notification_1.project_id).to eq(old_issue.project_id)
        expect(old_issue_notification_1.noteable_id).to eq(old_issue.id)
        expect(old_issue_notification_2.project_id).to eq(old_issue.project_id)
        expect(old_issue_notification_2.noteable_id).to eq(old_issue.id)
      end
    end
  end

  context 'copying email participants' do
    let!(:participant1) { create(:issue_email_participant, email: 'user1@example.com', issue: old_issue) }
    let!(:participant2) { create(:issue_email_participant, email: 'user2@example.com', issue: old_issue) }
    let!(:participant3) { create(:issue_email_participant, email: 'other_project_customer@example.com') }

    include_context 'user can move issue'

    subject(:new_issue) do
      move_service.execute(old_issue, new_project)
    end

    it 'copies moved issue email participants' do
      new_issue

      expect(participant1.reload.issue).to eq(old_issue)
      expect(participant2.reload.issue).to eq(old_issue)
      expect(new_issue.issue_email_participants.pluck(:email))
       .to match_array([participant1.email, participant2.email])
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Issues
  class CloneService < Issuable::Clone::BaseService
    CloneError = Class.new(StandardError)

    def execute(issue, target_project, with_notes: false)
      @target_project = target_project
      @with_notes = with_notes

      verify_can_clone_issue!(issue, target_project)

      super(issue, target_project)

      notify_participants

      queue_copy_designs

      new_entity
    end

    private

    attr_reader :target_project
    attr_reader :with_notes

    def verify_can_clone_issue!(issue, target_project)
      unless issue.supports_move_and_clone?
        raise CloneError, s_('CloneIssue|Cannot clone issues of \'%{issue_type}\' type.') % { issue_type: issue.issue_type }
      end

      unless issue.can_clone?(current_user, target_project)
        raise CloneError, s_('CloneIssue|Cannot clone issue due to insufficient permissions!')
      end

      if target_project.pending_delete?
        raise CloneError, s_('CloneIssue|Cannot clone issue to target project as it is pending deletion.')
      end
    end

    def update_new_entity
      # we don't call `super` because we want to be able to decide whether or not to copy all comments over.
      update_new_entity_description

      if with_notes
        copy_notes
        copy_resource_events
      end
    end

    def update_old_entity
      # no-op
      # The base_service closes the old issue, we don't want that, so we override here so nothing happens.
    end

    def create_new_entity
      new_params = {
        id: nil,
        iid: nil,
        relative_position: relative_position,
        project: target_project,
        author: current_user,
        assignee_ids: original_entity.assignee_ids
      }

      new_params = original_entity.serializable_hash.symbolize_keys.merge(new_params)
      new_params = new_params.merge(rewritten_old_entity_attributes)
      new_params.delete(:created_at)
      new_params.delete(:updated_at)

      # spam checking is not necessary, as no new content is being created.

      # Skip creation of system notes for existing attributes of the issue when cloning with notes.
      # The system notes of the old issue are copied over so we don't want to end up with duplicate notes.
      # When cloning without notes, we want to generate system notes for the attributes that were copied.
      create_result = CreateService.new(
        container: target_project,
        current_user: current_user,
        params: new_params,
        perform_spam_check: false
      ).execute(skip_system_notes: with_notes)

      raise CloneError, create_result.errors.join(', ') if create_result.error? && create_result[:issue].blank?

      create_result[:issue]
    end

    def queue_copy_designs
      return unless original_entity.designs.present?

      response = DesignManagement::CopyDesignCollection::QueueService.new(
        current_user,
        original_entity,
        new_entity
      ).execute

      log_error(response.message) if response.error?
    end

    def notify_participants
      notification_service.async.issue_cloned(original_entity, new_entity, current_user)
    end

    def add_note_from
      SystemNoteService.noteable_cloned(
        new_entity,
        target_project,
        original_entity,
        current_user,
        direction: :from,
        created_at: new_entity.created_at
      )
    end

    def add_note_to
      SystemNoteService.noteable_cloned(original_entity, old_project,
        new_entity, current_user,
        direction: :to)
    end
  end
end

Issues::CloneService.prepend_mod_with('Issues::CloneService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issues::CloneService, feature_category: :team_planning do
  include DesignManagementTestHelpers

  let_it_be(:user) { create(:user) }
  let_it_be(:author) { create(:user) }
  let_it_be(:title) { 'Some issue' }
  let_it_be(:description) { ""Some issue description with mention to #{user.to_reference}"" }
  let_it_be(:group) { create(:group, :private) }
  let_it_be(:sub_group_1) { create(:group, :private, parent: group) }
  let_it_be(:sub_group_2) { create(:group, :private, parent: group) }
  let_it_be(:old_project) { create(:project, namespace: sub_group_1) }
  let_it_be(:new_project) { create(:project, namespace: sub_group_2) }

  let_it_be(:old_issue, reload: true) do
    create(:issue, title: title, description: description, project: old_project, author: author)
  end

  let(:with_notes) { false }

  subject(:clone_service) do
    described_class.new(container: old_project, current_user: user)
  end

  shared_context 'user can clone issue' do
    before do
      old_project.add_reporter(user)
      new_project.add_reporter(user)
    end
  end

  describe '#execute' do
    context 'issue movable' do
      include_context 'user can clone issue'

      context 'when issue creation fails' do
        before do
          allow_next_instance_of(Issues::CreateService) do |create_service|
            allow(create_service).to receive(:execute).and_return(ServiceResponse.error(message: 'some error'))
          end
        end

        it 'raises a clone error' do
          expect { clone_service.execute(old_issue, new_project) }.to raise_error(
            Issues::CloneService::CloneError,
            'some error'
          )
        end
      end

      context 'generic issue' do
        let!(:new_issue) { clone_service.execute(old_issue, new_project, with_notes: with_notes) }

        it 'creates a new issue in the selected project' do
          expect do
            clone_service.execute(old_issue, new_project)
          end.to change { new_project.issues.count }.by(1)
        end

        it 'copies issue title' do
          expect(new_issue.title).to eq title
        end

        it 'copies issue description' do
          expect(new_issue.description).to eq description
        end

        it 'adds system note to old issue at the end' do
          expect(old_issue.notes.last.note).to start_with 'cloned to'
        end

        it 'adds system note to new issue at the start' do
          # We set an assignee so an assignee system note will be generated and
          # we can assert that the ""cloned from"" note is the first one
          assignee = create(:user)
          new_project.add_developer(assignee)
          old_issue.assignees = [assignee]

          new_issue = clone_service.execute(old_issue, new_project)

          expect(new_issue.notes.size).to eq(2)

          cloned_from_note = new_issue.notes.last
          expect(cloned_from_note.note).to start_with 'cloned from'
          expect(new_issue.notes.fresh.first).to eq(cloned_from_note)
        end

        it 'keeps old issue open' do
          expect(old_issue.open?).to be true
        end

        it 'persists new issue' do
          expect(new_issue.persisted?).to be true
        end

        it 'persists all changes' do
          expect(old_issue.changed?).to be false
          expect(new_issue.changed?).to be false
        end

        it 'sets the current user as author' do
          expect(new_issue.author).to eq user
        end

        it 'creates a new internal id for issue' do
          expect(new_issue.iid).to be_present
        end

        it 'sets created_at of new issue to the time of clone' do
          future_time = 5.days.from_now

          travel_to(future_time) do
            new_issue = clone_service.execute(old_issue, new_project, with_notes: with_notes)

            expect(new_issue.created_at).to be_like_time(future_time)
          end
        end

        it 'does not set moved_issue' do
          expect(old_issue.moved?).to eq(false)
        end

        context 'when copying comments' do
          let(:with_notes) { true }

          it 'does not create extra system notes' do
            new_issue = clone_service.execute(old_issue, new_project, with_notes: with_notes)

            expect(new_issue.notes.count).to eq(old_issue.notes.count)
          end
        end
      end

      context 'issue with system notes and resource events' do
        before do
          create(:note, :system, noteable: old_issue, project: old_project)
          create(:resource_label_event, label: create(:label, project: old_project), issue: old_issue)
          create(:resource_state_event, issue: old_issue, state: :reopened)
          create(:resource_milestone_event, issue: old_issue, action: 'remove', milestone_id: nil)
        end

        it 'does not copy system notes and resource events' do
          new_issue = clone_service.execute(old_issue, new_project)

          # 1 here is for the ""cloned from"" system note
          expect(new_issue.notes.count).to eq(1)
          expect(new_issue.resource_state_events).to be_empty
          expect(new_issue.resource_milestone_events).to be_empty
        end
      end

      context 'issue with award emoji' do
        let!(:award_emoji) { create(:award_emoji, awardable: old_issue) }

        it 'does not copy the award emoji' do
          old_issue.reload
          new_issue = clone_service.execute(old_issue, new_project)

          expect(new_issue.reload.award_emoji).to be_empty
        end
      end

      context 'issue with milestone' do
        let(:milestone) { create(:milestone, group: sub_group_1) }
        let(:new_project) { create(:project, namespace: sub_group_1) }

        let(:old_issue) do
          create(:issue, title: title, description: description, project: old_project, author: author, milestone: milestone)
        end

        it 'copies the milestone and creates a resource_milestone_event' do
          new_issue = clone_service.execute(old_issue, new_project)

          expect(new_issue.milestone).to eq(milestone)
          expect(new_issue.resource_milestone_events.count).to eq(1)
        end
      end

      context 'issue with label' do
        let(:label) { create(:group_label, group: sub_group_1) }
        let(:new_project) { create(:project, namespace: sub_group_1) }

        let(:old_issue) do
          create(:issue, project: old_project, labels: [label])
        end

        it 'copies the label and creates a resource_label_event' do
          new_issue = clone_service.execute(old_issue, new_project)

          expect(new_issue.labels).to contain_exactly(label)
          expect(new_issue.resource_label_events.count).to eq(1)
        end
      end

      context 'issue with due date' do
        let(:date) { Date.parse('2020-01-10') }
        let(:new_date) { date + 1.week }

        let(:old_issue) do
          create(:issue, title: title, description: description, project: old_project, author: author, due_date: date)
        end

        before do
          old_issue.update!(due_date: new_date)
          SystemNoteService.change_start_date_or_due_date(old_issue, old_project, author, old_issue.previous_changes.slice('due_date'))
        end

        it 'keeps the same due date' do
          new_issue = clone_service.execute(old_issue, new_project)

          expect(new_issue.due_date).to eq(old_issue.due_date)
        end
      end

      context 'issue with assignee' do
        let_it_be(:assignee) { create(:user) }

        before do
          old_issue.assignees = [assignee]
        end

        it 'preserves assignee with access to the new issue' do
          new_project.add_reporter(assignee)

          new_issue = clone_service.execute(old_issue, new_project)

          expect(new_issue.assignees).to eq([assignee])
        end

        it 'ignores assignee without access to the new issue' do
          new_issue = clone_service.execute(old_issue, new_project)

          expect(new_issue.assignees).to be_empty
        end
      end

      context 'issue is confidential' do
        before do
          old_issue.update_columns(confidential: true)
        end

        it 'preserves the confidential flag' do
          new_issue = clone_service.execute(old_issue, new_project)

          expect(new_issue.confidential).to be true
        end
      end

      context 'moving to same project' do
        it 'also works' do
          new_issue = clone_service.execute(old_issue, old_project)

          expect(new_issue.project).to eq(old_project)
          expect(new_issue.iid).not_to eq(old_issue.iid)
        end
      end

      context 'project issue hooks' do
        let!(:hook) { create(:project_hook, project: old_project, issues_events: true) }

        it 'executes project issue hooks' do
          allow_next_instance_of(WebHookService) do |instance|
            allow(instance).to receive(:execute)
          end

          # Ideally, we'd test that `WebHookWorker.jobs.size` increased by 1,
          # but since the entire spec run takes place in a transaction, we never
          # actually get to the `after_commit` hook that queues these jobs.
          expect { clone_service.execute(old_issue, new_project) }
          .not_to raise_error # Sidekiq::Worker::EnqueueFromTransactionError
        end
      end

      # These tests verify that notes are copied. More thorough tests are in
      # the unit test for Notes::CopyService.
      context 'issue with notes' do
        let_it_be(:notes) do
          [
            create(:note, noteable: old_issue, project: old_project, created_at: 2.weeks.ago, updated_at: 1.week.ago),
            create(:note, noteable: old_issue, project: old_project)
          ]
        end

        let(:new_issue) { clone_service.execute(old_issue, new_project, with_notes: with_notes) }

        let(:copied_notes) { new_issue.notes.limit(notes.size) } # Remove the system note added by the copy itself

        it 'does not copy notes' do
          # only the system note
          expect(copied_notes.order('id ASC').pluck(:note).size).to eq(1)
        end

        context 'when copying comments' do
          let(:with_notes) { true }

          it 'copies existing notes in order' do
            expect(copied_notes.order('id ASC').pluck(:note)).to eq(notes.map(&:note))
          end
        end
      end

      context 'issue with a design', :clean_gitlab_redis_shared_state do
        let_it_be(:new_project) { create(:project) }

        let!(:design) { create(:design, :with_lfs_file, issue: old_issue) }
        let!(:note) { create(:diff_note_on_design, noteable: design, issue: old_issue, project: old_issue.project) }
        let(:subject) { clone_service.execute(old_issue, new_project) }

        before do
          enable_design_management
        end

        it 'calls CopyDesignCollection::QueueService' do
          expect(DesignManagement::CopyDesignCollection::QueueService).to receive(:new)
                                                                            .with(user, old_issue, kind_of(Issue))
                                                                            .and_call_original

          subject
        end

        it 'logs if QueueService returns an error', :aggregate_failures do
          error_message = 'error'

          expect_next_instance_of(DesignManagement::CopyDesignCollection::QueueService) do |service|
            expect(service).to receive(:execute).and_return(
              ServiceResponse.error(message: error_message)
            )
          end
          expect(Gitlab::AppLogger).to receive(:error).with(error_message)

          subject
        end

        # Perform a small integration test to ensure the services and worker
        # can correctly create designs.
        it 'copies the design and its notes', :sidekiq_inline, :aggregate_failures do
          new_issue = subject

          expect(new_issue.designs.size).to eq(1)
          expect(new_issue.designs.first.notes.size).to eq(1)
        end
      end

      context 'issue relative position' do
        let(:subject) { clone_service.execute(old_issue, new_project) }

        it_behaves_like 'copy or reset relative position'
      end
    end

    describe 'clone permissions' do
      let(:clone) { clone_service.execute(old_issue, new_project) }

      context 'target project is pending deletion' do
        include_context 'user can clone issue'

        before do
          new_project.update_columns(pending_delete: true)
        end

        after do
          new_project.update_columns(pending_delete: false)
        end

        it { expect { clone }.to raise_error(Issues::CloneService::CloneError, /pending deletion/) }
      end

      context 'user is reporter in both projects' do
        include_context 'user can clone issue'
        it { expect { clone }.not_to raise_error }
      end

      context 'user is reporter only in new project' do
        before do
          new_project.add_reporter(user)
        end

        it { expect { clone }.to raise_error(StandardError, /permissions/) }
      end

      context 'user is reporter only in old project' do
        before do
          old_project.add_reporter(user)
        end

        it { expect { clone }.to raise_error(StandardError, /permissions/) }
      end

      context 'user is reporter in one project and guest in another' do
        before do
          new_project.add_guest(user)
          old_project.add_reporter(user)
        end

        it { expect { clone }.to raise_error(StandardError, /permissions/) }
      end

      context 'issue is not persisted' do
        include_context 'user can clone issue'
        let(:old_issue) { build(:issue, project: old_project, author: author) }

        it { expect { clone }.to raise_error(StandardError, /permissions/) }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Issues
  class ReorderService < Issues::BaseService
    include Gitlab::Utils::StrongMemoize

    def execute(issue)
      return false unless can?(current_user, :update_issue, issue)
      return false unless move_between_ids

      update(issue, { move_between_ids: move_between_ids })
    end

    private

    def update(issue, attrs)
      ::Issues::UpdateService.new(container: project, current_user: current_user, params: attrs).execute(issue)
    rescue ActiveRecord::RecordNotFound
      false
    end

    def move_between_ids
      strong_memoize(:move_between_ids) do
        ids = [params[:move_before_id], params[:move_after_id]]
                .map(&:to_i)
                .map { |m| m > 0 ? m : nil }

        ids.any? ? ids : nil
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issues::ReorderService, feature_category: :team_planning do
  let_it_be(:user)    { create_default(:user) }
  let_it_be(:group)   { create(:group) }
  let_it_be(:project, reload: true) { create(:project, namespace: group) }

  shared_examples 'issues reorder service' do
    context 'when reordering issues' do
      it 'returns false with no params' do
        expect(service({}).execute(issue1)).to be_falsey
      end

      it 'returns false with both invalid params' do
        params = { move_after_id: nil, move_before_id: non_existing_record_id }

        expect(service(params).execute(issue1)).to be_falsey
      end

      it 'sorts issues' do
        params = { move_after_id: issue2.id, move_before_id: issue3.id }

        service(params).execute(issue1)

        expect(issue1.relative_position)
          .to be_between(issue2.relative_position, issue3.relative_position)
      end

      it 'sorts issues if only given one neighbour, on the left' do
        params = { move_before_id: issue3.id }

        service(params).execute(issue1)

        expect(issue1.relative_position).to be > issue3.relative_position
      end

      it 'sorts issues if only given one neighbour, on the right' do
        params = { move_after_id: issue1.id }

        service(params).execute(issue3)

        expect(issue3.relative_position).to be < issue1.relative_position
      end
    end
  end

  describe '#execute' do
    let_it_be(:issue1, reload: true) { create(:issue, project: project, relative_position: 10) }
    let_it_be(:issue2) { create(:issue, project: project, relative_position: 20) }
    let_it_be(:issue3, reload: true) { create(:issue, project: project, relative_position: 30) }

    context 'when ordering issues in a project' do
      before do
        project.add_developer(user)
      end

      it_behaves_like 'issues reorder service'
    end

    context 'when ordering issues in a group' do
      before do
        group.add_developer(user)
      end

      it_behaves_like 'issues reorder service'

      context 'when ordering in a group issue list' do
        let(:params) { { move_after_id: issue2.id, move_before_id: issue3.id } }

        subject { service(params) }

        it 'sorts issues' do
          project2 = create(:project, namespace: group)
          issue4   = create(:issue, project: project2)

          subject.execute(issue4)

          expect(issue4.relative_position)
            .to be_between(issue2.relative_position, issue3.relative_position)
        end
      end
    end
  end

  def service(params)
    described_class.new(container: project, current_user: user, params: params)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Issues
  class PrepareImportCsvService < Import::PrepareService
    extend ::Gitlab::Utils::Override

    private

    override :worker
    def worker
      ImportIssuesCsvWorker
    end

    override :success_message
    def success_message
      _(""Your issues are being imported. Once finished, you'll get a confirmation email."")
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issues::PrepareImportCsvService, feature_category: :team_planning do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }

  let(:file) { double }
  let(:upload_service) { double }
  let(:uploader) { double }
  let(:upload) { double }

  let(:subject) do
    described_class.new(project, user, file: file).execute
  end

  context 'when file is uploaded correctly' do
    let(:upload_id) { 99 }

    before do
      mock_upload
    end

    it 'returns a success message' do
      result = subject

      expect(result[:status]).to eq(:success)
      expect(result[:message]).to eq(""Your issues are being imported. Once finished, you'll get a confirmation email."")
    end

    it 'enqueues the ImportRequirementsCsvWorker' do
      expect(ImportIssuesCsvWorker).to receive(:perform_async).with(user.id, project.id, upload_id)

      subject
    end
  end

  context 'when file upload fails' do
    before do
      mock_upload(false)
    end

    it 'returns an error message' do
      result = subject

      expect(result[:status]).to eq(:error)
      expect(result[:message]).to eq('File upload error.')
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Issues
  class ImportCsvService < Issuable::ImportCsv::BaseService
    def execute
      record_import_attempt

      super
    end

    def email_results_to_user
      Notify.import_issues_csv_email(user.id, project.id, results).deliver_later
    end

    private

    def create_object(attributes)
      super[:issue]
    end

    def create_object_class
      Issues::CreateService
    end

    def extra_create_service_params
      { perform_spam_check: perform_spam_check? }
    end

    def perform_spam_check?
      !user.can_admin_all_resources?
    end

    def record_import_attempt
      Issues::CsvImport.create!(user: user, project: project)
    end
  end
end

Issues::ImportCsvService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issues::ImportCsvService, feature_category: :team_planning do
  let(:project) { create(:project) }
  let(:user) { create(:user) }
  let(:assignee) { create(:user, username: 'csv_assignee') }
  let(:file) { fixture_file_upload('spec/fixtures/csv_complex.csv') }
  let(:service) do
    uploader = FileUploader.new(project)
    uploader.store!(file)

    described_class.new(user, project, uploader)
  end

  let!(:test_milestone) { create(:milestone, project: project, title: '15.10') }

  include_examples 'issuable import csv service', 'issue' do
    let(:issuables) { project.issues }
    let(:email_method) { :import_issues_csv_email }
  end

  describe '#execute' do
    subject { service.execute }

    it_behaves_like 'performs a spam check', true

    it 'sets all issueable attributes and executes quick actions' do
      project.add_developer(user)
      project.add_developer(assignee)

      expect { subject }.to change { issuables.count }.by 3

      expect(issuables.reload).to include(
        have_attributes(
          title: 'Title with quote""',
          description: 'Description',
          time_estimate: 3600,
          assignees: include(assignee),
          due_date: Date.new(2022, 6, 28),
          milestone_id: test_milestone.id
        )
      )
    end

    context 'when user is an admin' do
      before do
        allow(user).to receive(:can_admin_all_resources?).and_return(true)
      end

      it_behaves_like 'performs a spam check', false
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Issues
  class BuildService < Issues::BaseService
    include ResolveDiscussions

    def execute(initialize_callbacks: true)
      filter_resolve_discussion_params

      container_param = case container
                        when Project
                          { project: project }
                        when Namespaces::ProjectNamespace
                          { project: container.project }
                        else
                          { namespace: container }
                        end

      @issue = model_klass.new(issue_params.merge(container_param)).tap do |issue|
        set_work_item_type(issue)
        initialize_callbacks!(issue) if initialize_callbacks
      end
    end

    def issue_params_with_info_from_discussions
      return {} unless merge_request_to_resolve_discussions_of

      { title: title_from_merge_request, description: description_for_discussions }
    end

    def title_from_merge_request
      ""Follow-up from \""#{merge_request_to_resolve_discussions_of.title}\""""
    end

    def description_for_discussions
      if discussions_to_resolve.empty?
        return ""There are no unresolved discussions. ""\
               ""Review the conversation in #{merge_request_to_resolve_discussions_of.to_reference}""
      end

      description = ""The following #{'discussion'.pluralize(discussions_to_resolve.size)} ""\
                    ""from #{merge_request_to_resolve_discussions_of.to_reference} ""\
                    ""should be addressed:""

      [description, *items_for_discussions].join(""\n\n"")
    end

    def items_for_discussions
      discussions_to_resolve.map { |discussion| item_for_discussion(discussion) }
    end

    def item_for_discussion(discussion)
      first_note_to_resolve = discussion.first_note_to_resolve || discussion.first_note

      is_very_first_note = first_note_to_resolve == discussion.first_note
      action = is_very_first_note ? ""started"" : ""commented on""

      note_url = Gitlab::UrlBuilder.build(first_note_to_resolve)

      other_note_count = discussion.notes.size - 1

      discussion_info = [""- [ ] #{first_note_to_resolve.author.to_reference} #{action} a [discussion](#{note_url}): ""]
      discussion_info << ""(+#{other_note_count} #{'comment'.pluralize(other_note_count)})"" if other_note_count > 0

      note_without_block_quotes = Banzai::Filter::BlockquoteFenceFilter.new(first_note_to_resolve.note).call
      spaces = ' ' * 4
      quote = note_without_block_quotes.lines.map { |line| ""#{spaces}> #{line}"" }.join

      [discussion_info.join(' '), quote].join(""\n\n"")
    end

    def issue_params
      @issue_params ||= build_issue_params
    end

    private

    def set_work_item_type(issue)
      work_item_type = if params[:work_item_type_id].present?
                         params.delete(:work_item_type)
                         WorkItems::Type.find_by(id: params.delete(:work_item_type_id)) # rubocop: disable CodeReuse/ActiveRecord
                       else
                         params.delete(:work_item_type)
                       end

      # We need to support the legacy input params[:issue_type] even if we don't have the issue_type column anymore.
      # In the future only params[:work_item_type] should be provided
      base_type = work_item_type&.base_type || params[:issue_type]

      issue.work_item_type = if create_issue_type_allowed?(container, base_type)
                               work_item_type || WorkItems::Type.default_by_type(base_type)
                             else
                               # If no work item type was provided or not allowed, we need to set it to
                               # the default issue_type
                               WorkItems::Type.default_by_type(::Issue::DEFAULT_ISSUE_TYPE)
                             end
    end

    def model_klass
      ::Issue
    end

    def public_params
      # Additional params may be assigned later (in a CreateService for example)
      public_issue_params = [
        :title,
        :description,
        :confidential
      ]

      params.slice(*public_issue_params)
    end

    def build_issue_params
      { author: current_user }
        .merge(issue_params_with_info_from_discussions)
        .merge(public_params)
        .with_indifferent_access
    end
  end
end

Issues::BuildService.prepend_mod_with('Issues::BuildService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issues::BuildService, feature_category: :team_planning do
  using RSpec::Parameterized::TableSyntax

  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:developer) { create(:user) }
  let_it_be(:reporter) { create(:user) }
  let_it_be(:guest) { create(:user) }

  let(:user) { developer }

  before_all do
    project.add_developer(developer)
    project.add_reporter(reporter)
    project.add_guest(guest)
  end

  def build_issue(issue_params = {})
    described_class.new(container: project, current_user: user, params: issue_params).execute
  end

  context 'for a single discussion' do
    describe '#execute' do
      let(:merge_request) { create(:merge_request, title: ""Hello world"", source_project: project) }
      let(:discussion) { create(:diff_note_on_merge_request, project: project, noteable: merge_request, note: ""Almost done"").to_discussion }

      subject { build_issue(merge_request_to_resolve_discussions_of: merge_request.iid, discussion_to_resolve: discussion.id) }

      it 'references the noteable title in the issue title' do
        expect(subject.title).to include('Hello world')
      end

      it 'adds the note content to the description' do
        expect(subject.description).to include('Almost done')
      end
    end
  end

  context 'for discussions in a merge request' do
    let(:merge_request) { create(:merge_request_with_diff_notes, source_project: project) }

    describe '#items_for_discussions' do
      it 'has an item for each discussion' do
        create(:diff_note_on_merge_request, noteable: merge_request, project: merge_request.source_project, line_number: 13)
        service = described_class.new(container: project, current_user: user, params: { merge_request_to_resolve_discussions_of: merge_request.iid })

        service.execute

        expect(service.items_for_discussions.size).to eq(2)
      end
    end

    describe '#item_for_discussion' do
      let(:service) { described_class.new(container: project, current_user: user, params: { merge_request_to_resolve_discussions_of: merge_request.iid }) }

      it 'mentions the author of the note' do
        discussion = create(:diff_note_on_merge_request, author: create(:user, username: 'author')).to_discussion
        expect(service.item_for_discussion(discussion)).to include('@author')
      end

      it 'wraps the note in a blockquote' do
        note_text = ""This is a string\n""\
                    ""\n""\
                    "">>>\n""\
                    ""with a blockquote\n""\
                    ""> That has a quote\n""\
                    "">>>\n""
        note_result = ""    > This is a string\n""\
                      ""    > \n""\
                      ""    > \n""\
                      ""    > > with a blockquote\n""\
                      ""    > > > That has a quote\n""\
                      ""    > \n""
        discussion = create(:diff_note_on_merge_request, note: note_text).to_discussion
        expect(service.item_for_discussion(discussion)).to include(note_result)
      end
    end

    describe '#execute' do
      let(:base_params) { { merge_request_to_resolve_discussions_of: merge_request.iid } }

      context 'without additional params' do
        subject { build_issue(base_params) }

        it 'has the merge request reference in the title' do
          expect(subject.title).to include(merge_request.title)
        end

        it 'has the reference of the merge request in the description' do
          expect(subject.description).to include(merge_request.to_reference)
        end
      end

      it 'uses provided title if title param given' do
        issue = build_issue(base_params.merge(title: 'What an issue'))

        expect(issue.title).to eq('What an issue')
      end

      it 'uses provided description if description param given' do
        issue = build_issue(base_params.merge(description: 'Fix at your earliest convenience'))

        expect(issue.description).to eq('Fix at your earliest convenience')
      end

      describe 'with multiple discussions' do
        let!(:diff_note) { create(:diff_note_on_merge_request, noteable: merge_request, project: merge_request.target_project, line_number: 15) }

        it 'mentions all the authors in the description' do
          authors = merge_request.resolvable_discussions.map(&:author)

          expect(build_issue(base_params).description).to include(*authors.map(&:to_reference))
        end

        it 'has a link for each unresolved discussion in the description' do
          notes = merge_request.resolvable_discussions.map(&:first_note)
          links = notes.map { |note| Gitlab::UrlBuilder.build(note) }

          expect(build_issue(base_params).description).to include(*links)
        end

        it 'mentions additional notes' do
          create_list(:diff_note_on_merge_request, 2, noteable: merge_request, project: merge_request.target_project, in_reply_to: diff_note)

          expect(build_issue(base_params).description).to include('(+2 comments)')
        end
      end
    end
  end

  context 'For a merge request without discussions' do
    let(:merge_request) { create(:merge_request, source_project: project) }

    describe '#execute' do
      it 'mentions the merge request in the description' do
        issue = build_issue(merge_request_to_resolve_discussions_of: merge_request.iid)

        expect(issue.description).to include(""Review the conversation in #{merge_request.to_reference}"")
      end
    end
  end

  describe '#execute' do
    describe 'setting milestone' do
      context 'when developer' do
        it 'builds a new issues with given params' do
          milestone = create(:milestone, project: project)
          issue = build_issue(milestone_id: milestone.id)

          expect(issue.milestone).to eq(milestone)
        end

        it 'sets milestone to nil if it is not available for the project' do
          milestone = create(:milestone, project: create(:project))
          issue = build_issue(milestone_id: milestone.id)

          expect(issue.milestone).to be_nil
        end
      end

      context 'when user is not a project member' do
        let(:user) { create(:user) }

        it 'cannot set milestone' do
          milestone = create(:milestone, project: project)
          issue = build_issue(milestone_id: milestone.id)

          expect(issue.milestone).to be_nil
        end
      end
    end

    describe 'setting issue type' do
      context 'with a corresponding WorkItems::Type' do
        let_it_be(:type_task) { WorkItems::Type.default_by_type(:task) }
        let_it_be(:type_task_id) { type_task.id }
        let_it_be(:type_issue_id) { WorkItems::Type.default_issue_type.id }
        let_it_be(:type_incident_id) { WorkItems::Type.default_by_type(:incident).id }
        let(:combined_params) { { work_item_type: type_task, issue_type: 'issue' } }
        let(:work_item_params) { { work_item_type_id: type_task_id } }

        where(:issue_params, :current_user, :work_item_type_id, :resulting_issue_type) do
          { issue_type: nil }           | ref(:guest)    | ref(:type_issue_id)    | 'issue'
          { issue_type: 'issue' }       | ref(:guest)    | ref(:type_issue_id)    | 'issue'
          { issue_type: 'incident' }    | ref(:guest)    | ref(:type_issue_id)    | 'issue'
          { issue_type: 'incident' }    | ref(:reporter) | ref(:type_incident_id) | 'incident'
          ref(:combined_params)         | ref(:reporter) | ref(:type_task_id)     | 'task'
          ref(:work_item_params)        | ref(:reporter) | ref(:type_task_id)     | 'task'
          # update once support for test_case is enabled
          { issue_type: 'test_case' }   | ref(:guest)    | ref(:type_issue_id)    | 'issue'
          # update once support for requirement is enabled
          { issue_type: 'requirement' } | ref(:guest)    | ref(:type_issue_id)    | 'issue'
          { issue_type: 'invalid' }     | ref(:guest)    | ref(:type_issue_id)    | 'issue'
          # ensure that we don't set a value which has a permission check but is an invalid issue type
          { issue_type: 'project' }     | ref(:guest)    | ref(:type_issue_id)    | 'issue'
        end

        with_them do
          let(:user) { current_user }

          it 'builds an issue' do
            issue = build_issue(**issue_params)

            expect(issue.work_item_type_id).to eq(work_item_type_id)
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Issues
  class CloseService < Issues::BaseService
    # Closes the supplied issue if the current user is able to do so.
    def execute(issue, commit: nil, notifications: true, system_note: true, skip_authorization: false)
      return issue unless can_close?(issue, skip_authorization: skip_authorization)

      close_issue(
        issue,
        closed_via: commit,
        notifications: notifications,
        system_note: system_note
      )
    end

    # Closes the supplied issue without checking if the user is authorized to
    # do so.
    #
    # The code calling this method is responsible for ensuring that a user is
    # allowed to close the given issue.
    def close_issue(issue, closed_via: nil, notifications: true, system_note: true)
      if issue.is_a?(ExternalIssue)
        close_external_issue(issue, closed_via)

        return issue
      end

      if issue.close(current_user)
        event_service.close_issue(issue, current_user)
        create_note(issue, closed_via) if system_note

        if current_user.project_bot?
          log_audit_event(issue, current_user, ""#{issue.issue_type}_closed_by_project_bot"",
            ""Closed #{issue.issue_type.humanize(capitalize: false)} #{issue.title}"")
        end

        closed_via = _(""commit %{commit_id}"") % { commit_id: closed_via.id } if closed_via.is_a?(Commit)

        notification_service.async.close_issue(issue, current_user, { closed_via: closed_via }) if notifications
        todo_service.close_issue(issue, current_user)
        perform_incident_management_actions(issue)
        execute_hooks(issue, 'close')
        invalidate_cache_counts(issue, users: issue.assignees)
        issue.update_project_counter_caches
        track_incident_action(current_user, issue, :incident_closed)

        if closed_via.is_a?(MergeRequest)
          store_first_mentioned_in_commit_at(issue, closed_via)
          Onboarding::ProgressService.new(project.namespace).execute(action: :issue_auto_closed)
        end

        Milestones::ClosedIssuesCountService.new(issue.milestone).delete_cache if issue.milestone
      end

      issue
    end

    private

    def can_close?(issue, skip_authorization: false)
      skip_authorization || can?(current_user, :update_issue, issue) || issue.is_a?(ExternalIssue)
    end

    def perform_incident_management_actions(issue)
      resolve_alerts(issue)
      resolve_incident(issue)
    end

    def close_external_issue(issue, closed_via)
      return unless project.external_issue_tracker&.support_close_issue?

      project.external_issue_tracker.close_issue(closed_via, issue, current_user)
      todo_service.close_issue(issue, current_user)
    end

    def create_note(issue, current_commit)
      SystemNoteService.change_status(issue, issue.project, current_user, issue.state, current_commit)
    end

    def resolve_alerts(issue)
      issue.alert_management_alerts.each { |alert| resolve_alert(alert) }
    end

    def resolve_alert(alert)
      return if alert.resolved?

      issue = alert.issue

      if alert.resolve
        SystemNoteService.change_alert_status(alert, Users::Internal.alert_bot, "" because #{current_user.to_reference} closed incident #{issue.to_reference(project)}"")
      else
        Gitlab::AppLogger.warn(
          message: 'Cannot resolve an associated Alert Management alert',
          issue_id: issue.id,
          alert_id: alert.id,
          alert_errors: alert.errors.messages
        )
      end
    end

    def resolve_incident(issue)
      return unless issue.work_item_type&.incident?

      status = issue.incident_management_issuable_escalation_status || issue.build_incident_management_issuable_escalation_status

      return unless status.resolve

      SystemNoteService.change_incident_status(issue, current_user, ' by closing the incident')
      IncidentManagement::TimelineEvents::CreateService.resolve_incident(issue, current_user)
    end

    def store_first_mentioned_in_commit_at(issue, merge_request, max_commit_lookup: 100)
      metrics = issue.metrics
      return if metrics.nil? || metrics.first_mentioned_in_commit_at

      first_commit_timestamp = merge_request.commits(limit: max_commit_lookup).last.try(:authored_date)
      return unless first_commit_timestamp

      metrics.update!(first_mentioned_in_commit_at: first_commit_timestamp)
    end
  end
end

Issues::CloseService.prepend_mod_with('Issues::CloseService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issues::CloseService, feature_category: :team_planning do
  let(:project) { create(:project, :repository) }
  let(:delegated_project) { project.project_namespace.project }
  let(:user) { create(:user, email: ""user@example.com"") }
  let(:user2) { create(:user, email: ""user2@example.com"") }
  let(:guest) { create(:user) }
  let(:issue) { create(:issue, title: ""My issue"", project: project, assignees: [user2], author: create(:user)) }
  let(:external_issue) { ExternalIssue.new('JIRA-123', project) }
  let(:closing_merge_request) { create(:merge_request, source_project: project) }
  let(:closing_commit) { create(:commit, project: project) }
  let!(:todo) { create(:todo, :assigned, user: user, project: project, target: issue, author: user2) }

  before do
    project.add_maintainer(user)
    project.add_developer(user2)
    project.add_guest(guest)
  end

  describe '#execute' do
    let(:service) { described_class.new(container: project, current_user: user) }

    context 'when skip_authorization is true' do
      it 'does close the issue even if user is not authorized' do
        non_authorized_user = create(:user)

        service = described_class.new(container: project, current_user: non_authorized_user)

        expect do
          service.execute(issue, skip_authorization: true)
        end.to change { issue.reload.state }.from('opened').to('closed')
      end
    end

    it 'checks if the user is authorized to update the issue' do
      expect(service).to receive(:can?).with(user, :update_issue, issue)
        .and_call_original

      service.execute(issue)
    end

    it 'does not close the issue when the user is not authorized to do so' do
      allow(service).to receive(:can?).with(user, :update_issue, issue)
        .and_return(false)

      expect(service).not_to receive(:close_issue)
      expect(service.execute(issue)).to eq(issue)
    end

    it 'closes the external issue even when the user is not authorized to do so' do
      allow(service).to receive(:can?).with(user, :update_issue, external_issue)
        .and_return(false)

      expect(service).to receive(:close_issue)
        .with(external_issue, closed_via: nil, notifications: true, system_note: true)

      service.execute(external_issue)
    end

    it 'closes the issue when the user is authorized to do so' do
      allow(service).to receive(:can?).with(user, :update_issue, issue)
        .and_return(true)

      expect(service).to receive(:close_issue)
        .with(issue, closed_via: nil, notifications: true, system_note: true)

      service.execute(issue)
    end

    it 'refreshes the number of open issues', :use_clean_rails_memory_store_caching do
      expect do
        service.execute(issue)

        BatchLoader::Executor.clear_current
      end.to change { project.open_issues_count }.from(1).to(0)
    end

    it 'invalidates counter cache for assignees' do
      expect_any_instance_of(User).to receive(:invalidate_issue_cache_counts)

      service.execute(issue)
    end

    it 'does not change escalation status' do
      resolved = IncidentManagement::Escalatable::STATUSES[:resolved]

      expect { service.execute(issue) }
        .to not_change { IncidentManagement::IssuableEscalationStatus.where(issue: issue).count }
        .and not_change { IncidentManagement::IssuableEscalationStatus.where(status: resolved).count }
    end

    context 'issue is incident type' do
      let(:issue) { create(:incident, project: project) }
      let(:current_user) { user }

      subject { service.execute(issue) }

      it_behaves_like 'an incident management tracked event', :incident_management_incident_closed

      it_behaves_like 'Snowplow event tracking with RedisHLL context' do
        let(:namespace) { issue.namespace }
        let(:category) { described_class.to_s }
        let(:action) { 'incident_management_incident_closed' }
        let(:label) { 'redis_hll_counters.incident_management.incident_management_total_unique_counts_monthly' }
      end

      it 'creates a new escalation resolved escalation status', :aggregate_failures do
        expect { service.execute(issue) }.to change { IncidentManagement::IssuableEscalationStatus.where(issue: issue).count }.by(1)

        expect(issue.incident_management_issuable_escalation_status).to be_resolved
      end

      context 'when there is an escalation status' do
        before do
          create(:incident_management_issuable_escalation_status, issue: issue)
        end

        it 'changes escalations status to resolved' do
          expect { service.execute(issue) }.to change { issue.incident_management_issuable_escalation_status.reload.resolved? }.to(true)
        end

        it 'adds a system note', :aggregate_failures do
          expect { service.execute(issue) }.to change { issue.notes.count }.by(1)

          new_note = issue.notes.last
          expect(new_note.note).to eq('changed the incident status to **Resolved** by closing the incident')
          expect(new_note.author).to eq(user)
        end

        it 'adds a timeline event', :aggregate_failures do
          expect(IncidentManagement::TimelineEvents::CreateService)
            .to receive(:resolve_incident)
            .with(issue, user)
            .and_call_original

          expect { service.execute(issue) }.to change { issue.incident_management_timeline_events.count }.by(1)
        end

        context 'when the escalation status did not change to resolved' do
          let(:escalation_status) { instance_double('IncidentManagement::IssuableEscalationStatus', resolve: false, status_name: 'acknowledged') }

          before do
            allow(issue).to receive(:incident_management_issuable_escalation_status).and_return(escalation_status)
          end

          it 'does not create a system note' do
            expect { service.execute(issue) }.not_to change { issue.notes.count }
          end

          it 'does not create a timeline event' do
            expect { service.execute(issue) }.not_to change { issue.incident_management_timeline_events.count }
          end
        end
      end
    end
  end

  describe '#close_issue' do
    context 'with external issue' do
      context 'with an active external issue tracker supporting close_issue' do
        let!(:external_issue_tracker) { create(:jira_integration, project: project) }

        it 'closes the issue on the external issue tracker' do
          project.reload
          expect(project.external_issue_tracker).to receive(:close_issue)

          described_class.new(container: project, current_user: user).close_issue(external_issue)
        end
      end

      context 'with inactive external issue tracker supporting close_issue' do
        let!(:external_issue_tracker) { create(:jira_integration, project: project, active: false) }

        it 'does not close the issue on the external issue tracker' do
          project.reload
          expect(project.external_issue_tracker).not_to receive(:close_issue)

          described_class.new(container: project, current_user: user).close_issue(external_issue)
        end
      end

      context 'with an active external issue tracker not supporting close_issue' do
        let!(:external_issue_tracker) { create(:bugzilla_integration, project: project) }

        it 'does not close the issue on the external issue tracker' do
          project.reload
          expect(project.external_issue_tracker).not_to receive(:close_issue)

          described_class.new(container: project, current_user: user).close_issue(external_issue)
        end
      end
    end

    context ""closed by a merge request"" do
      subject(:close_issue) do
        perform_enqueued_jobs do
          described_class.new(container: project, current_user: user).close_issue(issue, closed_via: closing_merge_request)
        end
      end

      it 'mentions closure via a merge request' do
        expect_next_instance_of(NotificationService::Async) do |service|
          expect(service).to receive(:close_issue).with(issue, user, { closed_via: closing_merge_request })
        end

        close_issue
      end

      it_behaves_like 'records an onboarding progress action', :issue_auto_closed do
        let(:namespace) { project.namespace }
      end

      context 'updating `metrics.first_mentioned_in_commit_at`' do
        context 'when `metrics.first_mentioned_in_commit_at` is not set' do
          it 'uses the first commit authored timestamp' do
            expected = closing_merge_request.commits.take(100).last.authored_date

            close_issue

            expect(issue.metrics.first_mentioned_in_commit_at).to eq(expected)
          end
        end

        context 'when `metrics.first_mentioned_in_commit_at` is already set' do
          before do
            issue.metrics.update!(first_mentioned_in_commit_at: Time.current)
          end

          it 'does not update the metrics' do
            expect { close_issue }.not_to change { issue.metrics.first_mentioned_in_commit_at }
          end
        end

        context 'when merge request has no commits' do
          let(:closing_merge_request) { create(:merge_request, :without_diffs, source_project: project) }

          it 'does not update the metrics' do
            close_issue

            expect(issue.metrics.first_mentioned_in_commit_at).to be_nil
          end
        end
      end
    end

    context ""closed by a commit"", :sidekiq_might_not_need_inline do
      it 'mentions closure via a commit' do
        expect_next_instance_of(NotificationService::Async) do |service|
          expect(service).to receive(:close_issue).with(issue, user, { closed_via: ""commit #{closing_commit.id}"" })
        end

        described_class.new(container: project, current_user: user).close_issue(issue, closed_via: closing_commit)
      end
    end

    context ""valid params"" do
      subject(:close_issue) do
        perform_enqueued_jobs do
          described_class.new(container: project, current_user: user).close_issue(issue)
        end
      end

      it 'verifies the number of queries' do
        recorded = ActiveRecord::QueryRecorder.new { close_issue }
        expected_queries = 30

        expect(recorded.count).to be <= expected_queries
        expect(recorded.cached_count).to eq(0)
      end

      it 'closes the issue' do
        close_issue

        expect(issue).to be_valid
        expect(issue).to be_closed
      end

      it 'records closed user' do
        close_issue

        expect(issue.reload.closed_by_id).to be(user.id)
      end

      it 'sends notification', :sidekiq_might_not_need_inline do
        expect_next_instance_of(NotificationService::Async) do |service|
          expect(service).to receive(:close_issue).with(issue, user, { closed_via: nil })
        end

        close_issue
      end

      it 'creates resource state event about the issue being closed' do
        close_issue

        event = issue.resource_state_events.last
        expect(event.state).to eq('closed')
      end

      it 'marks todos as done' do
        close_issue

        expect(todo.reload).to be_done
      end

      context 'when closing the issue fails' do
        it 'does not assign a closed_by value for the issue' do
          allow(issue).to receive(:close).and_return(false)

          close_issue

          expect(issue.closed_by_id).to be_nil
        end
      end

      context 'when there is an associated Alert Management Alert' do
        context 'when alert can be resolved' do
          it 'resolves an alert and sends a system note' do
            alert = create(:alert_management_alert, issue: issue, project: project)

            expect(SystemNoteService).to receive(:change_alert_status)
              .with(alert, Users::Internal.alert_bot, "" because #{user.to_reference} closed incident #{issue.to_reference(project)}"")

            close_issue

            expect(alert.reload).to be_resolved
          end
        end

        context 'when alert cannot be resolved' do
          before do
            allow(Gitlab::AppLogger).to receive(:warn).and_call_original
          end

          it 'writes a warning into the log' do
            alert = create(:alert_management_alert, :with_validation_errors, issue: issue, project: project)

            close_issue

            expect(Gitlab::AppLogger).to have_received(:warn).with(
              message: 'Cannot resolve an associated Alert Management alert',
              issue_id: issue.id,
              alert_id: alert.id,
              alert_errors: { hosts: ['hosts array is over 255 chars'] }
            )
          end
        end
      end

      context 'when there are several associated Alert Management Alerts' do
        context 'when alerts can be resolved' do
          it 'resolves an alert and sends a system note', :aggregate_failures do
            alerts = create_list(:alert_management_alert, 2, issue: issue, project: project)

            alerts.each do |alert|
              expect(SystemNoteService).to receive(:change_alert_status)
                .with(alert, Users::Internal.alert_bot, "" because #{user.to_reference} closed incident #{issue.to_reference(project)}"")
            end

            close_issue

            expect(alerts.map(&:reload)).to all(be_resolved)
          end
        end
      end

      it 'deletes milestone issue counters cache' do
        issue.update!(milestone: create(:milestone, project: project))

        expect_next_instance_of(Milestones::ClosedIssuesCountService, issue.milestone) do |service|
          expect(service).to receive(:delete_cache).and_call_original
        end

        close_issue
      end

      it_behaves_like 'does not record an onboarding progress action'
    end

    context 'when issue is not confidential' do
      let(:expected_payload) do
        include(
          event_type: 'issue',
          object_kind: 'issue',
          changes: {
            closed_at: { current: kind_of(Time), previous: nil },
            state_id: { current: 2, previous: 1 },
            updated_at: { current: kind_of(Time), previous: kind_of(Time) }
          },
          object_attributes: include(
            closed_at: kind_of(Time),
            state: 'closed',
            action: 'close'
          )
        )
      end

      it 'executes issue hooks' do
        expect(delegated_project).to receive(:execute_hooks).with(expected_payload, :issue_hooks)
        expect(delegated_project).to receive(:execute_integrations).with(expected_payload, :issue_hooks)

        described_class.new(container: delegated_project, current_user: user).close_issue(issue)
      end
    end

    context 'when issue is confidential' do
      it 'executes confidential issue hooks' do
        issue = create(:issue, :confidential, project: project)

        expect(delegated_project).to receive(:execute_hooks).with(an_instance_of(Hash), :confidential_issue_hooks)
        expect(delegated_project).to receive(:execute_integrations).with(an_instance_of(Hash), :confidential_issue_hooks)

        described_class.new(container: project, current_user: user).close_issue(issue)
      end
    end

    context 'internal issues disabled' do
      before do
        project.issues_enabled = false
        project.save!
      end

      it 'does not close the issue' do
        expect(issue).to be_valid
        expect(issue).to be_opened
        expect(todo.reload).to be_pending
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Issues
  class AfterCreateService < Issues::BaseService
    def execute(issue)
      todo_service.new_issue(issue, current_user)
      track_incident_action(current_user, issue, :incident_created)
    end
  end
end

Issues::AfterCreateService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issues::AfterCreateService, feature_category: :team_planning do
  include AfterNextHelpers

  let_it_be(:project) { create(:project) }
  let_it_be(:current_user) { create(:user) }
  let_it_be(:assignee) { create(:user) }
  let_it_be(:milestone) { create(:milestone, project: project) }
  let_it_be(:issue) { create(:issue, project: project, author: current_user, milestone: milestone, assignee_ids: [assignee.id]) }

  subject(:after_create_service) { described_class.new(container: project, current_user: current_user) }

  describe '#execute' do
    it 'creates a pending todo for new assignee' do
      attributes = {
        project: project,
        author: current_user,
        user: assignee,
        target_id: issue.id,
        target_type: issue.class.name,
        action: Todo::ASSIGNED,
        state: :pending
      }

      expect { after_create_service.execute(issue) }.to change { Todo.where(attributes).count }.by(1)
    end

    context 'with a regular issue' do
      it_behaves_like 'does not track incident management event', :incident_management_incident_created do
        subject { after_create_service.execute(issue) }
      end
    end

    context 'with an incident issue' do
      let(:issue) { create(:issue, :incident, project: project, author: current_user) }

      it_behaves_like 'an incident management tracked event', :incident_management_incident_created do
        subject { after_create_service.execute(issue) }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Issues
  class ZoomLinkService < Issues::BaseService
    def initialize(container:, current_user:, params:)
      super

      @issue = params.fetch(:issue)
      @added_meeting = ZoomMeeting.canonical_meeting(@issue)
    end

    def add_link(link)
      if can_add_link? && (link = parse_link(link))
        begin
          add_zoom_meeting(link)
        rescue ActiveRecord::RecordNotUnique
          error(message: _('Failed to add a Zoom meeting'))
        end
      else
        error(message: _('Failed to add a Zoom meeting'))
      end
    end

    def remove_link
      if can_remove_link?
        remove_zoom_meeting
        success(message: _('Zoom meeting removed'))
      else
        error(message: _('Failed to remove a Zoom meeting'))
      end
    end

    def can_add_link?
      can_change_link? && !@added_meeting
    end

    def can_remove_link?
      can_change_link? && @issue.persisted? && !!@added_meeting
    end

    def parse_link(link)
      Gitlab::ZoomLinkExtractor.new(link).links.last
    end

    private

    attr_reader :issue

    def track_meeting_added_event
      ::Gitlab::Tracking.event('IncidentManagement::ZoomIntegration', 'add_zoom_meeting', label: 'Issue ID', value: issue.id, user: current_user, project: @project, namespace: @project.namespace)
    end

    def track_meeting_removed_event
      ::Gitlab::Tracking.event('IncidentManagement::ZoomIntegration', 'remove_zoom_meeting', label: 'Issue ID', value: issue.id, user: current_user, project: @project, namespace: @project.namespace)
    end

    def add_zoom_meeting(link)
      zoom_meeting = new_zoom_meeting(link)
      response =
        if @issue.persisted?
          # Save the meeting directly since we only want to update one meeting, not all
          zoom_meeting.save
          track_incident_action(current_user, issue, :incident_zoom_meeting)
          success(message: _('Zoom meeting added'))
        else
          success(message: _('Zoom meeting added'), payload: { zoom_meetings: [zoom_meeting] })
        end

      track_meeting_added_event
      SystemNoteService.zoom_link_added(@issue, @project, current_user)

      response
    end

    def new_zoom_meeting(link)
      ZoomMeeting.new(
        issue: @issue,
        project: @project,
        issue_status: :added,
        url: link
      )
    end

    def remove_zoom_meeting
      @added_meeting.update(issue_status: :removed)
      track_meeting_removed_event
      SystemNoteService.zoom_link_removed(@issue, @project, current_user)
    end

    def success(message:, payload: nil)
      ServiceResponse.success(message: message, payload: payload)
    end

    def error(message:)
      ServiceResponse.error(message: message)
    end

    def can_change_link?
      if @issue.persisted?
        can?(current_user, :update_issue, @project)
      else
        can?(current_user, :create_issue, @project)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issues::ZoomLinkService, feature_category: :team_planning do
  let_it_be(:user) { create(:user) }
  let_it_be(:issue) { create(:issue) }

  let(:project) { issue.project }
  let(:service) { described_class.new(container: project, current_user: user, params: { issue: issue }) }
  let(:zoom_link) { 'https://zoom.us/j/123456789' }

  before do
    project.add_reporter(user)
  end

  shared_context '""added"" Zoom meeting' do
    before do
      create(:zoom_meeting, issue: issue)
    end
  end

  shared_context '""removed"" zoom meetings' do
    before do
      create(:zoom_meeting, issue: issue, issue_status: :removed)
      create(:zoom_meeting, issue: issue, issue_status: :removed)
    end
  end

  shared_context 'insufficient issue update permissions' do
    before do
      project.add_guest(user)
    end
  end

  shared_context 'insufficient issue create permissions' do
    before do
      expect(service).to receive(:can?).with(user, :create_issue, project).and_return(false)
    end
  end

  describe '#add_link' do
    shared_examples 'can add meeting' do
      it 'appends the new meeting to zoom_meetings' do
        expect(result).to be_success
        expect(ZoomMeeting.canonical_meeting_url(issue)).to eq(zoom_link)
      end

      it 'tracks the add event', :snowplow do
        result

        expect_snowplow_event(
          category: 'IncidentManagement::ZoomIntegration',
          action: 'add_zoom_meeting',
          label: 'Issue ID',
          value: issue.id,
          user: user,
          project: project,
          namespace: project.namespace
        )
      end

      it 'creates a zoom_link_added notification' do
        expect(SystemNoteService).to receive(:zoom_link_added).with(issue, project, user)
        expect(SystemNoteService).not_to receive(:zoom_link_removed)
        result
      end
    end

    shared_examples 'cannot add meeting' do
      it 'cannot add the meeting' do
        expect(result).to be_error
        expect(result.message).to eq('Failed to add a Zoom meeting')
      end

      it 'creates no notification' do
        expect(SystemNoteService).not_to receive(:zoom_link_added)
        expect(SystemNoteService).not_to receive(:zoom_link_removed)
        result
      end
    end

    subject(:result) { service.add_link(zoom_link) }

    context 'without existing Zoom meeting' do
      context 'when updating an issue' do
        before do
          allow(issue).to receive(:persisted?).and_return(true)
        end

        include_examples 'can add meeting'

        context 'issue is incident type' do
          let(:issue) { create(:incident) }
          let(:current_user) { user }

          it_behaves_like 'an incident management tracked event', :incident_management_incident_zoom_meeting

          it_behaves_like 'Snowplow event tracking with RedisHLL context' do
            let(:namespace) { issue.namespace }
            let(:category) { described_class.to_s }
            let(:action) { 'incident_management_incident_zoom_meeting' }
            let(:label) { 'redis_hll_counters.incident_management.incident_management_total_unique_counts_monthly' }
          end
        end

        context 'with insufficient issue update permissions' do
          include_context 'insufficient issue update permissions'
          include_examples 'cannot add meeting'
        end
      end

      context 'when creating an issue' do
        before do
          allow(issue).to receive(:persisted?).and_return(false)
        end

        it 'creates a new zoom meeting' do
          expect(result).to be_success
          expect(result.payload[:zoom_meetings][0].url).to eq(zoom_link)
        end

        context 'with insufficient issue create permissions' do
          include_context 'insufficient issue create permissions'
          include_examples 'cannot add meeting'
        end
      end

      context 'with invalid Zoom url' do
        let(:zoom_link) { 'https://not-zoom.link' }

        include_examples 'cannot add meeting'
      end
    end

    context 'with ""added"" Zoom meeting' do
      include_context '""added"" Zoom meeting'
      include_examples 'cannot add meeting'
    end

    context 'with ""added"" Zoom meeting and race condition' do
      include_context '""added"" Zoom meeting'
      before do
        allow(service).to receive(:can_add_link?).and_return(true)
        allow(issue).to receive(:persisted?).and_return(true)
      end

      include_examples 'cannot add meeting'
    end
  end

  describe '#can_add_link?' do
    subject { service.can_add_link? }

    context 'without ""added"" zoom meeting' do
      it { is_expected.to eq(true) }

      context 'with insufficient issue update permissions' do
        include_context 'insufficient issue update permissions'

        it { is_expected.to eq(false) }
      end
    end

    context 'with Zoom meeting in the issue description' do
      include_context  '""added"" Zoom meeting'

      it { is_expected.to eq(false) }
    end
  end

  describe '#remove_link' do
    shared_examples 'cannot remove meeting' do
      it 'cannot remove the meeting' do
        expect(result).to be_error
        expect(result.message).to eq('Failed to remove a Zoom meeting')
      end

      it 'creates no notification' do
        expect(SystemNoteService).not_to receive(:zoom_link_added)
        expect(SystemNoteService).not_to receive(:zoom_link_removed)
        result
      end
    end

    shared_examples 'can remove meeting' do
      it 'creates no notification' do
        expect(SystemNoteService).not_to receive(:zoom_link_added).with(issue, project, user)
        expect(SystemNoteService).to receive(:zoom_link_removed)
        result
      end

      it 'can remove the meeting' do
        expect(result).to be_success
        expect(ZoomMeeting.canonical_meeting_url(issue)).to eq(nil)
      end

      it 'tracks the remove event', :snowplow do
        result

        expect_snowplow_event(
          category: 'IncidentManagement::ZoomIntegration',
          action: 'remove_zoom_meeting',
          label: 'Issue ID',
          value: issue.id,
          user: user,
          project: project,
          namespace: project.namespace
        )
      end
    end

    subject(:result) { service.remove_link }

    context 'with Zoom meeting' do
      include_context '""added"" Zoom meeting'

      context 'with existing issue' do
        before do
          allow(issue).to receive(:persisted?).and_return(true)
        end

        include_examples 'can remove meeting'
      end

      context 'without existing issue' do
        before do
          allow(issue).to receive(:persisted?).and_return(false)
        end

        include_examples 'cannot remove meeting'
      end

      context 'with insufficient issue update permissions' do
        include_context 'insufficient issue update permissions'
        include_examples 'cannot remove meeting'
      end
    end

    context 'without ""added"" Zoom meeting' do
      include_context '""removed"" zoom meetings'
      include_examples 'cannot remove meeting'
    end
  end

  describe '#can_remove_link?' do
    subject { service.can_remove_link? }

    context 'without Zoom meeting' do
      it { is_expected.to eq(false) }
    end

    context 'with only ""removed"" zoom meetings' do
      include_context '""removed"" zoom meetings'
      it { is_expected.to eq(false) }
    end

    context 'with ""added"" Zoom meeting' do
      include_context '""added"" Zoom meeting'
      it { is_expected.to eq(true) }

      context 'with ""removed"" zoom meetings' do
        include_context '""removed"" zoom meetings'
        it { is_expected.to eq(true) }
      end

      context 'with insufficient issue update permissions' do
        include_context 'insufficient issue update permissions'
        it { is_expected.to eq(false) }
      end
    end
  end

  describe '#parse_link' do
    subject { service.parse_link(description) }

    context 'with valid Zoom links' do
      where(:description) do
        [
          'Some text https://zoom.us/j/123456789 more text',
          'Mixed https://zoom.us/j/123456789 http://example.com',
          'Multiple link https://zoom.us/my/name https://zoom.us/j/123456789'
        ]
      end

      with_them do
        it { is_expected.to eq('https://zoom.us/j/123456789') }
      end
    end

    context 'with invalid Zoom links' do
      where(:description) do
        [
          nil,
          '',
          'Text only',
          'Non-Zoom http://example.com',
          'Almost Zoom http://zoom.us'
        ]
      end

      with_them do
        it { is_expected.to eq(nil) }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Issues
  class UpdateService < Issues::BaseService
    # NOTE: For Issues::UpdateService, we default perform_spam_check to false, because spam_checking is not
    # necessary in many cases, and we don't want to require every caller to explicitly pass it
    # to disable spam checking.
    def initialize(container:, current_user: nil, params: {}, perform_spam_check: false)
      super(container: container, current_user: current_user, params: params)
      @perform_spam_check = perform_spam_check
    end

    def execute(issue)
      handle_move_between_ids(issue)

      change_issue_duplicate(issue)
      move_issue_to_new_project(issue) || clone_issue(issue) || update_task_event(issue) || update(issue)
    end

    def update(issue)
      create_merge_request_from_quick_action

      super
    end

    def before_update(issue, skip_spam_check: false)
      change_work_item_type(issue)

      return if skip_spam_check || !perform_spam_check

      issue.check_for_spam(user: current_user, action: :update)
    end

    def change_work_item_type(issue)
      return unless params[:issue_type].present?

      type_id = find_work_item_type_id(params[:issue_type])

      issue.work_item_type_id = type_id
    end

    def handle_changes(issue, options)
      super
      old_associations = options.fetch(:old_associations, {})
      old_labels = old_associations.fetch(:labels, [])
      old_mentioned_users = old_associations.fetch(:mentioned_users, [])
      old_assignees = old_associations.fetch(:assignees, [])
      old_severity = old_associations[:severity]

      if has_changes?(issue, old_labels: old_labels, old_assignees: old_assignees)
        todo_service.resolve_todos_for_target(issue, current_user)
      end

      if issue.previous_changes.include?('title') ||
          issue.previous_changes.include?('description')
        todo_service.update_issue(issue, current_user, old_mentioned_users)
      end

      handle_assignee_changes(issue, old_assignees)
      handle_confidential_change(issue)
      handle_added_labels(issue, old_labels)
      handle_added_mentions(issue, old_mentioned_users)
      handle_severity_change(issue, old_severity)
      handle_escalation_status_change(issue)
      handle_issue_type_change(issue)
      handle_date_changes(issue)
    end

    def handle_assignee_changes(issue, old_assignees)
      return if issue.assignees == old_assignees

      create_assignee_note(issue, old_assignees)
      Gitlab::ResourceEvents::AssignmentEventRecorder.new(parent: issue, old_assignees: old_assignees).record
      notification_service.async.reassigned_issue(issue, current_user, old_assignees)
      todo_service.reassigned_assignable(issue, current_user, old_assignees)
      track_incident_action(current_user, issue, :incident_assigned)

      GraphqlTriggers.issuable_assignees_updated(issue)
    end

    def handle_task_changes(issuable)
      todo_service.resolve_todos_for_target(issuable, current_user)
      todo_service.update_issue(issuable, current_user)
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def change_issue_duplicate(issue)
      canonical_issue_id = params.delete(:canonical_issue_id)
      return unless canonical_issue_id

      canonical_issue = IssuesFinder.new(current_user).find_by(id: canonical_issue_id)

      if canonical_issue
        Issues::DuplicateService.new(container: project, current_user: current_user).execute(issue, canonical_issue)
      end
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def move_issue_to_new_project(issue)
      target_project = params.delete(:target_project)

      return unless target_project &&
          issue.can_move?(current_user, target_project) &&
          target_project != issue.project

      update(issue)
      Issues::MoveService.new(container: project, current_user: current_user).execute(issue, target_project)
    end

    private

    attr_reader :perform_spam_check

    override :after_update
    def after_update(issue, _old_associations)
      super

      GraphqlTriggers.work_item_updated(issue)
    end

    def handle_date_changes(issue)
      return unless issue.previous_changes.slice('due_date', 'start_date').any?

      GraphqlTriggers.issuable_dates_updated(issue)
    end

    def clone_issue(issue)
      target_project = params.delete(:target_clone_project)
      with_notes = params.delete(:clone_with_notes)

      return unless target_project &&
        issue.can_clone?(current_user, target_project)

      # we've pre-empted this from running in #execute, so let's go ahead and update the Issue now.
      update(issue)
      Issues::CloneService.new(container: project, current_user: current_user).execute(issue, target_project, with_notes: with_notes)
    end

    def create_merge_request_from_quick_action
      create_merge_request_params = params.delete(:create_merge_request)
      return unless create_merge_request_params

      MergeRequests::CreateFromIssueService.new(project: project, current_user: current_user, mr_params: create_merge_request_params).execute
    end

    def handle_confidential_change(issue)
      if issue.previous_changes.include?('confidential')
        # don't enqueue immediately to prevent todos removal in case of a mistake
        TodosDestroyer::ConfidentialIssueWorker.perform_in(Todo::WAIT_FOR_DELETE, issue.id) if issue.confidential?
        create_confidentiality_note(issue)
        track_incident_action(current_user, issue, :incident_change_confidential)
      end
    end

    def handle_added_labels(issue, old_labels)
      added_labels = issue.labels - old_labels

      if added_labels.present?
        notification_service.async.relabeled_issue(issue, added_labels, current_user)
      end
    end

    def handle_added_mentions(issue, old_mentioned_users)
      added_mentions = issue.mentioned_users(current_user) - old_mentioned_users

      if added_mentions.present?
        notification_service.async.new_mentions_in_issue(issue, added_mentions, current_user)
      end
    end

    def handle_severity_change(issue, old_severity)
      return unless old_severity && issue.severity != old_severity

      ::IncidentManagement::AddSeveritySystemNoteWorker.perform_async(issue.id, current_user.id)
    end

    def create_confidentiality_note(issue)
      SystemNoteService.change_issue_confidentiality(issue, issue.project, current_user)
    end

    def handle_issue_type_change(issue)
      return unless issue.previous_changes.include?('work_item_type_id')

      do_handle_issue_type_change(issue)
    end

    def do_handle_issue_type_change(issue)
      old_work_item_type = ::WorkItems::Type.find(issue.work_item_type_id_before_last_save).base_type
      SystemNoteService.change_issue_type(issue, current_user, old_work_item_type)

      ::IncidentManagement::IssuableEscalationStatuses::CreateService.new(issue).execute if issue.supports_escalation?
    end

    override :allowed_update_params
    def allowed_update_params(params)
      super.except(:issue_type)
    end
  end
end

Issues::UpdateService.prepend_mod_with('Issues::UpdateService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issues::UpdateService, :mailer, feature_category: :team_planning do
  let_it_be(:user) { create(:user) }
  let_it_be(:user2) { create(:user) }
  let_it_be(:user3) { create(:user) }
  let_it_be(:guest) { create(:user) }
  let_it_be(:group) { create(:group, :public, :crm_enabled) }
  let_it_be(:project, reload: true) { create(:project, :repository, group: group) }
  let_it_be(:label) { create(:label, title: 'a', project: project) }
  let_it_be(:label2) { create(:label, title: 'b', project: project) }
  let_it_be(:label3) { create(:label, title: 'c', project: project) }
  let_it_be(:milestone) { create(:milestone, project: project) }

  let(:container) { project }
  let(:issue) do
    create(
      :issue,
      title: 'Old title',
      description: ""for #{user2.to_reference}"",
      assignee_ids: [user3.id],
      project: project,
      author: create(:user)
    )
  end

  before_all do
    group.add_maintainer(user)
    group.add_developer(user2)
    group.add_developer(user3)
    group.add_guest(guest)
  end

  describe 'execute' do
    let_it_be(:contact) { create(:contact, group: group) }

    def find_note(starting_with)
      issue.notes.find do |note|
        note && note.note.start_with?(starting_with)
      end
    end

    def find_notes(action)
      issue
        .notes
        .joins(:system_note_metadata)
        .where(system_note_metadata: { action: action })
    end

    def update_issue(opts)
      described_class.new(container: container, current_user: user, params: opts).execute(issue)
    end

    it_behaves_like 'issuable update service updating last_edited_at values' do
      let(:issuable) { issue }
      subject(:update_issuable) { update_issue(update_params) }
    end

    context 'valid params' do
      let(:opts) do
        {
          title: 'New title',
          description: 'Also please fix',
          assignee_ids: [user2.id],
          state_event: 'close',
          label_ids: [label&.id],
          due_date: Date.tomorrow,
          discussion_locked: true,
          severity: 'low',
          milestone_id: milestone.id,
          add_contacts: [contact.email]
        }
      end

      context 'when an unauthorized project_id is provided' do
        let(:unauthorized_project) { create(:project) }

        before do
          opts[:project_id] = unauthorized_project.id
        end

        it 'ignores the project_id param and does not update the issue\'s project' do
          expect do
            update_issue(opts)
            unauthorized_project.reload
          end.to not_change { unauthorized_project.issues.count }

          expect(issue.project).to eq(project)
        end
      end

      it 'updates the issue with the given params' do
        expect(TodosDestroyer::ConfidentialIssueWorker).not_to receive(:perform_in)

        update_issue(opts)

        expect(issue).to be_valid
        expect(issue.title).to eq 'New title'
        expect(issue.description).to eq 'Also please fix'
        expect(issue.assignees).to match_array([user2])
        expect(issue).to be_closed
        expect(issue.labels).to match_array [label]
        expect(issue.due_date).to eq Date.tomorrow
        expect(issue.discussion_locked).to be_truthy
        expect(issue.confidential).to be_falsey
        expect(issue.milestone).to eq milestone
        expect(issue.issue_customer_relations_contacts.last.contact).to eq contact
      end

      it_behaves_like 'update service that triggers GraphQL work_item_updated subscription' do
        subject(:execute_service) { update_issue(opts) }
      end

      context 'when updating milestone' do
        before do
          update_issue({ milestone_id: nil })
        end

        it 'updates issue milestone when passing `milestone` param' do
          expect { update_issue({ milestone_id: milestone.id }) }
            .to change(issue, :milestone).to(milestone).from(nil)
        end

        it ""triggers 'issuableMilestoneUpdated'"" do
          expect(GraphqlTriggers).to receive(:issuable_milestone_updated).with(issue).and_call_original

          update_issue({ milestone_id: milestone.id })
        end

        context 'when milestone remains unchanged' do
          before do
            update_issue({ title: 'abc', milestone_id: milestone.id })
          end

          it ""does not trigger 'issuableMilestoneUpdated'"" do
            expect(GraphqlTriggers).not_to receive(:issuable_milestone_updated)

            update_issue({ milestone_id: milestone.id })
          end
        end
      end

      context 'when sentry identifier is given' do
        before do
          sentry_attributes = { sentry_issue_attributes: { sentry_issue_identifier: 42 } }
          opts.merge!(sentry_attributes)
        end

        it 'assigns the sentry error' do
          update_issue(opts)

          expect(issue.sentry_issue).to be_kind_of(SentryIssue)
        end

        context 'user is a guest' do
          let(:user) { guest }

          it 'does not assign the sentry error' do
            update_issue(opts)

            expect(issue.sentry_issue).to eq(nil)
          end
        end
      end

      context 'when issue type is not incident' do
        before do
          update_issue(opts)
        end

        it_behaves_like 'not an incident issue'

        context 'when confidentiality is changed' do
          subject { update_issue(confidential: true) }

          it_behaves_like 'does not track incident management event'
        end
      end

      context 'when issue type is incident' do
        let(:issue) { create(:incident, project: project) }

        before do
          update_issue(opts)
        end

        it_behaves_like 'incident issue'

        it 'does not add an incident label' do
          expect(issue.labels).to match_array [label]
        end

        context 'when confidentiality is changed' do
          let(:current_user) { user }

          subject { update_issue(confidential: true) }

          it_behaves_like 'an incident management tracked event', :incident_management_incident_change_confidential

          it_behaves_like 'Snowplow event tracking with RedisHLL context' do
            let(:namespace) { issue.namespace }
            let(:category) { described_class.to_s }
            let(:label) { 'redis_hll_counters.incident_management.incident_management_total_unique_counts_monthly' }
            let(:action) { 'incident_management_incident_change_confidential' }
            let(:opts) do
              {
                title: 'New title',
                description: 'Also please fix',
                assignee_ids: [user2.id],
                state_event: 'close',
                due_date: Date.tomorrow,
                discussion_locked: true,
                severity: 'low',
                milestone_id: milestone.id,
                add_contacts: [contact.email]
              }
            end
          end
        end
      end

      it 'refreshes the number of open issues when the issue is made confidential', :use_clean_rails_memory_store_caching do
        issue # make sure the issue is created first so our counts are correct.

        expect do
          update_issue(confidential: true)

          BatchLoader::Executor.clear_current
        end.to change { project.open_issues_count }.from(1).to(0)
      end

      it 'enqueues ConfidentialIssueWorker when an issue is made confidential' do
        expect(TodosDestroyer::ConfidentialIssueWorker).to receive(:perform_in).with(Todo::WAIT_FOR_DELETE, issue.id)

        update_issue(confidential: true)

        expect(issue.confidential).to be_truthy
      end

      it 'does not enqueue ConfidentialIssueWorker when an issue is made non confidential' do
        # set confidentiality to true before the actual update
        issue.update!(confidential: true)

        expect(TodosDestroyer::ConfidentialIssueWorker).not_to receive(:perform_in)

        update_issue(confidential: false)

        expect(issue.confidential).to be_falsey
      end

      context 'changing issue_type' do
        let!(:label_1) { create(:label, project: project, title: 'incident') }
        let!(:label_2) { create(:label, project: project, title: 'missed-sla') }

        before do
          stub_licensed_features(quality_management: true)
        end

        context 'from issue to incident' do
          it_behaves_like 'incident issue' do
            before do
              update_issue(**opts, issue_type: 'incident')
            end
          end

          it 'creates system note about issue type' do
            update_issue(issue_type: 'incident')

            note = find_note('changed type from issue to incident')

            expect(note).not_to eq(nil)
          end

          it 'creates an escalation status' do
            expect { update_issue(issue_type: 'incident') }
            .to change { issue.reload.incident_management_issuable_escalation_status }
            .from(nil)
            .to(a_kind_of(IncidentManagement::IssuableEscalationStatus))
          end

          context 'for an issue with multiple labels' do
            let(:issue) { create(:incident, project: project, labels: [label_1]) }

            before do
              update_issue(issue_type: 'incident')
            end

            it 'does not add an `incident` label if one already exist' do
              expect(issue.labels).to eq([label_1])
            end
          end
        end

        context 'from incident to issue' do
          let(:issue) { create(:incident, project: project) }

          it 'changed from an incident to an issue type' do
            expect { update_issue(issue_type: 'issue') }
              .to change(issue, :issue_type).from('incident').to('issue')
              .and(change { issue.work_item_type.base_type }.from('incident').to('issue'))
          end

          context 'for an incident with multiple labels' do
            let(:issue) { create(:incident, project: project, labels: [label_1, label_2]) }

            it 'does not remove an `incident` label if one exists on the incident' do
              expect { update_issue(issue_type: 'issue') }.to not_change(issue, :label_ids)
            end
          end

          context 'filtering the incident label' do
            let(:issue) { create(:incident, project: project, labels: [label_1, label_2]) }
            let(:params) { { label_ids: [label_1.id, label_2.id], remove_label_ids: [] } }

            it 'does not add an incident label id to remove_label_ids for it to be removed' do
              expect { update_issue(issue_type: 'issue') }.to not_change(issue, :label_ids)
            end
          end
        end

        context 'from issue to restricted issue types' do
          context 'without sufficient permissions' do
            let(:user) { guest }

            it 'does nothing to the labels' do
              expect { update_issue(issue_type: 'issue') }.not_to change(issue.labels, :count)
              expect(issue.reload.labels).to eq([])
            end
          end
        end
      end

      it 'updates open issue counter for assignees when issue is reassigned' do
        update_issue(assignee_ids: [user2.id])

        expect(user3.assigned_open_issues_count).to eq 0
        expect(user2.assigned_open_issues_count).to eq 1
      end

      context 'when changing relative position' do
        let(:issue1) { create(:issue, project: project, assignees: [user3]) }
        let(:issue2) { create(:issue, project: project, assignees: [user3]) }

        before do
          [issue, issue1, issue2].each do |issue|
            issue.move_to_end
            issue.save!
          end
        end

        it 'sorts issues as specified by parameters' do
          opts[:move_between_ids] = [issue1.id, issue2.id]

          update_issue(opts)

          expect(issue.relative_position).to be_between(issue1.relative_position, issue2.relative_position)
        end

        context 'when block_issue_positioning flag is enabled' do
          before do
            stub_feature_flags(block_issue_repositioning: true)
          end

          it 'raises error' do
            old_position = issue.relative_position
            opts[:move_between_ids] = [issue1.id, issue2.id]

            expect { update_issue(opts) }.to raise_error(::Gitlab::RelativePositioning::IssuePositioningDisabled)
            expect(issue.reload.relative_position).to eq(old_position)
          end
        end
      end

      it 'rebalances if needed on the left' do
        range = described_class::NO_REBALANCING_NEEDED
        issue1 = create(:issue, project: project, relative_position: range.first - 100)
        issue2 = create(:issue, project: project, relative_position: range.first)
        issue.update!(relative_position: RelativePositioning::START_POSITION)

        opts[:move_between_ids] = [issue1.id, issue2.id]

        expect(Issues::RebalancingWorker).to receive(:perform_async).with(nil, nil, project.root_namespace.id)

        update_issue(opts)
        expect(issue.relative_position).to be_between(issue1.relative_position, issue2.relative_position)
      end

      it 'rebalances if needed on the right' do
        range = described_class::NO_REBALANCING_NEEDED
        issue1 = create(:issue, project: project, relative_position: range.last)
        issue2 = create(:issue, project: project, relative_position: range.last + 100)
        issue.update!(relative_position: RelativePositioning::START_POSITION)

        opts[:move_between_ids] = [issue1.id, issue2.id]

        expect(Issues::RebalancingWorker).to receive(:perform_async).with(nil, nil, project.root_namespace.id)

        update_issue(opts)
        expect(issue.relative_position).to be_between(issue1.relative_position, issue2.relative_position)
      end

      context 'when moving issue between issues from different projects' do
        let(:group) { create(:group) }
        let(:subgroup) { create(:group, parent: group) }

        let(:project_1) { create(:project, namespace: group) }
        let(:project_2) { create(:project, namespace: group) }
        let(:project_3) { create(:project, namespace: subgroup) }

        let(:issue_1) { create(:issue, project: project_1) }
        let(:issue_2) { create(:issue, project: project_2) }
        let(:issue_3) { create(:issue, project: project_3) }

        before do
          group.add_developer(user)
        end

        it 'sorts issues as specified by parameters' do
          # Moving all issues to end here like the last example won't work since
          # all projects only have the same issue count
          # so their relative_position will be the same.
          issue_1.move_to_end
          issue_2.move_after(issue_1)
          issue_3.move_after(issue_2)
          [issue_1, issue_2, issue_3].map(&:save)

          opts[:move_between_ids] = [issue_1.id, issue_2.id]

          described_class.new(container: issue_3.project, current_user: user, params: opts).execute(issue_3)
          expect(issue_2.relative_position).to be_between(issue_1.relative_position, issue_2.relative_position)
        end
      end

      context 'when current user cannot admin issues in the project' do
        it 'filters out params that cannot be set without the :admin_issue permission' do
          described_class.new(
            container: project, current_user: guest, params: opts.merge(
              confidential: true,
              issue_type: 'test_case'
            )
          ).execute(issue)

          expect(issue).to be_valid
          expect(issue.title).to eq 'New title'
          expect(issue.description).to eq 'Also please fix'
          expect(issue.assignees).to match_array [user3]
          expect(issue.labels).to be_empty
          expect(issue.milestone).to be_nil
          expect(issue.due_date).to be_nil
          expect(issue.discussion_locked).to be_falsey
          expect(issue.confidential).to be_falsey
          expect(issue.issue_type).to eql('issue')
        end
      end

      context 'with background jobs processed', :sidekiq_might_not_need_inline do
        before do
          perform_enqueued_jobs do
            update_issue(opts)
          end
        end

        it 'sends email to user2 about assign of new issue and email to user3 about issue unassignment' do
          deliveries = ActionMailer::Base.deliveries
          email = deliveries.last
          recipients = deliveries.last(2).flat_map(&:to)
          expect(recipients).to include(user2.email, user3.email)
          expect(email.subject).to include(issue.title)
        end

        it 'creates system note about issue reassign' do
          note = find_note('assigned to')

          expect(note.note).to include ""assigned to #{user2.to_reference}""
        end

        it 'creates a resource label event' do
          event = issue.resource_label_events.last

          expect(event).not_to be_nil
          expect(event.label_id).to eq label.id
          expect(event.user_id).to eq user.id
        end

        it 'creates system note about title change' do
          note = find_note('changed title')

          expect(note.note).to eq 'changed title from **{-Old-} title** to **{+New+} title**'
        end

        it 'creates system note about discussion lock' do
          note = find_note('locked the discussion in this issue')

          expect(note.note).to eq 'locked the discussion in this issue'
        end
      end

      context 'after_save callback to store_mentions' do
        let(:issue) { create(:issue, title: 'Old title', description: ""simple description"", project: project, author: create(:user)) }
        let(:labels) { create_pair(:label, project: project) }
        let(:milestone) { create(:milestone, project: project) }

        context 'when mentionable attributes change' do
          let(:opts) { { description: ""Description with #{user.to_reference}"" } }

          it 'saves mentions' do
            expect(issue).to receive(:store_mentions!).and_call_original

            expect { update_issue(opts) }.to change { IssueUserMention.count }.by(1)

            expect(issue.referenced_users).to match_array([user])
          end
        end

        context 'when mentionable attributes do not change' do
          let(:opts) { { label_ids: labels.map(&:id), milestone_id: milestone.id } }

          it 'does not call store_mentions' do
            expect(issue).not_to receive(:store_mentions!).and_call_original

            expect { update_issue(opts) }.not_to change { IssueUserMention.count }

            expect(issue.referenced_users).to be_empty
          end
        end

        context 'when save fails' do
          let(:opts) { { title: '', label_ids: labels.map(&:id), milestone_id: milestone.id } }

          it 'does not call store_mentions' do
            expect(issue).not_to receive(:store_mentions!).and_call_original

            expect { update_issue(opts) }.not_to change { IssueUserMention.count }

            expect(issue.referenced_users).to be_empty
            expect(issue.valid?).to be false
          end
        end
      end
    end

    context 'when description changed' do
      it 'creates system note about description change' do
        update_issue(description: 'Changed description')

        note = find_note('changed the description')

        expect(note.note).to eq('changed the description')
      end

      it 'triggers GraphQL description updated subscription' do
        expect(GraphqlTriggers).to receive(:issuable_description_updated).with(issue).and_call_original

        update_issue(description: 'Changed description')
      end
    end

    context 'when description is not changed' do
      it 'does not trigger GraphQL description updated subscription' do
        expect(GraphqlTriggers).not_to receive(:issuable_description_updated)

        update_issue(title: 'Changed title')
      end
    end

    context 'when issue turns confidential' do
      let(:opts) do
        {
          title: 'New title',
          description: 'Also please fix',
          assignee_ids: [user2],
          state_event: 'close',
          label_ids: [label.id],
          confidential: true
        }
      end

      it 'creates system note about confidentiality change' do
        update_issue(confidential: true)

        note = find_note('made the issue confidential')

        expect(note.note).to eq 'made the issue confidential'
      end

      it 'executes confidential issue hooks' do
        expect(project.project_namespace).to receive(:execute_hooks).with(an_instance_of(Hash), :confidential_issue_hooks)
        expect(project.project_namespace).to receive(:execute_integrations).with(an_instance_of(Hash), :confidential_issue_hooks)

        update_issue(confidential: true)
      end

      it 'does not update assignee_id with unauthorized users' do
        project.update!(visibility_level: Gitlab::VisibilityLevel::PUBLIC)
        update_issue(confidential: true)
        non_member = create(:user)
        original_assignees = issue.assignees

        update_issue(assignee_ids: [non_member.id])

        expect(issue.reload.assignees).to eq(original_assignees)
      end
    end

    context 'todos' do
      let!(:todo) { create(:todo, :assigned, user: user, project: project, target: issue, author: user2) }

      context 'when the title change' do
        before do
          update_issue(title: 'New title')
        end

        it 'marks pending todos as done' do
          expect(todo.reload.done?).to eq true
        end

        it 'does not create any new todos' do
          expect(Todo.count).to eq(1)
        end
      end

      context 'when the description change' do
        before do
          update_issue(description: ""Also please fix #{user2.to_reference} #{user3.to_reference}"")
        end

        it 'marks todos as done' do
          expect(todo.reload.done?).to eq true
        end

        it 'creates only 1 new todo' do
          expect(Todo.count).to eq(2)
        end
      end

      context 'when is reassigned' do
        before do
          update_issue(assignees: [user2])
        end

        it 'marks previous assignee todos as done' do
          expect(todo.reload.done?).to eq true
        end

        it 'creates a todo for new assignee' do
          attributes = {
            project: project,
            author: user,
            user: user2,
            target_id: issue.id,
            target_type: issue.class.name,
            action: Todo::ASSIGNED,
            state: :pending
          }

          expect(Todo.where(attributes).count).to eq 1
        end
      end

      context 'when a new assignee added' do
        subject { update_issue(assignees: issue.assignees + [user2]) }

        it 'creates only 1 new todo' do
          expect { subject }.to change { Todo.count }.by(1)
        end

        it 'creates a todo for new assignee' do
          subject

          attributes = {
            project: project,
            author: user,
            user: user2,
            target_id: issue.id,
            target_type: issue.class.name,
            action: Todo::ASSIGNED,
            state: :pending
          }

          expect(Todo.where(attributes).count).to eq(1)
        end

        context 'issue is incident type' do
          let(:issue) { create(:incident, project: project) }
          let(:current_user) { user }

          it_behaves_like 'an incident management tracked event', :incident_management_incident_assigned

          it_behaves_like 'Snowplow event tracking with RedisHLL context' do
            let(:namespace) { issue.namespace }
            let(:category) { described_class.to_s }
            let(:label) { 'redis_hll_counters.incident_management.incident_management_total_unique_counts_monthly' }
            let(:action) { ""incident_management_incident_assigned"" }
          end
        end
      end

      context 'when the milestone is removed' do
        let!(:non_subscriber) { create(:user) }

        let!(:subscriber) do
          create(:user) do |u|
            issue.toggle_subscription(u, project)
            project.add_developer(u)
          end
        end

        it 'sends notifications for subscribers of changed milestone', :sidekiq_might_not_need_inline do
          issue.milestone = create(:milestone, project: project)

          issue.save!

          perform_enqueued_jobs do
            update_issue(milestone_id: """")
          end

          should_email(subscriber)
          should_not_email(non_subscriber)
        end

        it 'clears milestone issue counters cache' do
          issue.milestone = create(:milestone, project: project)

          issue.save!

          expect_next_instance_of(Milestones::IssuesCountService, issue.milestone) do |service|
            expect(service).to receive(:delete_cache).and_call_original
          end
          expect_next_instance_of(Milestones::ClosedIssuesCountService, issue.milestone) do |service|
            expect(service).to receive(:delete_cache).and_call_original
          end

          update_issue(milestone_id: """")
        end
      end

      context 'when the milestone is assigned' do
        let!(:non_subscriber) { create(:user) }

        let!(:subscriber) do
          create(:user) do |u|
            issue.toggle_subscription(u, project)
            project.add_developer(u)
          end
        end

        it 'marks todos as done' do
          update_issue(milestone_id: create(:milestone, project: project).id)

          expect(todo.reload.done?).to eq true
        end

        it 'sends notifications for subscribers of changed milestone', :sidekiq_might_not_need_inline do
          perform_enqueued_jobs do
            update_issue(milestone_id: create(:milestone, project: project).id)
          end

          should_email(subscriber)
          should_not_email(non_subscriber)
        end

        it 'deletes issue counters cache for the milestone' do
          milestone = create(:milestone, project: project)

          expect_next_instance_of(Milestones::IssuesCountService, milestone) do |service|
            expect(service).to receive(:delete_cache).and_call_original
          end
          expect_next_instance_of(Milestones::ClosedIssuesCountService, milestone) do |service|
            expect(service).to receive(:delete_cache).and_call_original
          end

          update_issue(milestone_id: milestone.id)
        end
      end

      context 'when the milestone is changed' do
        it 'deletes issue counters cache for both milestones' do
          old_milestone = create(:milestone, project: project)
          new_milestone = create(:milestone, project: project)

          issue.update!(milestone: old_milestone)

          expect_next_instance_of(Milestones::IssuesCountService, old_milestone) do |service|
            expect(service).to receive(:delete_cache).and_call_original
          end
          expect_next_instance_of(Milestones::ClosedIssuesCountService, old_milestone) do |service|
            expect(service).to receive(:delete_cache).and_call_original
          end
          expect_next_instance_of(Milestones::IssuesCountService, new_milestone) do |service|
            expect(service).to receive(:delete_cache).and_call_original
          end
          expect_next_instance_of(Milestones::ClosedIssuesCountService, new_milestone) do |service|
            expect(service).to receive(:delete_cache).and_call_original
          end

          update_issue(milestone_id: new_milestone.id)
        end
      end

      context 'when the labels change' do
        before do
          travel_to(1.minute.from_now) do
            update_issue(label_ids: [label.id])
          end
        end

        it 'marks todos as done' do
          expect(todo.reload.done?).to eq true
        end

        it 'updates updated_at' do
          expect(issue.reload.updated_at).to be_future
        end
      end
    end

    context 'when the issue is relabeled' do
      let!(:non_subscriber) { create(:user) }

      let!(:subscriber) do
        create(:user) do |u|
          label.toggle_subscription(u, project)
          project.add_developer(u)
        end
      end

      it 'sends notifications for subscribers of newly added labels', :sidekiq_might_not_need_inline do
        opts = { label_ids: [label.id] }

        perform_enqueued_jobs do
          @issue = described_class.new(container: project, current_user: user, params: opts).execute(issue)
        end

        should_email(subscriber)
        should_not_email(non_subscriber)
      end

      context 'when issue has the `label` label' do
        before do
          issue.labels << label
        end

        it 'does not send notifications for existing labels' do
          opts = { label_ids: [label.id, label2.id] }

          perform_enqueued_jobs do
            @issue = described_class.new(container: project, current_user: user, params: opts).execute(issue)
          end

          should_not_email(subscriber)
          should_not_email(non_subscriber)
        end

        it 'does not send notifications for removed labels' do
          opts = { label_ids: [label2.id] }

          perform_enqueued_jobs do
            @issue = described_class.new(container: project, current_user: user, params: opts).execute(issue)
          end

          should_not_email(subscriber)
          should_not_email(non_subscriber)
        end
      end
    end

    context 'when issue has tasks' do
      before do
        update_issue(description: ""- [ ] Task 1\n- [ ] Task 2"")
      end

      it { expect(issue.tasks?).to eq(true) }

      it_behaves_like 'updating a single task'

      context 'when tasks are marked as completed' do
        before do
          update_issue(description: ""- [x] Task 1\n- [X] Task 2"")
        end

        it 'does not check for spam on task status change' do
          params = {
            update_task: {
              index: 1,
              checked: false,
              line_source: '- [x] Task 1',
              line_number: 1
            }
          }
          service = described_class.new(container: project, current_user: user, params: params)

          expect(issue).not_to receive(:check_for_spam)

          service.execute(issue)
        end

        # At the moment of writting old associations are not necessary for update_task
        # and doing this will prevent fetching associations from the DB and comparing old and new labels
        it 'does not pass old_associations to the after_update method' do
          params = {
            update_task: {
              index: 1,
              checked: false,
              line_source: '- [x] Task 1',
              line_number: 1
            }
          }
          service = described_class.new(container: project, current_user: user, params: params)

          expect(service).to receive(:after_update).with(issue, {})

          service.execute(issue)
        end

        it 'creates system note about task status change' do
          note1 = find_note('marked the checklist item **Task 1** as completed')
          note2 = find_note('marked the checklist item **Task 2** as completed')

          expect(note1).not_to be_nil
          expect(note2).not_to be_nil

          description_notes = find_notes('description')
          expect(description_notes.length).to eq(1)
        end
      end

      context 'when tasks are marked as incomplete' do
        before do
          update_issue(description: ""- [x] Task 1\n- [X] Task 2"")
          update_issue(description: ""- [ ] Task 1\n- [ ] Task 2"")
        end

        it 'creates system note about task status change' do
          note1 = find_note('marked the checklist item **Task 1** as incomplete')
          note2 = find_note('marked the checklist item **Task 2** as incomplete')

          expect(note1).not_to be_nil
          expect(note2).not_to be_nil

          description_notes = find_notes('description')
          expect(description_notes.length).to eq(1)
        end
      end

      context 'when tasks position has been modified' do
        before do
          update_issue(description: ""- [x] Task 1\n- [X] Task 2"")
          update_issue(description: ""- [x] Task 1\n- [ ] Task 3\n- [ ] Task 2"")
        end

        it 'does not create a system note for the task' do
          task_note = find_note('marked the checklist item **Task 2** as incomplete')
          description_notes = find_notes('description')

          expect(task_note).to be_nil
          expect(description_notes.length).to eq(2)
        end
      end

      context 'when a Task list with a completed item is totally replaced' do
        before do
          update_issue(description: ""- [ ] Task 1\n- [X] Task 2"")
          update_issue(description: ""- [ ] One\n- [ ] Two\n- [ ] Three"")
        end

        it 'does not create a system note referencing the position the old item' do
          task_note = find_note('marked the checklist item **Two** as incomplete')
          description_notes = find_notes('description')

          expect(task_note).to be_nil
          expect(description_notes.length).to eq(2)
        end

        it 'does not generate a new note at all' do
          expect do
            update_issue(description: ""- [ ] One\n- [ ] Two\n- [ ] Three"")
          end.not_to change { Note.count }
        end
      end
    end

    context 'updating labels' do
      let(:label_a) { label }
      let(:label_b) { label2 }
      let(:label_c) { label3 }
      let(:label_locked) { create(:label, title: 'locked', project: project, lock_on_merge: true) }
      let(:issuable) { issue }

      it_behaves_like 'updating issuable labels'
      it_behaves_like 'keeps issuable labels sorted after update'
      it_behaves_like 'broadcasting issuable labels updates'

      context 'when the issue belongs directly to a group' do
        let(:container) { group }

        it_behaves_like 'updating issuable labels'
      end

      def update_issuable(update_params)
        update_issue(update_params)
      end
    end

    context 'updating dates' do
      subject(:result) { described_class.new(container: project, current_user: user, params: params).execute(issue) }

      let(:updated_date) { 1.week.from_now.to_date }

      shared_examples 'issue update service that triggers date updates' do
        it 'triggers graphql date updated subscription' do
          expect(GraphqlTriggers).to receive(:issuable_dates_updated).with(issue).and_call_original

          result
        end
      end

      shared_examples 'issue update service that does not trigger date updates' do
        it 'does not trigger date updated subscriptions' do
          expect(GraphqlTriggers).not_to receive(:issuable_dates_updated)

          result
        end
      end

      context 'when due_date is updated' do
        let(:params) { { due_date: updated_date } }

        it_behaves_like 'issue update service that triggers date updates'
      end

      context 'when start_date is updated' do
        let(:params) { { start_date: updated_date } }

        it_behaves_like 'issue update service that triggers date updates'
      end

      context 'when no date is updated' do
        let(:params) { { title: 'should not trigger date updates' } }

        it_behaves_like 'issue update service that does not trigger date updates'
      end

      context 'when update is not successful but date is provided' do
        let(:params) { { title: '', due_date: updated_date } }

        it_behaves_like 'issue update service that does not trigger date updates'
      end
    end

    context 'updating asssignee_id' do
      it 'changes assignee' do
        expect_next_instance_of(NotificationService::Async) do |service|
          expect(service).to receive(:reassigned_issue).with(issue, user, [user3])
        end

        update_issue(assignee_ids: [user2.id])

        expect(issue.reload.assignees).to eq([user2])
      end

      it 'does not update assignee when assignee_id is invalid' do
        expect(NotificationService).not_to receive(:new)

        update_issue(assignee_ids: [-1])

        expect(issue.reload.assignees).to eq([user3])
      end

      it 'unassigns assignee when user id is 0' do
        expect_next_instance_of(NotificationService::Async) do |service|
          expect(service).to receive(:reassigned_issue).with(issue, user, [user3])
        end

        update_issue(assignee_ids: [0])

        expect(issue.reload.assignees).to be_empty
      end

      it 'does not update assignee_id when user cannot read issue' do
        expect(NotificationService).not_to receive(:new)

        update_issue(assignee_ids: [create(:user).id])

        expect(issue.reload.assignees).to eq([user3])
      end

      context ""when issuable feature is private"" do
        levels = [Gitlab::VisibilityLevel::INTERNAL, Gitlab::VisibilityLevel::PUBLIC]

        levels.each do |level|
          it ""does not update with unauthorized assignee when project is #{Gitlab::VisibilityLevel.level_name(level)}"" do
            expect(NotificationService).not_to receive(:new)

            assignee = create(:user)
            project.update!(visibility_level: level)
            feature_visibility_attr = :""#{issue.model_name.plural}_access_level""
            project.project_feature.update_attribute(feature_visibility_attr, ProjectFeature::PRIVATE)

            expect { update_issue(assignee_ids: [assignee.id]) }.not_to change { issue.assignees }
          end
        end
      end

      it 'tracks the assignment events' do
        original_assignee = issue.assignees.first!

        update_issue(assignee_ids: [user2.id])
        update_issue(assignee_ids: [])
        update_issue(assignee_ids: [user3.id])

        expected_events = [
          have_attributes({
            issue_id: issue.id,
            user_id: original_assignee.id,
            action: 'remove'
          }),
          have_attributes({
            issue_id: issue.id,
            user_id: user2.id,
            action: 'add'
          }),
          have_attributes({
            issue_id: issue.id,
            user_id: user2.id,
            action: 'remove'
          }),
          have_attributes({
            issue_id: issue.id,
            user_id: user3.id,
            action: 'add'
          })
        ]

        expect(issue.assignment_events).to match_array(expected_events)
      end
    end

    context 'updating mentions' do
      let(:mentionable) { issue }

      include_examples 'updating mentions', described_class
    end

    context 'updating severity' do
      let(:opts) { { severity: 'low' } }

      shared_examples 'updates the severity' do |expected_severity|
        it 'has correct value' do
          update_issue(opts)

          expect(issue.severity).to eq(expected_severity)
        end

        it 'creates a system note' do
          expect(::IncidentManagement::AddSeveritySystemNoteWorker).to receive(:perform_async).with(issue.id, user.id)

          update_issue(opts)
        end

        it 'triggers webhooks' do
          expect(project.project_namespace).to receive(:execute_hooks).with(an_instance_of(Hash), :issue_hooks)
          expect(project.project_namespace).to receive(:execute_integrations).with(an_instance_of(Hash), :issue_hooks)
          expect(project.project_namespace).to receive(:execute_integrations).with(an_instance_of(Hash), :incident_hooks)

          update_issue(opts)
        end
      end

      shared_examples 'does not change the severity' do
        it 'retains the original value' do
          expected_severity = issue.severity

          update_issue(opts)

          expect(issue.severity).to eq(expected_severity)
        end

        it 'does not trigger side-effects' do
          expect(::IncidentManagement::AddSeveritySystemNoteWorker).not_to receive(:perform_async)
          expect(project).not_to receive(:execute_hooks)
          expect(project).not_to receive(:execute_integrations)

          expect { update_issue(opts) }.not_to change(IssuableSeverity, :count)
        end
      end

      context 'on incidents' do
        let(:issue) { create(:incident, project: project) }

        context 'when severity has not been set previously' do
          it_behaves_like 'updates the severity', 'low'

          it 'creates a new record' do
            expect { update_issue(opts) }.to change(IssuableSeverity, :count).by(1)
          end

          context 'with unsupported severity value' do
            let(:opts) { { severity: 'unsupported-severity' } }

            it_behaves_like 'does not change the severity'
          end

          context 'with severity value defined but unchanged' do
            let(:opts) { { severity: IssuableSeverity::DEFAULT } }

            it_behaves_like 'does not change the severity'
          end

          context 'as guest' do
            let(:user) { guest }

            it_behaves_like 'does not change the severity'

            context 'and also author' do
              let(:issue) { create(:incident, project: project, author: user) }

              it_behaves_like 'does not change the severity'
            end

            context 'and also assignee' do
              let(:issue) { create(:incident, project: project, assignee_ids: [user.id]) }

              it_behaves_like 'does not change the severity'
            end
          end
        end

        context 'when severity has been set before' do
          before do
            create(:issuable_severity, issue: issue, severity: 'high')
          end

          it_behaves_like 'updates the severity', 'low'

          it 'does not create a new record' do
            expect { update_issue(opts) }.not_to change(IssuableSeverity, :count)
          end

          context 'with unsupported severity value' do
            let(:opts) { { severity: 'unsupported-severity' } }

            it_behaves_like 'updates the severity', IssuableSeverity::DEFAULT
          end

          context 'with severity value defined but unchanged' do
            let(:opts) { { severity: issue.severity } }

            it_behaves_like 'does not change the severity'
          end
        end
      end

      context 'when issue type is not incident' do
        it_behaves_like 'does not change the severity'
      end
    end

    context 'updating escalation status' do
      let(:opts) { { escalation_status: { status: 'acknowledged' } } }
      let(:escalation_update_class) { ::IncidentManagement::IssuableEscalationStatuses::AfterUpdateService }

      shared_examples 'updates the escalation status record' do |expected_status|
        let(:service_double) { instance_double(escalation_update_class) }

        it 'has correct value' do
          expect(escalation_update_class).to receive(:new).with(issue, user).and_return(service_double)
          expect(service_double).to receive(:execute)

          update_issue(opts)

          expect(issue.escalation_status.status_name).to eq(expected_status)
        end

        it 'triggers webhooks' do
          expect(project.project_namespace).to receive(:execute_hooks).with(an_instance_of(Hash), :issue_hooks)
          expect(project.project_namespace).to receive(:execute_integrations).with(an_instance_of(Hash), :issue_hooks)
          expect(project.project_namespace).to receive(:execute_integrations).with(an_instance_of(Hash), :incident_hooks)

          update_issue(opts)
        end
      end

      shared_examples 'does not change the status record' do
        it 'retains the original value' do
          expected_status = issue.escalation_status&.status_name

          update_issue(opts)

          expect(issue.escalation_status&.status_name).to eq(expected_status)
        end

        it 'does not trigger side-effects' do
          expect(project).not_to receive(:execute_hooks)
          expect(project).not_to receive(:execute_integrations)

          update_issue(opts)
        end
      end

      context 'when issue is an incident' do
        let(:issue) { create(:incident, project: project) }

        context 'with an escalation status record' do
          before do
            create(:incident_management_issuable_escalation_status, issue: issue)
          end

          it_behaves_like 'updates the escalation status record', :acknowledged

          context 'with unsupported status value' do
            let(:opts) { { escalation_status: { status: 'unsupported-status' } } }

            it_behaves_like 'does not change the status record'
          end

          context 'with status value defined but unchanged' do
            let(:opts) { { escalation_status: { status: issue.escalation_status.status_name } } }

            it_behaves_like 'does not change the status record'
          end
        end

        context 'without an escalation status record' do
          it 'creates a new record' do
            expect { update_issue(opts) }.to change(::IncidentManagement::IssuableEscalationStatus, :count).by(1)
          end

          it_behaves_like 'updates the escalation status record', :acknowledged
        end
      end

      context 'when issue type is not incident' do
        it_behaves_like 'does not change the status record'
      end
    end

    context 'duplicate issue' do
      let(:canonical_issue) { create(:issue, project: project) }

      context 'invalid canonical_issue_id' do
        it 'does not call the duplicate service' do
          expect(Issues::DuplicateService).not_to receive(:new)

          update_issue(canonical_issue_id: 123456789)
        end
      end

      context 'valid canonical_issue_id' do
        it 'calls the duplicate service with both issues' do
          expect_next_instance_of(Issues::DuplicateService) do |service|
            expect(service).to receive(:execute).with(issue, canonical_issue)
          end

          update_issue(canonical_issue_id: canonical_issue.id)
        end
      end
    end

    context 'move issue to another project' do
      let(:target_project) { create(:project) }

      context 'valid project' do
        before do
          target_project.add_maintainer(user)
        end

        it 'calls the move service with the proper issue and project' do
          move_stub = instance_double(Issues::MoveService)
          allow(Issues::MoveService).to receive(:new).and_return(move_stub)
          allow(move_stub).to receive(:execute).with(issue, target_project).and_return(issue)

          expect(move_stub).to receive(:execute).with(issue, target_project)

          update_issue(target_project: target_project)
        end
      end
    end

    context 'clone an issue' do
      context 'valid project' do
        let(:target_project) { create(:project) }

        before do
          target_project.add_maintainer(user)
        end

        it 'calls the move service with the proper issue and project' do
          clone_stub = instance_double(Issues::CloneService)
          allow(Issues::CloneService).to receive(:new).and_return(clone_stub)
          allow(clone_stub).to receive(:execute).with(issue, target_project, with_notes: nil).and_return(issue)

          expect(clone_stub).to receive(:execute).with(issue, target_project, with_notes: nil)

          update_issue(target_clone_project: target_project)
        end
      end
    end

    context 'clone an issue with notes' do
      context 'valid project' do
        let(:target_project) { create(:project) }

        before do
          target_project.add_maintainer(user)
        end

        it 'calls the move service with the proper issue and project' do
          clone_stub = instance_double(Issues::CloneService)
          allow(Issues::CloneService).to receive(:new).and_return(clone_stub)
          allow(clone_stub).to receive(:execute).with(issue, target_project, with_notes: true).and_return(issue)

          expect(clone_stub).to receive(:execute).with(issue, target_project, with_notes: true)

          update_issue(target_clone_project: target_project, clone_with_notes: true)
        end
      end
    end

    context 'when moving an issue ' do
      it 'raises an error for invalid move ids' do
        opts = { move_between_ids: [9000, non_existing_record_id] }

        expect { described_class.new(container: issue.project, current_user: user, params: opts).execute(issue) }
            .to raise_error(ActiveRecord::RecordNotFound)
      end
    end

    it_behaves_like 'issuable update service' do
      let(:open_issuable) { issue }
      let(:closed_issuable) { create(:closed_issue, project: project) }
    end

    context 'broadcasting issue assignee updates' do
      let(:update_params) { { assignee_ids: [user2.id] } }

      it 'triggers the GraphQL subscription' do
        expect(GraphqlTriggers).to receive(:issuable_assignees_updated).with(issue)

        update_issue(update_params)
      end

      context 'when assignee is not updated' do
        let(:update_params) { { title: 'Some other title' } }

        it 'does not trigger the GraphQL subscription' do
          expect(GraphqlTriggers).not_to receive(:issuable_assignees_updated).with(issue)

          update_issue(update_params)
        end
      end
    end

    it_behaves_like 'issuable record that supports quick actions' do
      let(:existing_issue) { create(:issue, project: project) }
      let(:issuable) { described_class.new(container: project, current_user: user, params: params).execute(existing_issue) }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Issues
  class CreateService < Issues::BaseService
    include ResolveDiscussions
    prepend RateLimitedService
    include ::Services::ReturnServiceResponses

    rate_limit key: :issues_create,
      opts: { scope: [:project, :current_user, :external_author] }

    def initialize(container:, current_user: nil, params: {}, build_service: nil, perform_spam_check: true)
      @extra_params = params.delete(:extra_params) || {}
      super(container: container, current_user: current_user, params: params)
      @perform_spam_check = perform_spam_check
      @build_service = build_service ||
        BuildService.new(container: project, current_user: current_user, params: params)
    end

    def execute(skip_system_notes: false)
      return error(_('Operation not allowed'), 403) unless @current_user.can?(authorization_action, container)

      # We should not initialize the callback classes during the build service execution because these will be
      # initialized when we call #create below
      @issue = @build_service.execute(initialize_callbacks: false)

      # issue_type and work_item_type are set in BuildService, so we can delete it from params, in later phase
      # it can be set also from quick actions
      [:issue_type, :work_item_type, :work_item_type_id].each { |attribute| params.delete(attribute) }

      handle_move_between_ids(@issue)

      @add_related_issue ||= params.delete(:add_related_issue)
      filter_resolve_discussion_params

      issue = create(@issue, skip_system_notes: skip_system_notes)

      if issue.persisted?
        success(issue: issue)
      else
        error(issue.errors.full_messages, 422, pass_back: { issue: issue })
      end
    end

    def external_author
      params[:external_author] # present when creating an issue using service desk (email: from)
    end

    def before_create(issue)
      issue.check_for_spam(user: current_user, action: :create) if perform_spam_check

      # current_user (defined in BaseService) is not available within run_after_commit block
      user = current_user
      assign_description_from_template(issue)
      issue.run_after_commit do
        NewIssueWorker.perform_async(issue.id, user.id, issue.class.to_s)
        Issues::PlacementWorker.perform_async(nil, issue.project_id)
        # issue.namespace_id can point to either a project through project namespace or a group.
        Onboarding::IssueCreatedWorker.perform_async(issue.namespace_id)
      end
    end

    # Add new items to Issues::AfterCreateService if they can be performed in Sidekiq
    def after_create(issue)
      user_agent_detail_service.create
      handle_add_related_issue(issue)
      resolve_discussions_with_issue(issue)
      handle_escalation_status_change(issue)
      create_timeline_event(issue)
      try_to_associate_contacts(issue)

      super
    end

    def handle_changes(issue, options)
      super
      old_associations = options.fetch(:old_associations, {})
      old_assignees = old_associations.fetch(:assignees, [])

      handle_assignee_changes(issue, old_assignees)
    end

    def handle_assignee_changes(issue, old_assignees)
      return if issue.assignees == old_assignees

      create_assignee_note(issue, old_assignees)
      Gitlab::ResourceEvents::AssignmentEventRecorder.new(parent: issue, old_assignees: old_assignees).record
    end

    def resolve_discussions_with_issue(issue)
      return if discussions_to_resolve.empty?

      Discussions::ResolveService.new(
        project,
        current_user,
        one_or_more_discussions: discussions_to_resolve,
        follow_up_issue: issue
      ).execute
    end

    private

    def authorization_action
      :create_issue
    end

    attr_reader :perform_spam_check, :extra_params

    def create_timeline_event(issue)
      return unless issue.work_item_type&.incident?

      IncidentManagement::TimelineEvents::CreateService.create_incident(issue, current_user)
    end

    def user_agent_detail_service
      UserAgentDetailService.new(spammable: @issue, perform_spam_check: perform_spam_check)
    end

    def handle_add_related_issue(issue)
      return unless @add_related_issue

      IssueLinks::CreateService.new(issue, issue.author, { target_issuable: @add_related_issue }).execute
    end

    def try_to_associate_contacts(issue)
      return unless issue.external_author
      return unless current_user.can?(:set_issue_crm_contacts, issue)

      contacts = [issue.external_author]
      contacts.concat extra_params[:cc] unless extra_params[:cc].nil?

      set_crm_contacts(issue, contacts)
    end

    def assign_description_from_template(issue)
      return if issue.description.present?

      # Find the exact name for the default template (if the project has one).
      # Since there are multiple possibilities regarding the capitalization(s) that the
      # default template file name can have, getting the exact template name here will
      # allow us to extract the contents later, and bail early if the project does not have
      # a default template
      templates = TemplateFinder.all_template_names(project, :issues)
      template = templates.values.flatten.find { |tmpl| tmpl[:name].casecmp?('default') }

      return unless template

      begin
        default_template = TemplateFinder.build(
          :issues,
          issue.project,
          {
            name: template[:name],
            source_template_project_id: issue.project.id
          }
        ).execute
      rescue ::Gitlab::Template::Finders::RepoTemplateFinder::FileNotFoundError
        nil
      end

      issue.description = default_template.content if default_template.present?
    end
  end
end

Issues::CreateService.prepend_mod

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Issues::CreateService, feature_category: :team_planning do
  include AfterNextHelpers

  let_it_be(:group) { create(:group, :crm_enabled) }
  let_it_be_with_reload(:project) { create(:project, :public, group: group) }
  let_it_be(:user) { create(:user) }

  let(:opts) { { title: 'title' } }
  let(:service) { described_class.new(container: project, current_user: user, params: opts) }

  it_behaves_like 'rate limited service' do
    let(:key) { :issues_create }
    let(:key_scope) { %i[project current_user external_author] }
    let(:application_limit_key) { :issues_create_limit }
    let(:created_model) { Issue }
  end

  describe '#execute' do
    let_it_be(:assignee) { create(:user) }
    let_it_be(:milestone) { create(:milestone, project: project) }

    let(:result) { service.execute }
    let(:issue) { result[:issue] }

    context 'when params are invalid' do
      let(:opts) { { title: '' } }

      before_all do
        project.add_guest(assignee)
      end

      it 'returns an error service response' do
        expect(result).to be_error
        expect(result.errors).to include(""Title can't be blank"")
        expect(issue).not_to be_persisted
      end
    end

    context 'when params are valid' do
      let_it_be(:labels) { create_pair(:label, project: project) }

      before_all do
        project.add_guest(user)
        project.add_guest(assignee)
      end

      let(:opts) do
        { title: 'Awesome issue',
          issue_type: :task,
          description: 'please fix',
          assignee_ids: [assignee.id],
          label_ids: labels.map(&:id),
          milestone_id: milestone.id,
          milestone: milestone,
          due_date: Date.tomorrow }
      end

      context 'when an unauthorized project_id is provided' do
        let(:unauthorized_project) { create(:project) }

        before do
          opts[:project_id] = unauthorized_project.id
        end

        it 'ignores the project_id param and creates issue in the given project' do
          expect(issue.project).to eq(project)
          expect(unauthorized_project.reload.issues.count).to eq(0)
        end
      end

      describe 'authorization' do
        let_it_be(:project) { create(:project, :private, group: group).tap { |project| project.add_guest(user) } }

        let(:opts) { { title: 'private issue', description: 'please fix' } }

        context 'when the user is authorized' do
          it 'allows the user to create an issue' do
            expect(result).to be_success
            expect(issue).to be_persisted
          end
        end

        context 'when the user is not authorized' do
          let(:user) { create(:user) }

          it 'does not allow the user to create an issue' do
            expect(result).to be_error
            expect(result.errors).to contain_exactly('Operation not allowed')
            expect(result.http_status).to eq(403)
            expect(issue).to be_nil
          end
        end
      end

      it 'works if base work item types were not created yet' do
        WorkItems::Type.delete_all

        expect do
          issue
        end.to change(Issue, :count).by(1)
      end

      it 'creates the issue with the given params' do
        expect(Issuable::CommonSystemNotesService).to receive_message_chain(:new, :execute)

        expect(result).to be_success
        expect(issue).to be_persisted
        expect(issue).to be_a(::Issue)
        expect(issue.title).to eq('Awesome issue')
        expect(issue.assignees).to eq([assignee])
        expect(issue.labels).to match_array(labels)
        expect(issue.milestone).to eq(milestone)
        expect(issue.due_date).to eq(Date.tomorrow)
        expect(issue.work_item_type.base_type).to eq('task')
        expect(issue.issue_customer_relations_contacts).to be_empty
      end

      context 'with milestone' do
        it 'deletes milestone issues count cache' do
          expect_next(Milestones::IssuesCountService, milestone)
            .to receive(:delete_cache).and_call_original

          expect(result).to be_success
        end
      end

      context 'when the work item type is not allowed to create' do
        before do
          allow_next_instance_of(::Issues::BuildService) do |instance|
            allow(instance).to receive(:create_issue_type_allowed?).twice.and_return(false)
          end
        end

        it 'ignores the type and creates default issue' do
          expect(result).to be_success
          expect(issue).to be_persisted
          expect(issue).to be_a(::Issue)
          expect(issue.work_item_type.base_type).to eq('issue')
        end
      end

      it 'calls NewIssueWorker with correct arguments' do
        expect(NewIssueWorker).to receive(:perform_async).with(Integer, user.id, 'Issue')

        issue
      end

      it 'calls GroupMentionWorker' do
        expect(Integrations::GroupMentionWorker).to receive(:perform_async)

        issue
      end

      context 'when a build_service is provided' do
        let(:result) { described_class.new(container: project, current_user: user, params: opts, build_service: build_service).execute }

        let(:issue_from_builder) { build(:work_item, project: project, title: 'Issue from builder') }
        let(:build_service) { double(:build_service, execute: issue_from_builder) }

        it 'uses the provided service to build the issue' do
          expect(result).to be_success
          expect(issue).to be_persisted
          expect(issue).to be_a(WorkItem)
        end
      end

      context 'when issue template is provided' do
        let_it_be(:files) { { '.gitlab/issue_templates/Default.md' => 'Default template contents' } }
        let_it_be_with_reload(:project) { create(:project, :custom_repo, group: group, files: files).tap { |project| project.add_guest(user) } }

        context 'when description is blank' do
          it 'sets template contents as description when description is blank' do
            opts[:description] = ''

            expect(result).to be_success
            expect(issue).to be_persisted
            expect(issue).to have_attributes(description: 'Default template contents')
          end
        end

        context 'when description is not blank' do
          it 'does not apply template when description is not blank' do
            expect(result).to be_success
            expect(issue).to be_persisted
            expect(issue).to have_attributes(description: 'please fix')
          end
        end
      end

      context 'when skip_system_notes is true' do
        let(:issue) { described_class.new(container: project, current_user: user, params: opts).execute(skip_system_notes: true) }

        it 'does not call Issuable::CommonSystemNotesService' do
          expect(Issuable::CommonSystemNotesService).not_to receive(:new)

          issue
        end
      end

      context 'when setting a position' do
        let(:issue_before) { create(:issue, project: project, relative_position: 10) }
        let(:issue_after) { create(:issue, project: project, relative_position: 50) }

        before do
          opts.merge!(move_between_ids: [issue_before.id, issue_after.id])
        end

        it 'sets the correct relative position' do
          expect(result).to be_success
          expect(issue).to be_persisted
          expect(issue.relative_position).to be_present
          expect(issue.relative_position).to be_between(issue_before.relative_position, issue_after.relative_position)
        end
      end

      it_behaves_like 'not an incident issue'

      context 'when issue is incident type' do
        before do
          opts.merge!(issue_type: 'incident')
        end

        let(:current_user) { user }

        subject { issue }

        context 'as reporter' do
          let_it_be(:reporter) { create(:user) }

          let(:user) { reporter }

          before_all do
            project.add_reporter(reporter)
          end

          it_behaves_like 'incident issue'

          it 'calls IncidentManagement::Incidents::CreateEscalationStatusService' do
            expect_next(::IncidentManagement::IssuableEscalationStatuses::CreateService, a_kind_of(Issue))
              .to receive(:execute)

            issue
          end

          it 'calls IncidentManagement::TimelineEvents::CreateService.create_incident' do
            expect(IncidentManagement::TimelineEvents::CreateService)
              .to receive(:create_incident)
              .with(a_kind_of(Issue), reporter)

            issue
          end

          it 'calls NewIssueWorker with correct arguments' do
            expect(NewIssueWorker).to receive(:perform_async).with(Integer, reporter.id, 'Issue')

            issue
          end

          context 'when invalid' do
            before do
              opts.merge!(title: '')
            end

            it 'does not apply an incident label prematurely' do
              expect { subject }.to not_change(LabelLink, :count).and not_change(Issue, :count)
            end
          end
        end

        context 'as guest' do
          it_behaves_like 'not an incident issue'
        end
      end

      it 'refreshes the number of open issues', :use_clean_rails_memory_store_caching do
        expect do
          issue

          BatchLoader::Executor.clear_current
        end.to change { project.open_issues_count }.from(0).to(1)
      end

      context 'when current user cannot set issue metadata in the project' do
        let_it_be(:non_member) { create(:user) }

        it 'filters out params that cannot be set without the :set_issue_metadata permission' do
          result = described_class.new(container: project, current_user: non_member, params: opts).execute
          issue = result[:issue]

          expect(result).to be_success
          expect(issue).to be_persisted
          expect(issue.title).to eq('Awesome issue')
          expect(issue.description).to eq('please fix')
          expect(issue.assignees).to be_empty
          expect(issue.labels).to be_empty
          expect(issue.milestone).to be_nil
          expect(issue.due_date).to be_nil
        end

        it 'can create confidential issues' do
          result = described_class.new(container: project, current_user: non_member, params: opts.merge(confidential: true)).execute
          issue = result[:issue]

          expect(result).to be_success
          expect(issue.confidential).to be_truthy
        end
      end

      it 'moves the issue to the end, in an asynchronous worker' do
        expect(Issues::PlacementWorker).to receive(:perform_async).with(be_nil, Integer)

        described_class.new(container: project, current_user: user, params: opts).execute
      end

      context 'when label belongs to project group' do
        let(:group) { create(:group) }
        let(:group_labels) { create_pair(:group_label, group: group) }

        let(:opts) do
          {
            title: 'Title',
            description: 'Description',
            label_ids: group_labels.map(&:id)
          }
        end

        before do
          project.update!(group: group)
        end

        it 'assigns group labels' do
          expect(issue.labels).to match_array group_labels
        end
      end

      context 'when label belongs to different project' do
        let(:label) { create(:label) }

        let(:opts) do
          { title: 'Title',
            description: 'Description',
            label_ids: [label.id] }
        end

        it 'does not assign label' do
          expect(issue.labels).not_to include label
        end
      end

      context 'when labels is nil' do
        let(:opts) do
          { title: 'Title',
            description: 'Description',
            labels: nil }
        end

        it 'does not assign label' do
          expect(issue.labels).to be_empty
        end
      end

      context 'when labels is nil and label_ids is present' do
        let(:opts) do
          { title: 'Title',
            description: 'Description',
            labels: nil,
            label_ids: labels.map(&:id) }
        end

        it 'assigns group labels' do
          expect(issue.labels).to match_array labels
        end
      end

      context 'when milestone belongs to different project' do
        let(:milestone) { create(:milestone) }

        let(:opts) do
          { title: 'Title',
            description: 'Description',
            milestone_id: milestone.id }
        end

        it 'does not assign milestone' do
          expect(issue.milestone).not_to eq milestone
        end
      end

      context 'when assignee is set' do
        let(:opts) do
          { title: 'Title',
            description: 'Description',
            assignee_ids: [assignee.id] }
        end

        it 'invalidates open issues counter for assignees when issue is assigned' do
          project.add_maintainer(assignee)

          described_class.new(container: project, current_user: user, params: opts).execute

          expect(assignee.assigned_open_issues_count).to eq 1
        end

        it 'records the assignee assignment event' do
          result = described_class.new(container: project, current_user: user, params: opts).execute

          issue = result.payload[:issue]
          expect(issue.assignment_events).to match([have_attributes(user_id: assignee.id, action: 'add')])
        end
      end

      context 'when duplicate label titles are given' do
        let(:label) { create(:label, project: project) }

        let(:opts) do
          { title: 'Title',
            description: 'Description',
            labels: [label.title, label.title] }
        end

        it 'assigns the label once' do
          expect(issue.labels).to contain_exactly(label)
        end
      end

      context 'when sentry identifier is given' do
        before do
          sentry_attributes = { sentry_issue_attributes: { sentry_issue_identifier: 42 } }
          opts.merge!(sentry_attributes)
        end

        it 'does not assign the sentry error' do
          expect(issue.sentry_issue).to eq(nil)
        end

        context 'user is reporter or above' do
          before do
            project.add_developer(user)
          end

          it 'assigns the sentry error' do
            expect(issue.sentry_issue).to be_kind_of(SentryIssue)
          end
        end
      end

      describe 'executing hooks' do
        let(:opts) { { title: 'Title', description: 'Description' } }
        let(:expected_payload) do
          include(
            event_type: 'issue',
            object_kind: 'issue',
            changes: {
              author_id: { current: user.id, previous: nil },
              created_at: { current: kind_of(Time), previous: nil },
              description: { current: opts[:description], previous: nil },
              id: { current: kind_of(Integer), previous: nil },
              iid: { current: kind_of(Integer), previous: nil },
              project_id: { current: project.id, previous: nil },
              title: { current: opts[:title], previous: nil },
              updated_at: { current: kind_of(Time), previous: nil },
              time_estimate: { current: 0, previous: nil }
            },
            object_attributes: include(
              opts.merge(
                author_id: user.id,
                project_id: project.id
              )
            )
          )
        end

        it 'executes issue hooks' do
          expect(project.project_namespace).to receive(:execute_hooks).with(expected_payload, :issue_hooks)
          expect(project.project_namespace).to receive(:execute_integrations).with(expected_payload, :issue_hooks)

          described_class.new(container: project, current_user: user, params: opts).execute
        end

        context 'when issue is confidential' do
          let(:expected_payload) do
            include(
              event_type: 'confidential_issue',
              object_kind: 'issue',
              changes: include(
                confidential: { current: true, previous: false }
              ),
              object_attributes: include(confidential: true)
            )
          end

          before do
            opts[:confidential] = true
          end

          it 'executes confidential issue hooks' do
            expect(project.project_namespace).to receive(:execute_hooks).with(expected_payload, :confidential_issue_hooks)
            expect(project.project_namespace).to receive(:execute_integrations).with(expected_payload, :confidential_issue_hooks)

            described_class.new(container: project, current_user: user, params: opts).execute
          end
        end
      end

      context 'after_save callback to store_mentions' do
        context 'when mentionable attributes change' do
          let(:opts) { { title: 'Title', description: ""Description with #{user.to_reference}"" } }

          it 'saves mentions' do
            expect_next_instance_of(Issue) do |instance|
              expect(instance).to receive(:store_mentions!).and_call_original
            end
            expect(issue.user_mentions.count).to eq 1
          end
        end

        context 'when save fails' do
          let(:opts) { { title: '', label_ids: labels.map(&:id), milestone_id: milestone.id } }

          it 'does not call store_mentions' do
            expect_next_instance_of(Issue) do |instance|
              expect(instance).not_to receive(:store_mentions!).and_call_original
            end
            expect(issue.valid?).to be false
            expect(issue.user_mentions.count).to eq 0
          end
        end
      end

      it 'schedules a namespace onboarding create action worker' do
        expect(Onboarding::IssueCreatedWorker).to receive(:perform_async).with(project.project_namespace_id)

        issue
      end
    end

    context 'issue create service' do
      context 'assignees' do
        before_all do
          project.add_maintainer(user)
        end

        it 'removes assignee when user id is invalid' do
          opts = { title: 'Title', description: 'Description', assignee_ids: [-1] }

          result = described_class.new(container: project, current_user: user, params: opts).execute
          issue = result[:issue]

          expect(result).to be_success
          expect(issue.assignees).to be_empty
        end

        it 'removes assignee when user id is 0' do
          opts = { title: 'Title', description: 'Description', assignee_ids: [0] }

          result = described_class.new(container: project, current_user: user, params: opts).execute
          issue = result[:issue]

          expect(result).to be_success
          expect(issue.assignees).to be_empty
        end

        it 'saves assignee when user id is valid' do
          project.add_maintainer(assignee)
          opts = { title: 'Title', description: 'Description', assignee_ids: [assignee.id] }

          result = described_class.new(container: project, current_user: user, params: opts).execute
          issue = result[:issue]

          expect(result).to be_success
          expect(issue.assignees).to eq([assignee])
        end

        context ""when issuable feature is private"" do
          before do
            project.project_feature.update!(
              issues_access_level: ProjectFeature::PRIVATE,
              merge_requests_access_level: ProjectFeature::PRIVATE
            )
          end

          levels = [Gitlab::VisibilityLevel::INTERNAL, Gitlab::VisibilityLevel::PUBLIC]

          levels.each do |level|
            it ""removes not authorized assignee when project is #{Gitlab::VisibilityLevel.level_name(level)}"" do
              project.update!(visibility_level: level)
              opts = { title: 'Title', description: 'Description', assignee_ids: [assignee.id] }

              result = described_class.new(container: project, current_user: user, params: opts).execute
              issue = result[:issue]

              expect(result).to be_success
              expect(issue.assignees).to be_empty
            end
          end
        end
      end
    end

    it_behaves_like 'issuable record that supports quick actions' do
      let(:issuable) { described_class.new(container: project, current_user: user, params: params).execute[:issue] }
    end

    context 'Quick actions' do
      context 'with assignee, milestone, and contact in params and command' do
        let_it_be(:contact) { create(:contact, group: group) }

        let(:opts) do
          {
            assignee_ids: [create(:user).id],
            milestone_id: 1,
            title: 'Title',
            description: %(/assign @#{assignee.username}\n/milestone %""#{milestone.name}""),
            add_contacts: [contact.email]
          }
        end

        before_all do
          group.add_maintainer(user)
          project.add_maintainer(assignee)
        end

        it 'assigns, sets milestone, and sets contact to issuable from command' do
          expect(result).to be_success
          expect(issue).to be_persisted
          expect(issue.assignees).to eq([assignee])
          expect(issue.milestone).to eq(milestone)
          expect(issue.issue_customer_relations_contacts.last.contact).to eq(contact)
        end
      end

      context 'with external_author' do
        let_it_be(:contact) { create(:contact, group: group) }

        context 'when CRM contact exists with matching e-mail' do
          let(:opts) do
            {
              title: 'Title',
              external_author: contact.email
            }
          end

          context 'with permission' do
            it 'assigns contact to issue' do
              group.add_reporter(user)

              expect(result).to be_success
              expect(issue).to be_persisted
              expect(issue.issue_customer_relations_contacts.last.contact).to eq(contact)
            end
          end

          context 'without permission' do
            it 'does not assign contact to issue' do
              group.add_guest(user)

              expect(result).to be_success
              expect(issue).to be_persisted
              expect(issue.issue_customer_relations_contacts).to be_empty
            end
          end
        end

        context 'when no CRM contact exists with matching e-mail' do
          let(:opts) do
            {
              title: 'Title',
              external_author: 'example@gitlab.com'
            }
          end

          it 'does not assign contact to issue' do
            group.add_reporter(user)
            expect(issue).to be_persisted
            expect(issue.issue_customer_relations_contacts).to be_empty
          end
        end
      end

      context 'with alert bot author' do
        let_it_be(:user) { Users::Internal.alert_bot }
        let_it_be(:label) { create(:label, project: project) }

        let(:opts) do
          {
            title: 'Title',
            description: %(/label #{label.to_reference(format: :name)}"")
          }
        end

        it 'can apply labels' do
          expect(result).to be_success
          expect(issue).to be_persisted
          expect(issue.labels).to eq([label])
        end
      end

      context 'when using promote_to_incident' do
        let(:opts) { { title: 'Title', description: '/promote_to_incident' } }

        before do
          project.add_developer(user)
        end

        it 'creates an issue with the correct issue type' do
          expect { result }.to change(Issue, :count).by(1)

          created_issue = Issue.last

          expect(created_issue.work_item_type).to eq(WorkItems::Type.default_by_type('incident'))
        end
      end
    end

    context 'resolving discussions' do
      let_it_be(:discussion) { create(:diff_note_on_merge_request).to_discussion }
      let_it_be(:merge_request) { discussion.noteable }
      let_it_be(:project) { merge_request.source_project }

      before_all do
        project.add_maintainer(user)
      end

      describe 'for a single discussion' do
        let(:opts) { { discussion_to_resolve: discussion.id, merge_request_to_resolve_discussions_of: merge_request.iid } }

        it 'resolves the discussion' do
          described_class.new(container: project, current_user: user, params: opts).execute
          discussion.first_note.reload

          expect(discussion.resolved?).to be(true)
        end

        it 'added a system note to the discussion' do
          described_class.new(container: project, current_user: user, params: opts).execute

          reloaded_discussion = MergeRequest.find(merge_request.id).discussions.first

          expect(reloaded_discussion.last_note.system).to eq(true)
        end

        it 'sets default title and description values if not provided' do
          result = described_class.new(
            container: project, current_user: user,
            params: opts
          ).execute
          issue = result[:issue]

          expect(result).to be_success
          expect(issue).to be_persisted
          expect(issue.title).to eq(""Follow-up from \""#{merge_request.title}\"""")
          expect(issue.description).to include(""The following discussion from #{merge_request.to_reference} should be addressed"")
        end

        it 'takes params from the request over the default values' do
          result = described_class.new(
            container: project,
            current_user: user,
            params: opts.merge(
              description: 'Custom issue description',
              title: 'My new issue'
            )
          ).execute
          issue = result[:issue]

          expect(result).to be_success
          expect(issue).to be_persisted
          expect(issue.description).to eq('Custom issue description')
          expect(issue.title).to eq('My new issue')
        end
      end

      describe 'for a merge request' do
        let(:opts) { { merge_request_to_resolve_discussions_of: merge_request.iid } }

        it 'resolves the discussion' do
          described_class.new(container: project, current_user: user, params: opts).execute
          discussion.first_note.reload

          expect(discussion.resolved?).to be(true)
        end

        it 'added a system note to the discussion' do
          described_class.new(container: project, current_user: user, params: opts).execute

          reloaded_discussion = MergeRequest.find(merge_request.id).discussions.first

          expect(reloaded_discussion.last_note.system).to eq(true)
        end

        it 'sets default title and description values if not provided' do
          result = described_class.new(
            container: project, current_user: user,
            params: opts
          ).execute
          issue = result[:issue]

          expect(result).to be_success
          expect(issue).to be_persisted
          expect(issue.title).to eq(""Follow-up from \""#{merge_request.title}\"""")
          expect(issue.description).to include(""The following discussion from #{merge_request.to_reference} should be addressed"")
        end

        it 'takes params from the request over the default values' do
          result = described_class.new(
            container: project,
            current_user: user,
            params: opts.merge(
              description: 'Custom issue description',
              title: 'My new issue'
            )
          ).execute
          issue = result[:issue]

          expect(result).to be_success
          expect(issue).to be_persisted
          expect(issue.description).to eq('Custom issue description')
          expect(issue.title).to eq('My new issue')
        end
      end
    end

    context 'add related issue' do
      let_it_be(:related_issue) { create(:issue, project: project) }

      let(:opts) do
        { title: 'A new issue', add_related_issue: related_issue }
      end

      it 'ignores related issue if not accessible' do
        expect { issue }.not_to change { IssueLink.count }
        expect(result).to be_success
        expect(issue).to be_persisted
      end

      context 'when user has access to the related issue' do
        before do
          project.add_developer(user)
        end

        it 'adds a link to the issue' do
          expect { issue }.to change { IssueLink.count }.by(1)
          expect(result).to be_success
          expect(issue).to be_persisted
          expect(issue.related_issues(user)).to eq([related_issue])
        end
      end
    end

    context 'checking spam' do
      let(:params) do
        {
          title: 'Spam issue'
        }
      end

      let(:perform_spam_check) { true }

      subject do
        described_class.new(container: project, current_user: user, params: params, perform_spam_check: perform_spam_check)
      end

      it 'checks for spam' do
        expect_next_instance_of(Issue) do |instance|
          expect(instance).to receive(:check_for_spam).with(user: user, action: :create)
        end

        subject.execute
      end

      context 'when `perform_spam_check` is set to `false`' do
        let(:perform_spam_check) { false }

        it 'does not execute the SpamActionService' do
          expect_next_instance_of(Issue) do |instance|
            expect(instance).not_to receive(:check_for_spam)
          end

          subject.execute
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Pages
  class DestroyDeploymentsService
    def initialize(project, last_deployment_id = nil)
      @project = project
      @last_deployment_id = last_deployment_id
    end

    def execute
      deployments_to_destroy = @project.pages_deployments
      deployments_to_destroy = deployments_to_destroy.older_than(@last_deployment_id) if @last_deployment_id
      deployments_to_destroy.find_each(&:destroy) # rubocop: disable CodeReuse/ActiveRecord
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Pages::DestroyDeploymentsService, feature_category: :pages do
  let_it_be(:project) { create(:project) }
  let!(:old_deployments) { create_list(:pages_deployment, 2, project: project) }
  let!(:last_deployment) { create(:pages_deployment, project: project) }
  let!(:newer_deployment) { create(:pages_deployment, project: project) }
  let!(:deployment_from_another_project) { create(:pages_deployment) }

  it 'destroys all deployments of the project' do
    expect { described_class.new(project).execute }
      .to change { PagesDeployment.count }.by(-4)

    expect(deployment_from_another_project.reload).to be_persisted
  end

  it 'destroy only deployments older than last deployment if it is provided' do
    expect { described_class.new(project, last_deployment.id).execute }
      .to change { PagesDeployment.count }.by(-2)

    expect(last_deployment.reload).to be_persisted
    expect(newer_deployment.reload).to be_persisted
    expect(deployment_from_another_project.reload).to be_persisted
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Pages
  class DeleteService < BaseService
    def execute
      PagesDeployment.deactivate_all(project)

      # project.pages_domains.delete_all will just nullify project_id:
      # > If no :dependent option is given, then it will follow the default
      # > strategy for `has_many :through` associations.
      # > The default strategy is :nullify which sets the foreign keys to NULL.
      PagesDomain.for_project(project).delete_all

      publish_deleted_event

      DestroyPagesDeploymentsWorker.perform_async(project.id)
    end

    private

    def publish_deleted_event
      event = Pages::PageDeletedEvent.new(data: {
        project_id: project.id,
        namespace_id: project.namespace_id,
        root_namespace_id: project.root_namespace.id
      })

      Gitlab::EventStore.publish(event)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Pages::DeleteService, feature_category: :pages do
  let_it_be(:admin) { create(:admin) }

  let(:project) { create(:project, path: ""my.project"") }
  let(:service) { described_class.new(project, admin) }

  it 'marks pages as not deployed' do
    create(:pages_deployment, project: project)

    expect { service.execute }
      .to change { project.reload.pages_deployed? }
      .from(true).to(false)
  end

  it 'deletes all domains' do
    domain = create(:pages_domain, project: project)
    unrelated_domain = create(:pages_domain)

    service.execute

    expect(PagesDomain.find_by_id(domain.id)).to eq(nil)
    expect(PagesDomain.find_by_id(unrelated_domain.id)).to be_present
  end

  it 'schedules a destruction of pages deployments' do
    expect(DestroyPagesDeploymentsWorker)
      .to(receive(:perform_async).with(project.id))

    service.execute
  end

  it 'removes pages deployments', :sidekiq_inline do
    create(:pages_deployment, project: project)

    expect { service.execute }
      .to change { PagesDeployment.count }.by(-1)
  end

  it 'publishes a ProjectDeleted event with project id and namespace id' do
    expected_data = {
      project_id: project.id,
      namespace_id: project.namespace_id,
      root_namespace_id: project.root_namespace.id
    }

    expect { service.execute }.to publish_event(Pages::PageDeletedEvent).with(expected_data)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Timelogs
  class CreateService < Timelogs::BaseService
    attr_accessor :issuable, :time_spent, :spent_at, :summary

    def initialize(issuable, time_spent, spent_at, summary, user)
      super(user)

      @issuable = issuable
      @time_spent = time_spent
      @spent_at = spent_at
      @summary = summary
    end

    def execute
      unless can?(current_user, :create_timelog, issuable)
        return error(
          _(""%{issuable_class_name} doesn't exist or you don't have permission to add timelog to it."") % {
            issuable_class_name: issuable.nil? ? 'Issuable' : issuable.base_class_name
          }, 404)
      end

      return error(_(""Spent at can't be a future date and time.""), 404) if spent_at.future?
      return error(_(""Time spent can't be zero.""), 404) if time_spent == 0

      issue = issuable if issuable.is_a?(Issue)
      merge_request = issuable if issuable.is_a?(MergeRequest)

      timelog = Timelog.new(
        time_spent: time_spent,
        spent_at: spent_at,
        summary: summary,
        user: current_user,
        issue: issue,
        merge_request: merge_request,
        note: nil
      )

      if !timelog.save
        error_in_save(timelog)
      else
        SystemNoteService.created_timelog(issuable, issuable.project, current_user, timelog)
        success(timelog)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Timelogs::CreateService, feature_category: :team_planning do
  let_it_be(:author) { create(:user) }
  let_it_be(:project) { create(:project, :public) }

  let(:issuable) { nil }
  let(:users_container) { project }

  describe '#execute' do
    subject { service.execute }

    context 'when issuable is an Issue' do
      let_it_be(:issuable) { create(:issue, project: project) }
      let_it_be(:note_noteable) { create(:issue, project: project) }

      it_behaves_like 'issuable supports timelog creation service'
    end

    context 'when issuable is a MergeRequest' do
      let_it_be(:issuable) { create(:merge_request, source_project: project, source_branch: 'branch-1') }
      let_it_be(:note_noteable) { create(:merge_request, source_project: project, source_branch: 'branch-2') }

      it_behaves_like 'issuable supports timelog creation service'
    end

    context 'when issuable is a WorkItem' do
      let_it_be(:issuable) { create(:work_item, project: project, title: 'WorkItem-1') }
      let_it_be(:note_noteable) { create(:work_item, project: project, title: 'WorkItem-2') }

      it_behaves_like 'issuable supports timelog creation service'
    end

    context 'when issuable is an Incident' do
      let_it_be(:issuable) { create(:incident, project: project) }
      let_it_be(:note_noteable) { create(:incident, project: project) }

      it_behaves_like 'issuable supports timelog creation service'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Timelogs
  class DeleteService < Timelogs::BaseService
    attr_accessor :timelog

    def initialize(timelog, user)
      super(user)

      @timelog = timelog
    end

    def execute
      unless can?(current_user, :admin_timelog, timelog)
        return error(_(""Timelog doesn't exist or you don't have permission to delete it""), 404)
      end

      if timelog.destroy
        issuable = timelog.issuable

        if issuable
          # Add a system note for the timelog removal
          SystemNoteService.remove_timelog(issuable, issuable.project, current_user, timelog)
        end

        success(timelog)
      else
        error(_('Failed to remove timelog'), 400)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Timelogs::DeleteService, feature_category: :team_planning do
  let_it_be(:author) { create(:user) }
  let_it_be(:project) { create(:project, :public) }
  let_it_be(:issue) { create(:issue, project: project) }
  let_it_be(:timelog) { create(:timelog, user: author, issue: issue, time_spent: 1800) }

  let(:service) { described_class.new(timelog, user) }

  describe '#execute' do
    subject { service.execute }

    context 'when the timelog exists' do
      let(:user) { author }

      it 'removes the timelog' do
        expect { subject }.to change { Timelog.count }.by(-1)
      end

      it 'returns the removed timelog' do
        is_expected.to be_success
        expect(subject.payload[:timelog]).to eq(timelog)
      end
    end

    context 'when the timelog does not exist' do
      let(:user) { create(:user) }
      let!(:timelog) { nil }

      it 'returns an error' do
        is_expected.to be_error
        expect(subject.message).to eq('Timelog doesn\'t exist or you don\'t have permission to delete it')
        expect(subject.http_status).to eq(404)
      end
    end

    context 'when the user does not have permission' do
      let(:user) { create(:user) }

      it 'returns an error' do
        is_expected.to be_error
        expect(subject.message).to eq('Timelog doesn\'t exist or you don\'t have permission to delete it')
        expect(subject.http_status).to eq(404)
      end
    end

    context 'when the timelog deletion fails' do
      let(:user) { author }
      let!(:timelog) { create(:timelog, user: author, issue: issue, time_spent: 1800) }

      before do
        allow(timelog).to receive(:destroy).and_return(false)
      end

      it 'returns an error' do
        is_expected.to be_error
        expect(subject.message).to eq('Failed to remove timelog')
        expect(subject.http_status).to eq(400)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ActivityPub
  class InboxResolverService
    attr_reader :subscription

    def initialize(subscription)
      @subscription = subscription
    end

    def execute
      profile = subscriber_profile
      unless profile.has_key?('inbox') && profile['inbox'].is_a?(String)
        raise ThirdPartyError, 'Inbox parameter absent or invalid'
      end

      subscription.subscriber_inbox_url = profile['inbox']
      subscription.shared_inbox_url = profile.dig('entrypoints', 'sharedInbox')
      subscription.save!
    end

    private

    def subscriber_profile
      raw_data = download_subscriber_profile

      begin
        profile = Gitlab::Json.parse(raw_data)
      rescue JSON::ParserError => e
        raise ThirdPartyError, e.message
      end

      profile
    end

    def download_subscriber_profile
      begin
        response = Gitlab::HTTP.get(subscription.subscriber_url,
          headers: {
            'Accept' => 'application/ld+json; profile=""https://www.w3.org/ns/activitystreams""'
          }
        )
      rescue StandardError => e
        raise ThirdPartyError, e.message
      end

      response.body
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ActivityPub::InboxResolverService, feature_category: :integrations do
  let_it_be(:project) { create(:project, :public) }
  let_it_be_with_reload(:existing_subscription) { create(:activity_pub_releases_subscription, project: project) }
  let(:service) { described_class.new(existing_subscription) }

  shared_examples 'third party error' do
    it 'raises a ThirdPartyError' do
      expect { service.execute }.to raise_error(ActivityPub::ThirdPartyError)
    end

    it 'does not update the subscription record' do
      begin
        service.execute
      rescue StandardError
      end

      expect(ActivityPub::ReleasesSubscription.last.subscriber_inbox_url).not_to eq 'https://example.com/user/inbox'
    end
  end

  describe '#execute' do
    context 'with successful HTTP request' do
      before do
        allow(Gitlab::HTTP).to receive(:get) { response }
      end

      let(:response) { instance_double(HTTParty::Response, body: body) }

      context 'with a JSON response' do
        let(:body) do
          {
            '@context': 'https://www.w3.org/ns/activitystreams',
            id: 'https://example.com/user',
            type: 'Person',
            **inbox,
            **entrypoints,
            outbox: 'https://example.com/user/outbox'
          }.to_json
        end

        let(:entrypoints) { {} }

        context 'with valid response' do
          let(:inbox) { { inbox: 'https://example.com/user/inbox' } }

          context 'without a shared inbox' do
            it 'updates only the inbox in the subscription record' do
              service.execute

              expect(ActivityPub::ReleasesSubscription.last.subscriber_inbox_url).to eq 'https://example.com/user/inbox'
              expect(ActivityPub::ReleasesSubscription.last.shared_inbox_url).to be_nil
            end
          end

          context 'with a shared inbox' do
            let(:entrypoints) { { entrypoints: { sharedInbox: 'https://example.com/shared-inbox' } } }

            it 'updates both the inbox and shared inbox in the subscription record' do
              service.execute

              expect(ActivityPub::ReleasesSubscription.last.subscriber_inbox_url).to eq 'https://example.com/user/inbox'
              expect(ActivityPub::ReleasesSubscription.last.shared_inbox_url).to eq 'https://example.com/shared-inbox'
            end
          end
        end

        context 'without inbox attribute' do
          let(:inbox) { {} }

          it_behaves_like 'third party error'
        end

        context 'with a non string inbox attribute' do
          let(:inbox) { { inbox: 27.13 } }

          it_behaves_like 'third party error'
        end
      end

      context 'with non JSON response' do
        let(:body) { '<div>woops</div>' }

        it_behaves_like 'third party error'
      end
    end

    context 'with http error' do
      before do
        allow(Gitlab::HTTP).to receive(:get).and_raise(Errno::ECONNREFUSED)
      end

      it_behaves_like 'third party error'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ActivityPub
  class AcceptFollowService
    MissingInboxURLError = Class.new(StandardError)

    attr_reader :subscription, :actor

    def initialize(subscription, actor)
      @subscription = subscription
      @actor = actor
    end

    def execute
      return if subscription.accepted?
      raise MissingInboxURLError unless subscription.subscriber_inbox_url.present?

      upload_accept_activity
      subscription.accepted!
    end

    private

    def upload_accept_activity
      body = Gitlab::Json::LimitedEncoder.encode(payload, limit: 1.megabyte)

      begin
        Gitlab::HTTP.post(subscription.subscriber_inbox_url, body: body, headers: headers)
      rescue StandardError => e
        raise ThirdPartyError, e.message
      end
    end

    def payload
      follow = subscription.payload.dup
      follow.delete('@context')

      {
        '@context': 'https://www.w3.org/ns/activitystreams',
        id: ""#{actor}#follow/#{subscription.id}/accept"",
        type: 'Accept',
        actor: actor,
        object: follow
      }
    end

    def headers
      {
        'User-Agent' => ""GitLab/#{Gitlab::VERSION}"",
        'Content-Type' => 'application/ld+json; profile=""https://www.w3.org/ns/activitystreams""',
        'Accept' => 'application/ld+json; profile=""https://www.w3.org/ns/activitystreams""'
      }
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ActivityPub::AcceptFollowService, feature_category: :integrations do
  let_it_be(:project) { create(:project, :public) }
  let_it_be_with_reload(:existing_subscription) do
    create(:activity_pub_releases_subscription, :inbox, project: project)
  end

  let(:service) { described_class.new(existing_subscription, 'http://localhost/my-project/releases') }

  describe '#execute' do
    context 'when third party server complies' do
      before do
        allow(Gitlab::HTTP).to receive(:post).and_return(true)
        service.execute
      end

      it 'sends an Accept activity' do
        expect(Gitlab::HTTP).to have_received(:post)
      end

      it 'updates subscription state to accepted' do
        expect(existing_subscription.reload.status).to eq 'accepted'
      end
    end

    context 'when there is an error with third party server' do
      before do
        allow(Gitlab::HTTP).to receive(:post).and_raise(Errno::ECONNREFUSED)
      end

      it 'raises a ThirdPartyError' do
        expect { service.execute }.to raise_error(ActivityPub::ThirdPartyError)
      end

      it 'does not update subscription state to accepted' do
        begin
          service.execute
        rescue StandardError
        end

        expect(existing_subscription.reload.status).to eq 'requested'
      end
    end

    context 'when subscription is already accepted' do
      before do
        allow(Gitlab::HTTP).to receive(:post).and_return(true)
        allow(existing_subscription).to receive(:accepted!).and_return(true)
        existing_subscription.status = :accepted
        service.execute
      end

      it 'does not send an Accept activity' do
        expect(Gitlab::HTTP).not_to have_received(:post)
      end

      it 'does not update subscription state' do
        expect(existing_subscription).not_to have_received(:accepted!)
      end
    end

    context 'when inbox has not been resolved' do
      before do
        allow(Gitlab::HTTP).to receive(:post).and_return(true)
        allow(existing_subscription).to receive(:accepted!).and_return(true)
      end

      it 'raises an error' do
        existing_subscription.subscriber_inbox_url = nil
        expect { service.execute }.to raise_error(ActivityPub::AcceptFollowService::MissingInboxURLError)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ActivityPub
  module Projects
    class ReleasesUnfollowService < ReleasesSubscriptionService
      def execute
        unless subscriber_url
          errors << ""You need to provide an actor id for your unsubscribe activity""
          return false
        end

        return true unless previous_subscription.present?

        previous_subscription.destroy
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ActivityPub::Projects::ReleasesUnfollowService, feature_category: :release_orchestration do
  let_it_be(:project) { create(:project, :public) }
  let_it_be_with_reload(:existing_subscription) { create(:activity_pub_releases_subscription, project: project) }

  describe '#execute' do
    let(:service) { described_class.new(project, payload) }
    let(:payload) { nil }

    context 'with a valid payload' do
      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'https://example.com/new-actor#unfollow-1',
          type: 'Undo',
          actor: actor,
          object: {
            id: 'https://example.com/new-actor#follow-1',
            type: 'Follow',
            actor: actor,
            object: 'https://localhost/our/project/-/releases'
          }
        }.with_indifferent_access
      end

      let(:actor) { existing_subscription.subscriber_url }

      context 'when there is a subscription for this actor' do
        it 'deletes the subscription' do
          service.execute
          expect(ActivityPub::ReleasesSubscription.where(id: existing_subscription.id).first).to be_nil
        end

        it 'returns true' do
          expect(service.execute).to be_truthy
        end
      end

      context 'when there is no subscription for this actor' do
        before do
          allow(ActivityPub::ReleasesSubscription).to receive(:find_by_project_and_subscriber).and_return(nil)
        end

        it 'does not delete anything' do
          expect { service.execute }.not_to change { ActivityPub::ReleasesSubscription.count }
        end

        it 'returns true' do
          expect(service.execute).to be_truthy
        end
      end
    end

    shared_examples 'invalid unfollow request' do
      it 'does not delete anything' do
        expect { service.execute }.not_to change { ActivityPub::ReleasesSubscription.count }
      end

      it 'sets an error' do
        service.execute
        expect(service.errors).not_to be_empty
      end

      it 'returns false' do
        expect(service.execute).to be_falsey
      end
    end

    context 'when actor is missing' do
      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'https://example.com/new-actor#unfollow-1',
          type: 'Undo',
          object: {
            id: 'https://example.com/new-actor#follow-1',
            type: 'Follow',
            object: 'https://localhost/our/project/-/releases'
          }
        }.with_indifferent_access
      end

      it_behaves_like 'invalid unfollow request'
    end

    context 'when actor is an object with no id attribute' do
      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'https://example.com/new-actor#unfollow-1',
          actor: { type: 'Person' },
          type: 'Undo',
          object: {
            id: 'https://example.com/new-actor#follow-1',
            type: 'Follow',
            actor: { type: 'Person' },
            object: 'https://localhost/our/project/-/releases'
          }
        }.with_indifferent_access
      end

      it_behaves_like 'invalid unfollow request'
    end

    context 'when actor is neither a string nor an object' do
      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'https://example.com/new-actor#unfollow-1',
          actor: 27.13,
          type: 'Undo',
          object: {
            id: 'https://example.com/new-actor#follow-1',
            type: 'Follow',
            actor: 27.13,
            object: 'https://localhost/our/project/-/releases'
          }
        }.with_indifferent_access
      end

      it_behaves_like 'invalid unfollow request'
    end

    context ""when actor tries to delete someone else's subscription"" do
      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'https://example.com/actor#unfollow-1',
          type: 'Undo',
          actor: 'https://example.com/nasty-actor',
          object: {
            id: 'https://example.com/actor#follow-1',
            type: 'Follow',
            actor: existing_subscription.subscriber_url,
            object: 'https://localhost/our/project/-/releases'
          }
        }.with_indifferent_access
      end

      it 'does not delete anything' do
        expect { service.execute }.not_to change { ActivityPub::ReleasesSubscription.count }
      end

      it 'returns true' do
        expect(service.execute).to be_truthy
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module ActivityPub
  module Projects
    class ReleasesFollowService < ReleasesSubscriptionService
      def execute
        unless subscriber_url
          errors << ""You need to provide an actor id for your subscriber""
          return false
        end

        return true if previous_subscription.present?

        subscription = ReleasesSubscription.new(
          subscriber_url: subscriber_url,
          subscriber_inbox_url: subscriber_inbox_url,
          payload: payload,
          project: project
        )

        unless subscription.save
          errors.concat(subscription.errors.full_messages)
          return false
        end

        enqueue_subscription(subscription)
        true
      end

      private

      def subscriber_inbox_url
        return unless payload['actor'].is_a?(Hash)

        payload['actor']['inbox']
      end

      def enqueue_subscription(subscription)
        ReleasesSubscriptionWorker.perform_async(subscription.id)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ActivityPub::Projects::ReleasesFollowService, feature_category: :release_orchestration do
  let_it_be(:project) { create(:project, :public) }
  let_it_be_with_reload(:existing_subscription) { create(:activity_pub_releases_subscription, project: project) }

  describe '#execute' do
    let(:service) { described_class.new(project, payload) }
    let(:payload) { nil }

    before do
      allow(ActivityPub::Projects::ReleasesSubscriptionWorker).to receive(:perform_async)
    end

    context 'with a valid payload' do
      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'https://example.com/new-actor#follow-1',
          type: 'Follow',
          actor: actor,
          object: 'https://localhost/our/project/-/releases'
        }.with_indifferent_access
      end

      let(:actor) { 'https://example.com/new-actor' }

      context 'when there is no subscription for that actor' do
        before do
          allow(ActivityPub::ReleasesSubscription).to receive(:find_by_project_and_subscriber).and_return(nil)
        end

        it 'sets the subscriber url' do
          service.execute
          expect(ActivityPub::ReleasesSubscription.last.subscriber_url).to eq 'https://example.com/new-actor'
        end

        it 'sets the payload' do
          service.execute
          expect(ActivityPub::ReleasesSubscription.last.payload).to eq payload
        end

        it 'sets the project' do
          service.execute
          expect(ActivityPub::ReleasesSubscription.last.project_id).to eq project.id
        end

        it 'saves the subscription' do
          expect { service.execute }.to change { ActivityPub::ReleasesSubscription.count }.by(1)
        end

        it 'queues the subscription job' do
          service.execute
          expect(ActivityPub::Projects::ReleasesSubscriptionWorker).to have_received(:perform_async)
        end

        it 'returns true' do
          expect(service.execute).to be_truthy
        end
      end

      context 'when there is already a subscription for that actor' do
        before do
          allow(ActivityPub::ReleasesSubscription).to receive(:find_by_project_and_subscriber) { existing_subscription }
        end

        it 'does not save the subscription' do
          expect { service.execute }.not_to change { ActivityPub::ReleasesSubscription.count }
        end

        it 'does not queue the subscription job' do
          service.execute
          expect(ActivityPub::Projects::ReleasesSubscriptionWorker).not_to have_received(:perform_async)
        end

        it 'returns true' do
          expect(service.execute).to be_truthy
        end
      end
    end

    shared_examples 'invalid follow request' do
      it 'does not save the subscription' do
        expect { service.execute }.not_to change { ActivityPub::ReleasesSubscription.count }
      end

      it 'does not queue the subscription job' do
        service.execute
        expect(ActivityPub::Projects::ReleasesSubscriptionWorker).not_to have_received(:perform_async)
      end

      it 'sets an error' do
        service.execute
        expect(service.errors).not_to be_empty
      end

      it 'returns false' do
        expect(service.execute).to be_falsey
      end
    end

    context 'when actor is missing' do
      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'https://example.com/new-actor',
          type: 'Follow',
          object: 'https://localhost/our/project/-/releases'
        }.with_indifferent_access
      end

      it_behaves_like 'invalid follow request'
    end

    context 'when actor is an object with no id attribute' do
      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'https://example.com/new-actor',
          type: 'Follow',
          actor: { type: 'Person' },
          object: 'https://localhost/our/project/-/releases'
        }.with_indifferent_access
      end

      it_behaves_like 'invalid follow request'
    end

    context 'when actor is neither a string nor an object' do
      let(:payload) do
        {
          '@context': 'https://www.w3.org/ns/activitystreams',
          id: 'https://example.com/new-actor',
          type: 'Follow',
          actor: 27.13,
          object: 'https://localhost/our/project/-/releases'
        }.with_indifferent_access
      end

      it_behaves_like 'invalid follow request'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Git
  class TagPushService < ::BaseService
    include ChangeParams

    def execute
      return unless Gitlab::Git.tag_ref?(ref)

      project.repository.before_push_tag
      TagHooksService.new(project, current_user, params).execute

      unlock_artifacts

      true
    end

    private

    def unlock_artifacts
      return unless removing_tag?

      Ci::RefDeleteUnlockArtifactsWorker.perform_async(project.id, current_user.id, ref)
    end

    def removing_tag?
      Gitlab::Git.blank_ref?(newrev)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Git::TagPushService, feature_category: :source_code_management do
  include RepoHelpers

  let(:user) { create(:user) }
  let(:project) { create(:project, :repository) }
  let(:service) { described_class.new(project, user, change: { oldrev: oldrev, newrev: newrev, ref: ref }) }

  let(:blankrev) { Gitlab::Git::BLANK_SHA }
  let(:oldrev) { blankrev }
  let(:newrev) { ""8a2a6eb295bb170b34c24c76c49ed0e9b2eaf34b"" } # gitlab-test: git rev-parse refs/tags/v1.1.0
  let(:tag)   { 'v1.1.0' }
  let(:ref) { ""refs/tags/#{tag}"" }

  describe ""Push tags"" do
    subject do
      service.execute
      service
    end

    it 'flushes general cached data' do
      expect(project.repository).to receive(:before_push_tag)

      subject
    end

    it 'does not flush the tags cache' do
      expect(project.repository).not_to receive(:expire_tags_cache)

      subject
    end
  end

  describe 'Hooks' do
    context 'run on a tag' do
      it 'delegates to Git::TagHooksService' do
        expect_next_instance_of(::Git::TagHooksService) do |hooks_service|
          expect(hooks_service.project).to eq(service.project)
          expect(hooks_service.current_user).to eq(service.current_user)
          expect(hooks_service.params).to eq(service.params)

          expect(hooks_service).to receive(:execute)
        end

        service.execute
      end
    end

    context 'run on a branch' do
      let(:ref) { 'refs/heads/master' }

      it 'does nothing' do
        expect(::Git::BranchHooksService).not_to receive(:new)

        service.execute
      end
    end
  end

  describe 'artifacts' do
    context 'create tag' do
      let(:oldrev) { blankrev }

      it 'does nothing' do
        expect(::Ci::RefDeleteUnlockArtifactsWorker).not_to receive(:perform_async)

        service.execute
      end
    end

    context 'update tag' do
      it 'does nothing' do
        expect(::Ci::RefDeleteUnlockArtifactsWorker).not_to receive(:perform_async)

        service.execute
      end
    end

    context 'delete tag' do
      let(:newrev) { blankrev }

      it 'unlocks artifacts' do
        expect(::Ci::RefDeleteUnlockArtifactsWorker)
          .to receive(:perform_async).with(project.id, user.id, ""refs/tags/#{tag}"")

        service.execute
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Git
  class ProcessRefChangesService < BaseService
    PIPELINE_PROCESS_LIMIT = 4

    def execute
      changes = params[:changes]

      process_changes_by_action(:branch, changes.branch_changes)
      process_changes_by_action(:tag, changes.tag_changes)

      perform_housekeeping
    end

    private

    def process_changes_by_action(ref_type, changes)
      changes_by_action = group_changes_by_action(changes)

      changes_by_action.each do |action, changes|
        process_changes(ref_type, action, changes, execute_project_hooks: execute_project_hooks?(changes)) if changes.any?
      end
    end

    def group_changes_by_action(changes)
      changes.group_by do |change|
        change_action(change)
      end
    end

    def change_action(change)
      return :created if Gitlab::Git.blank_ref?(change[:oldrev])
      return :removed if Gitlab::Git.blank_ref?(change[:newrev])

      :pushed
    end

    def execute_project_hooks?(changes)
      changes.size <= Gitlab::CurrentSettings.push_event_hooks_limit
    end

    def process_changes(ref_type, action, changes, execute_project_hooks:)
      push_service_class = push_service_class_for(ref_type)

      create_bulk_push_event = changes.size > Gitlab::CurrentSettings.push_event_activities_limit
      merge_request_branches = merge_request_branches_for(ref_type, changes)

      changes.each do |change|
        push_service_class.new(
          project,
          current_user,
          change: change,
          push_options: params[:push_options],
          merge_request_branches: merge_request_branches,
          create_pipelines: under_process_limit?(change),
          execute_project_hooks: execute_project_hooks,
          create_push_event: !create_bulk_push_event
        ).execute
      end

      create_bulk_push_event(ref_type, action, changes) if create_bulk_push_event
    end

    def under_process_limit?(change)
      change[:index] < PIPELINE_PROCESS_LIMIT || Feature.enabled?(:git_push_create_all_pipelines, project)
    end

    def create_bulk_push_event(ref_type, action, changes)
      EventCreateService.new.bulk_push(
        project,
        current_user,
        Gitlab::DataBuilder::Push.build_bulk(action: action, ref_type: ref_type, changes: changes)
      )
    end

    def push_service_class_for(ref_type)
      return Git::TagPushService if ref_type == :tag

      Git::BranchPushService
    end

    def merge_request_branches_for(ref_type, changes)
      return [] if ref_type == :tag

      MergeRequests::PushedBranchesService.new(project: project, current_user: current_user, params: { changes: changes }).execute
    end

    def perform_housekeeping
      housekeeping = Repositories::HousekeepingService.new(project)
      housekeeping.increment!
      housekeeping.execute if housekeeping.needed?
    rescue Repositories::HousekeepingService::LeaseTaken
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Git::ProcessRefChangesService, feature_category: :source_code_management do
  let(:project) { create(:project, :repository) }
  let(:user) { project.first_owner }
  let(:params) { { changes: git_changes } }

  subject { described_class.new(project, user, params) }

  shared_examples_for 'service for processing ref changes' do |push_service_class|
    let(:service) { double(execute: true) }
    let(:git_changes) { double(branch_changes: [], tag_changes: []) }

    def multiple_changes(change, count)
      Array.new(count).map.with_index do |n, index|
        { index: index, oldrev: change[:oldrev], newrev: change[:newrev], ref: ""#{change[:ref]}#{n}"" }
      end
    end

    let(:changes) do
      [
        { index: 0, oldrev: Gitlab::Git::BLANK_SHA, newrev: '789012', ref: ""#{ref_prefix}/create"" },
        { index: 1, oldrev: '123456', newrev: '789012', ref: ""#{ref_prefix}/update"" },
        { index: 2, oldrev: '123456', newrev: Gitlab::Git::BLANK_SHA, ref: ""#{ref_prefix}/delete"" }
      ]
    end

    before do
      allow(git_changes).to receive(changes_method).and_return(changes)
    end

    it ""calls #{push_service_class}"" do
      expect(push_service_class)
        .to receive(:new)
        .with(project, project.first_owner, hash_including(execute_project_hooks: true, create_push_event: true))
        .exactly(changes.count).times
        .and_return(service)

      subject.execute
    end

    context 'changes exceed push_event_hooks_limit' do
      let(:push_event_hooks_limit) { 3 }

      let(:changes) do
        multiple_changes(
          { oldrev: '123456', newrev: '789012', ref: ""#{ref_prefix}/test"" },
          push_event_hooks_limit + 1
        )
      end

      before do
        stub_application_setting(push_event_hooks_limit: push_event_hooks_limit)
      end

      it ""calls #{push_service_class} with execute_project_hooks set to false"" do
        expect(push_service_class)
          .to receive(:new)
          .with(project, project.first_owner, hash_including(execute_project_hooks: false))
          .exactly(changes.count).times
          .and_return(service)

        subject.execute
      end
    end

    context 'changes exceed push_event_activities_limit per action' do
      let(:push_event_activities_limit) { 3 }

      let(:changes) do
        [
          { oldrev: Gitlab::Git::BLANK_SHA, newrev: '789012', ref: ""#{ref_prefix}/create"" },
          { oldrev: '123456', newrev: '789012', ref: ""#{ref_prefix}/update"" },
          { oldrev: '123456', newrev: Gitlab::Git::BLANK_SHA, ref: ""#{ref_prefix}/delete"" }
        ].map do |change|
          multiple_changes(change, push_event_activities_limit + 1)
        end.flatten
      end

      before do
        stub_application_setting(push_event_activities_limit: push_event_activities_limit)
      end

      it ""calls #{push_service_class} with create_push_event set to false"" do
        expect(push_service_class)
          .to receive(:new)
          .with(project, project.first_owner, hash_including(create_push_event: false))
          .exactly(changes.count).times
          .and_return(service)

        subject.execute
      end

      it 'creates events per action' do
        allow(push_service_class).to receive(:new).and_return(service)

        expect { subject.execute }.to change { Event.count }.by(3)
      end
    end

    context 'pipeline creation' do
      context 'with valid .gitlab-ci.yml' do
        before do
          stub_ci_pipeline_to_return_yaml_file

          allow_any_instance_of(Project)
            .to receive(:commit)
            .and_return(project.commit)

          if changes_method == :branch_changes
            allow_any_instance_of(Repository).to receive(:branch_exists?) { true }
          end

          if changes_method == :tag_changes
            allow_any_instance_of(Repository).to receive(:tag_exists?) { true }
          end

          allow(Gitlab::Git::Commit).to receive(:between) { [] }
        end

        context 'when git_push_create_all_pipelines is disabled' do
          before do
            stub_feature_flags(git_push_create_all_pipelines: false)
          end

          it 'creates pipeline for branches and tags' do
            subject.execute

            expect(Ci::Pipeline.pluck(:ref)).to contain_exactly('create', 'update', 'delete')
          end

          it ""creates exactly #{described_class::PIPELINE_PROCESS_LIMIT} pipelines"" do
            stub_const(""#{described_class}::PIPELINE_PROCESS_LIMIT"", changes.count - 1)

            expect { subject.execute }.to change { Ci::Pipeline.count }.by(described_class::PIPELINE_PROCESS_LIMIT)
          end
        end

        context 'when git_push_create_all_pipelines is enabled' do
          before do
            stub_feature_flags(git_push_create_all_pipelines: true)
          end

          it 'creates all pipelines' do
            expect { subject.execute }.to change { Ci::Pipeline.count }.by(changes.count)
          end
        end
      end

      context 'with invalid .gitlab-ci.yml' do
        before do
          stub_ci_pipeline_yaml_file(nil)

          allow(Gitlab::Git::Commit).to receive(:between) { [] }
        end

        it 'does not create a pipeline' do
          expect { subject.execute }.not_to change { Ci::Pipeline.count }
        end
      end
    end

    describe ""housekeeping"", :clean_gitlab_redis_cache, :clean_gitlab_redis_queues, :clean_gitlab_redis_shared_state do
      let(:housekeeping) { Repositories::HousekeepingService.new(project) }

      before do
        allow(Repositories::HousekeepingService).to receive(:new).and_return(housekeeping)

        allow(push_service_class)
          .to receive(:new)
          .with(project, project.first_owner, hash_including(execute_project_hooks: true, create_push_event: true))
          .exactly(changes.count).times
          .and_return(service)
      end

      it 'does not perform housekeeping when not needed' do
        expect(housekeeping).not_to receive(:execute)

        subject.execute
      end

      context 'when housekeeping is needed' do
        before do
          allow(housekeeping).to receive(:needed?).and_return(true)
        end

        it 'performs housekeeping' do
          expect(housekeeping).to receive(:execute)

          subject.execute
        end

        it 'does not raise an exception' do
          allow(housekeeping).to receive(:try_obtain_lease).and_return(false)

          subject.execute
        end
      end

      it 'increments the push counter' do
        expect(housekeeping).to receive(:increment!)

        subject.execute
      end
    end
  end

  context 'branch changes' do
    let(:changes_method) { :branch_changes }
    let(:ref_prefix) { 'refs/heads' }

    it_behaves_like 'service for processing ref changes', Git::BranchPushService

    context 'when there are merge requests associated with branches' do
      let(:tag_changes) do
        [
          { index: 0, oldrev: Gitlab::Git::BLANK_SHA, newrev: '789012', ref: ""refs/tags/v10.0.0"" }
        ]
      end

      let(:branch_changes) do
        [
          { index: 0, oldrev: Gitlab::Git::BLANK_SHA, newrev: '789012', ref: ""#{ref_prefix}/create1"" },
          { index: 1, oldrev: Gitlab::Git::BLANK_SHA, newrev: '789013', ref: ""#{ref_prefix}/create2"" },
          { index: 2, oldrev: Gitlab::Git::BLANK_SHA, newrev: '789014', ref: ""#{ref_prefix}/create3"" },
          { index: 3, oldrev: '789015', newrev: '789016', ref: ""#{ref_prefix}/changed1"" },
          { index: 4, oldrev: '789017', newrev: '789018', ref: ""#{ref_prefix}/changed2"" },
          { index: 5, oldrev: '789019', newrev: Gitlab::Git::BLANK_SHA, ref: ""#{ref_prefix}/removed1"" },
          { index: 6, oldrev: '789020', newrev: Gitlab::Git::BLANK_SHA, ref: ""#{ref_prefix}/removed2"" }
        ]
      end

      let(:git_changes) { double(branch_changes: branch_changes, tag_changes: tag_changes) }

      before do
        allow(MergeRequests::PushedBranchesService).to receive(:new).and_return(
          double(execute: %w[create1 create2]), double(execute: %w[changed1]), double(execute: %w[removed2])
        )

        allow(Gitlab::Git::Commit).to receive(:between).and_return([])
      end

      it 'schedules job for existing merge requests' do
        expect(UpdateMergeRequestsWorker).to receive(:perform_async).with(
          project.id,
          user.id,
          Gitlab::Git::BLANK_SHA,
          '789012',
          ""#{ref_prefix}/create1"",
          { 'push_options' => nil }).ordered

        expect(UpdateMergeRequestsWorker).to receive(:perform_async).with(
          project.id,
          user.id,
          Gitlab::Git::BLANK_SHA,
          '789013',
          ""#{ref_prefix}/create2"",
          { 'push_options' => nil }).ordered

        expect(UpdateMergeRequestsWorker).to receive(:perform_async).with(
          project.id,
          user.id,
          '789015',
          '789016',
          ""#{ref_prefix}/changed1"",
          { 'push_options' => nil }).ordered

        expect(UpdateMergeRequestsWorker).to receive(:perform_async).with(
          project.id,
          user.id,
          '789020',
          Gitlab::Git::BLANK_SHA,
          ""#{ref_prefix}/removed2"",
          { 'push_options' => nil }).ordered

        subject.execute
      end
    end
  end

  context 'tag changes' do
    let(:changes_method) { :tag_changes }
    let(:ref_prefix) { 'refs/tags' }

    it_behaves_like 'service for processing ref changes', Git::TagPushService
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Git
  class TagHooksService < ::Git::BaseHooksService
    private

    def hook_name
      :tag_push_hooks
    end

    def limited_commits
      [tag_commit].compact
    end

    def commits_count
      limited_commits.count
    end

    def event_message
      tag&.message
    end

    def tag
      strong_memoize(:tag) do
        next if Gitlab::Git.blank_ref?(newrev)

        tag_name = Gitlab::Git.ref_name(ref)
        tag = project.repository.find_tag(tag_name)

        tag if tag && tag.target == newrev
      end
    end

    def tag_commit
      strong_memoize(:tag_commit) do
        project.commit(tag.dereferenced_target) if tag
      end
    end
  end
end

Git::TagHooksService.prepend_mod_with('Git::TagHooksService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Git::TagHooksService, :service, feature_category: :source_code_management do
  let(:user) { create(:user) }
  let(:project) { create(:project, :repository) }

  let(:oldrev) { Gitlab::Git::BLANK_SHA }
  let(:newrev) { ""8a2a6eb295bb170b34c24c76c49ed0e9b2eaf34b"" } # gitlab-test: git rev-parse refs/tags/v1.1.0
  let(:ref) { ""refs/tags/#{tag_name}"" }
  let(:tag_name) { 'v1.1.0' }

  let(:tag) { project.repository.find_tag(tag_name) }
  let(:commit) { tag.dereferenced_target }

  let(:service) do
    described_class.new(project, user, change: { oldrev: oldrev, newrev: newrev, ref: ref })
  end

  describe 'System hooks' do
    it 'executes system hooks' do
      push_data = service.send(:push_data)
      expect(project).to receive(:has_active_hooks?).and_return(true)

      expect_next_instance_of(SystemHooksService) do |system_hooks_service|
        expect(system_hooks_service)
          .to receive(:execute_hooks)
          .with(push_data, :tag_push_hooks)
      end

      service.execute
    end
  end

  describe ""Webhooks"" do
    it ""executes hooks on the project"" do
      expect(project).to receive(:has_active_hooks?).and_return(true)
      expect(project).to receive(:execute_hooks)

      service.execute
    end
  end

  describe ""Pipelines"" do
    before do
      stub_ci_pipeline_to_return_yaml_file
      project.add_developer(user)
    end

    it ""creates a new pipeline"" do
      expect { service.execute }.to change { Ci::Pipeline.count }

      expect(Ci::Pipeline.last).to be_push
    end
  end

  describe 'Push data' do
    shared_examples_for 'tag push data expectations' do
      subject(:push_data) { service.send(:push_data) }

      it 'has expected push data attributes' do
        is_expected.to match a_hash_including(
          object_kind: 'tag_push',
          ref: ref,
          ref_protected: project.protected_for?(ref),
          before: oldrev,
          after: newrev,
          message: tag.message,
          user_id: user.id,
          user_name: user.name,
          project_id: project.id
        )
      end

      context ""with repository data"" do
        subject { push_data[:repository] }

        it 'has expected repository attributes' do
          is_expected.to match a_hash_including(
            name: project.name,
            url: project.url_to_repo,
            description: project.description,
            homepage: project.web_url
          )
        end
      end

      context ""with commits"" do
        subject { push_data[:commits] }

        it { is_expected.to be_an(Array) }

        it 'has 1 element' do
          expect(subject.size).to eq(1)
        end

        context ""the commit"" do
          subject { push_data[:commits].first }

          it { is_expected.to include(timestamp: commit.date.xmlschema) }

          it 'has expected commit attributes' do
            is_expected.to match a_hash_including(
              id: commit.id,
              message: commit.safe_message,
              url: [
                Gitlab.config.gitlab.url,
                project.namespace.to_param,
                project.to_param,
                '-',
                'commit',
                commit.id
              ].join('/')
            )
          end

          context ""with an author"" do
            subject { push_data[:commits].first[:author] }

            it 'has expected author attributes' do
              is_expected.to match a_hash_including(
                name: commit.author_name,
                email: commit.author_email
              )
            end
          end
        end
      end
    end

    context 'annotated tag' do
      include_examples 'tag push data expectations'
    end

    context 'lightweight tag' do
      let(:tag_name) { 'light-tag' }
      let(:newrev) { '5937ac0a7beb003549fc5fd26fc247adbce4a52e' }

      before do
        # Create the lightweight tag
        project.repository.write_ref(""refs/tags/#{tag_name}"", newrev)

        # Clear tag list cache
        project.repository.expire_tags_cache
      end

      include_examples 'tag push data expectations'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Git
  class BaseHooksService < ::BaseService
    include Gitlab::Utils::StrongMemoize
    include ChangeParams

    # The N most recent commits to process in a single push payload.
    PROCESS_COMMIT_LIMIT = 100

    def execute
      create_events
      create_pipelines
      execute_project_hooks

      # Not a hook, but it needs access to the list of changed commits
      enqueue_invalidate_cache
      enqueue_notify_kas

      success
    end

    private

    def hook_name
      raise NotImplementedError, ""Please implement #{self.class}##{__method__}""
    end

    # This should return PROCESS_COMMIT_LIMIT commits, ordered with newest last
    def limited_commits
      raise NotImplementedError, ""Please implement #{self.class}##{__method__}""
    end

    def commits_count
      raise NotImplementedError, ""Please implement #{self.class}##{__method__}""
    end

    def event_message
      nil
    end

    def invalidated_file_types
      []
    end

    # Push events in the activity feed only show information for the
    # last commit.
    def create_events
      return unless params.fetch(:create_push_event, true)

      EventCreateService.new.push(project, current_user, event_push_data)
    end

    def create_pipelines
      return unless params.fetch(:create_pipelines, true)

      response = Ci::CreatePipelineService
          .new(project, current_user, pipeline_params)
          .execute(:push, **pipeline_options)

      log_pipeline_errors(response.message) unless response.payload.persisted?
    end

    def execute_project_hooks
      return unless params.fetch(:execute_project_hooks, true)

      # Creating push_data invokes one CommitDelta RPC per commit. Only
      # build this data if we actually need it.
      project.execute_hooks(push_data, hook_name) if project.has_active_hooks?(hook_name)

      return unless project.has_active_integrations?(hook_name)

      project.execute_integrations(push_data, hook_name, skip_ci: integration_push_options&.fetch(:skip_ci).present?)
    end

    def enqueue_invalidate_cache
      file_types = invalidated_file_types

      return unless file_types.present?

      ProjectCacheWorker.perform_async(project.id, file_types, [], false)
    end

    def enqueue_notify_kas
      return unless Gitlab::Kas.enabled?

      Clusters::Agents::NotifyGitPushWorker.perform_async(project.id)
    end

    def pipeline_params
      strong_memoize(:pipeline_params) do
        {
          before: oldrev,
          after: newrev,
          ref: ref,
          variables_attributes: generate_vars_from_push_options || [],
          push_options: params[:push_options] || {},
          checkout_sha: Gitlab::DataBuilder::Push.checkout_sha(
            project.repository, newrev, ref)
        }
      end
    end

    def ci_variables_from_push_options
      strong_memoize(:ci_variables_from_push_options) do
        push_options&.dig(:ci, :variable)
      end
    end

    def integration_push_options
      strong_memoize(:integration_push_options) do
        push_options&.dig(:integrations)
      end
    end

    def push_options
      strong_memoize(:push_options) do
        params[:push_options]&.deep_symbolize_keys
      end
    end

    def generate_vars_from_push_options
      return [] unless ci_variables_from_push_options

      ci_variables_from_push_options.map do |var_definition, _count|
        key, value = var_definition.to_s.split(""="", 2)

        # Accept only valid format. We ignore the following formats
        # 1. ""=123"". In this case, `key` will be an empty string
        # 2. ""FOO"". In this case, `value` will be nil.
        # However, the format ""FOO="" will result in key beign `FOO` and value
        # being an empty string. This is acceptable.
        next if key.blank? || value.nil?

        { ""key"" => key, ""variable_type"" => ""env_var"", ""secret_value"" => value }
      end.compact
    end

    def push_data_params(commits:, with_changed_files: true)
      {
        oldrev: oldrev,
        newrev: newrev,
        ref: ref,
        project: project,
        user: current_user,
        commits: commits,
        message: event_message,
        commits_count: commits_count,
        with_changed_files: with_changed_files
      }
    end

    def event_push_data
      # We only need the newest commit for the event push, and we don't
      # need the full deltas either.
      @event_push_data ||= Gitlab::DataBuilder::Push.build(
        **push_data_params(commits: limited_commits.last, with_changed_files: false)
      )
    end

    def push_data
      @push_data ||= Gitlab::DataBuilder::Push.build(**push_data_params(commits: limited_commits))

      # Dependent code may modify the push data, so return a duplicate each time
      @push_data.dup
    end

    # to be overridden in EE
    def pipeline_options
      {}
    end

    def log_pipeline_errors(error_message)
      data = {
        class: self.class.name,
        correlation_id: Labkit::Correlation::CorrelationId.current_id.to_s,
        project_id: project.id,
        project_path: project.full_path,
        message: ""Error creating pipeline"",
        errors: error_message,
        pipeline_params: sanitized_pipeline_params
      }

      logger.warn(data)
    end

    def sanitized_pipeline_params
      pipeline_params.except(:push_options)
    end

    def logger
      if Gitlab::Runtime.sidekiq?
        Sidekiq.logger
      else
        # This service runs in Sidekiq, so this shouldn't ever be
        # called, but this is included just in case.
        Gitlab::IntegrationsLogger
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Git::BaseHooksService, feature_category: :source_code_management do
  include RepoHelpers

  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project, :repository) }

  let(:oldrev) { Gitlab::Git::BLANK_SHA }
  let(:newrev) { ""8a2a6eb295bb170b34c24c76c49ed0e9b2eaf34b"" } # gitlab-test: git rev-parse refs/tags/v1.1.0
  let(:ref) { 'refs/tags/v1.1.0' }
  let(:checkout_sha) { '5937ac0a7beb003549fc5fd26fc247adbce4a52e' }

  let(:test_service) do
    Class.new(described_class) do
      def hook_name
        :push_hooks
      end

      def limited_commits
        []
      end

      def commits_count
        0
      end
    end
  end

  subject { test_service.new(project, user, params) }

  let(:params) do
    {
      change: {
        oldrev: oldrev,
        newrev: newrev,
        ref: ref
      }
    }
  end

  describe 'push event' do
    it 'creates push event' do
      expect_next_instance_of(EventCreateService) do |service|
        expect(service).to receive(:push)
      end

      subject.execute
    end

    context 'create_push_event is set to false' do
      before do
        params[:create_push_event] = false
      end

      it 'does not create push event' do
        expect(EventCreateService).not_to receive(:new)

        subject.execute
      end
    end
  end

  describe 'project hooks and integrations' do
    context 'hooks' do
      before do
        expect(project).to receive(:has_active_hooks?).and_return(active)
      end

      context 'active hooks' do
        let(:active) { true }

        it 'executes the hooks' do
          expect(subject).to receive(:push_data).at_least(:once).and_call_original
          expect(project).to receive(:execute_hooks)

          subject.execute
        end
      end

      context 'inactive hooks' do
        let(:active) { false }

        it 'does not execute the hooks' do
          expect(subject).not_to receive(:push_data)
          expect(project).not_to receive(:execute_hooks)

          subject.execute
        end
      end
    end

    context 'with integrations' do
      before do
        expect(project).to receive(:has_active_integrations?).and_return(active)
      end

      context 'with active integrations' do
        let(:active) { true }

        it 'executes the services' do
          expect(subject).to receive(:push_data).at_least(:once).and_call_original
          expect(project).to receive(:execute_integrations).with(kind_of(Hash), subject.hook_name, skip_ci: false)

          subject.execute
        end

        context 'with integrations.skip_ci push option' do
          before do
            params[:push_options] = {
              integrations: { skip_ci: true }
            }
          end

          it 'executes the services' do
            expect(subject).to receive(:push_data).at_least(:once).and_call_original
            expect(project).to receive(:execute_integrations).with(kind_of(Hash), subject.hook_name, skip_ci: true)

            subject.execute
          end
        end
      end

      context 'with inactive integrations' do
        let(:active) { false }

        it 'does not execute the services' do
          expect(subject).not_to receive(:push_data)
          expect(project).not_to receive(:execute_integrations)

          subject.execute
        end
      end
    end

    context 'when execute_project_hooks param is set to false' do
      before do
        params[:execute_project_hooks] = false

        allow(project).to receive(:has_active_hooks?).and_return(true)
        allow(project).to receive(:has_active_integrations?).and_return(true)
      end

      it 'does not execute hooks and integrations' do
        expect(project).not_to receive(:execute_hooks)
        expect(project).not_to receive(:execute_integrations)

        subject.execute
      end
    end
  end

  describe 'Generating CI variables from push options' do
    let(:pipeline_params) do
      {
        after: newrev,
        before: oldrev,
        checkout_sha: checkout_sha,
        push_options: push_options, # defined in each context
        ref: ref,
        variables_attributes: variables_attributes # defined in each context
      }
    end

    shared_examples 'creates pipeline with params and expected variables' do
      let(:pipeline_service) { double(execute: service_response) }
      let(:service_response) { double(error?: false, payload: pipeline, message: ""Error"") }
      let(:pipeline) { double(persisted?: true) }

      it 'calls the create pipeline service' do
        expect(Ci::CreatePipelineService)
          .to receive(:new)
          .with(project, user, pipeline_params)
          .and_return(pipeline_service)
        expect(subject).not_to receive(:log_pipeline_errors)

        subject.execute
      end
    end

    context 'with empty push options' do
      let(:push_options) { {} }
      let(:variables_attributes) { [] }

      it_behaves_like 'creates pipeline with params and expected variables'
    end

    context 'with push options not specifying variables' do
      let(:push_options) do
        {
          mr: {
            create: true
          }
        }
      end

      let(:variables_attributes) { [] }

      before do
        params[:push_options] = push_options
      end

      it_behaves_like 'creates pipeline with params and expected variables'
    end

    context 'with push options specifying variables' do
      let(:push_options) do
        {
          ci: {
            variable: {
              ""FOO=123"": 1,
              ""BAR=456"": 1,
              ""MNO=890=ABC"": 1
            }
          }
        }
      end

      let(:variables_attributes) do
        [
          { ""key"" => ""FOO"", ""variable_type"" => ""env_var"", ""secret_value"" => ""123"" },
          { ""key"" => ""BAR"", ""variable_type"" => ""env_var"", ""secret_value"" => ""456"" },
          { ""key"" => ""MNO"", ""variable_type"" => ""env_var"", ""secret_value"" => ""890=ABC"" }
        ]
      end

      before do
        params[:push_options] = push_options
      end

      it_behaves_like 'creates pipeline with params and expected variables'
    end

    context 'with push options not specifying variables in correct format' do
      let(:push_options) do
        {
          ci: {
            variable: {
              ""FOO=123"": 1,
              ""BAR"": 1,
              ""=MNO"": 1
            }
          }
        }
      end

      let(:variables_attributes) do
        [
          { ""key"" => ""FOO"", ""variable_type"" => ""env_var"", ""secret_value"" => ""123"" }
        ]
      end

      before do
        params[:push_options] = push_options
      end

      it_behaves_like 'creates pipeline with params and expected variables'
    end
  end

  describe ""Pipeline creation"" do
    let(:pipeline_params) do
      {
        after: newrev,
        before: oldrev,
        checkout_sha: checkout_sha,
        push_options: push_options,
        ref: ref,
        variables_attributes: variables_attributes
      }
    end

    let(:pipeline_service) { double(execute: service_response) }
    let(:push_options) { {} }
    let(:variables_attributes) { [] }

    context ""when the pipeline is persisted"" do
      let(:pipeline) { double(persisted?: true) }

      context ""and there are no errors"" do
        let(:service_response) { double(error?: false, payload: pipeline, message: ""Error"") }

        it ""returns success"" do
          expect(Ci::CreatePipelineService)
            .to receive(:new)
            .with(project, user, pipeline_params)
            .and_return(pipeline_service)

          expect(subject.execute[:status]).to eq(:success)
        end
      end

      context ""and there are errors"" do
        let(:service_response) { double(error?: true, payload: pipeline, message: ""Error"") }

        it ""does not log errors and returns success"" do
          # This behaviour is due to the save_on_errors: true setting that is the default in the execute method.
          expect(Ci::CreatePipelineService)
            .to receive(:new)
            .with(project, user, pipeline_params)
            .and_return(pipeline_service)
          expect(subject).not_to receive(:log_pipeline_errors).with(service_response.message)

          expect(subject.execute[:status]).to eq(:success)
        end
      end
    end

    context ""when the pipeline wasn't persisted"" do
      let(:pipeline) { double(persisted?: false) }

      context ""and there are no errors"" do
        let(:service_response) { double(error?: false, payload: pipeline, message: nil) }

        it ""returns success"" do
          expect(Ci::CreatePipelineService)
            .to receive(:new)
            .with(project, user, pipeline_params)
            .and_return(pipeline_service)
          expect(subject).to receive(:log_pipeline_errors).with(service_response.message)

          expect(subject.execute[:status]).to eq(:success)
        end
      end

      context ""and there are errors"" do
        let(:service_response) { double(error?: true, payload: pipeline, message: ""Error"") }

        it ""logs errors and returns success"" do
          expect(Ci::CreatePipelineService)
            .to receive(:new)
            .with(project, user, pipeline_params)
            .and_return(pipeline_service)
          expect(subject).to receive(:log_pipeline_errors).with(service_response.message)

          expect(subject.execute[:status]).to eq(:success)
        end
      end
    end
  end

  describe 'notifying KAS' do
    let(:kas_enabled) { true }

    before do
      allow(Gitlab::Kas).to receive(:enabled?).and_return(kas_enabled)
    end

    it 'enqueues the notification worker' do
      expect(Clusters::Agents::NotifyGitPushWorker).to receive(:perform_async).with(project.id).once

      subject.execute
    end

    context 'when KAS is disabled' do
      let(:kas_enabled) { false }

      it do
        expect(Clusters::Agents::NotifyGitPushWorker).not_to receive(:perform_async)

        subject.execute
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Git
  class WikiPushService < ::BaseService
    # Maximum number of change events we will process on any single push
    MAX_CHANGES = 100

    attr_reader :wiki

    def initialize(wiki, current_user, params)
      @wiki = wiki
      @current_user = current_user
      @params = params.dup
    end

    def execute
      # Execute model-specific callbacks
      wiki.after_post_receive

      process_changes
      perform_housekeeping
    end

    private

    def process_changes
      return unless can_process_wiki_events?

      push_changes.take(MAX_CHANGES).each do |change| # rubocop:disable CodeReuse/ActiveRecord
        next unless change.page.present?

        response = create_event_for(change)
        log_error(response.message) if response.error?
      end
    end

    def can_process_wiki_events?
      # TODO: Support activity events for group wikis
      # https://gitlab.com/gitlab-org/gitlab/-/issues/209306
      wiki.is_a?(ProjectWiki)
    end

    def push_changes
      default_branch_changes.flat_map do |change|
        raw_changes(change).map { |raw| Git::WikiPushService::Change.new(wiki, change, raw) }
      end
    end

    def raw_changes(change)
      wiki.repository.raw.raw_changes_between(change[:oldrev], change[:newrev])
    end

    def create_event_for(change)
      event_service.execute(
        change.last_known_slug,
        change.page,
        change.event_action,
        change.sha
      )
    end

    def event_service
      @event_service ||= WikiPages::EventCreateService.new(current_user)
    end

    def on_default_branch?(change)
      wiki.default_branch == ::Gitlab::Git.branch_name(change[:ref])
    end

    # See: [Gitlab::GitPostReceive#changes]
    def changes
      params[:changes] || []
    end

    def default_branch_changes
      @default_branch_changes ||= changes.select { |change| on_default_branch?(change) }
    end

    def perform_housekeeping
      housekeeping = Repositories::HousekeepingService.new(wiki)
      housekeeping.increment!
      housekeeping.execute if housekeeping.needed?
    rescue Repositories::HousekeepingService::LeaseTaken
      # no-op
    end
  end
end

Git::WikiPushService.prepend_mod_with('Git::WikiPushService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Git::WikiPushService, services: true, feature_category: :wiki do
  include RepoHelpers

  let_it_be(:current_user) { create(:user) }
  let_it_be(:key_id) { create(:key, user: current_user).shell_id }

  let(:wiki) { create(:project_wiki, user: current_user) }
  let(:default_branch) { wiki.default_branch }
  let(:repository) { wiki.repository }

  before do
    repository.create_if_not_exists(default_branch)
  end

  describe '#execute' do
    it 'executes model-specific callbacks' do
      expect(wiki).to receive(:after_post_receive)

      create_service(current_sha).execute
    end
  end

  describe '#process_changes' do
    context 'the push contains more than the permitted number of changes' do
      def run_service
        process_changes { described_class::MAX_CHANGES.succ.times { write_new_page } }
      end

      it 'creates only MAX_CHANGES events' do
        expect { run_service }.to change(Event, :count).by(described_class::MAX_CHANGES)
      end
    end

    context 'default_branch collides with a tag' do
      it 'creates only one event' do
        base_sha = current_sha
        write_new_page

        service = create_service(base_sha, ['refs/heads/master', 'refs/tags/master'])

        expect { service.execute }.to change(Event, :count).by(1)
      end
    end

    describe 'successfully creating events' do
      let(:count) { Event::WIKI_ACTIONS.size }

      def run_service
        wiki_page_a = create(:wiki_page, wiki: wiki)
        wiki_page_b = create(:wiki_page, wiki: wiki)

        process_changes do
          write_new_page
          update_page(wiki_page_a.title)
          delete_page(wiki_page_b.page)
        end
      end

      it 'creates one event for every wiki action' do
        expect { run_service }.to change(Event, :count).by(count)
      end

      it 'handles all known actions' do
        run_service

        expect(Event.last(count).pluck(:action)).to match_array(Event::WIKI_ACTIONS.map(&:to_s))
      end

      context 'when wiki_page slug is not UTF-8 ' do
        let(:binary_title) { Gitlab::EncodingHelper.encode_binary('编码') }

        def run_service
          wiki_page = create(:wiki_page, wiki: wiki, title: ""#{binary_title} 'foo'"")

          process_changes do
            # Test that new_path is converted to UTF-8
            create(:wiki_page, wiki: wiki, title: binary_title)

            # Test that old_path is also is converted to UTF-8
            update_page(wiki_page.title, 'foo')
          end
        end

        it 'does not raise an error' do
          expect { run_service }.not_to raise_error
        end
      end
    end

    context 'two pages have been created' do
      def run_service
        process_changes do
          write_new_page
          write_new_page
        end
      end

      it 'creates two events' do
        expect { run_service }.to change(Event, :count).by(2)
      end

      it 'creates two metadata records' do
        expect { run_service }.to change(WikiPage::Meta, :count).by(2)
      end

      it 'creates appropriate events' do
        run_service

        expect(Event.last(2)).to all(have_attributes(wiki_page?: true, action: 'created'))
      end
    end

    context 'a non-page file as been added' do
      it 'does not create events, or WikiPage metadata' do
        expect do
          process_changes { write_non_page }
        end.not_to change { [Event.count, WikiPage::Meta.count] }
      end
    end

    context 'one page, and one non-page have been created' do
      def run_service
        process_changes do
          write_new_page
          write_non_page
        end
      end

      it 'creates a wiki page creation event' do
        expect { run_service }.to change(Event, :count).by(1)

        expect(Event.last).to have_attributes(wiki_page?: true, action: 'created')
      end

      it 'creates one metadata record' do
        expect { run_service }.to change(WikiPage::Meta, :count).by(1)
      end
    end

    context 'one page has been added, and then updated' do
      def run_service
        process_changes do
          title = write_new_page
          update_page(title)
        end
      end

      it 'creates just a single event' do
        expect { run_service }.to change(Event, :count).by(1)
      end

      it 'creates just one metadata record' do
        expect { run_service }.to change(WikiPage::Meta, :count).by(1)
      end

      it 'creates a new wiki page creation event' do
        run_service

        expect(Event.last).to have_attributes(
          wiki_page?: true,
          action: 'created'
        )
      end
    end

    context 'when a page we already know about has been updated' do
      let(:wiki_page) { create(:wiki_page, wiki: wiki) }

      before do
        create(:wiki_page_meta, :for_wiki_page, wiki_page: wiki_page)
      end

      def run_service
        process_changes { update_page(wiki_page.title) }
      end

      it 'does not create a new meta-data record' do
        expect { run_service }.not_to change(WikiPage::Meta, :count)
      end

      it 'creates a new event' do
        expect { run_service }.to change(Event, :count).by(1)
      end

      it 'adds an update event' do
        run_service

        expect(Event.last).to have_attributes(
          wiki_page?: true,
          action: 'updated'
        )
      end
    end

    context 'when a page we do not know about has been updated' do
      def run_service
        wiki_page = create(:wiki_page, wiki: wiki)
        process_changes { update_page(wiki_page.title) }
      end

      it 'creates a new meta-data record' do
        expect { run_service }.to change(WikiPage::Meta, :count).by(1)
      end

      it 'creates a new event' do
        expect { run_service }.to change(Event, :count).by(1)
      end

      it 'adds an update event' do
        run_service

        expect(Event.last).to have_attributes(
          wiki_page?: true,
          action: 'updated'
        )
      end
    end

    context 'when a page we do not know about has been deleted' do
      def run_service
        wiki_page = create(:wiki_page, wiki: wiki)
        process_changes { delete_page(wiki_page.page) }
      end

      it 'create a new meta-data record' do
        expect { run_service }.to change(WikiPage::Meta, :count).by(1)
      end

      it 'creates a new event' do
        expect { run_service }.to change(Event, :count).by(1)
      end

      it 'adds an update event' do
        run_service

        expect(Event.last).to have_attributes(
          wiki_page?: true,
          action: 'destroyed'
        )
      end
    end

    it 'calls log_error for every event we cannot create' do
      base_sha = current_sha
      count = 3
      count.times { write_new_page }
      message = 'something went very very wrong'
      allow_next_instance_of(WikiPages::EventCreateService, current_user) do |service|
        allow(service).to receive(:execute)
          .with(String, WikiPage, Symbol, String)
          .and_return(ServiceResponse.error(message: message))
      end

      service = create_service(base_sha)

      expect(service).to receive(:log_error).exactly(count).times.with(message)

      service.execute
    end

    describe 'feature flags' do
      shared_examples 'a no-op push' do
        it 'does not create any events' do
          expect { process_changes { write_new_page } }.not_to change(Event, :count)
        end

        it 'does not even look for events to process' do
          base_sha = current_sha
          write_new_page

          service = create_service(base_sha)

          expect(service).not_to receive(:changed_files)

          service.execute
        end
      end
    end
  end

  describe '#perform_housekeeping', :clean_gitlab_redis_shared_state do
    let(:housekeeping) { Repositories::HousekeepingService.new(wiki) }

    subject { create_service(current_sha).execute }

    before do
      allow(Repositories::HousekeepingService).to receive(:new).and_return(housekeeping)
    end

    it 'does not perform housekeeping when not needed' do
      expect(housekeeping).not_to receive(:execute)

      subject
    end

    context 'when housekeeping is needed' do
      before do
        allow(housekeeping).to receive(:needed?).and_return(true)
      end

      it 'performs housekeeping' do
        expect(housekeeping).to receive(:execute)

        subject
      end

      it 'does not raise an exception' do
        allow(housekeeping).to receive(:try_obtain_lease).and_return(false)

        expect { subject }.not_to raise_error
      end
    end

    it 'increments the push counter' do
      expect(housekeeping).to receive(:increment!)

      subject
    end
  end

  # In order to construct the correct GitPostReceive object that represents the
  # changes we are applying, we need to describe the changes between old-ref and
  # new-ref. Old ref (the base sha) we have to capture before we perform any
  # changes. Once the changes have been applied, we can execute the service to
  # process them.
  def process_changes(&block)
    base_sha = current_sha
    yield
    create_service(base_sha).execute
  end

  def create_service(base, refs = ['refs/heads/master'])
    changes = post_received(base, refs).changes
    described_class.new(wiki, current_user, changes: changes)
  end

  def post_received(base, refs)
    change_str = refs.map { |ref| +""#{base} #{current_sha} #{ref}"" }.join(""\n"")
    post_received = ::Gitlab::GitPostReceive.new(wiki.container, key_id, change_str, {})
    allow(post_received).to receive(:identify).with(key_id).and_return(current_user)

    post_received
  end

  def current_sha
    repository.commit('master')&.id || Gitlab::Git::BLANK_SHA
  end

  # It is important not to re-use the WikiPage services here, since they create
  # events - these helper methods below are intended to simulate actions on the repo
  # that have not gone through our services.

  def write_new_page
    generate(:wiki_page_title).tap do |t|
      repository.create_file(
        current_user, ::Wiki.sluggified_full_path(t, 'md'), 'Hello',
        **commit_details
      )
    end
  end

  # We write something to the wiki-repo that is not a page - as, for example, an
  # attachment. This will appear as a raw-diff change, but wiki.find_page will
  # return nil.
  def write_non_page
    params = {
      file_name: 'attachment.log',
      file_content: 'some stuff',
      branch_name: 'master'
    }
    ::Wikis::CreateAttachmentService.new(container: wiki.container, current_user: current_user, params: params).execute
  end

  def update_page(title, new_title = nil)
    new_title = title unless new_title.present?

    old_path = ::Wiki.sluggified_full_path(title, 'md')
    new_path = ::Wiki.sluggified_full_path(new_title, 'md')

    repository.update_file(
      current_user, new_path, 'Hey',
      **commit_details.merge(previous_path: old_path)
    )
  end

  def delete_page(page)
    repository.delete_file(current_user, page.path, **commit_details)
  end

  def commit_details
    {
      branch_name: default_branch,
      message: ""commit message"",
      author_email: current_user.email,
      author_name: current_user.name
    }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Git
  class BranchHooksService < ::Git::BaseHooksService
    extend ::Gitlab::Utils::Override

    JIRA_SYNC_BATCH_SIZE = 20
    JIRA_SYNC_BATCH_DELAY = 10.seconds

    def execute
      execute_branch_hooks

      super.tap do
        enqueue_update_signatures
      end
    end

    private

    def hook_name
      :push_hooks
    end

    def limited_commits
      strong_memoize(:limited_commits) { threshold_commits.last(PROCESS_COMMIT_LIMIT) }
    end

    # Taking limit+1 commits allows us to detect when the limit is in effect
    def threshold_commits
      strong_memoize(:threshold_commits) do
        if creating_default_branch?
          # The most recent PROCESS_COMMIT_LIMIT commits in the default branch.
          # They are returned newest-to-oldest, but we need to present them oldest-to-newest
          project.repository.commits(newrev, limit: PROCESS_COMMIT_LIMIT + 1).reverse!
        elsif creating_branch?
          # Use the pushed commits that aren't reachable by the default branch
          # as a heuristic. This may include more commits than are actually
          # pushed, but that shouldn't matter because we check for existing
          # cross-references later.
          project.repository.commits_between(project.default_branch, newrev, limit: PROCESS_COMMIT_LIMIT + 1)
        elsif updating_branch?
          project.repository.commits_between(oldrev, newrev, limit: PROCESS_COMMIT_LIMIT + 1)
        else # removing branch
          []
        end
      end
    end

    def commits_count
      strong_memoize(:commits_count) do
        next threshold_commits.count if
          strong_memoized?(:threshold_commits) &&
          threshold_commits.count <= PROCESS_COMMIT_LIMIT

        if creating_default_branch?
          project.repository.commit_count_for_ref(ref)
        elsif creating_branch?
          project.repository.count_commits_between(project.default_branch, newrev)
        elsif updating_branch?
          project.repository.count_commits_between(oldrev, newrev)
        else # removing branch
          0
        end
      end
    end

    override :invalidated_file_types
    def invalidated_file_types
      return super unless default_branch? && !creating_branch?

      modified_file_types
    end

    def modified_file_types
      paths = commit_paths.values.reduce(&:merge) || Set.new

      Gitlab::FileDetector.types_in_paths(paths)
    end

    def execute_branch_hooks
      project.repository.after_push_commit(branch_name)

      branch_create_hooks if creating_branch?
      branch_update_hooks if updating_branch?
      branch_change_hooks if creating_branch? || updating_branch?
      branch_remove_hooks if removing_branch?

      track_process_commit_limit_overflow
    end

    def branch_create_hooks
      project.repository.after_create_branch(expire_cache: false)
      project.after_create_default_branch if default_branch?
    end

    def branch_update_hooks
      # Update the bare repositories info/attributes file using the contents of
      # the default branch's .gitattributes file
      project.repository.copy_gitattributes(ref) if default_branch?
    end

    def branch_change_hooks
      enqueue_process_commit_messages
      enqueue_jira_connect_sync_messages
      track_ci_config_change_event
    end

    def branch_remove_hooks
      project.repository.after_remove_branch(expire_cache: false)
    end

    def track_ci_config_change_event
      return unless default_branch?

      commits_changing_ci_config.each do |commit|
        Gitlab::UsageDataCounters::HLLRedisCounter.track_event(
          'o_pipeline_authoring_unique_users_committing_ciconfigfile', values: commit.author&.id
        )
      end
    end

    def track_process_commit_limit_overflow
      return if threshold_commits.count <= PROCESS_COMMIT_LIMIT

      Gitlab::Metrics.add_event(:process_commit_limit_overflow)
    end

    # Schedules processing of commit messages
    def enqueue_process_commit_messages
      referencing_commits = limited_commits.select(&:matches_cross_reference_regex?)

      upstream_commit_ids = upstream_commit_ids(referencing_commits)

      referencing_commits.each do |commit|
        # Avoid reprocessing commits that already exist upstream if the project
        # is a fork. This will prevent duplicated/superfluous system notes on
        # mentionables referenced by a commit that is pushed to the upstream,
        # that is then also pushed to forks when these get synced by users.
        next if upstream_commit_ids.include?(commit.id)

        ProcessCommitWorker.perform_async(
          project.id,
          current_user.id,
          commit.to_hash,
          default_branch?
        )
      end
    end

    def enqueue_jira_connect_sync_messages
      return unless project.jira_subscription_exists?

      branch_to_sync = branch_name if Atlassian::JiraIssueKeyExtractors::Branch.has_keys?(project, branch_name)
      commits_to_sync = filtered_commit_shas

      return if branch_to_sync.nil? && commits_to_sync.empty?

      if commits_to_sync.any?
        commits_to_sync.each_slice(JIRA_SYNC_BATCH_SIZE).with_index do |commits, i|
          JiraConnect::SyncBranchWorker.perform_in(
            JIRA_SYNC_BATCH_DELAY * i,
            project.id,
            branch_to_sync,
            commits,
            Atlassian::JiraConnect::Client.generate_update_sequence_id
          )
        end
      else
        JiraConnect::SyncBranchWorker.perform_async(
          project.id,
          branch_to_sync,
          commits_to_sync,
          Atlassian::JiraConnect::Client.generate_update_sequence_id
        )
      end
    end

    def filtered_commit_shas
      limited_commits.select { |commit| Atlassian::JiraIssueKeyExtractor.has_keys?(commit.safe_message) }.map(&:sha)
    end

    def signature_types
      [
        ::CommitSignatures::GpgSignature,
        ::CommitSignatures::X509CommitSignature,
        ::CommitSignatures::SshSignature
      ]
    end

    def unsigned_commit_shas(commits)
      commit_shas = commits.map(&:sha)

      signature_types
        .map { |signature| signature.unsigned_commit_shas(commit_shas) }
        .reduce(&:&)
    end

    def enqueue_update_signatures
      unsigned = unsigned_commit_shas(limited_commits)
      return if unsigned.empty?

      signable = Gitlab::Git::Commit.shas_with_signatures(project.repository, unsigned)
      return if signable.empty?

      CreateCommitSignatureWorker.perform_async(signable, project.id)
    end

    # It's not sufficient to just check for a blank SHA as it's possible for the
    # branch to be pushed, but for the `post-receive` hook to never run:
    # https://gitlab.com/gitlab-org/gitlab-foss/issues/59257
    def creating_branch?
      strong_memoize(:creating_branch) do
        Gitlab::Git.blank_ref?(oldrev) ||
          !project.repository.branch_exists?(branch_name)
      end
    end

    def updating_branch?
      !creating_branch? && !removing_branch?
    end

    def removing_branch?
      Gitlab::Git.blank_ref?(newrev)
    end

    def creating_default_branch?
      creating_branch? && default_branch?
    end

    def default_branch?
      strong_memoize(:default_branch) do
        [nil, branch_name].include?(project.default_branch)
      end
    end

    def branch_name
      strong_memoize(:branch_name) { Gitlab::Git.ref_name(ref) }
    end

    def upstream_commit_ids(commits)
      set = Set.new

      upstream_project = project.fork_source
      if upstream_project
        upstream_project
          .commits_by(oids: commits.map(&:id))
          .each { |commit| set << commit.id }
      end

      set
    end

    def commits_changing_ci_config
      commit_paths.select do |commit, paths|
        next if commit.merge_commit?

        paths.include?(project.ci_config_path_or_default)
      end.keys
    end

    def commit_paths
      strong_memoize(:commit_paths) do
        limited_commits.to_h do |commit|
          paths = Set.new(commit.raw_deltas.map(&:new_path))
          [commit, paths]
        end
      end
    end
  end
end

Git::BranchHooksService.prepend_mod_with('Git::BranchHooksService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Git::BranchHooksService, :clean_gitlab_redis_shared_state, feature_category: :source_code_management do
  include RepoHelpers
  include ProjectForksHelper

  let(:project) { create(:project, :repository) }
  let(:user) { project.creator }

  let(:branch) { project.default_branch }
  let(:ref) { ""refs/heads/#{branch}"" }
  let(:commit_id) { sample_commit.id }
  let(:commit) { project.commit(commit_id) }
  let(:oldrev) { commit.parent_id }
  let(:newrev) { commit.id }

  let(:service) do
    described_class.new(project, user, change: { oldrev: oldrev, newrev: newrev, ref: ref })
  end

  describe ""Git Push Data"" do
    subject(:push_data) { service.send(:push_data) }

    it 'has expected push data attributes' do
      is_expected.to match a_hash_including(
        object_kind: 'push',
        before: oldrev,
        after: newrev,
        ref: ref,
        ref_protected: project.protected_for?(ref),
        user_id: user.id,
        user_name: user.name,
        project_id: project.id
      )
    end

    context ""with repository data"" do
      subject { push_data[:repository] }

      it 'has expected attributes' do
        is_expected.to match a_hash_including(
          name: project.name,
          url: project.url_to_repo,
          description: project.description,
          homepage: project.web_url
        )
      end
    end

    context ""with commits"" do
      subject { push_data[:commits] }

      it { is_expected.to be_an(Array) }

      it 'has 1 element' do
        expect(subject.size).to eq(1)
      end

      context ""the commit"" do
        subject { push_data[:commits].first }

        it { expect(subject[:timestamp].in_time_zone).to eq(commit.date.in_time_zone) }

        it 'includes expected commit data' do
          is_expected.to match a_hash_including(
            id: commit.id,
            message: commit.safe_message,
            url: [
              Gitlab.config.gitlab.url,
              project.namespace.to_param,
              project.to_param,
              '-',
              'commit',
              commit.id
            ].join('/')
          )
        end

        context ""with a author"" do
          subject { push_data[:commits].first[:author] }

          it 'includes expected author data' do
            is_expected.to match a_hash_including(
              name: commit.author_name,
              email: commit.author_email
            )
          end
        end
      end
    end
  end

  describe 'Push Event' do
    let(:event) { Event.pushed_action.take }

    subject(:execute_service) { service.execute }

    context ""with an existing branch"" do
      it 'generates a push event with one commit' do
        execute_service

        expect(event).to be_an_instance_of(PushEvent)
        expect(event.project).to eq(project)
        expect(event).to be_pushed_action
        expect(event.push_event_payload).to be_an_instance_of(PushEventPayload)
        expect(event.push_event_payload.commit_from).to eq(oldrev)
        expect(event.push_event_payload.commit_to).to eq(newrev)
        expect(event.push_event_payload.commit_title).to eq('Change some files')
        expect(event.push_event_payload.ref).to eq('master')
        expect(event.push_event_payload.commit_count).to eq(1)
      end

      context 'with changing CI config' do
        before do
          allow_next_instance_of(Gitlab::Git::Diff) do |diff|
            allow(diff).to receive(:new_path).and_return('.gitlab-ci.yml')
          end
        end

        let!(:commit_author) { create(:user, email: sample_commit.author_email) }

        let(:tracking_params) do
          ['o_pipeline_authoring_unique_users_committing_ciconfigfile', values: commit_author.id]
        end

        it 'tracks the event' do
          time = Time.zone.now

          execute_service

          expect(Gitlab::UsageDataCounters::HLLRedisCounter.unique_events(event_names: 'o_pipeline_authoring_unique_users_committing_ciconfigfile', start_date: time, end_date: time + 7.days)).to eq(1)
        end

        context 'when the branch is not the main branch' do
          let(:branch) { 'feature' }

          it 'does not track the event' do
            expect(Gitlab::UsageDataCounters::HLLRedisCounter)
              .not_to receive(:track_event).with(*tracking_params)

            execute_service
          end
        end

        context 'when the CI config is a different path' do
          before do
            project.ci_config_path = 'config/ci.yml'
          end

          it 'does not track the event' do
            expect(Gitlab::UsageDataCounters::HLLRedisCounter)
              .not_to receive(:track_event).with(*tracking_params)

            execute_service
          end
        end
      end
    end

    context ""with a new default branch"" do
      let(:oldrev) { Gitlab::Git::BLANK_SHA }

      it 'generates a push event with more than one commit' do
        execute_service

        expect(event).to be_an_instance_of(PushEvent)
        expect(event.project).to eq(project)
        expect(event).to be_pushed_action
        expect(event.push_event_payload).to be_an_instance_of(PushEventPayload)
        expect(event.push_event_payload.commit_from).to be_nil
        expect(event.push_event_payload.commit_to).to eq(newrev)
        expect(event.push_event_payload.commit_title).to eq('Change some files')
        expect(event.push_event_payload.ref).to eq('master')
        expect(event.push_event_payload.commit_count).to be > 1
      end
    end

    context ""with a new non-default branch"" do
      let(:oldrev) { Gitlab::Git::BLANK_SHA }
      let(:branch) { 'fix' }
      let(:commit_id) { project.commit(branch).id }

      it 'generates a push event with more than one commit' do
        execute_service

        expect(event).to be_an_instance_of(PushEvent)
        expect(event.project).to eq(project)
        expect(event).to be_pushed_action
        expect(event.push_event_payload).to be_an_instance_of(PushEventPayload)
        expect(event.push_event_payload.commit_from).to be_nil
        expect(event.push_event_payload.commit_to).to eq(newrev)
        expect(event.push_event_payload.commit_title).to eq('Test file for directories with a leading dot')
        expect(event.push_event_payload.ref).to eq('fix')
        expect(event.push_event_payload.commit_count).to be > 1
      end
    end

    context 'removing a branch' do
      let(:newrev) { Gitlab::Git::BLANK_SHA }

      it 'generates a push event with no commits' do
        execute_service

        expect(event).to be_an_instance_of(PushEvent)
        expect(event.project).to eq(project)
        expect(event).to be_pushed_action
        expect(event.push_event_payload).to be_an_instance_of(PushEventPayload)
        expect(event.push_event_payload.commit_from).to eq(oldrev)
        expect(event.push_event_payload.commit_to).to be_nil
        expect(event.push_event_payload.ref).to eq('master')
        expect(event.push_event_payload.commit_count).to eq(0)
      end
    end
  end

  describe 'Invalidating project cache' do
    let(:commit_id) do
      project.repository.update_file(
        user, 'README.md', '', message: 'Update', branch_name: branch
      )
    end

    let(:blank_sha) { Gitlab::Git::BLANK_SHA }

    def clears_cache(extended: [])
      expect(service).to receive(:invalidated_file_types).and_return(extended)

      if extended.present?
        expect(ProjectCacheWorker)
          .to receive(:perform_async)
          .with(project.id, extended, [], false)
      end

      service.execute
    end

    def clears_extended_cache
      clears_cache(extended: %i[readme])
    end

    context 'on default branch' do
      context 'create' do
        # FIXME: When creating the default branch,the cache worker runs twice
        before do
          allow(ProjectCacheWorker).to receive(:perform_async)
        end

        let(:oldrev) { blank_sha }

        it { clears_cache }
      end

      context 'update' do
        it { clears_extended_cache }
      end

      context 'remove' do
        let(:newrev) { blank_sha }

        # TODO: this case should pass, but we only take account of added files
        it { clears_cache }
      end
    end

    context 'on ordinary branch' do
      let(:branch) { 'fix' }

      context 'create' do
        let(:oldrev) { blank_sha }

        it { clears_cache }
      end

      context 'update' do
        it { clears_cache }
      end

      context 'remove' do
        let(:newrev) { blank_sha }

        it { clears_cache }
      end
    end
  end

  describe 'signatures' do
    context 'when the commit has a signature' do
      context 'when the signature is already cached' do
        before do
          create(:gpg_signature, commit_sha: commit.id)
        end

        it 'does not queue a CreateCommitSignatureWorker' do
          expect(CreateCommitSignatureWorker).not_to receive(:perform_async)

          service.execute
        end
      end

      context 'when the signature is not yet cached' do
        it 'queues a CreateCommitSignatureWorker' do
          expect(CreateCommitSignatureWorker).to receive(:perform_async).with([commit.id], project.id)

          service.execute
        end

        it 'can queue several commits to create the gpg signature' do
          allow(Gitlab::Git::Commit)
            .to receive(:shas_with_signatures)
            .and_return([sample_commit.id, another_sample_commit.id])

          expect(CreateCommitSignatureWorker)
            .to receive(:perform_async)
            .with([sample_commit.id, another_sample_commit.id], project.id)

          service.execute
        end
      end
    end

    context 'when the commit does not have a signature' do
      before do
        allow(Gitlab::Git::Commit)
          .to receive(:shas_with_signatures)
          .with(project.repository, [sample_commit.id])
          .and_return([])
      end

      it 'does not queue a CreateCommitSignatureWorker' do
        expect(CreateCommitSignatureWorker)
          .not_to receive(:perform_async)
          .with(sample_commit.id, project.id)

        service.execute
      end
    end
  end

  describe 'Processing commit messages' do
    # Create 6 commits, 3 of which have references. Limiting to 4 commits, we
    # expect to see two commit message processors enqueued.
    let!(:commit_ids) do
      Array.new(6) do |i|
        message = ""Issue #{'#' if i.even?}#{i}""
        project.repository.update_file(
          user, 'README.md', '', message: message, branch_name: branch
        )
      end
    end

    let(:commits_count) { service.send(:commits_count) }
    let(:threshold_limit) { described_class::PROCESS_COMMIT_LIMIT + 1 }

    let(:oldrev) { project.commit(commit_ids.first).parent_id }
    let(:newrev) { commit_ids.last }

    before do
      stub_const(""::Git::BaseHooksService::PROCESS_COMMIT_LIMIT"", 4)
    end

    context 'creating the default branch' do
      let(:oldrev) { Gitlab::Git::BLANK_SHA }

      it 'processes a limited number of commit messages' do
        expect(project.repository)
          .to receive(:commits)
          .with(newrev, limit: threshold_limit)
          .and_call_original

        expect(ProcessCommitWorker).to receive(:perform_async).twice

        service.execute

        expect(commits_count).to eq(project.repository.commit_count_for_ref(newrev))
      end

      it 'collects the related metrics' do
        expect(Gitlab::Metrics).to receive(:add_event).with(:push_commit, { branch: 'master' })
        expect(Gitlab::Metrics).to receive(:add_event).with(:push_branch, {})
        expect(Gitlab::Metrics).to receive(:add_event).with(:change_default_branch, {})
        expect(Gitlab::Metrics).to receive(:add_event).with(:process_commit_limit_overflow)

        service.execute
      end

      context 'when limit is not hit' do
        before do
          stub_const(""::Git::BaseHooksService::PROCESS_COMMIT_LIMIT"", 100)
        end

        it 'does not collect the corresponding metric' do
          expect(Gitlab::Metrics).not_to receive(:add_event).with(:process_commit_limit_overflow)

          service.execute
        end
      end
    end

    context 'updating the default branch' do
      it 'processes a limited number of commit messages' do
        expect(project.repository)
          .to receive(:commits_between)
          .with(oldrev, newrev, limit: threshold_limit)
          .and_call_original

        expect(ProcessCommitWorker).to receive(:perform_async).twice

        service.execute

        expect(commits_count).to eq(project.repository.count_commits_between(oldrev, newrev))
      end
    end

    context 'removing the default branch' do
      let(:newrev) { Gitlab::Git::BLANK_SHA }

      it 'does not process commit messages' do
        expect(project.repository).not_to receive(:commits)
        expect(project.repository).not_to receive(:commits_between)
        expect(ProcessCommitWorker).not_to receive(:perform_async)

        service.execute

        expect(commits_count).to eq(0)
      end
    end

    context 'creating a normal branch' do
      let(:branch) { 'fix' }
      let(:oldrev) { Gitlab::Git::BLANK_SHA }

      it 'processes a limited number of commit messages' do
        expect(project.repository)
          .to receive(:commits_between)
          .with(project.default_branch, newrev, limit: threshold_limit)
          .and_call_original

        expect(ProcessCommitWorker).to receive(:perform_async).twice

        service.execute

        expect(commits_count).to eq(project.repository.count_commits_between(project.default_branch, branch))
      end
    end

    context 'updating a normal branch' do
      let(:branch) { 'fix' }

      it 'processes a limited number of commit messages' do
        expect(project.repository)
          .to receive(:commits_between)
          .with(oldrev, newrev, limit: threshold_limit)
          .and_call_original

        expect(ProcessCommitWorker).to receive(:perform_async).twice

        service.execute
        expect(commits_count).to eq(project.repository.count_commits_between(oldrev, newrev))
      end
    end

    context 'removing a normal branch' do
      let(:branch) { 'fix' }
      let(:newrev) { Gitlab::Git::BLANK_SHA }

      it 'does not process commit messages' do
        expect(project.repository).not_to receive(:commits)
        expect(project.repository).not_to receive(:commits_between)
        expect(ProcessCommitWorker).not_to receive(:perform_async)

        service.execute

        expect(commits_count).to eq(0)
      end
    end

    context 'when the project is forked', :sidekiq_might_not_need_inline do
      let(:upstream_project) { project }
      let(:forked_project) { fork_project(upstream_project, user, repository: true, using_service: true) }

      let!(:forked_service) do
        described_class.new(forked_project, user, change: { oldrev: oldrev, newrev: newrev, ref: ref })
      end

      context 'when commits already exists in the upstream project' do
        it 'does not process commit messages' do
          expect(ProcessCommitWorker).not_to receive(:perform_async)

          forked_service.execute
        end
      end

      context 'when a commit does not exist in the upstream repo' do
        # On top of the existing 6 commits, 3 of which have references,
        # create 2 more, 1 of which has a reference. Limiting to 4 commits, we
        # expect to see one commit message processor enqueued.
        let!(:forked_commit_ids) do
          Array.new(2) do |i|
            message = ""Issue #{'#' if i.even?}#{i}""
            forked_project.repository.update_file(
              user, 'README.md', '', message: message, branch_name: branch
            )
          end
        end

        let(:newrev) { forked_commit_ids.last }

        it 'processes the commit message' do
          expect(ProcessCommitWorker).to receive(:perform_async).once

          forked_service.execute
        end
      end

      context 'when the upstream project no longer exists' do
        it 'processes the commit messages' do
          upstream_project.destroy!

          expect(ProcessCommitWorker).to receive(:perform_async).twice

          forked_service.execute
        end
      end
    end
  end

  describe 'New branch detection' do
    let(:branch) { 'fix' }

    context 'oldrev is the blank SHA' do
      let(:oldrev) { Gitlab::Git::BLANK_SHA }

      it 'is treated as a new branch' do
        expect(service).to receive(:branch_create_hooks)

        service.execute
      end
    end

    context 'oldrev is set' do
      context 'Gitaly does not know about the branch' do
        it 'is treated as a new branch' do
          allow(project.repository).to receive(:branch_names) { [] }

          expect(service).to receive(:branch_create_hooks)

          service.execute
        end
      end

      context 'Gitaly knows about the branch' do
        it 'is not treated as a new branch' do
          expect(service).not_to receive(:branch_create_hooks)

          service.execute
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Git
  class BranchPushService < ::BaseService
    include Gitlab::Access
    include Gitlab::Utils::StrongMemoize
    include ChangeParams

    # This method will be called after each git update
    # and only if the provided user and project are present in GitLab.
    #
    # All callbacks for post receive action should be placed here.
    #
    # Next, this method:
    #  1. Creates the push event
    #  2. Updates merge requests
    #  3. Recognizes cross-references from commit messages
    #  4. Executes the project's webhooks
    #  5. Executes the project's services
    #  6. Checks if the project's main language has changed
    #
    def execute
      return unless Gitlab::Git.branch_ref?(ref)

      enqueue_update_mrs
      enqueue_detect_repository_languages
      enqueue_record_project_target_platforms

      execute_related_hooks

      stop_environments
      unlock_artifacts

      true
    end

    # Update merge requests that may be affected by this push. A new branch
    # could cause the last commit of a merge request to change.
    def enqueue_update_mrs
      return if params[:merge_request_branches]&.exclude?(branch_name)

      UpdateMergeRequestsWorker.perform_async(
        project.id,
        current_user.id,
        oldrev,
        newrev,
        ref,
        params.slice(:push_options).deep_stringify_keys
      )
    end

    def enqueue_detect_repository_languages
      return unless default_branch?

      DetectRepositoryLanguagesWorker.perform_async(project.id)
    end

    def enqueue_record_project_target_platforms
      return unless default_branch?

      project.enqueue_record_project_target_platforms
    end

    # Only stop environments if the ref is a branch that is being deleted
    def stop_environments
      return unless removing_branch?

      Environments::StopService.new(project, current_user).execute_for_branch(branch_name)
    end

    def unlock_artifacts
      return unless removing_branch?

      Ci::RefDeleteUnlockArtifactsWorker.perform_async(project.id, current_user.id, ref)
    end

    def execute_related_hooks
      BranchHooksService.new(project, current_user, params).execute
    end

    def removing_branch?
      Gitlab::Git.blank_ref?(newrev)
    end

    def branch_name
      strong_memoize(:branch_name) { Gitlab::Git.ref_name(ref) }
    end

    def default_branch?
      strong_memoize(:default_branch) do
        [nil, branch_name].include?(project.default_branch)
      end
    end
  end
end

Git::BranchPushService.prepend_mod_with('Git::BranchPushService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Git::BranchPushService, :use_clean_rails_redis_caching, services: true, feature_category: :source_code_management do
  include RepoHelpers

  let_it_be(:user) { create(:user) }
  let_it_be_with_refind(:project) { create(:project, :repository) }

  let(:blankrev) { Gitlab::Git::BLANK_SHA }
  let(:oldrev)   { sample_commit.parent_id }
  let(:newrev)   { sample_commit.id }
  let(:branch)   { 'master' }
  let(:ref)      { ""refs/heads/#{branch}"" }
  let(:push_options) { nil }
  let(:service) do
    described_class
      .new(project, user, change: { oldrev: oldrev, newrev: newrev, ref: ref }, push_options: push_options)
  end

  before do
    project.add_maintainer(user)
  end

  subject(:execute_service) do
    service.execute
  end

  describe 'Push branches' do
    context 'new branch' do
      let(:oldrev) { blankrev }

      it { is_expected.to be_truthy }

      it 'calls the after_push_commit hook' do
        expect(project.repository).to receive(:after_push_commit).with('master')

        subject
      end

      it 'calls the after_create_branch hook' do
        expect(project.repository).to receive(:after_create_branch)

        subject
      end
    end

    context 'existing branch' do
      it { is_expected.to be_truthy }

      it 'calls the after_push_commit hook' do
        expect(project.repository).to receive(:after_push_commit).with('master')

        subject
      end
    end

    context 'rm branch' do
      let(:newrev) { blankrev }

      it { is_expected.to be_truthy }

      it 'calls the after_push_commit hook' do
        expect(project.repository).to receive(:after_push_commit).with('master')

        subject
      end

      it 'calls the after_remove_branch hook' do
        expect(project.repository).to receive(:after_remove_branch)

        subject
      end
    end
  end

  describe ""Pipelines"" do
    before do
      stub_ci_pipeline_to_return_yaml_file
    end

    it 'creates a pipeline with the right parameters' do
      expect(Ci::CreatePipelineService).to receive(:new).with(
        project,
        user,
        {
          before: oldrev,
          after: newrev,
          ref: ref,
          checkout_sha: SeedRepo::Commit::ID,
          variables_attributes: [],
          push_options: {}
        }
      ).and_call_original

      subject
    end

    it ""creates a new pipeline"" do
      expect { subject }.to change { Ci::Pipeline.count }

      pipeline = Ci::Pipeline.last
      expect(pipeline).to be_push
      expect(Gitlab::Git::BRANCH_REF_PREFIX + pipeline.ref).to eq(ref)
    end

    context 'when pipeline has errors' do
      before do
        config = YAML.dump({ test: { script: 'ls', only: ['feature'] } })
        stub_ci_pipeline_yaml_file(config)
      end

      it 'reports an error' do
        allow(Gitlab::Runtime).to receive(:sidekiq?).and_return(true)
        expect(Sidekiq.logger).to receive(:warn)

        expect { subject }.not_to change { Ci::Pipeline.count }
      end

      context 'with push options' do
        let(:push_options) { { 'mr' => { 'create' => true } } }

        it 'sanitizes push options' do
          allow(Gitlab::Runtime).to receive(:sidekiq?).and_return(true)
          expect(Sidekiq.logger).to receive(:warn) do |args|
            pipeline_params = args[:pipeline_params]
            expect(pipeline_params.keys).to match_array(%i[before after ref variables_attributes checkout_sha])
          end

          expect { subject }.not_to change { Ci::Pipeline.count }
        end
      end
    end

    context 'when .gitlab-ci.yml file is invalid' do
      before do
        stub_ci_pipeline_yaml_file('invalid yaml file')
      end

      it 'persists an error pipeline' do
        expect { subject }.to change { Ci::Pipeline.count }

        pipeline = Ci::Pipeline.last
        expect(pipeline).to be_push
        expect(pipeline).to be_failed
        expect(pipeline).to be_config_error
      end
    end
  end

  describe ""Updates merge requests"" do
    let(:oldrev) { blankrev }

    it ""when pushing a new branch for the first time"" do
      expect(UpdateMergeRequestsWorker)
        .to receive(:perform_async)
        .with(project.id, user.id, blankrev, newrev, ref, { 'push_options' => nil })
        .ordered

      subject
    end
  end

  describe ""Updates git attributes"" do
    context ""for default branch"" do
      context ""when first push"" do
        let(:oldrev) { blankrev }

        it ""calls the copy attributes method for the first push to the default branch"" do
          expect(project.repository).to receive(:copy_gitattributes).with('master')

          subject
        end
      end

      it ""calls the copy attributes method for changes to the default branch"" do
        expect(project.repository).to receive(:copy_gitattributes).with(ref)

        subject
      end
    end

    context ""for non-default branch"" do
      before do
        # Make sure the ""default"" branch is different
        allow(project).to receive(:default_branch).and_return('not-master')
      end

      it ""does not call copy attributes method"" do
        expect(project.repository).not_to receive(:copy_gitattributes)

        subject
      end
    end
  end

  describe ""Webhooks"" do
    before do
      create(:project_hook, push_events: true, project: project)
    end

    context ""when pushing a branch for the first time"" do
      let(:oldrev) { blankrev }

      it ""executes webhooks"" do
        expect(project).to receive(:execute_hooks)
        expect(project.default_branch).to eq(""master"")

        subject

        expect(project.protected_branches).not_to be_empty
        expect(project.protected_branches.first.push_access_levels.map(&:access_level)).to eq([Gitlab::Access::MAINTAINER])
        expect(project.protected_branches.first.merge_access_levels.map(&:access_level)).to eq([Gitlab::Access::MAINTAINER])
      end

      it ""with default branch protection disabled"" do
        expect(project.namespace).to receive(:default_branch_protection).and_return(Gitlab::Access::PROTECTION_NONE)

        expect(project).to receive(:execute_hooks)
        expect(project.default_branch).to eq(""master"")
        subject
        expect(project.protected_branches).to be_empty
      end

      it ""with default branch protection set to 'developers can push'"" do
        expect(project.namespace).to receive(:default_branch_protection).and_return(Gitlab::Access::PROTECTION_DEV_CAN_PUSH)

        expect(project).to receive(:execute_hooks)
        expect(project.default_branch).to eq(""master"")

        subject

        expect(project.protected_branches).not_to be_empty
        expect(project.protected_branches.last.push_access_levels.map(&:access_level)).to eq([Gitlab::Access::DEVELOPER])
        expect(project.protected_branches.last.merge_access_levels.map(&:access_level)).to eq([Gitlab::Access::MAINTAINER])
      end

      it ""with an existing branch permission configured"" do
        expect(project.namespace).to receive(:default_branch_protection).and_return(Gitlab::Access::PROTECTION_DEV_CAN_PUSH)

        create(:protected_branch, :no_one_can_push, :developers_can_merge, project: project, name: 'master')
        expect(project).to receive(:execute_hooks)
        expect(project.default_branch).to eq(""master"")
        expect(ProtectedBranches::CreateService).not_to receive(:new)

        subject

        expect(project.protected_branches).not_to be_empty
        expect(project.protected_branches.last.push_access_levels.map(&:access_level)).to eq([Gitlab::Access::NO_ACCESS])
        expect(project.protected_branches.last.merge_access_levels.map(&:access_level)).to eq([Gitlab::Access::DEVELOPER])
      end

      it ""with default branch protection set to 'developers can merge'"" do
        expect(project.namespace).to receive(:default_branch_protection).and_return(Gitlab::Access::PROTECTION_DEV_CAN_MERGE)

        expect(project).to receive(:execute_hooks)
        expect(project.default_branch).to eq(""master"")
        subject
        expect(project.protected_branches).not_to be_empty
        expect(project.protected_branches.first.push_access_levels.map(&:access_level)).to eq([Gitlab::Access::MAINTAINER])
        expect(project.protected_branches.first.merge_access_levels.map(&:access_level)).to eq([Gitlab::Access::DEVELOPER])
      end
    end

    context ""when pushing new commits to existing branch"" do
      it ""executes webhooks"" do
        expect(project).to receive(:execute_hooks)
        subject
      end
    end
  end

  describe ""cross-reference notes"" do
    let(:issue) { create :issue, project: project }
    let(:commit_author) { create :user }
    let(:commit) { project.commit }

    before do
      project.add_developer(commit_author)
      project.add_developer(user)

      allow(commit).to receive_messages(
        safe_message: ""this commit \n mentions #{issue.to_reference}"",
        references: [issue],
        author_name: commit_author.name,
        author_email: commit_author.email
      )

      allow(Commit).to receive(:build_from_sidekiq_hash)
        .and_return(commit)

      allow(project.repository).to receive(:commits_between).and_return([commit])
    end

    it ""creates a note if a pushed commit mentions an issue"", :sidekiq_might_not_need_inline do
      expect(SystemNoteService).to receive(:cross_reference).with(issue, commit, commit_author)

      subject
    end

    it ""only creates a cross-reference note if one doesn't already exist"" do
      SystemNoteService.cross_reference(issue, commit, user)

      expect(SystemNoteService).not_to receive(:cross_reference).with(issue, commit, commit_author)

      subject
    end

    it ""defaults to the pushing user if the commit's author is not known"", :sidekiq_inline, :use_clean_rails_redis_caching do
      allow(commit).to receive_messages(
        author_name: 'unknown name',
        author_email: 'unknown@email.com'
      )
      expect(SystemNoteService).to receive(:cross_reference).with(issue, commit, user)

      subject
    end

    context ""when first push on a non-default branch"" do
      let(:oldrev) { blankrev }
      let(:ref) { 'refs/heads/other' }

      it ""finds references"", :sidekiq_might_not_need_inline do
        allow(project.repository).to receive(:commits_between).with(blankrev, newrev).and_return([])
        allow(project.repository).to receive(:commits_between).with(""master"", newrev).and_return([commit])

        expect(SystemNoteService).to receive(:cross_reference).with(issue, commit, commit_author)

        subject
      end
    end
  end

  describe ""issue metrics"" do
    let(:issue) { create :issue, project: project }
    let(:commit_author) { create :user }
    let(:commit) { project.commit }
    let(:commit_time) { Time.current }

    before do
      project.add_developer(commit_author)
      project.add_developer(user)

      allow(commit).to receive_messages(
        safe_message: ""this commit \n mentions #{issue.to_reference}"",
        references: [issue],
        author_name: commit_author.name,
        author_email: commit_author.email,
        committed_date: commit_time
      )

      allow(Commit).to receive(:build_from_sidekiq_hash)
        .and_return(commit)

      allow(project.repository).to receive(:commits_between).and_return([commit])
    end

    context ""while saving the 'first_mentioned_in_commit_at' metric for an issue"" do
      it 'sets the metric for referenced issues', :sidekiq_inline, :use_clean_rails_redis_caching do
        subject

        expect(issue.reload.metrics.first_mentioned_in_commit_at).to be_like_time(commit_time)
      end

      it 'does not set the metric for non-referenced issues' do
        non_referenced_issue = create(:issue, project: project)
        subject

        expect(non_referenced_issue.reload.metrics.first_mentioned_in_commit_at).to be_nil
      end
    end
  end

  describe ""closing issues from pushed commits containing a closing reference"" do
    let(:issue) { create :issue, project: project }
    let(:other_issue) { create :issue, project: project }
    let(:commit_author) { create :user }
    let(:closing_commit) { project.commit }

    before do
      allow(closing_commit).to receive_messages(
        issue_closing_regex: /^([Cc]loses|[Ff]ixes) #\d+/,
        safe_message: ""this is some work.\n\ncloses ##{issue.iid}"",
        author_name: commit_author.name,
        author_email: commit_author.email
      )

      allow(project.repository).to receive(:commits_between)
        .and_return([closing_commit])

      allow(Commit).to receive(:build_from_sidekiq_hash)
        .and_return(closing_commit)

      project.add_maintainer(commit_author)
    end

    context ""to default branches"" do
      let(:user) { commit_author }

      it ""closes issues"", :sidekiq_might_not_need_inline do
        subject
        expect(Issue.find(issue.id)).to be_closed
      end

      it ""adds a note indicating that the issue is now closed"", :sidekiq_might_not_need_inline do
        expect(SystemNoteService).to receive(:change_status).with(issue, project, commit_author, ""closed"", closing_commit)
        subject
      end

      it ""doesn't create additional cross-reference notes"" do
        expect(SystemNoteService).not_to receive(:cross_reference)
        subject
      end
    end

    context ""to non-default branches"" do
      before do
        # Make sure the ""default"" branch is different
        allow(project).to receive(:default_branch).and_return('not-master')
      end

      it ""creates cross-reference notes"", :sidekiq_inline, :use_clean_rails_redis_caching do
        expect(SystemNoteService).to receive(:cross_reference).with(issue, closing_commit, commit_author)
        subject
      end

      it ""doesn't close issues"" do
        subject
        expect(Issue.find(issue.id)).to be_opened
      end
    end

    context ""for jira issue tracker"" do
      include JiraIntegrationHelpers

      let(:jira_tracker) { project.create_jira_integration if project.jira_integration.nil? }

      before do
        # project.create_jira_integration doesn't seem to invalidate the cache here
        project.has_external_issue_tracker = true
        stub_jira_integration_test
        jira_integration_settings
        stub_jira_urls(""JIRA-1"")

        allow(closing_commit).to receive_messages({
          issue_closing_regex: Regexp.new(Gitlab.config.gitlab.issue_closing_pattern),
          safe_message: message,
          author_name: commit_author.name,
          author_email: commit_author.email
        })

        allow(JIRA::Resource::Remotelink).to receive(:all).and_return([])

        allow(project.repository).to receive_messages(commits_between: [closing_commit])
      end

      after do
        jira_tracker.destroy!
      end

      context ""mentioning an issue"" do
        let(:message) { ""this is some work.\n\nrelated to JIRA-1"" }

        it ""initiates one api call to jira server to mention the issue"", :sidekiq_inline, :use_clean_rails_redis_caching do
          subject

          expect(WebMock).to have_requested(:post, jira_api_comment_url('JIRA-1')).with(
            body: /mentioned this issue in/
          ).once
        end
      end

      context ""closing an issue"" do
        let(:message) { ""this is some work.\n\ncloses JIRA-1"" }
        let(:comment_body) do
          {
            body: ""Issue solved with [#{closing_commit.id}|http://#{Gitlab.config.gitlab.host}/#{project.full_path}/-/commit/#{closing_commit.id}].""
          }.to_json
        end

        before do
          open_issue   = JIRA::Resource::Issue.new(jira_tracker.client, attrs: { ""id"" => ""JIRA-1"" })
          closed_issue = open_issue.dup
          allow(open_issue).to receive(:resolution).and_return(false)
          allow(closed_issue).to receive(:resolution).and_return(true)
          allow(JIRA::Resource::Issue).to receive(:find).and_return(open_issue, closed_issue)

          allow_any_instance_of(JIRA::Resource::Issue).to receive(:key).and_return(""JIRA-1"")
        end

        context ""using right markdown"", :sidekiq_might_not_need_inline do
          let(:user) { commit_author }

          it ""initiates one api call to jira server to close the issue"" do
            subject

            expect(WebMock).to have_requested(:post, jira_api_transition_url('JIRA-1')).once
          end

          it ""initiates one api call to jira server to comment on the issue"" do
            subject

            expect(WebMock)
              .to have_requested(:post, jira_api_comment_url('JIRA-1'))
              .with(body: comment_body)
              .once
          end
        end

        context ""using internal issue reference"" do
          let(:user) { commit_author }

          context 'when internal issues are disabled' do
            before do
              project.issues_enabled = false
              project.save!
            end

            let(:message) { ""this is some work.\n\ncloses #1"" }

            it ""does not initiates one api call to jira server to close the issue"" do
              subject

              expect(WebMock).not_to have_requested(:post, jira_api_transition_url('JIRA-1'))
            end

            it ""does not initiates one api call to jira server to comment on the issue"" do
              subject

              expect(WebMock).not_to have_requested(:post, jira_api_comment_url('JIRA-1')).with(
                body: comment_body
              ).once
            end
          end

          context 'when internal issues are enabled', :sidekiq_might_not_need_inline do
            let(:issue) { create(:issue, project: project) }
            let(:message) { ""this is some work.\n\ncloses JIRA-1 \n\n closes #{issue.to_reference}"" }

            it ""initiates one api call to jira server to close the jira issue"" do
              subject

              expect(WebMock).to have_requested(:post, jira_api_transition_url('JIRA-1')).once
            end

            it ""initiates one api call to jira server to comment on the jira issue"" do
              subject

              expect(WebMock).to have_requested(:post, jira_api_comment_url('JIRA-1')).with(
                body: comment_body
              ).once
            end

            it ""closes the internal issue"" do
              subject
              expect(issue.reload).to be_closed
            end

            it ""adds a note indicating that the issue is now closed"" do
              expect(SystemNoteService).to receive(:change_status)
                .with(issue, project, commit_author, ""closed"", closing_commit)
              subject
            end
          end
        end
      end
    end
  end

  describe ""empty project"" do
    let(:project) { create(:project_empty_repo) }
    let(:ref) { 'refs/heads/feature' }
    let(:oldrev) { blankrev }

    before do
      allow(project).to receive(:default_branch).and_return('feature')
      expect(project).to receive(:change_head) { 'feature' }
    end

    it 'push to first branch updates HEAD' do
      subject
    end
  end

  describe ""CI environments"" do
    context 'create branch' do
      let(:oldrev) { blankrev }

      it 'does nothing' do
        expect(::Environments::StopService).not_to receive(:new)

        subject
      end
    end

    context 'update branch' do
      it 'does nothing' do
        expect(::Environments::StopService).not_to receive(:new)

        subject
      end
    end

    context 'delete branch' do
      let(:newrev) { blankrev }

      it 'stops environments' do
        expect_next_instance_of(::Environments::StopService) do |stop_service|
          expect(stop_service.project).to eq(project)
          expect(stop_service.current_user).to eq(user)
          expect(stop_service).to receive(:execute_for_branch).with(branch)
        end

        subject
      end
    end
  end

  describe 'artifacts' do
    context 'create branch' do
      let(:oldrev) { blankrev }

      it 'does nothing' do
        expect(::Ci::RefDeleteUnlockArtifactsWorker).not_to receive(:perform_async)

        subject
      end
    end

    context 'update branch' do
      it 'does nothing' do
        expect(::Ci::RefDeleteUnlockArtifactsWorker).not_to receive(:perform_async)

        subject
      end
    end

    context 'delete branch' do
      let(:newrev) { blankrev }

      it 'unlocks artifacts' do
        expect(::Ci::RefDeleteUnlockArtifactsWorker)
          .to receive(:perform_async).with(project.id, user.id, ""refs/heads/#{branch}"")

        subject
      end
    end
  end

  describe 'Hooks' do
    context 'run on a branch' do
      it 'delegates to Git::BranchHooksService' do
        expect_next_instance_of(::Git::BranchHooksService) do |hooks_service|
          expect(hooks_service.project).to eq(project)
          expect(hooks_service.current_user).to eq(user)
          expect(hooks_service.params).to include(
            change: {
              oldrev: oldrev,
              newrev: newrev,
              ref: ref
            }
          )

          expect(hooks_service).to receive(:execute)
        end

        subject
      end
    end

    context 'run on a tag' do
      let(:ref) { 'refs/tags/v1.1.0' }

      it 'does nothing' do
        expect(::Git::BranchHooksService).not_to receive(:new)

        subject
      end
    end
  end

  context 'Jira Connect hooks' do
    let(:branch_to_sync) { nil }
    let(:commits_to_sync) { [] }

    shared_examples 'enqueues Jira sync worker' do
      specify :aggregate_failures do
        Sidekiq::Testing.fake! do
          if commits_to_sync.any?
            expect(JiraConnect::SyncBranchWorker)
              .to receive(:perform_in)
              .with(kind_of(Numeric), project.id, branch_to_sync, commits_to_sync, kind_of(Numeric))
              .and_call_original
          else
            expect(JiraConnect::SyncBranchWorker)
              .to receive(:perform_async)
              .with(project.id, branch_to_sync, commits_to_sync, kind_of(Numeric))
              .and_call_original
          end

          expect { subject }.to change(JiraConnect::SyncBranchWorker.jobs, :size).by(1)
        end
      end
    end

    shared_examples 'does not enqueue Jira sync worker' do
      specify do
        Sidekiq::Testing.fake! do
          expect { subject }.not_to change(JiraConnect::SyncBranchWorker.jobs, :size)
        end
      end
    end

    context 'with a Jira subscription' do
      before do
        create(:jira_connect_subscription, namespace: project.namespace)
      end

      context 'branch name contains Jira issue key' do
        let(:branch_to_sync) { 'branch-JIRA-123' }
        let(:ref) { ""refs/heads/#{branch_to_sync}"" }

        it_behaves_like 'enqueues Jira sync worker'
      end

      context 'commit message contains Jira issue key' do
        let(:commits_to_sync) { [newrev] }

        before do
          allow_any_instance_of(Commit).to receive(:safe_message).and_return('Commit with key JIRA-123')
        end

        it_behaves_like 'enqueues Jira sync worker'

        describe 'batch requests' do
          let(:commits_to_sync) { [sample_commit.id, another_sample_commit.id] }

          it 'enqueues multiple jobs' do
            # We have to stub this as we only have two valid commits to use
            stub_const('Git::BranchHooksService::JIRA_SYNC_BATCH_SIZE', 1)

            expect_any_instance_of(Git::BranchHooksService).to receive(:filtered_commit_shas).and_return(commits_to_sync)

            expect(JiraConnect::SyncBranchWorker)
              .to receive(:perform_in)
              .with(0.seconds, project.id, branch_to_sync, [commits_to_sync.first], kind_of(Numeric))
              .and_call_original

            expect(JiraConnect::SyncBranchWorker)
              .to receive(:perform_in)
              .with(10.seconds, project.id, branch_to_sync, [commits_to_sync.last], kind_of(Numeric))
              .and_call_original

            subject
          end
        end
      end

      context 'branch name and commit message does not contain Jira issue key' do
        it_behaves_like 'does not enqueue Jira sync worker'
      end
    end

    context 'without a Jira subscription' do
      it_behaves_like 'does not enqueue Jira sync worker'
    end
  end

  describe 'project target platforms detection' do
    let(:oldrev) { blankrev }

    it 'calls enqueue_record_project_target_platforms on the project' do
      expect(project).to receive(:enqueue_record_project_target_platforms)

      subject
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Git
  class WikiPushService
    class Change
      include Gitlab::Utils::StrongMemoize

      # @param [Wiki] wiki
      # @param [Hash] change - must have keys `:oldrev` and `:newrev`
      # @param [Gitlab::Git::RawDiffChange] raw_change
      def initialize(wiki, change, raw_change)
        @wiki = wiki
        @raw_change = raw_change
        @change = change
      end

      def page
        strong_memoize(:page) { wiki.find_page(slug, revision) }
      end

      # See [Gitlab::Git::RawDiffChange#extract_operation] for the
      # definition of the full range of operation values.
      def event_action
        case raw_change.operation
        when :added
          :created
        when :deleted
          :destroyed
        else
          :updated
        end
      end

      def last_known_slug
        strip_extension(raw_change.old_path || raw_change.new_path)
      end

      def sha
        change[:newrev]
      end

      private

      attr_reader :raw_change, :change, :wiki

      def filename
        return raw_change.old_path if deleted?

        raw_change.new_path
      end

      def slug
        strip_extension(filename)
      end

      def revision
        return change[:oldrev] if deleted?

        change[:newrev]
      end

      def deleted?
        raw_change.operation == :deleted
      end

      def strip_extension(filename)
        return unless filename

        encoded_filename = Gitlab::EncodingHelper.encode_utf8(filename.dup)
        File.basename(encoded_filename, File.extname(encoded_filename))
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Git::WikiPushService::Change, feature_category: :source_code_management do
  subject { described_class.new(project_wiki, change, raw_change) }

  let(:project_wiki) { double('ProjectWiki') }
  let(:raw_change) { double('RawChange', new_path: new_path, old_path: old_path, operation: operation) }
  let(:change) { { oldrev: generate(:sha), newrev: generate(:sha) } }

  let(:new_path) do
    case operation
    when :deleted
      nil
    else
      generate(:wiki_filename)
    end
  end

  let(:old_path) do
    case operation
    when :added
      nil
    when :deleted, :renamed
      generate(:wiki_filename)
    else
      new_path
    end
  end

  describe '#page' do
    context 'the page does not exist' do
      before do
        expect(project_wiki).to receive(:find_page).with(String, String).and_return(nil)
      end

      %i[added deleted renamed modified].each do |op|
        context ""the operation is #{op}"" do
          let(:operation) { op }

          it { is_expected.to have_attributes(page: be_nil) }
        end
      end
    end

    context 'the page can be found' do
      let(:wiki_page) { double('WikiPage') }

      before do
        expect(project_wiki).to receive(:find_page).with(slug, revision).and_return(wiki_page)
      end

      context 'the page has been deleted' do
        let(:operation) { :deleted }
        let(:slug) { old_path.chomp('.md') }
        let(:revision) { change[:oldrev] }

        it { is_expected.to have_attributes(page: wiki_page) }
      end

      %i[added renamed modified].each do |op|
        context ""the operation is #{op}"" do
          let(:operation) { op }
          let(:slug) { new_path.chomp('.md') }
          let(:revision) { change[:newrev] }

          it { is_expected.to have_attributes(page: wiki_page) }
        end
      end
    end
  end

  describe '#last_known_slug' do
    context 'the page has been created' do
      let(:operation) { :added }

      it { is_expected.to have_attributes(last_known_slug: new_path.chomp('.md')) }
    end

    %i[renamed modified deleted].each do |op|
      context ""the operation is #{op}"" do
        let(:operation) { op }

        it { is_expected.to have_attributes(last_known_slug: old_path.chomp('.md')) }
      end
    end
  end

  describe '#event_action' do
    context 'the page is deleted' do
      let(:operation) { :deleted }

      it { is_expected.to have_attributes(event_action: :destroyed) }
    end

    context 'the page is added' do
      let(:operation) { :added }

      it { is_expected.to have_attributes(event_action: :created) }
    end

    %i[renamed modified].each do |op|
      context ""the page is #{op}"" do
        let(:operation) { op }

        it { is_expected.to have_attributes(event_action: :updated) }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Onboarding
  class ProgressService
    class Async
      attr_reader :namespace_id

      def initialize(namespace_id)
        @namespace_id = namespace_id
      end

      def execute(action:)
        return unless Onboarding::Progress.not_completed?(namespace_id, action)

        Onboarding::ProgressWorker.perform_async(namespace_id, action)
      end
    end

    def self.async(namespace_id)
      Async.new(namespace_id)
    end

    def initialize(namespace)
      @namespace = namespace&.root_ancestor
    end

    def execute(action:)
      return unless @namespace

      Onboarding::Progress.register(@namespace, action)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Onboarding::ProgressService, feature_category: :onboarding do
  describe '.async' do
    let_it_be(:namespace) { create(:namespace) }
    let_it_be(:action) { :git_pull }

    subject(:execute_service) { described_class.async(namespace.id).execute(action: action) }

    context 'when not onboarded' do
      it 'does not schedule a worker' do
        expect(Onboarding::ProgressWorker).not_to receive(:perform_async)

        execute_service
      end
    end

    context 'when onboarded' do
      before do
        Onboarding::Progress.onboard(namespace)
      end

      context 'when action is already completed' do
        before do
          Onboarding::Progress.register(namespace, action)
        end

        it 'does not schedule a worker' do
          expect(Onboarding::ProgressWorker).not_to receive(:perform_async)

          execute_service
        end
      end

      context 'when action is not yet completed' do
        it 'schedules a worker' do
          expect(Onboarding::ProgressWorker).to receive(:perform_async)

          execute_service
        end
      end
    end
  end

  describe '#execute' do
    let(:namespace) { create(:namespace) }
    let(:action) { :namespace_action }

    subject(:execute_service) { described_class.new(namespace).execute(action: :subscription_created) }

    context 'when the namespace is a root' do
      before do
        Onboarding::Progress.onboard(namespace)
      end

      it 'registers a namespace onboarding progress action for the given namespace' do
        execute_service

        expect(Onboarding::Progress.completed?(namespace, :subscription_created)).to eq(true)
      end
    end

    context 'when the namespace is not the root' do
      let(:group) { create(:group, :nested) }

      before do
        Onboarding::Progress.onboard(group)
      end

      it 'does not register a namespace onboarding progress action' do
        execute_service

        expect(Onboarding::Progress.completed?(group, :subscription_created)).to be(nil)
      end
    end

    context 'when no namespace is passed' do
      let(:namespace) { nil }

      it 'does not register a namespace onboarding progress action' do
        execute_service

        expect(Onboarding::Progress.completed?(namespace, :subscription_created)).to be(nil)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module PagesDomains
  class CreateAcmeOrderService
    attr_reader :pages_domain

    def initialize(pages_domain)
      @pages_domain = pages_domain
    end

    def execute
      lets_encrypt_client = Gitlab::LetsEncrypt::Client.new
      order = lets_encrypt_client.new_order(pages_domain.domain)

      challenge = order.new_challenge

      private_key = OpenSSL::PKey::RSA.new(4096)
      saved_order = pages_domain.acme_orders.create!(
        url: order.url,
        expires_at: order.expires,
        private_key: private_key.to_pem,

        challenge_token: challenge.token,
        challenge_file_content: challenge.file_content
      )

      challenge.request_validation
      saved_order
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe PagesDomains::CreateAcmeOrderService, feature_category: :pages do
  include LetsEncryptHelpers

  let(:pages_domain) { create(:pages_domain) }

  let(:challenge) { ::Gitlab::LetsEncrypt::Challenge.new(acme_challenge_double) }

  let(:order_double) do
    Gitlab::LetsEncrypt::Order.new(acme_order_double).tap do |order|
      allow(order).to receive(:new_challenge).and_return(challenge)
    end
  end

  let(:lets_encrypt_client) do
    instance_double('Gitlab::LetsEncrypt::Client').tap do |client|
      allow(client).to receive(:new_order).with(pages_domain.domain)
        .and_return(order_double)
    end
  end

  let(:service) { described_class.new(pages_domain) }

  before do
    allow(::Gitlab::LetsEncrypt::Client).to receive(:new).and_return(lets_encrypt_client)
  end

  it 'saves order to database before requesting validation' do
    allow(pages_domain.acme_orders).to receive(:create!).and_call_original
    allow(challenge).to receive(:request_validation).and_call_original

    service.execute

    expect(pages_domain.acme_orders).to have_received(:create!).ordered
    expect(challenge).to have_received(:request_validation).ordered
  end

  it 'generates and saves private key' do
    service.execute

    saved_order = PagesDomainAcmeOrder.last
    expect { OpenSSL::PKey::RSA.new(saved_order.private_key) }.not_to raise_error
  end

  it 'properly saves order attributes' do
    service.execute

    saved_order = PagesDomainAcmeOrder.last
    expect(saved_order.url).to eq(order_double.url)
    expect(saved_order.expires_at).to be_like_time(order_double.expires)
  end

  it 'properly saves challenge attributes' do
    service.execute

    saved_order = PagesDomainAcmeOrder.last
    expect(saved_order.challenge_token).to eq(challenge.token)
    expect(saved_order.challenge_file_content).to eq(challenge.file_content)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module PagesDomains
  class RetryAcmeOrderService
    attr_reader :pages_domain

    def initialize(pages_domain)
      @pages_domain = pages_domain
    end

    def execute
      updated = pages_domain.with_lock do
        next unless pages_domain.auto_ssl_enabled && pages_domain.auto_ssl_failed

        pages_domain.update!(auto_ssl_failed: false)
      end

      return unless updated

      PagesDomainSslRenewalWorker.perform_async(pages_domain.id)

      publish_event(pages_domain)
    end

    private

    def publish_event(domain)
      event = PagesDomainUpdatedEvent.new(
        data: {
          project_id: domain.project.id,
          namespace_id: domain.project.namespace_id,
          root_namespace_id: domain.project.root_namespace.id,
          domain_id: domain.id,
          domain: domain.domain
        }
      )

      Gitlab::EventStore.publish(event)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe PagesDomains::RetryAcmeOrderService, feature_category: :pages do
  let_it_be(:project) { create(:project) }

  let(:domain) { create(:pages_domain, project: project, auto_ssl_enabled: true, auto_ssl_failed: true) }

  let(:service) { described_class.new(domain) }

  it 'clears auto_ssl_failed' do
    expect { service.execute }
      .to change { domain.auto_ssl_failed }
      .from(true).to(false)
      .and publish_event(PagesDomains::PagesDomainUpdatedEvent)
      .with(
        project_id: project.id,
        namespace_id: project.namespace.id,
        root_namespace_id: project.root_namespace.id,
        domain_id: domain.id,
        domain: domain.domain
      )
  end

  it 'schedules renewal worker and publish PagesDomainUpdatedEvent event' do
    expect(PagesDomainSslRenewalWorker).to receive(:perform_async).with(domain.id).and_return(nil).once

    expect { service.execute }
      .to publish_event(PagesDomains::PagesDomainUpdatedEvent)
      .with(
        project_id: project.id,
        namespace_id: project.namespace.id,
        root_namespace_id: project.root_namespace.id,
        domain_id: domain.id,
        domain: domain.domain
      )
  end

  it ""doesn't schedule renewal worker if Let's Encrypt integration is not enabled"" do
    domain.update!(auto_ssl_enabled: false)

    expect(PagesDomainSslRenewalWorker).not_to receive(:new)

    expect { service.execute }
      .to not_publish_event(PagesDomains::PagesDomainUpdatedEvent)
  end

  it ""doesn't schedule renewal worker if auto ssl has not failed yet"" do
    domain.update!(auto_ssl_failed: false)

    expect(PagesDomainSslRenewalWorker).not_to receive(:new)

    expect { service.execute }
      .to not_publish_event(PagesDomains::PagesDomainUpdatedEvent)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module PagesDomains
  class UpdateService < BaseService
    def execute(domain)
      return unless authorized?

      return false unless domain.update(params)

      publish_event(domain)

      true
    end

    private

    def authorized?
      current_user.can?(:update_pages, project)
    end

    def publish_event(domain)
      event = PagesDomainUpdatedEvent.new(
        data: {
          project_id: project.id,
          namespace_id: project.namespace_id,
          root_namespace_id: project.root_namespace.id,
          domain_id: domain.id,
          domain: domain.domain
        }
      )

      Gitlab::EventStore.publish(event)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe PagesDomains::UpdateService, feature_category: :pages do
  let_it_be(:user) { create(:user) }
  let_it_be(:pages_domain) { create(:pages_domain, :with_project) }

  let(:params) do
    attributes_for(:pages_domain, :with_trusted_chain).slice(:key, :certificate).tap do |params|
      params[:user_provided_key] = params.delete(:key)
      params[:user_provided_certificate] = params.delete(:certificate)
    end
  end

  subject(:service) { described_class.new(pages_domain.project, user, params) }

  context 'when the user does not have the required permissions' do
    it 'does not update the pages domain and does not publish a PagesDomainUpdatedEvent' do
      expect do
        expect(service.execute(pages_domain)).to be_nil
      end.to not_publish_event(PagesDomains::PagesDomainUpdatedEvent)
    end
  end

  context 'when the user has the required permissions' do
    before do
      pages_domain.project.add_maintainer(user)
    end

    context 'when it updates the domain successfully' do
      it 'updates the domain' do
        expect(service.execute(pages_domain)).to eq(true)
      end

      it 'publishes a PagesDomainUpdatedEvent' do
        expect { service.execute(pages_domain) }
          .to publish_event(PagesDomains::PagesDomainUpdatedEvent)
          .with(
            project_id: pages_domain.project.id,
            namespace_id: pages_domain.project.namespace.id,
            root_namespace_id: pages_domain.project.root_namespace.id,
            domain_id: pages_domain.id,
            domain: pages_domain.domain
          )
      end
    end

    context 'when it fails to update the domain' do
      let(:params) { { user_provided_certificate: 'blabla' } }

      it 'does not update a pages domain' do
        expect(service.execute(pages_domain)).to be(false)
      end

      it 'does not publish a PagesDomainUpdatedEvent' do
        expect { service.execute(pages_domain) }
          .not_to publish_event(PagesDomains::PagesDomainUpdatedEvent)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module PagesDomains
  class ObtainLetsEncryptCertificateService
    # time for processing validation requests for acme challenges
    # 5-15 seconds is usually enough
    CHALLENGE_PROCESSING_DELAY = 1.minute.freeze

    # time LetsEncrypt ACME server needs to generate the certificate
    # no particular SLA, usually takes 10-15 seconds
    CERTIFICATE_PROCESSING_DELAY = 1.minute.freeze

    attr_reader :pages_domain

    def initialize(pages_domain)
      @pages_domain = pages_domain
    end

    def execute
      pages_domain.acme_orders.expired.delete_all
      acme_order = pages_domain.acme_orders.first

      unless acme_order
        ::PagesDomains::CreateAcmeOrderService.new(pages_domain).execute
        PagesDomainSslRenewalWorker.perform_in(CHALLENGE_PROCESSING_DELAY, pages_domain.id)
        return
      end

      api_order = ::Gitlab::LetsEncrypt::Client.new.load_order(acme_order.url)

      # https://www.rfc-editor.org/rfc/rfc8555#section-7.1.6 - statuses diagram
      case api_order.status
      when 'ready'
        api_order.request_certificate(private_key: acme_order.private_key, domain: pages_domain.domain)
        PagesDomainSslRenewalWorker.perform_in(CERTIFICATE_PROCESSING_DELAY, pages_domain.id)
      when 'valid'
        save_certificate(acme_order.private_key, api_order)
        acme_order.destroy!
      when 'invalid'
        save_order_error(acme_order, api_order)
      end
    end

    private

    def save_certificate(private_key, api_order)
      certificate = api_order.certificate
      pages_domain.update!(gitlab_provided_key: private_key, gitlab_provided_certificate: certificate)
    end

    def save_order_error(acme_order, api_order)
      log_error(api_order)

      pages_domain.assign_attributes(auto_ssl_failed: true)
      pages_domain.save!(validate: false)

      acme_order.destroy!

      NotificationService.new.pages_domain_auto_ssl_failed(pages_domain)
    end

    def log_error(api_order)
      Gitlab::AppLogger.error(
        message: ""Failed to obtain Let's Encrypt certificate"",
        acme_error: api_order.challenge_error,
        project_id: pages_domain.project_id,
        pages_domain: pages_domain.domain
      )
    rescue StandardError => e
      # getting authorizations is an additional network request which can raise errors
      Gitlab::ErrorTracking.track_exception(e)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe PagesDomains::ObtainLetsEncryptCertificateService, feature_category: :pages do
  include LetsEncryptHelpers

  let(:pages_domain) { create(:pages_domain, :without_certificate, :without_key) }
  let(:service) { described_class.new(pages_domain) }

  before do
    stub_lets_encrypt_settings
  end

  around do |example|
    Sidekiq::Testing.fake! do
      example.run
    end
  end

  def expect_to_create_acme_challenge
    expect(::PagesDomains::CreateAcmeOrderService).to receive(:new).with(pages_domain)
      .and_wrap_original do |m, *args|
      create_service = m.call(*args)

      expect(create_service).to receive(:execute)

      create_service
    end
  end

  def stub_lets_encrypt_order(url, status)
    order = ::Gitlab::LetsEncrypt::Order.new(acme_order_double(status: status))

    allow_next_instance_of(::Gitlab::LetsEncrypt::Client) do |instance|
      allow(instance).to receive(:load_order).with(url).and_return(order)
    end

    order
  end

  context 'when there is no acme order' do
    it 'creates acme order and schedules next step' do
      expect_to_create_acme_challenge
      expect(PagesDomainSslRenewalWorker).to(
        receive(:perform_in).with(described_class::CHALLENGE_PROCESSING_DELAY, pages_domain.id)
          .and_return(nil).once
      )

      service.execute
    end
  end

  context 'when there is expired acme order' do
    let!(:existing_order) do
      create(:pages_domain_acme_order, :expired, pages_domain: pages_domain)
    end

    it 'removes acme order and creates new one' do
      expect_to_create_acme_challenge

      service.execute

      expect(PagesDomainAcmeOrder.find_by_id(existing_order.id)).to be_nil
    end
  end

  %w[pending processing].each do |status|
    context ""there is an order in '#{status}' status"" do
      let(:existing_order) do
        create(:pages_domain_acme_order, pages_domain: pages_domain)
      end

      before do
        stub_lets_encrypt_order(existing_order.url, status)
      end

      it 'does not raise errors' do
        expect do
          service.execute
        end.not_to raise_error
      end
    end
  end

  context 'when order is ready' do
    let(:existing_order) do
      create(:pages_domain_acme_order, pages_domain: pages_domain)
    end

    let!(:api_order) do
      stub_lets_encrypt_order(existing_order.url, 'ready')
    end

    it 'request certificate and schedules next step' do
      expect(api_order).to receive(:request_certificate).and_call_original
      expect(PagesDomainSslRenewalWorker).to(
        receive(:perform_in).with(described_class::CERTIFICATE_PROCESSING_DELAY, pages_domain.id)
          .and_return(nil).once
      )

      service.execute
    end
  end

  context 'when order is valid' do
    let(:existing_order) do
      create(:pages_domain_acme_order, pages_domain: pages_domain)
    end

    let!(:api_order) do
      stub_lets_encrypt_order(existing_order.url, 'valid')
    end

    let(:certificate) do
      key = OpenSSL::PKey.read(existing_order.private_key)

      subject = ""/C=BE/O=Test/OU=Test/CN=#{pages_domain.domain}""

      cert = OpenSSL::X509::Certificate.new
      cert.subject = cert.issuer = OpenSSL::X509::Name.parse(subject)
      cert.not_before = Time.current
      cert.not_after = 1.year.from_now
      cert.public_key = key.public_key
      cert.serial = 0x0
      cert.version = 2

      ef = OpenSSL::X509::ExtensionFactory.new
      ef.subject_certificate = cert
      ef.issuer_certificate = cert
      cert.extensions = [
        ef.create_extension(""basicConstraints"", ""CA:TRUE"", true),
        ef.create_extension(""subjectKeyIdentifier"", ""hash"")
      ]
      cert.add_extension ef.create_extension(""authorityKeyIdentifier"", ""keyid:always,issuer:always"")

      cert.sign key, OpenSSL::Digest.new('SHA256')

      cert.to_pem
    end

    before do
      expect(api_order).to receive(:certificate) { certificate }
    end

    it 'saves private_key and certificate for domain' do
      service.execute

      expect(pages_domain.key).to be_present
      expect(pages_domain.certificate).to eq(certificate)
    end

    it 'marks certificate as gitlab_provided' do
      service.execute

      expect(pages_domain.certificate_source).to eq(""gitlab_provided"")
    end

    it 'removes order from database' do
      service.execute

      expect(PagesDomainAcmeOrder.find_by_id(existing_order.id)).to be_nil
    end
  end

  context 'when order is invalid' do
    let(:existing_order) do
      create(:pages_domain_acme_order, pages_domain: pages_domain)
    end

    let!(:api_order) do
      stub_lets_encrypt_order(existing_order.url, 'invalid')
    end

    it 'saves error to domain and deletes acme order' do
      expect do
        service.execute
      end.to change { pages_domain.reload.auto_ssl_failed }.from(false).to(true)

      expect(PagesDomainAcmeOrder.find_by_id(existing_order.id)).to be_nil
    end

    it 'sends notification' do
      expect_next_instance_of(NotificationService) do |notification_service|
        expect(notification_service).to receive(:pages_domain_auto_ssl_failed).with(pages_domain)
      end

      service.execute
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module PagesDomains
  class CreateService < BaseService
    def execute
      return unless authorized?

      domain = project.pages_domains.create(params)

      publish_event(domain) if domain.persisted?

      domain
    end

    private

    def authorized?
      current_user.can?(:update_pages, project)
    end

    def publish_event(domain)
      event = PagesDomainCreatedEvent.new(
        data: {
          project_id: project.id,
          namespace_id: project.namespace_id,
          root_namespace_id: project.root_namespace.id,
          domain_id: domain.id,
          domain: domain.domain
        }
      )

      Gitlab::EventStore.publish(event)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::PagesDomains::CreateService, feature_category: :pages do
  let_it_be(:user) { create(:user) }
  let_it_be(:project) { create(:project, :in_subgroup) }

  let(:domain) { 'new.domain.com' }
  let(:attributes) { { domain: domain } }

  subject(:service) { described_class.new(project, user, attributes) }

  context 'when the user does not have the required permissions' do
    it 'does not create a pages domain and does not publish a PagesDomainCreatedEvent' do
      expect(service.execute).to be_nil

      expect { service.execute }
        .to not_publish_event(PagesDomains::PagesDomainCreatedEvent)
        .and not_change(project.pages_domains, :count)
    end
  end

  context 'when the user has the required permissions' do
    before do
      project.add_maintainer(user)
    end

    context 'when it saves the domain successfully' do
      it 'creates the domain and publishes a PagesDomainCreatedEvent' do
        pages_domain = nil

        expect { pages_domain = service.execute }
          .to change(project.pages_domains, :count)
          .and publish_event(PagesDomains::PagesDomainCreatedEvent)
          .with(
            project_id: project.id,
            namespace_id: project.namespace.id,
            root_namespace_id: project.root_namespace.id,
            domain_id: kind_of(Numeric),
            domain: domain
          )

        expect(pages_domain).to be_persisted
      end
    end

    context 'when it fails to save the domain' do
      let(:domain) { nil }

      it 'does not create a pages domain and does not publish a PagesDomainCreatedEvent' do
        pages_domain = nil

        expect { pages_domain = service.execute }
          .to not_publish_event(PagesDomains::PagesDomainCreatedEvent)
          .and not_change(project.pages_domains, :count)

        expect(pages_domain).not_to be_persisted
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module PagesDomains
  class DeleteService < BaseService
    def execute(domain)
      return unless authorized?

      domain.destroy

      publish_event(domain)
    end

    private

    def authorized?
      current_user.can?(:update_pages, project)
    end

    def publish_event(domain)
      event = PagesDomainDeletedEvent.new(
        data: {
          project_id: project.id,
          namespace_id: project.namespace_id,
          root_namespace_id: project.root_namespace.id,
          domain_id: domain.id,
          domain: domain.domain
        }
      )

      Gitlab::EventStore.publish(event)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ::PagesDomains::DeleteService, feature_category: :pages do
  let_it_be(:user) { create(:user) }
  let_it_be(:pages_domain) { create(:pages_domain, :with_project) }

  let(:params) do
    attributes_for(:pages_domain, :with_trusted_chain).slice(:key, :certificate).tap do |params|
      params[:user_provided_key] = params.delete(:key)
      params[:user_provided_certificate] = params.delete(:certificate)
    end
  end

  subject(:service) { described_class.new(pages_domain.project, user, params) }

  context 'when the user does not have the required permissions' do
    it 'does not delete the pages domain and does not publish a PagesDomainDeletedEvent' do
      result_match = -> { expect(service.execute(pages_domain)).to be_nil }

      expect(&result_match)
        .to not_publish_event(PagesDomains::PagesDomainDeletedEvent)
    end
  end

  context 'when the user has the required permissions' do
    before do
      pages_domain.project.add_maintainer(user)
    end

    context 'when it updates the domain successfully' do
      it 'deletes the domain and publishes a PagesDomainDeletedEvent' do
        result_match = -> { expect(service.execute(pages_domain)).not_to be_nil }

        expect(&result_match)
          .to publish_event(PagesDomains::PagesDomainDeletedEvent)
          .with(
            project_id: pages_domain.project.id,
            namespace_id: pages_domain.project.namespace.id,
            root_namespace_id: pages_domain.project.root_namespace.id,
            domain_id: pages_domain.id,
            domain: pages_domain.domain
          )
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

#
# Concern that helps with getting an exclusive lease for running a block
# of code.
#
# `#try_obtain_lease` takes a block which will be run if it was able to
# obtain  the lease. Implement `#lease_timeout` to configure the timeout
# for the exclusive lease.
#
# Optionally override `#lease_key` to set the
# lease key, it defaults to the class name with underscores.
#
# Optionally override `#lease_release?` to prevent the job to
# be re-executed more often than LEASE_TIMEOUT.
#
module ExclusiveLeaseGuard
  extend ActiveSupport::Concern

  def try_obtain_lease
    lease = exclusive_lease.try_obtain

    unless lease
      log_lease_taken
      return
    end

    begin
      yield lease
    ensure
      release_lease(lease) if lease_release?
    end
  end

  def exclusive_lease
    @lease ||= Gitlab::ExclusiveLease.new(lease_key, timeout: lease_timeout)
  end

  def lease_key
    @lease_key ||= self.class.name.underscore
  end

  def lease_timeout
    raise NotImplementedError,
      ""#{self.class.name} does not implement #{__method__}""
  end

  def lease_release?
    true
  end

  def release_lease(uuid)
    Gitlab::ExclusiveLease.cancel(lease_key, uuid)
  end

  def renew_lease!
    exclusive_lease.renew
  end

  def log_lease_taken
    logger = Gitlab::AppJsonLogger
    args = { message: lease_taken_message, lease_key: lease_key, class_name: self.class.name, lease_timeout: lease_timeout }

    case lease_taken_log_level
    when :debug then logger.debug(args)
    when :info  then logger.info(args)
    when :warn  then logger.warn(args)
    else             logger.error(args)
    end
  end

  def lease_taken_message
    ""Cannot obtain an exclusive lease. There must be another instance already in execution.""
  end

  def lease_taken_log_level
    :error
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe ExclusiveLeaseGuard, :clean_gitlab_redis_shared_state, feature_category: :shared do
  subject :subject_class do
    Class.new do
      include ExclusiveLeaseGuard

      def self.name
        'ExclusiveLeaseGuardTestClass'
      end

      def call(&block)
        try_obtain_lease do
          internal_method(&block)
        end
      end

      def internal_method
        yield
      end

      def lease_timeout
        1.second
      end
    end
  end

  describe '#try_obtain_lease' do
    let(:subject) { subject_class.new }

    it 'obtains the lease, calls internal_method and releases the lease', :aggregate_failures do
      expect(subject).to receive(:internal_method).and_call_original

      subject.call do
        expect(subject.exclusive_lease.exists?).to be_truthy
      end

      expect(subject.exclusive_lease.exists?).to be_falsey
    end

    context 'when the lease is already obtained' do
      before do
        subject.exclusive_lease.try_obtain
      end

      after do
        subject.exclusive_lease.cancel
      end

      context 'when the class does not override lease_taken_log_level' do
        it 'does not call internal_method but logs error', :aggregate_failures do
          expect(subject).not_to receive(:internal_method)
          expect(Gitlab::AppJsonLogger).to receive(:error).with({ message: ""Cannot obtain an exclusive lease. There must be another instance already in execution."", lease_key: 'exclusive_lease_guard_test_class', class_name: 'ExclusiveLeaseGuardTestClass', lease_timeout: 1.second })

          subject.call
        end
      end

      context 'when the class overrides lease_taken_log_level to return :info' do
        subject :overwritten_subject_class do
          Class.new(subject_class) do
            def lease_taken_log_level
              :info
            end
          end
        end

        let(:subject) { overwritten_subject_class.new }

        it 'logs info', :aggregate_failures do
          expect(Gitlab::AppJsonLogger).to receive(:info).with({ message: ""Cannot obtain an exclusive lease. There must be another instance already in execution."", lease_key: 'exclusive_lease_guard_test_class', class_name: 'ExclusiveLeaseGuardTestClass', lease_timeout: 1.second })

          subject.call
        end
      end

      context 'when the class overrides lease_taken_log_level to return :debug' do
        subject :overwritten_subject_class do
          Class.new(subject_class) do
            def lease_taken_log_level
              :debug
            end
          end
        end

        let(:subject) { overwritten_subject_class.new }

        it 'logs debug', :aggregate_failures do
          expect(Gitlab::AppJsonLogger).to receive(:debug).with({ message: ""Cannot obtain an exclusive lease. There must be another instance already in execution."", lease_key: 'exclusive_lease_guard_test_class', class_name: 'ExclusiveLeaseGuardTestClass', lease_timeout: 1.second })

          subject.call
        end
      end
    end

    context 'with overwritten lease_release?' do
      subject :overwritten_subject_class do
        Class.new(subject_class) do
          def lease_release?
            false
          end
        end
      end

      let(:subject) { overwritten_subject_class.new }

      it 'does not release the lease after execution', :aggregate_failures do
        subject.call do
          expect(subject.exclusive_lease.exists?).to be_truthy
        end

        expect(subject.exclusive_lease.exists?).to be_truthy
      end
    end
  end

  describe '#exclusive_lease' do
    it 'uses the class name as lease key' do
      expect(Gitlab::ExclusiveLease).to receive(:new).with('exclusive_lease_guard_test_class', timeout: 1.second)

      subject_class.new.exclusive_lease
    end

    context 'with overwritten lease_key' do
      subject :overwritten_class do
        Class.new(subject_class) do
          def lease_key
            'other_lease_key'
          end
        end
      end

      it 'uses the custom lease key' do
        expect(Gitlab::ExclusiveLease).to receive(:new).with('other_lease_key', timeout: 1.second)

        overwritten_class.new.exclusive_lease
      end
    end
  end

  describe '#release_lease' do
    it 'sends a cancel message to ExclusiveLease' do
      expect(Gitlab::ExclusiveLease).to receive(:cancel).with('exclusive_lease_guard_test_class', 'some_uuid')

      subject_class.new.release_lease('some_uuid')
    end
  end

  describe '#renew_lease!' do
    let(:subject) { subject_class.new }

    it 'sends a renew message to the exclusive_lease instance' do
      expect(subject.exclusive_lease).to receive(:renew)
      subject.renew_lease!
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module RateLimitedService
  extend ActiveSupport::Concern

  RateLimitedNotSetupError = Class.new(StandardError)

  class RateLimitedError < StandardError
    def initialize(key:, rate_limiter:)
      @key = key
      @rate_limiter = rate_limiter
    end

    def headers
      # TODO: This will be fleshed out in https://gitlab.com/gitlab-org/gitlab/-/issues/342370
      {}
    end

    def log_request(request, current_user)
      rate_limiter.log_request(request, ""#{key}_request_limit"".to_sym, current_user)
    end

    private

    attr_reader :key, :rate_limiter
  end

  class RateLimiterScopedAndKeyed
    attr_reader :key, :opts, :rate_limiter

    def initialize(key:, opts:, rate_limiter:)
      @key = key
      @opts = opts
      @rate_limiter = rate_limiter
    end

    def rate_limit!(service)
      evaluated_scope = evaluated_scope_for(service)

      if rate_limiter.throttled?(key, **opts.merge(scope: evaluated_scope.values, users_allowlist: users_allowlist))
        raise RateLimitedError.new(key: key, rate_limiter: rate_limiter), _('This endpoint has been requested too many times. Try again later.')
      end
    end

    private

    def users_allowlist
      @users_allowlist ||= opts[:users_allowlist] ? opts[:users_allowlist].call : []
    end

    def evaluated_scope_for(service)
      opts[:scope].index_with do |var|
        service.public_send(var) # rubocop: disable GitlabSecurity/PublicSend
      end
    end
  end

  prepended do
    attr_accessor :rate_limiter_bypassed

    cattr_accessor :rate_limiter_scoped_and_keyed

    def self.rate_limit(key:, opts:, rate_limiter: ::Gitlab::ApplicationRateLimiter)
      self.rate_limiter_scoped_and_keyed = RateLimiterScopedAndKeyed.new(
        key: key,
        opts: opts,
        rate_limiter: rate_limiter
      )
    end
  end

  def execute_without_rate_limiting(*args, **kwargs)
    self.rate_limiter_bypassed = true
    execute(*args, **kwargs)
  ensure
    self.rate_limiter_bypassed = false
  end

  def execute(*args, **kwargs)
    raise RateLimitedNotSetupError if rate_limiter_scoped_and_keyed.nil?

    rate_limiter_scoped_and_keyed.rate_limit!(self) unless rate_limiter_bypassed

    super
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe RateLimitedService, feature_category: :rate_limiting do
  let(:key) { :issues_create }
  let(:scope) { [:container, :current_user] }
  let(:opts) { { scope: scope, users_allowlist: -> { [Users::Internal.support_bot.username] } } }
  let(:rate_limiter) { ::Gitlab::ApplicationRateLimiter }

  describe 'RateLimitedError' do
    subject { described_class::RateLimitedError.new(key: key, rate_limiter: rate_limiter) }

    describe '#headers' do
      it 'returns a Hash of HTTP headers' do
        # TODO: This will be fleshed out in https://gitlab.com/gitlab-org/gitlab/-/issues/342370
        expected_headers = {}

        expect(subject.headers).to eq(expected_headers)
      end
    end

    describe '#log_request' do
      it 'logs the request' do
        request = instance_double(Grape::Request)
        user = instance_double(User)

        expect(rate_limiter).to receive(:log_request).with(request, ""#{key}_request_limit"".to_sym, user)

        subject.log_request(request, user)
      end
    end
  end

  describe 'RateLimiterScopedAndKeyed' do
    subject { described_class::RateLimiterScopedAndKeyed.new(key: key, opts: opts, rate_limiter: rate_limiter) }

    describe '#rate_limit!' do
      let_it_be(:project) { create(:project) }
      let_it_be(:current_user) { create(:user) }

      let(:service) { instance_double(Issues::CreateService, container: project, current_user: current_user) }
      let(:evaluated_scope) { [project, current_user] }
      let(:evaluated_opts) { { scope: evaluated_scope, users_allowlist: %w[support-bot] } }

      context 'when rate limiting is not in effect' do
        let(:throttled) { false }

        it 'does not raise an exception' do
          expect(subject.rate_limit!(service)).to be_nil
        end
      end

      context 'when rate limiting is in effect' do
        before do
          allow(rate_limiter).to receive(:throttled?).and_return(true)
        end

        it 'raises a RateLimitedError exception' do
          expect { subject.rate_limit!(service) }.to raise_error(described_class::RateLimitedError, 'This endpoint has been requested too many times. Try again later.')
        end
      end
    end
  end

  describe '#execute_without_rate_limiting' do
    let(:rate_limiter_scoped_and_keyed) { instance_double(RateLimitedService::RateLimiterScopedAndKeyed) }
    let(:subject) do
      local_key = key
      local_opts = opts

      Class.new do
        prepend RateLimitedService

        rate_limit key: local_key, opts: local_opts

        def execute(*args, **kwargs)
          'main logic here'
        end
      end.new
    end

    before do
      allow(RateLimitedService::RateLimiterScopedAndKeyed).to receive(:new).with(key: key, opts: opts, rate_limiter: rate_limiter).and_return(rate_limiter_scoped_and_keyed)
    end

    context 'bypasses rate limiting' do
      it 'calls super' do
        expect(rate_limiter_scoped_and_keyed).not_to receive(:rate_limit!).with(subject)

        expect(subject.execute_without_rate_limiting).to eq('main logic here')
      end
    end
  end

  describe '#execute' do
    context 'when rate_limit has not been called' do
      let(:subject) { Class.new { prepend RateLimitedService }.new }

      it 'raises an RateLimitedNotSetupError exception' do
        expect { subject.execute }.to raise_error(described_class::RateLimitedNotSetupError)
      end
    end

    context 'when rate_limit has been called' do
      let(:rate_limiter_scoped_and_keyed) { instance_double(RateLimitedService::RateLimiterScopedAndKeyed) }
      let(:subject) do
        local_key = key
        local_opts = opts

        Class.new do
          prepend RateLimitedService

          rate_limit key: local_key, opts: local_opts

          def execute(*args, **kwargs)
            'main logic here'
          end
        end.new
      end

      before do
        allow(RateLimitedService::RateLimiterScopedAndKeyed).to receive(:new).with(key: key, opts: opts, rate_limiter: rate_limiter).and_return(rate_limiter_scoped_and_keyed)
      end

      context 'and applies rate limiting' do
        it 'raises an RateLimitedService::RateLimitedError exception' do
          expect(rate_limiter_scoped_and_keyed).to receive(:rate_limit!).with(subject).and_raise(RateLimitedService::RateLimitedError.new(key: key, rate_limiter: rate_limiter))

          expect { subject.execute }.to raise_error(RateLimitedService::RateLimitedError)
        end
      end

      context 'but does not apply rate limiting' do
        it 'calls super' do
          expect(rate_limiter_scoped_and_keyed).to receive(:rate_limit!).with(subject).and_return(nil)

          expect(subject.execute).to eq('main logic here')
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module AuditEventSaveType
  SAVE_TYPES = {
    database: 0b01,
    stream: 0b10,
    database_and_stream: 0b11
  }.freeze

  # def should_save_stream?(type)
  # def should_save_database?(type)
  [:database, :stream].each do |type|
    define_method(""should_save_#{type}?"") do |param_type|
      return false unless save_type_valid?(param_type)

      # If the current type does not support query, the result of the `&` operation is 0 .
      SAVE_TYPES[param_type] & SAVE_TYPES[type] != 0
    end
  end

  private

  def save_type_valid?(type)
    SAVE_TYPES.key?(type)
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe AuditEventSaveType, feature_category: :audit_events do
  subject(:target) { Object.new.extend(described_class) }

  describe '#should_save_database? and #should_save_stream?' do
    using RSpec::Parameterized::TableSyntax

    where(:query_method, :query_param, :result) do
      :should_save_stream?    | :stream               | true
      :should_save_stream?    | :database_and_stream  | true
      :should_save_database?  | :database             | true
      :should_save_database?  | :database_and_stream  | true
      :should_save_stream?    | :database             | false
      :should_save_stream?    | nil                   | false
      :should_save_database?  | :stream               | false
      :should_save_database?  | nil                   | false
    end

    with_them do
      it 'returns corresponding results according to the query_method and query_param' do
        expect(target.send(query_method, query_param)).to eq result
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module MergeRequests
  module AssignsMergeParams
    def self.included(klass)
      raise ""#{self} can not be included in #{klass} without implementing #current_user"" unless klass.method_defined?(:current_user)
    end

    def assign_allowed_merge_params(merge_request, merge_params)
      known_merge_params = merge_params.to_h.with_indifferent_access.slice(*MergeRequest::KNOWN_MERGE_PARAMS)

      # Not checking `MergeRequest#can_remove_source_branch` as that includes
      # other checks that aren't needed here.
      known_merge_params.delete(:force_remove_source_branch) unless current_user.can?(:push_code, merge_request.source_project)

      merge_request.merge_params.merge!(known_merge_params)

      # Delete the known params now that they're assigned, so we don't try to
      # assign them through an `#assign_attributes` later.
      # They could be coming in as strings or symbols
      merge_params.to_h.with_indifferent_access.except!(*MergeRequest::KNOWN_MERGE_PARAMS)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequests::AssignsMergeParams, feature_category: :code_review_workflow do
  it 'raises an error when used from an instance that does not respond to #current_user' do
    define_class = -> { Class.new { include MergeRequests::AssignsMergeParams }.new }

    expect { define_class.call }.to raise_error %r{can not be included in (.*) without implementing #current_user}
  end

  describe '#assign_allowed_merge_params' do
    let(:merge_request) { build(:merge_request) }

    let(:params) do
      { commit_message: 'Commit Message',
        'should_remove_source_branch' => true,
        unknown_symbol: 'Unknown symbol',
        'unknown_string' => 'Unknown String' }
    end

    subject(:merge_request_service) do
      Class.new do
        attr_accessor :current_user

        include MergeRequests::AssignsMergeParams

        def initialize(user)
          @current_user = user
        end
      end
    end

    it 'only assigns known parameters to the merge request' do
      service = merge_request_service.new(merge_request.author)

      service.assign_allowed_merge_params(merge_request, params)

      expect(merge_request.merge_params).to eq('commit_message' => 'Commit Message', 'should_remove_source_branch' => true)
    end

    it 'returns a hash without the known merge params' do
      service = merge_request_service.new(merge_request.author)

      result = service.assign_allowed_merge_params(merge_request, params)

      expect(result).to eq({ 'unknown_symbol' => 'Unknown symbol', 'unknown_string' => 'Unknown String' })
    end

    context 'the force_remove_source_branch param' do
      let(:params) { { force_remove_source_branch: true } }

      it 'assigns the param if the user is allowed to do that' do
        service = merge_request_service.new(merge_request.author)

        result = service.assign_allowed_merge_params(merge_request, params)

        expect(merge_request.force_remove_source_branch?).to be true
        expect(result).to be_empty
      end

      it 'only removes the param if the user is not allowed to do that' do
        service = merge_request_service.new(build(:user))

        result = service.assign_allowed_merge_params(merge_request, params)

        expect(merge_request.force_remove_source_branch?).to be_falsy
        expect(result).to be_empty
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Services
  # adapter for existing services over BaseServiceUtility - add error and
  # success methods returning ServiceResponse objects
  module ReturnServiceResponses
    def error(message, http_status, pass_back: {})
      ServiceResponse.error(message: message, http_status: http_status, payload: pass_back)
    end

    def success(payload)
      ServiceResponse.success(payload: payload)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Services::ReturnServiceResponses, feature_category: :rate_limiting do
  subject(:object) { Class.new { include Services::ReturnServiceResponses }.new }

  let(:message) { 'a delivering message' }
  let(:payload) { 'string payload' }

  describe '#success' do
    it 'returns a ServiceResponse instance' do
      response = object.success(payload)
      expect(response).to be_an(ServiceResponse)
      expect(response).to be_success
      expect(response.message).to be_nil
      expect(response.payload).to eq(payload)
      expect(response.http_status).to eq(:ok)
    end
  end

  describe '#error' do
    it 'returns a ServiceResponse instance' do
      response = object.error(message, :not_found, pass_back: payload)
      expect(response).to be_an(ServiceResponse)
      expect(response).to be_error
      expect(response.message).to eq(message)
      expect(response.payload).to eq(payload)
      expect(response.http_status).to eq(:not_found)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Topics
  class MergeService
    attr_accessor :source_topic, :target_topic

    def initialize(source_topic, target_topic)
      @source_topic = source_topic
      @target_topic = target_topic
    end

    def execute
      validate_parameters!

      ::Projects::ProjectTopic.transaction do
        move_project_topics
        refresh_target_topic_counters
        delete_source_topic
      end

      ServiceResponse.success
    rescue ArgumentError => e
      ServiceResponse.error(message: e.message)
    rescue StandardError => e
      Gitlab::ErrorTracking.track_exception(e, source_topic_id: source_topic.id, target_topic_id: target_topic.id)
      ServiceResponse.error(message: _('Topics could not be merged!'))
    end

    private

    def validate_parameters!
      raise ArgumentError, _('The source topic is not a topic.') unless source_topic.is_a?(Projects::Topic)
      raise ArgumentError, _('The target topic is not a topic.') unless target_topic.is_a?(Projects::Topic)
      raise ArgumentError, _('The source topic and the target topic are identical.') if source_topic == target_topic
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def move_project_topics
      project_ids_for_projects_currently_using_source_and_target = ::Projects::ProjectTopic
        .where(topic_id: target_topic).select(:project_id)
      # Only update for projects that exclusively use the source topic
      ::Projects::ProjectTopic.where(topic_id: source_topic.id)
        .where.not(project_id: project_ids_for_projects_currently_using_source_and_target)
        .update_all(topic_id: target_topic.id)

      # Delete source topic for projects that were using source and target
      ::Projects::ProjectTopic.where(topic_id: source_topic.id).delete_all
    end

    def refresh_target_topic_counters
      target_topic.update!(
        total_projects_count: total_projects_count(target_topic.id),
        non_private_projects_count: non_private_projects_count(target_topic.id)
      )
    end

    def delete_source_topic
      source_topic.destroy!
    end

    def total_projects_count(topic_id)
      ::Projects::ProjectTopic.where(topic_id: topic_id).count
    end

    def non_private_projects_count(topic_id)
      ::Projects::ProjectTopic.joins(:project).where(topic_id: topic_id).where('projects.visibility_level in (10, 20)')
        .count
    end
    # rubocop: enable CodeReuse/ActiveRecord
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Topics::MergeService, feature_category: :shared do
  let_it_be(:source_topic) { create(:topic, name: 'source_topic') }
  let_it_be(:target_topic) { create(:topic, name: 'target_topic') }
  let_it_be(:project_1) { create(:project, :public, topic_list: source_topic.name) }
  let_it_be(:project_2) { create(:project, :private, topic_list: source_topic.name) }
  let_it_be(:project_3) { create(:project, :public, topic_list: target_topic.name) }
  let_it_be(:project_4) { create(:project, :public, topic_list: [source_topic.name, target_topic.name]) }

  subject { described_class.new(source_topic, target_topic).execute }

  describe '#execute' do
    it 'merges source topic into target topic' do
      subject

      expect(target_topic.projects).to contain_exactly(project_1, project_2, project_3, project_4)
      expect { source_topic.reload }.to raise_error(ActiveRecord::RecordNotFound)
    end

    it 'refreshes counters of target topic' do
      expect { subject }
        .to change { target_topic.reload.total_projects_count }.by(2)
        .and change { target_topic.reload.non_private_projects_count }.by(1)
    end

    context 'when source topic fails to delete' do
      it 'reverts previous changes' do
        allow(source_topic.reload).to receive(:destroy!).and_raise(ActiveRecord::RecordNotDestroyed)

        response = subject
        expect(response).to be_error
        expect(response.message).to eq('Topics could not be merged!')

        expect(source_topic.projects).to contain_exactly(project_1, project_2, project_4)
        expect(target_topic.projects).to contain_exactly(project_3, project_4)
      end
    end

    context 'for parameter validation' do
      using RSpec::Parameterized::TableSyntax

      subject { described_class.new(source_topic_parameter, target_topic_parameter).execute }

      where(:source_topic_parameter, :target_topic_parameter, :expected_message) do
        nil                | ref(:target_topic) | 'The source topic is not a topic.'
        ref(:source_topic) | nil                | 'The target topic is not a topic.'
        ref(:target_topic) | ref(:target_topic) | 'The source topic and the target topic are identical.'
      end

      with_them do
        it 'raises correct error' do
          response = subject
          expect(response).to be_error
          expect(response.message).to eq(expected_message)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Analytics
  module CycleAnalytics
    module Stages
      class ListService < Analytics::CycleAnalytics::Stages::BaseService
        def execute
          return forbidden unless allowed?

          success(build_default_stages)
        end

        private

        def allowed?
          can?(current_user, :read_cycle_analytics, parent.project)
        end

        def success(stages)
          ServiceResponse.success(payload: { stages: stages })
        end
      end
    end
  end
end

Analytics::CycleAnalytics::Stages::ListService.prepend_mod_with('Analytics::CycleAnalytics::Stages::ListService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Analytics::CycleAnalytics::Stages::ListService, feature_category: :value_stream_management do
  let_it_be(:project) { create(:project) }
  let_it_be(:user) { create(:user) }
  let_it_be(:project_namespace) { project.project_namespace.reload }

  let(:value_stream) { Analytics::CycleAnalytics::ValueStream.build_default_value_stream(project_namespace) }
  let(:stages) { subject.payload[:stages] }

  subject do
    described_class.new(parent: project_namespace, current_user: user, params: { value_stream: value_stream }).execute
  end

  before_all do
    project.add_reporter(user)
  end

  it 'returns only the default stages' do
    expect(stages.size).to eq(Gitlab::Analytics::CycleAnalytics::DefaultStages.all.size)
  end

  it 'provides the default stages as non-persisted objects' do
    expect(stages.map(&:id)).to all(be_nil)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Deployments
  # Service class for linking merge requests to deployments.
  class LinkMergeRequestsService
    attr_reader :deployment

    # The number of commits per query for which to find merge requests.
    COMMITS_PER_QUERY = 5_000

    def initialize(deployment)
      @deployment = deployment
    end

    def execute
      # Review apps have the environment type set (e.g. to `review`, though the
      # exact value may differ). We don't want to link merge requests to review
      # app deployments, as this is not useful.
      return unless deployment.environment.should_link_to_merge_requests?

      # This service is triggered by a Sidekiq worker, which only runs when a
      # deployment is successful. We add an extra check here in case we ever
      # call this service elsewhere and forget to check the status there.
      #
      # The reason we only want to link successful deployments is as follows:
      # when we link a merge request, we don't link it to future deployments for
      # the same environment. If we were to link an MR to a failed deploy, we
      # wouldn't be able to later on link it to a successful deploy (e.g. after
      # the deploy is retried).
      #
      # In addition, showing failed deploys in the UI of a merge request isn't
      # useful to users, as they can't act upon the information in any
      # meaningful way (i.e. they can't just retry the deploy themselves).
      return unless deployment.success?

      if (prev = deployment.previous_deployment)
        link_merge_requests_for_range(prev.sha, deployment.sha)
      else
        # When no previous deployment is found we fall back to linking all merge
        # requests merged into the deployed branch. This will not always be
        # accurate, but it's better than having no data.
        #
        # We can't use the first commit in the repository as a base to compare
        # to, as this will not scale to large repositories. For example, GitLab
        # itself has over 150 000 commits.
        link_all_merged_merge_requests
      end
    end

    def link_merge_requests_for_range(from, to)
      commits = project
        .repository
        .commits_between(from, to)
        .map(&:id)

      # For some projects the list of commits to deploy may be very large. To
      # ensure we do not end up running SQL queries with thousands of WHERE IN
      # values, we run one query per a certain number of commits.
      #
      # In most cases this translates to only a single query. For very large
      # deployment we may end up running a handful of queries to get and insert
      # the data.
      commits.each_slice(COMMITS_PER_QUERY) do |slice|
        merge_requests =
          project.merge_requests.merged.by_merge_commit_sha(slice)

        deployment.link_merge_requests(merge_requests)

        # The cherry picked commits are tracked via `notes.commit_id`
        # See https://gitlab.com/gitlab-org/gitlab/-/merge_requests/22209
        #
        # NOTE: cross-joining `merge_requests` table and `notes` table could
        # result in very poor performance because PG planner often uses an
        # inappropriate index.
        # See https://gitlab.com/gitlab-org/gitlab/-/issues/321032.
        mr_ids = project.notes.cherry_picked_merge_requests(slice)
        picked_merge_requests = project.merge_requests.id_in(mr_ids)

        deployment.link_merge_requests(picked_merge_requests)
      end
    end

    def link_all_merged_merge_requests
      merge_requests =
        project.merge_requests.merged.by_target_branch(deployment.ref)

      deployment.link_merge_requests(merge_requests)
    end

    private

    def project
      deployment.project
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Deployments::LinkMergeRequestsService, feature_category: :continuous_delivery do
  let(:project) { create(:project, :repository) }

  # *   ddd0f15 Merge branch 'po-fix-test-env-path' into 'master'
  # |\
  # | * 2d1db52 Correct test_env.rb path for adding branch
  # |/
  # *   1e292f8 Merge branch 'cherry-pick-ce369011' into 'master'
  # |\
  # | * c1c67ab Add file with a _flattable_ path
  # |/
  # *   7975be0 Merge branch 'rd-add-file-larger-than-1-mb' into 'master'
  let_it_be(:first_deployment_sha) { '7975be0116940bf2ad4321f79d02a55c5f7779aa' }
  let_it_be(:mr1_merge_commit_sha) { '1e292f8fedd741b75372e19097c76d327140c312' }
  let_it_be(:mr2_merge_commit_sha) { 'ddd0f15ae83993f5cb66a927a28673882e99100b' }

  describe '#execute' do
    context 'when the deployment is for a review environment' do
      it 'does nothing' do
        environment =
          create(:environment, environment_type: 'review', name: 'review/foo')

        deploy = create(:deployment, :success, environment: environment)

        expect(deploy).not_to receive(:link_merge_requests)

        described_class.new(deploy).execute
      end
    end

    context 'when the deployment is for one of the production environments' do
      it 'links merge requests' do
        environment =
          create(:environment, environment_type: 'production', name: 'production/gcp')

        deploy = create(:deployment, :success, environment: environment)

        expect(deploy).to receive(:link_merge_requests).once

        described_class.new(deploy).execute
      end
    end

    context 'when the deployment failed' do
      it 'does nothing' do
        environment = create(:environment, name: 'foo')
        deploy = create(:deployment, :failed, environment: environment)

        expect(deploy).not_to receive(:link_merge_requests)

        described_class.new(deploy).execute
      end
    end

    context 'when there is a previous deployment' do
      it 'links all merge requests merged since the previous deployment' do
        deploy1 = create(
          :deployment,
          :success,
          project: project,
          sha: first_deployment_sha
        )

        deploy2 = create(
          :deployment,
          :success,
          project: deploy1.project,
          environment: deploy1.environment,
          sha: mr2_merge_commit_sha
        )

        service = described_class.new(deploy2)

        expect(service)
          .to receive(:link_merge_requests_for_range)
          .with(first_deployment_sha, mr2_merge_commit_sha)

        service.execute
      end
    end

    context 'when there are no previous deployments' do
      it 'links all merged merge requests' do
        deploy = create(:deployment, :success, project: project)
        service = described_class.new(deploy)

        expect(service).to receive(:link_all_merged_merge_requests)

        service.execute
      end
    end
  end

  describe '#link_merge_requests_for_range' do
    it 'links merge requests' do
      environment = create(:environment, project: project)
      deploy =
        create(:deployment, :success, project: project, environment: environment)

      mr1 = create(
        :merge_request,
        :merged,
        merge_commit_sha: mr1_merge_commit_sha,
        source_project: project,
        target_project: project
      )

      mr2 = create(
        :merge_request,
        :merged,
        merge_commit_sha: mr2_merge_commit_sha,
        source_project: project,
        target_project: project
      )

      described_class.new(deploy).link_merge_requests_for_range(
        first_deployment_sha,
        mr2_merge_commit_sha
      )

      expect(deploy.merge_requests).to include(mr1, mr2)
    end

    it 'links picked merge requests' do
      environment = create(:environment, project: project)
      deploy =
        create(:deployment, :success, project: project, environment: environment)

      picked_mr = create(
        :merge_request,
        :merged,
        merge_commit_sha: '123abc',
        source_project: project,
        target_project: project
      )

      mr1 = create(
        :merge_request,
        :merged,
        merge_commit_sha: mr1_merge_commit_sha,
        source_project: project,
        target_project: project
      )

      # mr1 includes c1c67abba which is a cherry-pick of the fake picked_mr merge request
      create(:track_mr_picking_note, noteable: picked_mr, project: project, commit_id: 'c1c67abbaf91f624347bb3ae96eabe3a1b742478')

      described_class.new(deploy).link_merge_requests_for_range(
        first_deployment_sha,
        mr1_merge_commit_sha
      )

      expect(deploy.merge_requests).to include(mr1, picked_mr)
    end

    it ""doesn't link the same merge_request twice"" do
      create(:merge_request, :merged, merge_commit_sha: mr1_merge_commit_sha, source_project: project)

      picked_mr = create(:merge_request, :merged, merge_commit_sha: '123abc', source_project: project)

      # the first MR includes c1c67abba which is a cherry-pick of the fake picked_mr merge request
      create(:track_mr_picking_note, noteable: picked_mr, project: project, commit_id: 'c1c67abbaf91f624347bb3ae96eabe3a1b742478')

      environment = create(:environment, project: project)
      old_deploy =
        create(:deployment, :success, project: project, environment: environment)

      # manually linking all the MRs to the old_deploy
      old_deploy.link_merge_requests(project.merge_requests)

      deploy =
        create(:deployment, :success, project: project, environment: environment)

      described_class.new(deploy).link_merge_requests_for_range(
        first_deployment_sha,
        mr1_merge_commit_sha
      )

      expect(deploy.merge_requests).to be_empty
    end
  end

  describe '#link_all_merged_merge_requests' do
    it 'links all merged merge requests targeting the deployed branch' do
      environment = create(:environment, project: project)
      deploy =
        create(:deployment, :success, project: project, environment: environment)

      mr1 = create(
        :merge_request,
        :merged,
        source_project: project,
        target_project: project,
        source_branch: 'source1',
        target_branch: deploy.ref
      )

      mr2 = create(
        :merge_request,
        :merged,
        source_project: project,
        target_project: project,
        source_branch: 'source2',
        target_branch: deploy.ref
      )

      mr3 = create(
        :merge_request,
        :merged,
        source_project: project,
        target_project: project,
        target_branch: 'foo'
      )

      described_class.new(deploy).link_all_merged_merge_requests

      expect(deploy.merge_requests).to include(mr1, mr2)
      expect(deploy.merge_requests).not_to include(mr3)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Deployments
  # This service archives old deploymets and deletes deployment refs for
  # keeping the project repository performant.
  class ArchiveInProjectService < ::BaseService
    BATCH_SIZE = 100

    def execute
      deployments = Deployment.archivables_in(project, limit: BATCH_SIZE)

      return success(result: :empty) if deployments.empty?

      ids = deployments.map(&:id)
      ref_paths = deployments.map(&:ref_path)

      project.repository.delete_refs(*ref_paths)
      project.deployments.id_in(ids).update_all(archived: true)

      success(result: :archived, count: ids.count)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Deployments::ArchiveInProjectService, feature_category: :continuous_delivery do
  let_it_be(:project) { create(:project, :repository) }

  let(:service) { described_class.new(project, nil) }

  describe '#execute' do
    subject { service.execute }

    context 'when there are archivable deployments' do
      let!(:deployments) { create_list(:deployment, 3, project: project) }
      let!(:deployment_refs) { deployments.map(&:ref_path) }

      before do
        deployments.each(&:create_ref)
        allow(Deployment).to receive(:archivables_in) { deployments }
      end

      it 'returns result code' do
        expect(subject[:result]).to eq(:archived)
        expect(subject[:status]).to eq(:success)
        expect(subject[:count]).to eq(3)
      end

      it 'archives the deployment' do
        expect(deployments.map(&:archived?)).to be_all(false)
        expect(deployment_refs_exist?).to be_all(true)

        subject

        deployments.each(&:reload)
        expect(deployments.map(&:archived?)).to be_all(true)
        expect(deployment_refs_exist?).to be_all(false)
      end

      context 'when ref does not exist by some reason' do
        before do
          project.repository.delete_refs(*deployment_refs)
        end

        it 'does not raise an error' do
          expect(deployment_refs_exist?).to be_all(false)

          expect { subject }.not_to raise_error

          expect(deployment_refs_exist?).to be_all(false)
        end
      end

      def deployment_refs_exist?
        deployment_refs.map { |path| project.repository.ref_exists?(path) }
      end
    end

    context 'when there are no archivable deployments' do
      before do
        allow(Deployment).to receive(:archivables_in) { Deployment.none }
      end

      it 'returns result code' do
        expect(subject[:result]).to eq(:empty)
        expect(subject[:status]).to eq(:success)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Deployments
  # This class creates a deployment record for a pipeline job.
  class CreateForJobService
    DeploymentCreationError = Class.new(StandardError)

    def execute(job)
      return unless job.is_a?(::Ci::Processable) && job.persisted_environment.present?

      environment = job.actual_persisted_environment

      deployment = to_resource(job, environment)

      return unless deployment

      deployment.save!
      job.association(:deployment).target = deployment
      job.association(:deployment).loaded!

      deployment
    rescue ActiveRecord::RecordInvalid => e
      Gitlab::ErrorTracking.track_and_raise_for_dev_exception(
        DeploymentCreationError.new(e.message), job_id: job.id)
    end

    private

    def to_resource(job, environment)
      return job.deployment if job.deployment
      return unless job.deployment_job?

      deployment = ::Deployment.new(attributes(job, environment))

      # If there is a validation error on environment creation, such as
      # the name contains invalid character, the job will fall back to a
      # non-environment job.
      return unless deployment.valid? && deployment.environment.persisted?

      if cluster = deployment.environment.deployment_platform&.cluster # rubocop: disable Lint/AssignmentInCondition
        deployment.deployment_cluster = ::DeploymentCluster.new(
          cluster_id: cluster.id,
          kubernetes_namespace: cluster.kubernetes_namespace_for(deployment.environment, deployable: job)
        )
      end

      # Allocate IID for deployments.
      # This operation must be outside of transactions of pipeline creations.
      deployment.ensure_project_iid!

      deployment
    end

    def attributes(job, environment)
      {
        project: job.project,
        environment: environment,
        deployable: job,
        user: job.user,
        ref: job.ref,
        tag: job.tag,
        sha: job.sha,
        on_stop: job.on_stop
      }
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Deployments::CreateForJobService, feature_category: :continuous_delivery do
  let_it_be(:project) { create(:project, :repository) }
  let_it_be(:user) { create(:user) }

  let(:service) { described_class.new }

  it_behaves_like 'create deployment for job' do
    let(:factory_type) { :ci_build }
  end

  it_behaves_like 'create deployment for job' do
    let(:factory_type) { :ci_bridge }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Deployments
  class UpdateEnvironmentService
    attr_reader :deployment
    attr_reader :deployable

    delegate :environment, to: :deployment
    delegate :variables, to: :deployable
    delegate :options, to: :deployable, allow_nil: true

    EnvironmentUpdateFailure = Class.new(StandardError)

    def initialize(deployment)
      @deployment = deployment
      @deployable = deployment.deployable
    end

    def execute
      deployment.create_ref
      deployment.invalidate_cache

      update_environment(deployment)

      deployment
    end

    def update_environment(deployment)
      ApplicationRecord.transaction do
        # Renew attributes at update
        renew_external_url
        renew_auto_stop_in
        renew_deployment_tier
        environment.fire_state_event(action)

        if environment.save
          deployment.update_merge_request_metrics! unless environment.stopped?
        else
          # If there is a validation error on environment update, such as
          # the external URL is malformed, the error message is recorded for debugging purpose.
          # We should surface the error message to users for letting them to take an action.
          # See https://gitlab.com/gitlab-org/gitlab/-/issues/21182.
          Gitlab::ErrorTracking.track_exception(
            EnvironmentUpdateFailure.new,
            project_id: deployment.project_id,
            environment_id: environment.id,
            reason: environment.errors.full_messages.to_sentence)
        end
      end
    end

    private

    def environment_options
      options&.dig(:environment) || {}
    end

    def expanded_environment_url
      return unless environment_url

      ExpandVariables.expand(environment_url, -> { variables.sort_and_expand_all })
    end

    def expanded_auto_stop_in
      return unless auto_stop_in

      ExpandVariables.expand(auto_stop_in, -> { variables.sort_and_expand_all })
    end

    def environment_url
      environment_options[:url]
    end

    def action
      environment_options[:action] || 'start'
    end

    def auto_stop_in
      deployable&.environment_auto_stop_in
    end

    def renew_external_url
      if (url = expanded_environment_url)
        environment.external_url = url
      end
    end

    def renew_auto_stop_in
      return unless deployable

      if (value = expanded_auto_stop_in)
        environment.auto_stop_in = value
      end
    end

    def renew_deployment_tier
      return unless deployable

      if (tier = deployable.environment_tier_from_options)
        environment.tier = tier
      end
    end
  end
end

Deployments::UpdateEnvironmentService.prepend_mod_with('Deployments::UpdateEnvironmentService')

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Deployments::UpdateEnvironmentService, feature_category: :continuous_delivery do
  let(:user) { create(:user) }
  let(:project) { create(:project, :repository) }
  let(:options) { { name: environment_name } }
  let(:pipeline) do
    create(
      :ci_pipeline,
      sha: 'b83d6e391c22777fca1ed3012fce84f633d7fed0',
      project: project
    )
  end

  let(:job) do
    create(:ci_build,
      :with_deployment,
      pipeline: pipeline,
      ref: 'master',
      tag: false,
      environment: environment_name,
      options: { environment: options },
      project: project)
  end

  let(:deployment) { job.deployment }
  let(:environment) { deployment.environment }
  let(:environment_name) { 'production' }

  subject(:service) { described_class.new(deployment) }

  before do
    allow(Deployments::LinkMergeRequestWorker).to receive(:perform_async)
    allow(Deployments::HooksWorker).to receive(:perform_async)
    job.success! # Create/Succeed deployment
  end

  describe '#execute' do
    let(:store) { Gitlab::EtagCaching::Store.new }

    it 'invalidates the environment etag cache' do
      old_value = store.get(environment.etag_cache_key)

      service.execute

      expect(store.get(environment.etag_cache_key)).not_to eq(old_value)
    end

    it 'creates ref' do
      expect_any_instance_of(Repository)
        .to receive(:create_ref)
        .with(deployment.sha, ""refs/environments/production/deployments/#{deployment.iid}"")

      service.execute
    end

    it 'updates merge request metrics' do
      expect_any_instance_of(Deployment)
        .to receive(:update_merge_request_metrics!)

      service.execute
    end

    it 'returns the deployment' do
      expect(subject.execute).to eq(deployment)
    end

    it 'returns the deployment when could not save the environment' do
      allow(environment).to receive(:save).and_return(false)

      expect(subject.execute).to eq(deployment)
    end

    it 'returns the deployment when environment is stopped' do
      allow(environment).to receive(:stopped?).and_return(true)

      expect(subject.execute).to eq(deployment)
    end

    context 'when deployable is bridge job' do
      let(:job) do
        create(:ci_bridge,
          :with_deployment,
          pipeline: pipeline,
          ref: 'master',
          tag: false,
          environment: environment_name,
          options: { environment: options },
          project: project)
      end

      it 'creates ref' do
        expect_any_instance_of(Repository)
          .to receive(:create_ref)
          .with(deployment.sha, ""refs/environments/production/deployments/#{deployment.iid}"")

        service.execute
      end
    end

    context 'when start action is defined' do
      let(:options) { { name: 'production', action: 'start' } }

      context 'and environment is stopped' do
        before do
          environment.stop_complete
        end

        it 'makes environment available' do
          service.execute

          expect(environment.reload).to be_available
        end
      end
    end

    context 'when external URL is specified and the tier is unset' do
      let(:options) { { name: 'production', url: external_url } }

      before do
        environment.update_columns(external_url: external_url, tier: nil)
        job.update!(environment: 'production')
      end

      context 'when external URL is valid' do
        let(:external_url) { 'https://google.com' }

        it 'succeeds to update the tier automatically' do
          expect { subject.execute }.to change { environment.tier }.from(nil).to('production')
        end
      end

      context 'when external URL is invalid' do
        let(:external_url) { 'javascript:alert(""hello"")' }

        it 'fails to update the tier due to validation error' do
          expect { subject.execute }.not_to change { environment.reload.tier }
        end

        it 'tracks an exception' do
          expect(Gitlab::ErrorTracking).to receive(:track_exception)
            .with(
              an_instance_of(described_class::EnvironmentUpdateFailure),
              project_id: project.id,
              environment_id: environment.id,
              reason: %q(External url javascript scheme is not allowed)
            )
            .once

          subject.execute
        end
      end
    end

    context 'when variables are used' do
      let(:options) do
        { name: 'review-apps/$CI_COMMIT_REF_NAME',
          url: 'http://$CI_COMMIT_REF_NAME.review-apps.gitlab.com' }
      end

      before do
        environment.update!(name: 'review-apps/master')
        job.update!(environment: 'review-apps/$CI_COMMIT_REF_NAME')
      end

      it 'does not create a new environment' do
        expect { subject.execute }.not_to change { Environment.count }
      end

      it 'updates external url' do
        subject.execute

        expect(subject.environment.name).to eq('review-apps/master')
        expect(subject.environment.external_url).to eq('http://master.review-apps.gitlab.com')
      end
    end

    context 'when auto_stop_in are used' do
      let(:options) do
        { name: 'production', auto_stop_in: '1 day' }
      end

      before do
        environment.update_attribute(:auto_stop_at, nil)
      end

      it 'renews auto stop at' do
        freeze_time do
          expect { subject.execute }
            .to change { environment.reset.auto_stop_at&.round }.from(nil).to(1.day.since.round)
        end
      end

      context 'when value is a variable' do
        let(:options) { { name: 'production', auto_stop_in: '$TTL' } }

        let(:yaml_variables) do
          [
            { key: ""TTL"", value: '2 days', public: true }
          ]
        end

        before do
          job.update_attribute(:yaml_variables, yaml_variables)
        end

        it 'renews auto stop at with expanded variable value' do
          freeze_time do
            expect { subject.execute }
              .to change { environment.reset.auto_stop_at&.round }.from(nil).to(2.days.since.round)
          end
        end
      end
    end

    context 'when deployment tier is specified' do
      let(:environment_name) { 'customer-portal' }
      let(:options) { { name: environment_name, deployment_tier: 'production' } }

      context 'when tier has already been set' do
        before do
          environment.update_column(:tier, Environment.tiers[:other])
        end

        it 'overwrites the guessed tier by the specified deployment tier' do
          expect { subject.execute }
            .to change { environment.reset.tier }.from('other').to('production')
        end
      end

      context 'when tier has not been set' do
        before do
          environment.update_column(:tier, nil)
        end

        it 'sets the specified deployment tier' do
          expect { subject.execute }
            .to change { environment.reset.tier }.from(nil).to('production')
        end

        context 'when deployment was created by an external CD system' do
          before do
            deployment.update_column(:deployable_id, nil)
            deployment.reload
          end

          it 'guesses the deployment tier' do
            expect { subject.execute }
              .to change { environment.reset.tier }.from(nil).to('other')
          end
        end
      end
    end

    context 'when deployment tier is not specified' do
      let(:environment_name) { 'customer-portal' }
      let(:options) { { name: environment_name } }

      it 'guesses the deployment tier' do
        environment.update_column(:tier, nil)

        expect { subject.execute }
          .to change { environment.reset.tier }.from(nil).to('other')
      end
    end
  end

  describe '#expanded_environment_url' do
    subject { service.send(:expanded_environment_url) }

    context 'when yaml environment uses $CI_COMMIT_REF_NAME' do
      let(:job) do
        create(
          :ci_build,
          :with_deployment,
          pipeline: pipeline,
          ref: 'master',
          environment: 'production',
          project: project,
          options: { environment: { name: 'production', url: 'http://review/$CI_COMMIT_REF_NAME' } }
        )
      end

      it { is_expected.to eq('http://review/master') }
    end

    context 'when yaml environment uses $CI_ENVIRONMENT_SLUG' do
      let(:job) do
        create(
          :ci_build,
          :with_deployment,
          pipeline: pipeline,
          ref: 'master',
          environment: 'prod-slug',
          project: project,
          options: { environment: { name: 'prod-slug', url: 'http://review/$CI_ENVIRONMENT_SLUG' } }
        )
      end

      it { is_expected.to eq('http://review/prod-slug') }
    end

    context 'when yaml environment uses yaml_variables containing symbol keys' do
      let(:job) do
        create(
          :ci_build,
          :with_deployment,
          pipeline: pipeline,
          yaml_variables: [{ key: :APP_HOST, value: 'host' }],
          environment: 'production',
          project: project,
          options: { environment: { name: 'production', url: 'http://review/$APP_HOST' } }
        )
      end

      it { is_expected.to eq('http://review/host') }
    end

    context 'when job variables are generated during runtime' do
      let(:job) do
        create(
          :ci_build,
          :with_deployment,
          pipeline: pipeline,
          environment: 'review/$CI_COMMIT_REF_NAME',
          project: project,
          job_variables: [job_variable],
          options: { environment: { name: 'review/$CI_COMMIT_REF_NAME', url: 'http://$DYNAMIC_ENV_URL' } }
        )
      end

      let(:job_variable) do
        build(:ci_job_variable, :dotenv_source, key: 'DYNAMIC_ENV_URL', value: 'abc.test.com')
      end

      it 'expands the environment URL from the dynamic variable' do
        is_expected.to eq('http://abc.test.com')
      end
    end

    context 'when environment url uses a nested variable' do
      let(:yaml_variables) do
        [
          { key: 'MAIN_DOMAIN', value: '${STACK_NAME}.example.com' },
          { key: 'STACK_NAME', value: 'appname-${ENVIRONMENT_NAME}' },
          { key: 'ENVIRONMENT_NAME', value: '${CI_COMMIT_REF_SLUG}' }
        ]
      end

      let(:job) do
        create(
          :ci_build,
          :with_deployment,
          pipeline: pipeline,
          ref: 'master',
          environment: 'production',
          project: project,
          yaml_variables: yaml_variables,
          options: { environment: { name: 'production', url: 'http://$MAIN_DOMAIN' } }
        )
      end

      it { is_expected.to eq('http://appname-master.example.com') }
    end

    context 'when yaml environment does not have url' do
      let(:job) { create(:ci_build, :with_deployment, pipeline: pipeline, environment: 'staging', project: project) }

      it 'returns the external_url from persisted environment' do
        is_expected.to be_nil
      end
    end
  end

  describe ""merge request metrics"" do
    let(:merge_request) { create(:merge_request, target_branch: 'master', source_branch: 'feature', source_project: project) }

    context ""while updating the 'first_deployed_to_production_at' time"" do
      before do
        merge_request.metrics.update!(merged_at: 1.hour.ago)
      end

      context ""for merge requests merged before the current deploy"" do
        it ""sets the time if the deploy's environment is 'production'"" do
          service.execute

          expect(merge_request.reload.metrics.first_deployed_to_production_at).to be_like_time(deployment.finished_at)
        end

        context 'when job deploys to staging' do
          let(:job) do
            create(:ci_build,
              :with_deployment,
              pipeline: pipeline,
              ref: 'master',
              tag: false,
              environment: 'staging',
              options: { environment: { name: 'staging' } },
              project: project)
          end

          it ""doesn't set the time if the deploy's environment is not 'production'"" do
            service.execute

            expect(merge_request.reload.metrics.first_deployed_to_production_at).to be_nil
          end
        end

        it 'does not raise errors if the merge request does not have a metrics record' do
          merge_request.metrics.destroy!

          expect(merge_request.reload.metrics).to be_nil
          expect { service.execute }.not_to raise_error
        end
      end

      context ""for merge requests merged before the previous deploy"" do
        context ""if the 'first_deployed_to_production_at' time is already set"" do
          it ""does not overwrite the older 'first_deployed_to_production_at' time"" do
            # Previous deploy
            service.execute

            expect(merge_request.reload.metrics.first_deployed_to_production_at).to be_like_time(deployment.finished_at)

            # Current deploy
            travel_to(12.hours.from_now) do
              service.execute

              expect(merge_request.reload.metrics.first_deployed_to_production_at).to be_like_time(deployment.finished_at)
            end
          end
        end

        context ""if the 'first_deployed_to_production_at' time is not already set"" do
          it ""does not overwrite the older 'first_deployed_to_production_at' time"" do
            # Previous deploy
            time = 5.minutes.from_now
            travel_to(time) { service.execute }

            expect(merge_request.reload.metrics.merged_at).to be < merge_request.reload.metrics.first_deployed_to_production_at

            previous_time = merge_request.reload.metrics.first_deployed_to_production_at

            # Current deploy
            travel_to(time + 12.hours) { service.execute }

            expect(merge_request.reload.metrics.first_deployed_to_production_at).to eq(previous_time)
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Deployments
  class UpdateService
    attr_reader :deployment, :params

    def initialize(deployment, params)
      @deployment = deployment
      @params = params
    end

    def execute
      deployment.update_status(params[:status])
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Deployments::UpdateService, feature_category: :continuous_delivery do
  let(:deploy) { create(:deployment) }

  describe '#execute' do
    it 'can update the status to running' do
      expect(described_class.new(deploy, status: 'running').execute)
        .to be_truthy

      expect(deploy).to be_running
    end

    it 'can update the status to success' do
      expect(described_class.new(deploy, status: 'success').execute)
        .to be_truthy

      expect(deploy).to be_success
    end

    it 'can update the status to failed' do
      expect(described_class.new(deploy, status: 'failed').execute)
        .to be_truthy

      expect(deploy).to be_failed
    end

    it 'can update the status to canceled' do
      expect(described_class.new(deploy, status: 'canceled').execute)
        .to be_truthy

      expect(deploy).to be_canceled
    end

    it 'does not change the state if the status is invalid' do
      expect(described_class.new(deploy, status: 'kittens').execute)
        .to be_falsy

      expect(deploy).to be_created
    end

    it 'links merge requests when changing the status to success', :sidekiq_inline do
      mr = create(
        :merge_request,
        :merged,
        target_project: deploy.project,
        source_project: deploy.project,
        target_branch: 'master',
        source_branch: 'foo'
      )

      described_class.new(deploy, status: 'success').execute

      expect(deploy.merge_requests).to eq([mr])
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Deployments
  class CreateService
    attr_reader :environment, :current_user, :params

    def initialize(environment, current_user, params)
      @environment = environment
      @current_user = current_user
      @params = params
    end

    def execute
      return last_deployment if last_deployment&.equal_to?(params)

      environment.deployments.build(deployment_attributes).tap do |deployment|
        # Deployment#change_status already saves the model, so we only need to
        # call #save ourselves if no status is provided.
        if (status = params[:status])
          deployment.update_status(status)
        else
          deployment.save
        end
      end
    end

    def deployment_attributes
      # We use explicit parameters here so we never by accident allow parameters
      # to be set that one should not be able to set (e.g. the row ID).
      {
        project_id: environment.project_id,
        environment_id: environment.id,
        ref: params[:ref],
        tag: params[:tag],
        sha: params[:sha],
        user: current_user,
        on_stop: params[:on_stop]
      }
    end

    private

    def last_deployment
      @environment.last_deployment
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe Deployments::CreateService, feature_category: :continuous_delivery do
  let(:user) { create(:user) }

  describe '#execute' do
    let(:project) { create(:project, :repository) }
    let(:environment) { create(:environment, project: project) }

    it 'creates a deployment' do
      service = described_class.new(
        environment,
        user,
        sha: 'b83d6e391c22777fca1ed3012fce84f633d7fed0',
        ref: 'master',
        tag: false,
        status: 'success'
      )

      expect(Deployments::UpdateEnvironmentWorker).to receive(:perform_async)
      expect(Deployments::LinkMergeRequestWorker).to receive(:perform_async)
      expect(Deployments::HooksWorker).to receive(:perform_async)

      expect(service.execute).to be_persisted
    end

    it 'does not change the status if no status is given' do
      service = described_class.new(
        environment,
        user,
        sha: 'b83d6e391c22777fca1ed3012fce84f633d7fed0',
        ref: 'master',
        tag: false
      )

      expect(Deployments::UpdateEnvironmentWorker).not_to receive(:perform_async)
      expect(Deployments::LinkMergeRequestWorker).not_to receive(:perform_async)
      expect(Deployments::HooksWorker).not_to receive(:perform_async)

      expect(service.execute).to be_persisted
    end

    context 'when the last deployment has the same parameters' do
      let(:params) do
        {
          sha: 'b83d6e391c22777fca1ed3012fce84f633d7fed0',
          ref: 'master',
          tag: false,
          status: 'success'
        }
      end

      it 'does not create a new deployment' do
        described_class.new(environment, user, params).execute

        expect(Deployments::UpdateEnvironmentWorker).not_to receive(:perform_async)
        expect(Deployments::LinkMergeRequestWorker).not_to receive(:perform_async)
        expect(Deployments::HooksWorker).not_to receive(:perform_async)

        described_class.new(environment.reload, user, params).execute
      end
    end
  end

  describe '#deployment_attributes' do
    let(:environment) do
      double(
        :environment,
        deployment_platform: double(:platform, cluster_id: 1),
        project_id: 2,
        id: 3
      )
    end

    it 'only includes attributes that we want to persist' do
      service = described_class.new(
        environment,
        user,
        ref: 'master',
        tag: true,
        sha: '123',
        foo: 'bar',
        on_stop: 'stop'
      )

      expect(service.deployment_attributes).to eq(
        project_id: 2,
        environment_id: 3,
        ref: 'master',
        tag: true,
        sha: '123',
        user: user,
        on_stop: 'stop'
      )
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module BulkImports
  class UploadsExportService
    include Gitlab::ImportExport::CommandLineUtil

    BATCH_SIZE = 100
    AVATAR_PATH = 'avatar'

    attr_reader :exported_objects_count

    def initialize(portable, export_path)
      @portable = portable
      @export_path = export_path
      @exported_objects_count = 0
    end

    def execute(options = {})
      relation = portable.uploads

      if options[:batch_ids]
        relation = relation.where(relation.model.primary_key => options[:batch_ids]) # rubocop:disable CodeReuse/ActiveRecord
      end

      relation.find_each(batch_size: BATCH_SIZE) do |upload| # rubocop: disable CodeReuse/ActiveRecord
        uploader = upload.retrieve_uploader

        next unless upload.exist?
        next unless uploader.file

        subdir_path = export_subdir_path(upload)
        mkdir_p(subdir_path)
        download_or_copy_upload(uploader, File.join(subdir_path, uploader.filename))
        @exported_objects_count += 1
      rescue StandardError => e
        # Do not fail entire project export if something goes wrong during file download
        # (e.g. downloaded file has filename that exceeds 255 characters).
        # Ignore raised exception, skip such upload, log the error and keep going with the export instead.
        Gitlab::ErrorTracking.log_exception(e, portable_id: portable.id, portable_class: portable.class.name, upload_id: upload.id)
      end
    end

    private

    attr_reader :portable, :export_path

    def export_subdir_path(upload)
      subdir = if upload.path == avatar_path
                 AVATAR_PATH
               else
                 upload.try(:secret).to_s
               end

      File.join(export_path, subdir)
    end

    def avatar_path
      @avatar_path ||= portable.avatar&.upload&.path
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe BulkImports::UploadsExportService, feature_category: :importers do
  let(:export_path) { Dir.mktmpdir }
  let(:project) { create(:project, avatar: fixture_file_upload('spec/fixtures/rails_sample.png', 'image/png')) }
  let!(:upload) { create(:upload, :with_file, :issuable_upload, uploader: FileUploader, model: project) }
  let(:exported_filepath) { File.join(export_path, upload.secret, upload.retrieve_uploader.filename) }

  subject(:service) { described_class.new(project, export_path) }

  after do
    FileUtils.remove_entry(export_path) if Dir.exist?(export_path)
  end

  describe '#execute' do
    it 'exports project uploads and avatar' do
      service.execute

      expect(File).to exist(File.join(export_path, 'avatar', 'rails_sample.png'))
      expect(File).to exist(exported_filepath)
    end

    context 'when export is batched' do
      it 'exports only specified uploads' do
        service.execute(batch_ids: [upload.id])

        expect(service.exported_objects_count).to eq(1)
        expect(File).not_to exist(File.join(export_path, 'avatar', 'rails_sample.png'))
        expect(File).to exist(exported_filepath)
      end
    end

    context 'when upload has underlying file missing' do
      context 'with an upload missing its file' do
        it 'does not cause errors' do
          File.delete(upload.absolute_path)

          expect { service.execute }.not_to raise_error

          expect(File).not_to exist(exported_filepath)
        end
      end

      context 'when upload is in object storage' do
        before do
          stub_uploads_object_storage(FileUploader)
        end

        shared_examples 'export with invalid upload' do
          it 'ignores problematic upload and logs exception' do
            allow(service).to receive(:download_or_copy_upload).and_raise(exception)

            expect(Gitlab::ErrorTracking)
              .to receive(:log_exception)
              .with(
                instance_of(exception), {
                  portable_id: project.id,
                  portable_class: 'Project',
                  upload_id: upload.id
                }
              )

            expect(Gitlab::ErrorTracking)
              .to receive(:log_exception)
              .with(
                instance_of(exception), {
                  portable_id: project.id,
                  portable_class: 'Project',
                  upload_id: project.avatar.upload.id
                }
              )

            service.execute

            expect(File).not_to exist(exported_filepath)
          end
        end

        context 'when filename is too long' do
          let(:exception) { Errno::ENAMETOOLONG }

          include_examples 'export with invalid upload'
        end

        context 'when network exception occurs' do
          let(:exception) { Net::OpenTimeout }

          include_examples 'export with invalid upload'
        end
      end
    end
  end

  describe '#exported_objects_count' do
    it 'return the number of exported uploads' do
      service.execute

      expect(service.exported_objects_count).to eq(2)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module BulkImports
  class LfsObjectsExportService
    include Gitlab::ImportExport::CommandLineUtil

    BATCH_SIZE = 100

    attr_reader :exported_objects_count

    def initialize(portable, export_path)
      @portable = portable
      @export_path = export_path
      @lfs_json = {}
      @exported_objects_count = 0
    end

    def execute(options = {})
      relation = portable.lfs_objects

      if options[:batch_ids]
        relation = relation.where(relation.model.primary_key => options[:batch_ids]) # rubocop:disable CodeReuse/ActiveRecord
      end

      relation.find_in_batches(batch_size: BATCH_SIZE) do |batch| # rubocop: disable CodeReuse/ActiveRecord
        batch.each do |lfs_object|
          save_lfs_object(lfs_object)
          @exported_objects_count += 1
        end

        append_lfs_json_for_batch(batch)
      end

      write_lfs_json
    end

    private

    attr_reader :portable, :export_path, :lfs_json

    def save_lfs_object(lfs_object)
      destination_filepath = File.join(export_path, lfs_object.oid)

      if lfs_object.local_store?
        return unless File.exist?(lfs_object.file.path)

        copy_files(lfs_object.file.path, destination_filepath)
      else
        download(lfs_object.file.url, destination_filepath)
      end
    end

    # rubocop: disable CodeReuse/ActiveRecord
    def append_lfs_json_for_batch(lfs_objects_batch)
      lfs_objects_projects = LfsObjectsProject
        .select('lfs_objects.oid, array_agg(distinct lfs_objects_projects.repository_type) as repository_types')
        .joins(:lfs_object)
        .where(project: portable, lfs_object: lfs_objects_batch)
        .group('lfs_objects.oid')

      lfs_objects_projects.each do |group|
        oid = group.oid

        lfs_json[oid] ||= []
        lfs_json[oid] += group.repository_types
      end
    end
    # rubocop: enable CodeReuse/ActiveRecord

    def write_lfs_json
      filepath = File.join(export_path, ""#{BulkImports::FileTransfer::ProjectConfig::LFS_OBJECTS_RELATION}.json"")

      File.write(filepath, Gitlab::Json.dump(lfs_json))
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe BulkImports::LfsObjectsExportService, feature_category: :importers do
  let_it_be(:project) { create(:project) }
  let_it_be(:lfs_json_filename) { ""#{BulkImports::FileTransfer::ProjectConfig::LFS_OBJECTS_RELATION}.json"" }
  let_it_be(:remote_url) { 'http://my-object-storage.local' }

  let(:export_path) { Dir.mktmpdir }
  let(:lfs_object) { create(:lfs_object, :with_file) }

  subject(:service) { described_class.new(project, export_path) }

  before do
    stub_lfs_object_storage

    %w[wiki design].each do |repository_type|
      create(
        :lfs_objects_project,
        project: project,
        repository_type: repository_type,
        lfs_object: lfs_object
      )
    end

    project.lfs_objects << lfs_object
  end

  after do
    FileUtils.remove_entry(export_path) if Dir.exist?(export_path)
  end

  describe '#execute' do
    it 'exports lfs objects and their repository types' do
      filepath = File.join(export_path, lfs_json_filename)

      service.execute

      expect(File).to exist(File.join(export_path, lfs_object.oid))
      expect(File).to exist(filepath)

      lfs_json = Gitlab::Json.parse(File.read(filepath))

      expect(lfs_json).to eq(
        {
          lfs_object.oid => [
            LfsObjectsProject.repository_types['wiki'],
            LfsObjectsProject.repository_types['design'],
            nil
          ]
        }
      )
    end

    context 'when export is batched' do
      it 'exports only specified lfs objects' do
        new_lfs_object = create(:lfs_object, :with_file)

        project.lfs_objects << new_lfs_object

        service.execute(batch_ids: [new_lfs_object.id])

        expect(File).to exist(File.join(export_path, new_lfs_object.oid))
        expect(File).not_to exist(File.join(export_path, lfs_object.oid))
      end
    end

    context 'when lfs object has file on disk missing' do
      it 'does not attempt to copy non-existent file' do
        FileUtils.rm(lfs_object.file.path)

        expect(service).not_to receive(:copy_files)

        service.execute

        expect(File).not_to exist(File.join(export_path, lfs_object.oid))
      end
    end

    context 'when lfs object is remotely stored' do
      let(:lfs_object) { create(:lfs_object, :object_storage) }

      it 'downloads lfs object from object storage' do
        expect_next_instance_of(LfsObjectUploader) do |instance|
          expect(instance).to receive(:url).and_return(remote_url)
        end

        expect(subject).to receive(:download).with(remote_url, File.join(export_path, lfs_object.oid))

        service.execute
      end
    end
  end

  describe '#exported_objects_count' do
    it 'return the number of exported lfs objects' do
      project.lfs_objects << create(:lfs_object, :with_file)

      service.execute

      expect(service.exported_objects_count).to eq(2)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# File Download Service allows remote file download into tmp directory.
#
# @param configuration [BulkImports::Configuration] Config object containing url and access token
# @param relative_url [String] Relative URL to download the file from
# @param tmpdir [String] Temp directory to store downloaded file to. Must be located under `Dir.tmpdir`.
# @param file_size_limit [Integer] Maximum allowed file size. If 0, no limit will apply.
# @param allowed_content_types [Array<String>] Allowed file content types
# @param filename [String] Name of the file to download, if known. Use remote filename if none given.
module BulkImports
  class FileDownloadService
    include ::BulkImports::FileDownloads::FilenameFetch
    include ::BulkImports::FileDownloads::Validations

    ServiceError = Class.new(StandardError)

    DEFAULT_ALLOWED_CONTENT_TYPES = %w[application/gzip application/octet-stream].freeze
    LAST_CHUNK_CONTEXT_CHAR_LIMIT = 200

    def initialize(
      configuration:,
      relative_url:,
      tmpdir:,
      file_size_limit: default_file_size_limit,
      allowed_content_types: DEFAULT_ALLOWED_CONTENT_TYPES,
      filename: nil)
      @configuration = configuration
      @relative_url = relative_url
      @filename = filename
      @tmpdir = tmpdir
      @file_size_limit = file_size_limit
      @allowed_content_types = allowed_content_types
      @remote_content_validated = false
    end

    def execute
      validate_tmpdir
      validate_filepath
      validate_url

      download_file

      validate_symlink

      filepath
    end

    private

    attr_reader :configuration, :relative_url, :tmpdir, :file_size_limit, :allowed_content_types,
      :response_headers, :last_chunk_context, :response_code

    def download_file
      File.open(filepath, 'wb') do |file|
        bytes_downloaded = 0

        http_client.stream(relative_url) do |chunk|
          next if bytes_downloaded == 0 && [301, 302, 303, 307, 308].include?(chunk.code)

          @response_code = chunk.code
          @response_headers ||= Gitlab::HTTP::Response::Headers.new(chunk.http_response.to_hash)
          @last_chunk_context = chunk.to_s.truncate(LAST_CHUNK_CONTEXT_CHAR_LIMIT)

          unless @remote_content_validated
            validate_content_type
            validate_content_length

            @remote_content_validated = true
          end

          bytes_downloaded += chunk.size

          validate_size!(bytes_downloaded)

          raise(ServiceError, ""File download error #{chunk.code}"") unless chunk.code == 200

          file.write(chunk)
        end
      end
    rescue StandardError => e
      FileUtils.rm_f(filepath)

      raise e
    end

    def raise_error(message)
      logger.warn(
        message: message,
        response_code: response_code,
        response_headers: response_headers,
        importer: 'gitlab_migration',
        last_chunk_context: last_chunk_context
      )

      raise ServiceError, message
    end

    def http_client
      @http_client ||= BulkImports::Clients::HTTP.new(
        url: configuration.url,
        token: configuration.access_token
      )
    end

    def allow_local_requests?
      ::Gitlab::CurrentSettings.allow_local_requests_from_web_hooks_and_services?
    end

    def validate_tmpdir
      Gitlab::PathTraversal.check_allowed_absolute_path!(tmpdir, [Dir.tmpdir])
    end

    def filepath
      @filepath ||= File.join(@tmpdir, filename)
    end

    def filename
      @filename.presence || remote_filename
    end

    def logger
      @logger ||= Logger.build
    end

    def validate_url
      ::Gitlab::UrlBlocker.validate!(
        http_client.resource_url(relative_url),
        allow_localhost: allow_local_requests?,
        allow_local_network: allow_local_requests?,
        schemes: %w[http https]
      )
    end

    def default_file_size_limit
      Gitlab::CurrentSettings.current_application_settings.bulk_import_max_download_file_size.megabytes
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe BulkImports::FileDownloadService, feature_category: :importers do
  describe '#execute' do
    let_it_be(:allowed_content_types) { %w[application/gzip application/octet-stream] }
    let_it_be(:file_size_limit) { 5.gigabytes }
    let_it_be(:config) { build(:bulk_import_configuration) }
    let_it_be(:content_type) { 'application/octet-stream' }
    let_it_be(:content_disposition) { nil }
    let_it_be(:filename) { 'file_download_service_spec' }
    let_it_be(:tmpdir) { Dir.mktmpdir }
    let_it_be(:filepath) { File.join(tmpdir, filename) }
    let_it_be(:content_length) { 1000 }

    let(:headers) do
      {
        'content-length' => content_length,
        'content-type' => content_type,
        'content-disposition' => content_disposition
      }
    end

    let(:chunk_code) { 200 }
    let(:chunk_double) do
      double('chunk', size: 100, code: chunk_code, http_response: double(to_hash: headers), to_s: 'some chunk context')
    end

    subject(:service) do
      described_class.new(
        configuration: config,
        relative_url: '/test',
        tmpdir: tmpdir,
        filename: filename,
        file_size_limit: file_size_limit,
        allowed_content_types: allowed_content_types
      )
    end

    before do
      allow_next_instance_of(BulkImports::Clients::HTTP) do |client|
        allow(client).to receive(:stream).and_yield(chunk_double)
      end

      allow(service).to receive(:response_headers).and_return(headers)
    end

    shared_examples 'downloads file' do
      it 'downloads file' do
        subject.execute

        expect(File.exist?(filepath)).to eq(true)
        expect(File.read(filepath)).to include('chunk')
      end
    end

    include_examples 'downloads file'

    context 'when content-type is application/gzip' do
      let_it_be(:content_type) { 'application/gzip' }

      include_examples 'downloads file'
    end

    context 'when url is not valid' do
      it 'raises an error' do
        stub_application_setting(allow_local_requests_from_web_hooks_and_services: false)

        double = instance_double(BulkImports::Configuration, url: 'https://localhost', access_token: 'token')
        service = described_class.new(
          configuration: double,
          relative_url: '/test',
          tmpdir: tmpdir,
          filename: filename,
          file_size_limit: file_size_limit,
          allowed_content_types: allowed_content_types
        )

        expect { service.execute }.to raise_error(Gitlab::HTTP_V2::UrlBlocker::BlockedUrlError)
      end
    end

    context 'when content-type is not valid' do
      let(:content_type) { 'invalid' }
      let(:import_logger) { instance_double(BulkImports::Logger) }

      before do
        allow(BulkImports::Logger).to receive(:build).and_return(import_logger)
        allow(import_logger).to receive(:warn)
      end

      it 'logs and raises an error' do
        expect(import_logger).to receive(:warn).once.with(
          message: 'Invalid content type',
          response_code: chunk_code,
          response_headers: headers,
          importer: 'gitlab_migration',
          last_chunk_context: 'some chunk context'
        )

        expect { subject.execute }.to raise_error(described_class::ServiceError, 'Invalid content type')
      end
    end

    context 'when content-length is not valid' do
      context 'when content-length exceeds limit' do
        let(:file_size_limit) { 1 }

        it 'raises an error' do
          expect { subject.execute }.to raise_error(
            described_class::ServiceError,
            'File size 1000 B exceeds limit of 1 B'
          )
        end
      end

      context 'when content-length is missing' do
        let(:content_length) { nil }

        it 'raises an error' do
          expect { subject.execute }.to raise_error(
            described_class::ServiceError,
            'Missing content-length header'
          )
        end
      end
    end

    context 'when content-length is equals the file size limit' do
      let(:content_length) { 150 }
      let(:file_size_limit) { 150 }

      it 'does not raise an error' do
        expect { subject.execute }.not_to raise_error
      end
    end

    context 'when partially downloaded file exceeds limit' do
      let(:content_length) { 151 }
      let(:file_size_limit) { 150 }

      it 'raises an error' do
        expect { subject.execute }.to raise_error(
          described_class::ServiceError,
          'File size 151 B exceeds limit of 150 B'
        )
      end
    end

    context 'when chunk code is not 200' do
      let(:chunk_code) { 500 }

      it 'raises an error' do
        expect { subject.execute }.to raise_error(
          described_class::ServiceError,
          'File download error 500'
        )
      end

      context 'when chunk code is redirection' do
        let(:chunk_code) { 303 }

        it 'does not write a redirection chunk' do
          expect { subject.execute }.not_to raise_error

          expect(File.read(filepath)).not_to include('redirection')
        end

        context 'when redirection chunk appears at a later stage of the download' do
          it 'raises an error' do
            another_chunk_double = double('another redirection', size: 1000, code: 303)
            data_chunk = double('data chunk', size: 1000, code: 200, http_response: double(to_hash: {}))

            allow_next_instance_of(BulkImports::Clients::HTTP) do |client|
              allow(client)
                .to receive(:stream)
                .and_yield(chunk_double)
                .and_yield(data_chunk)
                .and_yield(another_chunk_double)
            end

            expect { subject.execute }.to raise_error(
              described_class::ServiceError,
              'File download error 303'
            )
          end
        end
      end
    end

    describe 'remote content validation' do
      context 'on redirect chunk' do
        let(:chunk_code) { 303 }

        it 'does not run content type & length validations' do
          expect(service).not_to receive(:validate_content_type)
          expect(service).not_to receive(:validate_content_length)

          service.execute
        end
      end

      context 'when there is one data chunk' do
        it 'validates content type & length' do
          expect(service).to receive(:validate_content_type)
          expect(service).to receive(:validate_content_length)

          service.execute
        end
      end

      context 'when there are multiple data chunks' do
        it 'validates content type & length only once' do
          data_chunk = double(
            'data chunk',
            size: 1000,
            code: 200,
            http_response: double(to_hash: {})
          )

          allow_next_instance_of(BulkImports::Clients::HTTP) do |client|
            allow(client)
              .to receive(:stream)
              .and_yield(chunk_double)
              .and_yield(data_chunk)
          end

          expect(service).to receive(:validate_content_type).once
          expect(service).to receive(:validate_content_length).once

          service.execute
        end
      end
    end

    context 'when file is a symlink' do
      let_it_be(:symlink) { File.join(tmpdir, 'symlink') }

      before do
        FileUtils.ln_s(File.join(tmpdir, filename), symlink, force: true)
      end

      subject do
        described_class.new(
          configuration: config,
          relative_url: '/test',
          tmpdir: tmpdir,
          filename: 'symlink',
          file_size_limit: file_size_limit,
          allowed_content_types: allowed_content_types
        )
      end

      it 'raises an error and removes the file' do
        expect { subject.execute }.to raise_error(
          described_class::ServiceError,
          'Invalid downloaded file'
        )

        expect(File.exist?(symlink)).to eq(false)
      end
    end

    context 'when file shares multiple hard links' do
      let_it_be(:hard_link) { File.join(tmpdir, 'hard_link') }

      before do
        existing_file = File.join(Dir.mktmpdir, filename)
        FileUtils.touch(existing_file)
        FileUtils.link(existing_file, hard_link)
      end

      subject do
        described_class.new(
          configuration: config,
          relative_url: '/test',
          tmpdir: tmpdir,
          filename: 'hard_link',
          file_size_limit: file_size_limit,
          allowed_content_types: allowed_content_types
        )
      end

      it 'raises an error and removes the file' do
        expect { subject.execute }.to raise_error(
          described_class::ServiceError,
          'Invalid downloaded file'
        )

        expect(File.exist?(hard_link)).to eq(false)
      end
    end

    context 'when dir is not in tmpdir' do
      subject do
        described_class.new(
          configuration: config,
          relative_url: '/test',
          tmpdir: '/etc',
          filename: filename,
          file_size_limit: file_size_limit,
          allowed_content_types: allowed_content_types
        )
      end

      it 'raises an error' do
        expect { subject.execute }.to raise_error(
          StandardError,
          'path /etc is not allowed'
        )
      end
    end

    context 'when dir path is being traversed' do
      subject do
        described_class.new(
          configuration: config,
          relative_url: '/test',
          tmpdir: File.join(Dir.mktmpdir('bulk_imports'), 'test', '..'),
          filename: filename,
          file_size_limit: file_size_limit,
          allowed_content_types: allowed_content_types
        )
      end

      it 'raises an error' do
        expect { subject.execute }.to raise_error(
          Gitlab::PathTraversal::PathTraversalAttackError,
          'Invalid path'
        )
      end
    end

    context 'when using the remote filename' do
      let_it_be(:filename) { nil }

      context 'when no filename is given' do
        it 'raises an error when the filename is not provided in the request header' do
          expect { subject.execute }.to raise_error(
            described_class::ServiceError,
            'Remote filename not provided in content-disposition header'
          )
        end
      end

      context 'with a given filename' do
        let_it_be(:content_disposition) { 'filename=""avatar.png""' }

        it 'uses the given filename' do
          expect(subject.execute).to eq(File.join(tmpdir, ""avatar.png""))
        end
      end

      context 'when the filename is a path' do
        let_it_be(:content_disposition) { 'filename=""../../avatar.png""' }

        it 'raises an error when the filename is not provided in the request header' do
          expect(subject.execute).to eq(File.join(tmpdir, ""avatar.png""))
        end
      end

      context 'when the filename is longer the the limit' do
        let_it_be(:content_disposition) { 'filename=""../../xxx.b""' }

        before do
          stub_const('BulkImports::FileDownloads::FilenameFetch::FILENAME_SIZE_LIMIT', 1)
        end

        it 'raises an error when the filename is not provided in the request header' do
          expect(subject.execute).to eq(File.join(tmpdir, ""x.b""))
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module BulkImports
  class BatchedRelationExportService
    include Gitlab::Utils::StrongMemoize

    BATCH_SIZE = 1000
    BATCH_CACHE_KEY = 'bulk_imports/batched_relation_export/%{export_id}/%{batch_id}'
    CACHE_DURATION = 4.hours

    def self.cache_key(export_id, batch_id)
      Kernel.format(BATCH_CACHE_KEY, export_id: export_id, batch_id: batch_id)
    end

    def initialize(user, portable, relation, jid)
      @user = user
      @portable = portable
      @relation = relation
      @resolved_relation = portable.public_send(relation) # rubocop:disable GitlabSecurity/PublicSend
      @jid = jid
    end

    def execute
      return finish_export! if batches_count == 0

      start_export!
      export.batches.destroy_all # rubocop: disable Cop/DestroyAll
      enqueue_batch_exports

      FinishBatchedRelationExportWorker.perform_async(export.id)
    end

    private

    attr_reader :user, :portable, :relation, :jid, :config, :resolved_relation

    def export
      @export ||= portable.bulk_import_exports.find_or_create_by!(relation: relation) # rubocop:disable CodeReuse/ActiveRecord
    end

    def objects_count
      resolved_relation.count
    end

    def batches_count
      objects_count.fdiv(BATCH_SIZE).ceil
    end

    def start_export!
      update_export!('start')
    end

    def finish_export!
      update_export!('finish')
    end

    def update_export!(event)
      export.update!(
        status_event: event,
        total_objects_count: objects_count,
        batched: true,
        batches_count: batches_count,
        jid: jid,
        error: nil
      )
    end

    def enqueue_batch_exports
      resolved_relation.each_batch(of: BATCH_SIZE) do |batch, batch_number|
        batch_id = find_or_create_batch(batch_number).id
        ids = batch.pluck(batch.model.primary_key) # rubocop:disable CodeReuse/ActiveRecord

        Gitlab::Cache::Import::Caching.set_add(self.class.cache_key(export.id, batch_id), ids, timeout: CACHE_DURATION)

        RelationBatchExportWorker.perform_async(user.id, batch_id)
      end
    end

    def find_or_create_batch(batch_number)
      export.batches.find_or_create_by!(batch_number: batch_number) # rubocop:disable CodeReuse/ActiveRecord
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe BulkImports::BatchedRelationExportService, feature_category: :importers do
  let_it_be(:user) { create(:user) }
  let_it_be(:portable) { create(:group) }

  let(:relation) { 'labels' }
  let(:jid) { '123' }

  subject(:service) { described_class.new(user, portable, relation, jid) }

  describe '#execute' do
    context 'when there are batches to export' do
      let_it_be(:label) { create(:group_label, group: portable) }

      it 'marks export as started' do
        service.execute

        export = portable.bulk_import_exports.first

        expect(export.reload.started?).to eq(true)
      end

      it 'removes existing batches' do
        expect_next_instance_of(BulkImports::Export) do |export|
          expect(export.batches).to receive(:destroy_all)
        end

        service.execute
      end

      it 'enqueues export jobs for each batch & caches batch record ids' do
        expect(BulkImports::RelationBatchExportWorker).to receive(:perform_async)
        expect(Gitlab::Cache::Import::Caching).to receive(:set_add)

        service.execute
      end

      it 'enqueues FinishBatchedRelationExportWorker' do
        expect(BulkImports::FinishBatchedRelationExportWorker).to receive(:perform_async)

        service.execute
      end

      context 'when there are multiple batches' do
        it 'creates a batch record for each batch of records' do
          stub_const(""#{described_class.name}::BATCH_SIZE"", 1)

          create_list(:group_label, 10, group: portable)

          service.execute

          export = portable.bulk_import_exports.first

          expect(export.batches.count).to eq(11)
        end
      end

      context 'when an error occurs during batches creation' do
        it 'does not enqueue FinishBatchedRelationExportWorker' do
          allow(service).to receive(:enqueue_batch_exports).and_raise(StandardError)

          expect(BulkImports::FinishBatchedRelationExportWorker).not_to receive(:perform_async)

          expect { service.execute }.to raise_error(StandardError)
        end
      end
    end

    context 'when there are no batches to export' do
      let(:relation) { 'milestones' }

      it 'marks export as finished' do
        service.execute

        export = portable.bulk_import_exports.first

        expect(export.finished?).to eq(true)
        expect(export.batches.count).to eq(0)
      end
    end
  end

  describe '.cache_key' do
    it 'returns cache key given export and batch ids' do
      expect(described_class.cache_key(1, 1)).to eq('bulk_imports/batched_relation_export/1/1')
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module BulkImports
  class RepositoryBundleExportService
    def initialize(repository, export_path, export_filename)
      @repository = repository
      @export_path = export_path
      @export_filename = export_filename
    end

    def execute(_options = {})
      return unless repository_exists?

      repository.bundle_to_disk(bundle_filepath)
    end

    private

    attr_reader :repository, :export_path, :export_filename

    def repository_exists?
      repository.exists? && !repository.empty?
    end

    def bundle_filepath
      File.join(export_path, ""#{export_filename}.bundle"")
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe BulkImports::RepositoryBundleExportService, feature_category: :importers do
  let(:project) { create(:project) }
  let(:export_path) { Dir.mktmpdir }

  subject(:service) { described_class.new(repository, export_path, export_filename) }

  after do
    FileUtils.remove_entry(export_path) if Dir.exist?(export_path)
  end

  describe '#execute' do
    shared_examples 'repository export' do
      context 'when repository exists' do
        it 'bundles repository to disk' do
          allow(repository).to receive(:exists?).and_return(true)
          allow(repository).to receive(:empty?).and_return(false)
          expect(repository).to receive(:bundle_to_disk).with(File.join(export_path, ""#{export_filename}.bundle""))

          service.execute
        end
      end

      context 'when repository does not exist' do
        it 'does not bundle repository to disk' do
          allow(repository).to receive(:exists?).and_return(false)
          expect(repository).not_to receive(:bundle_to_disk)

          service.execute
        end
      end

      context 'when repository is empty' do
        it 'does not bundle repository to disk' do
          allow(repository).to receive(:empty?).and_return(true)
          expect(repository).not_to receive(:bundle_to_disk)

          service.execute
        end
      end
    end

    include_examples 'repository export' do
      let(:repository) { project.repository }
      let(:export_filename) { 'repository' }
    end

    include_examples 'repository export' do
      let(:repository) { project.design_repository }
      let(:export_filename) { 'design' }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module BulkImports
  class ExportService
    # @param portable [Project|Group] A project or a group to export.
    # @param user [User] A user performing the export.
    # @param batched [Boolean] Whether to export the data in batches.
    def initialize(portable:, user:, batched: false)
      @portable = portable
      @current_user = user
      @batched = batched
    end

    def execute
      validate_user_permissions!

      FileTransfer.config_for(portable).portable_relations.each do |relation|
        RelationExportWorker.perform_async(current_user.id, portable.id, portable.class.name, relation, batched)
      end

      ServiceResponse.success
    rescue StandardError => e
      ServiceResponse.error(
        message: e.class,
        http_status: :unprocessable_entity
      )
    end

    private

    attr_reader :portable, :current_user, :batched

    def validate_user_permissions!
      ability = ""admin_#{portable.to_ability_name}""

      current_user.can?(ability, portable) ||
        raise(::Gitlab::ImportExport::Error.permission_error(current_user, portable))
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe BulkImports::ExportService, feature_category: :importers do
  let_it_be(:group) { create(:group) }
  let_it_be(:user) { create(:user) }

  before do
    group.add_owner(user)
  end

  subject { described_class.new(portable: group, user: user) }

  describe '#execute' do
    let_it_be(:top_level_relations) { BulkImports::FileTransfer.config_for(group).portable_relations }

    before do
      allow(subject).to receive(:execute).and_return(ServiceResponse.success).and_call_original
    end

    context 'when export is not batched' do
      it 'schedules RelationExportWorker for each top level relation' do
        top_level_relations.each do |relation|
          expect(BulkImports::RelationExportWorker)
            .to receive(:perform_async)
            .with(user.id, group.id, group.class.name, relation, false)
        end

        subject.execute
      end
    end

    context 'when export is batched' do
      subject { described_class.new(portable: group, user: user, batched: true) }

      it 'schedules RelationExportWorker with a `batched: true` flag' do
        top_level_relations.each do |relation|
          expect(BulkImports::RelationExportWorker)
            .to receive(:perform_async)
            .with(user.id, group.id, group.class.name, relation, true)
        end

        subject.execute
      end
    end

    context 'when exception occurs' do
      it 'does not schedule RelationExportWorker' do
        service = described_class.new(portable: nil, user: user)

        expect(service)
          .to receive(:execute)
          .and_return(ServiceResponse.error(message: 'Gitlab::ImportExport::Error', http_status: :unprocessible_entity))
          .and_call_original
        expect(BulkImports::RelationExportWorker).not_to receive(:perform_async)

        service.execute
      end

      context 'when user is not allowed to perform export' do
        let(:another_user) { create(:user) }

        it 'does not schedule RelationExportWorker' do
          another_user = create(:user)
          service = described_class.new(portable: group, user: another_user)
          response = service.execute

          expect(response.status).to eq(:error)
          expect(response.message).to eq(Gitlab::ImportExport::Error)
          expect(response.http_status).to eq(:unprocessable_entity)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module BulkImports
  class ProcessService
    PERFORM_DELAY = 5.seconds
    DEFAULT_BATCH_SIZE = 5

    attr_reader :bulk_import

    def initialize(bulk_import)
      @bulk_import = bulk_import
    end

    def execute
      return unless bulk_import
      return if bulk_import.completed?
      return bulk_import.fail_op! if all_entities_failed?
      return bulk_import.finish! if all_entities_processed? && bulk_import.started?
      return re_enqueue if max_batch_size_exceeded? # Do not start more jobs if max allowed are already running

      process_bulk_import
      re_enqueue
    end

    private

    def process_bulk_import
      bulk_import.start! if bulk_import.created?

      created_entities.first(next_batch_size).each do |entity|
        create_tracker(entity)

        entity.start!

        Gitlab::ApplicationContext.with_context(bulk_import_entity_id: entity.id) do
          BulkImports::ExportRequestWorker.perform_async(entity.id)
        end
      end
    end

    def entities
      @entities ||= bulk_import.entities
    end

    def created_entities
      entities.with_status(:created)
    end

    def all_entities_processed?
      entities.all? { |entity| entity.finished? || entity.failed? }
    end

    def all_entities_failed?
      entities.all?(&:failed?)
    end

    # A new BulkImportWorker job is enqueued to either
    #   - Process the new BulkImports::Entity created during import (e.g. for the subgroups)
    #   - Or to mark the `bulk_import` as finished
    def re_enqueue
      BulkImportWorker.perform_in(PERFORM_DELAY, bulk_import.id)
    end

    def started_entities
      entities.with_status(:started)
    end

    def max_batch_size_exceeded?
      started_entities.count >= DEFAULT_BATCH_SIZE
    end

    def next_batch_size
      [DEFAULT_BATCH_SIZE - started_entities.count, 0].max
    end

    def create_tracker(entity)
      entity.class.transaction do
        entity.pipelines.each do |pipeline|
          status = skip_pipeline?(pipeline, entity) ? :skipped : :created

          entity.trackers.create!(
            stage: pipeline[:stage],
            pipeline_name: pipeline[:pipeline],
            status: BulkImports::Tracker.state_machine.states[status].value
          )
        end
      end
    end

    def skip_pipeline?(pipeline, entity)
      return false unless entity.source_version.valid?

      minimum_version, maximum_version = pipeline.values_at(:minimum_source_version, :maximum_source_version)

      if source_version_out_of_range?(minimum_version, maximum_version, entity.source_version.without_patch)
        log_skipped_pipeline(pipeline, entity, minimum_version, maximum_version)
        return true
      end

      false
    end

    def source_version_out_of_range?(minimum_version, maximum_version, non_patch_source_version)
      (minimum_version && non_patch_source_version < Gitlab::VersionInfo.parse(minimum_version)) ||
        (maximum_version && non_patch_source_version > Gitlab::VersionInfo.parse(maximum_version))
    end

    def log_skipped_pipeline(pipeline, entity, minimum_version, maximum_version)
      logger.info(
        message: 'Pipeline skipped as source instance version not compatible with pipeline',
        bulk_import_entity_id: entity.id,
        bulk_import_id: entity.bulk_import_id,
        bulk_import_entity_type: entity.source_type,
        source_full_path: entity.source_full_path,
        pipeline_class: pipeline[:pipeline],
        minimum_source_version: minimum_version,
        maximum_source_version: maximum_version,
        source_version: entity.source_version.to_s
      )
    end

    def logger
      @logger ||= Logger.build
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe BulkImports::ProcessService, feature_category: :importers do
  describe '#execute' do
    let_it_be_with_reload(:bulk_import) { create(:bulk_import) }

    subject { described_class.new(bulk_import) }

    context 'when no bulk import is found' do
      let(:bulk_import) { nil }

      it 'does nothing' do
        expect(described_class).not_to receive(:process_bulk_import)
        subject.execute
      end
    end

    context 'when bulk import is finished' do
      it 'does nothing' do
        bulk_import.update!(status: 2)

        expect(described_class).not_to receive(:process_bulk_import)
        subject.execute
      end
    end

    context 'when bulk import is failed' do
      it 'does nothing' do
        bulk_import.update!(status: -1)

        expect(described_class).not_to receive(:process_bulk_import)
        subject.execute
      end
    end

    context 'when bulk import has timed out' do
      it 'does nothing' do
        bulk_import.update!(status: 3)

        expect(described_class).not_to receive(:process_bulk_import)
        subject.execute
      end
    end

    context 'when all entities are processed' do
      it 'marks bulk import as finished' do
        bulk_import.update!(status: 1)
        create(:bulk_import_entity, :finished, bulk_import: bulk_import)
        create(:bulk_import_entity, :failed, bulk_import: bulk_import)

        subject.execute

        expect(bulk_import.reload.finished?).to eq(true)
      end
    end

    context 'when all entities are failed' do
      it 'marks bulk import as failed' do
        bulk_import.update!(status: 1)
        create(:bulk_import_entity, :failed, bulk_import: bulk_import)
        create(:bulk_import_entity, :failed, bulk_import: bulk_import)

        subject.execute

        expect(bulk_import.reload.failed?).to eq(true)
      end
    end

    context 'when maximum allowed number of import entities in progress' do
      it 're-enqueues itself' do
        bulk_import.update!(status: 1)
        create(:bulk_import_entity, :created, bulk_import: bulk_import)
        (described_class::DEFAULT_BATCH_SIZE + 1).times do
          create(:bulk_import_entity, :started, bulk_import: bulk_import)
        end

        expect(BulkImportWorker).to receive(:perform_in).with(described_class::PERFORM_DELAY, bulk_import.id)
        expect(BulkImports::ExportRequestWorker).not_to receive(:perform_async)

        subject.execute
      end
    end

    context 'when bulk import is created' do
      it 'marks bulk import as started' do
        create(:bulk_import_entity, :created, bulk_import: bulk_import)

        subject.execute

        expect(bulk_import.reload.started?).to eq(true)
      end

      it 'creates all the required pipeline trackers' do
        entity_1 = create(:bulk_import_entity, :created, bulk_import: bulk_import)
        entity_2 = create(:bulk_import_entity, :created, bulk_import: bulk_import)

        expect { subject.execute }
          .to change { BulkImports::Tracker.count }
                .by(BulkImports::Groups::Stage.new(entity_1).pipelines.size * 2)

        expect(entity_1.trackers).not_to be_empty
        expect(entity_2.trackers).not_to be_empty
      end

      context 'when there are created entities to process' do
        before do
          stub_const(""#{described_class}::DEFAULT_BATCH_SIZE"", 1)
        end

        it 'marks a batch of entities as started, enqueues EntityWorker, ExportRequestWorker and reenqueues' do
          create(:bulk_import_entity, :created, bulk_import: bulk_import)
          create(:bulk_import_entity, :created, bulk_import: bulk_import)

          expect(BulkImportWorker).to receive(:perform_in).with(described_class::PERFORM_DELAY, bulk_import.id)
          expect(BulkImports::ExportRequestWorker).to receive(:perform_async).once

          subject.execute

          bulk_import.reload

          expect(bulk_import.entities.map(&:status_name)).to contain_exactly(:created, :started)
        end

        context 'when there are project entities to process' do
          it 'enqueues ExportRequestWorker' do
            create(:bulk_import_entity, :created, :project_entity, bulk_import: bulk_import)

            expect(BulkImports::ExportRequestWorker).to receive(:perform_async).once

            subject.execute
          end
        end
      end
    end

    context 'when importing a group' do
      it 'creates trackers for group entity' do
        entity = create(:bulk_import_entity, :group_entity, bulk_import: bulk_import)

        subject.execute

        expect(entity.trackers.to_a).to include(
          have_attributes(
            stage: 0, status_name: :created, relation: BulkImports::Groups::Pipelines::GroupPipeline.to_s
          ),
          have_attributes(
            stage: 1, status_name: :created, relation: BulkImports::Groups::Pipelines::GroupAttributesPipeline.to_s
          )
        )
      end
    end

    context 'when importing a project' do
      it 'creates trackers for project entity' do
        entity = create(:bulk_import_entity, :project_entity, bulk_import: bulk_import)

        subject.execute

        expect(entity.trackers.to_a).to include(
          have_attributes(
            stage: 0, status_name: :created, relation: BulkImports::Projects::Pipelines::ProjectPipeline.to_s
          ),
          have_attributes(
            stage: 1, status_name: :created, relation: BulkImports::Projects::Pipelines::RepositoryPipeline.to_s
          )
        )
      end
    end

    context 'when tracker configuration has a minimum version defined' do
      before do
        allow_next_instance_of(BulkImports::Groups::Stage) do |stage|
          allow(stage).to receive(:config).and_return(
            {
              pipeline1: { pipeline: 'PipelineClass1', stage: 0 },
              pipeline2: { pipeline: 'PipelineClass2', stage: 1, minimum_source_version: '14.10.0' },
              pipeline3: { pipeline: 'PipelineClass3', stage: 1, minimum_source_version: '15.0.0' },
              pipeline5: { pipeline: 'PipelineClass4', stage: 1, minimum_source_version: '15.1.0' },
              pipeline6: { pipeline: 'PipelineClass5', stage: 1, minimum_source_version: '16.0.0' }
            }
          )
        end
      end

      context 'when the source instance version is older than the tracker mininum version' do
        let_it_be(:entity) { create(:bulk_import_entity, :group_entity, bulk_import: bulk_import) }

        before do
          bulk_import.update!(source_version: '15.0.0')
        end

        it 'creates trackers as skipped if version requirement does not meet' do
          subject.execute

          expect(entity.trackers.collect { |tracker| [tracker.status_name, tracker.relation] }).to contain_exactly(
            [:created, 'PipelineClass1'],
            [:created, 'PipelineClass2'],
            [:created, 'PipelineClass3'],
            [:skipped, 'PipelineClass4'],
            [:skipped, 'PipelineClass5']
          )
        end

        it 'logs an info message for the skipped pipelines' do
          expect_next_instance_of(BulkImports::Logger) do |logger|
            expect(logger).to receive(:info).with(
              message: 'Pipeline skipped as source instance version not compatible with pipeline',
              bulk_import_entity_id: entity.id,
              bulk_import_id: entity.bulk_import_id,
              bulk_import_entity_type: entity.source_type,
              source_full_path: entity.source_full_path,
              pipeline_class: 'PipelineClass4',
              minimum_source_version: '15.1.0',
              maximum_source_version: nil,
              source_version: '15.0.0'
            )

            expect(logger).to receive(:info).with(
              message: 'Pipeline skipped as source instance version not compatible with pipeline',
              bulk_import_entity_id: entity.id,
              bulk_import_id: entity.bulk_import_id,
              bulk_import_entity_type: entity.source_type,
              source_full_path: entity.source_full_path,
              pipeline_class: 'PipelineClass5',
              minimum_source_version: '16.0.0',
              maximum_source_version: nil,
              source_version: '15.0.0'
            )
          end

          subject.execute
        end
      end

      context 'when the source instance version is undefined' do
        it 'creates trackers as created' do
          bulk_import.update!(source_version: nil)
          entity = create(:bulk_import_entity, :group_entity, bulk_import: bulk_import)

          subject.execute

          expect(entity.trackers.collect { |tracker| [tracker.status_name, tracker.relation] }).to contain_exactly(
            [:created, 'PipelineClass1'],
            [:created, 'PipelineClass2'],
            [:created, 'PipelineClass3'],
            [:created, 'PipelineClass4'],
            [:created, 'PipelineClass5']
          )
        end
      end
    end

    context 'when tracker configuration has a maximum version defined' do
      before do
        allow_next_instance_of(BulkImports::Groups::Stage) do |stage|
          allow(stage).to receive(:config).and_return(
            {
              pipeline1: { pipeline: 'PipelineClass1', stage: 0 },
              pipeline2: { pipeline: 'PipelineClass2', stage: 1, maximum_source_version: '14.10.0' },
              pipeline3: { pipeline: 'PipelineClass3', stage: 1, maximum_source_version: '15.0.0' },
              pipeline5: { pipeline: 'PipelineClass4', stage: 1, maximum_source_version: '15.1.0' },
              pipeline6: { pipeline: 'PipelineClass5', stage: 1, maximum_source_version: '16.0.0' }
            }
          )
        end
      end

      context 'when the source instance version is older than the tracker maximum version' do
        it 'creates trackers as skipped if version requirement does not meet' do
          bulk_import.update!(source_version: '15.0.0')
          entity = create(:bulk_import_entity, :group_entity, bulk_import: bulk_import)

          subject.execute

          expect(entity.trackers.collect { |tracker| [tracker.status_name, tracker.relation] }).to contain_exactly(
            [:created, 'PipelineClass1'],
            [:skipped, 'PipelineClass2'],
            [:created, 'PipelineClass3'],
            [:created, 'PipelineClass4'],
            [:created, 'PipelineClass5']
          )
        end
      end

      context 'when the source instance version is a patch version' do
        it 'creates trackers with the same status as the non-patch source version' do
          bulk_import_1 = create(:bulk_import, source_version: '15.0.1')
          entity_1 = create(:bulk_import_entity, :group_entity, bulk_import: bulk_import_1)

          bulk_import_2 = create(:bulk_import, source_version: '15.0.0')
          entity_2 = create(:bulk_import_entity, :group_entity, bulk_import: bulk_import_2)

          described_class.new(bulk_import_1).execute
          described_class.new(bulk_import_2).execute

          trackers_1 = entity_1.trackers.collect { |tracker| [tracker.status_name, tracker.relation] }
          trackers_2 = entity_2.trackers.collect { |tracker| [tracker.status_name, tracker.relation] }

          expect(trackers_1).to eq(trackers_2)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module BulkImports
  class RelationBatchExportService
    include Gitlab::ImportExport::CommandLineUtil

    def initialize(user, batch)
      @user = user
      @batch = batch
      @config = FileTransfer.config_for(portable)
    end

    def execute
      start_batch!

      export_service.export_batch(relation_batch_ids)
      ensure_export_file_exists!
      compress_exported_relation
      upload_compressed_file

      finish_batch!
    ensure
      FileUtils.remove_entry(export_path)
    end

    private

    attr_reader :user, :batch, :config

    delegate :export_path, to: :config
    delegate :batch_number, :export, to: :batch
    delegate :portable, :relation, to: :export
    delegate :exported_filename, :exported_objects_count, to: :export_service

    def export_service
      @export_service ||= config.export_service_for(relation).new(portable, export_path, relation, user)
    end

    def compress_exported_relation
      gzip(dir: export_path, filename: exported_filename)
    end

    def upload_compressed_file
      File.open(compressed_filename) { |file| batch_upload.export_file = file }

      batch_upload.save!
    end

    def batch_upload
      @batch_upload ||= ::BulkImports::ExportUpload.find_or_initialize_by(export_id: export.id, batch_id: batch.id) # rubocop: disable CodeReuse/ActiveRecord
    end

    def compressed_filename
      File.join(export_path, ""#{exported_filename}.gz"")
    end

    def relation_batch_ids
      Gitlab::Cache::Import::Caching.values_from_set(cache_key).map(&:to_i)
    end

    def cache_key
      BulkImports::BatchedRelationExportService.cache_key(export.id, batch.id)
    end

    def start_batch!
      batch.update!(status_event: 'start', objects_count: 0, error: nil)
    end

    def finish_batch!
      batch.update!(status_event: 'finish', objects_count: exported_objects_count, error: nil)
    end

    def exported_filepath
      File.join(export_path, exported_filename)
    end

    # Create empty file on disk
    # if relation is empty and nothing was exported
    def ensure_export_file_exists!
      FileUtils.touch(exported_filepath)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe BulkImports::RelationBatchExportService, feature_category: :importers do
  let_it_be(:project) { create(:project) }
  let_it_be(:label) { create(:label, project: project) }
  let_it_be(:user) { create(:user) }
  let_it_be(:export) { create(:bulk_import_export, :batched, project: project) }
  let_it_be(:batch) { create(:bulk_import_export_batch, export: export) }
  let_it_be(:cache_key) { BulkImports::BatchedRelationExportService.cache_key(export.id, batch.id) }

  subject(:service) { described_class.new(user, batch) }

  before_all do
    Gitlab::Cache::Import::Caching.set_add(cache_key, label.id)
  end

  after(:all) do
    Gitlab::Cache::Import::Caching.expire(cache_key, 0)
  end

  describe '#execute' do
    it 'exports relation batch' do
      expect(Gitlab::Cache::Import::Caching).to receive(:values_from_set).with(cache_key).and_call_original

      service.execute
      batch.reload

      expect(batch.finished?).to eq(true)
      expect(batch.objects_count).to eq(1)
      expect(batch.error).to be_nil
      expect(export.upload.export_file).to be_present
    end

    it 'removes exported contents after export' do
      allow(subject).to receive(:export_path).and_return('foo')
      allow(FileUtils).to receive(:remove_entry)

      expect(FileUtils).to receive(:remove_entry).with('foo')

      service.execute
    end

    context 'when relation is empty and there is nothing to export' do
      let_it_be(:export) { create(:bulk_import_export, :batched, project: project, relation: 'milestones') }
      let_it_be(:batch) { create(:bulk_import_export_batch, export: export) }

      it 'creates empty file on disk' do
        allow(subject).to receive(:export_path).and_return('foo')
        allow(FileUtils).to receive(:remove_entry)

        expect(FileUtils).to receive(:touch).with('foo/milestones.ndjson').and_call_original

        subject.execute
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Archive Extraction Service allows extraction of contents
# from `tar` archives with an additional handling (removal)
# of file symlinks.
#
# @param tmpdir [String] A path where archive is located
# and where its contents are extracted.
# Tmpdir directory must be located under `Dir.tmpdir`.
# `BulkImports::Error` is raised if any other directory path is used.
#
# @param filename [String] Name of the file to extract contents from.
#
# @example
#   dir = Dir.mktmpdir
#   filename = 'things.tar'
#   BulkImports::ArchiveExtractionService.new(tmpdir: dir, filename: filename).execute
#   Dir.glob(File.join(dir, '**', '*'))
#   => ['/path/to/tmp/dir/extracted_file_1', '/path/to/tmp/dir/extracted_file_2', '/path/to/tmp/dir/extracted_file_3']
module BulkImports
  class ArchiveExtractionService
    include Gitlab::ImportExport::CommandLineUtil

    def initialize(tmpdir:, filename:)
      @tmpdir = tmpdir
      @filename = filename
      @filepath = File.join(@tmpdir, @filename)
    end

    def execute
      validate_tmpdir
      validate_filepath
      validate_symlink

      extract_archive
      tmpdir
    end

    private

    attr_reader :tmpdir, :filename, :filepath

    def validate_filepath
      Gitlab::PathTraversal.check_path_traversal!(filepath)
    end

    def validate_tmpdir
      Gitlab::PathTraversal.check_allowed_absolute_path!(tmpdir, [Dir.tmpdir])
    end

    def validate_symlink
      raise(BulkImports::Error, 'Invalid file') if Gitlab::Utils::FileInfo.linked?(filepath)
    end

    def extract_archive
      untar_xf(archive: filepath, dir: tmpdir)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe BulkImports::ArchiveExtractionService, feature_category: :importers do
  let_it_be(:tmpdir) { Dir.mktmpdir }
  let_it_be(:filename) { 'symlink_export.tar' }
  let_it_be(:filepath) { File.join(tmpdir, filename) }

  before do
    FileUtils.copy_file(File.join('spec', 'fixtures', filename), filepath)
  end

  after(:all) do
    FileUtils.remove_entry(tmpdir)
  end

  subject(:service) { described_class.new(tmpdir: tmpdir, filename: filename) }

  describe '#execute' do
    it 'extracts files from archive and removes symlinks' do
      file = File.join(tmpdir, 'project.json')
      folder = File.join(tmpdir, 'uploads')
      symlink = File.join(tmpdir, 'uploads', 'link.gitignore')

      expect(service).to receive(:untar_xf).with(archive: filepath, dir: tmpdir).and_call_original

      service.execute

      expect(File.exist?(file)).to eq(true)
      expect(Dir.exist?(folder)).to eq(true)
      expect(File.exist?(symlink)).to eq(false)
    end

    context 'when dir is not in tmpdir' do
      it 'raises an error' do
        ['/etc', '/usr', '/', '/home', '/some/other/path', Rails.root.to_s].each do |path|
          expect { described_class.new(tmpdir: path, filename: 'filename').execute }
            .to raise_error(StandardError, ""path #{path} is not allowed"")
        end
      end
    end

    context 'when archive file is a symlink' do
      it 'raises an error' do
        FileUtils.ln_s(filepath, File.join(tmpdir, 'symlink'))

        expect { described_class.new(tmpdir: tmpdir, filename: 'symlink').execute }
          .to raise_error(BulkImports::Error, 'Invalid file')
      end
    end

    context 'when archive file shares multiple hard links' do
      it 'raises an error' do
        FileUtils.link(filepath, File.join(tmpdir, 'hard_link'))

        expect { subject.execute }.to raise_error(BulkImports::Error, 'Invalid file')
      end
    end

    context 'when filepath is being traversed' do
      it 'raises an error' do
        expect { described_class.new(tmpdir: File.join(Dir.mktmpdir, 'test', '..'), filename: 'name').execute }
          .to raise_error(Gitlab::PathTraversal::PathTraversalAttackError, 'Invalid path')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module BulkImports
  class FileExportService
    include Gitlab::ImportExport::CommandLineUtil

    SINGLE_OBJECT_RELATIONS = [
      FileTransfer::ProjectConfig::REPOSITORY_BUNDLE_RELATION,
      FileTransfer::ProjectConfig::DESIGN_BUNDLE_RELATION
    ].freeze

    def initialize(portable, export_path, relation, user)
      @portable = portable
      @export_path = export_path
      @relation = relation
      @user = user # not used anywhere in this class at the moment
    end

    def execute(options = {})
      export_service.execute(options)

      archive_exported_data
    end

    def export_batch(ids)
      execute(batch_ids: ids)
    end

    def exported_filename
      ""#{relation}.tar""
    end

    def exported_objects_count
      case relation
      when *SINGLE_OBJECT_RELATIONS
        1
      else
        export_service.exported_objects_count
      end
    end

    private

    attr_reader :export_path, :portable, :relation

    def export_service
      @export_service ||= case relation
                          when FileTransfer::BaseConfig::UPLOADS_RELATION
                            UploadsExportService.new(portable, export_path)
                          when FileTransfer::ProjectConfig::LFS_OBJECTS_RELATION
                            LfsObjectsExportService.new(portable, export_path)
                          when FileTransfer::ProjectConfig::REPOSITORY_BUNDLE_RELATION
                            RepositoryBundleExportService.new(portable.repository, export_path, relation)
                          when FileTransfer::ProjectConfig::DESIGN_BUNDLE_RELATION
                            RepositoryBundleExportService.new(portable.design_repository, export_path, relation)
                          else
                            raise BulkImports::Error, 'Unsupported relation export type'
                          end
    end

    def archive_exported_data
      archive_file = File.join(export_path, exported_filename)

      tar_cf(archive: archive_file, dir: export_path)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe BulkImports::FileExportService, feature_category: :importers do
  let_it_be(:project) { create(:project) }

  let(:relations) do
    {
      'uploads' => BulkImports::UploadsExportService,
      'lfs_objects' => BulkImports::LfsObjectsExportService,
      'repository' => BulkImports::RepositoryBundleExportService,
      'design' => BulkImports::RepositoryBundleExportService
    }
  end

  describe '#execute' do
    it 'executes export service and archives exported data for each file relation' do
      relations.each do |relation, klass|
        Dir.mktmpdir do |export_path|
          service = described_class.new(project, export_path, relation, nil)

          expect_next_instance_of(klass) do |service|
            expect(service).to receive(:execute)
          end

          expect(service).to receive(:tar_cf).with(archive: File.join(export_path, ""#{relation}.tar""), dir: export_path)

          service.execute
        end
      end
    end

    context 'when unsupported relation is passed' do
      it 'raises an error' do
        service = described_class.new(project, nil, 'unsupported', nil)

        expect { service.execute }.to raise_error(BulkImports::Error, 'Unsupported relation export type')
      end
    end
  end

  describe '#execute_batch' do
    it 'calls execute with provided array of record ids' do
      relations.each do |relation, klass|
        Dir.mktmpdir do |export_path|
          service = described_class.new(project, export_path, relation, nil)

          expect_next_instance_of(klass) do |service|
            expect(service).to receive(:execute).with({ batch_ids: [1, 2, 3] })
          end

          service.export_batch([1, 2, 3])
        end
      end
    end
  end

  describe '#exported_filename' do
    it 'returns filename of the exported file' do
      service = described_class.new(project, nil, 'uploads', nil)

      expect(service.exported_filename).to eq('uploads.tar')
    end
  end

  describe '#exported_objects_count' do
    context 'when relation is a collection' do
      it 'returns a number of exported relations' do
        %w[uploads lfs_objects].each do |relation|
          service = described_class.new(project, nil, relation, nil)

          allow(service).to receive_message_chain(:export_service, :exported_objects_count).and_return(10)

          expect(service.exported_objects_count).to eq(10)
        end
      end
    end

    context 'when relation is a repository' do
      it 'returns 1' do
        %w[repository design].each do |relation|
          service = described_class.new(project, nil, relation, nil)

          expect(service.exported_objects_count).to eq(1)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Entry point of the BulkImport/Direct Transfer feature.
# This service receives a Gitlab Instance connection params
# and a list of groups or projects to be imported.
#
# Process topography:
#
#       sync      |   async
#                 |
#  User +--> P1 +----> Pn +---+
#                 |     ^     | Enqueue new job
#                 |     +-----+
#
# P1 (sync)
#
# - Create a BulkImport record
# - Create a BulkImport::Entity for each group or project (entities) to be imported
# - Enqueue a BulkImportWorker job (P2) to import the given entity
#
# Pn (async)
#
# - For each group to be imported (BulkImport::Entity.with_status(:created))
#   - Import the group data
#   - Create entities for each subgroup of the imported group
#   - Create entities for each project of the imported group
#   - Enqueue a BulkImportWorker job (Pn) to import the new entities

module BulkImports
  class CreateService
    ENTITY_TYPES_MAPPING = {
      'group_entity' => 'groups',
      'project_entity' => 'projects'
    }.freeze

    attr_reader :current_user, :params, :credentials

    def initialize(current_user, params, credentials)
      @current_user = current_user
      @params = params
      @credentials = credentials
    end

    def execute
      validate!

      bulk_import = create_bulk_import

      Gitlab::Tracking.event(
        self.class.name,
        'create',
        label: 'bulk_import_group',
        extra: { source_equals_destination: source_equals_destination? }
      )

      BulkImportWorker.perform_async(bulk_import.id)

      ServiceResponse.success(payload: bulk_import)

    rescue ActiveRecord::RecordInvalid, BulkImports::Error, BulkImports::NetworkError => e
      ServiceResponse.error(
        message: e.message,
        http_status: :unprocessable_entity
      )
    end

    private

    def validate!
      client.validate_instance_version!
      validate_setting_enabled!
      client.validate_import_scopes!
    end

    def create_bulk_import
      BulkImport.transaction do
        bulk_import = BulkImport.create!(
          user: current_user,
          source_type: 'gitlab',
          source_version: client.instance_version,
          source_enterprise: client.instance_enterprise
        )
        bulk_import.create_configuration!(credentials.slice(:url, :access_token))

        Array.wrap(params).each do |entity_params|
          track_access_level(entity_params)

          validate_destination_namespace(entity_params)
          validate_destination_slug(entity_params[:destination_slug] || entity_params[:destination_name])
          validate_destination_full_path(entity_params)

          BulkImports::Entity.create!(
            bulk_import: bulk_import,
            source_type: entity_params[:source_type],
            source_full_path: entity_params[:source_full_path],
            destination_slug: entity_params[:destination_slug] || entity_params[:destination_name],
            destination_namespace: entity_params[:destination_namespace],
            migrate_projects: Gitlab::Utils.to_boolean(entity_params[:migrate_projects], default: true)
          )
        end
        bulk_import
      end
    end

    def validate_setting_enabled!
      source_full_path, source_type = Array.wrap(params)[0].values_at(:source_full_path, :source_type)
      entity_type = ENTITY_TYPES_MAPPING.fetch(source_type)
      if /^[0-9]+$/.match?(source_full_path)
        query = query_type(entity_type)
        response = graphql_client.execute(
          graphql_client.parse(query.to_s),
          { full_path: source_full_path }
        ).original_hash

        source_entity_identifier = ::GlobalID.parse(response.dig(*query.data_path, 'id')).model_id
      else
        source_entity_identifier = ERB::Util.url_encode(source_full_path)
      end

      client.get(""/#{entity_type}/#{source_entity_identifier}/export_relations/status"")
    end

    def track_access_level(entity_params)
      Gitlab::Tracking.event(
        self.class.name,
        'create',
        label: 'import_access_level',
        user: current_user,
        extra: { user_role: user_role(entity_params[:destination_namespace]), import_type: 'bulk_import_group' }
      )
    end

    def source_equals_destination?
      credentials[:url].starts_with?(Settings.gitlab.base_url)
    end

    def validate_destination_namespace(entity_params)
      destination_namespace = entity_params[:destination_namespace]
      source_type = entity_params[:source_type]

      return if destination_namespace.blank?

      group = Group.find_by_full_path(destination_namespace)
      if group.nil? ||
          (source_type == 'group_entity' && !current_user.can?(:create_subgroup, group)) ||
          (source_type == 'project_entity' && !current_user.can?(:import_projects, group))
        raise BulkImports::Error.destination_namespace_validation_failure(destination_namespace)
      end
    end

    def validate_destination_slug(destination_slug)
      return if Gitlab::Regex.oci_repository_path_regex.match?(destination_slug)

      raise BulkImports::Error.destination_slug_validation_failure
    end

    def validate_destination_full_path(entity_params)
      source_type = entity_params[:source_type]

      full_path = [
        entity_params[:destination_namespace],
        entity_params[:destination_slug] || entity_params[:destination_name]
      ].reject(&:blank?).join('/')

      case source_type
      when 'group_entity'
        return if Namespace.find_by_full_path(full_path).nil?
      when 'project_entity'
        return if Project.find_by_full_path(full_path).nil?
      end

      raise BulkImports::Error.destination_full_path_validation_failure(full_path)
    end

    def user_role(destination_namespace)
      namespace = Namespace.find_by_full_path(destination_namespace)
      # if there is no parent namespace we assume user will be group creator/owner
      return owner_role unless destination_namespace
      return owner_role unless namespace
      return owner_role unless namespace.group_namespace? # user namespace

      membership = current_user.group_members.find_by(source_id: namespace.id) # rubocop:disable CodeReuse/ActiveRecord

      return 'Not a member' unless membership

      Gitlab::Access.human_access(membership.access_level)
    end

    def owner_role
      Gitlab::Access.human_access(Gitlab::Access::OWNER)
    end

    def client
      @client ||= BulkImports::Clients::HTTP.new(
        url: @credentials[:url],
        token: @credentials[:access_token]
      )
    end

    def graphql_client
      @graphql_client ||= BulkImports::Clients::Graphql.new(
        url: @credentials[:url],
        token: @credentials[:access_token]
      )
    end

    def query_type(entity_type)
      if entity_type == 'groups'
        BulkImports::Groups::Graphql::GetGroupQuery.new(context: nil)
      else
        BulkImports::Projects::Graphql::GetProjectQuery.new(context: nil)
      end
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe BulkImports::CreateService, feature_category: :importers do
  let(:user) { create(:user) }
  let(:credentials) { { url: 'http://gitlab.example', access_token: 'token' } }
  let(:destination_group) { create(:group, path: 'destination1') }
  let(:migrate_projects) { true }
  let_it_be(:parent_group) { create(:group, path: 'parent-group') }
  # note: destination_name and destination_slug are currently interchangable so we need to test for both possibilities
  let(:params) do
    [
      {
        source_type: 'group_entity',
        source_full_path: 'full/path/to/group1',
        destination_slug: 'destination-group-1',
        destination_namespace: 'parent-group',
        migrate_projects: migrate_projects
      },
      {
        source_type: 'group_entity',
        source_full_path: 'full/path/to/group2',
        destination_name: 'destination-group-2',
        destination_namespace: 'parent-group',
        migrate_projects: migrate_projects
      },
      {
        source_type: 'project_entity',
        source_full_path: 'full/path/to/project1',
        destination_slug: 'destination-project-1',
        destination_namespace: 'parent-group',
        migrate_projects: migrate_projects
      }
    ]
  end

  let(:source_entity_identifier) { ERB::Util.url_encode(params[0][:source_full_path]) }
  let(:source_entity_type) { BulkImports::CreateService::ENTITY_TYPES_MAPPING.fetch(params[0][:source_type]) }

  subject { described_class.new(user, params, credentials) }

  describe '#execute' do
    context 'when gitlab version is 15.5 or higher' do
      let(:source_version) { { version: ""15.6.0"", enterprise: false } }

      context 'when a BulkImports::Error is raised while validating the instance version' do
        before do
          allow_next_instance_of(BulkImports::Clients::HTTP) do |client|
            allow(client)
              .to receive(:validate_instance_version!)
              .and_raise(BulkImports::Error, ""This is a BulkImports error."")
          end
        end

        it 'rescues the error and raises a ServiceResponse::Error' do
          result = subject.execute

          expect(result).to be_a(ServiceResponse)
          expect(result).to be_error
          expect(result.message).to eq(""This is a BulkImports error."")
        end
      end

      # response when authorize_admin_project in API endpoint fails
      context 'when direct transfer status query returns a 403' do
        it 'raises a ServiceResponse::Error' do
          expect_next_instance_of(BulkImports::Clients::HTTP) do |client|
            expect(client).to receive(:validate_instance_version!).and_return(true)
            expect(client).to receive(:get)
              .with(""/groups/full%2Fpath%2Fto%2Fgroup1/export_relations/status"")
              .and_raise(BulkImports::NetworkError, '403 Forbidden')
          end

          result = subject.execute

          expect(result).to be_a(ServiceResponse)
          expect(result).to be_error
          expect(result.message).to eq(""403 Forbidden"")
        end
      end

      context 'when direct transfer setting query returns a 404' do
        it 'raises a ServiceResponse::Error' do
          stub_request(:get, 'http://gitlab.example/api/v4/version?private_token=token').to_return(status: 404)
          stub_request(:get, 'http://gitlab.example/api/v4/metadata?private_token=token')
            .to_return(
              status: 200,
              body: source_version.to_json,
              headers: { 'Content-Type' => 'application/json' }
            )
          stub_request(:get, ""http://gitlab.example/api/v4/#{source_entity_type}/#{source_entity_identifier}/export_relations/status?page=1&per_page=30&private_token=token"")
            .to_return(status: 404)

          expect_next_instance_of(BulkImports::Clients::HTTP) do |client|
            expect(client).to receive(:get).and_raise(BulkImports::Error.setting_not_enabled)
          end

          result = subject.execute

          expect(result).to be_a(ServiceResponse)
          expect(result).to be_error
          expect(result.message)
            .to eq(
              ""Group import disabled on source or destination instance. "" \
              ""Ask an administrator to enable it on both instances and try again.""
            )
        end
      end

      context 'when required scopes are not present' do
        it 'returns ServiceResponse with error if token does not have api scope' do
          stub_request(:get, 'http://gitlab.example/api/v4/version?private_token=token').to_return(status: 404)
          stub_request(:get, 'http://gitlab.example/api/v4/metadata?private_token=token')
            .to_return(
              status: 200,
              body: source_version.to_json,
              headers: { 'Content-Type' => 'application/json' }
            )
          stub_request(:get, ""http://gitlab.example/api/v4/#{source_entity_type}/#{source_entity_identifier}/export_relations/status?page=1&per_page=30&private_token=token"")
            .to_return(
              status: 200
            )

          allow_next_instance_of(BulkImports::Clients::HTTP) do |client|
            allow(client).to receive(:validate_import_scopes!)
              .and_raise(BulkImports::Error.scope_or_url_validation_failure)
          end

          result = subject.execute

          expect(result).to be_a(ServiceResponse)
          expect(result).to be_error
          expect(result.message)
            .to eq(
              ""Check that the source instance base URL and the personal access token meet the necessary requirements.""
            )
        end
      end

      context 'when token validation succeeds' do
        before do
          stub_request(:get, 'http://gitlab.example/api/v4/version?private_token=token').to_return(status: 404)
          stub_request(:get, 'http://gitlab.example/api/v4/metadata?private_token=token')
            .to_return(status: 200, body: source_version.to_json, headers: { 'Content-Type' => 'application/json' })
          stub_request(:get, ""http://gitlab.example/api/v4/#{source_entity_type}/#{source_entity_identifier}/export_relations/status?page=1&per_page=30&private_token=token"")
            .to_return(
              status: 200
            )
          stub_request(:get, 'http://gitlab.example/api/v4/personal_access_tokens/self?private_token=token')
            .to_return(
              status: 200,
              body: { 'scopes' => ['api'] }.to_json,
              headers: { 'Content-Type' => 'application/json' }
            )

          parent_group.add_owner(user)
        end

        it 'creates bulk import' do
          expect { subject.execute }.to change { BulkImport.count }.by(1)

          last_bulk_import = BulkImport.last
          expect(last_bulk_import.user).to eq(user)
          expect(last_bulk_import.source_version).to eq(source_version[:version])
          expect(last_bulk_import.user).to eq(user)
          expect(last_bulk_import.source_enterprise).to eq(false)

          expect_snowplow_event(
            category: 'BulkImports::CreateService',
            action: 'create',
            label: 'bulk_import_group',
            extra: { source_equals_destination: false }
          )

          expect_snowplow_event(
            category: 'BulkImports::CreateService',
            action: 'create',
            label: 'import_access_level',
            user: user,
            extra: { user_role: 'Owner', import_type: 'bulk_import_group' }
          )
        end

        context 'on the same instance' do
          before do
            allow(Settings.gitlab).to receive(:base_url).and_return('http://gitlab.example')
          end

          it 'tracks the same instance migration' do
            expect { subject.execute }.to change { BulkImport.count }.by(1)

            expect_snowplow_event(
              category: 'BulkImports::CreateService',
              action: 'create',
              label: 'bulk_import_group',
              extra: { source_equals_destination: true }
            )
          end
        end

        describe 'projects migration flag' do
          let(:import) { BulkImport.last }

          context 'when false' do
            let(:migrate_projects) { false }

            it 'sets false' do
              subject.execute

              expect(import.entities.pluck(:migrate_projects)).to contain_exactly(false, false, false)
            end
          end

          context 'when true' do
            let(:migrate_projects) { true }

            it 'sets true' do
              subject.execute

              expect(import.entities.pluck(:migrate_projects)).to contain_exactly(true, true, true)
            end
          end

          context 'when nil' do
            let(:migrate_projects) { nil }

            it 'sets true' do
              subject.execute

              expect(import.entities.pluck(:migrate_projects)).to contain_exactly(true, true, true)
            end
          end
        end
      end
    end

    context 'when gitlab version is lower than 15.5' do
      let(:source_version) do
        Gitlab::VersionInfo.new(
          ::BulkImport::MIN_MAJOR_VERSION,
          ::BulkImport::MIN_MINOR_VERSION_FOR_PROJECT
        )
      end

      before do
        allow_next_instance_of(BulkImports::Clients::HTTP) do |instance|
          allow(instance).to receive(:instance_version).and_return(source_version)
          allow(instance).to receive(:instance_enterprise).and_return(false)
          stub_request(:get, ""http://gitlab.example/api/v4/#{source_entity_type}/#{source_entity_identifier}/export_relations/status?page=1&per_page=30&private_token=token"")
            .to_return(
              status: 200
            )
        end

        parent_group.add_owner(user)
      end

      it 'creates bulk import' do
        expect { subject.execute }.to change { BulkImport.count }.by(1)

        last_bulk_import = BulkImport.last

        expect(last_bulk_import.user).to eq(user)
        expect(last_bulk_import.source_version).to eq(source_version.to_s)
        expect(last_bulk_import.user).to eq(user)
        expect(last_bulk_import.source_enterprise).to eq(false)

        expect_snowplow_event(
          category: 'BulkImports::CreateService',
          action: 'create',
          label: 'bulk_import_group',
          extra: { source_equals_destination: false }
        )

        expect_snowplow_event(
          category: 'BulkImports::CreateService',
          action: 'create',
          label: 'import_access_level',
          user: user,
          extra: { user_role: 'Owner', import_type: 'bulk_import_group' }
        )
      end

      context 'on the same instance' do
        before do
          allow(Settings.gitlab).to receive(:base_url).and_return('http://gitlab.example')
        end

        it 'tracks the same instance migration' do
          expect { subject.execute }.to change { BulkImport.count }.by(1)

          expect_snowplow_event(
            category: 'BulkImports::CreateService',
            action: 'create',
            label: 'bulk_import_group',
            extra: { source_equals_destination: true }
          )
        end
      end

      it 'creates bulk import entities' do
        expect { subject.execute }.to change { BulkImports::Entity.count }.by(3)
      end

      it 'creates bulk import configuration' do
        expect { subject.execute }.to change { BulkImports::Configuration.count }.by(1)
      end

      it 'enqueues BulkImportWorker' do
        expect(BulkImportWorker).to receive(:perform_async)

        subject.execute
      end

      it 'returns success ServiceResponse' do
        result = subject.execute

        expect(result).to be_a(ServiceResponse)
        expect(result).to be_success
      end

      it 'returns ServiceResponse with error if validation fails' do
        params[0][:source_full_path] = nil

        result = subject.execute

        expect(result).to be_a(ServiceResponse)
        expect(result).to be_error
        expect(result.message).to eq(""Validation failed: Source full path can't be blank, "" \
                                     ""Source full path must have a relative path structure with "" \
                                     ""no HTTP protocol characters, or leading or trailing forward slashes. "" \
                                     ""Path segments must not start or end with a special character, and "" \
                                     ""must not contain consecutive special characters"")
      end

      describe '#user-role' do
        context 'when there is a parent_namespace and the user is a member' do
          let(:group2) { create(:group, path: 'destination200', source_id: parent_group.id ) }
          let(:params) do
            [
              {
                source_type: 'group_entity',
                source_full_path: 'full/path/to/group1',
                destination_slug: 'destination200',
                destination_namespace: 'parent-group'
              }
            ]
          end

          it 'defines access_level from parent namespace membership' do
            parent_group.add_guest(user)
            subject.execute

            expect_snowplow_event(
              category: 'BulkImports::CreateService',
              action: 'create',
              label: 'import_access_level',
              user: user,
              extra: { user_role: 'Guest', import_type: 'bulk_import_group' }
            )
          end
        end

        it 'defines access_level as not a member' do
          parent_group.members.delete_all

          subject.execute
          expect_snowplow_event(
            category: 'BulkImports::CreateService',
            action: 'create',
            label: 'import_access_level',
            user: user,
            extra: { user_role: 'Not a member', import_type: 'bulk_import_group' }
          )
        end

        context 'when there is a destination_namespace but no parent_namespace' do
          let(:params) do
            [
              {
                source_type: 'group_entity',
                source_full_path: 'full/path/to/group1',
                destination_slug: 'destination-group-1',
                destination_namespace: 'destination1'
              }
            ]
          end

          it 'defines access_level from destination_namespace' do
            destination_group.add_developer(user)
            subject.execute

            expect_snowplow_event(
              category: 'BulkImports::CreateService',
              action: 'create',
              label: 'import_access_level',
              user: user,
              extra: { user_role: 'Developer', import_type: 'bulk_import_group' }
            )
          end
        end

        context 'when there is no destination_namespace or parent_namespace' do
          let(:params) do
            [
              {
                source_type: 'group_entity',
                source_full_path: 'full/path/to/group1',
                destination_slug: 'destinationational-mcdestiny',
                destination_namespace: 'destinational-mcdestiny'
              }
            ]
          end

          it 'defines access_level as owner' do
            subject.execute

            expect_snowplow_event(
              category: 'BulkImports::CreateService',
              action: 'create',
              label: 'import_access_level',
              user: user,
              extra: { user_role: 'Owner', import_type: 'bulk_import_group' }
            )
          end
        end
      end

      describe '#validate_setting_enabled!' do
        let(:entity_source_id) { 'gid://gitlab/Model/12345' }
        let(:graphql_client) { instance_double(BulkImports::Clients::Graphql) }
        let(:http_client) { instance_double(BulkImports::Clients::HTTP) }
        let(:http_response) { double(code: 200, success?: true) } # rubocop:disable RSpec/VerifiedDoubles

        before do
          allow(BulkImports::Clients::HTTP).to receive(:new).and_return(http_client)
          allow(BulkImports::Clients::Graphql).to receive(:new).and_return(graphql_client)

          allow(http_client).to receive(:instance_version).and_return(status: 200)
          allow(http_client).to receive(:instance_enterprise).and_return(false)
          allow(http_client).to receive(:validate_instance_version!).and_return(source_version)
          allow(http_client).to receive(:validate_import_scopes!).and_return(true)
        end

        context 'when the source_type is a group' do
          context 'when the source_full_path contains only integer characters' do
            let(:query_string) { BulkImports::Groups::Graphql::GetGroupQuery.new(context: nil).to_s }
            let(:graphql_response) do
              double(original_hash: { 'data' => { 'group' => { 'id' => entity_source_id } } }) # rubocop:disable RSpec/VerifiedDoubles
            end

            let(:params) do
              [
                {
                  source_type: 'group_entity',
                  source_full_path: '67890',
                  destination_slug: 'destination-group-1',
                  destination_namespace: 'destination1'
                }
              ]
            end

            before do
              allow(graphql_client).to receive(:parse).with(query_string)
              allow(graphql_client).to receive(:execute).and_return(graphql_response)

              allow(http_client).to receive(:get)
                .with(""/groups/12345/export_relations/status"")
                .and_return(http_response)

              stub_request(:get, ""http://gitlab.example/api/v4/groups/12345/export_relations/status?page=1&per_page=30&private_token=token"")
                  .to_return(status: 200, body: """", headers: {})
            end

            it 'makes a graphql request using the group full path and an http request with the correct id' do
              expect(graphql_client).to receive(:parse).with(query_string)
              expect(graphql_client).to receive(:execute).and_return(graphql_response)

              expect(http_client).to receive(:get).with(""/groups/12345/export_relations/status"")

              subject.execute
            end
          end
        end

        context 'when the source_type is a project' do
          context 'when the source_full_path contains only integer characters' do
            let(:query_string) { BulkImports::Projects::Graphql::GetProjectQuery.new(context: nil).to_s }
            let(:graphql_response) do
              double(original_hash: { 'data' => { 'project' => { 'id' => entity_source_id } } }) # rubocop:disable RSpec/VerifiedDoubles
            end

            let(:params) do
              [
                {
                  source_type: 'project_entity',
                  source_full_path: '67890',
                  destination_slug: 'destination-group-1',
                  destination_namespace: 'destination1'
                }
              ]
            end

            before do
              allow(graphql_client).to receive(:parse).with(query_string)
              allow(graphql_client).to receive(:execute).and_return(graphql_response)

              allow(http_client).to receive(:get)
                .with(""/projects/12345/export_relations/status"")
                .and_return(http_response)

              stub_request(:get, ""http://gitlab.example/api/v4/projects/12345/export_relations/status?page=1&per_page=30&private_token=token"")
                  .to_return(status: 200, body: """", headers: {})
            end

            it 'makes a graphql request using the group full path and an http request with the correct id' do
              expect(graphql_client).to receive(:parse).with(query_string)
              expect(graphql_client).to receive(:execute).and_return(graphql_response)

              expect(http_client).to receive(:get).with(""/projects/12345/export_relations/status"")

              subject.execute
            end
          end
        end
      end

      describe '#validate_destination_namespace' do
        context 'when the destination_namespace does not exist' do
          let(:params) do
            [
              {
                source_type: 'group_entity',
                source_full_path: 'full/path/to/source',
                destination_slug: 'destination-slug',
                destination_namespace: 'destination-namespace',
                migrate_projects: migrate_projects
              }
            ]
          end

          it 'returns ServiceResponse with an error message' do
            result = subject.execute

            expect(result).to be_a(ServiceResponse)
            expect(result).to be_error
            expect(result.message)
              .to eq(""Import failed. Destination 'destination-namespace' is invalid, "" \
                     ""or you don't have permission."")
          end
        end

        context 'when the user does not have permission to create subgroups' do
          let(:params) do
            [
              {
                source_type: 'group_entity',
                source_full_path: 'full/path/to/source',
                destination_slug: 'destination-slug',
                destination_namespace: parent_group.path,
                migrate_projects: migrate_projects
              }
            ]
          end

          it 'returns ServiceResponse with an error message' do
            parent_group.members.delete_all

            result = subject.execute

            expect(result).to be_a(ServiceResponse)
            expect(result).to be_error
            expect(result.message)
            .to eq(""Import failed. Destination '#{parent_group.path}' is invalid, "" \
                   ""or you don't have permission."")
          end
        end

        context 'when the user does not have permission to create projects' do
          let(:params) do
            [
              {
                source_type: 'project_entity',
                source_full_path: 'full/path/to/source',
                destination_slug: 'destination-slug',
                destination_namespace: parent_group.path,
                migrate_projects: migrate_projects
              }
            ]
          end

          it 'returns ServiceResponse with an error message' do
            parent_group.members.delete_all

            result = subject.execute

            expect(result).to be_a(ServiceResponse)
            expect(result).to be_error
            expect(result.message)
              .to eq(""Import failed. Destination '#{parent_group.path}' is invalid, "" \
                     ""or you don't have permission."")
          end
        end
      end

      describe '#validate_destination_slug' do
        context 'when the destination_slug is invalid' do
          let(:params) do
            [
              {
                source_type: 'group_entity',
                source_full_path: 'full/path/to/source',
                destination_slug: 'destin-*-ation-slug',
                destination_namespace: parent_group.path,
                migrate_projects: migrate_projects
              }
            ]
          end

          it 'returns ServiceResponse with an error message' do
            result = subject.execute

            expect(result).to be_a(ServiceResponse)
            expect(result).to be_error
            expect(result.message)
              .to eq(
                ""Import failed. Destination URL "" \
                ""must not start or end with a special character and must "" \
                ""not contain consecutive special characters.""
              )
          end
        end
      end

      describe '#validate_destination_full_path' do
        context 'when the source_type is a group' do
          context 'when the provided destination_slug already exists in the destination_namespace' do
            let_it_be(:existing_subgroup) { create(:group, path: 'existing-subgroup', parent_id: parent_group.id ) }
            let_it_be(:existing_subgroup_2) { create(:group, path: 'existing-subgroup_2', parent_id: parent_group.id ) }
            let(:params) do
              [
                {
                  source_type: 'group_entity',
                  source_full_path: 'full/path/to/source',
                  destination_slug: existing_subgroup.path,
                  destination_namespace: parent_group.path,
                  migrate_projects: migrate_projects
                }
              ]
            end

            it 'returns ServiceResponse with an error message' do
              result = subject.execute

              expect(result).to be_a(ServiceResponse)
              expect(result).to be_error
              expect(result.message)
                .to eq(
                  ""Import failed. 'parent-group/existing-subgroup' already exists. "" \
                  ""Change the destination and try again.""
                )
            end
          end

          context 'when the destination_slug conflicts with an existing top-level namespace' do
            let_it_be(:existing_top_level_group) { create(:group, path: 'top-level-group') }
            let(:params) do
              [
                {
                  source_type: 'group_entity',
                  source_full_path: 'full/path/to/source',
                  destination_slug: existing_top_level_group.path,
                  destination_namespace: '',
                  migrate_projects: migrate_projects
                }
              ]
            end

            it 'returns ServiceResponse with an error message' do
              result = subject.execute

              expect(result).to be_a(ServiceResponse)
              expect(result).to be_error
              expect(result.message)
                .to eq(
                  ""Import failed. 'top-level-group' already exists. "" \
                  ""Change the destination and try again.""
                )
            end
          end

          context 'when the destination_slug does not conflict with an existing top-level namespace' do
            let(:params) do
              [
                {
                  source_type: 'group_entity',
                  source_full_path: 'full/path/to/source',
                  destination_slug: 'new-group',
                  destination_namespace: parent_group.path,
                  migrate_projects: migrate_projects
                }
              ]
            end

            it 'returns success ServiceResponse' do
              result = subject.execute

              expect(result).to be_a(ServiceResponse)
              expect(result).to be_success
            end
          end
        end

        context 'when the source_type is a project' do
          context 'when the provided destination_slug already exists in the destination_namespace' do
            let_it_be(:existing_group) { create(:group, path: 'existing-group' ) }
            let_it_be(:existing_project) { create(:project, path: 'existing-project', parent_id: existing_group.id ) }
            let(:params) do
              [
                {
                  source_type: 'project_entity',
                  source_full_path: 'full/path/to/source',
                  destination_slug: existing_project.path,
                  destination_namespace: existing_group.path,
                  migrate_projects: migrate_projects
                }
              ]
            end

            it 'returns ServiceResponse with an error message' do
              existing_group.add_owner(user)

              result = subject.execute

              expect(result).to be_a(ServiceResponse)
              expect(result).to be_error
              expect(result.message)
                .to eq(
                  ""Import failed. 'existing-group/existing-project' already exists. "" \
                  ""Change the destination and try again.""
                )
            end
          end

          context 'when the destination_slug does not conflict with an existing project' do
            let_it_be(:existing_group) { create(:group, path: 'existing-group' ) }
            let(:params) do
              [
                {
                  source_type: 'project_entity',
                  source_full_path: 'full/path/to/source',
                  destination_slug: 'new-project',
                  destination_namespace: 'existing-group',
                  migrate_projects: migrate_projects
                }
              ]
            end

            it 'returns success ServiceResponse' do
              existing_group.add_owner(user)

              result = subject.execute

              expect(result).to be_a(ServiceResponse)
              expect(result).to be_success
            end
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module BulkImports
  class RelationExportService
    include Gitlab::ImportExport::CommandLineUtil

    EXISTING_EXPORT_TTL = 3.minutes

    def initialize(user, portable, relation, jid)
      @user = user
      @portable = portable
      @relation = relation
      @jid = jid
      @config = FileTransfer.config_for(portable)
    end

    def execute
      find_or_create_export! do |export|
        export.remove_existing_upload!
        export_service.execute
        ensure_export_file_exists!
        compress_exported_relation
        upload_compressed_file(export)
      end
    ensure
      FileUtils.remove_entry(export_path)
    end

    private

    attr_reader :user, :portable, :relation, :jid, :config

    delegate :export_path, to: :config

    def find_or_create_export!
      export = portable.bulk_import_exports.safe_find_or_create_by!(relation: relation)

      return export if export.finished? && export.updated_at > EXISTING_EXPORT_TTL.ago && !export.batched?

      start_export!(export)

      yield export

      finish_export!(export)
    end

    def export_service
      @export_service ||= if config.tree_relation?(relation) || config.self_relation?(relation)
                            TreeExportService.new(portable, export_path, relation, user)
                          elsif config.file_relation?(relation)
                            FileExportService.new(portable, export_path, relation, user)
                          else
                            raise BulkImports::Error, 'Unsupported export relation'
                          end
    end

    def upload_compressed_file(export)
      compressed_file = File.join(export_path, ""#{export_service.exported_filename}.gz"")

      upload = ExportUpload.find_or_initialize_by(export_id: export.id) # rubocop: disable CodeReuse/ActiveRecord

      File.open(compressed_file) { |file| upload.export_file = file }

      upload.save!
    end

    def compress_exported_relation
      gzip(dir: export_path, filename: export_service.exported_filename)
    end

    def start_export!(export)
      export.update!(
        status_event: 'start',
        jid: jid,
        batched: false,
        batches_count: 0,
        total_objects_count: 0,
        error: nil
      )

      export.batches.destroy_all if export.batches.any? # rubocop:disable Cop/DestroyAll
    end

    def finish_export!(export)
      export.update!(status_event: 'finish', batched: false, error: nil)
    end

    def exported_filepath
      File.join(export_path, export_service.exported_filename)
    end

    # Create empty file on disk
    # if relation is empty and nothing was exported
    def ensure_export_file_exists!
      FileUtils.touch(exported_filepath)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe BulkImports::RelationExportService, feature_category: :importers do
  let_it_be(:jid) { 'jid' }
  let_it_be(:relation) { 'labels' }
  let_it_be(:user) { create(:user) }
  let_it_be(:group) { create(:group) }
  let_it_be(:project) { create(:project) }
  let_it_be(:label) { create(:group_label, group: group) }
  let_it_be(:export_path) { ""#{Dir.tmpdir}/relation_export_service_spec/tree"" }
  let_it_be_with_reload(:export) { create(:bulk_import_export, group: group, relation: relation) }

  before do
    FileUtils.mkdir_p(export_path)

    group.add_owner(user)
    project.add_maintainer(user)

    allow(subject).to receive(:export_path).and_return(export_path)
  end

  after :all do
    FileUtils.rm_rf(export_path)
  end

  subject { described_class.new(user, group, relation, jid) }

  describe '#execute' do
    it 'exports specified relation and marks export as finished' do
      expect_next_instance_of(BulkImports::TreeExportService) do |service|
        expect(service).to receive(:execute).and_call_original
      end

      subject.execute

      expect(export.reload.upload.export_file).to be_present
      expect(export.finished?).to eq(true)
      expect(export.batched?).to eq(false)
      expect(export.batches_count).to eq(0)
      expect(export.batches.count).to eq(0)
      expect(export.total_objects_count).to eq(0)
    end

    it 'removes temp export files' do
      subject.execute

      expect(Dir.exist?(export_path)).to eq(false)
    end

    it 'exports specified relation and marks export as finished' do
      subject.execute

      expect(export.upload.export_file).to be_present
    end

    context 'when relation is empty and there is nothing to export' do
      let(:relation) { 'milestones' }

      it 'creates empty file on disk' do
        expect(FileUtils).to receive(:touch).with(""#{export_path}/#{relation}.ndjson"").and_call_original

        subject.execute
      end
    end

    context 'when exporting a file relation' do
      it 'uses file export service' do
        service = described_class.new(user, project, 'uploads', jid)

        expect_next_instance_of(BulkImports::FileExportService) do |service|
          expect(service).to receive(:execute)
        end

        service.execute
      end
    end

    context 'when export record does not exist' do
      let(:another_group) { create(:group) }

      subject { described_class.new(user, another_group, relation, jid) }

      it 'creates export record' do
        another_group.add_owner(user)

        expect { subject.execute }
          .to change { another_group.bulk_import_exports.count }
          .from(0)
          .to(1)
      end
    end

    context 'when there is existing export present' do
      let(:upload) { create(:bulk_import_export_upload, export: export) }

      it 'removes existing export before exporting' do
        upload.update!(export_file: fixture_file_upload('spec/fixtures/bulk_imports/gz/labels.ndjson.gz'))

        expect_any_instance_of(BulkImports::ExportUpload) do |upload|
          expect(upload).to receive(:remove_export_file!)
        end

        subject.execute
      end

      context 'when export is recently finished' do
        it 'returns recently finished export instead of re-exporting' do
          updated_at = 5.seconds.ago
          export.update!(status: 1, updated_at: updated_at)

          expect { subject.execute }.not_to change { export.updated_at }

          expect(export.status).to eq(1)
          expect(export.updated_at).to eq(updated_at)
        end
      end
    end

    context 'when export was batched' do
      let(:relation) { 'milestones' }
      let(:export) { create(:bulk_import_export, group: group, relation: relation, batched: true, batches_count: 2) }

      it 'removes existing batches and marks export as not batched' do
        create(:bulk_import_export_batch, batch_number: 1, export: export)
        create(:bulk_import_export_batch, batch_number: 2, export: export)

        expect { described_class.new(user, group, relation, jid).execute }
          .to change { export.reload.batches.count }
          .from(2)
          .to(0)

        expect(export.batched?).to eq(false)
        expect(export.batches_count).to eq(0)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module BulkImports
  class GetImportableDataService
    def initialize(params, query_params, credentials)
      @params = params
      @query_params = query_params
      @credentials = credentials
    end

    def execute
      {
        version_validation: version_validation,
        response: importables
      }
    end

    private

    def importables
      client.get('groups', @query_params)
    end

    def version_validation
      {
        features: {
          project_migration: {
            available: client.compatible_for_project_migration?,
            min_version: BulkImport.min_gl_version_for_project_migration.to_s
          },
          source_instance_version: client.instance_version.to_s
        }
      }
    end

    def client
      @client ||= BulkImports::Clients::HTTP.new(
        url: @credentials[:url],
        token: @credentials[:access_token],
        per_page: @params[:per_page],
        page: @params[:page]
      )
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe BulkImports::GetImportableDataService, feature_category: :importers do
  describe '#execute' do
    include_context 'bulk imports requests context', 'https://gitlab.example.com'

    let_it_be(:params) { { per_page: 20, page: 1 } }
    let_it_be(:query_params) { { top_level_only: true, min_access_level: 50, search: '' } }
    let_it_be(:credentials) { { url: 'https://gitlab.example.com', access_token: 'demo-pat' } }
    let_it_be(:expected_version_validation) do
      {
        features: {
          project_migration: {
            available: true,
            min_version: BulkImport.min_gl_version_for_project_migration.to_s
          },
          'source_instance_version': BulkImport.min_gl_version_for_project_migration.to_s
        }
      }
    end

    let_it_be(:expected_parsed_response) do
      [
        {
          'id' => 2595438,
          'web_url' => 'https://gitlab.com/groups/auto-breakfast',
          'name' => 'Stub',
          'path' => 'stub-group',
          'full_name' => 'Stub',
          'full_path' => 'stub-group'
        }
      ]
    end

    let(:source_version) do
      Gitlab::VersionInfo.new(
        ::BulkImport::MIN_MAJOR_VERSION,
        ::BulkImport::MIN_MINOR_VERSION_FOR_PROJECT
      )
    end

    before do
      allow_next_instance_of(BulkImports::Clients::HTTP) do |instance|
        allow(instance).to receive(:instance_version).and_return(source_version)
        allow(instance).to receive(:instance_enterprise).and_return(false)
      end
    end

    subject do
      described_class.new(params, query_params, credentials).execute
    end

    it 'returns version_validation and a response' do
      expect(subject[:version_validation]).to eq(expected_version_validation)
      expect(subject[:response].parsed_response).to eq(expected_parsed_response)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# File Decompression Service allows gzipped files decompression into tmp directory.
#
# @param tmpdir [String] Temp directory to store downloaded file to. Must be located under `Dir.tmpdir`.
# @param filename [String] Name of the file to decompress.
module BulkImports
  class FileDecompressionService
    include Gitlab::ImportExport::CommandLineUtil

    ServiceError = Class.new(StandardError)

    def initialize(tmpdir:, filename:)
      @tmpdir = tmpdir
      @filename = filename
      @filepath = File.join(@tmpdir, @filename)
      @decompressed_filename = File.basename(@filename, '.gz')
      @decompressed_filepath = File.join(@tmpdir, @decompressed_filename)
    end

    def execute
      validate_tmpdir
      validate_filepath
      validate_decompressed_file_size if Feature.enabled?(:validate_import_decompressed_archive_size)
      validate_symlink(filepath)

      decompress_file

      validate_symlink(decompressed_filepath)

      filepath
    rescue StandardError => e
      File.delete(filepath) if File.exist?(filepath)
      File.delete(decompressed_filepath) if File.exist?(decompressed_filepath)

      raise e
    end

    private

    attr_reader :tmpdir, :filename, :filepath, :decompressed_filename, :decompressed_filepath

    def validate_filepath
      Gitlab::PathTraversal.check_path_traversal!(filepath)
    end

    def validate_tmpdir
      Gitlab::PathTraversal.check_allowed_absolute_path!(tmpdir, [Dir.tmpdir])
    end

    def validate_decompressed_file_size
      raise(ServiceError, 'File decompression error') unless size_validator.valid?
    end

    def validate_symlink(filepath)
      raise(ServiceError, 'Invalid file') if Gitlab::Utils::FileInfo.linked?(filepath)
    end

    def decompress_file
      gunzip(dir: tmpdir, filename: filename)
    end

    def size_validator
      @size_validator ||= Gitlab::ImportExport::DecompressedArchiveSizeValidator.new(archive_path: filepath)
    end
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe BulkImports::FileDecompressionService, feature_category: :importers do
  using RSpec::Parameterized::TableSyntax

  let_it_be(:tmpdir) { Dir.mktmpdir }
  let_it_be(:ndjson_filename) { 'labels.ndjson' }
  let_it_be(:ndjson_filepath) { File.join(tmpdir, ndjson_filename) }
  let_it_be(:gz_filename) { ""#{ndjson_filename}.gz"" }
  let_it_be(:gz_filepath) { ""spec/fixtures/bulk_imports/gz/#{gz_filename}"" }

  before do
    FileUtils.copy_file(gz_filepath, File.join(tmpdir, gz_filename))
    FileUtils.remove_entry(ndjson_filepath) if File.exist?(ndjson_filepath)
  end

  after(:all) do
    FileUtils.remove_entry(tmpdir)
  end

  subject { described_class.new(tmpdir: tmpdir, filename: gz_filename) }

  describe '#execute' do
    it 'decompresses specified file' do
      subject.execute

      expect(File.exist?(File.join(tmpdir, ndjson_filename))).to eq(true)
      expect(File.open(ndjson_filepath, &:readline)).to include('title', 'description')
    end

    context 'when validate_import_decompressed_archive_size feature flag is enabled' do
      before do
        stub_feature_flags(validate_import_decompressed_archive_size: true)
      end

      it 'performs decompressed file size validation' do
        expect_next_instance_of(Gitlab::ImportExport::DecompressedArchiveSizeValidator) do |validator|
          expect(validator).to receive(:valid?).and_return(true)
        end

        subject.execute
      end
    end

    context 'when validate_import_decompressed_archive_size feature flag is disabled' do
      before do
        stub_feature_flags(validate_import_decompressed_archive_size: false)
      end

      it 'does not perform decompressed file size validation' do
        expect(Gitlab::ImportExport::DecompressedArchiveSizeValidator).not_to receive(:new)

        subject.execute
      end
    end

    context 'when dir is not in tmpdir' do
      subject { described_class.new(tmpdir: '/etc', filename: 'filename') }

      it 'raises an error' do
        expect { subject.execute }.to raise_error(StandardError, 'path /etc is not allowed')
      end
    end

    context 'when path is being traversed' do
      subject { described_class.new(tmpdir: File.join(Dir.mktmpdir, 'test', '..'), filename: 'filename') }

      it 'raises an error' do
        expect { subject.execute }.to raise_error(Gitlab::PathTraversal::PathTraversalAttackError, 'Invalid path')
      end
    end

    shared_examples 'raises an error and removes the file' do |error_message:|
      specify do
        expect { subject.execute }
          .to raise_error(BulkImports::FileDecompressionService::ServiceError, error_message)
        expect(File).not_to exist(file)
      end
    end

    shared_context 'when compressed file' do
      let_it_be(:file) { File.join(tmpdir, 'file.gz') }

      subject { described_class.new(tmpdir: tmpdir, filename: 'file.gz') }

      before do
        FileUtils.send(link_method, File.join(tmpdir, gz_filename), file)
      end
    end

    shared_context 'when decompressed file' do
      let_it_be(:file) { File.join(tmpdir, 'file.txt') }

      subject { described_class.new(tmpdir: tmpdir, filename: gz_filename) }

      before do
        original_file = File.join(tmpdir, 'original_file.txt')
        FileUtils.touch(original_file)
        FileUtils.send(link_method, original_file, file)

        subject.instance_variable_set(:@decompressed_filepath, file)
      end
    end

    context 'when compressed file is a symlink' do
      let(:link_method) { :symlink }

      include_context 'when compressed file'

      include_examples 'raises an error and removes the file', error_message: 'File decompression error'
    end

    context 'when compressed file shares multiple hard links' do
      let(:link_method) { :link }

      include_context 'when compressed file'

      include_examples 'raises an error and removes the file', error_message: 'File decompression error'
    end

    context 'when decompressed file is a symlink' do
      let(:link_method) { :symlink }

      include_context 'when decompressed file'

      include_examples 'raises an error and removes the file', error_message: 'Invalid file'
    end

    context 'when decompressed file shares multiple hard links' do
      let(:link_method) { :link }

      include_context 'when decompressed file'

      include_examples 'raises an error and removes the file', error_message: 'Invalid file'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module BulkImports
  class TreeExportService
    include Gitlab::Utils::StrongMemoize

    delegate :exported_objects_count, to: :serializer

    def initialize(portable, export_path, relation, user)
      @portable = portable
      @export_path = export_path
      @relation = relation
      @config = FileTransfer.config_for(portable)
      @user = user
    end

    def execute
      if self_relation?(relation)
        serializer.serialize_root(config.class::SELF_RELATION)
      else
        serializer.serialize_relation(relation_definition)
      end
    end

    def export_batch(ids)
      serializer.serialize_relation(relation_definition, batch_ids: Array.wrap(ids))
    end

    def exported_filename
      ""#{relation}.#{extension}""
    end

    private

    delegate :self_relation?, to: :config

    attr_reader :export_path, :portable, :relation, :config, :user

    # rubocop: disable CodeReuse/Serializer
    def serializer
      @serializer ||= ::Gitlab::ImportExport::Json::StreamingSerializer.new(
        portable,
        config.portable_tree,
        ::Gitlab::ImportExport::Json::NdjsonWriter.new(export_path),
        exportable_path: '',
        current_user: user
      )
    end
    # rubocop: enable CodeReuse/Serializer

    def extension
      return 'json' if self_relation?(relation)

      'ndjson'
    end

    def relation_definition
      definition = config.tree_relation_definition_for(relation)

      raise BulkImports::Error, 'Unsupported relation export type' unless definition

      definition
    end
    strong_memoize_attr :relation_definition
  end
end

```","# frozen_string_literal: true

require 'spec_helper'

RSpec.describe BulkImports::TreeExportService, feature_category: :importers do
  let_it_be(:project) { create(:project) }
  let_it_be(:export_path) { Dir.mktmpdir }

  let(:relation) { 'issues' }

  subject(:service) { described_class.new(project, export_path, relation, project.owner) }

  describe '#execute' do
    it 'executes export service and archives exported data' do
      expect_next_instance_of(Gitlab::ImportExport::Json::StreamingSerializer) do |serializer|
        expect(serializer).to receive(:serialize_relation)
      end

      subject.execute
    end

    context 'when unsupported relation is passed' do
      it 'raises an error' do
        service = described_class.new(project, export_path, 'unsupported', project.owner)

        expect { service.execute }.to raise_error(BulkImports::Error, 'Unsupported relation export type')
      end
    end

    context 'when relation is self' do
      let(:relation) { 'self' }

      it 'executes export on portable itself' do
        expect_next_instance_of(Gitlab::ImportExport::Json::StreamingSerializer) do |serializer|
          expect(serializer).to receive(:serialize_root)
        end

        subject.execute
      end
    end
  end

  describe '#exported_filename' do
    it 'returns filename of the exported file' do
      expect(subject.exported_filename).to eq('issues.ndjson')
    end

    context 'when relation is self' do
      let(:relation) { 'self' }

      it 'returns filename of the exported file' do
        expect(subject.exported_filename).to eq('self.json')
      end
    end
  end

  describe '#export_batch' do
    it 'serializes relation with specified ids' do
      expect_next_instance_of(Gitlab::ImportExport::Json::StreamingSerializer) do |serializer|
        expect(serializer).to receive(:serialize_relation).with(anything, batch_ids: [1, 2, 3])
      end

      subject.export_batch([1, 2, 3])
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

TopicStatusUpdater =
  Struct.new(:topic, :user) do
    def update!(status, enabled, opts = {})
      status = Status.new(status, enabled)

      @topic_timer = topic.public_topic_timer

      updated = nil
      Topic.transaction do
        updated = change(status, opts)
        if updated
          highest_post_number = topic.highest_post_number
          create_moderator_post_for(status, opts)
          update_read_state_for(status, highest_post_number)
        end
      end

      updated
    end

    private

    def change(status, opts = {})
      result = true

      if status.pinned? || status.pinned_globally?
        topic.update_pinned(status.enabled?, status.pinned_globally?, opts[:until])
      elsif status.autoclosed?
        rc = Topic.where(id: topic.id, closed: !status.enabled?).update_all(closed: status.enabled?)
        topic.closed = status.enabled?
        result = false if rc == 0
      else
        rc =
          Topic.where(:id => topic.id, status.name => !status.enabled).update_all(
            status.name => status.enabled?,
          )

        topic.public_send(""#{status.name}="", status.enabled?)
        result = false if rc == 0
      end

      DiscourseEvent.trigger(:topic_closed, topic) if status.manually_closing_topic?

      if status.visible? && status.disabled?
        UserProfile.remove_featured_topic_from_all_profiles(topic)
      end

      if status.visible? && result
        topic.update_category_topic_count_by(status.enabled? ? 1 : -1)
        UserStatCountUpdater.public_send(
          status.enabled? ? :increment! : :decrement!,
          topic.first_post,
        )
      end

      if @topic_timer
        if status.manually_closing_topic? || status.closing_topic?
          topic.delete_topic_timer(TopicTimer.types[:close])
          topic.delete_topic_timer(TopicTimer.types[:silent_close])
        elsif status.manually_opening_topic? || status.opening_topic?
          topic.delete_topic_timer(TopicTimer.types[:open])
          topic.inherit_auto_close_from_category
        end
      end

      # remove featured topics if we close/archive/make them invisible. Previously we used
      # to run the whole featuring logic but that could be very slow and have concurrency
      # errors on large sites with many autocloses and topics being created.
      if (
           (status.enabled? && (status.autoclosed? || status.closed? || status.archived?)) ||
             (status.disabled? && status.visible?)
         )
        CategoryFeaturedTopic.where(topic_id: topic.id).delete_all
      end

      result
    end

    def create_moderator_post_for(status, opts)
      message = opts[:message]
      topic.add_moderator_post(user, message || message_for(status), options_for(status, opts))
      topic.reload
    end

    def update_read_state_for(status, old_highest_read)
      if status.autoclosed? && status.enabled?
        # let's pretend all the people that read up to the autoclose message
        # actually read the topic
        PostTiming.pretend_read(topic.id, old_highest_read, topic.highest_post_number)
      end
    end

    def message_for(status)
      if status.autoclosed?
        locale_key = status.locale_key.dup
        locale_key << ""_lastpost"" if @topic_timer&.based_on_last_post
        message_for_autoclosed(locale_key)
      end
    end

    def message_for_autoclosed(locale_key)
      num_minutes =
        if @topic_timer&.based_on_last_post
          (@topic_timer.duration_minutes || 0).minutes.to_i
        elsif @topic_timer&.created_at
          Time.zone.now - @topic_timer.created_at
        else
          Time.zone.now - topic.created_at
        end

      # all of the results above are in seconds, this brings them
      # back to the actual minutes integer
      num_minutes = (num_minutes / 1.minute).round

      if num_minutes.minutes >= 2.days
        I18n.t(""#{locale_key}_days"", count: (num_minutes.minutes / 1.day).round)
      else
        num_hours = (num_minutes.minutes / 1.hour).round
        if num_hours >= 2
          I18n.t(""#{locale_key}_hours"", count: num_hours)
        else
          I18n.t(""#{locale_key}_minutes"", count: num_minutes)
        end
      end
    end

    def options_for(status, opts = {})
      {
        bump: status.opening_topic?,
        post_type: Post.types[:small_action],
        silent: opts[:silent],
        action_code: status.action_code,
      }
    end

    Status =
      Struct.new(:name, :enabled) do
        %w[pinned_globally pinned autoclosed closed visible archived].each do |status|
          define_method(""#{status}?"") { name == status }
        end

        def enabled?
          enabled
        end

        def disabled?
          !enabled?
        end

        def action_code
          ""#{name}.#{enabled? ? ""enabled"" : ""disabled""}""
        end

        def locale_key
          ""topic_statuses.#{action_code.tr(""."", ""_"")}""
        end

        def opening_topic?
          (closed? || autoclosed?) && disabled?
        end

        def closing_topic?
          (closed? || autoclosed?) && enabled?
        end

        def manually_closing_topic?
          closed? && enabled?
        end

        def manually_opening_topic?
          closed? && disabled?
        end
      end
  end

```","# encoding: UTF-8
# frozen_string_literal: true

# TODO - test pinning, create_moderator_post

RSpec.describe TopicStatusUpdater do
  fab!(:user)
  fab!(:admin)

  it ""avoids notifying on automatically closed topics"" do
    # TODO: TopicStatusUpdater should suppress message bus updates from the users it ""pretends to read""
    post =
      PostCreator.create(
        user,
        raw: ""this is a test post 123 this is a test post"",
        title: ""hello world title"",
      )
    # TODO needed so counts sync up, PostCreator really should not give back out-of-date Topic
    post.topic.set_or_create_timer(TopicTimer.types[:close], ""10"")
    post.topic.reload

    TopicStatusUpdater.new(post.topic, admin).update!(""autoclosed"", true)

    expect(post.topic.posts.count).to eq(2)

    tu = TopicUser.find_by(user_id: user.id)
    expect(tu.last_read_post_number).to eq(2)
  end

  it ""adds an autoclosed message"" do
    topic = create_topic
    topic.set_or_create_timer(TopicTimer.types[:close], ""10"")

    TopicStatusUpdater.new(topic, admin).update!(""autoclosed"", true)

    last_post = topic.posts.last
    expect(last_post.post_type).to eq(Post.types[:small_action])
    expect(last_post.action_code).to eq(""autoclosed.enabled"")
    expect(last_post.raw).to eq(I18n.t(""topic_statuses.autoclosed_enabled_minutes"", count: 0))
  end

  it ""triggers a DiscourseEvent on close"" do
    topic = create_topic

    called = false
    updater = ->(_) { called = true }

    DiscourseEvent.on(:topic_closed, &updater)
    TopicStatusUpdater.new(topic, admin).update!(""closed"", true)
    DiscourseEvent.off(:topic_closed, &updater)

    expect(topic).to be_closed
    expect(called).to eq(true)
  end

  it ""adds an autoclosed message based on last post"" do
    topic = create_topic
    Fabricate(:post, topic: topic)

    topic.set_or_create_timer(
      TopicTimer.types[:close],
      nil,
      based_on_last_post: true,
      duration_minutes: 600,
    )

    TopicStatusUpdater.new(topic, admin).update!(""autoclosed"", true)

    last_post = topic.posts.last
    expect(last_post.post_type).to eq(Post.types[:small_action])
    expect(last_post.action_code).to eq(""autoclosed.enabled"")
    expect(last_post.raw).to eq(
      I18n.t(""topic_statuses.autoclosed_enabled_lastpost_hours"", count: 10),
    )
  end

  describe ""opening the topic"" do
    it ""opens the topic and deletes the timer"" do
      topic = create_topic

      topic.set_or_create_timer(TopicTimer.types[:open], 10.hours.from_now)

      TopicStatusUpdater.new(topic, admin).update!(""closed"", false)
      timer = TopicTimer.find_by(topic: topic)
      expect(timer).to eq(nil)
    end

    context ""when the category has auto close settings"" do
      let(:topic) { create_topic }
      let(:based_on_last_post) { false }

      before do
        # auto close after 3 days, topic was created a day ago
        topic.update(
          category:
            Fabricate(
              :category,
              auto_close_hours: 72,
              auto_close_based_on_last_post: based_on_last_post,
            ),
          created_at: 1.day.ago,
        )
      end

      it ""inherits auto close from the topic category, based on the created_at date of the topic"" do
        # close the topic manually, and set a timer to automatically open
        TopicStatusUpdater.new(topic, admin).update!(""closed"", true)
        topic.set_or_create_timer(TopicTimer.types[:open], 10.hours.from_now)

        # manually open the topic. it has been 1 days since creation so the
        # topic should auto-close 2 days from now, the original auto close time
        TopicStatusUpdater.new(topic, admin).update!(""closed"", false)

        timer = TopicTimer.find_by(topic: topic)
        expect(timer).not_to eq(nil)
        expect(timer.execute_at).to be_within_one_second_of(topic.created_at + 72.hours)
      end

      it ""does not inherit auto close from the topic category if it has already been X hours since topic creation"" do
        topic.category.update(auto_close_hours: 1)

        # close the topic manually, and set a timer to automatically open
        TopicStatusUpdater.new(topic, admin).update!(""closed"", true)
        topic.set_or_create_timer(TopicTimer.types[:open], 10.hours.from_now)

        # manually open the topic. it has been over a day since creation and
        # the auto close hours was 1 so a new timer should not be made
        TopicStatusUpdater.new(topic, admin).update!(""closed"", false)

        timer = TopicTimer.find_by(topic: topic)
        expect(timer).to eq(nil)
      end

      context ""when category setting is based_on_last_post"" do
        let(:based_on_last_post) { true }

        it ""inherits auto close from the topic category, using the duration because the close is based_on_last_post"" do
          # close the topic manually, and set a timer to automatically open
          TopicStatusUpdater.new(topic, admin).update!(""closed"", true)
          topic.set_or_create_timer(TopicTimer.types[:open], 10.hours.from_now)

          # manually open the topic. it should re open 3 days from now, NOT
          # 3 days from creation
          TopicStatusUpdater.new(topic, admin).update!(""closed"", false)

          timer = TopicTimer.find_by(topic: topic)
          expect(timer).not_to eq(nil)
          expect(timer.duration_minutes).to eq(72 * 60)
          expect(timer.execute_at).to be_within_one_second_of(Time.zone.now + 72.hours)
        end
      end
    end
  end

  describe ""repeat actions"" do
    shared_examples ""an action that doesn't repeat"" do
      it ""does not perform the update twice"" do
        topic = Fabricate(:topic, status_name => false)
        updated = TopicStatusUpdater.new(topic, admin).update!(status_name, true)
        expect(updated).to eq(true)
        expect(topic.public_send(""#{status_name}?"")).to eq(true)

        updated = TopicStatusUpdater.new(topic, admin).update!(status_name, true)
        expect(updated).to eq(false)
        expect(topic.posts.where(post_type: Post.types[:small_action]).count).to eq(1)

        updated = TopicStatusUpdater.new(topic, admin).update!(status_name, false)
        expect(updated).to eq(true)
        expect(topic.public_send(""#{status_name}?"")).to eq(false)

        updated = TopicStatusUpdater.new(topic, admin).update!(status_name, false)
        expect(updated).to eq(false)
        expect(topic.posts.where(post_type: Post.types[:small_action]).count).to eq(2)
      end
    end

    it_behaves_like ""an action that doesn't repeat"" do
      let(:status_name) { ""closed"" }
    end

    it_behaves_like ""an action that doesn't repeat"" do
      let(:status_name) { ""visible"" }
    end

    it_behaves_like ""an action that doesn't repeat"" do
      let(:status_name) { ""archived"" }
    end

    it ""updates autoclosed"" do
      topic = Fabricate(:topic)
      updated = TopicStatusUpdater.new(topic, admin).update!(""autoclosed"", true)
      expect(updated).to eq(true)
      expect(topic.closed?).to eq(true)

      updated = TopicStatusUpdater.new(topic, admin).update!(""autoclosed"", true)
      expect(updated).to eq(false)
      expect(topic.posts.where(post_type: Post.types[:small_action]).count).to eq(1)

      updated = TopicStatusUpdater.new(topic, admin).update!(""autoclosed"", false)
      expect(updated).to eq(true)
      expect(topic.closed?).to eq(false)

      updated = TopicStatusUpdater.new(topic, admin).update!(""autoclosed"", false)
      expect(updated).to eq(false)
      expect(topic.posts.where(post_type: Post.types[:small_action]).count).to eq(2)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class NotificationEmailer
  class EmailUser
    attr_reader :notification, :no_delay

    def initialize(notification, no_delay: false)
      @notification = notification
      @no_delay = no_delay
    end

    def group_mentioned
      enqueue :group_mentioned
    end

    def mentioned
      enqueue :user_mentioned
    end

    def posted
      enqueue :user_posted
    end

    def watching_category_or_tag
      enqueue :user_posted
    end

    def quoted
      enqueue :user_quoted
    end

    def replied
      enqueue :user_replied
    end

    def linked
      enqueue :user_linked
    end

    def watching_first_post
      enqueue :user_watching_first_post
    end

    def post_approved
      enqueue :post_approved
    end

    def private_message
      enqueue_private(:user_private_message)
    end

    def invited_to_private_message
      enqueue(:user_invited_to_private_message, private_delay)
    end

    def invited_to_topic
      enqueue(:user_invited_to_topic, private_delay)
    end

    def self.notification_params(notification, type)
      post_id = (notification.data_hash[:original_post_id] || notification.post_id).to_i
      notification_type = Notification.types[notification.notification_type]

      hash = {
        type: type.to_s,
        user_id: notification.user_id,
        notification_id: notification.id,
        notification_data_hash: notification.data_hash,
        notification_type: notification_type.to_s,
      }

      hash[:post_id] = post_id if post_id > 0 && notification_type != :post_approved
      hash
    end

    private

    EMAILABLE_POST_TYPES ||= Set.new [Post.types[:regular], Post.types[:whisper]]

    def enqueue(type, delay = default_delay)
      return if notification.user.user_option.email_level == UserOption.email_level_types[:never]
      perform_enqueue(type, delay)
    end

    def enqueue_private(type, delay = private_delay)
      if notification.user.user_option.nil?
        # this can happen if we roll back user creation really early
        # or delete user
        # bypass this pm
        return
      end

      if notification.user.user_option.email_messages_level == UserOption.email_level_types[:never]
        return
      end
      perform_enqueue(type, delay)
    end

    def perform_enqueue(type, delay)
      user = notification.user
      return unless user.active? || user.staged?
      return if SiteSetting.must_approve_users? && !user.approved? && !user.staged?
      return if user.staged? && (type == :user_linked || type == :user_quoted)

      return unless EMAILABLE_POST_TYPES.include?(post_type)

      Jobs.enqueue_in(delay, :user_email, self.class.notification_params(notification, type))
    end

    def default_delay
      no_delay ? 0 : SiteSetting.email_time_window_mins.minutes
    end

    def private_delay
      no_delay ? 0 : SiteSetting.personal_email_time_window_seconds
    end

    def post_type
      @post_type ||=
        begin
          type = notification.data_hash[""original_post_type""] if notification.data_hash
          type ||= notification.post.try(:post_type)
          type
        end
    end
  end

  def self.disable
    @disabled = true
  end

  def self.enable
    @disabled = false
  end

  def self.process_notification(notification, no_delay: false)
    return if @disabled

    email_user = EmailUser.new(notification, no_delay: no_delay)
    email_method = Notification.types[notification.notification_type]

    DiscoursePluginRegistry.email_notification_filters.each do |filter|
      return unless filter.call(notification)
    end

    email_user.public_send(email_method) if email_user.respond_to? email_method
  end
end

```","# frozen_string_literal: true

RSpec.describe NotificationEmailer do
  before do
    freeze_time
    NotificationEmailer.enable
  end

  fab!(:topic)
  fab!(:post) { Fabricate(:post, topic: topic) }

  # something is off with fabricator
  def create_notification(type, user = nil)
    user ||= Fabricate(:user)
    Notification.create(
      data: ""{\""a\"": 1}"",
      user: user,
      notification_type: Notification.types[type],
      topic: topic,
      post_number: post.post_number,
    )
  end

  shared_examples ""enqueue"" do
    it ""enqueues a job for the email"" do
      expect_enqueued_with(
        job: :user_email,
        args: NotificationEmailer::EmailUser.notification_params(notification, type),
        at: no_delay ? Time.zone.now : Time.zone.now + delay,
      ) { NotificationEmailer.process_notification(notification, no_delay: no_delay) }
    end

    context ""with an inactive user"" do
      before { notification.user.active = false }

      it ""doesn't enqueue a job"" do
        expect_not_enqueued_with(job: :user_email, args: { type: type }) do
          NotificationEmailer.process_notification(notification, no_delay: no_delay)
        end
      end

      it ""enqueues a job if the user is staged for non-linked and non-quoted types"" do
        notification.user.staged = true

        if type == :user_linked || type == :user_quoted
          expect_not_enqueued_with(job: :user_email, args: { type: type }) do
            NotificationEmailer.process_notification(notification, no_delay: no_delay)
          end
        else
          expect_enqueued_with(
            job: :user_email,
            args: NotificationEmailer::EmailUser.notification_params(notification, type),
            at: no_delay ? Time.zone.now : Time.zone.now + delay,
          ) { NotificationEmailer.process_notification(notification, no_delay: no_delay) }
        end
      end

      it ""enqueues a job if the user is staged even if site requires user approval for non-linked and non-quoted typed"" do
        notification.user.staged = true
        SiteSetting.must_approve_users = true

        if type == :user_linked || type == :user_quoted
          expect_not_enqueued_with(job: :user_email, args: { type: type }) do
            NotificationEmailer.process_notification(notification, no_delay: no_delay)
          end
        else
          expect_enqueued_with(
            job: :user_email,
            args: NotificationEmailer::EmailUser.notification_params(notification, type),
            at: no_delay ? Time.zone.now : Time.zone.now + delay,
          ) { NotificationEmailer.process_notification(notification, no_delay: no_delay) }
        end
      end
    end

    context ""with an active but unapproved user"" do
      before do
        SiteSetting.must_approve_users = true
        notification.user.approved = false
        notification.user.active = true
      end

      it ""doesn't enqueue a job"" do
        expect_not_enqueued_with(job: :user_email, args: { type: type }) do
          NotificationEmailer.process_notification(notification, no_delay: no_delay)
        end
      end
    end

    context ""with a small action"" do
      it ""doesn't enqueue a job"" do
        Post.any_instance.expects(:post_type).returns(Post.types[:small_action])

        expect_not_enqueued_with(job: :user_email, args: { type: type }) do
          NotificationEmailer.process_notification(notification, no_delay: no_delay)
        end
      end
    end
  end

  shared_examples ""enqueue_public"" do
    include_examples ""enqueue""

    it ""doesn't enqueue a job if the user has mention emails disabled"" do
      notification.user.user_option.update_columns(
        email_level: UserOption.email_level_types[:never],
      )

      expect_not_enqueued_with(job: :user_email, args: { type: type }) do
        NotificationEmailer.process_notification(notification, no_delay: no_delay)
      end
    end
  end

  shared_examples ""enqueue_private"" do
    include_examples ""enqueue""

    it ""doesn't enqueue a job if the user has private message emails disabled"" do
      notification.user.user_option.update_columns(
        email_messages_level: UserOption.email_level_types[:never],
      )

      expect_not_enqueued_with(job: :user_email, args: { type: type }) do
        NotificationEmailer.process_notification(notification)
      end
    end
  end

  [true, false].each do |no_delay|
    context ""with user_mentioned"" do
      let(:no_delay) { no_delay }
      let(:type) { :user_mentioned }
      let(:delay) { SiteSetting.email_time_window_mins.minutes }
      let!(:notification) { create_notification(:mentioned) }

      include_examples ""enqueue_public""

      it ""enqueue a delayed job for users that are online"" do
        notification.user.last_seen_at = 1.minute.ago

        expect_enqueued_with(
          job: :user_email,
          args: NotificationEmailer::EmailUser.notification_params(notification, type),
          at: Time.zone.now + delay,
        ) { NotificationEmailer.process_notification(notification) }
      end
    end

    context ""with user_replied"" do
      let(:no_delay) { no_delay }
      let(:type) { :user_replied }
      let(:delay) { SiteSetting.email_time_window_mins.minutes }
      let!(:notification) { create_notification(:replied) }

      include_examples ""enqueue_public""
    end

    context ""with user_quoted"" do
      let(:no_delay) { no_delay }
      let(:type) { :user_quoted }
      let(:delay) { SiteSetting.email_time_window_mins.minutes }
      let!(:notification) { create_notification(:quoted) }

      include_examples ""enqueue_public""
    end

    context ""with user_linked"" do
      let(:no_delay) { no_delay }
      let(:type) { :user_linked }
      let(:delay) { SiteSetting.email_time_window_mins.minutes }
      let!(:notification) { create_notification(:linked) }

      include_examples ""enqueue_public""
    end

    context ""with user_posted"" do
      let(:no_delay) { no_delay }
      let(:type) { :user_posted }
      let(:delay) { SiteSetting.email_time_window_mins.minutes }
      let!(:notification) { create_notification(:posted) }

      include_examples ""enqueue_public""
    end

    context ""with user_watching_category_or_tag"" do
      let(:no_delay) { no_delay }
      let(:type) { :user_posted }
      let(:delay) { SiteSetting.email_time_window_mins.minutes }
      let!(:notification) { create_notification(:watching_category_or_tag) }

      include_examples ""enqueue_public""
    end

    context ""with user_private_message"" do
      let(:no_delay) { no_delay }
      let(:type) { :user_private_message }
      let(:delay) { SiteSetting.personal_email_time_window_seconds }
      let!(:notification) { create_notification(:private_message) }

      include_examples ""enqueue_private""

      it ""doesn't enqueue a job for a small action"" do
        notification.data_hash[""original_post_type""] = Post.types[:small_action]

        expect_not_enqueued_with(job: :user_email, args: { type: type }) do
          NotificationEmailer.process_notification(notification)
        end
      end
    end

    context ""with user_invited_to_private_message"" do
      let(:no_delay) { no_delay }
      let(:type) { :user_invited_to_private_message }
      let(:delay) { SiteSetting.personal_email_time_window_seconds }
      let!(:notification) { create_notification(:invited_to_private_message) }

      include_examples ""enqueue_public""
    end

    context ""with user_invited_to_topic"" do
      let(:no_delay) { no_delay }
      let(:type) { :user_invited_to_topic }
      let(:delay) { SiteSetting.personal_email_time_window_seconds }
      let!(:notification) { create_notification(:invited_to_topic) }

      include_examples ""enqueue_public""
    end

    context ""when watching the first post"" do
      let(:no_delay) { no_delay }
      let(:type) { :user_watching_first_post }
      let(:delay) { SiteSetting.email_time_window_mins.minutes }
      let!(:notification) { create_notification(:watching_first_post) }

      include_examples ""enqueue_public""
    end

    context ""with post_approved"" do
      let(:no_delay) { no_delay }
      let(:type) { :post_approved }
      let(:delay) { SiteSetting.email_time_window_mins.minutes }
      let!(:notification) { create_notification(:post_approved) }

      include_examples ""enqueue_public""
    end
  end

  it ""has translations for each sendable notification type"" do
    notification = create_notification(:mentioned)
    email_user = NotificationEmailer::EmailUser.new(notification, no_delay: true)
    subkeys = %w[title subject_template text_body_template]

    # some notification types need special handling
    replace_keys = {
      ""post_approved"" => [""post_approved""],
      ""private_message"" => [""user_posted""],
      ""invited_to_private_message"" => %w[
        user_invited_to_private_message_pm
        user_invited_to_private_message_pm_group
        user_invited_to_private_message_pm_staged
      ],
    }

    Notification.types.keys.each do |notification_type|
      if email_user.respond_to?(notification_type)
        type_keys = replace_keys[notification_type.to_s] || [""user_#{notification_type}""]

        type_keys.each do |type_key|
          subkeys.each do |subkey|
            key = ""user_notifications.#{type_key}.#{subkey}""
            expect(I18n.exists?(key)).to eq(true), ""missing translation: #{key}""
          end
        end
      end
    end
  end

  describe ""with plugin-added email_notification_filters"" do
    let!(:plugin) { Plugin::Instance.new }
    let!(:notification) { create_notification(:quoted) }
    let(:no_delay) { true }
    let(:type) { :user_quoted }

    after { DiscoursePluginRegistry.reset! }

    it ""sends email when all filters return true"" do
      plugin.register_email_notification_filter { |_| true }
      plugin.register_email_notification_filter { |_| true }

      expect_enqueued_with(job: :user_email, args: { type: type }) do
        NotificationEmailer.process_notification(notification, no_delay: no_delay)
      end
    end

    it ""doesn't send email when all one filter returns false"" do
      plugin.register_email_notification_filter { |_| true }
      plugin.register_email_notification_filter { |_| false }

      expect_not_enqueued_with(job: :user_email, args: { type: type }) do
        NotificationEmailer.process_notification(notification, no_delay: no_delay)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class WordWatcher
  REPLACEMENT_LETTER ||= CGI.unescape_html(""&#9632;"")
  CACHE_VERSION ||= 3

  def initialize(raw)
    @raw = raw
  end

  @cache_enabled = true

  def self.disable_cache
    @cache_enabled = false
  end

  def self.cache_enabled?
    @cache_enabled
  end

  def self.cache_key(action)
    ""watched-words-list:v#{CACHE_VERSION}:#{action}""
  end

  def self.clear_cache!
    WatchedWord.actions.each { |action, _| Discourse.cache.delete(cache_key(action)) }
  end

  def self.words_for_action(action)
    WatchedWord
      .where(action: WatchedWord.actions[action.to_sym])
      .limit(WatchedWord::MAX_WORDS_PER_ACTION)
      .order(:id)
      .pluck(:word, :replacement, :case_sensitive)
      .to_h do |w, r, c|
        [
          word_to_regexp(w, match_word: false),
          { word: w, replacement: r, case_sensitive: c }.compact,
        ]
      end
  end

  def self.words_for_action_exist?(action)
    WatchedWord.where(action: WatchedWord.actions[action.to_sym]).exists?
  end

  def self.cached_words_for_action(action)
    if cache_enabled?
      Discourse
        .cache
        .fetch(cache_key(action), expires_in: 1.day) { words_for_action(action).presence }
    else
      words_for_action(action).presence
    end
  end

  def self.regexps_for_action(action, engine: :ruby)
    cached_words_for_action(action)&.to_h do |_, attrs|
      [word_to_regexp(attrs[:word], engine: engine), attrs]
    end
  end

  # This regexp is run in miniracer, and the client JS app
  # Make sure it is compatible with major browsers when changing
  # hint: non-chrome browsers do not support 'lookbehind'
  def self.compiled_regexps_for_action(action, engine: :ruby, raise_errors: false)
    words = cached_words_for_action(action)
    return [] if words.blank?

    words
      .values
      .group_by { |attrs| attrs[:case_sensitive] ? :case_sensitive : :case_insensitive }
      .map do |group_key, attrs_list|
        words = attrs_list.map { |attrs| attrs[:word] }

        # Compile all watched words into a single regular expression
        regexp =
          words
            .map do |word|
              r = word_to_regexp(word, match_word: SiteSetting.watched_words_regular_expressions?)
              begin
                r if Regexp.new(r)
              rescue RegexpError
                raise if raise_errors
              end
            end
            .select { |r| r.present? }
            .join(""|"")

        # Add word boundaries to the regexp for regular watched words
        regexp =
          match_word_regexp(
            regexp,
            engine: engine,
          ) if !SiteSetting.watched_words_regular_expressions?

        # Add case insensitive flag if needed
        Regexp.new(regexp, group_key == :case_sensitive ? nil : Regexp::IGNORECASE)
      end
  end

  def self.serialized_regexps_for_action(action, engine: :ruby)
    compiled_regexps_for_action(action, engine: engine).map do |r|
      { r.source => { case_sensitive: !r.casefold? } }
    end
  end

  def self.word_to_regexp(word, engine: :ruby, match_word: true)
    if SiteSetting.watched_words_regular_expressions?
      regexp = word
      regexp = ""(#{regexp})"" if match_word
      regexp
    else
      # Convert word to regex by escaping special characters in a regexp.
      # Avoid using Regexp.escape because it escapes more characters than
      # it should (for example, whitespaces, dashes, etc)
      regexp = word.gsub(/([.*+?^${}()|\[\]\\])/, '\\\\\1')

      # Convert wildcards to regexp
      regexp = regexp.gsub(""\\*"", '\S*')

      regexp = match_word_regexp(regexp, engine: engine) if match_word
      regexp
    end
  end

  def self.censor(html)
    regexps = compiled_regexps_for_action(:censor)
    return html if regexps.blank?

    doc = Nokogiri::HTML5.fragment(html)
    doc.traverse do |node|
      regexps.each do |regexp|
        node.content = censor_text_with_regexp(node.content, regexp) if node.text?
      end
    end

    doc.to_s
  end

  def self.censor_text(text)
    return text if text.blank?

    regexps = compiled_regexps_for_action(:censor)
    return text if regexps.blank?

    regexps.inject(text) { |txt, regexp| censor_text_with_regexp(txt, regexp) }
  end

  def self.replace_text(text)
    return text if text.blank?
    replace(text, :replace)
  end

  def self.replace_link(text)
    return text if text.blank?
    replace(text, :link)
  end

  def self.apply_to_text(text)
    text = censor_text(text)
    text = replace_text(text)
    text = replace_link(text)
    text
  end

  def requires_approval?
    word_matches_for_action?(:require_approval)
  end

  def should_flag?
    word_matches_for_action?(:flag)
  end

  def should_block?
    word_matches_for_action?(:block, all_matches: true)
  end

  def should_silence?
    word_matches_for_action?(:silence)
  end

  def word_matches_for_action?(action, all_matches: false)
    regexps = self.class.compiled_regexps_for_action(action)
    return if regexps.blank?

    match_list = []
    regexps.each do |regexp|
      match = regexp.match(@raw)

      if !all_matches
        return match if match
        next
      end

      next if !match

      if SiteSetting.watched_words_regular_expressions?
        set = Set.new
        @raw
          .scan(regexp)
          .each do |m|
            if Array === m
              set.add(m.find(&:present?))
            elsif String === m
              set.add(m)
            end
          end

        matches = set.to_a
      else
        matches = @raw.scan(regexp)
        matches.flatten!
      end

      match_list.concat(matches)
    end

    return if match_list.blank?

    match_list.compact!
    match_list.uniq!
    match_list.sort!
    match_list
  end

  def word_matches?(word, case_sensitive: false)
    options = case_sensitive ? nil : Regexp::IGNORECASE
    Regexp.new(WordWatcher.word_to_regexp(word), options).match?(@raw)
  end

  def self.replace_text_with_regexp(text, regexp, replacement)
    text.gsub(regexp) do |match|
      prefix = """"
      # match may be prefixed with a non-word character from the non-capturing group
      # Ensure this isn't replaced if watched words regular expression is disabled.
      if !SiteSetting.watched_words_regular_expressions? && (match[0] =~ /\W/) != nil
        prefix = ""#{match[0]}""
      end

      ""#{prefix}#{replacement}""
    end
  end

  private_class_method :replace_text_with_regexp

  def self.censor_text_with_regexp(text, regexp)
    text.gsub(regexp) do |match|
      # the regex captures leading whitespaces
      padding = match.size - match.lstrip.size
      if padding > 0
        match[0..padding - 1] + REPLACEMENT_LETTER * (match.size - padding)
      else
        REPLACEMENT_LETTER * match.size
      end
    end
  end

  private_class_method :censor_text_with_regexp

  # Returns a regexp that transforms a regular expression into a regular
  # expression that matches a whole word.
  def self.match_word_regexp(regexp, engine: :ruby)
    if engine == :js
      ""(?:\\P{L}|^)(#{regexp})(?=\\P{L}|$)""
    elsif engine == :ruby
      ""(?:[^[:word:]]|^)(#{regexp})(?=[^[:word:]]|$)""
    else
      raise ""unknown regexp engine: #{engine}""
    end
  end

  private_class_method :match_word_regexp

  def self.replace(text, watch_word_type)
    regexps_for_action(watch_word_type)
      .to_a
      .reduce(text) do |t, (word_regexp, attrs)|
        case_flag = attrs[:case_sensitive] ? nil : Regexp::IGNORECASE
        replace_text_with_regexp(t, Regexp.new(word_regexp, case_flag), attrs[:replacement])
      end
  end

  private_class_method :replace
end

```","# frozen_string_literal: true

RSpec.describe WordWatcher do
  let(:raw) { <<~RAW.strip }
      Do you like liquorice?


      I really like them. One could even say that I am *addicted* to liquorice. And if
      you can mix it up with some anise, then I'm in heaven ;)
    RAW

  after { Discourse.redis.flushdb }

  describe "".words_for_action"" do
    it ""returns words with metadata including case sensitivity flag"" do
      Fabricate(:watched_word, action: WatchedWord.actions[:censor])
      word1 = Fabricate(:watched_word, action: WatchedWord.actions[:block]).word
      word2 =
        Fabricate(:watched_word, action: WatchedWord.actions[:block], case_sensitive: true).word

      expect(described_class.words_for_action(:block)).to include(
        word1 => {
          case_sensitive: false,
          word: word1,
        },
        word2 => {
          case_sensitive: true,
          word: word2,
        },
      )
    end

    it ""returns word with metadata including replacement if word has replacement"" do
      word =
        Fabricate(
          :watched_word,
          action: WatchedWord.actions[:link],
          replacement: ""http://test.localhost/"",
        ).word

      expect(described_class.words_for_action(:link)).to include(
        word => {
          case_sensitive: false,
          replacement: ""http://test.localhost/"",
          word: word,
        },
      )
    end

    it ""returns an empty hash when no words are present"" do
      expect(described_class.words_for_action(:tag)).to eq({})
    end
  end

  describe "".compiled_regexps_for_action"" do
    let!(:word1) { Fabricate(:watched_word, action: WatchedWord.actions[:block]).word }
    let!(:word2) { Fabricate(:watched_word, action: WatchedWord.actions[:block]).word }
    let!(:word3) do
      Fabricate(:watched_word, action: WatchedWord.actions[:block], case_sensitive: true).word
    end
    let!(:word4) do
      Fabricate(:watched_word, action: WatchedWord.actions[:block], case_sensitive: true).word
    end

    context ""when watched_words_regular_expressions = true"" do
      it ""returns the proper regexp"" do
        SiteSetting.watched_words_regular_expressions = true
        regexps = described_class.compiled_regexps_for_action(:block)

        expect(regexps).to be_an(Array)
        expect(regexps.map(&:inspect)).to contain_exactly(
          ""/(#{word1})|(#{word2})/i"",
          ""/(#{word3})|(#{word4})/"",
        )
      end
    end

    context ""when watched_words_regular_expressions = false"" do
      it ""returns the proper regexp"" do
        SiteSetting.watched_words_regular_expressions = false
        regexps = described_class.compiled_regexps_for_action(:block)

        expect(regexps).to be_an(Array)
        expect(regexps.map(&:inspect)).to contain_exactly(
          ""/(?:[^[:word:]]|^)(#{word1}|#{word2})(?=[^[:word:]]|$)/i"",
          ""/(?:[^[:word:]]|^)(#{word3}|#{word4})(?=[^[:word:]]|$)/"",
        )
      end

      it ""is empty for an action without watched words"" do
        regexps = described_class.compiled_regexps_for_action(:censor)

        expect(regexps).to be_an(Array)
        expect(regexps).to be_empty
      end
    end

    context ""when regular expression is invalid"" do
      before do
        SiteSetting.watched_words_regular_expressions = true
        Fabricate(:watched_word, word: ""Test[\S*"", action: WatchedWord.actions[:block])
      end

      it ""does not raise an exception by default"" do
        expect { described_class.compiled_regexps_for_action(:block) }.not_to raise_error
        expect(described_class.compiled_regexps_for_action(:block)).to contain_exactly(
          /(#{word1})|(#{word2})/i,
          /(#{word3})|(#{word4})/,
        )
      end

      it ""raises an exception with raise_errors set to true"" do
        expect {
          described_class.compiled_regexps_for_action(:block, raise_errors: true)
        }.to raise_error(RegexpError)
      end
    end
  end

  describe ""#word_matches_for_action?"" do
    it ""is falsey when there are no watched words"" do
      expect(described_class.new(raw).word_matches_for_action?(:require_approval)).to be_falsey
    end

    context ""with watched words"" do
      fab!(:anise) do
        Fabricate(:watched_word, word: ""anise"", action: WatchedWord.actions[:require_approval])
      end

      it ""is falsey without a match"" do
        expect(
          described_class.new(""No liquorice for me, thanks..."").word_matches_for_action?(
            :require_approval,
          ),
        ).to be_falsey
      end

      it ""is returns matched words if there's a match"" do
        matches = described_class.new(raw).word_matches_for_action?(:require_approval)
        expect(matches).to be_truthy
        expect(matches[1]).to eq(anise.word)
      end

      it ""finds at start of string"" do
        matches =
          described_class.new(""#{anise.word} is garbage"").word_matches_for_action?(
            :require_approval,
          )
        expect(matches[1]).to eq(anise.word)
      end

      it ""finds at end of string"" do
        matches =
          described_class.new(""who likes #{anise.word}"").word_matches_for_action?(:require_approval)
        expect(matches[1]).to eq(anise.word)
      end

      it ""finds non-letters in place of letters"" do
        Fabricate(:watched_word, word: ""co(onut"", action: WatchedWord.actions[:require_approval])

        matches =
          described_class.new(""This co(onut is delicious."").word_matches_for_action?(
            :require_approval,
          )
        expect(matches[1]).to eq(""co(onut"")
      end

      it ""handles * for wildcards"" do
        Fabricate(:watched_word, word: ""a**le*"", action: WatchedWord.actions[:require_approval])

        matches =
          described_class.new(""I acknowledge you."").word_matches_for_action?(:require_approval)
        expect(matches[1]).to eq(""acknowledge"")
      end

      it ""handles word boundary"" do
        Fabricate(:watched_word, word: ""love"", action: WatchedWord.actions[:require_approval])
        expect(
          described_class.new(""I Love, bananas."").word_matches_for_action?(:require_approval)[1],
        ).to eq(""Love"")
        expect(
          described_class.new(""I LOVE; apples."").word_matches_for_action?(:require_approval)[1],
        ).to eq(""LOVE"")
        expect(
          described_class.new(""love: is a thing."").word_matches_for_action?(:require_approval)[1],
        ).to eq(""love"")
        expect(
          described_class.new(""I love. oranges"").word_matches_for_action?(:require_approval)[1],
        ).to eq(""love"")
        expect(
          described_class.new(""I :love. pineapples"").word_matches_for_action?(:require_approval)[1],
        ).to eq(""love"")
        expect(
          described_class.new(""peace ,love and understanding."").word_matches_for_action?(
            :require_approval,
          )[
            1
          ],
        ).to eq(""love"")
      end

      context ""when there are multiple matches"" do
        context ""with non regexp words"" do
          it ""lists all matching words"" do
            %w[bananas hate hates].each do |word|
              Fabricate(:watched_word, word: word, action: WatchedWord.actions[:block])
            end

            matches =
              described_class.new(""I hate bananas"").word_matches_for_action?(
                :block,
                all_matches: true,
              )
            expect(matches).to contain_exactly(""hate"", ""bananas"")

            matches =
              described_class.new(""She hates bananas too"").word_matches_for_action?(
                :block,
                all_matches: true,
              )
            expect(matches).to contain_exactly(""hates"", ""bananas"")
          end
        end

        context ""with regexp words"" do
          before { SiteSetting.watched_words_regular_expressions = true }

          it ""lists all matching patterns"" do
            Fabricate(:watched_word, word: ""(pine)?apples"", action: WatchedWord.actions[:block])
            Fabricate(
              :watched_word,
              word: ""((move|store)(d)?)|((watch|listen)(ed|ing)?)"",
              action: WatchedWord.actions[:block],
            )

            matches =
              described_class.new(""pine pineapples apples"").word_matches_for_action?(
                :block,
                all_matches: true,
              )
            expect(matches).to contain_exactly(""pineapples"", ""apples"")

            matches =
              described_class.new(
                ""go watched watch ed ing move d moveed moved moving"",
              ).word_matches_for_action?(:block, all_matches: true)
            expect(matches).to contain_exactly(*%w[watched watch move moved])
          end
        end
      end

      context ""when word is an emoji"" do
        it ""handles emoji"" do
          Fabricate(:watched_word, word: "":joy:"", action: WatchedWord.actions[:require_approval])

          matches =
            described_class.new(""Lots of emojis here :joy:"").word_matches_for_action?(
              :require_approval,
            )
          expect(matches[1]).to eq("":joy:"")
        end

        it ""handles unicode emoji"" do
          Fabricate(:watched_word, word: ""🎃"", action: WatchedWord.actions[:require_approval])

          matches =
            described_class.new(""Halloween party! 🎃"").word_matches_for_action?(:require_approval)
          expect(matches[1]).to eq(""🎃"")
        end

        it ""handles emoji skin tone"" do
          Fabricate(
            :watched_word,
            word: "":woman:t5:"",
            action: WatchedWord.actions[:require_approval],
          )

          matches =
            described_class.new(""To Infinity and beyond! 🚀 :woman:t5:"").word_matches_for_action?(
              :require_approval,
            )
          expect(matches[1]).to eq("":woman:t5:"")
        end
      end

      context ""when word is a regular expression"" do
        before { SiteSetting.watched_words_regular_expressions = true }

        it ""supports regular expressions on word boundaries"" do
          Fabricate(:watched_word, word: /\btest\b/, action: WatchedWord.actions[:block])

          matches = described_class.new(""this is not a test."").word_matches_for_action?(:block)
          expect(matches[0]).to eq(""test"")
        end

        it ""supports regular expressions as a site setting"" do
          Fabricate(
            :watched_word,
            word: /tro[uo]+t/,
            action: WatchedWord.actions[:require_approval],
          )

          matches =
            described_class.new(""Evil Trout is cool"").word_matches_for_action?(:require_approval)
          expect(matches[0]).to eq(""Trout"")

          matches =
            described_class.new(""Evil Troot is cool"").word_matches_for_action?(:require_approval)
          expect(matches[0]).to eq(""Troot"")

          matches = described_class.new(""trooooooooot"").word_matches_for_action?(:require_approval)
          expect(matches[0]).to eq(""trooooooooot"")
        end

        it ""support uppercase"" do
          Fabricate(:watched_word, word: /a\S+ce/, action: WatchedWord.actions[:require_approval])

          matches = described_class.new(""Amazing place"").word_matches_for_action?(:require_approval)
          expect(matches).to be_nil

          matches =
            described_class.new(""Amazing applesauce"").word_matches_for_action?(:require_approval)
          expect(matches[0]).to eq(""applesauce"")

          matches =
            described_class.new(""Amazing AppleSauce"").word_matches_for_action?(:require_approval)
          expect(matches[0]).to eq(""AppleSauce"")
        end
      end

      context ""when case sensitive words are present"" do
        before do
          Fabricate(
            :watched_word,
            word: ""Discourse"",
            action: WatchedWord.actions[:block],
            case_sensitive: true,
          )
        end

        context ""when watched_words_regular_expressions = true"" do
          it ""respects case sensitivity flag in matching words"" do
            SiteSetting.watched_words_regular_expressions = true
            Fabricate(:watched_word, word: ""p(rivate|ublic)"", action: WatchedWord.actions[:block])

            matches =
              described_class.new(
                ""PUBLIC: Discourse is great for public discourse"",
              ).word_matches_for_action?(:block, all_matches: true)
            expect(matches).to contain_exactly(""PUBLIC"", ""Discourse"", ""public"")
          end
        end

        context ""when watched_words_regular_expressions = false"" do
          it ""repects case sensitivity flag in matching"" do
            SiteSetting.watched_words_regular_expressions = false
            Fabricate(:watched_word, word: ""private"", action: WatchedWord.actions[:block])

            matches =
              described_class.new(
                ""PRIVATE: Discourse is also great private discourse"",
              ).word_matches_for_action?(:block, all_matches: true)

            expect(matches).to contain_exactly(""PRIVATE"", ""Discourse"", ""private"")
          end
        end
      end
    end
  end

  describe ""word replacement"" do
    fab!(:censored_word) do
      Fabricate(:watched_word, word: ""censored"", action: WatchedWord.actions[:censor])
    end
    fab!(:replaced_word) do
      Fabricate(
        :watched_word,
        word: ""to replace"",
        replacement: ""replaced"",
        action: WatchedWord.actions[:replace],
      )
    end
    fab!(:link_word) do
      Fabricate(
        :watched_word,
        word: ""https://notdiscourse.org"",
        replacement: ""https://discourse.org"",
        action: WatchedWord.actions[:link],
      )
    end

    it ""censors text"" do
      expect(described_class.censor_text(""a censored word"")).to eq(
        ""a #{described_class::REPLACEMENT_LETTER * 8} word"",
      )
    end

    it ""replaces text"" do
      expect(described_class.replace_text(""a word to replace meow"")).to eq(""a word replaced meow"")
    end

    it ""replaces links"" do
      expect(described_class.replace_link(""please visit https://notdiscourse.org meow"")).to eq(
        ""please visit https://discourse.org meow"",
      )
    end

    describe "".apply_to_text"" do
      it ""replaces all types of words"" do
        text = ""hello censored world to replace https://notdiscourse.org""
        expected =
          ""hello #{described_class::REPLACEMENT_LETTER * 8} world replaced https://discourse.org""
        expect(described_class.apply_to_text(text)).to eq(expected)
      end

      context ""when watched_words_regular_expressions = true"" do
        it ""replaces captured non-word prefix"" do
          SiteSetting.watched_words_regular_expressions = true
          Fabricate(
            :watched_word,
            word: ""\\Wplaceholder"",
            replacement: ""replacement"",
            action: WatchedWord.actions[:replace],
          )

          text = ""is \tplaceholder in https://notdiscourse.org""
          expected = ""is replacement in https://discourse.org""
          expect(described_class.apply_to_text(text)).to eq(expected)
        end
      end

      context ""when watched_words_regular_expressions = false"" do
        it ""maintains non-word character prefix"" do
          SiteSetting.watched_words_regular_expressions = false

          text = ""to replace and\thttps://notdiscourse.org""
          expected = ""replaced and\thttps://discourse.org""
          expect(described_class.apply_to_text(text)).to eq(expected)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class UsernameCheckerService
  def initialize(allow_reserved_username: false)
    @allow_reserved_username = allow_reserved_username
  end

  def check_username(username, email)
    if username && username.length > 0
      validator = UsernameValidator.new(username)
      if !validator.valid_format?
        { errors: validator.errors }
      else
        check_username_availability(username, email)
      end
    end
  end

  def check_username_availability(username, email)
    available =
      User.username_available?(username, email, allow_reserved_username: @allow_reserved_username)

    if available
      { available: true, is_developer: is_developer?(email) }
    else
      { available: false, suggestion: UserNameSuggester.suggest(username) }
    end
  end

  def is_developer?(value)
    Rails.configuration.respond_to?(:developer_emails) &&
      Rails.configuration.developer_emails.include?(value)
  end

  def self.is_developer?(email)
    UsernameCheckerService.new.is_developer?(email)
  end
end

```","# frozen_string_literal: true

RSpec.describe UsernameCheckerService do
  describe ""#check_username"" do
    before do
      @service = UsernameCheckerService.new
      @nil_email = nil
      @email = ""vincentvega@example.com""
    end

    context ""when username is invalid"" do
      it ""rejects too short usernames"" do
        result = @service.check_username(""a"", @nil_email)
        expect(result).to have_key(:errors)
      end

      it ""rejects too long usernames"" do
        result = @service.check_username(""a123456789b123456789c123456789"", @nil_email)
        expect(result).to have_key(:errors)
      end

      it ""rejects usernames with invalid characters"" do
        result = @service.check_username(""vincent-"", @nil_email)
        expect(result).to have_key(:errors)
      end

      it ""rejects usernames that do not start with an alphanumeric character"" do
        result = @service.check_username("".vincent"", @nil_email)
        expect(result).to have_key(:errors)
      end

      context ""with reserved usernames"" do
        before { SiteSetting.reserved_usernames = ""test|donkey"" }

        it ""rejects usernames that are reserved"" do
          result = @service.check_username(""test"", @nil_email)
          expect(result[:available]).to eq(false)
        end

        it ""allows reserved username checker to be skipped"" do
          @service = UsernameCheckerService.new(allow_reserved_username: true)
          result = @service.check_username(""test"", @nil_email)
          expect(result[:available]).to eq(true)
        end
      end
    end

    it ""username not available locally"" do
      User.stubs(:username_available?).returns(false)
      UserNameSuggester.stubs(:suggest).returns(""einar-j"")
      result = @service.check_username(""vincent"", @nil_email)
      expect(result[:available]).to eq(false)
      expect(result[:suggestion]).to eq(""einar-j"")
    end

    it ""username available locally"" do
      User.stubs(:username_available?).returns(true)
      result = @service.check_username(""vincent"", @nil_email)
      expect(result[:available]).to eq(true)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class HashtagAutocompleteService
  HASHTAGS_PER_REQUEST = 20
  SEARCH_MAX_LIMIT = 50
  DEFAULT_DATA_SOURCES = [CategoryHashtagDataSource, TagHashtagDataSource]
  DEFAULT_CONTEXTUAL_TYPE_PRIORITIES = [
    { type: ""category"", context: ""topic-composer"", priority: 100 },
    { type: ""tag"", context: ""topic-composer"", priority: 50 },
  ]

  def self.search_conditions
    @search_conditions ||= Enum.new(contains: 0, starts_with: 1)
  end

  attr_reader :guardian

  # NOTE: This is not meant to be called directly; use `enabled_data_sources`
  # or the individual data_source_X methods instead.
  def self.data_sources
    # Category and Tag data sources are in core and always should be
    # included for searches and lookups.
    Set.new(DEFAULT_DATA_SOURCES | DiscoursePluginRegistry.hashtag_autocomplete_data_sources)
  end

  def self.contextual_type_priorities
    # Category and Tag type priorities for the composer are default and
    # always are included.
    Set.new(
      DEFAULT_CONTEXTUAL_TYPE_PRIORITIES |
        DiscoursePluginRegistry.hashtag_autocomplete_contextual_type_priorities,
    )
  end

  def self.enabled_data_sources
    self.data_sources.filter(&:enabled?)
  end

  def self.data_source_types
    self.enabled_data_sources.map(&:type)
  end

  def self.data_source_icon_map
    self.enabled_data_sources.map { |ds| [ds.type, ds.icon] }.to_h
  end

  def self.data_source_from_type(type)
    self.enabled_data_sources.find { |ds| ds.type == type }
  end

  def self.find_priorities_for_context(context)
    contextual_type_priorities.select { |ctp| ctp[:context] == context }
  end

  def self.unique_contexts
    contextual_type_priorities.map { |ctp| ctp[:context] }.uniq
  end

  def self.ordered_types_for_context(context)
    find_priorities_for_context(context)
      .sort_by { |ctp| -ctp[:priority] }
      .map { |ctp| ctp[:type] }
      .reject { |type| data_source_types.exclude?(type) }
  end

  def self.contexts_with_ordered_types
    Hash[unique_contexts.map { |context| [context, ordered_types_for_context(context)] }]
  end

  class HashtagItem
    # The text to display in the UI autocomplete menu for the item.
    attr_accessor :text

    # Some items may want to display extra text in the UI styled differently, e.g. tag topic counts.
    attr_accessor :secondary_text

    # The description text to display in the UI autocomplete menu on hover.
    # This will be things like e.g. category description.
    attr_accessor :description

    # Canonical slug for the item. Different from the ref, which can
    # have the type as a suffix to distinguish between conflicts.
    attr_accessor :slug

    # The icon to display in the UI autocomplete menu for the item.
    attr_accessor :icon

    # Distinguishes between different entities e.g. tag, category.
    attr_accessor :type

    # Inserted into the textbox when an autocomplete item is selected,
    # and must be unique so it can be used for lookups via the #lookup
    # method above.
    attr_accessor :ref

    # The relative URL for the resource that is represented by the autocomplete
    # item, used for the cooked hashtags, e.g. /c/2/staff
    attr_accessor :relative_url

    # The ID of the resource that is represented by the autocomplete item,
    # e.g. category.id, tag.id
    attr_accessor :id

    def initialize(params = {})
      @relative_url = params[:relative_url]
      @text = params[:text]
      @description = params[:description]
      @icon = params[:icon]
      @type = params[:type]
      @ref = params[:ref]
      @slug = params[:slug]
      @id = params[:id]
    end

    def to_h
      {
        relative_url: self.relative_url,
        text: self.text,
        description: self.description,
        icon: self.icon,
        type: self.type,
        ref: self.ref,
        slug: self.slug,
        id: self.id,
      }
    end
  end

  def initialize(guardian)
    @guardian = guardian
  end

  ##
  # Finds resources of the provided types by their exact slugs, unlike
  # search which can search partial names, slugs, etc. Used for cooking
  # fully formed #hashtags in the markdown pipeline. The @guardian handles
  # permissions around which results should be returned here.
  #
  # @param {Array} slugs The fully formed slugs to look up, which can have
  #                      ::type suffixes attached as well (e.g. ::category),
  #                      and in the case of categories can have parent:child
  #                      relationships.
  # @param {Array} types_in_priority_order The resource types we are looking up
  #                                        and the priority order in which we should
  #                                        match them if they do not have type suffixes.
  # @returns {Hash} A hash with the types as keys and an array of HashtagItem that
  #                 matches the provided slugs.
  def lookup(slugs, types_in_priority_order)
    raise Discourse::InvalidParameters.new(:slugs) if !slugs.is_a?(Array)
    raise Discourse::InvalidParameters.new(:order) if !types_in_priority_order.is_a?(Array)

    types_in_priority_order =
      types_in_priority_order.select do |type|
        HashtagAutocompleteService.data_source_types.include?(type)
      end
    lookup_results = Hash[types_in_priority_order.collect { |type| [type.to_sym, []] }]
    limited_slugs = slugs[0..HashtagAutocompleteService::HASHTAGS_PER_REQUEST]

    slugs_without_suffixes =
      limited_slugs.reject do |slug|
        HashtagAutocompleteService.data_source_types.any? { |type| slug.ends_with?(""::#{type}"") }
      end
    slugs_with_suffixes = (limited_slugs - slugs_without_suffixes)

    # For all the slugs without a type suffix, we need to lookup in order, falling
    # back to the next type if no results are returned for a slug for the current
    # type. This way slugs without suffix make sense in context, e.g. in the topic
    # composer we want a slug without a suffix to be a category first, tag second.
    if slugs_without_suffixes.any?
      types_in_priority_order.each do |type|
        # We do not want to continue fallback if there are conflicting slugs where
        # one has a type and one does not, this may result in duplication. An
        # example:
        #
        # A category with slug `management` is not found because of permissions
        # and we also have a slug with suffix in the form of `management::tag`.
        # There is a tag that exists with the `management` slug. The tag should
        # not be found here but rather in the next lookup since it's got a more
        # specific lookup with the type.
        slugs_to_lookup =
          slugs_without_suffixes.reject { |slug| slugs_with_suffixes.include?(""#{slug}::#{type}"") }
        found_from_slugs = execute_lookup!(lookup_results, type, guardian, slugs_to_lookup)

        slugs_without_suffixes = slugs_without_suffixes - found_from_slugs.map(&:ref)
        break if slugs_without_suffixes.empty?
      end
    end

    # We then look up the remaining slugs based on their type suffix, stripping out
    # the type suffix first since it will not match the actual slug.
    if slugs_with_suffixes.any?
      types_in_priority_order.each do |type|
        slugs_for_type =
          slugs_with_suffixes
            .select { |slug| slug.ends_with?(""::#{type}"") }
            .map { |slug| slug.gsub(""::#{type}"", """") }
        next if slugs_for_type.empty?
        execute_lookup!(lookup_results, type, guardian, slugs_for_type)

        # Make sure the refs are the same going out as they were going in.
        lookup_results[type.to_sym].each do |item|
          item.ref = ""#{item.ref}::#{type}"" if slugs_with_suffixes.include?(""#{item.ref}::#{type}"")
        end
      end
    end

    lookup_results
  end

  ##
  # Searches registered hashtag data sources using the provided term (data
  # sources determine what is actually searched) and prioritises the results
  # based on types_in_priority_order and the limit. For example, if 5 categories
  # were returned for the term and the limit was 5, we would not even bother
  # searching tags. The @guardian handles permissions around which results should
  # be returned here.
  #
  # Items which have a slug that exactly matches the search term via lookup will be found
  # first and floated to the top of the results, and still be ordered by type.
  #
  # @param {String} term Search term, from the UI generally where the user is typing #has...
  # @param {Array} types_in_priority_order The resource types we are searching for
  #                                        and the priority order in which we should
  #                                        return them.
  # @param {Integer} limit The maximum number of search results to return, we don't
  #                        bother searching subsequent types if the first types in
  #                        the array already reach the limit.
  # @returns {Array} The results as HashtagItems
  def search(
    term,
    types_in_priority_order,
    limit: SiteSetting.experimental_hashtag_search_result_limit
  )
    raise Discourse::InvalidParameters.new(:order) if !types_in_priority_order.is_a?(Array)
    limit = [limit, SEARCH_MAX_LIMIT].min
    types_in_priority_order =
      types_in_priority_order.select do |type|
        HashtagAutocompleteService.data_source_types.include?(type)
      end

    return search_without_term(types_in_priority_order, limit) if term.blank?

    limited_results = []
    top_ranked_type = nil
    term = term.downcase

    # Float exact matches by slug to the top of the list, any of these will be excluded
    # from further results.
    types_in_priority_order.each do |type|
      search_results = execute_lookup!(nil, type, guardian, [term])
      limited_results.concat(search_results) if search_results
      break if limited_results.length >= limit
    end

    # Next priority are slugs which start with the search term.
    if limited_results.length < limit
      types_in_priority_order.each do |type|
        limited_results =
          search_using_condition(
            limited_results,
            term,
            type,
            limit,
            HashtagAutocompleteService.search_conditions[:starts_with],
          )
        top_ranked_type = type if top_ranked_type.nil?
        break if limited_results.length >= limit
      end
    end

    # Search the data source for each type, validate and sort results,
    # and break off from searching more data sources if we reach our limit
    if limited_results.length < limit
      types_in_priority_order.each do |type|
        limited_results =
          search_using_condition(
            limited_results,
            term,
            type,
            limit,
            HashtagAutocompleteService.search_conditions[:contains],
          )
        top_ranked_type = type if top_ranked_type.nil?
        break if limited_results.length >= limit
      end
    end

    # Any items that are _not_ the top-ranked type (which could possibly not be
    # the same as the first item in the types_in_priority_order if there was
    # no data for that type) that have conflicting slugs with other items for
    # other higher-ranked types need to have a ::type suffix added to their ref.
    #
    # This will be used for the lookup method above if one of these items is
    # chosen in the UI, otherwise there is no way to determine whether a hashtag is
    # for a category or a tag etc.
    #
    # For example, if there is a category with the slug #general and a tag
    # with the slug #general, then the tag will have its ref changed to #general::tag
    append_types_to_conflicts(limited_results, top_ranked_type, types_in_priority_order, limit)
  end

  private

  def search_using_condition(limited_results, term, type, limit, condition)
    search_results =
      search_for_type(type, guardian, term, limit - limited_results.length, condition)
    return limited_results if search_results.empty?

    search_results =
      HashtagAutocompleteService.data_source_from_type(type).search_sort(
        search_results.reject do |item|
          limited_results.any? { |exact| exact.type == type && exact.slug === item.slug }
        end,
        term,
      )

    limited_results.concat(search_results)
  end

  def search_without_term(types_in_priority_order, limit)
    split_limit = (limit.to_f / types_in_priority_order.length.to_f).ceil
    limited_results = []

    types_in_priority_order.each do |type|
      search_results =
        filter_valid_data_items(
          HashtagAutocompleteService.data_source_from_type(type).search_without_term(
            guardian,
            split_limit,
          ),
        )
      next if search_results.empty?

      # This is purposefully unsorted as search_without_term should sort
      # in its own way.
      limited_results.concat(set_types(set_refs(search_results), type))
    end

    limited_results.take(limit)
  end

  # Sometimes a specific ref is required, e.g. for categories that have
  # a parent their ref will be parent_slug:child_slug, though most of the
  # time it will be the same as the slug. The ref can then be used for
  # lookup in the UI.
  def set_refs(hashtag_items)
    hashtag_items.each { |item| item.ref ||= item.slug }
  end

  def set_types(hashtag_items, type)
    hashtag_items.each { |item| item.type = type }
  end

  def filter_valid_data_items(items)
    items.select { |item| item.kind_of?(HashtagItem) && item.slug.present? && item.text.present? }
  end

  def search_for_type(
    type,
    guardian,
    term,
    limit,
    condition = HashtagAutocompleteService.search_conditions[:contains]
  )
    filter_valid_data_items(
      set_types(
        set_refs(
          HashtagAutocompleteService.data_source_from_type(type).search(
            guardian,
            term,
            limit,
            condition,
          ),
        ),
        type,
      ),
    )
  end

  def execute_lookup!(lookup_results, type, guardian, slugs)
    found_from_slugs = filter_valid_data_items(lookup_for_type(type, guardian, slugs))
    found_from_slugs.sort_by! { |item| item.text.downcase }

    if lookup_results.present?
      lookup_results[type.to_sym] = lookup_results[type.to_sym].concat(found_from_slugs)
    end

    found_from_slugs
  end

  def lookup_for_type(type, guardian, slugs)
    set_types(
      set_refs(HashtagAutocompleteService.data_source_from_type(type).lookup(guardian, slugs)),
      type,
    )
  end

  def append_types_to_conflicts(limited_results, top_ranked_type, types_in_priority_order, limit)
    limited_results.each do |hashtag_item|
      next if hashtag_item.type == top_ranked_type

      # We only need to change the ref to include the type if there is a
      # higher-ranked hashtag slug that conflicts with this one.
      higher_ranked_types =
        types_in_priority_order.slice(0, types_in_priority_order.index(hashtag_item.type))
      higher_ranked_slugs =
        limited_results
          .reject { |r| r.type === hashtag_item.type }
          .select { |r| higher_ranked_types.include?(r.type) }
          .map(&:slug)

      if higher_ranked_slugs.include?(hashtag_item.slug)
        hashtag_item.ref = ""#{hashtag_item.ref}::#{hashtag_item.type}""
      end
    end

    limited_results.take(limit)
  end
end

```","# frozen_string_literal: true

RSpec.describe HashtagAutocompleteService do
  subject(:service) { described_class.new(guardian) }

  fab!(:user)
  fab!(:category1) { Fabricate(:category, name: ""The Book Club"", slug: ""the-book-club"") }
  fab!(:tag1) do
    Fabricate(:tag, name: ""great-books"", staff_topic_count: 22, public_topic_count: 22)
  end
  fab!(:topic1) { Fabricate(:topic) }

  let(:guardian) { Guardian.new(user) }

  after { DiscoursePluginRegistry.reset! }

  describe "".enabled_data_sources"" do
    it ""only returns data sources that are enabled"" do
      expect(HashtagAutocompleteService.enabled_data_sources).to eq(
        HashtagAutocompleteService::DEFAULT_DATA_SOURCES,
      )
    end
  end

  describe "".contexts_with_ordered_types"" do
    it ""returns a hash of all the registered search contexts and their types in the defined priority order"" do
      expect(HashtagAutocompleteService.contexts_with_ordered_types).to eq(
        { ""topic-composer"" => %w[category tag] },
      )
      DiscoursePluginRegistry.register_hashtag_autocomplete_contextual_type_priority(
        { type: ""category"", context: ""awesome-composer"", priority: 50 },
        stub(enabled?: true),
      )
      DiscoursePluginRegistry.register_hashtag_autocomplete_contextual_type_priority(
        { type: ""tag"", context: ""awesome-composer"", priority: 100 },
        stub(enabled?: true),
      )
      expect(HashtagAutocompleteService.contexts_with_ordered_types).to eq(
        { ""topic-composer"" => %w[category tag], ""awesome-composer"" => %w[tag category] },
      )
    end

    it ""does not return types which have been disabled"" do
      SiteSetting.tagging_enabled = false
      expect(HashtagAutocompleteService.contexts_with_ordered_types).to eq(
        { ""topic-composer"" => %w[category] },
      )
    end
  end

  describe "".data_source_icon_map"" do
    it ""gets an array for all icons defined by data sources so they can be used for markdown allowlisting"" do
      expect(HashtagAutocompleteService.data_source_icon_map).to eq(
        { ""category"" => ""folder"", ""tag"" => ""tag"" },
      )
    end
  end

  describe ""#search"" do
    it ""returns search results for tags and categories by default"" do
      expect(service.search(""book"", %w[category tag]).map(&:text)).to eq(
        [""The Book Club"", ""great-books""],
      )
    end

    it ""respects the types_in_priority_order param"" do
      expect(service.search(""book"", %w[tag category]).map(&:text)).to eq(
        [""great-books"", ""The Book Club""],
      )
    end

    it ""respects the limit param"" do
      expect(service.search(""book"", %w[tag category], limit: 1).map(&:text)).to eq([""great-books""])
    end

    it ""does not allow more than SEARCH_MAX_LIMIT results to be specified by the limit param"" do
      stub_const(HashtagAutocompleteService, ""SEARCH_MAX_LIMIT"", 1) do
        expect(service.search(""book"", %w[category tag], limit: 1000).map(&:text)).to eq(
          [""The Book Club""],
        )
      end
    end

    it ""does not search other data sources if the limit is reached by earlier type data sources"" do
      # only expected once to try get the exact matches first
      DiscourseTagging.expects(:filter_allowed_tags).never
      service.search(""the-book"", %w[category tag], limit: 1)
    end

    it ""includes the tag count"" do
      tag1.update!(staff_topic_count: 78, public_topic_count: 78)
      expect(service.search(""book"", %w[tag category]).map(&:text)).to eq(
        [""great-books"", ""The Book Club""],
      )
    end

    it ""does case-insensitive search"" do
      expect(service.search(""bOOk"", %w[category tag]).map(&:text)).to eq(
        [""The Book Club"", ""great-books""],
      )
    end

    it ""can search categories by name or slug"" do
      expect(service.search(""the-book-club"", %w[category]).map(&:text)).to eq([""The Book Club""])
      expect(service.search(""Book C"", %w[category]).map(&:text)).to eq([""The Book Club""])
    end

    it ""does not include categories the user cannot access"" do
      category1.update!(read_restricted: true)
      expect(service.search(""book"", %w[tag category]).map(&:text)).to eq([""great-books""])
    end

    it ""does not include tags the user cannot access"" do
      Fabricate(:tag_group, permissions: { ""staff"" => 1 }, tag_names: [""great-books""])
      expect(service.search(""book"", %w[tag]).map(&:text)).to be_empty
    end

    it ""includes other data sources"" do
      Fabricate(:bookmark, user: user, name: ""read review of this fantasy book"")
      Fabricate(:bookmark, user: user, name: ""cool rock song"")
      guardian.user.reload

      DiscoursePluginRegistry.register_hashtag_autocomplete_data_source(
        FakeBookmarkHashtagDataSource,
        stub(enabled?: true),
      )

      expect(service.search(""book"", %w[category tag bookmark]).map(&:text)).to eq(
        [""The Book Club"", ""great-books"", ""read review of this fantasy book""],
      )
    end

    it ""handles refs for categories that have a parent"" do
      parent = Fabricate(:category, name: ""Hobbies"", slug: ""hobbies"")
      category1.update!(parent_category: parent)
      expect(service.search(""book"", %w[category tag]).map(&:ref)).to eq(
        %w[hobbies:the-book-club great-books],
      )
      category1.update!(parent_category: nil)
    end

    it ""appends type suffixes for the ref on conflicting slugs on items that are not the top priority type"" do
      Fabricate(:tag, name: ""the-book-club"")
      expect(service.search(""book"", %w[category tag]).map(&:ref)).to eq(
        %w[the-book-club great-books the-book-club::tag],
      )

      Fabricate(:bookmark, user: user, name: ""book club"")
      guardian.user.reload

      DiscoursePluginRegistry.register_hashtag_autocomplete_data_source(
        FakeBookmarkHashtagDataSource,
        stub(enabled?: true),
      )

      expect(service.search(""book"", %w[category tag bookmark]).map(&:ref)).to eq(
        %w[book-club the-book-club great-books the-book-club::tag],
      )
    end

    it ""does not add a type suffix where
        1. a subcategory name conflicts with an existing tag name and
        2. the category is not the top ranked type"" do
      parent = Fabricate(:category, name: ""Hobbies"", slug: ""hobbies"")
      category1.update!(parent_category: parent)
      Fabricate(:tag, name: ""the-book-club"")

      Fabricate(:bookmark, user: user, name: ""book club"")
      guardian.user.reload

      DiscoursePluginRegistry.register_hashtag_autocomplete_data_source(
        FakeBookmarkHashtagDataSource,
        stub(enabled?: true),
      )

      expect(service.search(""book"", %w[bookmark category tag]).map(&:ref)).to eq(
        %w[book-club hobbies:the-book-club great-books the-book-club::tag],
      )
    end

    it ""handles the type suffix where the top ranked type conflicts with a subcategory"" do
      parent = Fabricate(:category, name: ""Hobbies"", slug: ""hobbies"")
      category1.update!(parent_category: parent)
      Fabricate(:tag, name: ""the-book-club"")

      Fabricate(:bookmark, user: user, name: ""the book club"")
      guardian.user.reload

      DiscoursePluginRegistry.register_hashtag_autocomplete_data_source(
        FakeBookmarkHashtagDataSource,
        stub(enabled?: true),
      )

      expect(service.search(""book"", %w[bookmark category tag]).map(&:ref)).to eq(
        %w[the-book-club hobbies:the-book-club::category great-books the-book-club::tag],
      )
    end

    it ""orders results by (with type ordering within each section):
        1. exact match on slug (ignoring parent/child distinction for categories)
        2. slugs that start with the term
        3. then name for everything else"" do
      category2 = Fabricate(:category, name: ""Book Library"", slug: ""book-library"")
      Fabricate(:category, name: ""Horror"", slug: ""book"", parent_category: category2)
      Fabricate(:category, name: ""Romance"", slug: ""romance-books"")
      Fabricate(:category, name: ""Abstract Philosophy"", slug: ""abstract-philosophy-books"")
      category6 = Fabricate(:category, name: ""Book Reviews"", slug: ""book-reviews"")
      Fabricate(:category, name: ""Good Books"", slug: ""book"", parent_category: category6)

      Fabricate(:tag, name: ""bookmania"", staff_topic_count: 15, public_topic_count: 15)
      Fabricate(:tag, name: ""awful-books"", staff_topic_count: 56, public_topic_count: 56)

      expect(service.search(""book"", %w[category tag]).map(&:ref)).to eq(
        [
          ""book-reviews:book"", # category exact match on slug, name sorted
          ""book-library:book"",
          ""book-library"", # category starts with match on slug, name sorted
          ""book-reviews"",
          ""bookmania"", # tag starts with match on slug, name sorted
          ""abstract-philosophy-books"", # category partial match on slug, name sorted
          ""romance-books"",
          ""the-book-club"",
          ""awful-books"", # tag partial match on slug, name sorted
          ""great-books"",
        ],
      )
      expect(service.search(""book"", %w[category tag]).map(&:text)).to eq(
        [
          ""Good Books"",
          ""Horror"",
          ""Book Library"",
          ""Book Reviews"",
          ""bookmania"",
          ""Abstract Philosophy"",
          ""Romance"",
          ""The Book Club"",
          ""awful-books"",
          ""great-books"",
        ],
      )
    end

    context ""when multiple tags and categories are returned"" do
      fab!(:category2) { Fabricate(:category, name: ""Book Zone"", slug: ""book-zone"") }
      fab!(:category3) { Fabricate(:category, name: ""Book Dome"", slug: ""book-dome"") }
      fab!(:category4) { Fabricate(:category, name: ""Bookworld"", slug: ""book"") }
      fab!(:tag2) { Fabricate(:tag, name: ""mid-books"") }
      fab!(:tag3) { Fabricate(:tag, name: ""terrible-books"") }
      fab!(:tag4) { Fabricate(:tag, name: ""book"") }

      it ""orders them by name within their type order and prioritizes exact matches to the top of the list"" do
        expect(service.search(""book"", %w[category tag], limit: 10).map(&:ref)).to eq(
          %w[book book::tag book-dome book-zone the-book-club great-books mid-books terrible-books],
        )
      end
    end

    context ""when not tagging_enabled"" do
      before { SiteSetting.tagging_enabled = false }

      it ""does not return any tags"" do
        expect(service.search(""book"", %w[category tag]).map(&:text)).to eq([""The Book Club""])
      end
    end

    context ""when no term is provided (default results) triggered by a # with no characters in the UI"" do
      fab!(:category2) do
        Fabricate(:category, name: ""Book Zone"", slug: ""book-zone"", topic_count: 546)
      end
      fab!(:category3) do
        Fabricate(:category, name: ""Book Dome"", slug: ""book-dome"", topic_count: 987)
      end
      fab!(:category4) { Fabricate(:category, name: ""Bookworld"", slug: ""book"", topic_count: 56) }
      fab!(:category5) { Fabricate(:category, name: ""Media"", slug: ""media"", topic_count: 446) }
      fab!(:tag2) do
        Fabricate(:tag, name: ""mid-books"", staff_topic_count: 33, public_topic_count: 33)
      end
      fab!(:tag3) do
        Fabricate(:tag, name: ""terrible-books"", staff_topic_count: 2, public_topic_count: 2)
      end
      fab!(:tag4) { Fabricate(:tag, name: ""book"", staff_topic_count: 1, public_topic_count: 1) }

      it ""returns the 'most popular' categories and tags (based on topic_count) that the user can access"" do
        category1.update!(read_restricted: true)
        Fabricate(:tag_group, permissions: { ""staff"" => 1 }, tag_names: [""terrible-books""])

        expect(service.search(nil, %w[category tag]).map(&:text)).to eq(
          [
            ""Book Dome"",
            ""Book Zone"",
            ""Media"",
            ""Bookworld"",
            Category.find(SiteSetting.uncategorized_category_id).name,
            ""mid-books"",
            ""great-books"",
            ""book"",
          ],
        )
      end

      it ""does not error if a type provided for priority order has been disabled"" do
        SiteSetting.tagging_enabled = false
        expect(service.search(nil, %w[category tag]).map(&:ref)).to eq(
          %w[book-dome book-zone media book uncategorized the-book-club],
        )
      end
    end
  end

  describe ""#lookup"" do
    fab!(:tag2) { Fabricate(:tag, name: ""fiction-books"") }

    it ""returns category and tag in a hash format with the slug and url"" do
      result = service.lookup(%w[the-book-club great-books fiction-books], %w[category tag])
      expect(result[:category].map(&:slug)).to eq([""the-book-club""])
      expect(result[:category].map(&:relative_url)).to eq([""/c/the-book-club/#{category1.id}""])
      expect(result[:tag].map(&:slug)).to eq(%w[fiction-books great-books])
      expect(result[:tag].map(&:relative_url)).to eq(%w[/tag/fiction-books /tag/great-books])
    end

    it ""does not include category the user cannot access"" do
      category1.update!(read_restricted: true)
      result = service.lookup(%w[the-book-club great-books fiction-books], %w[category tag])
      expect(result[:category]).to eq([])
    end

    it ""does not include tag the user cannot access"" do
      Fabricate(:tag_group, permissions: { ""staff"" => 1 }, tag_names: [""great-books""])
      result = service.lookup(%w[the-book-club great-books fiction-books], %w[category tag])
      expect(result[:tag].map(&:slug)).to eq(%w[fiction-books])
      expect(result[:tag].map(&:relative_url)).to eq([""/tag/fiction-books""])
    end

    it ""handles type suffixes for slugs"" do
      result =
        service.lookup(%w[the-book-club::category great-books::tag fiction-books], %w[category tag])
      expect(result[:category].map(&:slug)).to eq([""the-book-club""])
      expect(result[:category].map(&:relative_url)).to eq([""/c/the-book-club/#{category1.id}""])
      expect(result[:tag].map(&:slug)).to eq(%w[fiction-books great-books])
      expect(result[:tag].map(&:relative_url)).to eq(%w[/tag/fiction-books /tag/great-books])
    end

    it ""handles parent:child category lookups"" do
      parent_category = Fabricate(:category, name: ""Media"", slug: ""media"")
      category1.update!(parent_category: parent_category)
      result = service.lookup(%w[media:the-book-club], %w[category tag])
      expect(result[:category].map(&:slug)).to eq([""the-book-club""])
      expect(result[:category].map(&:ref)).to eq([""media:the-book-club""])
      expect(result[:category].map(&:relative_url)).to eq(
        [""/c/media/the-book-club/#{category1.id}""],
      )
      category1.update!(parent_category: nil)
    end

    it ""handles parent:child category lookups with type suffix"" do
      parent_category = Fabricate(:category, name: ""Media"", slug: ""media"")
      category1.update!(parent_category: parent_category)
      result = service.lookup(%w[media:the-book-club::category], %w[category tag])
      expect(result[:category].map(&:slug)).to eq([""the-book-club""])
      expect(result[:category].map(&:ref)).to eq([""media:the-book-club::category""])
      expect(result[:category].map(&:relative_url)).to eq(
        [""/c/media/the-book-club/#{category1.id}""],
      )
      category1.update!(parent_category: nil)
    end

    it ""does not return the category if the parent does not match the child"" do
      parent_category = Fabricate(:category, name: ""Media"", slug: ""media"")
      category1.update!(parent_category: parent_category)
      result = service.lookup(%w[bad-parent:the-book-club], %w[category tag])
      expect(result[:category]).to be_empty
    end

    it ""for slugs without a type suffix it falls back in type order until a result is found or types are exhausted"" do
      result = service.lookup(%w[the-book-club great-books fiction-books], %w[category tag])
      expect(result[:category].map(&:slug)).to eq([""the-book-club""])
      expect(result[:category].map(&:relative_url)).to eq([""/c/the-book-club/#{category1.id}""])
      expect(result[:tag].map(&:slug)).to eq(%w[fiction-books great-books])
      expect(result[:tag].map(&:relative_url)).to eq(%w[/tag/fiction-books /tag/great-books])

      category2 = Fabricate(:category, name: ""Great Books"", slug: ""great-books"")
      result = service.lookup(%w[the-book-club great-books fiction-books], %w[category tag])
      expect(result[:category].map(&:slug)).to eq(%w[great-books the-book-club])
      expect(result[:category].map(&:relative_url)).to eq(
        [""/c/great-books/#{category2.id}"", ""/c/the-book-club/#{category1.id}""],
      )
      expect(result[:tag].map(&:slug)).to eq(%w[fiction-books])
      expect(result[:tag].map(&:relative_url)).to eq(%w[/tag/fiction-books])

      category1.destroy!
      Fabricate(:tag, name: ""the-book-club"")
      result = service.lookup(%w[the-book-club great-books fiction-books], %w[category tag])
      expect(result[:category].map(&:slug)).to eq([""great-books""])
      expect(result[:category].map(&:relative_url)).to eq([""/c/great-books/#{category2.id}""])
      expect(result[:tag].map(&:slug)).to eq(%w[fiction-books the-book-club])
      expect(result[:tag].map(&:relative_url)).to eq(%w[/tag/fiction-books /tag/the-book-club])

      result = service.lookup(%w[the-book-club great-books fiction-books], %w[tag category])
      expect(result[:category]).to eq([])
      expect(result[:tag].map(&:slug)).to eq(%w[fiction-books great-books the-book-club])
      expect(result[:tag].map(&:relative_url)).to eq(
        %w[/tag/fiction-books /tag/great-books /tag/the-book-club],
      )
    end

    it ""includes other data sources"" do
      Fabricate(:bookmark, user: user, name: ""read review of this fantasy book"")
      Fabricate(:bookmark, user: user, name: ""coolrock"")
      guardian.user.reload

      DiscoursePluginRegistry.register_hashtag_autocomplete_data_source(
        FakeBookmarkHashtagDataSource,
        stub(enabled?: true),
      )

      result = service.lookup([""coolrock""], %w[category tag bookmark])
      expect(result[:bookmark].map(&:slug)).to eq([""coolrock""])
    end

    it ""handles type suffix lookups where there is another type with a conflicting slug that the user cannot access"" do
      category1.update!(read_restricted: true)
      Fabricate(:tag, name: ""the-book-club"")
      result = service.lookup(%w[the-book-club::tag the-book-club], %w[category tag])
      expect(result[:category].map(&:ref)).to eq([])
      expect(result[:tag].map(&:ref)).to eq([""the-book-club::tag""])
    end

    context ""when not tagging_enabled"" do
      before { SiteSetting.tagging_enabled = false }

      it ""does not return tag"" do
        result = service.lookup(%w[the-book-club great-books fiction-books], %w[category tag])
        expect(result[:category].map(&:slug)).to eq([""the-book-club""])
        expect(result[:category].map(&:relative_url)).to eq([""/c/the-book-club/#{category1.id}""])
        expect(result[:tag]).to eq(nil)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class HeatSettingsUpdater
  def self.update
    return unless SiteSetting.automatic_topic_heat_values

    views_by_percentile = views_thresholds
    update_setting(:topic_views_heat_high, views_by_percentile[10])
    update_setting(:topic_views_heat_medium, views_by_percentile[25])
    update_setting(:topic_views_heat_low, views_by_percentile[45])

    like_ratios_by_percentile = like_ratio_thresholds
    update_setting(:topic_post_like_heat_high, like_ratios_by_percentile[10])
    update_setting(:topic_post_like_heat_medium, like_ratios_by_percentile[25])
    update_setting(:topic_post_like_heat_low, like_ratios_by_percentile[45])
  end

  def self.views_thresholds
    results = DB.query(<<~SQL)
      SELECT ranked.bucket * 5 as percentile, MIN(ranked.views) as views
      FROM (
        SELECT NTILE(20) OVER (ORDER BY t.views DESC) AS bucket, t.views
        FROM (
          SELECT views
            FROM topics
           WHERE deleted_at IS NULL
             AND archetype <> 'private_message'
             AND visible = TRUE
        ) t
      ) ranked
      WHERE bucket <= 9
      GROUP BY bucket
    SQL

    results.inject({}) do |h, row|
      h[row.percentile] = row.views
      h
    end
  end

  def self.like_ratio_thresholds
    results = DB.query(<<~SQL)
      SELECT ranked.bucket * 5 as percentile, MIN(ranked.ratio) as like_ratio
      FROM (
        SELECT NTILE(20) OVER (ORDER BY t.ratio DESC) AS bucket, t.ratio
        FROM (
          SELECT like_count::decimal / posts_count AS ratio
            FROM topics
           WHERE deleted_at IS NULL
             AND archetype <> 'private_message'
             AND visible = TRUE
             AND posts_count >= 10
             AND like_count > 0
        ORDER BY created_at DESC
           LIMIT 1000
        ) t
      ) ranked
      WHERE bucket <= 9
      GROUP BY bucket
    SQL

    results.inject({}) do |h, row|
      h[row.percentile] = row.like_ratio
      h
    end
  end

  def self.update_setting(name, new_value)
    if new_value.nil? || new_value <= SiteSetting.defaults[name]
      if SiteSetting.get(name) != SiteSetting.defaults[name]
        SiteSetting.set_and_log(name, SiteSetting.defaults[name])
      end
    elsif SiteSetting.get(name) == 0 || (new_value.to_f / SiteSetting.get(name) - 1.0).abs >= 0.05
      rounded_new_value =
        if new_value.is_a?(Integer)
          if new_value > 9
            digits = new_value.digits.reverse
            (digits[0] * 10 + digits[1]) * 10.pow(digits[2..-1].size)
          else
            new_value
          end
        else
          new_value.round(2)
        end

      SiteSetting.set_and_log(name, rounded_new_value) if SiteSetting.get(name) != rounded_new_value
    end
  end
end

```","# frozen_string_literal: true

RSpec.describe HeatSettingsUpdater do
  describe "".update"" do
    subject(:update_settings) { described_class.update }

    def expect_default_values
      %i[topic_views_heat topic_post_like_heat].each do |prefix|
        %i[low medium high].each do |level|
          setting_name = ""#{prefix}_#{level}""
          expect(SiteSetting.get(setting_name)).to eq(SiteSetting.defaults[setting_name])
        end
      end
    end

    it ""changes nothing on fresh install"" do
      expect { update_settings }.to_not change { UserHistory.count }
      expect_default_values
    end

    context ""with low activity"" do
      let!(:hottest_topic1) { Fabricate(:topic, views: 3000, posts_count: 10, like_count: 2) }
      let!(:hottest_topic2) { Fabricate(:topic, views: 3000, posts_count: 10, like_count: 2) }
      let!(:warm_topic1) { Fabricate(:topic, views: 1500, posts_count: 10, like_count: 1) }
      let!(:warm_topic2) { Fabricate(:topic, views: 1500, posts_count: 10, like_count: 1) }
      let!(:warm_topic3) { Fabricate(:topic, views: 1500, posts_count: 10, like_count: 1) }
      let!(:lukewarm_topic1) { Fabricate(:topic, views: 800, posts_count: 10, like_count: 0) }
      let!(:lukewarm_topic2) { Fabricate(:topic, views: 800, posts_count: 10, like_count: 0) }
      let!(:lukewarm_topic3) { Fabricate(:topic, views: 800, posts_count: 10, like_count: 0) }
      let!(:lukewarm_topic4) { Fabricate(:topic, views: 800, posts_count: 10, like_count: 0) }
      let!(:cold_topic) { Fabricate(:topic, views: 100, posts_count: 10, like_count: 0) }

      it ""doesn't make settings lower than defaults"" do
        expect { update_settings }.to_not change { UserHistory.count }
        expect_default_values
      end

      it ""can set back down to minimum defaults"" do
        %i[low medium high].each do |level|
          SiteSetting.set(""topic_views_heat_#{level}"", 20_000)
          SiteSetting.set(""topic_post_like_heat_#{level}"", 5.0)
        end
        expect { update_settings }.to change { UserHistory.count }.by(6)
        expect_default_values
      end
    end

    context ""with similar activity"" do
      let!(:hottest_topic1) { Fabricate(:topic, views: 3530, posts_count: 100, like_count: 201) }
      let!(:hottest_topic2) { Fabricate(:topic, views: 3530, posts_count: 100, like_count: 201) }
      let!(:warm_topic1) { Fabricate(:topic, views: 2020, posts_count: 100, like_count: 99) }
      let!(:warm_topic2) { Fabricate(:topic, views: 2020, posts_count: 100, like_count: 99) }
      let!(:warm_topic3) { Fabricate(:topic, views: 2020, posts_count: 100, like_count: 99) }
      let!(:lukewarm_topic1) { Fabricate(:topic, views: 1010, posts_count: 100, like_count: 51) }
      let!(:lukewarm_topic2) { Fabricate(:topic, views: 1010, posts_count: 100, like_count: 51) }
      let!(:lukewarm_topic3) { Fabricate(:topic, views: 1010, posts_count: 100, like_count: 51) }
      let!(:lukewarm_topic4) { Fabricate(:topic, views: 1010, posts_count: 100, like_count: 51) }
      let!(:cold_topic) { Fabricate(:topic, views: 100, posts_count: 100, like_count: 1) }

      it ""doesn't make small changes"" do
        expect { update_settings }.to_not change { UserHistory.count }
        expect_default_values
      end
    end

    context ""with increased activity"" do
      let!(:hottest_topic1) { Fabricate(:topic, views: 10_100, posts_count: 100, like_count: 230) }
      let!(:hottest_topic2) { Fabricate(:topic, views: 10_012, posts_count: 100, like_count: 220) }
      let!(:warm_topic1) { Fabricate(:topic, views: 4020, posts_count: 99, like_count: 126) }
      let!(:warm_topic2) { Fabricate(:topic, views: 4010, posts_count: 99, like_count: 116) }
      let!(:warm_topic3) { Fabricate(:topic, views: 4005, posts_count: 99, like_count: 106) }
      let!(:lukewarm_topic1) { Fabricate(:topic, views: 2040, posts_count: 99, like_count: 84) }
      let!(:lukewarm_topic2) { Fabricate(:topic, views: 2030, posts_count: 99, like_count: 74) }
      let!(:lukewarm_topic3) { Fabricate(:topic, views: 2020, posts_count: 99, like_count: 64) }
      let!(:lukewarm_topic4) { Fabricate(:topic, views: 2002, posts_count: 99, like_count: 54) }
      let!(:cold_topic) { Fabricate(:topic, views: 100, posts_count: 100, like_count: 1) }

      it ""changes settings when difference is significant"" do
        expect { update_settings }.to change { UserHistory.count }.by(6)
        expect(SiteSetting.topic_views_heat_high).to eq(10_000)
        expect(SiteSetting.topic_views_heat_medium).to eq(4000)
        expect(SiteSetting.topic_views_heat_low).to eq(2000)
        expect(SiteSetting.topic_post_like_heat_high).to eq(2.2)
        expect(SiteSetting.topic_post_like_heat_medium).to eq(1.07)
        expect(SiteSetting.topic_post_like_heat_low).to eq(0.55)
      end

      it ""doesn't change settings when automatic_topic_heat_values is false"" do
        SiteSetting.automatic_topic_heat_values = false
        expect { update_settings }.to_not change { UserHistory.count }
        expect_default_values
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class UsernameChanger
  def initialize(user, new_username, actor = nil)
    @user = user
    @old_username = user.username
    @new_username = new_username
    @actor = actor
  end

  def self.change(user, new_username, actor = nil)
    self.new(user, new_username, actor).change
  end

  def self.override(user, new_username)
    if user.username_equals_to?(new_username)
      # override anyway since case could've been changed:
      UsernameChanger.change(user, new_username, user)
      true
    elsif user.username != UserNameSuggester.fix_username(new_username)
      suggested_username = UserNameSuggester.suggest(new_username, current_username: user.username)
      UsernameChanger.change(user, suggested_username, user)
      true
    else
      false
    end
  end

  def change(asynchronous: true, run_update_job: true)
    return false if @user.username == @new_username

    @user.username = @new_username

    if @user.save
      if @actor && @old_username != @new_username
        StaffActionLogger.new(@actor).log_username_change(@user, @old_username, @new_username)
      end

      if run_update_job
        UsernameChanger.update_username(
          user_id: @user.id,
          old_username: @old_username,
          new_username: @new_username,
          avatar_template: @user.avatar_template_url,
          asynchronous: asynchronous,
        )
      end
      return true
    end

    false
  end

  def self.update_username(
    user_id:,
    old_username:,
    new_username:,
    avatar_template:,
    asynchronous: true
  )
    args = {
      user_id: user_id,
      old_username: old_username,
      new_username: new_username,
      avatar_template: avatar_template,
    }

    if asynchronous
      Jobs.enqueue(:update_username, args)
    else
      Jobs::UpdateUsername.new.execute(args)
    end
  end
end

```","# frozen_string_literal: true

RSpec.describe UsernameChanger do
  before { Jobs.run_immediately! }

  describe ""#change"" do
    let(:user) { Fabricate(:user) }

    context ""when everything goes well"" do
      let!(:old_username) { user.username }

      it ""should change the username"" do
        new_username = ""#{user.username}1234""

        events =
          DiscourseEvent
            .track_events { @result = UsernameChanger.change(user, new_username) }
            .last(2)

        expect(@result).to eq(true)

        event = events.first
        expect(event[:event_name]).to eq(:username_changed)
        expect(event[:params].first).to eq(old_username)
        expect(event[:params].second).to eq(new_username)

        event = events.last
        expect(event[:event_name]).to eq(:user_updated)
        expect(event[:params].first).to eq(user)

        user.reload
        expect(user.username).to eq(new_username)
        expect(user.username_lower).to eq(new_username.downcase)
      end

      it ""do nothing if the new username is the same"" do
        new_username = user.username

        events =
          DiscourseEvent.track_events { @result = UsernameChanger.change(user, new_username) }

        expect(@result).to eq(false)
        expect(events.count).to be_zero
      end
    end

    context ""when something goes wrong"" do
      let(:wrong_username) { """" }
      let(:username_before_change) { user.username }
      let(:username_lower_before_change) { user.username_lower }

      it ""should not change the username"" do
        @result = UsernameChanger.change(user, wrong_username)
        expect(@result).to eq(false)

        user.reload
        expect(user.username).to eq(username_before_change)
        expect(user.username_lower).to eq(username_lower_before_change)
      end
    end

    context ""when changing the case of my username"" do
      let!(:myself) { Fabricate(:user, username: ""hansolo"") }

      it ""should change the username"" do
        expect do
          expect(UsernameChanger.change(myself, ""HanSolo"", myself)).to eq(true)
        end.to change { UserHistory.count }.by(1)

        expect(UserHistory.last.action).to eq(UserHistory.actions[:change_username])

        expect(myself.reload.username).to eq(""HanSolo"")

        expect do UsernameChanger.change(myself, ""HanSolo"", myself) end.not_to change {
          UserHistory.count
        } # make sure it does not log a dupe

        expect do UsernameChanger.change(myself, user.username, myself) end.not_to change {
          UserHistory.count
        } # does not log if the username already exists
      end
    end

    describe ""allow custom minimum username length from site settings"" do
      before do
        @custom_min = 2
        SiteSetting.min_username_length = @custom_min
      end

      it ""should allow a shorter username than default"" do
        result = UsernameChanger.change(user, ""a"" * @custom_min)
        expect(result).not_to eq(false)
      end

      it ""should not allow a shorter username than limit"" do
        result = UsernameChanger.change(user, ""a"" * (@custom_min - 1))
        expect(result).to eq(false)
      end

      it ""should not allow a longer username than limit"" do
        result = UsernameChanger.change(user, ""a"" * (User.username_length.end + 1))
        expect(result).to eq(false)
      end
    end

    context ""when there are posts and revisions"" do
      let(:user) { Fabricate(:user, username: ""foo"") }
      let(:topic) { Fabricate(:topic, user: user) }

      before do
        UserActionManager.enable
        Discourse.expects(:warn_exception).never
      end

      def create_post_and_change_username(args = {}, &block)
        stub_image_size
        post = create_post(args.merge(topic_id: topic.id))

        args
          .delete(:revisions)
          &.each { |revision| post.revise(post.user, revision, force_new_version: true) }

        block.call(post) if block

        UsernameChanger.change(user, args[:target_username] || ""bar"")
        post.reload
      end

      context ""when there are mentions"" do
        it ""rewrites cooked correctly"" do
          post = create_post_and_change_username(raw: ""Hello @foo"")
          expect(post.cooked).to eq(%Q(<p>Hello <a class=""mention"" href=""/u/bar"">@bar</a></p>))

          post.rebake!
          expect(post.cooked).to eq(%Q(<p>Hello <a class=""mention"" href=""/u/bar"">@bar</a></p>))
        end

        it ""removes the username from the search index"" do
          SearchIndexer.enable
          create_post_and_change_username(raw: ""Hello @foo"")

          results = Search.execute(""foo"", min_search_term_length: 1)
          expect(results.posts).to be_empty
        end

        it ""ignores case when replacing mentions"" do
          post = create_post_and_change_username(raw: ""There's no difference between @foo and @Foo"")

          expect(post.raw).to eq(""There's no difference between @bar and @bar"")
          expect(post.cooked).to eq(
            %Q(<p>There’s no difference between <a class=""mention"" href=""/u/bar"">@bar</a> and <a class=""mention"" href=""/u/bar"">@bar</a></p>),
          )
        end

        it ""replaces mentions when there are leading symbols"" do
          post = create_post_and_change_username(raw: "".@foo -@foo %@foo _@foo ,@foo ;@foo @@foo"")

          expect(post.raw).to eq("".@bar -@bar %@bar _@bar ,@bar ;@bar @@bar"")
          expect(post.cooked).to match_html <<~HTML
            <p>.<a class=""mention"" href=""/u/bar"">@bar</a>
               -<a class=""mention"" href=""/u/bar"">@bar</a>
               %<a class=""mention"" href=""/u/bar"">@bar</a>
               _<a class=""mention"" href=""/u/bar"">@bar</a>
               ,<a class=""mention"" href=""/u/bar"">@bar</a>
               ;<a class=""mention"" href=""/u/bar"">@bar</a>
               @<a class=""mention"" href=""/u/bar"">@bar</a></p>
          HTML
        end

        it ""replaces mentions within double and single quotes"" do
          post = create_post_and_change_username(raw: %Q(""@foo"" '@foo'))

          expect(post.raw).to eq(%Q(""@bar"" '@bar'))
          expect(post.cooked).to eq(
            %Q(<p>“<a class=""mention"" href=""/u/bar"">@bar</a>” ‘<a class=""mention"" href=""/u/bar"">@bar</a>’</p>),
          )
        end

        it ""replaces Markdown formatted mentions"" do
          post = create_post_and_change_username(raw: ""**@foo** *@foo* _@foo_ ~~@foo~~"")

          expect(post.raw).to eq(""**@bar** *@bar* _@bar_ ~~@bar~~"")
          expect(post.cooked).to match_html <<~HTML
            <p><strong><a class=""mention"" href=""/u/bar"">@bar</a></strong>
               <em><a class=""mention"" href=""/u/bar"">@bar</a></em>
               <em><a class=""mention"" href=""/u/bar"">@bar</a></em>
               <s><a class=""mention"" href=""/u/bar"">@bar</a></s></p>
          HTML
        end

        it ""replaces mentions when there are trailing symbols"" do
          post = create_post_and_change_username(raw: ""@foo. @foo, @foo: @foo; @foo_ @foo-"")

          expect(post.raw).to eq(""@bar. @bar, @bar: @bar; @bar_ @bar-"")
          expect(post.cooked).to match_html <<~HTML
            <p><a class=""mention"" href=""/u/bar"">@bar</a>.
               <a class=""mention"" href=""/u/bar"">@bar</a>,
               <a class=""mention"" href=""/u/bar"">@bar</a>:
               <a class=""mention"" href=""/u/bar"">@bar</a>;
               <a class=""mention"" href=""/u/bar"">@bar</a>_
               <a class=""mention"" href=""/u/bar"">@bar</a>-</p>
          HTML
        end

        it ""does not replace mention in cooked when mention contains a trailing underscore"" do
          # Older versions of Discourse detected a trailing underscore as part of a username.
          # That doesn't happen anymore, so we need to do create the `cooked` for this test manually.
          post =
            create_post_and_change_username(raw: ""@foobar @foo"") do |p|
              p.update_columns(
                raw: p.raw.gsub(""@foobar"", ""@foo_""),
                cooked: p.cooked.gsub(""@foobar"", ""@foo_""),
              )
            end

          expect(post.raw).to eq(""@bar_ @bar"")
          expect(post.cooked).to eq(
            %Q(<p><span class=""mention"">@foo_</span> <a class=""mention"" href=""/u/bar"">@bar</a></p>),
          )
        end

        it ""does not replace mentions when there are leading alphanumeric chars"" do
          post = create_post_and_change_username(raw: ""@foo a@foo 2@foo"")

          expect(post.raw).to eq(""@bar a@foo 2@foo"")
          expect(post.cooked).to eq(
            %Q(<p><a class=""mention"" href=""/u/bar"">@bar</a> a@foo 2@foo</p>),
          )
        end

        it ""does not replace username within email address"" do
          post = create_post_and_change_username(raw: ""@foo mail@foo.com"")

          expect(post.raw).to eq(""@bar mail@foo.com"")
          expect(post.cooked).to eq(
            %Q(<p><a class=""mention"" href=""/u/bar"">@bar</a> <a href=""mailto:mail@foo.com"">mail@foo.com</a></p>),
          )
        end

        it ""does not replace username in a mention of a similar username"" do
          Fabricate(:user, username: ""foobar"")
          Fabricate(:user, username: ""foo-bar"")
          Fabricate(:user, username: ""foo_bar"")
          Fabricate(:user, username: ""foo1"")

          post = create_post_and_change_username(raw: ""@foo @foobar @foo-bar @foo_bar @foo1"")

          expect(post.raw).to eq(""@bar @foobar @foo-bar @foo_bar @foo1"")
          expect(post.cooked).to match_html <<~HTML
            <p><a class=""mention"" href=""/u/bar"">@bar</a> <a class=""mention"" href=""/u/foobar"">@foobar</a> <a class=""mention"" href=""/u/foo-bar"">@foo-bar</a> <a class=""mention"" href=""/u/foo_bar"">@foo_bar</a> <a class=""mention"" href=""/u/foo1"">@foo1</a></p>
          HTML
        end

        it ""updates the path to the user even when it links to /user instead of /u"" do
          post = create_post_and_change_username(raw: ""Hello @foo"")
          post.update_column(:cooked, post.cooked.gsub(""/u/foo"", ""/users/foo""))

          expect(post.raw).to eq(""Hello @bar"")
          expect(post.cooked).to eq(%Q(<p>Hello <a class=""mention"" href=""/u/bar"">@bar</a></p>))
        end

        it ""replaces mentions within revisions"" do
          revisions = [
            { raw: ""Hello Foo"" },
            { title: ""new topic title"" },
            { raw: ""Hello @foo!"" },
            { raw: ""Hello @foo!!"" },
          ]
          post = create_post_and_change_username(raw: ""Hello @foo"", revisions: revisions)

          expect(post.raw).to eq(""Hello @bar!!"")
          expect(post.cooked).to eq(%Q(<p>Hello <a class=""mention"" href=""/u/bar"">@bar</a>!!</p>))

          expect(post.revisions.count).to eq(4)

          expect(post.revisions[0].modifications[""raw""][0]).to eq(""Hello @bar"")
          expect(post.revisions[0].modifications[""raw""][1]).to eq(""Hello Foo"")
          expect(post.revisions[0].modifications[""cooked""][0]).to eq(
            %Q(<p>Hello <a class=""mention"" href=""/u/bar"">@bar</a></p>),
          )
          expect(post.revisions[0].modifications[""cooked""][1]).to eq(""<p>Hello Foo</p>"")

          expect(post.revisions[1].modifications).to include(""title"")

          expect(post.revisions[2].modifications[""raw""][0]).to eq(""Hello Foo"")
          expect(post.revisions[2].modifications[""raw""][1]).to eq(""Hello @bar!"")
          expect(post.revisions[2].modifications[""cooked""][0]).to eq(""<p>Hello Foo</p>"")
          expect(post.revisions[2].modifications[""cooked""][1]).to eq(
            %Q(<p>Hello <a class=""mention"" href=""/u/bar"">@bar</a>!</p>),
          )

          expect(post.revisions[3].modifications[""raw""][0]).to eq(""Hello @bar!"")
          expect(post.revisions[3].modifications[""raw""][1]).to eq(""Hello @bar!!"")
          expect(post.revisions[3].modifications[""cooked""][0]).to eq(
            %Q(<p>Hello <a class=""mention"" href=""/u/bar"">@bar</a>!</p>),
          )
          expect(post.revisions[3].modifications[""cooked""][1]).to eq(
            %Q(<p>Hello <a class=""mention"" href=""/u/bar"">@bar</a>!!</p>),
          )
        end

        it ""replaces mentions in posts marked for deletion"" do
          post =
            create_post_and_change_username(raw: ""Hello @foo"") do |p|
              PostDestroyer.new(p.user, p).destroy
            end

          expect(post.raw).to_not include(""@foo"")
          expect(post.cooked).to_not include(""foo"")
          expect(post.revisions.count).to eq(1)

          expect(post.revisions[0].modifications[""raw""][0]).to eq(""Hello @bar"")
          expect(post.revisions[0].modifications[""cooked""][0]).to eq(
            %Q(<p>Hello <a class=""mention"" href=""/u/bar"">@bar</a></p>),
          )
        end

        it ""works when users are mentioned with HTML"" do
          post =
            create_post_and_change_username(
              raw: '<a class=""mention"">@foo</a> and <a class=""mention"">@someuser</a>',
            )

          expect(post.raw).to eq('<a class=""mention"">@bar</a> and <a class=""mention"">@someuser</a>')
          expect(post.cooked).to match_html(
            '<p><a class=""mention"">@bar</a> and <a class=""mention"">@someuser</a></p>',
          )
        end

        it ""replaces mentions of oneself in posts"" do
          post = create_post_and_change_username(raw: ""Hello @#{user.username}"", user: user)

          expect(post.raw).to eq(""Hello @bar"")
          expect(post.cooked).to eq(%Q(<p>Hello <a class=""mention"" href=""/u/bar"">@bar</a></p>))
        end

        it ""replaces mentions of oneself in revisions"" do
          revisions = [
            { raw: ""Hello Foo"" },
            { title: ""new topic title"" },
            { raw: ""Hello @#{user.username}!"" },
            { raw: ""Hello @#{user.username}!!"" },
          ]

          post =
            create_post_and_change_username(raw: ""Hello @#{user.username}"", revisions: revisions)

          expect(post.raw).to eq(""Hello @bar!!"")
          expect(post.cooked).to eq(%Q(<p>Hello <a class=""mention"" href=""/u/bar"">@bar</a>!!</p>))

          expect(post.revisions.count).to eq(4)

          expect(post.revisions[0].modifications[""raw""][0]).to eq(""Hello @bar"")
          expect(post.revisions[0].modifications[""cooked""][0]).to eq(
            %Q(<p>Hello <a class=""mention"" href=""/u/bar"">@bar</a></p>),
          )
          expect(post.revisions[0].modifications[""cooked""][1]).to eq(""<p>Hello Foo</p>"")

          expect(post.revisions[1].modifications).to include(""title"")

          expect(post.revisions[2].modifications[""raw""][0]).to eq(""Hello Foo"")
          expect(post.revisions[2].modifications[""raw""][1]).to eq(""Hello @bar!"")
          expect(post.revisions[2].modifications[""cooked""][0]).to eq(""<p>Hello Foo</p>"")
          expect(post.revisions[2].modifications[""cooked""][1]).to eq(
            %Q(<p>Hello <a class=""mention"" href=""/u/bar"">@bar</a>!</p>),
          )

          expect(post.revisions[3].modifications[""raw""][0]).to eq(""Hello @bar!"")
          expect(post.revisions[3].modifications[""raw""][1]).to eq(""Hello @bar!!"")
          expect(post.revisions[3].modifications[""cooked""][0]).to eq(
            %Q(<p>Hello <a class=""mention"" href=""/u/bar"">@bar</a>!</p>),
          )
          expect(post.revisions[3].modifications[""cooked""][1]).to eq(
            %Q(<p>Hello <a class=""mention"" href=""/u/bar"">@bar</a>!!</p>),
          )
        end

        context ""when using Unicode usernames"" do
          before { SiteSetting.unicode_usernames = true }
          let(:user) { Fabricate(:user, username: ""թռչուն"") }

          it ""it correctly updates mentions"" do
            post = create_post_and_change_username(raw: ""Hello @թռչուն"", target_username: ""птица"")

            expect(post.raw).to eq(""Hello @птица"")
            expect(post.cooked).to eq(
              %Q(<p>Hello <a class=""mention"" href=""/u/%D0%BF%D1%82%D0%B8%D1%86%D0%B0"">@птица</a></p>),
            )
          end

          it ""does not replace mentions when there are leading alphanumeric chars"" do
            post =
              create_post_and_change_username(
                raw: ""Hello @թռչուն 鳥@թռչուն 2@թռչուն ٩@թռչուն"",
                target_username: ""птица"",
              )

            expect(post.raw).to eq(""Hello @птица 鳥@թռչուն 2@թռչուն ٩@թռչուն"")
            expect(post.cooked).to eq(
              %Q(<p>Hello <a class=""mention"" href=""/u/%D0%BF%D1%82%D0%B8%D1%86%D0%B0"">@птица</a> 鳥@թռչուն 2@թռչուն ٩@թռչուն</p>),
            )
          end

          it ""does not replace username in a mention of a similar username"" do
            Fabricate(:user, username: ""թռչուն鳥"")
            Fabricate(:user, username: ""թռչուն-鳥"")
            Fabricate(:user, username: ""թռչուն_鳥"")
            Fabricate(:user, username: ""թռչուն٩"")

            post =
              create_post_and_change_username(
                raw: ""@թռչուն @թռչուն鳥 @թռչուն-鳥 @թռչուն_鳥 @թռչուն٩"",
                target_username: ""птица"",
              )

            expect(post.raw).to eq(""@птица @թռչուն鳥 @թռչուն-鳥 @թռչուն_鳥 @թռչուն٩"")
            expect(post.cooked).to match_html <<~HTML
              <p><a class=""mention"" href=""/u/%D0%BF%D1%82%D0%B8%D1%86%D0%B0"">@птица</a> <a class=""mention"" href=""/u/%D5%A9%D5%BC%D5%B9%D5%B8%D6%82%D5%B6%E9%B3%A5"">@թռչուն鳥</a> <a class=""mention"" href=""/u/%D5%A9%D5%BC%D5%B9%D5%B8%D6%82%D5%B6-%E9%B3%A5"">@թռչուն-鳥</a> <a class=""mention"" href=""/u/%D5%A9%D5%BC%D5%B9%D5%B8%D6%82%D5%B6_%E9%B3%A5"">@թռչուն_鳥</a> <a class=""mention"" href=""/u/%D5%A9%D5%BC%D5%B9%D5%B8%D6%82%D5%B6%D9%A9"">@թռչուն٩</a></p>
            HTML
          end
        end
      end

      context ""when there are quotes"" do
        let(:quoted_post) do
          create_post(user: user, topic: topic, post_number: 1, raw: ""quoted post"")
        end
        let(:avatar_url) { user.avatar_template_url.gsub(""{size}"", ""48"") }

        it ""replaces the username in quote tags and updates avatar"" do
          post = create_post_and_change_username(raw: <<~RAW)
            Lorem ipsum

            [quote=""foo, post:1, topic:#{quoted_post.topic.id}""]
            quoted post
            [/quote]

            [quote='foo']
            quoted post
            [/quote]

            [quote=foo, post:1, topic:#{quoted_post.topic.id}]
            quoted post
            [/quote]

            dolor sit amet
          RAW

          expect(post.raw).to eq(<<~RAW.strip)
            Lorem ipsum

            [quote=""bar, post:1, topic:#{quoted_post.topic.id}""]
            quoted post
            [/quote]

            [quote='bar']
            quoted post
            [/quote]

            [quote=bar, post:1, topic:#{quoted_post.topic.id}]
            quoted post
            [/quote]

            dolor sit amet
          RAW

          expect(post.cooked).to match_html <<~HTML
            <p>Lorem ipsum</p>
            <aside class=""quote no-group"" data-username=""bar"" data-post=""1"" data-topic=""#{quoted_post.topic.id}"">
            <div class=""title"">
            <div class=""quote-controls""></div>
            <img loading=""lazy"" alt='' width=""24"" height=""24"" src=""#{avatar_url}"" class=""avatar""> bar:</div>
            <blockquote>
            <p>quoted post</p>
            </blockquote>
            </aside>
            <aside class=""quote no-group"" data-username=""bar"">
            <div class=""title"">
            <div class=""quote-controls""></div>
            <img loading=""lazy"" alt="""" width=""24"" height=""24"" src=""#{avatar_url}"" class=""avatar""> bar:</div>
            <blockquote>
            <p>quoted post</p>
            </blockquote>
            </aside>
            <aside class=""quote no-group"" data-username=""bar"" data-post=""1"" data-topic=""#{quoted_post.topic.id}"">
            <div class=""title"">
            <div class=""quote-controls""></div>
            <img loading=""lazy"" alt="""" width=""24"" height=""24"" src=""#{avatar_url}"" class=""avatar""> bar:</div>
            <blockquote>
            <p>quoted post</p>
            </blockquote>
            </aside>
            <p>dolor sit amet</p>
          HTML
        end

        it ""replaces the username in new quote format"" do
          post = create_post_and_change_username(raw: <<~RAW)
            Lorem ipsum

            [quote=""Foo Bar, post:1, topic:#{quoted_post.topic.id}, username:foo""]
            quoted post
            [/quote]

            dolor sit amet
          RAW

          expect(post.raw).to eq(<<~RAW.strip)
            Lorem ipsum

            [quote=""Foo Bar, post:1, topic:#{quoted_post.topic.id}, username:bar""]
            quoted post
            [/quote]

            dolor sit amet
          RAW

          expect(post.cooked).to match_html(<<~HTML)
            <p>Lorem ipsum</p>
            <aside class=""quote no-group"" data-username=""bar"" data-post=""1"" data-topic=""#{quoted_post.topic.id}"">
            <div class=""title"">
            <div class=""quote-controls""></div>
            <img loading=""lazy"" alt="""" width=""24"" height=""24"" src=""//test.localhost/letter_avatar_proxy/v4/letter/b/b77776/48.png"" class=""avatar""> Foo Bar:</div>
            <blockquote>
            <p>quoted post</p>
            </blockquote>
            </aside>
            <p>dolor sit amet</p>
          HTML
        end

        context ""when there is a simple quote"" do
          let(:raw) { <<~RAW }
              Lorem ipsum

              [quote=""foo, post:1, topic:#{quoted_post.topic.id}""]
              quoted
              [/quote]
            RAW

          let(:expected_raw) { <<~RAW.strip }
              Lorem ipsum

              [quote=""bar, post:1, topic:#{quoted_post.topic.id}""]
              quoted
              [/quote]
            RAW

          let(:expected_cooked) { <<~HTML.rstrip }
              <p>Lorem ipsum</p>
              <aside class=""quote no-group"" data-username=""bar"" data-post=""1"" data-topic=""#{quoted_post.topic.id}"">
              <div class=""title"">
              <div class=""quote-controls""></div>
              <img loading=""lazy"" alt='' width=""24"" height=""24"" src=""#{avatar_url}"" class=""avatar""> bar:</div>
              <blockquote>
              <p>quoted</p>
              </blockquote>
              </aside>
            HTML

          it ""replaces the username in quote tags when the post is deleted"" do
            post =
              create_post_and_change_username(raw: raw) do |p|
                PostDestroyer.new(Discourse.system_user, p).destroy
              end

            expect(post.raw).to eq(expected_raw)
            expect(post.cooked).to match_html(expected_cooked)
          end
        end
      end

      context ""when there are oneboxes"" do
        let(:quoted_post) do
          create_post(user: user, topic: topic, post_number: 1, raw: ""quoted post"")
        end
        let(:avatar_url) { user_avatar_url(user) }
        let(:evil_trout) { Fabricate(:evil_trout) }
        let(:another_quoted_post) do
          create_post(user: evil_trout, topic: topic, post_number: 2, raw: ""evil post"")
        end

        def protocol_relative_url(url)
          url.sub(/^https?:/, """")
        end

        def user_avatar_url(u)
          u.avatar_template_url.gsub(""{size}"", ""48"")
        end

        it ""updates avatar for linked topics and posts"" do
          raw = ""#{quoted_post.full_url}\n#{quoted_post.topic.url}""
          post = create_post_and_change_username(raw: raw)

          expect(post.raw).to eq(raw)
          expect(post.cooked).to match_html <<~HTML
            <aside class=""quote"" data-post=""#{quoted_post.post_number}"" data-topic=""#{quoted_post.topic.id}"">
              <div class=""title"">
                <div class=""quote-controls""></div>
                <img loading=""lazy"" alt="""" width=""24"" height=""24"" src=""#{avatar_url}"" class=""avatar"">
                <a href=""#{protocol_relative_url(quoted_post.full_url)}"">#{quoted_post.topic.title}</a>
              </div>
              <blockquote>
                quoted post
              </blockquote>
            </aside>

            <aside class=""quote"" data-post=""#{quoted_post.post_number}"" data-topic=""#{quoted_post.topic.id}"">
              <div class=""title"">
                <div class=""quote-controls""></div>
                <img loading=""lazy"" alt="""" width=""24"" height=""24"" src=""#{avatar_url}"" class=""avatar"">
                <a href=""#{protocol_relative_url(quoted_post.topic.url)}"">#{quoted_post.topic.title}</a>
              </div>
              <blockquote>
                quoted post
              </blockquote>
            </aside>
          HTML
        end

        it ""does not update the wrong avatar"" do
          raw = ""#{quoted_post.full_url}\n#{another_quoted_post.full_url}""
          post = create_post_and_change_username(raw: raw)

          expect(post.raw).to eq(raw)
          expect(post.cooked).to match_html <<~HTML
            <aside class=""quote"" data-post=""#{quoted_post.post_number}"" data-topic=""#{quoted_post.topic.id}"">
              <div class=""title"">
                <div class=""quote-controls""></div>
                <img loading=""lazy"" alt="""" width=""24"" height=""24"" src=""#{avatar_url}"" class=""avatar"">
                <a href=""#{protocol_relative_url(quoted_post.full_url)}"">#{quoted_post.topic.title}</a>
              </div>
              <blockquote>
                quoted post
              </blockquote>
            </aside>
            <aside class=""quote"" data-post=""#{another_quoted_post.post_number}"" data-topic=""#{another_quoted_post.topic.id}"">
              <div class=""title"">
                <div class=""quote-controls""></div>
                <img loading=""lazy"" alt="""" width=""24"" height=""24"" src=""#{user_avatar_url(evil_trout)}"" class=""avatar"">
                <a href=""#{protocol_relative_url(another_quoted_post.full_url)}"">#{another_quoted_post.topic.title}</a>
              </div>
              <blockquote>
                evil post
              </blockquote>
            </aside>
          HTML
        end
      end

      it ""updates username in small action posts"" do
        invited_by = Fabricate(:user)
        p1 = topic.add_small_action(invited_by, ""invited_user"", ""foo"")
        p2 = topic.add_small_action(invited_by, ""invited_user"", ""foobar"")
        UsernameChanger.change(user, ""bar"")

        expect(p1.reload.custom_fields[""action_code_who""]).to eq(""bar"")
        expect(p2.reload.custom_fields[""action_code_who""]).to eq(""foobar"")
      end
    end

    context ""when there are notifications"" do
      def create_notification(type, notified_user, post, data = {})
        Fabricate(
          :notification,
          notification_type: Notification.types[type],
          user: notified_user,
          data: data.to_json,
          topic: post&.topic,
          post_number: post&.post_number,
        )
      end

      def notification_data(notification)
        JSON.parse(notification.reload.data, symbolize_names: true)
      end

      def original_and_display_username(username)
        { original_username: username, display_username: username, foo: ""bar"" }
      end

      def original_username_and_some_text_as_display_username(username)
        { original_username: username, display_username: ""some text"", foo: ""bar"" }
      end

      def only_display_username(username)
        { display_username: username }
      end

      def username_and_something_else(username)
        { username: username, foo: ""bar"" }
      end

      it ""replaces usernames in notifications"" do
        renamed_user = Fabricate(:user, username: ""alice"")
        another_user = Fabricate(:user, username: ""another_user"")
        notified_user = Fabricate(:user)
        p1 = Fabricate(:post, post_number: 1, user: renamed_user)
        p2 = Fabricate(:post, post_number: 1, user: another_user)
        Fabricate(
          :invited_user,
          invite: Fabricate(:invite, invited_by: notified_user),
          user: renamed_user,
        )
        Fabricate(
          :invited_user,
          invite: Fabricate(:invite, invited_by: notified_user),
          user: another_user,
        )

        n01 =
          create_notification(:mentioned, notified_user, p1, original_and_display_username(""alice""))
        n02 =
          create_notification(
            :mentioned,
            notified_user,
            p2,
            original_and_display_username(""another_user""),
          )
        n03 =
          create_notification(
            :mentioned,
            notified_user,
            p1,
            original_username_and_some_text_as_display_username(""alice""),
          )
        n04 = create_notification(:mentioned, notified_user, p1, only_display_username(""alice""))
        n05 =
          create_notification(:invitee_accepted, notified_user, nil, only_display_username(""alice""))
        n06 =
          create_notification(
            :invitee_accepted,
            notified_user,
            nil,
            only_display_username(""another_user""),
          )
        n07 =
          create_notification(
            :granted_badge,
            renamed_user,
            nil,
            username_and_something_else(""alice""),
          )
        n08 =
          create_notification(
            :granted_badge,
            another_user,
            nil,
            username_and_something_else(""another_user""),
          )
        n09 =
          create_notification(
            :group_message_summary,
            renamed_user,
            nil,
            username_and_something_else(""alice""),
          )
        n10 =
          create_notification(
            :group_message_summary,
            another_user,
            nil,
            username_and_something_else(""another_user""),
          )

        UsernameChanger.change(renamed_user, ""bob"")

        expect(notification_data(n01)).to eq(original_and_display_username(""bob""))
        expect(notification_data(n02)).to eq(original_and_display_username(""another_user""))
        expect(notification_data(n03)).to eq(
          original_username_and_some_text_as_display_username(""bob""),
        )
        expect(notification_data(n04)).to eq(only_display_username(""bob""))
        expect(notification_data(n05)).to eq(only_display_username(""bob""))
        expect(notification_data(n06)).to eq(only_display_username(""another_user""))
        expect(notification_data(n07)).to eq(username_and_something_else(""bob""))
        expect(notification_data(n08)).to eq(username_and_something_else(""another_user""))
        expect(notification_data(n09)).to eq(username_and_something_else(""bob""))
        expect(notification_data(n10)).to eq(username_and_something_else(""another_user""))
      end
    end
  end

  describe ""#override"" do
    common_test_cases = [
      [""overrides the username if a new name is different"", ""john"", ""bill"", ""bill"", false],
      [""does not change the username if a new name is the same"", ""john"", ""john"", ""john"", false],
      [""overrides the username if a new name has different case"", ""john"", ""JoHN"", ""JoHN"", false],
    ]

    context ""when unicode_usernames is off"" do
      before { SiteSetting.unicode_usernames = false }

      [
        *common_test_cases,
        [
          ""does not change the username if a new name after unicode normalization is the same"",
          ""john"",
          ""john¥¥"",
          ""john"",
        ],
      ].each do |testcase_name, current, new, overrode|
        it ""#{testcase_name}"" do
          user = Fabricate(:user, username: current)
          UsernameChanger.override(user, new)
          expect(user.username).to eq(overrode)
        end
      end

      it ""overrides the username with username suggestions in case the username is already taken"" do
        user = Fabricate(:user, username: ""bill"")
        Fabricate(:user, username: ""john"")

        UsernameChanger.override(user, ""john"")

        expect(user.username).to eq(""john1"")
      end
    end

    context ""when unicode_usernames is on"" do
      before { SiteSetting.unicode_usernames = true }

      [
        *common_test_cases,
        [
          ""overrides the username if a new name after unicode normalization is different only in case"",
          ""lo\u0308we"",
          ""L\u00F6wee"",
          ""L\u00F6wee"",
        ],
      ].each do |testcase_name, current, new, overrode|
        it ""#{testcase_name}"" do
          user = Fabricate(:user, username: current)
          UsernameChanger.override(user, new)
          expect(user.username).to eq(overrode)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class GroupActionLogger
  def initialize(acting_user, group)
    @acting_user = acting_user
    @group = group
  end

  def log_make_user_group_owner(target_user)
    GroupHistory.create!(
      default_params.merge(
        action: GroupHistory.actions[:make_user_group_owner],
        target_user: target_user,
      ),
    )
  end

  def log_remove_user_as_group_owner(target_user)
    GroupHistory.create!(
      default_params.merge(
        action: GroupHistory.actions[:remove_user_as_group_owner],
        target_user: target_user,
      ),
    )
  end

  def log_add_user_to_group(target_user, subject = nil)
    GroupHistory.create!(
      default_params.merge(
        action: GroupHistory.actions[:add_user_to_group],
        target_user: target_user,
        subject: subject,
      ),
    )
  end

  def log_remove_user_from_group(target_user, subject = nil)
    GroupHistory.create!(
      default_params.merge(
        action: GroupHistory.actions[:remove_user_from_group],
        target_user: target_user,
        subject: subject,
      ),
    )
  end

  def log_change_group_settings
    @group
      .previous_changes
      .except(*excluded_attributes)
      .each do |attribute_name, value|
        next if value[0].blank? && value[1].blank?

        GroupHistory.create!(
          default_params.merge(
            action: GroupHistory.actions[:change_group_setting],
            subject: attribute_name,
            prev_value: value[0],
            new_value: value[1],
          ),
        )
      end
  end

  private

  def excluded_attributes
    %i[bio_cooked updated_at created_at user_count]
  end

  def default_params
    { group: @group, acting_user: @acting_user }
  end
end

```","# frozen_string_literal: true

RSpec.describe GroupActionLogger do
  subject(:logger) { described_class.new(group_owner, group) }

  fab!(:group_owner) { Fabricate(:user) }
  fab!(:group)
  fab!(:user)

  before { group.add_owner(group_owner) }

  describe ""#log_make_user_group_owner"" do
    it ""should create the right record"" do
      logger.log_make_user_group_owner(user)

      group_history = GroupHistory.last

      expect(group_history.action).to eq(GroupHistory.actions[:make_user_group_owner])
      expect(group_history.acting_user).to eq(group_owner)
      expect(group_history.target_user).to eq(user)
    end
  end

  describe ""#log_remove_user_as_group_owner"" do
    it ""should create the right record"" do
      logger.log_remove_user_as_group_owner(user)

      group_history = GroupHistory.last

      expect(group_history.action).to eq(GroupHistory.actions[:remove_user_as_group_owner])
      expect(group_history.acting_user).to eq(group_owner)
      expect(group_history.target_user).to eq(user)
    end
  end

  describe ""#log_add_user_to_group"" do
    context ""as a group owner"" do
      it ""should create the right record"" do
        logger.log_add_user_to_group(user)

        group_history = GroupHistory.last

        expect(group_history.action).to eq(GroupHistory.actions[:add_user_to_group])
        expect(group_history.acting_user).to eq(group_owner)
        expect(group_history.target_user).to eq(user)
      end
    end

    context ""as a normal user"" do
      subject(:logger) { described_class.new(user, group) }

      before { group.update!(public_admission: true) }

      it ""should create the right record"" do
        logger.log_add_user_to_group(user)

        group_history = GroupHistory.last

        expect(group_history.action).to eq(GroupHistory.actions[:add_user_to_group])
        expect(group_history.acting_user).to eq(user)
        expect(group_history.target_user).to eq(user)
      end
    end
  end

  describe ""#log_remove_user_from_group"" do
    context ""as group owner"" do
      it ""should create the right record"" do
        logger.log_remove_user_from_group(user)

        group_history = GroupHistory.last

        expect(group_history.action).to eq(GroupHistory.actions[:remove_user_from_group])
        expect(group_history.acting_user).to eq(group_owner)
        expect(group_history.target_user).to eq(user)
      end
    end

    context ""as a normal user"" do
      subject(:logger) { described_class.new(user, group) }

      before { group.update!(public_exit: true) }

      it ""should create the right record"" do
        logger.log_remove_user_from_group(user)

        group_history = GroupHistory.last

        expect(group_history.action).to eq(GroupHistory.actions[:remove_user_from_group])
        expect(group_history.acting_user).to eq(user)
        expect(group_history.target_user).to eq(user)
      end
    end
  end

  describe ""#log_change_group_settings"" do
    it ""should create the right record"" do
      group.update!(public_admission: true, created_at: Time.zone.now)

      expect { logger.log_change_group_settings }.to change { GroupHistory.count }.by(1)

      group_history = GroupHistory.last

      expect(group_history.action).to eq(GroupHistory.actions[:change_group_setting])
      expect(group_history.acting_user).to eq(group_owner)
      expect(group_history.subject).to eq(""public_admission"")
      expect(group_history.prev_value).to eq(""f"")
      expect(group_history.new_value).to eq(""t"")
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class GroupMentionsUpdater
  def self.update(current_name, previous_name)
    Post
      .where(
        ""cooked LIKE '%class=\""mention-group%' AND raw LIKE :previous_name"",
        previous_name: ""%@#{previous_name}%"",
      )
      .find_in_batches do |posts|
        posts.each do |post|
          post.raw.gsub!(/(^|\s)(@#{previous_name})(\s|$)/, ""\\1@#{current_name}\\3"")
          post.save!(validate: false)
        end
      end
  end
end

```","# frozen_string_literal: true

RSpec.describe GroupMentionsUpdater do
  fab!(:post)

  before { Jobs.run_immediately! }

  describe "".update"" do
    it ""should update valid group mentions"" do
      new_group_name = ""awesome_team""
      old_group_name = ""team""

      [
        [""@#{old_group_name} is awesome!"", ""@#{new_group_name} is awesome!""],
        [""This @#{old_group_name} is awesome!"", ""This @#{new_group_name} is awesome!""],
        [""Mention us @ @#{old_group_name}"", ""Mention us @ @#{new_group_name}""],
      ].each do |raw, expected_raw|
        group =
          Fabricate(:group, name: old_group_name, mentionable_level: Group::ALIAS_LEVELS[:everyone])

        post.update!(raw: raw)
        group.update!(name: new_group_name)
        post.reload

        expect(post.raw_mentions).to eq([new_group_name])
        expect(post.raw).to eq(expected_raw)

        group.destroy!
      end
    end

    it ""should not update invalid group mentions"" do
      group = Fabricate(:group, name: ""team"", mentionable_level: Group::ALIAS_LEVELS[:everyone])

      post.update!(raw: ""This is not valid@team.com"")

      expect(post.reload.raw_mentions).to eq([])

      group.update!(name: ""new_team_name"")

      expect(post.reload.raw_mentions).to eq([])
    end

    it ""should ignore validations"" do
      everyone_mention_level = Group::ALIAS_LEVELS[:everyone]

      %w[awesome_team pro_team].each do |name|
        Fabricate(:group, name: name, mentionable_level: everyone_mention_level)
      end

      post.update!(raw: ""@awesome_team is cool and so is @pro_team"")

      SiteSetting.max_mentions_per_post = 1
      GroupMentionsUpdater.update(""cool_team"", ""awesome_team"")

      post.reload
      expect(post.raw_mentions).to match_array(%w[cool_team pro_team])
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class PostActionNotifier
  def self.disable
    @disabled = true
  end

  def self.enable
    @disabled = false
  end

  # For testing purposes
  def self.reset!
    @custom_post_revision_notifier_recipients = nil
  end

  def self.alerter
    @alerter ||= PostAlerter.new
  end

  def self.refresh_like_notification(post, read)
    return unless post && post.user_id && post.topic

    usernames =
      post
        .post_actions
        .where(post_action_type_id: PostActionType.types[:like])
        .joins(:user)
        .order(""post_actions.created_at desc"")
        .where(""post_actions.created_at > ?"", 1.day.ago)
        .pluck(:username)

    if usernames.length > 0
      data = {
        topic_title: post.topic.title,
        username: usernames[0],
        display_username: usernames[0],
        username2: usernames[1],
        count: usernames.length,
      }
      Notification.create(
        notification_type: Notification.types[:liked],
        topic_id: post.topic_id,
        post_number: post.post_number,
        user_id: post.user_id,
        read: read,
        data: data.to_json,
      )
    end
  end

  def self.post_action_deleted(post_action)
    return if @disabled

    # We only care about deleting post actions for now
    return if post_action.deleted_at.blank?

    if post_action.post_action_type_id == PostActionType.types[:like] && post_action.post
      read = true

      Notification
        .where(
          topic_id: post_action.post.topic_id,
          user_id: post_action.post.user_id,
          post_number: post_action.post.post_number,
          notification_type: Notification.types[:liked],
        )
        .each do |notification|
          read = false unless notification.read
          notification.destroy
        end

      refresh_like_notification(post_action.post, read)
    else
      # not using destroy_all cause we want stuff to trigger
      Notification.where(post_action_id: post_action.id).each(&:destroy)
    end
  end

  def self.post_action_created(post_action)
    return if @disabled

    # We only notify on likes for now
    return unless post_action.is_like?

    post = post_action.post
    return if post_action.user.blank? || post.blank?

    alerter.create_notification(
      post.user,
      Notification.types[:liked],
      post,
      display_username: post_action.user.username,
      post_action_id: post_action.id,
      user_id: post_action.user_id,
    )
  end

  def self.after_create_post_revision(post_revision)
    return if @disabled

    post = post_revision.post

    return unless post
    return if post_revision.user.blank?
    return if post.topic.blank?
    return if post.topic.private_message?
    return if notification_is_disabled?(post_revision)

    user_ids = []

    user_ids << post.user_id if post_revision.user_id != post.user_id

    # Notify all users watching the topic when the OP of a wiki topic is edited
    # or if the topic category allows unlimited owner edits on the OP.
    if post.is_first_post? &&
         (post.wiki? || post.topic.category_allows_unlimited_owner_edits_on_first_post?)
      user_ids.concat(
        TopicUser
          .watching(post.topic_id)
          .where.not(user_id: post_revision.user_id)
          .where(topic: post.topic)
          .pluck(:user_id),
      )
    end

    custom_post_revision_notifier_recipients.each do |block|
      user_ids.concat(Array(block.call(post_revision)))
    end

    if user_ids.present?
      DB.after_commit do
        Jobs.enqueue(:notify_post_revision, user_ids: user_ids, post_revision_id: post_revision.id)
      end
    end
  end

  def self.after_post_unhide(post, flaggers)
    return if @disabled || post.last_editor.blank? || flaggers.blank?

    flaggers.each do |flagger|
      alerter.create_notification(
        flagger,
        Notification.types[:edited],
        post,
        display_username: post.last_editor.username,
        acting_user_id: post.last_editor.id,
      )
    end
  end

  def self.custom_post_revision_notifier_recipients
    @custom_post_revision_notifier_recipients ||= Set.new
  end

  def self.add_post_revision_notifier_recipients(&block)
    custom_post_revision_notifier_recipients << block
  end

  private

  def self.notification_is_disabled?(post_revision)
    modifications = post_revision.modifications
    (
      SiteSetting.disable_system_edit_notifications &&
        post_revision.user_id == Discourse::SYSTEM_USER_ID
    ) ||
      (
        SiteSetting.disable_category_edit_notifications &&
          modifications&.dig(""category_id"").present?
      ) || (SiteSetting.disable_tags_edit_notifications && modifications&.dig(""tags"").present?)
  end
end

```","# frozen_string_literal: true

RSpec.describe PostActionNotifier do
  before do
    PostActionNotifier.enable
    Jobs.run_immediately!
  end

  fab!(:evil_trout)
  fab!(:post)

  context ""when editing a post"" do
    it ""notifies a user of the revision"" do
      expect { post.revise(evil_trout, raw: ""world is the new body of the message"") }.to change {
        post.reload.user.notifications.count
      }.by(1)
    end

    it ""notifies watching users of revision when post is wiki-ed and first post in topic"" do
      SiteSetting.editing_grace_period_max_diff = 1

      post.update!(wiki: true)
      owner = post.user
      user2 = Fabricate(:user)
      user3 = Fabricate(:user)

      TopicUser.change(
        user2.id,
        post.topic,
        notification_level: TopicUser.notification_levels[:watching],
      )

      TopicUser.change(
        user3.id,
        post.topic,
        notification_level: TopicUser.notification_levels[:tracking],
      )

      expect do
        post.revise(Fabricate(:user), raw: ""I made some changes to the wiki!"")
      end.to change { Notification.count }.by(2)

      edited_notification_type = Notification.types[:edited]

      expect(Notification.exists?(user: owner, notification_type: edited_notification_type)).to eq(
        true,
      )

      expect(Notification.exists?(user: user2, notification_type: edited_notification_type)).to eq(
        true,
      )

      expect do post.revise(owner, raw: ""I made some changes to the wiki again!"") end.to change {
        Notification.where(notification_type: edited_notification_type).count
      }.by(1)

      expect(
        Notification.where(user: user2, notification_type: edited_notification_type).count,
      ).to eq(2)

      expect do post.revise(user2, raw: ""I changed the wiki totally"") end.to change {
        Notification.where(notification_type: edited_notification_type).count
      }.by(1)

      expect(
        Notification.where(user: owner, notification_type: edited_notification_type).count,
      ).to eq(2)
    end

    it ""notifies watching users of revision when topic category allow_unlimited_owner_edits_on_first_post and first post in topic is edited"" do
      SiteSetting.editing_grace_period_max_diff = 1

      post.topic.update(
        category: Fabricate(:category, allow_unlimited_owner_edits_on_first_post: true),
      )
      owner = post.user
      user2 = Fabricate(:user)
      user3 = Fabricate(:user)

      TopicUser.change(
        user2.id,
        post.topic,
        notification_level: TopicUser.notification_levels[:watching],
      )

      TopicUser.change(
        user3.id,
        post.topic,
        notification_level: TopicUser.notification_levels[:tracking],
      )

      expect do
        post.revise(Fabricate(:user), raw: ""I made some changes to the first post!"")
      end.to change { Notification.count }.by(2)

      edited_notification_type = Notification.types[:edited]

      expect(Notification.exists?(user: owner, notification_type: edited_notification_type)).to eq(
        true,
      )

      expect(Notification.exists?(user: user2, notification_type: edited_notification_type)).to eq(
        true,
      )

      expect do
        post.revise(owner, raw: ""I made some changes to the first post again!"")
      end.to change { Notification.where(notification_type: edited_notification_type).count }.by(1)

      expect(
        Notification.where(user: user2, notification_type: edited_notification_type).count,
      ).to eq(2)

      expect do post.revise(user2, raw: ""I changed the first post totally"") end.to change {
        Notification.where(notification_type: edited_notification_type).count
      }.by(1)

      expect(
        Notification.where(user: owner, notification_type: edited_notification_type).count,
      ).to eq(2)
    end

    it ""stores the revision number with the notification"" do
      post.revise(evil_trout, raw: ""world is the new body of the message"")
      notification_data = JSON.parse post.user.notifications.last.data
      expect(notification_data[""revision_number""]).to eq post.post_revisions.last.number
    end

    context ""when edit notifications are disabled"" do
      before { SiteSetting.disable_system_edit_notifications = true }

      it ""notifies a user of the revision made by another user"" do
        expect { post.revise(evil_trout, raw: ""world is the new body of the message"") }.to change(
          post.user.notifications,
          :count,
        ).by(1)
      end

      it ""does not notify a user of the revision made by the system user"" do
        expect {
          post.revise(Discourse.system_user, raw: ""world is the new body of the message"")
        }.not_to change(post.user.notifications, :count)
      end
    end

    context ""when category edit notifications are disabled"" do
      it ""notifies a user of the revision made by another user"" do
        SiteSetting.disable_category_edit_notifications = false

        expect { post.revise(evil_trout, category_id: Fabricate(:category).id) }.to change(
          post.user.notifications,
          :count,
        ).by(1)
      end

      it ""does not notify a user of the revision made by the system user"" do
        SiteSetting.disable_category_edit_notifications = true

        expect { post.revise(evil_trout, category_id: Fabricate(:category).id) }.not_to change(
          post.user.notifications,
          :count,
        )
      end
    end

    context ""when tags edit notifications are disabled"" do
      it ""notifies a user of the revision made by another user"" do
        SiteSetting.disable_tags_edit_notifications = false

        expect { post.revise(evil_trout, tags: [Fabricate(:tag).name]) }.to change(
          post.user.notifications,
          :count,
        ).by(1)
      end

      it ""does not notify a user of the revision made by the system user"" do
        SiteSetting.disable_tags_edit_notifications = true

        expect { post.revise(evil_trout, tags: [Fabricate(:tag).name]) }.not_to change(
          post.user.notifications,
          :count,
        )
      end
    end

    context ""when using plugin API to add custom recipients"" do
      let(:lurker) { Fabricate(:user) }

      before do
        plugin = Plugin::Instance.new
        plugin.add_post_revision_notifier_recipients { |post_revision| [lurker.id] }
      end

      after { PostActionNotifier.reset! }

      it ""notifies the specified user of the revision"" do
        expect { post.revise(evil_trout, raw: ""world is the new body of the message"") }.to change {
          lurker.notifications.count
        }.by(1)
      end
    end
  end

  context ""with private message"" do
    fab!(:private_message) do
      Fabricate(:topic, archetype: Archetype.private_message, category_id: nil)
    end
    fab!(:user)
    fab!(:mention_post) do
      Fabricate(:post, topic: private_message, user: user, raw: ""Hello @eviltrout"")
    end

    it ""won't notify someone who can't see the post"" do
      expect { PostAlerter.post_created(mention_post) }.not_to change(
        evil_trout.notifications,
        :count,
      )
    end

    it ""creates like notifications"" do
      other_user = Fabricate(:user)
      private_message.allowed_users << user << other_user
      expect { PostActionCreator.like(other_user, mention_post) }.to change(
        user.notifications,
        :count,
      )
    end
  end

  context ""with moderator action post"" do
    fab!(:user)
    fab!(:first_post) { Fabricate(:post, user: user, raw: ""A useless post for you."") }
    let(:topic) { first_post.topic }

    it ""should not notify anyone"" do
      expect {
        Fabricate(
          :post,
          topic: topic,
          raw: ""This topic is CLOSED"",
          post_type: Post.types[:moderator_action],
        )
      }.to_not change { Notification.count }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class ColorSchemeRevisor
  def initialize(color_scheme, params = {})
    @color_scheme = color_scheme
    @params = params
  end

  def self.revise(color_scheme, params)
    self.new(color_scheme, params).revise
  end

  def revise
    ColorScheme.transaction do
      @color_scheme.name = @params[:name] if @params.has_key?(:name)
      @color_scheme.user_selectable = @params[:user_selectable] if @params.has_key?(
        :user_selectable,
      )
      @color_scheme.base_scheme_id = @params[:base_scheme_id] if @params.has_key?(:base_scheme_id)
      has_colors = @params[:colors]

      if has_colors
        @params[:colors].each do |c|
          if existing = @color_scheme.colors_by_name[c[:name]]
            existing.update(c)
          else
            @color_scheme.color_scheme_colors << ColorSchemeColor.new(name: c[:name], hex: c[:hex])
          end
        end
        @color_scheme.clear_colors_cache
      end

      if has_colors || @color_scheme.saved_change_to_name? ||
           @color_scheme.will_save_change_to_user_selectable? ||
           @color_scheme.saved_change_to_base_scheme_id?
        @color_scheme.save
      end
    end
    @color_scheme
  end
end

```","# frozen_string_literal: true

RSpec.describe ColorSchemeRevisor do
  let(:color) { Fabricate.build(:color_scheme_color, hex: ""FFFFFF"", color_scheme: nil) }
  let(:color_scheme) do
    Fabricate(
      :color_scheme,
      created_at: 1.day.ago,
      updated_at: 1.day.ago,
      color_scheme_colors: [color],
    )
  end
  let(:valid_params) { { name: color_scheme.name, colors: nil } }

  describe ""revise"" do
    it ""does nothing if there are no changes"" do
      expect {
        ColorSchemeRevisor.revise(color_scheme, valid_params.merge(colors: nil))
      }.to_not change { color_scheme.reload.updated_at }
    end

    it ""can change the name"" do
      ColorSchemeRevisor.revise(color_scheme, valid_params.merge(name: ""Changed Name""))
      expect(color_scheme.reload.name).to eq(""Changed Name"")
    end

    it ""can update the base_scheme_id"" do
      ColorSchemeRevisor.revise(color_scheme, valid_params.merge(base_scheme_id: ""test""))
      expect(color_scheme.reload.base_scheme_id).to eq(""test"")
    end

    it ""can change colors"" do
      ColorSchemeRevisor.revise(
        color_scheme,
        valid_params.merge(
          colors: [{ name: color.name, hex: ""BEEF99"" }, { name: ""bob"", hex: ""AAAAAA"" }],
        ),
      )
      color_scheme.reload

      expect(color_scheme.version).to eq(2)
      expect(color_scheme.colors.size).to eq(2)
      expect(color_scheme.colors.find_by(name: color.name).hex).to eq(""BEEF99"")
      expect(color_scheme.colors.find_by(name: ""bob"").hex).to eq(""AAAAAA"")
    end

    it ""doesn't make changes when a color is invalid"" do
      expect {
        cs =
          ColorSchemeRevisor.revise(
            color_scheme,
            valid_params.merge(colors: [{ name: color.name, hex: ""OOPS"" }]),
          )
        expect(cs).not_to be_valid
        expect(cs.errors).to be_present
      }.to_not change { color_scheme.reload.version }
      expect(color_scheme.colors.first.hex).to eq(color.hex)
    end

    it ""can change the user_selectable column"" do
      expect(color_scheme.user_selectable).to eq(false)

      ColorSchemeRevisor.revise(color_scheme, { user_selectable: true })
      expect(color_scheme.reload.user_selectable).to eq(true)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class UserUpdater
  CATEGORY_IDS = {
    watched_first_post_category_ids: :watching_first_post,
    watched_category_ids: :watching,
    tracked_category_ids: :tracking,
    regular_category_ids: :regular,
    muted_category_ids: :muted,
  }

  TAG_NAMES = {
    watching_first_post_tags: :watching_first_post,
    watched_tags: :watching,
    tracked_tags: :tracking,
    muted_tags: :muted,
  }

  OPTION_ATTR = %i[
    mailing_list_mode
    mailing_list_mode_frequency
    email_digests
    email_level
    email_messages_level
    external_links_in_new_tab
    enable_quoting
    enable_defer
    color_scheme_id
    dark_scheme_id
    dynamic_favicon
    automatically_unpin_topics
    digest_after_minutes
    new_topic_duration_minutes
    auto_track_topics_after_msecs
    notification_level_when_replying
    email_previous_replies
    email_in_reply_to
    like_notification_frequency
    include_tl0_in_digests
    theme_ids
    allow_private_messages
    enable_allowed_pm_users
    homepage_id
    hide_profile_and_presence
    text_size
    title_count_mode
    timezone
    skip_new_user_tips
    seen_popups
    default_calendar
    bookmark_auto_delete_preference
    sidebar_link_to_filtered_list
    sidebar_show_count_of_new_items
    watched_precedence_over_muted
  ]

  NOTIFICATION_SCHEDULE_ATTRS = -> do
    attrs = [:enabled]
    7.times do |n|
      attrs.push(""day_#{n}_start_time"".to_sym)
      attrs.push(""day_#{n}_end_time"".to_sym)
    end
    { user_notification_schedule: attrs }
  end.call

  def initialize(actor, user)
    @user = user
    @user_guardian = Guardian.new(user)
    @guardian = Guardian.new(actor)
    @actor = actor
  end

  def update(attributes = {})
    user_profile = user.user_profile
    user_profile.dismissed_banner_key = attributes[:dismissed_banner_key] if attributes[
      :dismissed_banner_key
    ].present?
    unless SiteSetting.enable_discourse_connect && SiteSetting.discourse_connect_overrides_bio
      user_profile.bio_raw = attributes.fetch(:bio_raw) { user_profile.bio_raw }
    end

    unless SiteSetting.enable_discourse_connect && SiteSetting.discourse_connect_overrides_location
      user_profile.location = attributes.fetch(:location) { user_profile.location }
    end

    unless SiteSetting.enable_discourse_connect && SiteSetting.discourse_connect_overrides_website
      user_profile.website = format_url(attributes.fetch(:website) { user_profile.website })
    end

    if attributes[:profile_background_upload_url] == """" ||
         !guardian.can_upload_profile_header?(user)
      user_profile.profile_background_upload_id = nil
    elsif upload = Upload.get_from_url(attributes[:profile_background_upload_url])
      user_profile.profile_background_upload_id = upload.id
    end

    if attributes[:card_background_upload_url] == """" ||
         !guardian.can_upload_user_card_background?(user)
      user_profile.card_background_upload_id = nil
    elsif upload = Upload.get_from_url(attributes[:card_background_upload_url])
      user_profile.card_background_upload_id = upload.id
    end

    if attributes[:user_notification_schedule]
      user_notification_schedule =
        user.user_notification_schedule || UserNotificationSchedule.new(user: user)
      user_notification_schedule.assign_attributes(attributes[:user_notification_schedule])
    end

    old_user_name = user.name.present? ? user.name : """"

    user.name = attributes.fetch(:name) { user.name } if guardian.can_edit_name?(user)

    user.locale = attributes.fetch(:locale) { user.locale }
    user.date_of_birth = attributes.fetch(:date_of_birth) { user.date_of_birth }

    if attributes[:title] && attributes[:title] != user.title &&
         guardian.can_grant_title?(user, attributes[:title])
      user.title = attributes[:title]
    end

    if SiteSetting.user_selected_primary_groups && attributes[:primary_group_id] &&
         attributes[:primary_group_id] != user.primary_group_id &&
         guardian.can_use_primary_group?(user, attributes[:primary_group_id])
      user.primary_group_id = attributes[:primary_group_id]
    elsif SiteSetting.user_selected_primary_groups && attributes[:primary_group_id] &&
          attributes[:primary_group_id].blank?
      user.primary_group_id = nil
    end

    if attributes[:flair_group_id] && attributes[:flair_group_id] != user.flair_group_id &&
         (
           attributes[:flair_group_id].blank? ||
             guardian.can_use_flair_group?(user, attributes[:flair_group_id])
         )
      user.flair_group_id = attributes[:flair_group_id]
    end

    if @guardian.can_change_tracking_preferences?(user)
      CATEGORY_IDS.each do |attribute, level|
        if ids = attributes[attribute]
          CategoryUser.batch_set(user, level, ids)
        end
      end

      TAG_NAMES.each do |attribute, level|
        if attributes.has_key?(attribute)
          TagUser.batch_set(user, level, attributes[attribute]&.split("","") || [])
        end
      end
    end

    save_options = false

    # special handling for theme_id cause we need to bump a sequence number
    if attributes.key?(:theme_ids)
      attributes[:theme_ids].reject!(&:blank?)
      attributes[:theme_ids].map!(&:to_i)

      if @user_guardian.allow_themes?(attributes[:theme_ids])
        user.user_option.theme_key_seq += 1 if user.user_option.theme_ids != attributes[:theme_ids]
      else
        attributes.delete(:theme_ids)
      end
    end

    if attributes.key?(:text_size)
      user.user_option.text_size_seq += 1 if user.user_option.text_size.to_s !=
        attributes[:text_size]
    end

    OPTION_ATTR.each do |attribute|
      if attributes.key?(attribute)
        save_options = true

        if [true, false].include?(user.user_option.public_send(attribute))
          val = attributes[attribute].to_s == ""true""
          user.user_option.public_send(""#{attribute}="", val)
        else
          user.user_option.public_send(""#{attribute}="", attributes[attribute])
        end
      end
    end

    if attributes.key?(:skip_new_user_tips) && user.user_option.skip_new_user_tips
      user.user_option.seen_popups = [-1]
    end

    # automatically disable digests when mailing_list_mode is enabled
    user.user_option.email_digests = false if user.user_option.mailing_list_mode

    fields = attributes[:custom_fields]
    user.custom_fields = user.custom_fields.merge(fields) if fields.present?

    saved = nil

    User.transaction do
      update_muted_users(attributes[:muted_usernames]) if attributes.key?(:muted_usernames)

      if attributes.key?(:allowed_pm_usernames)
        update_allowed_pm_users(attributes[:allowed_pm_usernames])
      end

      if attributes.key?(:discourse_connect)
        update_discourse_connect(attributes[:discourse_connect])
      end

      if attributes.key?(:user_associated_accounts)
        updated_associated_accounts(attributes[:user_associated_accounts])
      end

      if attributes.key?(:sidebar_category_ids)
        SidebarSectionLinksUpdater.update_category_section_links(
          user,
          category_ids:
            Category
              .secured(@user_guardian)
              .where(id: attributes[:sidebar_category_ids])
              .pluck(:id),
        )
      end

      if attributes.key?(:sidebar_tag_names) && SiteSetting.tagging_enabled
        SidebarSectionLinksUpdater.update_tag_section_links(
          user,
          tag_ids:
            DiscourseTagging
              .filter_visible(Tag, @user_guardian)
              .where(name: attributes[:sidebar_tag_names])
              .pluck(:id),
        )
      end

      if SiteSetting.enable_user_status?
        update_user_status(attributes[:status]) if attributes.has_key?(:status)
      end

      name_changed = user.name_changed?
      saved =
        (!save_options || user.user_option.save) &&
          (user_notification_schedule.nil? || user_notification_schedule.save) &&
          user_profile.save && user.save

      if saved && (name_changed && old_user_name.casecmp(attributes.fetch(:name)) != 0)
        StaffActionLogger.new(@actor).log_name_change(
          user.id,
          old_user_name,
          attributes.fetch(:name) { """" },
        )
      end
      DiscourseEvent.trigger(:within_user_updater_transaction, user, attributes)
    rescue Addressable::URI::InvalidURIError => e
      # Prevent 500 for crazy url input
      return saved
    end

    if saved
      if user_notification_schedule
        if user_notification_schedule.enabled
          user_notification_schedule.create_do_not_disturb_timings(delete_existing: true)
        else
          user_notification_schedule.destroy_scheduled_timings
        end
      end
      if attributes.key?(:seen_popups) || attributes.key?(:skip_new_user_tips)
        MessageBus.publish(
          ""/user-tips/#{user.id}"",
          user.user_option.seen_popups,
          user_ids: [user.id],
        )
      end
      DiscourseEvent.trigger(:user_updated, user)
    end

    saved
  end

  def update_muted_users(usernames)
    usernames ||= """"
    desired_usernames = usernames.split("","").reject { |username| user.username == username }
    desired_ids = User.where(username: desired_usernames).pluck(:id)
    if desired_ids.empty?
      MutedUser.where(user_id: user.id).destroy_all
    else
      MutedUser.where(""user_id = ? AND muted_user_id not in (?)"", user.id, desired_ids).destroy_all

      # SQL is easier here than figuring out how to do the same in AR
      DB.exec(<<~SQL, now: Time.now, user_id: user.id, desired_ids: desired_ids)
        INSERT into muted_users(user_id, muted_user_id, created_at, updated_at)
        SELECT :user_id, id, :now, :now
        FROM users
        WHERE id in (:desired_ids)
        ON CONFLICT DO NOTHING
      SQL
    end
  end

  def update_allowed_pm_users(usernames)
    usernames ||= """"
    desired_usernames = usernames.split("","").reject { |username| user.username == username }
    desired_ids = User.where(username: desired_usernames).pluck(:id)

    if desired_ids.empty?
      AllowedPmUser.where(user_id: user.id).destroy_all
    else
      AllowedPmUser.where(
        ""user_id = ? AND allowed_pm_user_id not in (?)"",
        user.id,
        desired_ids,
      ).destroy_all

      # SQL is easier here than figuring out how to do the same in AR
      DB.exec(<<~SQL, now: Time.zone.now, user_id: user.id, desired_ids: desired_ids)
        INSERT into allowed_pm_users(user_id, allowed_pm_user_id, created_at, updated_at)
        SELECT :user_id, id, :now, :now
        FROM users
        WHERE id in (:desired_ids)
        ON CONFLICT DO NOTHING
      SQL
    end
  end

  def updated_associated_accounts(associations)
    associations.each do |association|
      user_associated_account =
        UserAssociatedAccount.find_or_initialize_by(
          user_id: user.id,
          provider_name: association[:provider_name],
        )
      if association[:provider_uid].present?
        user_associated_account.update!(provider_uid: association[:provider_uid])
      else
        user_associated_account.destroy!
      end
    end
  end

  private

  def update_user_status(status)
    if status.blank?
      @user.clear_status!
    else
      @user.set_status!(status[:description], status[:emoji], status[:ends_at])
    end
  end

  def update_discourse_connect(discourse_connect)
    external_id = discourse_connect[:external_id]
    sso = SingleSignOnRecord.find_or_initialize_by(user_id: user.id)

    if external_id.present?
      sso.update!(
        external_id: discourse_connect[:external_id],
        last_payload: ""external_id=#{discourse_connect[:external_id]}"",
      )
    else
      sso.destroy!
    end
  end

  attr_reader :user, :guardian

  def format_url(website)
    return nil if website.blank?
    website =~ /\Ahttp/ ? website : ""http://#{website}""
  end
end

```","# frozen_string_literal: true

RSpec.describe UserUpdater do
  fab!(:user)
  fab!(:u1) { Fabricate(:user) }
  fab!(:u2) { Fabricate(:user) }
  fab!(:u3) { Fabricate(:user) }

  let(:acting_user) { Fabricate.build(:user) }

  describe ""#update_muted_users"" do
    it ""has no cross talk"" do
      updater = UserUpdater.new(u1, u1)
      updater.update_muted_users(""#{u2.username},#{u3.username}"")

      updater = UserUpdater.new(u2, u2)
      updater.update_muted_users(""#{u3.username},#{u1.username}"")

      updater = UserUpdater.new(u3, u3)
      updater.update_muted_users("""")

      expect(MutedUser.where(user_id: u2.id).pluck(:muted_user_id)).to match_array([u3.id, u1.id])
      expect(MutedUser.where(user_id: u1.id).pluck(:muted_user_id)).to match_array([u2.id, u3.id])
      expect(MutedUser.where(user_id: u3.id).count).to eq(0)
    end

    it ""excludes acting user"" do
      updater = UserUpdater.new(u1, u1)
      updater.update_muted_users(""#{u1.username},#{u2.username}"")

      expect(MutedUser.where(muted_user_id: u2.id).pluck(:muted_user_id)).to match_array([u2.id])
    end
  end

  describe ""#update"" do
    fab!(:category)
    fab!(:tag)
    fab!(:tag2) { Fabricate(:tag) }

    it ""saves user"" do
      user = Fabricate(:user, name: ""Billy Bob"")
      updater = UserUpdater.new(user, user)

      updater.update(name: ""Jim Tom"")

      expect(user.reload.name).to eq ""Jim Tom""
    end

    describe ""the within_user_updater_transaction event"" do
      it ""allows plugins to perform additional updates"" do
        update_attributes = { name: ""Jimmmy Johnny"" }
        handler =
          Proc.new do |user, attrs|
            user.user_profile.update!(bio_raw: ""hello world I'm Jimmmy"")
            expect(attrs).to eq(update_attributes)
          end
        DiscourseEvent.on(:within_user_updater_transaction, &handler)

        updater = UserUpdater.new(user, user)
        updater.update(update_attributes)

        expect(user.reload.name).to eq(""Jimmmy Johnny"")
        expect(user.user_profile.bio_raw).to eq(""hello world I'm Jimmmy"")
      ensure
        DiscourseEvent.off(:within_user_updater_transaction, &handler)
      end

      it ""can cancel the whole update transaction if a handler raises"" do
        error_class = Class.new(StandardError)
        handler = Proc.new { raise error_class.new }

        DiscourseEvent.on(:within_user_updater_transaction, &handler)

        old_name = user.name
        updater = UserUpdater.new(user, user)

        expect { updater.update(name: ""Failure McClario"") }.to raise_error(error_class)

        expect(user.reload.name).to eq(old_name)
      ensure
        DiscourseEvent.off(:within_user_updater_transaction, &handler)
      end
    end

    it ""can update categories and tags"" do
      updater = UserUpdater.new(user, user)
      updater.update(watched_tags: ""#{tag.name},#{tag2.name}"", muted_category_ids: [category.id])

      expect(
        TagUser.where(
          user_id: user.id,
          tag_id: tag.id,
          notification_level: TagUser.notification_levels[:watching],
        ).exists?,
      ).to eq(true)

      expect(
        TagUser.where(
          user_id: user.id,
          tag_id: tag2.id,
          notification_level: TagUser.notification_levels[:watching],
        ).exists?,
      ).to eq(true)

      expect(
        CategoryUser.where(
          user_id: user.id,
          category_id: category.id,
          notification_level: CategoryUser.notification_levels[:muted],
        ).count,
      ).to eq(1)
    end

    context ""with a staged user"" do
      let(:staged_user) { Fabricate(:staged) }

      context ""when allow_changing_staged_user_tracking is false"" do
        before { SiteSetting.allow_changing_staged_user_tracking = false }

        it ""doesn't update muted categories and watched tags"" do
          updater = UserUpdater.new(Fabricate(:admin), staged_user)
          updater.update(watched_tags: ""#{tag.name}"", muted_category_ids: [category.id])
          expect(TagUser.exists?(user_id: staged_user.id)).to eq(false)
          expect(CategoryUser.exists?(user_id: staged_user.id)).to eq(false)
        end
      end

      context ""when allow_changing_staged_user_tracking is true"" do
        before { SiteSetting.allow_changing_staged_user_tracking = true }

        it ""updates muted categories and watched tags"" do
          updater = UserUpdater.new(Fabricate(:admin), staged_user)
          updater.update(watched_tags: ""#{tag.name}"", muted_category_ids: [category.id])
          expect(
            TagUser.exists?(
              user_id: staged_user.id,
              tag_id: tag.id,
              notification_level: TagUser.notification_levels[:watching],
            ),
          ).to eq(true)

          expect(
            CategoryUser.exists?(
              user_id: staged_user.id,
              category_id: category.id,
              notification_level: CategoryUser.notification_levels[:muted],
            ),
          ).to eq(true)
        end
      end
    end

    it ""doesn't remove notification prefs when updating something else"" do
      TagUser.create!(
        user: user,
        tag: tag,
        notification_level: TagUser.notification_levels[:watching],
      )
      CategoryUser.create!(
        user: user,
        category: category,
        notification_level: CategoryUser.notification_levels[:muted],
      )

      updater = UserUpdater.new(acting_user, user)
      updater.update(name: ""Steve Dave"")

      expect(TagUser.where(user: user).count).to eq(1)
      expect(CategoryUser.where(user: user).count).to eq(1)
    end

    it ""updates various fields"" do
      updater = UserUpdater.new(acting_user, user)
      date_of_birth = Time.zone.now
      SiteSetting.disable_mailing_list_mode = false

      theme = Fabricate(:theme, user_selectable: true)

      seq = user.user_option.theme_key_seq

      val =
        updater.update(
          bio_raw: ""my new bio"",
          email_level: UserOption.email_level_types[:always],
          mailing_list_mode: true,
          digest_after_minutes: ""45"",
          new_topic_duration_minutes: 100,
          auto_track_topics_after_msecs: 101,
          notification_level_when_replying: 3,
          email_in_reply_to: false,
          date_of_birth: date_of_birth,
          theme_ids: [theme.id],
          allow_private_messages: false,
        )

      expect(val).to be_truthy

      user.reload

      expect(user.user_profile.bio_raw).to eq ""my new bio""
      expect(user.user_option.email_level).to eq UserOption.email_level_types[:always]
      expect(user.user_option.mailing_list_mode).to eq true
      expect(user.user_option.digest_after_minutes).to eq 45
      expect(user.user_option.new_topic_duration_minutes).to eq 100
      expect(user.user_option.auto_track_topics_after_msecs).to eq 101
      expect(user.user_option.notification_level_when_replying).to eq 3
      expect(user.user_option.email_in_reply_to).to eq false
      expect(user.user_option.theme_ids.first).to eq theme.id
      expect(user.user_option.theme_key_seq).to eq(seq + 1)
      expect(user.user_option.allow_private_messages).to eq(false)
      expect(user.date_of_birth).to eq(date_of_birth.to_date)
    end

    it ""allows user to update profile header when the user has required trust level"" do
      user = Fabricate(:user, trust_level: 2)
      updater = UserUpdater.new(user, user)
      upload = Fabricate(:upload)
      SiteSetting.min_trust_level_to_allow_profile_background = 2
      val = updater.update(profile_background_upload_url: upload.url)
      expect(val).to be_truthy
      user.reload
      expect(user.profile_background_upload).to eq(upload)
      success = updater.update(profile_background_upload_url: """")
      expect(success).to eq(true)
      user.reload
      expect(user.profile_background_upload).to eq(nil)
    end

    it ""allows user to update user card background when the user has required trust level"" do
      user = Fabricate(:user, trust_level: 2)
      updater = UserUpdater.new(user, user)
      upload = Fabricate(:upload)
      SiteSetting.min_trust_level_to_allow_user_card_background = 2
      val = updater.update(card_background_upload_url: upload.url)
      expect(val).to be_truthy
      user.reload
      expect(user.card_background_upload).to eq(upload)
      success = updater.update(card_background_upload_url: """")
      expect(success).to eq(true)
      user.reload
      expect(user.card_background_upload).to eq(nil)
    end

    it ""disables email_digests when enabling mailing_list_mode"" do
      updater = UserUpdater.new(acting_user, user)
      SiteSetting.disable_mailing_list_mode = false

      val = updater.update(mailing_list_mode: true, email_digests: true)
      expect(val).to be_truthy

      user.reload

      expect(user.user_option.email_digests).to eq false
      expect(user.user_option.mailing_list_mode).to eq true
    end

    it ""filters theme_ids blank values before updating preferences"" do
      user.user_option.update!(theme_ids: [1])
      updater = UserUpdater.new(acting_user, user)

      updater.update(theme_ids: [""""])
      user.reload
      expect(user.user_option.theme_ids).to eq([])

      updater.update(theme_ids: [nil])
      user.reload
      expect(user.user_option.theme_ids).to eq([])

      theme = Fabricate(:theme)
      child = Fabricate(:theme, component: true)
      theme.add_relative_theme!(:child, child)
      theme.set_default!

      updater.update(theme_ids: [theme.id.to_s, child.id.to_s, """", nil])
      user.reload
      expect(user.user_option.theme_ids).to eq([theme.id, child.id])
    end

    let(:schedule_attrs) do
      {
        enabled: true,
        day_0_start_time: 30,
        day_0_end_time: 60,
        day_1_start_time: 30,
        day_1_end_time: 60,
        day_2_start_time: 30,
        day_2_end_time: 60,
        day_3_start_time: 30,
        day_3_end_time: 60,
        day_4_start_time: 30,
        day_4_end_time: 60,
        day_5_start_time: 30,
        day_5_end_time: 60,
        day_6_start_time: 30,
        day_6_end_time: 60,
      }
    end

    context ""with user_notification_schedule"" do
      it ""allows users to create their notification schedule when it doesn't exist previously"" do
        expect(user.user_notification_schedule).to be_nil
        updater = UserUpdater.new(acting_user, user)

        updater.update(user_notification_schedule: schedule_attrs)
        user.reload
        expect(user.user_notification_schedule.enabled).to eq(true)
        expect(user.user_notification_schedule.day_0_start_time).to eq(30)
        expect(user.user_notification_schedule.day_0_end_time).to eq(60)
        expect(user.user_notification_schedule.day_6_start_time).to eq(30)
        expect(user.user_notification_schedule.day_6_end_time).to eq(60)
      end

      it ""allows users to update their notification schedule"" do
        UserNotificationSchedule.create({ user: user }.merge(UserNotificationSchedule::DEFAULT))
        updater = UserUpdater.new(acting_user, user)
        updater.update(user_notification_schedule: schedule_attrs)
        user.reload
        expect(user.user_notification_schedule.enabled).to eq(true)
        expect(user.user_notification_schedule.day_0_start_time).to eq(30)
        expect(user.user_notification_schedule.day_0_end_time).to eq(60)
        expect(user.user_notification_schedule.day_6_start_time).to eq(30)
        expect(user.user_notification_schedule.day_6_end_time).to eq(60)
      end

      it ""processes the schedule and do_not_disturb_timings are created"" do
        updater = UserUpdater.new(acting_user, user)

        expect { updater.update(user_notification_schedule: schedule_attrs) }.to change {
          user.do_not_disturb_timings.count
        }.by(4)
      end

      it ""removes do_not_disturb_timings when the schedule is disabled"" do
        updater = UserUpdater.new(acting_user, user)
        updater.update(user_notification_schedule: schedule_attrs)
        expect(user.user_notification_schedule.enabled).to eq(true)

        schedule_attrs[:enabled] = false
        updater.update(user_notification_schedule: schedule_attrs)

        expect(user.user_notification_schedule.enabled).to eq(false)
        expect(user.do_not_disturb_timings.count).to eq(0)
      end
    end

    context ""when sso overrides bio"" do
      it ""does not change bio"" do
        SiteSetting.discourse_connect_url = ""https://www.example.com/sso""
        SiteSetting.enable_discourse_connect = true
        SiteSetting.discourse_connect_overrides_bio = true

        updater = UserUpdater.new(acting_user, user)

        expect(updater.update(bio_raw: ""new bio"")).to be_truthy

        user.reload
        expect(user.user_profile.bio_raw).not_to eq ""new bio""
      end
    end

    context ""when sso overrides location"" do
      it ""does not change location"" do
        SiteSetting.discourse_connect_url = ""https://www.example.com/sso""
        SiteSetting.enable_discourse_connect = true
        SiteSetting.discourse_connect_overrides_location = true

        updater = UserUpdater.new(acting_user, user)

        expect(updater.update(location: ""new location"")).to be_truthy

        user.reload
        expect(user.user_profile.location).not_to eq ""new location""
      end
    end

    context ""when sso overrides website"" do
      it ""does not change website"" do
        SiteSetting.discourse_connect_url = ""https://www.example.com/sso""
        SiteSetting.enable_discourse_connect = true
        SiteSetting.discourse_connect_overrides_website = true

        updater = UserUpdater.new(acting_user, user)

        expect(updater.update(website: ""https://google.com"")).to be_truthy

        user.reload
        expect(user.user_profile.website).not_to eq ""https://google.com""
      end
    end

    context ""when updating primary group"" do
      let(:new_group) { Group.create(name: ""new_group"") }

      it ""updates when setting is enabled"" do
        SiteSetting.user_selected_primary_groups = true
        user.groups << new_group
        user.update(primary_group_id: nil)
        UserUpdater.new(acting_user, user).update(primary_group_id: new_group.id)

        user.reload
        expect(user.primary_group_id).to eq new_group.id
      end

      it ""does not update when setting is disabled"" do
        SiteSetting.user_selected_primary_groups = false
        user.groups << new_group
        user.update(primary_group_id: nil)
        UserUpdater.new(acting_user, user).update(primary_group_id: new_group.id)

        user.reload
        expect(user.primary_group_id).to eq nil
      end

      it ""does not update when changing other profile data"" do
        SiteSetting.user_selected_primary_groups = true
        user.groups << new_group
        user.update(primary_group_id: new_group.id)
        UserUpdater.new(acting_user, user).update(website: ""http://example.com"")

        user.reload
        expect(user.primary_group_id).to eq new_group.id
      end

      it ""can be removed by the user when setting is enabled"" do
        SiteSetting.user_selected_primary_groups = true
        user.groups << new_group
        user.update(primary_group_id: new_group.id)
        UserUpdater.new(acting_user, user).update(primary_group_id: """")

        user.reload
        expect(user.primary_group_id).to eq nil
      end

      it ""cannot be removed by the user when setting is disabled"" do
        SiteSetting.user_selected_primary_groups = false
        user.groups << new_group
        user.update(primary_group_id: new_group.id)
        UserUpdater.new(acting_user, user).update(primary_group_id: """")

        user.reload
        expect(user.primary_group_id).to eq new_group.id
      end
    end

    context ""when updating flair group"" do
      let(:group) do
        Fabricate(
          :group,
          name: ""Group"",
          flair_bg_color: ""#111111"",
          flair_color: ""#999999"",
          flair_icon: ""icon"",
        )
      end

      it ""updates when setting is enabled"" do
        group.add(user)

        UserUpdater.new(acting_user, user).update(flair_group_id: group.id)
        expect(user.reload.flair_group_id).to eq(group.id)

        UserUpdater.new(acting_user, user).update(flair_group_id: """")
        expect(user.reload.flair_group_id).to eq(nil)
      end
    end

    context ""when update fails"" do
      it ""returns false"" do
        user.stubs(save: false)
        updater = UserUpdater.new(acting_user, user)

        expect(updater.update).to be_falsey
      end
    end

    context ""with permission to update title"" do
      it ""allows user to change title"" do
        user = Fabricate(:user, title: ""Emperor"")
        Guardian.any_instance.stubs(:can_grant_title?).with(user, ""Minion"").returns(true)
        updater = UserUpdater.new(acting_user, user)

        updater.update(title: ""Minion"")

        expect(user.reload.title).to eq ""Minion""
      end
    end

    context ""when title is from a badge"" do
      fab!(:user) { Fabricate(:user, title: ""Emperor"") }
      fab!(:badge) { Fabricate(:badge, name: ""Minion"") }

      context ""when badge can be used as a title"" do
        before { badge.update(allow_title: true) }

        it ""can use as title, sets granted_title_badge_id"" do
          BadgeGranter.grant(badge, user)
          updater = UserUpdater.new(user, user)
          updater.update(title: badge.name)
          user.reload
          expect(user.user_profile.granted_title_badge_id).to eq(badge.id)
        end

        it ""badge has not been granted, does not change title"" do
          badge.update(allow_title: true)
          updater = UserUpdater.new(user, user)
          updater.update(title: badge.name)
          user.reload
          expect(user.title).not_to eq(badge.name)
          expect(user.user_profile.granted_title_badge_id).to be_nil
        end

        it ""changing to a title that is not from a badge, unsets granted_title_badge_id"" do
          user.update(title: badge.name)
          user.user_profile.update(granted_title_badge_id: badge.id)

          Guardian.any_instance.stubs(:can_grant_title?).with(user, ""Dancer"").returns(true)

          updater = UserUpdater.new(user, user)
          updater.update(title: ""Dancer"")
          user.reload
          expect(user.title).to eq(""Dancer"")
          expect(user.user_profile.granted_title_badge_id).to be_nil
        end
      end

      it ""cannot use as title, does not change title"" do
        BadgeGranter.grant(badge, user)
        updater = UserUpdater.new(user, user)
        updater.update(title: badge.name)
        user.reload
        expect(user.title).not_to eq(badge.name)
        expect(user.user_profile.granted_title_badge_id).to be_nil
      end
    end

    context ""without permission to update title"" do
      it ""does not allow user to change title"" do
        user = Fabricate(:user, title: ""Emperor"")
        Guardian.any_instance.stubs(:can_grant_title?).with(user, ""Minion"").returns(false)
        updater = UserUpdater.new(acting_user, user)

        updater.update(title: ""Minion"")

        expect(user.reload.title).not_to eq ""Minion""
      end
    end

    context ""when website includes http"" do
      it ""does not add http before updating"" do
        updater = UserUpdater.new(acting_user, user)

        updater.update(website: ""http://example.com"")

        expect(user.reload.user_profile.website).to eq ""http://example.com""
      end
    end

    context ""when website does not include http"" do
      it ""adds http before updating"" do
        updater = UserUpdater.new(acting_user, user)

        updater.update(website: ""example.com"")

        expect(user.reload.user_profile.website).to eq ""http://example.com""
      end
    end

    context ""when website is invalid"" do
      it ""returns an error"" do
        updater = UserUpdater.new(acting_user, user)

        expect(updater.update(website: ""ʔ<"")).to eq nil
      end
    end

    context ""when custom_fields is empty string"" do
      it ""update is successful"" do
        user.custom_fields = { ""import_username"" => ""my_old_username"" }
        user.save
        updater = UserUpdater.new(acting_user, user)

        updater.update(website: ""example.com"", custom_fields: """")
        expect(user.reload.custom_fields).to eq(""import_username"" => ""my_old_username"")
      end
    end

    context ""when skip_new_user_tips is edited"" do
      it ""updates seen_popups too"" do
        messages =
          MessageBus.track_publish(""/user-tips/#{user.id}"") do
            UserUpdater.new(Discourse.system_user, user).update(skip_new_user_tips: true)
          end

        expect(user.user_option.skip_new_user_tips).to eq(true)
        expect(user.user_option.seen_popups).to eq([-1])
        expect(messages.map(&:data)).to contain_exactly([-1])
      end

      it ""does not reset seen_popups"" do
        user.user_option.update!(seen_popups: [1, 2, 3])

        UserUpdater.new(Discourse.system_user, user).update(skip_new_user_tips: false)

        expect(user.user_option.skip_new_user_tips).to eq(false)
        expect(user.user_option.seen_popups).to eq([1, 2, 3])
      end
    end

    context ""when seen_popups is edited"" do
      it ""publishes a message"" do
        messages =
          MessageBus.track_publish(""/user-tips/#{user.id}"") do
            UserUpdater.new(Discourse.system_user, user).update(seen_popups: [1])
          end

        expect(user.user_option.seen_popups).to eq([1])
        expect(messages.map(&:data)).to contain_exactly([1])
      end
    end

    it ""logs the action"" do
      user = Fabricate(:user, name: ""Billy Bob"")

      expect do UserUpdater.new(user, user).update(name: ""Jim Tom"") end.to change {
        UserHistory.count
      }.by(1)

      expect(UserHistory.last.action).to eq(UserHistory.actions[:change_name])

      expect do UserUpdater.new(user, user).update(name: ""JiM TOm"") end.to_not change {
        UserHistory.count
      }

      expect do UserUpdater.new(user, user).update(bio_raw: ""foo bar"") end.to_not change {
        UserHistory.count
      }

      user_without_name = Fabricate(:user, name: nil)

      expect do
        UserUpdater.new(user_without_name, user_without_name).update(bio_raw: ""foo bar"")
      end.to_not change { UserHistory.count }

      expect do
        UserUpdater.new(user_without_name, user_without_name).update(name: ""Jim Tom"")
      end.to change { UserHistory.count }.by(1)

      expect(UserHistory.last.action).to eq(UserHistory.actions[:change_name])

      expect do UserUpdater.new(user, user).update(name: """") end.to change { UserHistory.count }.by(
        1,
      )

      expect(UserHistory.last.action).to eq(UserHistory.actions[:change_name])
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class RandomTopicSelector
  BACKFILL_SIZE = 3000
  BACKFILL_LOW_WATER_MARK = 500

  def self.backfill(category = nil)
    exclude = category&.topic_id

    options = {
      per_page: category ? category.num_featured_topics : 3,
      visible: true,
      no_definitions: true,
    }

    options[:except_topic_ids] = [category.topic_id] if exclude

    if category
      options[:category] = category.id
      # NOTE: at the moment this site setting scopes tightly to a category (excluding subcats)
      # this is done so we don't populate a junk cache
      options[:no_subcategories] = true if SiteSetting.limit_suggested_to_category

      # don't leak private categories into the ""everything"" group
      options[:guardian] = Guardian.new(Discourse.system_user)
    end

    query = TopicQuery.new(nil, options)

    results =
      query
        .latest_results
        .order(""RANDOM()"")
        .where(closed: false, archived: false)
        .where(""topics.created_at > ?"", SiteSetting.suggested_topics_max_days_old.days.ago)
        .limit(BACKFILL_SIZE)
        .reorder(""RANDOM()"")
        .pluck(:id)

    key = cache_key(category)

    if results.present?
      Discourse.redis.multi do |transaction|
        transaction.rpush(key, results)
        transaction.expire(key, 2.days)
      end
    end

    results
  end

  def self.next(count, category = nil)
    key = cache_key(category)

    results = []

    return results if count < 1

    results =
      Discourse.redis.multi do |transaction|
        transaction.lrange(key, 0, count - 1)
        transaction.ltrim(key, count, -1)
      end

    if !results.is_a?(Array) # Redis is in readonly mode
      results = Discourse.redis.lrange(key, 0, count - 1)
    else
      results = results[0]
    end

    results.map!(&:to_i)

    left = count - results.length

    backfilled = false
    if left > 0
      ids = backfill(category)
      backfilled = true
      results += ids[0...count]
      results.uniq!
      results = results[0...count]
    end

    if !backfilled && Discourse.redis.llen(key) < BACKFILL_LOW_WATER_MARK
      Scheduler::Defer.later(""backfill"") { backfill(category) }
    end

    results
  end

  def self.cache_key(category = nil)
    ""random_topic_cache_#{category&.id}""
  end
end

```","# frozen_string_literal: true

RSpec.describe RandomTopicSelector do
  it ""can correctly use cache"" do
    key = RandomTopicSelector.cache_key

    Discourse.redis.del key

    4.times { |t| Discourse.redis.rpush key, t }

    expect(RandomTopicSelector.next(0)).to eq([])
    expect(RandomTopicSelector.next(2)).to eq([0, 1])

    Discourse.redis.expects(:multi).returns(Discourse.received_redis_readonly!)
    expect(RandomTopicSelector.next(2)).to eq([2, 3])
    Discourse.redis.unstub(:multi)

    expect(RandomTopicSelector.next(2)).to eq([2, 3])
    expect(RandomTopicSelector.next(2)).to eq([])
  end

  it ""can correctly backfill"" do
    category = Fabricate(:category, sort_order: ""op_likes"")
    t1 = Fabricate(:topic, category_id: category.id)
    _t2 = Fabricate(:topic, category_id: category.id, visible: false)
    _t3 = Fabricate(:topic, category_id: category.id, deleted_at: 1.minute.ago)
    t4 = Fabricate(:topic, category_id: category.id)

    expect(RandomTopicSelector.next(5, category).sort).to eq([t1.id, t4.id].sort)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class BadgeGranter
  class GrantError < StandardError
  end

  def self.disable_queue
    @queue_disabled = true
  end

  def self.enable_queue
    @queue_disabled = false
  end

  def initialize(badge, user, opts = {})
    @badge, @user, @opts = badge, user, opts
    @granted_by = opts[:granted_by] || Discourse.system_user
    @post_id = opts[:post_id]
  end

  def self.grant(badge, user, opts = {})
    BadgeGranter.new(badge, user, opts).grant
  end

  def self.enqueue_mass_grant_for_users(
    badge,
    emails: [],
    usernames: [],
    ensure_users_have_badge_once: true
  )
    emails = emails.map(&:downcase)
    usernames = usernames.map(&:downcase)
    usernames_map_to_ids = {}
    emails_map_to_ids = {}
    if usernames.size > 0
      usernames_map_to_ids = User.where(username_lower: usernames).pluck(:username_lower, :id).to_h
    end
    if emails.size > 0
      emails_map_to_ids = User.with_email(emails).pluck(""LOWER(user_emails.email)"", :id).to_h
    end

    count_per_user = {}
    unmatched = Set.new
    (usernames + emails).each do |entry|
      id = usernames_map_to_ids[entry] || emails_map_to_ids[entry]
      if id.blank?
        unmatched << entry
        next
      end

      if ensure_users_have_badge_once
        count_per_user[id] = 1
      else
        count_per_user[id] ||= 0
        count_per_user[id] += 1
      end
    end

    existing_owners_ids = []
    if ensure_users_have_badge_once
      existing_owners_ids = UserBadge.where(badge: badge).distinct.pluck(:user_id)
    end
    count_per_user.each do |user_id, count|
      next if ensure_users_have_badge_once && existing_owners_ids.include?(user_id)

      Jobs.enqueue(:mass_award_badge, user: user_id, badge: badge.id, count: count)
    end

    {
      unmatched_entries: unmatched.to_a,
      matched_users_count: count_per_user.size,
      unmatched_entries_count: unmatched.size,
    }
  end

  def self.mass_grant(badge, user, count:)
    return if !badge.enabled?

    raise ArgumentError.new(""count can't be less than 1"") if count < 1

    UserBadge.transaction do
      DB.exec(
        <<~SQL * count,
        INSERT INTO user_badges
        (granted_at, created_at, granted_by_id, user_id, badge_id, seq)
        VALUES
        (
          :now,
          :now,
          :system,
          :user_id,
          :badge_id,
          COALESCE((
            SELECT MAX(seq) + 1
            FROM user_badges
            WHERE badge_id = :badge_id AND user_id = :user_id
          ), 0)
        );
      SQL
        now: Time.zone.now,
        system: Discourse.system_user.id,
        user_id: user.id,
        badge_id: badge.id,
      )
      notification = send_notification(user.id, user.username, user.locale, badge)

      DB.exec(<<~SQL, notification_id: notification.id, user_id: user.id, badge_id: badge.id)
        UPDATE user_badges
        SET notification_id = :notification_id
        WHERE notification_id IS NULL AND user_id = :user_id AND badge_id = :badge_id
      SQL

      UserBadge.update_featured_ranks!(user.id)
    end
  end

  def grant
    return if @granted_by && !Guardian.new(@granted_by).can_grant_badges?(@user)
    return unless @badge.present? && @badge.enabled?
    return if @user.blank?

    find_by = { badge_id: @badge.id, user_id: @user.id }

    find_by[:post_id] = @post_id if @badge.multiple_grant?

    user_badge = UserBadge.find_by(find_by)

    if user_badge.nil? || (@badge.multiple_grant? && @post_id.nil?)
      UserBadge.transaction do
        seq = 0
        if @badge.multiple_grant?
          seq = UserBadge.where(badge: @badge, user: @user).maximum(:seq)
          seq = (seq || -1) + 1
        end

        user_badge =
          UserBadge.create!(
            badge: @badge,
            user: @user,
            granted_by: @granted_by,
            granted_at: @opts[:created_at] || Time.now,
            post_id: @post_id,
            seq: seq,
          )

        return unless SiteSetting.enable_badges

        if @granted_by != Discourse.system_user
          StaffActionLogger.new(@granted_by).log_badge_grant(user_badge)
        end

        skip_new_user_tips = @user.user_option.skip_new_user_tips
        unless self.class.suppress_notification?(@badge, user_badge.granted_at, skip_new_user_tips)
          notification =
            self.class.send_notification(@user.id, @user.username, @user.effective_locale, @badge)
          user_badge.update!(notification_id: notification.id)
        end
      end
    end

    user_badge
  end

  def self.revoke(user_badge, options = {})
    UserBadge.transaction do
      user_badge.destroy!
      if options[:revoked_by]
        StaffActionLogger.new(options[:revoked_by]).log_badge_revoke(user_badge)
      end

      # If the user's title is the same as the badge name OR the custom badge name, remove their title.
      custom_badge_name =
        TranslationOverride.find_by(translation_key: user_badge.badge.translation_key)&.value
      user_title_is_badge_name = user_badge.user.title == user_badge.badge.name
      user_title_is_custom_badge_name =
        custom_badge_name.present? && user_badge.user.title == custom_badge_name

      if user_title_is_badge_name || user_title_is_custom_badge_name
        if options[:revoked_by]
          StaffActionLogger.new(options[:revoked_by]).log_title_revoke(
            user_badge.user,
            revoke_reason: ""user title was same as revoked badge name or custom badge name"",
            previous_value: user_badge.user.title,
          )
        end
        user_badge.user.title = nil
        user_badge.user.save!
      end
    end
  end

  def self.revoke_all(badge)
    custom_badge_names =
      TranslationOverride.where(translation_key: badge.translation_key).pluck(:value)

    users =
      User.joins(:user_badges).where(user_badges: { badge_id: badge.id }).where(title: badge.name)
    users =
      users.or(
        User.joins(:user_badges).where(title: custom_badge_names),
      ) unless custom_badge_names.empty?
    users.update_all(title: nil)

    UserBadge.where(badge: badge).delete_all
  end

  def self.queue_badge_grant(type, opt)
    return if !SiteSetting.enable_badges || @queue_disabled
    payload = nil

    case type
    when Badge::Trigger::PostRevision
      post = opt[:post]
      payload = { type: ""PostRevision"", post_ids: [post.id] }
    when Badge::Trigger::UserChange
      user = opt[:user]
      payload = { type: ""UserChange"", user_ids: [user.id] }
    when Badge::Trigger::TrustLevelChange
      user = opt[:user]
      payload = { type: ""TrustLevelChange"", user_ids: [user.id] }
    when Badge::Trigger::PostAction
      action = opt[:post_action]
      payload = { type: ""PostAction"", post_ids: [action.post_id, action.related_post_id].compact! }
    end

    Discourse.redis.lpush queue_key, payload.to_json if payload
  end

  def self.clear_queue!
    Discourse.redis.del queue_key
  end

  def self.process_queue!
    limit = 1000
    items = []
    while limit > 0 && item = Discourse.redis.lpop(queue_key)
      items << JSON.parse(item)
      limit -= 1
    end

    items = items.group_by { |i| i[""type""] }

    items.each do |type, list|
      post_ids = list.flat_map { |i| i[""post_ids""] }.compact.uniq
      user_ids = list.flat_map { |i| i[""user_ids""] }.compact.uniq

      next unless post_ids.present? || user_ids.present?

      find_by_type(type).each { |badge| backfill(badge, post_ids: post_ids, user_ids: user_ids) }
    end
  end

  def self.find_by_type(type)
    Badge.where(trigger: ""Badge::Trigger::#{type}"".constantize)
  end

  def self.queue_key
    ""badge_queue""
  end

  # Options:
  #   :target_posts - whether the badge targets posts
  #   :trigger - the Badge::Trigger id
  def self.contract_checks!(sql, opts = {})
    return if sql.blank?

    if Badge::Trigger.uses_post_ids?(opts[:trigger])
      unless sql.match(/:post_ids/)
        raise(
          ""Contract violation:\nQuery triggers on posts, but does not reference the ':post_ids' array"",
        )
      end
      if sql.match(/:user_ids/)
        raise ""Contract violation:\nQuery triggers on posts, but references the ':user_ids' array""
      end
    end

    if Badge::Trigger.uses_user_ids?(opts[:trigger])
      unless sql.match(/:user_ids/)
        raise ""Contract violation:\nQuery triggers on users, but does not reference the ':user_ids' array""
      end
      if sql.match(/:post_ids/)
        raise ""Contract violation:\nQuery triggers on users, but references the ':post_ids' array""
      end
    end

    if opts[:trigger] && !Badge::Trigger.is_none?(opts[:trigger])
      unless sql.match(/:backfill/)
        raise ""Contract violation:\nQuery is triggered, but does not reference the ':backfill' parameter.\n(Hint: if :backfill is TRUE, you should ignore the :post_ids/:user_ids)""
      end
    end

    # TODO these three conditions have a lot of false negatives
    if opts[:target_posts]
      unless sql.match(/post_id/)
        raise ""Contract violation:\nQuery targets posts, but does not return a 'post_id' column""
      end
    end

    unless sql.match(/user_id/)
      raise ""Contract violation:\nQuery does not return a 'user_id' column""
    end
    unless sql.match(/granted_at/)
      raise ""Contract violation:\nQuery does not return a 'granted_at' column""
    end
    if sql.match(/;\s*\z/)
      raise ""Contract violation:\nQuery ends with a semicolon. Remove the semicolon; your sql will be used in a subquery.""
    end
  end

  # Options:
  #   :target_posts - whether the badge targets posts
  #   :trigger - the Badge::Trigger id
  #   :explain - return the EXPLAIN query
  def self.preview(sql, opts = {})
    params = { user_ids: [], post_ids: [], backfill: true }

    BadgeGranter.contract_checks!(sql, opts)

    # hack to allow for params, otherwise sanitizer will trigger sprintf
    count_sql = <<~SQL
      SELECT COUNT(*) count
                 FROM (
                        #{sql}
                      ) q
                WHERE :backfill = :backfill
    SQL
    grant_count = DB.query_single(count_sql, params).first.to_i

    grants_sql =
      if opts[:target_posts]
        <<~SQL
        SELECT u.id, u.username, q.post_id, t.title, q.granted_at
          FROM (
                 #{sql}
               ) q
          JOIN users u on u.id = q.user_id
     LEFT JOIN badge_posts p on p.id = q.post_id
     LEFT JOIN topics t on t.id = p.topic_id
         WHERE :backfill = :backfill
         LIMIT 10
      SQL
      else
        <<~SQL
        SELECT u.id, u.username, q.granted_at
         FROM (
                #{sql}
              ) q
         JOIN users u on u.id = q.user_id
        WHERE :backfill = :backfill
        LIMIT 10
      SQL
      end

    query_plan = nil
    # HACK: active record sanitization too flexible, force it to go down the sanitization path that cares not for % stuff
    # note mini_sql uses AR sanitizer at the moment (review if changed)
    query_plan = DB.query_hash(""EXPLAIN #{sql} /*:backfill*/"", params) if opts[:explain]

    sample = DB.query(grants_sql, params)

    sample.each do |result|
      unless User.exists?(id: result.id)
        raise ""Query returned a non-existent user ID:\n#{result.id}""
      end
      unless result.granted_at
        raise ""Query did not return a badge grant time\n(Try using 'current_timestamp granted_at')""
      end
      if opts[:target_posts]
        raise ""Query did not return a post ID"" unless result.post_id
        unless Post.exists?(result.post_id).present?
          raise ""Query returned a non-existent post ID:\n#{result.post_id}""
        end
      end
    end

    { grant_count: grant_count, sample: sample, query_plan: query_plan }
  rescue => e
    { errors: e.message }
  end

  MAX_ITEMS_FOR_DELTA ||= 200
  def self.backfill(badge, opts = nil)
    return unless SiteSetting.enable_badges
    return unless badge.enabled
    return unless badge.query.present?

    post_ids = user_ids = nil
    post_ids = opts[:post_ids] if opts
    user_ids = opts[:user_ids] if opts

    # safeguard fall back to full backfill if more than 200
    if (post_ids && post_ids.size > MAX_ITEMS_FOR_DELTA) ||
         (user_ids && user_ids.size > MAX_ITEMS_FOR_DELTA)
      post_ids = nil
      user_ids = nil
    end

    post_ids = nil if post_ids.blank?
    user_ids = nil if user_ids.blank?

    full_backfill = !user_ids && !post_ids

    post_clause = badge.target_posts ? ""AND (q.post_id = ub.post_id OR NOT :multiple_grant)"" : """"
    post_id_field = badge.target_posts ? ""q.post_id"" : ""NULL""

    sql = <<~SQL
      DELETE FROM user_badges
        WHERE id IN (
          SELECT ub.id
          FROM user_badges ub
          LEFT JOIN (
            #{badge.query}
          ) q ON q.user_id = ub.user_id
          #{post_clause}
          WHERE ub.badge_id = :id AND q.user_id IS NULL
        )
    SQL

    if badge.auto_revoke && full_backfill
      DB.exec(
        sql,
        id: badge.id,
        post_ids: [-1],
        user_ids: [-2],
        backfill: true,
        multiple_grant: true, # cheat here, cause we only run on backfill and are deleting
      )
    end

    sql = <<~SQL
      WITH w as (
        INSERT INTO user_badges(badge_id, user_id, granted_at, granted_by_id, created_at, post_id)
        SELECT :id, q.user_id, q.granted_at, -1, current_timestamp, #{post_id_field}
          FROM (
                 #{badge.query}
               ) q
     LEFT JOIN user_badges ub ON ub.badge_id = :id AND ub.user_id = q.user_id
        #{post_clause}
        /*where*/
        ON CONFLICT DO NOTHING
        RETURNING id, user_id, granted_at
      )
      SELECT w.*, username, locale, (u.admin OR u.moderator) AS staff, uo.skip_new_user_tips
        FROM w
        JOIN users u on u.id = w.user_id
        JOIN user_options uo ON uo.user_id = w.user_id
    SQL

    builder = DB.build(sql)
    builder.where(""ub.badge_id IS NULL AND q.user_id > 0"")

    if (post_ids || user_ids) && !badge.query.include?("":backfill"")
      Rails.logger.warn ""Your triggered badge query for #{badge.name} does not include the :backfill param, skipping!""
      return
    end

    if post_ids && !badge.query.include?("":post_ids"")
      Rails.logger.warn ""Your triggered badge query for #{badge.name} does not include the :post_ids param, skipping!""
      return
    end

    if user_ids && !badge.query.include?("":user_ids"")
      Rails.logger.warn ""Your triggered badge query for #{badge.name} does not include the :user_ids param, skipping!""
      return
    end

    builder
      .query(
        id: badge.id,
        multiple_grant: badge.multiple_grant,
        backfill: full_backfill,
        post_ids: post_ids || [-2],
        user_ids: user_ids || [-2],
      )
      .each do |row|
        next if suppress_notification?(badge, row.granted_at, row.skip_new_user_tips)
        next if row.staff && badge.awarded_for_trust_level?

        notification = send_notification(row.user_id, row.username, row.locale, badge)
        UserBadge.trigger_user_badge_granted_event(badge.id, row.user_id)

        DB.exec(
          ""UPDATE user_badges SET notification_id = :notification_id WHERE id = :id"",
          notification_id: notification.id,
          id: row.id,
        )
      end

    badge.reset_grant_count!
  rescue => e
    raise GrantError, ""Failed to backfill '#{badge.name}' badge: #{opts}. Reason: #{e.message}""
  end

  def self.revoke_ungranted_titles!
    DB.exec <<~SQL
      UPDATE users u
      SET title = ''
      FROM user_profiles up
      WHERE u.title IS NOT NULL
        AND u.title <> ''
        AND up.user_id = u.id
        AND up.granted_title_badge_id IS NOT NULL
        AND NOT EXISTS(
          SELECT 1
          FROM badges b
                 JOIN user_badges ub ON ub.user_id = u.id AND ub.badge_id = b.id
          WHERE b.id = up.granted_title_badge_id
            AND b.allow_title
            AND b.enabled
        )
    SQL

    DB.exec <<~SQL
      UPDATE user_profiles up
      SET granted_title_badge_id = NULL
      FROM users u
      WHERE up.user_id = u.id
        AND (u.title IS NULL OR u.title = '')
        AND up.granted_title_badge_id IS NOT NULL
    SQL
  end

  def self.notification_locale(locale)
    use_default_locale = !SiteSetting.allow_user_locale || locale.blank?
    use_default_locale ? SiteSetting.default_locale : locale
  end

  def self.send_notification(user_id, username, locale, badge)
    I18n.with_locale(notification_locale(locale)) do
      Notification.create!(
        user_id: user_id,
        notification_type: Notification.types[:granted_badge],
        data: {
          badge_id: badge.id,
          badge_name: badge.display_name,
          badge_slug: badge.slug,
          badge_title: badge.allow_title,
          username: username,
        }.to_json,
      )
    end
  end

  def self.suppress_notification?(badge, granted_at, skip_new_user_tips)
    is_old_bronze_badge = badge.badge_type_id == BadgeType::Bronze && granted_at < 2.days.ago
    skip_beginner_badge = skip_new_user_tips && badge.for_beginners?

    is_old_bronze_badge || skip_beginner_badge
  end
end

```","# frozen_string_literal: true

RSpec.describe BadgeGranter do
  fab!(:badge)
  fab!(:user)

  before { BadgeGranter.enable_queue }

  after do
    BadgeGranter.disable_queue
    BadgeGranter.clear_queue!
  end

  describe ""revoke_titles"" do
    let(:user) { Fabricate(:user) }
    let(:badge) { Fabricate(:badge, allow_title: true) }

    it ""revokes title when badge is not allowed as title"" do
      BadgeGranter.grant(badge, user)
      user.update!(title: badge.name)

      BadgeGranter.revoke_ungranted_titles!
      user.reload
      expect(user.title).to eq(badge.name)
      expect(user.user_profile.granted_title_badge_id).to eq(badge.id)

      badge.update_column(:allow_title, false)
      BadgeGranter.revoke_ungranted_titles!
      user.reload
      expect(user.title).to be_blank
      expect(user.user_profile.granted_title_badge_id).to be_nil
    end

    it ""revokes title when badge is disabled"" do
      BadgeGranter.grant(badge, user)
      user.update!(title: badge.name)

      BadgeGranter.revoke_ungranted_titles!
      user.reload
      expect(user.title).to eq(badge.name)
      expect(user.user_profile.granted_title_badge_id).to eq(badge.id)

      badge.update_column(:enabled, false)
      BadgeGranter.revoke_ungranted_titles!
      user.reload
      expect(user.title).to be_blank
      expect(user.user_profile.granted_title_badge_id).to be_nil
    end

    it ""revokes title when user badge is revoked"" do
      BadgeGranter.grant(badge, user)
      user.update!(title: badge.name)

      BadgeGranter.revoke_ungranted_titles!
      user.reload
      expect(user.title).to eq(badge.name)
      expect(user.user_profile.granted_title_badge_id).to eq(badge.id)

      BadgeGranter.revoke(user.user_badges.first)
      BadgeGranter.revoke_ungranted_titles!
      user.reload
      expect(user.title).to be_blank
      expect(user.user_profile.granted_title_badge_id).to be_nil
    end

    it ""does not revoke custom title"" do
      user.title = ""CEO""
      user.save!

      BadgeGranter.revoke_ungranted_titles!

      user.reload
      expect(user.title).to eq(""CEO"")
    end

    it ""does not revoke localized title"" do
      badge = Badge.find(Badge::Regular)
      badge_name = nil
      BadgeGranter.grant(badge, user)

      I18n.with_locale(:de) do
        badge_name = badge.display_name
        user.update!(title: badge_name)
      end

      user.reload
      expect(user.title).to eq(badge_name)
      expect(user.user_profile.granted_title_badge_id).to eq(badge.id)

      BadgeGranter.revoke_ungranted_titles!
      user.reload
      expect(user.title).to eq(badge_name)
      expect(user.user_profile.granted_title_badge_id).to eq(badge.id)
    end
  end

  describe ""preview"" do
    it ""can correctly preview"" do
      Fabricate(:user, email: ""sam@gmail.com"")
      result =
        BadgeGranter.preview(
          'select u.id user_id, null post_id, u.created_at granted_at from users u
                                     join user_emails ue on ue.user_id = u.id AND ue.primary
                                     where ue.email like \'%gmail.com\'',
          explain: true,
        )

      expect(result[:grant_count]).to eq(1)
      expect(result[:query_plan]).to be_present
    end

    it ""with badges containing trailing comments do not break generated SQL"" do
      query = Badge.find(1).query + ""\n-- a comment""
      expect(BadgeGranter.preview(query)[:errors]).to be_nil
    end
  end

  describe ""backfill"" do
    it ""has no broken badge queries"" do
      Badge.all.each { |b| BadgeGranter.backfill(b) }
    end

    it ""can backfill the welcome badge"" do
      post = Fabricate(:post)
      user2 = Fabricate(:user)
      PostActionCreator.like(user2, post)

      UserBadge.destroy_all
      BadgeGranter.backfill(Badge.find(Badge::Welcome))
      BadgeGranter.backfill(Badge.find(Badge::FirstLike))

      b = UserBadge.find_by(user_id: post.user_id)
      expect(b.post_id).to eq(post.id)
      b.badge_id = Badge::Welcome

      b = UserBadge.find_by(user_id: user2.id)
      expect(b.post_id).to eq(post.id)
      b.badge_id = Badge::FirstLike
    end

    it ""should grant missing badges"" do
      nice_topic = Badge.find(Badge::NiceTopic)
      good_topic = Badge.find(Badge::GoodTopic)

      post = Fabricate(:post, like_count: 30)

      2.times do
        BadgeGranter.backfill(nice_topic, post_ids: [post.id])
        BadgeGranter.backfill(good_topic)
      end

      # TODO add welcome
      expect(post.user.user_badges.pluck(:badge_id)).to contain_exactly(
        nice_topic.id,
        good_topic.id,
      )
      expect(post.user.notifications.count).to eq(2)

      data = post.user.notifications.last.data_hash
      expect(data[""badge_id""]).to eq(good_topic.id)
      expect(data[""badge_slug""]).to eq(good_topic.slug)
      expect(data[""username""]).to eq(post.user.username)

      expect(nice_topic.grant_count).to eq(1)
      expect(good_topic.grant_count).to eq(1)
    end

    it ""should grant badges in the user locale"" do
      SiteSetting.allow_user_locale = true

      nice_topic = Badge.find(Badge::NiceTopic)
      name_english = nice_topic.name

      user = Fabricate(:user, locale: ""fr"")
      post = Fabricate(:post, like_count: 10, user: user)

      BadgeGranter.backfill(nice_topic)

      notification_badge_name = JSON.parse(post.user.notifications.first.data)[""badge_name""]

      expect(notification_badge_name).not_to eq(name_english)
    end

    it ""with badges containing trailing comments do not break generated SQL"" do
      badge = Fabricate(:badge)
      badge.query = Badge.find(1).query + ""\n-- a comment""
      expect { BadgeGranter.backfill(badge) }.not_to raise_error
    end

    it 'does not notify about badges ""for beginners"" when user skipped new user tips' do
      user.user_option.update!(skip_new_user_tips: true)
      post = Fabricate(:post)
      PostActionCreator.like(user, post)

      expect { BadgeGranter.backfill(Badge.find(Badge::FirstLike)) }.to_not change {
        Notification.where(user_id: user.id).count
      }
    end

    it ""does not grant sharing badges to deleted users"" do
      post = Fabricate(:post)
      incoming_links = Fabricate.times(25, :incoming_link, post: post, user: user)
      user_id = user.id
      user.destroy!

      nice_share = Badge.find(Badge::NiceShare)
      first_share = Badge.find(Badge::FirstShare)

      BadgeGranter.backfill(nice_share)
      BadgeGranter.backfill(first_share)

      expect(UserBadge.where(user_id: user_id).count).to eq(0)
    end
  end

  describe ""grant"" do
    it ""allows overriding of granted_at does not notify old bronze"" do
      freeze_time
      badge = Badge.create!(name: ""a badge"", badge_type_id: BadgeType::Bronze)
      user_badge = BadgeGranter.grant(badge, user, created_at: 1.year.ago)

      expect(user_badge.granted_at).to eq_time(1.year.ago)
      expect(Notification.where(user_id: user.id).count).to eq(0)
    end

    it ""handles deleted badge"" do
      freeze_time
      user_badge = BadgeGranter.grant(nil, user, created_at: 1.year.ago)
      expect(user_badge).to eq(nil)
    end

    it ""doesn't grant disabled badges"" do
      freeze_time
      badge = Fabricate(:badge, badge_type_id: BadgeType::Bronze, enabled: false)

      user_badge = BadgeGranter.grant(badge, user, created_at: 1.year.ago)
      expect(user_badge).to eq(nil)
    end

    it ""doesn't notify about badges 'for beginners' when user skipped new user tips"" do
      freeze_time
      UserBadge.destroy_all
      user.user_option.update!(skip_new_user_tips: true)
      badge = Fabricate(:badge, badge_grouping_id: BadgeGrouping::GettingStarted)

      expect { BadgeGranter.grant(badge, user) }.to_not change {
        Notification.where(user_id: user.id).count
      }
    end

    it ""notifies about the New User of the Month badge when user skipped new user tips"" do
      freeze_time
      user.user_option.update!(skip_new_user_tips: true)
      badge = Badge.find(Badge::NewUserOfTheMonth)

      expect { BadgeGranter.grant(badge, user) }.to change {
        Notification.where(user_id: user.id).count
      }
    end

    it ""grants multiple badges"" do
      badge = Fabricate(:badge, multiple_grant: true)
      user_badge = BadgeGranter.grant(badge, user)
      user_badge = BadgeGranter.grant(badge, user)
      expect(user_badge).to be_present

      expect(UserBadge.where(user_id: user.id).count).to eq(2)
    end

    it ""sets granted_at"" do
      day_ago = freeze_time 1.day.ago
      user_badge = BadgeGranter.grant(badge, user)

      expect(user_badge.granted_at).to eq_time(day_ago)
    end

    it ""sets granted_by if the option is present"" do
      admin = Fabricate(:admin)
      StaffActionLogger.any_instance.expects(:log_badge_grant).once
      user_badge = BadgeGranter.grant(badge, user, granted_by: admin)
      expect(user_badge.granted_by).to eq(admin)
    end

    it ""defaults granted_by to the system user"" do
      StaffActionLogger.any_instance.expects(:log_badge_grant).never
      user_badge = BadgeGranter.grant(badge, user)
      expect(user_badge.granted_by_id).to eq(Discourse.system_user.id)
    end

    it ""does not allow a regular user to grant badges"" do
      user_badge = BadgeGranter.grant(badge, user, granted_by: Fabricate(:user))
      expect(user_badge).not_to be_present
    end

    it ""increments grant_count on the badge and creates a notification"" do
      BadgeGranter.grant(badge, user)
      expect(badge.reload.grant_count).to eq(1)
      expect(
        user.notifications.find_by(notification_type: Notification.types[:granted_badge]).data_hash[
          ""badge_id""
        ],
      ).to eq(badge.id)
    end

    it ""does not fail when user is missing"" do
      BadgeGranter.grant(badge, nil)
      expect(badge.reload.grant_count).to eq(0)
    end
  end

  describe ""revoke"" do
    fab!(:admin)
    let!(:user_badge) { BadgeGranter.grant(badge, user) }

    it ""revokes the badge and does necessary cleanup"" do
      user.title = badge.name
      user.save!
      expect(badge.reload.grant_count).to eq(1)
      StaffActionLogger.any_instance.expects(:log_badge_revoke).with(user_badge)
      BadgeGranter.revoke(user_badge, revoked_by: admin)
      expect(UserBadge.find_by(user: user, badge: badge)).not_to be_present
      expect(badge.reload.grant_count).to eq(0)
      expect(
        user.notifications.where(notification_type: Notification.types[:granted_badge]),
      ).to be_empty
      expect(user.reload.title).to eq(nil)
    end

    context ""when the badge name is customized, and the customized name is the same as the user title"" do
      let(:customized_badge_name) { ""Merit Badge"" }

      before do
        TranslationOverride.upsert!(I18n.locale, Badge.i18n_key(badge.name), customized_badge_name)
      end

      it ""revokes the badge and title and does necessary cleanup"" do
        user.title = customized_badge_name
        user.save!
        expect(badge.reload.grant_count).to eq(1)
        StaffActionLogger.any_instance.expects(:log_badge_revoke).with(user_badge)
        StaffActionLogger
          .any_instance
          .expects(:log_title_revoke)
          .with(
            user,
            revoke_reason: ""user title was same as revoked badge name or custom badge name"",
            previous_value: user_badge.user.title,
          )
        BadgeGranter.revoke(user_badge, revoked_by: admin)
        expect(UserBadge.find_by(user: user, badge: badge)).not_to be_present
        expect(badge.reload.grant_count).to eq(0)
        expect(
          user.notifications.where(notification_type: Notification.types[:granted_badge]),
        ).to be_empty
        expect(user.reload.title).to eq(nil)
      end

      after { TranslationOverride.revert!(I18n.locale, Badge.i18n_key(badge.name)) }
    end
  end

  describe ""revoke_all"" do
    it ""deletes every user_badge record associated with that badge"" do
      described_class.grant(badge, user)
      described_class.revoke_all(badge)

      expect(UserBadge.exists?(badge: badge, user: user)).to eq(false)
    end

    it ""removes titles"" do
      another_title = ""another title""
      described_class.grant(badge, user)
      user.update!(title: badge.name)
      user2 = Fabricate(:user, title: another_title)

      described_class.revoke_all(badge)

      expect(user.reload.title).to be_nil
      expect(user2.reload.title).to eq(another_title)
    end

    it ""removes custom badge titles"" do
      custom_badge_title = ""this is a badge title""
      TranslationOverride.create!(
        translation_key: badge.translation_key,
        value: custom_badge_title,
        locale: ""en"",
      )
      described_class.grant(badge, user)
      user.update!(title: custom_badge_title)

      described_class.revoke_all(badge)

      expect(user.reload.title).to be_nil
    end
  end

  describe ""update_badges"" do
    fab!(:user)
    fab!(:liker) { Fabricate(:user) }

    it ""grants autobiographer"" do
      user.user_profile.bio_raw = ""THIS IS MY bio it a long bio I like my bio""
      user.uploaded_avatar_id = 10
      user.user_profile.save
      user.save

      BadgeGranter.process_queue!
      expect(UserBadge.where(user_id: user.id, badge_id: Badge::Autobiographer).count).to eq(1)
    end

    it ""grants read guidelines"" do
      user.user_stat.read_faq = Time.now
      user.user_stat.save

      BadgeGranter.process_queue!
      expect(UserBadge.where(user_id: user.id, badge_id: Badge::ReadGuidelines).count).to eq(1)
    end

    it ""grants first link"" do
      post = create_post
      post2 = create_post(raw: ""#{Discourse.base_url}/t/slug/#{post.topic_id}"")

      BadgeGranter.process_queue!
      expect(UserBadge.where(user_id: post2.user.id, badge_id: Badge::FirstLink).count).to eq(1)
    end

    it ""grants first edit"" do
      SiteSetting.editing_grace_period = 0
      post = create_post
      user = post.user

      expect(UserBadge.where(user_id: user.id, badge_id: Badge::Editor).count).to eq(0)

      PostRevisor.new(post).revise!(user, raw: ""This is my new test 1235 123"")
      BadgeGranter.process_queue!

      expect(UserBadge.where(user_id: user.id, badge_id: Badge::Editor).count).to eq(1)
    end

    it ""grants and revokes trust level badges"" do
      user.change_trust_level!(TrustLevel[4])
      BadgeGranter.process_queue!
      expect(UserBadge.where(user_id: user.id, badge_id: Badge.trust_level_badge_ids).count).to eq(
        4,
      )

      user.change_trust_level!(TrustLevel[1])
      BadgeGranter.backfill(Badge.find(1))
      BadgeGranter.backfill(Badge.find(2))
      expect(UserBadge.where(user_id: user.id, badge_id: 1).first).not_to eq(nil)
      expect(UserBadge.where(user_id: user.id, badge_id: 2).first).to eq(nil)
    end

    it ""grants system like badges"" do
      post = create_post(user: user)
      # Welcome badge
      action = PostActionCreator.like(liker, post).post_action
      BadgeGranter.process_queue!
      expect(UserBadge.find_by(user_id: user.id, badge_id: 5)).not_to eq(nil)

      post = create_post(topic: post.topic, user: user)
      action = PostActionCreator.like(liker, post).post_action

      # Nice post badge
      post.update like_count: 10

      BadgeGranter.queue_badge_grant(Badge::Trigger::PostAction, post_action: action)
      BadgeGranter.process_queue!

      expect(UserBadge.find_by(user_id: user.id, badge_id: Badge::NicePost)).not_to eq(nil)
      expect(UserBadge.where(user_id: user.id, badge_id: Badge::NicePost).count).to eq(1)

      # Good post badge
      post.update like_count: 25
      BadgeGranter.queue_badge_grant(Badge::Trigger::PostAction, post_action: action)
      BadgeGranter.process_queue!
      expect(UserBadge.find_by(user_id: user.id, badge_id: Badge::GoodPost)).not_to eq(nil)

      # Great post badge
      post.update like_count: 50
      BadgeGranter.queue_badge_grant(Badge::Trigger::PostAction, post_action: action)
      BadgeGranter.process_queue!
      expect(UserBadge.find_by(user_id: user.id, badge_id: Badge::GreatPost)).not_to eq(nil)

      # Revoke badges on unlike
      post.update like_count: 49
      BadgeGranter.backfill(Badge.find(Badge::GreatPost))
      expect(UserBadge.find_by(user_id: user.id, badge_id: Badge::GreatPost)).to eq(nil)
    end

    it ""triggers the 'user_badge_granted' DiscourseEvent per badge when badges are backfilled"" do
      post = create_post(user: user)
      action = PostActionCreator.like(liker, post).post_action

      events = DiscourseEvent.track_events(:user_badge_granted) { BadgeGranter.process_queue! }

      expect(events.length).to eq(2)
      expect(events[0][:params]).to eq([Badge::FirstLike, liker.id])
      expect(events[1][:params]).to eq([Badge::Welcome, user.id])
    end
  end

  describe ""notification locales"" do
    it ""is using default locales when user locales are not set"" do
      SiteSetting.allow_user_locale = true
      expect(BadgeGranter.notification_locale("""")).to eq(SiteSetting.default_locale)
    end

    it ""is using default locales when user locales are set but is not allowed"" do
      SiteSetting.allow_user_locale = false
      expect(BadgeGranter.notification_locale(""pl_PL"")).to eq(SiteSetting.default_locale)
    end

    it ""is using user locales when set and allowed"" do
      SiteSetting.allow_user_locale = true
      expect(BadgeGranter.notification_locale(""pl_PL"")).to eq(""pl_PL"")
    end
  end

  describe "".mass_grant"" do
    it ""raises an error if the count argument is less than 1"" do
      expect do BadgeGranter.mass_grant(badge, user, count: 0) end.to raise_error(
        ArgumentError,
        ""count can't be less than 1"",
      )
    end

    it ""grants the badge to the user as many times as the count argument"" do
      BadgeGranter.mass_grant(badge, user, count: 10)
      sequence = UserBadge.where(badge: badge, user: user).pluck(:seq).sort
      expect(sequence).to eq((0...10).to_a)

      BadgeGranter.mass_grant(badge, user, count: 10)
      sequence = UserBadge.where(badge: badge, user: user).pluck(:seq).sort
      expect(sequence).to eq((0...20).to_a)
    end
  end

  describe "".enqueue_mass_grant_for_users"" do
    before { Jobs.run_immediately! }

    it ""returns a list of the entries that could not be matched to any users"" do
      results =
        BadgeGranter.enqueue_mass_grant_for_users(
          badge,
          emails: [""fakeemail@discourse.invalid"", user.email],
          usernames: [user.username, ""fakeusername""],
        )
      expect(results[:unmatched_entries]).to contain_exactly(
        ""fakeemail@discourse.invalid"",
        ""fakeusername"",
      )
      expect(results[:matched_users_count]).to eq(1)
      expect(results[:unmatched_entries_count]).to eq(2)
    end

    context ""when ensure_users_have_badge_once is true"" do
      it ""ensures each user has the badge at least once and does not grant the badge multiple times to one user"" do
        BadgeGranter.grant(badge, user)
        user_without_badge = Fabricate(:user)

        Notification.destroy_all
        results =
          BadgeGranter.enqueue_mass_grant_for_users(
            badge,
            usernames: [
              user.username,
              user.username,
              user_without_badge.username,
              user_without_badge.username,
            ],
            ensure_users_have_badge_once: true,
          )
        expect(results[:unmatched_entries]).to eq([])
        expect(results[:matched_users_count]).to eq(2)
        expect(results[:unmatched_entries_count]).to eq(0)

        sequence = UserBadge.where(user: user, badge: badge).pluck(:seq)
        expect(sequence).to contain_exactly(0)
        # no new badge/notification because user already had the badge
        # before enqueue_mass_grant_for_users was called
        expect(user.reload.notifications.size).to eq(0)

        sequence = UserBadge.where(user: user_without_badge, badge: badge)
        expect(sequence.pluck(:seq)).to contain_exactly(0)
        notifications = user_without_badge.reload.notifications
        expect(notifications.size).to eq(1)
        expect(sequence.first.notification_id).to eq(notifications.first.id)
        expect(notifications.first.notification_type).to eq(Notification.types[:granted_badge])
      end
    end

    context ""when ensure_users_have_badge_once is false"" do
      it ""grants the badge to the users as many times as they appear in the emails and usernames arguments"" do
        badge.update!(multiple_grant: true)
        user_without_badge = Fabricate(:user)
        user_with_badge = Fabricate(:user).tap { |u| BadgeGranter.grant(badge, u) }

        Notification.destroy_all
        emails = [user_with_badge.email.titlecase, user_without_badge.email.titlecase] * 20
        usernames = [user_with_badge.username.titlecase, user_without_badge.username.titlecase] * 20

        results =
          BadgeGranter.enqueue_mass_grant_for_users(
            badge,
            emails: emails,
            usernames: usernames,
            ensure_users_have_badge_once: false,
          )
        expect(results[:unmatched_entries]).to eq([])
        expect(results[:matched_users_count]).to eq(2)
        expect(results[:unmatched_entries_count]).to eq(0)

        sequence = UserBadge.where(user: user_with_badge, badge: badge).pluck(:seq)
        expect(sequence.size).to eq(40 + 1)
        expect(sequence.sort).to eq((0...(40 + 1)).to_a)
        sequence = UserBadge.where(user: user_without_badge, badge: badge).pluck(:seq)
        expect(sequence.size).to eq(40)
        expect(sequence.sort).to eq((0...40).to_a)

        # each user gets 1 notification no matter how many times
        # they're repeated in the file.
        [user_without_badge, user_with_badge].each do |u|
          notifications = u.reload.notifications
          expect(notifications.size).to eq(1)
          expect(notifications.map(&:notification_type).uniq).to contain_exactly(
            Notification.types[:granted_badge],
          )
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class TopicSummarization
  def initialize(strategy)
    @strategy = strategy
  end

  def summarize(topic, user, opts = {}, &on_partial_blk)
    existing_summary = SummarySection.find_by(target: topic, meta_section_id: nil)

    # Existing summary shouldn't be nil in this scenario because the controller checks its existence.
    return if !user && !existing_summary

    targets_data = summary_targets(topic).pluck(:post_number, :raw, :username)

    current_topic_sha = build_sha(targets_data.map(&:first))
    can_summarize = Summarization::Base.can_request_summary_for?(user)

    if use_cached?(existing_summary, can_summarize, current_topic_sha, !!opts[:skip_age_check])
      # It's important that we signal a cached summary is outdated
      existing_summary.mark_as_outdated if new_targets?(existing_summary, current_topic_sha)

      return existing_summary
    end

    delete_cached_summaries_of(topic) if existing_summary

    content = {
      resource_path: ""#{Discourse.base_path}/t/-/#{topic.id}"",
      content_title: topic.title,
      contents: [],
    }

    targets_data.map do |(pn, raw, username)|
      content[:contents] << { poster: username, id: pn, text: raw }
    end

    summarization_result = strategy.summarize(content, user, &on_partial_blk)

    cache_summary(summarization_result, targets_data.map(&:first), topic)
  end

  def summary_targets(topic)
    topic.has_summary? ? best_replies(topic) : pick_selection(topic)
  end

  private

  attr_reader :strategy

  def best_replies(topic)
    Post
      .summary(topic.id)
      .where(""post_type = ?"", Post.types[:regular])
      .where(""NOT hidden"")
      .joins(:user)
      .order(:post_number)
  end

  def pick_selection(topic)
    posts =
      Post
        .where(topic_id: topic.id)
        .where(""post_type = ?"", Post.types[:regular])
        .where(""NOT hidden"")
        .order(:post_number)

    post_numbers = posts.limit(5).pluck(:post_number)
    post_numbers += posts.reorder(""posts.score desc"").limit(50).pluck(:post_number)
    post_numbers += posts.reorder(""post_number desc"").limit(5).pluck(:post_number)

    Post
      .where(topic_id: topic.id)
      .joins(:user)
      .where(""post_number in (?)"", post_numbers)
      .order(:post_number)
  end

  def delete_cached_summaries_of(topic)
    SummarySection.where(target: topic).destroy_all
  end

  # For users without permissions to generate a summary or fresh summaries, we return what we have cached.
  def use_cached?(existing_summary, can_summarize, current_sha, skip_age_check)
    existing_summary &&
      !(
        can_summarize && new_targets?(existing_summary, current_sha) &&
          (skip_age_check || existing_summary.created_at < 1.hour.ago)
      )
  end

  def new_targets?(summary, current_sha)
    summary.original_content_sha != current_sha
  end

  def cache_summary(result, post_numbers, topic)
    main_summary =
      SummarySection.create!(
        target: topic,
        algorithm: strategy.model,
        content_range: (post_numbers.first..post_numbers.last),
        summarized_text: result[:summary],
        original_content_sha: build_sha(post_numbers),
      )

    result[:chunks].each do |chunk|
      SummarySection.create!(
        target: topic,
        algorithm: strategy.model,
        content_range: chunk[:ids].min..chunk[:ids].max,
        summarized_text: chunk[:summary],
        original_content_sha: build_sha(chunk[:ids]),
        meta_section_id: main_summary.id,
      )
    end

    main_summary
  end

  def build_sha(ids)
    Digest::SHA256.hexdigest(ids.join)
  end
end

```","# frozen_string_literal: true

describe TopicSummarization do
  fab!(:user) { Fabricate(:admin) }
  fab!(:topic) { Fabricate(:topic, highest_post_number: 2) }
  fab!(:post_1) { Fabricate(:post, topic: topic, post_number: 1) }
  fab!(:post_2) { Fabricate(:post, topic: topic, post_number: 2) }

  shared_examples ""includes only public-visible topics"" do
    subject { described_class.new(DummyCustomSummarization.new({})) }

    it ""only includes visible posts"" do
      topic.first_post.update!(hidden: true)

      posts = subject.summary_targets(topic)

      expect(posts.none?(&:hidden?)).to eq(true)
    end

    it ""doesn't include posts without users"" do
      topic.first_post.user.destroy!

      posts = subject.summary_targets(topic)

      expect(posts.detect { |p| p.id == topic.first_post.id }).to be_nil
    end

    it ""doesn't include deleted posts"" do
      topic.first_post.update!(user_id: nil)

      posts = subject.summary_targets(topic)

      expect(posts.detect { |p| p.id == topic.first_post.id }).to be_nil
    end
  end

  describe ""#summary_targets"" do
    context ""when the topic has a best replies summary"" do
      before { topic.has_summary = true }

      it_behaves_like ""includes only public-visible topics""
    end

    context ""when the topic doesn't have a best replies summary"" do
      before { topic.has_summary = false }

      it_behaves_like ""includes only public-visible topics""
    end
  end

  describe ""#summarize"" do
    subject(:summarization) { described_class.new(strategy) }

    let(:strategy) { DummyCustomSummarization.new(summary) }

    def assert_summary_is_cached(topic, summary_response)
      cached_summary = SummarySection.find_by(target: topic, meta_section_id: nil)

      expect(cached_summary.content_range).to cover(*topic.posts.map(&:post_number))
      expect(cached_summary.summarized_text).to eq(summary_response[:summary])
      expect(cached_summary.original_content_sha).to be_present
      expect(cached_summary.algorithm).to eq(strategy.model)
    end

    def assert_chunk_is_cached(topic, chunk_response)
      cached_chunk =
        SummarySection
          .where.not(meta_section_id: nil)
          .find_by(
            target: topic,
            content_range: (chunk_response[:ids].min..chunk_response[:ids].max),
          )

      expect(cached_chunk.summarized_text).to eq(chunk_response[:summary])
      expect(cached_chunk.original_content_sha).to be_present
      expect(cached_chunk.algorithm).to eq(strategy.model)
    end

    context ""when the content was summarized in a single chunk"" do
      let(:summary) { { summary: ""This is the final summary"", chunks: [] } }

      it ""caches the summary"" do
        section = summarization.summarize(topic, user)

        expect(section.summarized_text).to eq(summary[:summary])

        assert_summary_is_cached(topic, summary)
      end

      it ""returns the cached version in subsequent calls"" do
        summarization.summarize(topic, user)

        cached_summary_text = ""This is a cached summary""
        cached_summary =
          SummarySection.find_by(target: topic, meta_section_id: nil).update!(
            summarized_text: cached_summary_text,
            updated_at: 24.hours.ago,
          )

        section = summarization.summarize(topic, user)
        expect(section.summarized_text).to eq(cached_summary_text)
      end
    end

    context ""when the content was summarized in multiple chunks"" do
      let(:summary) do
        {
          summary: ""This is the final summary"",
          chunks: [
            { ids: [topic.first_post.post_number], summary: ""this is the first chunk"" },
            { ids: [post_1.post_number, post_2.post_number], summary: ""this is the second chunk"" },
          ],
        }
      end

      it ""caches the summary and each chunk"" do
        section = summarization.summarize(topic, user)

        expect(section.summarized_text).to eq(summary[:summary])

        assert_summary_is_cached(topic, summary)

        summary[:chunks].each { |c| assert_chunk_is_cached(topic, c) }
      end
    end

    describe ""invalidating cached summaries"" do
      let(:cached_text) { ""This is a cached summary"" }
      let(:summarized_text) { ""This is the final summary"" }
      let(:summary) do
        {
          summary: summarized_text,
          chunks: [
            { ids: [topic.first_post.post_number], summary: ""this is the first chunk"" },
            { ids: [post_1.post_number, post_2.post_number], summary: ""this is the second chunk"" },
          ],
        }
      end

      def cached_summary
        SummarySection.find_by(target: topic, meta_section_id: nil)
      end

      before do
        summarization.summarize(topic, user)

        cached_summary.update!(summarized_text: cached_text, created_at: 24.hours.ago)
      end

      context ""when the user can requests new summaries"" do
        context ""when there are no new posts"" do
          it ""returns the cached summary"" do
            section = summarization.summarize(topic, user)

            expect(section.summarized_text).to eq(cached_text)
          end
        end

        context ""when there are new posts"" do
          before { cached_summary.update!(original_content_sha: ""outdated_sha"") }

          it ""returns a new summary"" do
            section = summarization.summarize(topic, user)

            expect(section.summarized_text).to eq(summarized_text)
          end

          context ""when the cached summary is less than one hour old"" do
            before { cached_summary.update!(created_at: 30.minutes.ago) }

            it ""returns the cached summary"" do
              cached_summary.update!(created_at: 30.minutes.ago)

              section = summarization.summarize(topic, user)

              expect(section.summarized_text).to eq(cached_text)
              expect(section.outdated).to eq(true)
            end

            it ""returns a new summary if the skip_age_check flag is passed"" do
              section = summarization.summarize(topic, user, skip_age_check: true)

              expect(section.summarized_text).to eq(summarized_text)
            end
          end
        end
      end
    end

    describe ""stream partial updates"" do
      let(:summary) { { summary: ""This is the final summary"", chunks: [] } }

      it ""receives a blk that is passed to the underlying strategy and called with partial summaries"" do
        partial_result = nil

        summarization.summarize(topic, user) { |partial_summary| partial_result = partial_summary }

        expect(partial_result).to eq(summary[:summary])
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Responsible for logging the actions of admins and moderators.
class StaffActionLogger
  def self.base_attrs
    %i[topic_id post_id context subject ip_address previous_value new_value]
  end

  def initialize(admin)
    @admin = admin
    raise Discourse::InvalidParameters.new(:admin) unless @admin && @admin.is_a?(User)
  end

  USER_FIELDS ||= %i[id username name created_at trust_level last_seen_at last_emailed_at]

  def log_user_deletion(deleted_user, opts = {})
    unless deleted_user && deleted_user.is_a?(User)
      raise Discourse::InvalidParameters.new(:deleted_user)
    end

    details = USER_FIELDS.map { |x| ""#{x}: #{deleted_user.public_send(x)}"" }.join(""\n"")

    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:delete_user],
        ip_address: deleted_user.ip_address.to_s,
        details: details,
      ),
    )
  end

  def log_custom(custom_type, details = nil)
    raise Discourse::InvalidParameters.new(:custom_type) unless custom_type

    details ||= {}

    attrs = {}
    StaffActionLogger.base_attrs.each do |attr|
      attrs[attr] = details.delete(attr) if details.has_key?(attr)
    end
    attrs[:details] = details.map { |r| ""#{r[0]}: #{r[1]}"" }.join(""\n"")
    attrs[:acting_user_id] = @admin.id
    attrs[:action] = UserHistory.actions[:custom_staff]
    attrs[:custom_type] = custom_type

    UserHistory.create!(attrs)
  end

  def edit_directory_columns_details(column_data, directory_column)
    directory_column = directory_column.attributes.transform_values(&:to_s)
    previous_value = directory_column
    new_value = directory_column.clone

    directory_column.each do |key, value|
      if column_data[key] != value && column_data[key].present?
        new_value[key] = column_data[key]
      elsif key != ""name""
        previous_value.delete key
        new_value.delete key
      end
    end

    [previous_value.to_json, new_value.to_json]
  end

  def log_post_deletion(deleted_post, opts = {})
    unless deleted_post && deleted_post.is_a?(Post)
      raise Discourse::InvalidParameters.new(:deleted_post)
    end

    topic = deleted_post.topic || Topic.with_deleted.find_by(id: deleted_post.topic_id)

    username = deleted_post.user.try(:username) || I18n.t(""staff_action_logs.unknown"")
    name = deleted_post.user.try(:name) || I18n.t(""staff_action_logs.unknown"")
    topic_title = topic.try(:title) || I18n.t(""staff_action_logs.not_found"")

    details = [
      ""id: #{deleted_post.id}"",
      ""created_at: #{deleted_post.created_at}"",
      ""user: #{username} (#{name})"",
      ""topic: #{topic_title}"",
      ""post_number: #{deleted_post.post_number}"",
      ""raw: #{deleted_post.raw}"",
    ]

    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:delete_post],
        post_id: deleted_post.id,
        details: details.join(""\n""),
      ),
    )
  end

  def log_topic_delete_recover(topic, action = ""delete_topic"", opts = {})
    raise Discourse::InvalidParameters.new(:topic) unless topic && topic.is_a?(Topic)

    user = topic.user ? ""#{topic.user.username} (#{topic.user.name})"" : ""(deleted user)""

    details = [
      ""id: #{topic.id}"",
      ""created_at: #{topic.created_at}"",
      ""user: #{user}"",
      ""title: #{topic.title}"",
    ]

    if first_post = topic.ordered_posts.with_deleted.first
      details << ""raw: #{first_post.raw}""
    end

    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[action.to_sym],
        topic_id: topic.id,
        details: details.join(""\n""),
      ),
    )
  end

  def log_trust_level_change(user, old_trust_level, new_trust_level, opts = {})
    raise Discourse::InvalidParameters.new(:user) unless user && user.is_a?(User)
    unless TrustLevel.valid? old_trust_level
      raise Discourse::InvalidParameters.new(:old_trust_level)
    end
    unless TrustLevel.valid? new_trust_level
      raise Discourse::InvalidParameters.new(:new_trust_level)
    end
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:change_trust_level],
        target_user_id: user.id,
        previous_value: old_trust_level,
        new_value: new_trust_level,
      ),
    )
  end

  def log_lock_trust_level(user, opts = {})
    raise Discourse::InvalidParameters.new(:user) unless user && user.is_a?(User)
    action =
      UserHistory.actions[
        user.manual_locked_trust_level.nil? ? :unlock_trust_level : :lock_trust_level
      ]
    UserHistory.create!(params(opts).merge(action: action, target_user_id: user.id))
  end

  def log_topic_published(topic, opts = {})
    raise Discourse::InvalidParameters.new(:topic) unless topic && topic.is_a?(Topic)
    UserHistory.create!(
      params(opts).merge(action: UserHistory.actions[:topic_published], topic_id: topic.id),
    )
  end

  def log_topic_timestamps_changed(topic, new_timestamp, previous_timestamp, opts = {})
    raise Discourse::InvalidParameters.new(:topic) unless topic && topic.is_a?(Topic)
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:topic_timestamps_changed],
        topic_id: topic.id,
        new_value: new_timestamp,
        previous_value: previous_timestamp,
      ),
    )
  end

  def log_post_lock(post, opts = {})
    raise Discourse::InvalidParameters.new(:post) unless post && post.is_a?(Post)
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[opts[:locked] ? :post_locked : :post_unlocked],
        post_id: post.id,
      ),
    )
  end

  def log_post_edit(post, opts = {})
    raise Discourse::InvalidParameters.new(:post) unless post && post.is_a?(Post)
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:post_edit],
        post_id: post.id,
        details: ""#{opts[:old_raw]}\n\n---\n\n#{post.raw}"",
      ),
    )
  end

  def log_topic_closed(topic, opts = {})
    raise Discourse::InvalidParameters.new(:topic) unless topic && topic.is_a?(Topic)
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[opts[:closed] ? :topic_closed : :topic_opened],
        topic_id: topic.id,
      ),
    )
  end

  def log_topic_archived(topic, opts = {})
    raise Discourse::InvalidParameters.new(:topic) unless topic && topic.is_a?(Topic)
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[opts[:archived] ? :topic_archived : :topic_unarchived],
        topic_id: topic.id,
      ),
    )
  end

  def log_post_staff_note(post, opts = {})
    raise Discourse::InvalidParameters.new(:post) unless post && post.is_a?(Post)

    args =
      params(opts).merge(
        action:
          UserHistory.actions[
            opts[:new_value].present? ? :post_staff_note_create : :post_staff_note_destroy
          ],
        post_id: post.id,
      )
    args[:new_value] = opts[:new_value] if opts[:new_value].present?
    args[:previous_value] = opts[:old_value] if opts[:old_value].present?

    UserHistory.create!(params(opts).merge(args))
  end

  def log_site_setting_change(setting_name, previous_value, new_value, opts = {})
    unless setting_name.present? && SiteSetting.respond_to?(setting_name)
      raise Discourse::InvalidParameters.new(:setting_name)
    end
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:change_site_setting],
        subject: setting_name,
        previous_value: previous_value&.to_s,
        new_value: new_value&.to_s,
      ),
    )
  end

  def theme_json(theme)
    ThemeSerializer.new(theme, root: false, include_theme_field_values: true).to_json
  end

  def strip_duplicates(old, cur)
    return old, cur unless old && cur

    old = JSON.parse(old)
    cur = JSON.parse(cur)

    old.each do |k, v|
      next if k == ""name""
      next if k == ""id""
      if (v == cur[k])
        cur.delete(k)
        old.delete(k)
      end
    end

    [old.to_json, cur.to_json]
  end

  def log_theme_change(old_json, new_theme, opts = {})
    raise Discourse::InvalidParameters.new(:new_theme) unless new_theme

    new_json = theme_json(new_theme)

    old_json, new_json = strip_duplicates(old_json, new_json)

    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:change_theme],
        subject: new_theme.name,
        previous_value: old_json,
        new_value: new_json,
      ),
    )
  end

  def log_theme_destroy(theme, opts = {})
    raise Discourse::InvalidParameters.new(:theme) unless theme
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:delete_theme],
        subject: theme.name,
        previous_value: theme_json(theme),
      ),
    )
  end

  def log_theme_component_disabled(component)
    UserHistory.create!(
      params.merge(
        action: UserHistory.actions[:disable_theme_component],
        subject: component.name,
        context: component.id,
      ),
    )
  end

  def log_theme_component_enabled(component)
    UserHistory.create!(
      params.merge(
        action: UserHistory.actions[:enable_theme_component],
        subject: component.name,
        context: component.id,
      ),
    )
  end

  def log_theme_setting_change(setting_name, previous_value, new_value, theme, opts = {})
    raise Discourse::InvalidParameters.new(:theme) unless theme
    unless theme.cached_settings.has_key?(setting_name)
      raise Discourse::InvalidParameters.new(:setting_name)
    end

    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:change_theme_setting],
        subject: ""#{theme.name}: #{setting_name.to_s}"",
        previous_value: previous_value,
        new_value: new_value,
      ),
    )
  end

  def log_site_text_change(subject, new_text = nil, old_text = nil, opts = {})
    raise Discourse::InvalidParameters.new(:subject) unless subject.present?
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:change_site_text],
        subject: subject,
        previous_value: old_text,
        new_value: new_text,
      ),
    )
  end

  def log_username_change(user, old_username, new_username, opts = {})
    raise Discourse::InvalidParameters.new(:user) unless user
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:change_username],
        target_user_id: user.id,
        previous_value: old_username,
        new_value: new_username,
      ),
    )
  end

  def log_name_change(user_id, old_name, new_name, opts = {})
    raise Discourse::InvalidParameters.new(:user) unless user_id
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:change_name],
        target_user_id: user_id,
        previous_value: old_name,
        new_value: new_name,
      ),
    )
  end

  def log_user_suspend(user, reason, opts = {})
    raise Discourse::InvalidParameters.new(:user) unless user

    details = StaffMessageFormat.new(:suspend, reason, opts[:message]).format

    args =
      params(opts).merge(
        action: UserHistory.actions[:suspend_user],
        target_user_id: user.id,
        details: details,
      )
    args[:post_id] = opts[:post_id] if opts[:post_id]
    UserHistory.create!(args)
  end

  def log_user_unsuspend(user, opts = {})
    raise Discourse::InvalidParameters.new(:user) unless user
    UserHistory.create!(
      params(opts).merge(action: UserHistory.actions[:unsuspend_user], target_user_id: user.id),
    )
  end

  def log_user_merge(user, source_username, source_email, opts = {})
    raise Discourse::InvalidParameters.new(:user) unless user
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:merge_user],
        target_user_id: user.id,
        context: I18n.t(""staff_action_logs.user_merged"", username: source_username),
        email: source_email,
      ),
    )
  end

  BADGE_FIELDS ||= %i[
    id
    name
    description
    long_description
    icon
    image_upload_id
    badge_type_id
    badge_grouping_id
    query
    allow_title
    multiple_grant
    listable
    target_posts
    enabled
    auto_revoke
    show_posts
    system
  ]

  def log_badge_creation(badge)
    raise Discourse::InvalidParameters.new(:badge) unless badge

    details =
      BADGE_FIELDS
        .map { |f| [f, badge.public_send(f)] }
        .select { |f, v| v.present? }
        .map { |f, v| ""#{f}: #{v}"" }

    UserHistory.create!(
      params.merge(action: UserHistory.actions[:create_badge], details: details.join(""\n"")),
    )
  end

  def log_badge_change(badge)
    raise Discourse::InvalidParameters.new(:badge) unless badge
    details = [""id: #{badge.id}""]
    badge.previous_changes.each do |f, values|
      details << ""#{f}: #{values[1]}"" if BADGE_FIELDS.include?(f.to_sym)
    end
    UserHistory.create!(
      params.merge(action: UserHistory.actions[:change_badge], details: details.join(""\n"")),
    )
  end

  def log_badge_deletion(badge)
    raise Discourse::InvalidParameters.new(:badge) unless badge

    details =
      BADGE_FIELDS
        .map { |f| [f, badge.public_send(f)] }
        .select { |f, v| v.present? }
        .map { |f, v| ""#{f}: #{v}"" }

    UserHistory.create!(
      params.merge(action: UserHistory.actions[:delete_badge], details: details.join(""\n"")),
    )
  end

  def log_badge_grant(user_badge, opts = {})
    raise Discourse::InvalidParameters.new(:user_badge) unless user_badge
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:grant_badge],
        target_user_id: user_badge.user_id,
        details: user_badge.badge.name,
      ),
    )
  end

  def log_badge_revoke(user_badge, opts = {})
    raise Discourse::InvalidParameters.new(:user_badge) unless user_badge
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:revoke_badge],
        target_user_id: user_badge.user_id,
        details: user_badge.badge.name,
      ),
    )
  end

  def log_title_revoke(user, opts = {})
    raise Discourse::InvalidParameters.new(:user) unless user
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:revoke_title],
        target_user_id: user.id,
        details: opts[:revoke_reason],
        previous_value: opts[:previous_value],
      ),
    )
  end

  def log_title_change(user, opts = {})
    raise Discourse::InvalidParameters.new(:user) unless user
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:change_title],
        target_user_id: user.id,
        details: opts[:details],
        new_value: opts[:new_value],
        previous_value: opts[:previous_value],
      ),
    )
  end

  def log_change_upload_secure_status(opts = {})
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:override_upload_secure_status],
        details: [
          ""upload_id: #{opts[:upload_id]}"",
          ""reason: #{I18n.t(""uploads.marked_insecure_from_theme_component_reason"")}"",
        ].join(""\n""),
        new_value: opts[:new_value],
      ),
    )
  end

  def log_check_email(user, opts = {})
    raise Discourse::InvalidParameters.new(:user) unless user
    UserHistory.create!(
      params(opts).merge(action: UserHistory.actions[:check_email], target_user_id: user.id),
    )
  end

  def log_show_emails(users, opts = {})
    return if users.blank?
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:check_email],
        details: users.map { |u| ""[#{u.id}] #{u.username}"" }.join(""\n""),
      ),
    )
  end

  def log_impersonate(user, opts = {})
    raise Discourse::InvalidParameters.new(:user) unless user
    UserHistory.create!(
      params(opts).merge(action: UserHistory.actions[:impersonate], target_user_id: user.id),
    )
  end

  def log_roll_up(subnet, ips, opts = {})
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:roll_up],
        details: ""#{subnet} from #{ips.join("", "")}"",
      ),
    )
  end

  def log_category_settings_change(
    category,
    category_params,
    old_permissions: nil,
    old_custom_fields: nil
  )
    validate_category(category)

    changed_attributes = category.previous_changes.slice(*category_params.keys)

    if !old_permissions.empty? && (old_permissions != category_params[:permissions])
      changed_attributes.merge!(
        permissions: [old_permissions.to_json, category_params[:permissions].to_json],
      )
    end

    if old_custom_fields && category_params[:custom_fields]
      category_params[:custom_fields].each do |key, value|
        next if old_custom_fields[key] == value
        changed_attributes[""custom_fields[#{key}]""] = [old_custom_fields[key], value]
      end
    end

    changed_attributes.each do |key, value|
      UserHistory.create!(
        params.merge(
          action: UserHistory.actions[:change_category_settings],
          category_id: category.id,
          context: category.url,
          subject: key,
          previous_value: value[0],
          new_value: value[1],
        ),
      )
    end
  end

  def log_category_deletion(category)
    validate_category(category)

    details = [
      ""created_at: #{category.created_at}"",
      ""name: #{category.name}"",
      ""permissions: #{category.permissions_params}"",
    ]

    if parent_category = category.parent_category
      details << ""parent_category: #{parent_category.name}""
    end

    UserHistory.create!(
      params.merge(
        action: UserHistory.actions[:delete_category],
        category_id: category.id,
        details: details.join(""\n""),
        context: category.url,
      ),
    )
  end

  def log_category_creation(category)
    validate_category(category)

    details = [""created_at: #{category.created_at}"", ""name: #{category.name}""]

    UserHistory.create!(
      params.merge(
        action: UserHistory.actions[:create_category],
        details: details.join(""\n""),
        category_id: category.id,
        context: category.url,
      ),
    )
  end

  def log_silence_user(user, opts = {})
    raise Discourse::InvalidParameters.new(:user) unless user

    create_args =
      params(opts).merge(
        action: UserHistory.actions[:silence_user],
        target_user_id: user.id,
        details: opts[:details],
      )
    create_args[:post_id] = opts[:post_id] if opts[:post_id]

    UserHistory.create!(create_args)
  end

  def log_unsilence_user(user, opts = {})
    raise Discourse::InvalidParameters.new(:user) unless user
    UserHistory.create!(
      params(opts).merge(action: UserHistory.actions[:unsilence_user], target_user_id: user.id),
    )
  end

  def log_disable_second_factor_auth(user, opts = {})
    raise Discourse::InvalidParameters.new(:user) unless user
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:disabled_second_factor],
        target_user_id: user.id,
      ),
    )
  end

  def log_grant_admin(user, opts = {})
    raise Discourse::InvalidParameters.new(:user) unless user
    UserHistory.create!(
      params(opts).merge(action: UserHistory.actions[:grant_admin], target_user_id: user.id),
    )
  end

  def log_revoke_admin(user, opts = {})
    raise Discourse::InvalidParameters.new(:user) unless user
    UserHistory.create!(
      params(opts).merge(action: UserHistory.actions[:revoke_admin], target_user_id: user.id),
    )
  end

  def log_grant_moderation(user, opts = {})
    raise Discourse::InvalidParameters.new(:user) unless user
    UserHistory.create!(
      params(opts).merge(action: UserHistory.actions[:grant_moderation], target_user_id: user.id),
    )
  end

  def log_revoke_moderation(user, opts = {})
    raise Discourse::InvalidParameters.new(:user) unless user
    UserHistory.create!(
      params(opts).merge(action: UserHistory.actions[:revoke_moderation], target_user_id: user.id),
    )
  end

  def log_backup_create(opts = {})
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:backup_create],
        ip_address: @admin.ip_address.to_s,
      ),
    )
  end

  def log_entity_export(entity, opts = {})
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:entity_export],
        ip_address: @admin.ip_address.to_s,
        subject: entity,
      ),
    )
  end

  def log_backup_download(backup, opts = {})
    raise Discourse::InvalidParameters.new(:backup) unless backup
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:backup_download],
        ip_address: @admin.ip_address.to_s,
        details: backup.filename,
      ),
    )
  end

  def log_backup_destroy(backup, opts = {})
    raise Discourse::InvalidParameters.new(:backup) unless backup
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:backup_destroy],
        ip_address: @admin.ip_address.to_s,
        details: backup.filename,
      ),
    )
  end

  def log_revoke_email(user, reason, opts = {})
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:revoke_email],
        target_user_id: user.id,
        details: reason,
      ),
    )
  end

  def log_user_approve(user, opts = {})
    UserHistory.create!(
      params(opts).merge(action: UserHistory.actions[:approve_user], target_user_id: user.id),
    )
  end

  def log_user_deactivate(user, reason, opts = {})
    raise Discourse::InvalidParameters.new(:user) unless user
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:deactivate_user],
        target_user_id: user.id,
        details: reason,
      ),
    )
  end

  def log_user_activate(user, reason, opts = {})
    raise Discourse::InvalidParameters.new(:user) unless user
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:activate_user],
        target_user_id: user.id,
        details: reason,
      ),
    )
  end

  def log_wizard_step(step, opts = {})
    raise Discourse::InvalidParameters.new(:step) unless step
    UserHistory.create!(
      params(opts).merge(action: UserHistory.actions[:wizard_step], context: step.id),
    )
  end

  def log_change_readonly_mode(state)
    UserHistory.create!(
      params.merge(
        action: UserHistory.actions[:change_readonly_mode],
        previous_value: !state,
        new_value: state,
      ),
    )
  end

  def log_check_personal_message(topic, opts = {})
    raise Discourse::InvalidParameters.new(:topic) unless topic && topic.is_a?(Topic)
    UserHistory.create!(
      params(opts).merge(
        action: UserHistory.actions[:check_personal_message],
        topic_id: topic.id,
        context: topic.relative_url,
      ),
    )
  end

  def log_post_approved(post, opts = {})
    raise Discourse::InvalidParameters.new(:post) unless post.is_a?(Post)
    UserHistory.create!(
      params(opts).merge(action: UserHistory.actions[:post_approved], post_id: post.id),
    )
  end

  def log_post_rejected(reviewable, rejected_at, opts = {})
    raise Discourse::InvalidParameters.new(:rejected_post) unless reviewable.is_a?(Reviewable)

    topic = reviewable.topic || Topic.with_deleted.find_by(id: reviewable.topic_id)
    topic_title = topic&.title || I18n.t(""staff_action_logs.not_found"")
    username = reviewable.target_created_by&.username || I18n.t(""staff_action_logs.unknown"")
    name = reviewable.target_created_by&.name || I18n.t(""staff_action_logs.unknown"")

    details = [
      ""created_at: #{reviewable.created_at}"",
      ""rejected_at: #{rejected_at}"",
      ""user: #{username} (#{name})"",
      ""topic: #{topic_title}"",
      ""raw: #{reviewable.payload[""raw""]}"",
    ]

    UserHistory.create!(
      params(opts).merge(action: UserHistory.actions[:post_rejected], details: details.join(""\n"")),
    )
  end

  def log_web_hook(web_hook, action, opts = {})
    details = [""webhook_id: #{web_hook.id}"", ""payload_url: #{web_hook.payload_url}""]

    old_values, new_values = get_changes(opts[:changes])

    UserHistory.create!(
      params(opts).merge(
        action: action,
        context: details.join("", ""),
        previous_value: old_values&.join("", ""),
        new_value: new_values&.join("", ""),
      ),
    )
  end

  def log_web_hook_deactivate(web_hook, response_http_status, opts = {})
    context = [""webhook_id: #{web_hook.id}"", ""webhook_response_status: #{response_http_status}""]

    UserHistory.create!(
      params.merge(
        action: UserHistory.actions[:web_hook_deactivate],
        context: context,
        details:
          I18n.t(""staff_action_logs.webhook_deactivation_reason"", status: response_http_status),
      ),
    )
  end

  def log_embeddable_host(embeddable_host, action, opts = {})
    old_values, new_values = get_changes(opts[:changes])

    UserHistory.create!(
      params(opts).merge(
        action: action,
        context: ""host: #{embeddable_host.host}"",
        previous_value: old_values&.join("", ""),
        new_value: new_values&.join("", ""),
      ),
    )
  end

  def log_api_key(api_key, action, opts = {})
    opts[:changes]&.delete(""key"") # Do not log the full key

    history_params = params(opts).merge(action: action, subject: api_key.truncated_key)

    if opts[:changes]
      old_values, new_values = get_changes(opts[:changes])
      history_params[:previous_value] = old_values&.join("", "") unless opts[:changes].keys.include?(
        ""id"",
      )
      history_params[:new_value] = new_values&.join("", "")
    end

    UserHistory.create!(history_params)
  end

  def log_api_key_revoke(api_key)
    UserHistory.create!(
      params.merge(
        subject: api_key.truncated_key,
        action: UserHistory.actions[:api_key_update],
        details: I18n.t(""staff_action_logs.api_key.revoked""),
      ),
    )
  end

  def log_api_key_restore(api_key)
    UserHistory.create!(
      params.merge(
        subject: api_key.truncated_key,
        action: UserHistory.actions[:api_key_update],
        details: I18n.t(""staff_action_logs.api_key.restored""),
      ),
    )
  end

  def log_published_page(topic_id, slug)
    UserHistory.create!(
      params.merge(subject: slug, topic_id: topic_id, action: UserHistory.actions[:page_published]),
    )
  end

  def log_unpublished_page(topic_id, slug)
    UserHistory.create!(
      params.merge(
        subject: slug,
        topic_id: topic_id,
        action: UserHistory.actions[:page_unpublished],
      ),
    )
  end

  def log_add_email(user)
    raise Discourse::InvalidParameters.new(:user) unless user

    UserHistory.create!(
      action: UserHistory.actions[:add_email],
      acting_user_id: @admin.id,
      target_user_id: user.id,
    )
  end

  def log_update_email(user)
    raise Discourse::InvalidParameters.new(:user) unless user

    UserHistory.create!(
      action: UserHistory.actions[:update_email],
      acting_user_id: @admin.id,
      target_user_id: user.id,
    )
  end

  def log_destroy_email(user)
    raise Discourse::InvalidParameters.new(:user) unless user

    UserHistory.create!(
      action: UserHistory.actions[:destroy_email],
      acting_user_id: @admin.id,
      target_user_id: user.id,
    )
  end

  def log_watched_words_creation(watched_word)
    raise Discourse::InvalidParameters.new(:watched_word) unless watched_word

    UserHistory.create!(
      action: UserHistory.actions[:watched_word_create],
      acting_user_id: @admin.id,
      details: watched_word.action_log_details,
      context: WatchedWord.actions[watched_word.action],
    )
  end

  def log_watched_words_deletion(watched_word)
    raise Discourse::InvalidParameters.new(:watched_word) unless watched_word

    UserHistory.create!(
      action: UserHistory.actions[:watched_word_destroy],
      acting_user_id: @admin.id,
      details: watched_word.action_log_details,
      context: WatchedWord.actions[watched_word.action],
    )
  end

  def log_group_deletion(group)
    raise Discourse::InvalidParameters.new(:group) if group.nil?

    details = [""name: #{group.name}"", ""id: #{group.id}""]

    details << ""grant_trust_level: #{group.grant_trust_level}"" if group.grant_trust_level

    UserHistory.create!(
      acting_user_id: @admin.id,
      action: UserHistory.actions[:delete_group],
      details: details.join("", ""),
    )
  end

  def log_permanently_delete_post_revisions(post)
    raise Discourse::InvalidParameters.new(:post) if post.nil?

    UserHistory.create!(
      action: UserHistory.actions[:permanently_delete_post_revisions],
      acting_user_id: @admin.id,
      post_id: post.id,
    )
  end

  def log_create_public_sidebar_section(section)
    UserHistory.create!(
      action: UserHistory.actions[:create_public_sidebar_section],
      acting_user_id: @admin.id,
      subject: section.title,
      details: custom_section_details(section),
    )
  end

  def log_update_public_sidebar_section(section)
    UserHistory.create!(
      action: UserHistory.actions[:update_public_sidebar_section],
      acting_user_id: @admin.id,
      subject: section.title,
      details: custom_section_details(section),
    )
  end

  def log_destroy_public_sidebar_section(section)
    UserHistory.create!(
      action: UserHistory.actions[:destroy_public_sidebar_section],
      acting_user_id: @admin.id,
      subject: section.title,
    )
  end

  def log_reset_bounce_score(user, opts = {})
    raise Discourse::InvalidParameters.new(:user) unless user

    UserHistory.create!(
      params(opts).merge(action: UserHistory.actions[:reset_bounce_score], target_user_id: user.id),
    )
  end

  private

  def get_changes(changes)
    return unless changes

    changes.delete(""updated_at"")
    old_values = []
    new_values = []
    changes
      .sort_by { |k, _| k.to_s }
      .each do |k, v|
        old_values << ""#{k}: #{v[0]}""
        new_values << ""#{k}: #{v[1]}""
      end

    [old_values, new_values]
  end

  def params(opts = nil)
    opts ||= {}
    { acting_user_id: @admin.id, context: opts[:context], details: opts[:details] }
  end

  def validate_category(category)
    raise Discourse::InvalidParameters.new(:category) unless category && category.is_a?(Category)
  end

  def custom_section_details(section)
    urls = section.sidebar_urls.map { |url| ""#{url.name} - #{url.value}"" }
    ""links: #{urls.join("", "")}""
  end
end

```","# frozen_string_literal: true

RSpec.describe StaffActionLogger do
  fab!(:admin)
  let(:logger) { described_class.new(admin) }

  describe ""new"" do
    it ""raises an error when user is nil"" do
      expect { described_class.new(nil) }.to raise_error(Discourse::InvalidParameters)
    end

    it ""raises an error when user is not a User"" do
      expect { described_class.new(5) }.to raise_error(Discourse::InvalidParameters)
    end
  end

  describe ""log_user_deletion"" do
    subject(:log_user_deletion) { described_class.new(admin).log_user_deletion(deleted_user) }

    fab!(:deleted_user) { Fabricate(:user) }

    it ""raises an error when user is nil"" do
      expect { logger.log_user_deletion(nil) }.to raise_error(Discourse::InvalidParameters)
    end

    it ""raises an error when user is not a User"" do
      expect { logger.log_user_deletion(1) }.to raise_error(Discourse::InvalidParameters)
    end

    it ""creates a new UserHistory record"" do
      expect { log_user_deletion }.to change { UserHistory.count }.by(1)
    end
  end

  describe ""log_show_emails"" do
    it ""logs the user history"" do
      expect { logger.log_show_emails([admin]) }.to change(UserHistory, :count).by(1)
    end

    it ""doesn't raise an exception with nothing to log"" do
      expect { logger.log_show_emails([]) }.not_to raise_error
    end

    it ""doesn't raise an exception with nil input"" do
      expect { logger.log_show_emails(nil) }.not_to raise_error
    end
  end

  describe ""log_post_deletion"" do
    subject(:log_post_deletion) { described_class.new(admin).log_post_deletion(deleted_post) }

    fab!(:deleted_post) { Fabricate(:post) }

    it ""raises an error when post is nil"" do
      expect { logger.log_post_deletion(nil) }.to raise_error(Discourse::InvalidParameters)
    end

    it ""raises an error when post is not a Post"" do
      expect { logger.log_post_deletion(1) }.to raise_error(Discourse::InvalidParameters)
    end

    it ""creates a new UserHistory record"" do
      expect { log_post_deletion }.to change { UserHistory.count }.by(1)
    end

    it ""does not explode if post does not have a user"" do
      expect {
        deleted_post.update_columns(user_id: nil)
        log_post_deletion
      }.to change { UserHistory.count }.by(1)
    end
  end

  describe ""log_topic_delete_recover"" do
    fab!(:topic)

    context ""when deleting topic"" do
      subject(:log_topic_delete_recover) do
        described_class.new(admin).log_topic_delete_recover(topic)
      end

      it ""raises an error when topic is nil"" do
        expect { logger.log_topic_delete_recover(nil) }.to raise_error(Discourse::InvalidParameters)
      end

      it ""raises an error when topic is not a Topic"" do
        expect { logger.log_topic_delete_recover(1) }.to raise_error(Discourse::InvalidParameters)
      end

      it ""creates a new UserHistory record"" do
        expect { log_topic_delete_recover }.to change { UserHistory.count }.by(1)
      end
    end

    context ""when recovering topic"" do
      subject(:log_topic_delete_recover) do
        described_class.new(admin).log_topic_delete_recover(topic, ""recover_topic"")
      end

      it ""raises an error when topic is nil"" do
        expect { logger.log_topic_delete_recover(nil, ""recover_topic"") }.to raise_error(
          Discourse::InvalidParameters,
        )
      end

      it ""raises an error when topic is not a Topic"" do
        expect { logger.log_topic_delete_recover(1, ""recover_topic"") }.to raise_error(
          Discourse::InvalidParameters,
        )
      end

      it ""creates a new UserHistory record"" do
        expect { log_topic_delete_recover }.to change { UserHistory.count }.by(1)
      end
    end
  end

  describe ""log_trust_level_change"" do
    subject(:log_trust_level_change) do
      described_class.new(admin).log_trust_level_change(user, old_trust_level, new_trust_level)
    end

    fab!(:user)

    let(:old_trust_level) { TrustLevel[0] }
    let(:new_trust_level) { TrustLevel[1] }

    it ""raises an error when user or trust level is nil"" do
      expect {
        logger.log_trust_level_change(nil, old_trust_level, new_trust_level)
      }.to raise_error(Discourse::InvalidParameters)
      expect { logger.log_trust_level_change(user, nil, new_trust_level) }.to raise_error(
        Discourse::InvalidParameters,
      )
      expect { logger.log_trust_level_change(user, old_trust_level, nil) }.to raise_error(
        Discourse::InvalidParameters,
      )
    end

    it ""raises an error when user is not a User"" do
      expect { logger.log_trust_level_change(1, old_trust_level, new_trust_level) }.to raise_error(
        Discourse::InvalidParameters,
      )
    end

    it ""raises an error when new trust level is not a Trust Level"" do
      max_level = TrustLevel.valid_range.max
      expect { logger.log_trust_level_change(user, old_trust_level, max_level + 1) }.to raise_error(
        Discourse::InvalidParameters,
      )
    end

    it ""creates a new UserHistory record"" do
      expect { log_trust_level_change }.to change { UserHistory.count }.by(1)
      expect(UserHistory.last.previous_value).to eq(old_trust_level.to_s)
      expect(UserHistory.last.new_value).to eq(new_trust_level.to_s)
    end
  end

  describe ""log_site_setting_change"" do
    it ""raises an error when params are invalid"" do
      expect { logger.log_site_setting_change(nil, ""1"", ""2"") }.to raise_error(
        Discourse::InvalidParameters,
      )
      expect {
        logger.log_site_setting_change(""i_am_a_site_setting_that_will_never_exist"", ""1"", ""2"")
      }.to raise_error(Discourse::InvalidParameters)
    end

    it ""creates a new UserHistory record"" do
      expect { logger.log_site_setting_change(""title"", ""Discourse"", ""My Site"") }.to change {
        UserHistory.count
      }.by(1)
    end

    it ""logs boolean values"" do
      log_record = logger.log_site_setting_change(""allow_user_locale"", true, false)
      expect(log_record.previous_value).to eq(""true"")
      expect(log_record.new_value).to eq(""false"")
    end

    it ""logs nil values"" do
      log_record = logger.log_site_setting_change(""title"", nil, nil)
      expect(log_record.previous_value).to be_nil
      expect(log_record.new_value).to be_nil
    end
  end

  describe ""log_theme_change"" do
    it ""raises an error when params are invalid"" do
      expect { logger.log_theme_change(nil, nil) }.to raise_error(Discourse::InvalidParameters)
    end

    let! :theme do
      Fabricate(:theme)
    end

    it ""logs new site customizations"" do
      log_record = logger.log_theme_change(nil, theme)
      expect(log_record.subject).to eq(theme.name)
      expect(log_record.previous_value).to eq(nil)
      expect(log_record.new_value).to be_present

      json = ::JSON.parse(log_record.new_value)
      expect(json[""name""]).to eq(theme.name)
    end

    it ""logs updated site customizations"" do
      old_json = ThemeSerializer.new(theme, root: false).to_json

      theme.set_field(target: :common, name: :scss, value: ""body{margin: 10px;}"")

      log_record = logger.log_theme_change(old_json, theme)

      expect(log_record.previous_value).to be_present

      json = ::JSON.parse(log_record.new_value)
      expect(json[""theme_fields""]).to eq(
        [
          {
            ""name"" => ""scss"",
            ""target"" => ""common"",
            ""value"" => ""body{margin: 10px;}"",
            ""type_id"" => 1,
          },
        ],
      )
    end
  end

  describe ""log_theme_destroy"" do
    it ""raises an error when params are invalid"" do
      expect { logger.log_theme_destroy(nil) }.to raise_error(Discourse::InvalidParameters)
    end

    it ""creates a new UserHistory record"" do
      theme = Fabricate(:theme)
      theme.set_field(target: :common, name: :scss, value: ""body{margin: 10px;}"")

      log_record = logger.log_theme_destroy(theme)
      expect(log_record.previous_value).to be_present
      expect(log_record.new_value).to eq(nil)
      json = ::JSON.parse(log_record.previous_value)

      expect(json[""theme_fields""]).to eq(
        [
          {
            ""name"" => ""scss"",
            ""target"" => ""common"",
            ""value"" => ""body{margin: 10px;}"",
            ""type_id"" => 1,
          },
        ],
      )
    end
  end

  describe ""log_theme_setting_change"" do
    it ""raises an error when params are invalid"" do
      expect { logger.log_theme_setting_change(nil, nil, nil, nil) }.to raise_error(
        Discourse::InvalidParameters,
      )
    end

    let! :theme do
      Fabricate(:theme)
    end

    before do
      theme.set_field(target: :settings, name: :yaml, value: ""custom_setting: special"")
      theme.save!
    end

    it ""raises an error when theme setting is invalid"" do
      expect {
        logger.log_theme_setting_change(:inexistent_setting, nil, nil, theme)
      }.to raise_error(Discourse::InvalidParameters)
    end

    it ""logs theme setting changes"" do
      log_record =
        logger.log_theme_setting_change(:custom_setting, ""special"", ""notsospecial"", theme)
      expect(log_record.subject).to eq(""#{theme.name}: custom_setting"")
      expect(log_record.previous_value).to eq(""special"")
      expect(log_record.new_value).to eq(""notsospecial"")
    end
  end

  describe ""log_site_text_change"" do
    it ""raises an error when params are invalid"" do
      expect { logger.log_site_text_change(nil, ""new text"", ""old text"") }.to raise_error(
        Discourse::InvalidParameters,
      )
    end

    it ""creates a new UserHistory record"" do
      expect { logger.log_site_text_change(""created"", ""new text"", ""old text"") }.to change {
        UserHistory.count
      }.by(1)
    end
  end

  describe ""log_user_suspend"" do
    fab!(:user) { Fabricate(:user, suspended_at: 10.minutes.ago, suspended_till: 1.day.from_now) }

    it ""raises an error when arguments are missing"" do
      expect { logger.log_user_suspend(nil, nil) }.to raise_error(Discourse::InvalidParameters)
      expect { logger.log_user_suspend(nil, ""He was bad."") }.to raise_error(
        Discourse::InvalidParameters,
      )
    end

    it ""reason arg is optional"" do
      expect { logger.log_user_suspend(user, nil) }.to_not raise_error
    end

    it ""creates a new UserHistory record"" do
      reason = ""He was a big meanie.""
      log_record = logger.log_user_suspend(user, reason)
      expect(log_record).to be_valid
      expect(log_record.details).to eq(reason)
      expect(log_record.target_user).to eq(user)
    end
  end

  describe ""log_user_unsuspend"" do
    fab!(:user) { Fabricate(:user, suspended_at: 1.day.ago, suspended_till: 7.days.from_now) }

    it ""raises an error when argument is missing"" do
      expect { logger.log_user_unsuspend(nil) }.to raise_error(Discourse::InvalidParameters)
    end

    it ""creates a new UserHistory record"" do
      log_record = logger.log_user_unsuspend(user)
      expect(log_record).to be_valid
      expect(log_record.target_user).to eq(user)
    end
  end

  describe ""log_badge_grant"" do
    let(:user) { Fabricate(:user) }
    let(:badge) { Fabricate(:badge) }
    let(:user_badge) { BadgeGranter.grant(badge, user) }

    it ""raises an error when argument is missing"" do
      expect { logger.log_badge_grant(nil) }.to raise_error(Discourse::InvalidParameters)
    end

    it ""creates a new UserHistory record"" do
      log_record = logger.log_badge_grant(user_badge)
      expect(log_record).to be_valid
      expect(log_record.target_user).to eq(user)
      expect(log_record.details).to eq(badge.name)
    end
  end

  describe ""log_badge_revoke"" do
    fab!(:user)
    fab!(:badge)
    let(:user_badge) { BadgeGranter.grant(badge, user) }

    it ""raises an error when argument is missing"" do
      expect { logger.log_badge_revoke(nil) }.to raise_error(Discourse::InvalidParameters)
    end

    it ""creates a new UserHistory record"" do
      log_record = logger.log_badge_revoke(user_badge)
      expect(log_record).to be_valid
      expect(log_record.target_user).to eq(user)
      expect(log_record.details).to eq(badge.name)
    end
  end

  describe ""log_roll_up"" do
    subject(:log_roll_up) { described_class.new(admin).log_roll_up(subnet, ips) }

    let(:subnet) { ""1.2.3.0/24"" }
    let(:ips) { %w[1.2.3.4 1.2.3.100] }

    it ""creates a new UserHistory record"" do
      log_record = logger.log_roll_up(subnet, ips)
      expect(log_record).to be_valid
      expect(log_record.details).to eq(""#{subnet} from #{ips.join("", "")}"")
    end
  end

  describe ""log_custom"" do
    it ""raises an error when `custom_type` is missing"" do
      expect { logger.log_custom(nil) }.to raise_error(Discourse::InvalidParameters)
    end

    it ""creates the UserHistory record"" do
      logged =
        logger.log_custom(""clicked_something"", evil: ""trout"", clicked_on: ""thing"", topic_id: 1234)
      expect(logged).to be_valid
      expect(logged.details).to eq(""evil: trout\nclicked_on: thing"")
      expect(logged.action).to eq(UserHistory.actions[:custom_staff])
      expect(logged.custom_type).to eq(""clicked_something"")
      expect(logged.topic_id).to be === 1234
    end
  end

  describe ""log_category_settings_change"" do
    let(:category) { Fabricate(:category, name: ""haha"") }
    let(:category_group) { Fabricate(:category_group, category: category, permission_type: 1) }

    it ""raises an error when category is missing"" do
      expect { logger.log_category_settings_change(nil, nil) }.to raise_error(
        Discourse::InvalidParameters,
      )
    end

    it ""creates new UserHistory records"" do
      attributes = { name: ""new_name"", permissions: { category_group.group_name => 2 } }

      category.update!(attributes)

      logger.log_category_settings_change(
        category,
        attributes,
        old_permissions: {
          category_group.group_name => category_group.permission_type,
        },
      )

      expect(UserHistory.count).to eq(2)

      permission_user_history = UserHistory.find_by_subject(""permissions"")
      expect(permission_user_history.category_id).to eq(category.id)
      expect(permission_user_history.previous_value).to eq(
        { category_group.group_name => 1 }.to_json,
      )
      expect(permission_user_history.new_value).to eq({ category_group.group_name => 2 }.to_json)
      expect(permission_user_history.action).to eq(UserHistory.actions[:change_category_settings])
      expect(permission_user_history.context).to eq(category.url)

      name_user_history = UserHistory.find_by_subject(""name"")
      expect(name_user_history.category).to eq(category)
      expect(name_user_history.previous_value).to eq(""haha"")
      expect(name_user_history.new_value).to eq(""new_name"")
    end

    it ""logs permissions changes even if the category is visible to everyone"" do
      attributes = { name: ""new_name"" }
      old_permission = { ""everyone"" => 1 }
      category.update!(attributes)

      logger.log_category_settings_change(
        category,
        attributes.merge(permissions: { ""trust_level_3"" => 1 }),
        old_permissions: old_permission,
      )

      expect(UserHistory.count).to eq(2)
      expect(UserHistory.find_by_subject(""name"").category).to eq(category)
    end

    it ""logs custom fields changes"" do
      attributes = { custom_fields: { ""auto_populated"" => ""t"" } }
      category.update!(attributes)

      logger.log_category_settings_change(
        category,
        attributes,
        old_permissions: category.permissions_params,
        old_custom_fields: {
        },
      )

      expect(UserHistory.count).to eq(1)
    end

    it ""does not log custom fields changes if value is unchanged"" do
      attributes = { custom_fields: { ""auto_populated"" => ""t"" } }
      category.update!(attributes)

      logger.log_category_settings_change(
        category,
        attributes,
        old_permissions: category.permissions_params,
        old_custom_fields: {
          ""auto_populated"" => ""t"",
        },
      )

      expect(UserHistory.count).to eq(0)
    end
  end

  describe ""log_category_deletion"" do
    fab!(:parent_category) { Fabricate(:category) }
    fab!(:category) { Fabricate(:category, parent_category: parent_category) }

    it ""raises an error when category is missing"" do
      expect { logger.log_category_deletion(nil) }.to raise_error(Discourse::InvalidParameters)
    end

    it ""creates a new UserHistory record"" do
      logger.log_category_deletion(category)

      expect(UserHistory.count).to eq(1)
      user_history = UserHistory.last

      expect(user_history.subject).to eq(nil)
      expect(user_history.category).to eq(category)
      expect(user_history.details).to include(""parent_category: #{parent_category.name}"")
      expect(user_history.context).to eq(category.url)
      expect(user_history.action).to eq(UserHistory.actions[:delete_category])
    end
  end

  describe ""log_category_creation"" do
    fab!(:category)

    it ""raises an error when category is missing"" do
      expect { logger.log_category_deletion(nil) }.to raise_error(Discourse::InvalidParameters)
    end

    it ""creates a new UserHistory record"" do
      logger.log_category_creation(category)

      expect(UserHistory.count).to eq(1)
      user_history = UserHistory.last

      expect(user_history.category).to eq(category)
      expect(user_history.context).to eq(category.url)
      expect(user_history.action).to eq(UserHistory.actions[:create_category])
    end
  end

  describe ""log_lock_trust_level"" do
    fab!(:user)

    it ""raises an error when argument is missing"" do
      expect { logger.log_lock_trust_level(nil) }.to raise_error(Discourse::InvalidParameters)
    end

    it ""creates a new UserHistory record"" do
      user.manual_locked_trust_level = 3
      expect { logger.log_lock_trust_level(user) }.to change { UserHistory.count }.by(1)
      user_history = UserHistory.last
      expect(user_history.action).to eq(UserHistory.actions[:lock_trust_level])

      user.manual_locked_trust_level = nil
      expect { logger.log_lock_trust_level(user) }.to change { UserHistory.count }.by(1)
      user_history = UserHistory.last
      expect(user_history.action).to eq(UserHistory.actions[:unlock_trust_level])
    end
  end

  describe ""log_user_activate"" do
    fab!(:user)

    it ""raises an error when argument is missing"" do
      expect { logger.log_user_activate(nil, nil) }.to raise_error(Discourse::InvalidParameters)
    end

    it ""creates a new UserHistory record"" do
      reason = ""Staff activated from admin""
      expect { logger.log_user_activate(user, reason) }.to change { UserHistory.count }.by(1)
      user_history = UserHistory.last
      expect(user_history.action).to eq(UserHistory.actions[:activate_user])
      expect(user_history.details).to eq(reason)
    end
  end

  describe ""#log_readonly_mode"" do
    it ""creates a new record"" do
      expect { logger.log_change_readonly_mode(true) }.to change { UserHistory.count }.by(1)

      user_history = UserHistory.last

      expect(user_history.action).to eq(UserHistory.actions[:change_readonly_mode])
      expect(user_history.new_value).to eq(""t"")
      expect(user_history.previous_value).to eq(""f"")

      expect { logger.log_change_readonly_mode(false) }.to change { UserHistory.count }.by(1)

      user_history = UserHistory.last

      expect(user_history.action).to eq(UserHistory.actions[:change_readonly_mode])
      expect(user_history.new_value).to eq(""f"")
      expect(user_history.previous_value).to eq(""t"")
    end
  end

  describe ""log_check_personal_message"" do
    subject(:log_check_personal_message) do
      described_class.new(admin).log_check_personal_message(personal_message)
    end

    fab!(:personal_message) { Fabricate(:private_message_topic) }

    it ""raises an error when topic is nil"" do
      expect { logger.log_check_personal_message(nil) }.to raise_error(Discourse::InvalidParameters)
    end

    it ""raises an error when topic is not a Topic"" do
      expect { logger.log_check_personal_message(1) }.to raise_error(Discourse::InvalidParameters)
    end

    it ""creates a new UserHistory record"" do
      expect { log_check_personal_message }.to change { UserHistory.count }.by(1)
    end
  end

  describe ""log_post_approved"" do
    subject(:log_post_approved) { described_class.new(admin).log_post_approved(approved_post) }

    fab!(:approved_post) { Fabricate(:post) }

    it ""raises an error when post is nil"" do
      expect { logger.log_post_approved(nil) }.to raise_error(Discourse::InvalidParameters)
    end

    it ""raises an error when post is not a Post"" do
      expect { logger.log_post_approved(1) }.to raise_error(Discourse::InvalidParameters)
    end

    it ""creates a new UserHistory record"" do
      expect { log_post_approved }.to change { UserHistory.count }.by(1)
    end
  end

  describe ""log_post_rejected"" do
    subject(:log_post_rejected) do
      described_class.new(admin).log_post_rejected(reviewable, DateTime.now)
    end

    fab!(:reviewable) { Fabricate(:reviewable_queued_post) }

    it ""raises an error when reviewable not supplied"" do
      expect { logger.log_post_rejected(nil, DateTime.now) }.to raise_error(
        Discourse::InvalidParameters,
      )
      expect { logger.log_post_rejected(1, DateTime.now) }.to raise_error(
        Discourse::InvalidParameters,
      )
    end

    it ""creates a new UserHistory record"" do
      expect { log_post_rejected }.to change { UserHistory.count }.by(1)
      user_history = UserHistory.last
      expect(user_history.action).to eq(UserHistory.actions[:post_rejected])
      expect(user_history.details).to include(reviewable.payload[""raw""])
    end

    it ""works if the user was destroyed"" do
      reviewable.created_by.destroy
      reviewable.reload

      expect { log_post_rejected }.to change { UserHistory.count }.by(1)
      user_history = UserHistory.last
      expect(user_history.action).to eq(UserHistory.actions[:post_rejected])
      expect(user_history.details).to include(reviewable.payload[""raw""])
    end
  end

  describe ""log_topic_closed"" do
    fab!(:topic)

    it ""raises an error when argument is missing"" do
      expect { logger.log_topic_closed(nil) }.to raise_error(Discourse::InvalidParameters)
    end

    it ""creates a new UserHistory record"" do
      expect { logger.log_topic_closed(topic, closed: true) }.to change {
        UserHistory.where(action: UserHistory.actions[:topic_closed]).count
      }.by(1)
      expect { logger.log_topic_closed(topic, closed: false) }.to change {
        UserHistory.where(action: UserHistory.actions[:topic_opened]).count
      }.by(1)
    end
  end

  describe ""log_topic_archived"" do
    fab!(:topic)

    it ""raises an error when argument is missing"" do
      expect { logger.log_topic_archived(nil) }.to raise_error(Discourse::InvalidParameters)
    end

    it ""creates a new UserHistory record"" do
      expect { logger.log_topic_archived(topic, archived: true) }.to change {
        UserHistory.where(action: UserHistory.actions[:topic_archived]).count
      }.by(1)
      expect { logger.log_topic_archived(topic, archived: false) }.to change {
        UserHistory.where(action: UserHistory.actions[:topic_unarchived]).count
      }.by(1)
    end
  end

  describe ""log_post_staff_note"" do
    fab!(:post)

    it ""raises an error when argument is missing"" do
      expect { logger.log_topic_archived(nil) }.to raise_error(Discourse::InvalidParameters)
    end

    it ""creates a new UserHistory record"" do
      expect {
        logger.log_post_staff_note(post, { new_value: ""my note"", old_value: nil })
      }.to change { UserHistory.count }.by(1)
      user_history = UserHistory.last
      expect(user_history.action).to eq(UserHistory.actions[:post_staff_note_create])
      expect(user_history.new_value).to eq(""my note"")
      expect(user_history.previous_value).to eq(nil)

      expect {
        logger.log_post_staff_note(post, { new_value: nil, old_value: ""my note"" })
      }.to change { UserHistory.count }.by(1)
      user_history = UserHistory.last
      expect(user_history.action).to eq(UserHistory.actions[:post_staff_note_destroy])
      expect(user_history.new_value).to eq(nil)
      expect(user_history.previous_value).to eq(""my note"")
    end
  end

  describe ""#log_watched_words_creation"" do
    fab!(:watched_word) { Fabricate(:watched_word, action: WatchedWord.actions[:block]) }

    it ""raises an error when watched_word is missing"" do
      expect { logger.log_watched_words_creation(nil) }.to raise_error(Discourse::InvalidParameters)
    end

    it ""creates a new UserHistory record"" do
      logger.log_watched_words_creation(watched_word)

      expect(UserHistory.count).to eq(1)
      user_history = UserHistory.last

      expect(user_history.subject).to eq(nil)
      expect(user_history.details).to include(watched_word.word)
      expect(user_history.context).to eq(""block"")
      expect(user_history.action).to eq(UserHistory.actions[:watched_word_create])
    end
  end

  describe ""#log_watched_words_deletion"" do
    fab!(:watched_word) { Fabricate(:watched_word, action: WatchedWord.actions[:block]) }

    it ""raises an error when watched_word is missing"" do
      expect { logger.log_watched_words_deletion(nil) }.to raise_error(Discourse::InvalidParameters)
    end

    it ""creates a new UserHistory record"" do
      logger.log_watched_words_deletion(watched_word)

      expect(UserHistory.count).to eq(1)
      user_history = UserHistory.last

      expect(user_history.subject).to eq(nil)
      expect(user_history.details).to include(watched_word.word)
      expect(user_history.context).to eq(""block"")
      expect(user_history.action).to eq(UserHistory.actions[:watched_word_destroy])
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

require ""net/imap""
require ""net/smtp""
require ""net/pop""

# Usage:
#
# begin
#   EmailSettingsValidator.validate_imap(host: ""imap.test.com"", port: 999, username: ""test@test.com"", password: ""password"")
#
#   # or for specific host preset
#   EmailSettingsValidator.validate_imap(**{ username: ""test@gmail.com"", password: ""test"" }.merge(Email.gmail_imap_settings))
#
# rescue *EmailSettingsExceptionHandler::EXPECTED_EXCEPTIONS => err
#   EmailSettingsExceptionHandler.friendly_exception_message(err, host)
# end
class EmailSettingsValidator
  def self.validate_as_user(user, protocol, **kwargs)
    DistributedMutex.synchronize(""validate_#{protocol}_#{user.id}"", validity: 10) do
      self.public_send(""validate_#{protocol}"", **kwargs)
    end
  end

  ##
  # Attempts to authenticate and disconnect a POP3 session and if that raises
  # an error then it is assumed the credentials or some other settings are wrong.
  #
  # @param debug [Boolean] - When set to true, any errors will be logged at a warning
  #                          level before being re-raised.
  def self.validate_pop3(
    host:,
    port:,
    username:,
    password:,
    ssl: SiteSetting.pop3_polling_ssl,
    openssl_verify: SiteSetting.pop3_polling_openssl_verify,
    debug: Rails.env.development?
  )
    begin
      pop3 = Net::POP3.new(host, port)

      # Note that we do not allow which verification mode to be specified
      # like we do for SMTP, we just pick TLS1_2 if the SSL and openSSL verify
      # options have been enabled.
      if ssl
        if openssl_verify
          pop3.enable_ssl(max_version: OpenSSL::SSL::TLS1_2_VERSION)
        else
          pop3.enable_ssl(OpenSSL::SSL::VERIFY_NONE)
        end
      end

      # This disconnects itself, unlike SMTP and IMAP.
      pop3.auth_only(username, password)
    rescue => err
      log_and_raise(err, debug)
    end
  end

  ##
  # Attempts to start an SMTP session and if that raises an error then it is
  # assumed the credentials or other settings are wrong.
  #
  # For Gmail, the port should be 587, enable_starttls_auto should be true,
  # and enable_tls should be false.
  #
  # @param domain [String] - Used for HELO, will be the email sender's domain, so often
  #                          will just be the host e.g. the domain for test@gmail.com is gmail.com.
  #                          localhost can be used in development mode.
  #                          See https://datatracker.ietf.org/doc/html/rfc788#section-4
  # @param debug [Boolean] - When set to true, any errors will be logged at a warning
  #                          level before being re-raised.
  def self.validate_smtp(
    host:,
    port:,
    username:,
    password:,
    domain: nil,
    authentication: GlobalSetting.smtp_authentication,
    enable_starttls_auto: GlobalSetting.smtp_enable_start_tls,
    enable_tls: GlobalSetting.smtp_force_tls,
    openssl_verify_mode: GlobalSetting.smtp_openssl_verify_mode,
    debug: Rails.env.development?
  )
    begin
      port, enable_tls, enable_starttls_auto =
        provider_specific_ssl_overrides(host, port, enable_tls, enable_starttls_auto)

      if enable_tls && enable_starttls_auto
        raise ArgumentError, ""TLS and STARTTLS are mutually exclusive""
      end

      if !%i[plain login cram_md5].include?(authentication.to_sym)
        raise ArgumentError, ""Invalid authentication method. Must be plain, login, or cram_md5.""
      end

      if domain.blank?
        if Rails.env.development?
          domain = ""localhost""
        else
          # Because we are using the SMTP settings here to send emails,
          # the domain should just be the TLD of the host.
          domain = MiniSuffix.domain(host)
        end
      end

      smtp = Net::SMTP.new(host, port)

      # These SSL options are cribbed from the Mail gem, which is used internally
      # by ActionMailer. Unfortunately the mail gem hides this setup in private
      # methods, e.g. https://github.com/mikel/mail/blob/master/lib/mail/network/delivery_methods/smtp.rb#L112-L147
      #
      # Relying on the GlobalSetting options is a good idea here.
      #
      # For specific use cases, options should be passed in from higher up. For example
      # Gmail needs either port 465 and tls enabled, or port 587 and starttls_auto.
      if openssl_verify_mode.kind_of?(String)
        openssl_verify_mode = OpenSSL::SSL.const_get(""VERIFY_#{openssl_verify_mode.upcase}"")
      end
      ssl_context = Net::SMTP.default_ssl_context
      ssl_context.verify_mode = openssl_verify_mode if openssl_verify_mode

      smtp.enable_starttls_auto(ssl_context) if enable_starttls_auto
      smtp.enable_tls(ssl_context) if enable_tls

      smtp.open_timeout = 5
      smtp.read_timeout = 5

      smtp.start(domain, username, password, authentication.to_sym)
      smtp.finish
    rescue => err
      log_and_raise(err, debug)
    end
  end

  ##
  # Attempts to login, logout, and disconnect an IMAP session and if that raises
  # an error then it is assumed the credentials or some other settings are wrong.
  #
  # @param debug [Boolean] - When set to true, any errors will be logged at a warning
  #                          level before being re-raised.
  def self.validate_imap(
    host:,
    port:,
    username:,
    password:,
    open_timeout: 5,
    ssl: true,
    debug: false
  )
    begin
      imap = Net::IMAP.new(host, port: port, ssl: ssl, open_timeout: open_timeout)
      imap.login(username, password)
      begin
        imap.logout
      rescue StandardError
        nil
      end
      imap.disconnect
    rescue => err
      log_and_raise(err, debug)
    end
  end

  def self.log_and_raise(err, debug)
    if debug
      Rails.logger.warn(
        ""[EmailSettingsValidator] Error encountered when validating email settings: #{err.message} #{err.backtrace.join(""\n"")}"",
      )
    end
    raise err
  end

  def self.provider_specific_ssl_overrides(host, port, enable_tls, enable_starttls_auto)
    # Gmail acts weirdly if you do not use the correct combinations of
    # TLS settings based on the port, we clean these up here for the user.
    if host == ""smtp.gmail.com""
      if port.to_i == 587
        enable_starttls_auto = true
        enable_tls = false
      elsif port.to_i == 465
        enable_starttls_auto = false
        enable_tls = true
      end
    end

    [port, enable_tls, enable_starttls_auto]
  end
end

```","# frozen_string_literal: true

RSpec.describe EmailSettingsValidator do
  let(:username) { ""kwest@gmail.com"" }
  let(:password) { ""mbdtf"" }

  describe ""#validate_imap"" do
    let(:host) { ""imap.gmail.com"" }
    let(:port) { 993 }

    let(:net_imap_stub) do
      obj = mock()
      obj.stubs(:login).returns(true)
      obj
    end

    before { Net::IMAP.stubs(:new).returns(net_imap_stub) }

    it ""is valid if no error is raised"" do
      net_imap_stub.stubs(:logout).returns(true)
      net_imap_stub.stubs(:disconnect).returns(true)
      expect {
        described_class.validate_imap(
          host: host,
          port: port,
          username: username,
          password: password,
        )
      }.not_to raise_error
    end

    it ""is invalid if an error is raised"" do
      net_imap_stub.stubs(:login).raises(
        Net::IMAP::NoResponseError,
        stub(data: stub(text: ""no response"")),
      )
      expect {
        described_class.validate_imap(
          host: host,
          port: port,
          username: username,
          password: password,
          debug: true,
        )
      }.to raise_error(Net::IMAP::NoResponseError)
    end

    it ""logs a warning if debug: true passed in and still raises the error"" do
      net_imap_stub.stubs(:login).raises(
        Net::IMAP::NoResponseError,
        stub(data: stub(text: ""no response"")),
      )
      Rails
        .logger
        .expects(:warn)
        .with(regexp_matches(/\[EmailSettingsValidator\] Error encountered/))
        .at_least_once
      expect {
        described_class.validate_imap(
          host: host,
          port: port,
          username: username,
          password: password,
          debug: true,
        )
      }.to raise_error(Net::IMAP::NoResponseError)
    end
  end

  describe ""#validate_pop3"" do
    let(:host) { ""pop.gmail.com"" }
    let(:port) { 995 }

    let(:net_pop3_stub) do
      obj = mock()
      obj.stubs(:auth_only).returns(true)
      obj.stubs(:enable_ssl).returns(true)
      obj
    end

    before { Net::POP3.stubs(:new).returns(net_pop3_stub) }

    it ""is valid if no error is raised"" do
      expect {
        described_class.validate_pop3(
          host: host,
          port: port,
          username: username,
          password: password,
        )
      }.not_to raise_error
    end

    it ""is invalid if an error is raised"" do
      net_pop3_stub.stubs(:auth_only).raises(Net::POPAuthenticationError, ""invalid credentials"")
      expect {
        described_class.validate_pop3(
          host: host,
          port: port,
          username: username,
          password: password,
          debug: true,
        )
      }.to raise_error(Net::POPAuthenticationError)
    end

    it ""logs a warning if debug: true passed in and still raises the error"" do
      Rails
        .logger
        .expects(:warn)
        .with(regexp_matches(/\[EmailSettingsValidator\] Error encountered/))
        .at_least_once
      net_pop3_stub.stubs(:auth_only).raises(Net::POPAuthenticationError, ""invalid credentials"")
      expect {
        described_class.validate_pop3(
          host: host,
          port: port,
          username: username,
          password: password,
          debug: true,
        )
      }.to raise_error(Net::POPAuthenticationError)
    end

    it ""uses the correct ssl verify params if those settings are enabled"" do
      SiteSetting.pop3_polling_ssl = true
      SiteSetting.pop3_polling_openssl_verify = true
      net_pop3_stub.expects(:enable_ssl).with(max_version: OpenSSL::SSL::TLS1_2_VERSION)
      expect {
        described_class.validate_pop3(
          host: host,
          port: port,
          username: username,
          password: password,
        )
      }.not_to raise_error
    end

    it ""uses the correct ssl verify params if openssl_verify is not enabled"" do
      SiteSetting.pop3_polling_ssl = true
      SiteSetting.pop3_polling_openssl_verify = false
      net_pop3_stub.expects(:enable_ssl).with(OpenSSL::SSL::VERIFY_NONE)
      expect {
        described_class.validate_pop3(
          host: host,
          port: port,
          username: username,
          password: password,
        )
      }.not_to raise_error
    end
  end

  describe ""#validate_smtp"" do
    let(:host) { ""smtp.gmail.com"" }
    let(:port) { 587 }
    let(:domain) { ""gmail.com"" }

    let(:net_smtp_stub) do
      obj = mock()
      obj.stubs(:start).returns(true)
      obj.stubs(:finish).returns(true)
      obj.stubs(:enable_tls).returns(true)
      obj.stubs(:enable_starttls_auto).returns(true)
      obj.stubs(:open_timeout=)
      obj.stubs(:read_timeout=)
      obj
    end

    before { Net::SMTP.stubs(:new).returns(net_smtp_stub) }

    it ""is valid if no error is raised"" do
      expect {
        described_class.validate_smtp(
          host: host,
          port: port,
          username: username,
          password: password,
          domain: domain,
        )
      }.not_to raise_error
    end

    it ""is invalid if an error is raised"" do
      net_smtp_stub.stubs(:start).raises(Net::SMTPAuthenticationError, ""invalid credentials"")
      expect {
        described_class.validate_smtp(
          host: host,
          port: port,
          username: username,
          password: password,
          domain: domain,
        )
      }.to raise_error(Net::SMTPAuthenticationError)
    end

    it ""logs a warning if debug: true passed in and still raises the error"" do
      Rails
        .logger
        .expects(:warn)
        .with(regexp_matches(/\[EmailSettingsValidator\] Error encountered/))
        .at_least_once
      net_smtp_stub.stubs(:start).raises(
        Net::SMTPAuthenticationError,
        stub(message: ""invalid credentials""),
      )
      expect {
        described_class.validate_smtp(
          host: host,
          port: port,
          username: username,
          password: password,
          debug: true,
          domain: domain,
        )
      }.to raise_error(Net::SMTPAuthenticationError)
    end

    it ""uses the correct ssl verify params for enable_tls if those settings are enabled"" do
      net_smtp_stub.expects(:enable_tls)
      expect {
        described_class.validate_smtp(
          host: host,
          port: 465,
          username: username,
          password: password,
          domain: domain,
          openssl_verify_mode: ""peer"",
          enable_tls: true,
          enable_starttls_auto: false,
        )
      }.not_to raise_error
    end

    it ""uses the correct ssl verify params for enable_starttls_auto if those settings are enabled"" do
      net_smtp_stub.expects(:enable_starttls_auto)
      expect {
        described_class.validate_smtp(
          host: host,
          port: 587,
          username: username,
          password: password,
          domain: domain,
          openssl_verify_mode: ""peer"",
          enable_tls: false,
          enable_starttls_auto: true,
        )
      }.not_to raise_error
    end

    it ""raises an ArgumentError if both enable_tls is true and enable_starttls_auto is true"" do
      expect {
        described_class.validate_smtp(
          host: host,
          port: port,
          username: username,
          password: password,
          domain: domain,
          enable_ssl: true,
          enable_starttls_auto: true,
        )
      }.to raise_error(ArgumentError)
    end

    it ""raises an ArgumentError if a bad authentication method is used"" do
      expect {
        described_class.validate_smtp(
          host: host,
          port: port,
          username: username,
          password: password,
          domain: domain,
          authentication: :rubber_stamp,
        )
      }.to raise_error(ArgumentError)
    end

    context ""when the domain is not provided"" do
      let(:domain) { nil }
      it ""gets the domain from the host"" do
        net_smtp_stub.expects(:start).with(""gmail.com"", username, password, :plain)
        described_class.validate_smtp(
          host: host,
          port: port,
          username: username,
          password: password,
          enable_tls: true,
          enable_starttls_auto: false,
        )
      end

      it ""uses localhost when in development mode"" do
        Rails.env.stubs(:development?).returns(true)
        net_smtp_stub.expects(:start).with(""localhost"", username, password, :plain)
        described_class.validate_smtp(
          host: host,
          port: port,
          username: username,
          password: password,
          enable_tls: true,
          enable_starttls_auto: false,
        )
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class UserStatCountUpdater
  class << self
    def increment!(post, user_stat: nil)
      update_using_operator!(post, user_stat: user_stat, action: :increment!)
    end

    def decrement!(post, user_stat: nil)
      update_using_operator!(post, user_stat: user_stat, action: :decrement!)
    end

    def set!(user_stat:, count:, count_column:)
      return if user_stat.blank?
      return if !%i[post_count topic_count].include?(count_column)

      if SiteSetting.verbose_user_stat_count_logging && count < 0
        Rails.logger.warn(
          ""Attempted to insert negative count into UserStat##{count_column} for user #{user_stat.user_id}, using 0 instead. Caller:\n #{caller[0..10].join(""\n"")}"",
        )
      end

      user_stat.update_column(count_column, [count, 0].max)
    end

    private

    def update_using_operator!(post, user_stat: nil, action: :increment!)
      return if !post&.topic
      return if action == :increment! && post.topic.private_message?
      stat = user_stat || post.user&.user_stat

      return if stat.blank?

      column =
        if post.is_first_post?
          :topic_count
        elsif post.post_type == Post.types[:regular]
          :post_count
        end

      return if column.blank?

      # There are lingering bugs in the code base that does not properly increase the count when the status of the post
      # changes. Since we have Job::DirectoryRefreshOlder which runs daily to reconcile the count, there is no need
      # to trigger an error.
      if action == :decrement! && stat.public_send(column) < 1
        if SiteSetting.verbose_user_stat_count_logging
          Rails.logger.warn(
            ""Attempted to insert negative count into UserStat##{column} for post with id '#{post.id}'. Caller:\n #{caller[0..10].join(""\n"")}"",
          )
        end

        return
      end

      stat.public_send(action, column)
    end
  end
end

```","# frozen_string_literal: true

RSpec.describe UserStatCountUpdater do
  fab!(:user)
  fab!(:user_stat) { user.user_stat }
  fab!(:post)
  fab!(:post_2) { Fabricate(:post, topic: post.topic) }

  before do
    @orig_logger = Rails.logger
    Rails.logger = @fake_logger = FakeLogger.new
    SiteSetting.verbose_user_stat_count_logging = true
  end

  after { Rails.logger = @orig_logger }

  it ""should log the exception when a negative count is inserted"" do
    UserStatCountUpdater.decrement!(post, user_stat: user_stat)

    expect(@fake_logger.warnings.last).to match(""topic_count"")
    expect(@fake_logger.warnings.last).to match(post.id.to_s)

    UserStatCountUpdater.decrement!(post_2, user_stat: user_stat)

    expect(@fake_logger.warnings.last).to match(""post_count"")
    expect(@fake_logger.warnings.last).to match(post_2.id.to_s)
  end

  it ""should log the exception when a negative count will be inserted but 0 is used instead"" do
    UserStatCountUpdater.set!(user_stat: user_stat, count: -10, count_column: :post_count)

    expect(@fake_logger.warnings.last).to match(""post_count"")
    expect(@fake_logger.warnings.last).to match(""using 0"")
    expect(@fake_logger.warnings.last).to match(""user #{user_stat.user_id}"")
    expect(user_stat.reload.post_count).to eq(0)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class UserAuthenticator
  def initialize(
    user,
    session,
    authenticator_finder: Users::OmniauthCallbacksController,
    require_password: true
  )
    @user = user
    @session = session
    if session&.dig(:authentication) && session[:authentication].is_a?(Hash)
      @auth_result = Auth::Result.from_session_data(session[:authentication], user: user)
    end
    @authenticator_finder = authenticator_finder
    @require_password = require_password
  end

  def start
    if authenticated?
      @user.active = true
      @auth_result.apply_user_attributes!
    elsif @require_password
      @user.password_required!
    end

    @user.skip_email_validation = true if @auth_result && @auth_result.skip_email_validation
  end

  def has_authenticator?
    !!authenticator
  end

  def finish
    if authenticator
      authenticator.after_create_account(@user, @auth_result)
      confirm_email
    end
    @session[:authentication] = @auth_result = nil if @session&.dig(:authentication)
  end

  def email_valid?
    @auth_result&.email_valid
  end

  def authenticated?
    return false if !@auth_result
    return false if @auth_result&.email&.downcase != @user.email.downcase
    return false if !@auth_result.email_valid
    true
  end

  private

  def confirm_email
    @user.activate if authenticated?
  end

  def authenticator
    if authenticator_name
      @authenticator ||= @authenticator_finder.find_authenticator(authenticator_name)
    end
  end

  def authenticator_name
    @auth_result&.authenticator_name
  end
end

```","# frozen_string_literal: true

RSpec.describe UserAuthenticator do
  def github_auth(email_valid)
    {
      email: ""user53@discourse.org"",
      username: ""joedoe546"",
      email_valid: email_valid,
      omit_username: nil,
      name: ""Joe Doe 546"",
      authenticator_name: ""github"",
      extra_data: {
        provider: ""github"",
        uid: ""100"",
      },
      skip_email_validation: false,
    }
  end

  before { SiteSetting.enable_github_logins = true }

  describe ""#start"" do
    describe ""without authentication session"" do
      it ""should apply the right user attributes"" do
        user = User.new
        UserAuthenticator.new(user, {}).start

        expect(user.password_required?).to eq(true)
      end

      it ""allows password requirement to be skipped"" do
        user = User.new
        UserAuthenticator.new(user, {}, require_password: false).start

        expect(user.password_required?).to eq(false)
      end
    end
  end

  describe ""#finish"" do
    fab!(:group) { Fabricate(:group, automatic_membership_email_domains: ""discourse.org"") }

    it ""confirms email and adds the user to appropriate groups based on email"" do
      user = Fabricate(:user, email: ""user53@discourse.org"")
      expect(group.usernames).not_to include(user.username)

      authentication = github_auth(true)

      UserAuthenticator.new(user, { authentication: authentication }).finish
      expect(user.email_confirmed?).to be_truthy
      expect(group.usernames).to include(user.username)
    end

    it ""doesn't confirm email if email is invalid"" do
      user = Fabricate(:user, email: ""user53@discourse.org"")

      authentication = github_auth(false)

      UserAuthenticator.new(user, { authentication: authentication }).finish
      expect(user.email_confirmed?).to be_falsey
      expect(group.usernames).not_to include(user.username)
    end

    it ""doesn't confirm email if it was changed"" do
      user = Fabricate(:user, email: ""changed@discourse.org"")

      authentication = github_auth(true)

      UserAuthenticator.new(user, { authentication: authentication }).finish
      expect(user.email_confirmed?).to be_falsey
      expect(group.usernames).not_to include(user.username)
    end

    it ""clears the authentication info from the session"" do
      user = Fabricate(:user, email: ""user53@discourse.org"")
      session = { authentication: github_auth(true) }

      UserAuthenticator.new(user, session).finish
      expect(user.email_confirmed?).to be_truthy

      expect(session[:authentication]).to eq(nil)
    end

    it ""raises an error for non-boolean values"" do
      user = Fabricate(:user, email: ""user53@discourse.org"")
      session = { authentication: github_auth(""string"") }

      expect do UserAuthenticator.new(user, session).finish end.to raise_error ArgumentError
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Used as a data source via HashtagAutocompleteService to provide tag
# results when looking up a tag slug via markdown or searching for
# tags via the # autocomplete character.
class TagHashtagDataSource
  def self.enabled?
    SiteSetting.tagging_enabled
  end

  def self.icon
    ""tag""
  end

  def self.type
    ""tag""
  end

  def self.tag_to_hashtag_item(tag, guardian)
    topic_count_column = Tag.topic_count_column(guardian)

    tag =
      Tag.new(
        tag.slice(:id, :name, :description).merge(topic_count_column => tag[:count]),
      ) if tag.is_a?(Hash)

    HashtagAutocompleteService::HashtagItem.new.tap do |item|
      item.text = tag.name
      item.secondary_text = ""x#{tag.public_send(topic_count_column)}""
      item.description = tag.description
      item.slug = tag.name
      item.relative_url = tag.url
      item.icon = icon
      item.id = tag.id
    end
  end
  private_class_method :tag_to_hashtag_item

  def self.lookup(guardian, slugs)
    DiscourseTagging
      .filter_visible(Tag.where_name(slugs), guardian)
      .map { |tag| tag_to_hashtag_item(tag, guardian) }
  end

  def self.search(
    guardian,
    term,
    limit,
    condition = HashtagAutocompleteService.search_conditions[:contains]
  )
    tags_with_counts, _ =
      DiscourseTagging.filter_allowed_tags(
        guardian,
        term: term,
        term_type:
          (
            if condition == HashtagAutocompleteService.search_conditions[:starts_with]
              DiscourseTagging.term_types[:starts_with]
            else
              DiscourseTagging.term_types[:contains]
            end
          ),
        with_context: true,
        limit: limit,
        order_search_results: true,
      )

    TagsController
      .tag_counts_json(tags_with_counts, guardian)
      .take(limit)
      .map do |tag|
        # We want the actual ID here not the `name` as tag_counts_json gives us.
        tag[:id] = tags_with_counts.find { |t| t.name == tag[:name] }.id
        tag_to_hashtag_item(tag, guardian)
      end
  end

  def self.search_sort(search_results, _)
    search_results.sort_by { |item| item.text.downcase }
  end

  def self.search_without_term(guardian, limit)
    tags_with_counts, _ =
      DiscourseTagging.filter_allowed_tags(
        guardian,
        with_context: true,
        limit: limit,
        order_popularity: true,
        excluded_tag_names: DiscourseTagging.muted_tags(guardian.user),
      )

    TagsController
      .tag_counts_json(tags_with_counts, guardian)
      .take(limit)
      .map { |tag| tag_to_hashtag_item(tag, guardian) }
  end
end

```","# frozen_string_literal: true

RSpec.describe TagHashtagDataSource do
  fab!(:tag1) { Fabricate(:tag, name: ""fact"", public_topic_count: 0) }
  fab!(:tag2) { Fabricate(:tag, name: ""factor"", public_topic_count: 5) }
  fab!(:tag3) { Fabricate(:tag, name: ""factory"", public_topic_count: 4) }
  fab!(:tag4) { Fabricate(:tag, name: ""factorio"", public_topic_count: 3) }
  fab!(:tag5) { Fabricate(:tag, name: ""factz"", public_topic_count: 1) }
  fab!(:user)
  let(:guardian) { Guardian.new(user) }

  describe ""#enabled?"" do
    it ""returns false if tagging is disabled"" do
      SiteSetting.tagging_enabled = false
      expect(described_class.enabled?).to eq(false)
    end

    it ""returns true if tagging is enabled"" do
      SiteSetting.tagging_enabled = true
      expect(described_class.enabled?).to eq(true)
    end
  end

  describe ""#search"" do
    it ""orders tag results by exact search match, then public topic count, then name"" do
      expect(described_class.search(guardian, ""fact"", 5).map(&:slug)).to eq(
        %w[fact factor factory factorio factz],
      )
    end

    it ""does not get more than the limit"" do
      expect(described_class.search(guardian, ""fact"", 1).map(&:slug)).to eq(%w[fact])
    end

    it ""does not get tags that the user does not have permission to see"" do
      Fabricate(:tag_group, permissions: { ""staff"" => 1 }, tag_names: [""fact""])
      expect(described_class.search(guardian, ""fact"", 5).map(&:slug)).not_to include(""fact"")
    end

    it ""returns an array of HashtagAutocompleteService::HashtagItem"" do
      expect(described_class.search(guardian, ""fact"", 1).first).to be_a(
        HashtagAutocompleteService::HashtagItem,
      )
    end

    it ""includes the public topic count for the text of the tag in secondary text"" do
      expect(described_class.search(guardian, ""fact"", 5).map(&:secondary_text)).to eq(
        %w[x0 x5 x4 x3 x1],
      )
    end

    it ""returns tags that are children of a TagGroup"" do
      parent_tag = Fabricate(:tag, name: ""sidebar"")
      child_tag = Fabricate(:tag, name: ""sidebar-v1"")
      tag_group = Fabricate(:tag_group, parent_tag: parent_tag, name: ""Sidebar TG"")
      TagGroupMembership.create!(tag: child_tag, tag_group: tag_group)
      expect(described_class.search(guardian, ""sidebar-v"", 5).map(&:slug)).to eq(%w[sidebar-v1])
    end
  end

  describe ""#search_without_term"" do
    it ""returns distinct tags sorted by public topic count"" do
      expect(described_class.search_without_term(guardian, 5).map(&:slug)).to eq(
        %w[factor factory factorio factz fact],
      )
    end

    it ""does not return tags the user does not have permission to view"" do
      Fabricate(:tag_group, permissions: { ""staff"" => 1 }, tag_names: [""factor""])
      expect(described_class.search_without_term(guardian, 5).map(&:slug)).not_to include(""factor"")
    end

    it ""does not return tags the user has muted"" do
      TagUser.create(user: user, tag: tag2, notification_level: TagUser.notification_levels[:muted])
      expect(described_class.search_without_term(guardian, 5).map(&:slug)).not_to include(""factor"")
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# A service class that backfills the changes to the default sidebar categories and tags site settings.
#
# When a category/tag is removed from the site settings, the `SidebarSectionLink` records associated with the category/tag
# are deleted.
#
# When a category/tag is added to the site settings, a `SidebarSectionLink` record for the associated category/tag are
# created for all users that do not already have a `SidebarSectionLink` record for the category/tag.
class SidebarSiteSettingsBackfiller
  def initialize(setting_name, previous_value:, new_value:)
    @setting_name = setting_name

    @linkable_klass, previous_ids, new_ids =
      case setting_name
      when ""default_navigation_menu_categories""
        [Category, previous_value.split(""|""), new_value.split(""|"")]
      when ""default_navigation_menu_tags""
        klass = Tag

        [
          klass,
          klass.where(name: previous_value.split(""|"")).pluck(:id),
          klass.where(name: new_value.split(""|"")).pluck(:id),
        ]
      else
        raise ""Invalid setting_name""
      end

    @added_ids = new_ids - previous_ids
    @removed_ids = previous_ids - new_ids
  end

  def backfill!
    DistributedMutex.synchronize(""backfill_sidebar_site_settings_#{@setting_name}"") do
      SidebarSectionLink.where(
        linkable_type: @linkable_klass.to_s,
        linkable_id: @removed_ids,
      ).delete_all

      User
        .real
        .where(staged: false)
        .select(:id)
        .find_in_batches do |users|
          rows = []

          users.each do |user|
            @added_ids.each do |linkable_id|
              rows << {
                user_id: user[:id],
                linkable_type: @linkable_klass.to_s,
                linkable_id: linkable_id,
              }
            end
          end

          SidebarSectionLink.insert_all(rows) if rows.present?
        end
    end
  end

  def number_of_users_to_backfill
    select_statements = []

    select_statements.push(<<~SQL) if @removed_ids.present?
      SELECT
        sidebar_section_links.user_id
      FROM sidebar_section_links
      WHERE sidebar_section_links.linkable_type = '#{@linkable_klass.to_s}'
      AND sidebar_section_links.linkable_id IN (#{@removed_ids.join("","")})
      SQL

    if @added_ids.present?
      # Returns the ids of users that will receive the new additions by excluding the users that already have the additions
      # Note that we want to avoid doing a left outer join against the ""sidebar_section_links"" table as PG will end up having
      # to do a full table join for both tables first which is less efficient and can be slow on large sites.
      select_statements.push(<<~SQL)
      SELECT
        users.id
      FROM users
      WHERE users.id NOT IN (
        SELECT
          DISTINCT(sidebar_section_links.user_id)
        FROM sidebar_section_links
        WHERE sidebar_section_links.linkable_type = '#{@linkable_klass.to_s}'
        AND sidebar_section_links.linkable_id IN (#{@added_ids.join("","")})
      ) AND users.id > 0 AND NOT users.staged
      SQL
    end

    return 0 if select_statements.blank?

    DB.query_single(<<~SQL)[0]
    SELECT
      COUNT(*)
    FROM (#{select_statements.join(""\nUNION DISTINCT\n"")}) AS user_ids
    SQL
  end
end

```","# frozen_string_literal: true

RSpec.describe SidebarSiteSettingsBackfiller do
  fab!(:user)
  fab!(:user2) { Fabricate(:user) }
  fab!(:user3) { Fabricate(:user) }
  fab!(:staged_user) { Fabricate(:user, staged: true) }
  fab!(:category)
  fab!(:category2) { Fabricate(:category) }
  fab!(:category3) { Fabricate(:category) }
  fab!(:user_category_sidebar_section_link) do
    Fabricate(:category_sidebar_section_link, user: user, linkable: category)
  end
  fab!(:user2_category_sidebar_section_link) do
    Fabricate(:category_sidebar_section_link, user: user2, linkable: category)
  end
  fab!(:user3_category2_sidebar_section_link) do
    Fabricate(:category_sidebar_section_link, user: user3, linkable: category2)
  end

  let!(:category_sidebar_section_link_ids) do
    [
      user_category_sidebar_section_link.id,
      user2_category_sidebar_section_link.id,
      user3_category2_sidebar_section_link.id,
    ]
  end

  fab!(:tag)
  fab!(:tag2) { Fabricate(:tag) }
  fab!(:tag3) { Fabricate(:tag) }
  fab!(:user_tag_sidebar_section_link) do
    Fabricate(:tag_sidebar_section_link, user: user, linkable: tag)
  end
  fab!(:user2_tag_sidebar_section_link) do
    Fabricate(:tag_sidebar_section_link, user: user2, linkable: tag)
  end
  fab!(:user3_tag2_sidebar_section_link) do
    Fabricate(:tag_sidebar_section_link, user: user3, linkable: tag2)
  end

  let!(:tag_sidebar_section_link_ids) do
    [
      user_tag_sidebar_section_link.id,
      user2_tag_sidebar_section_link.id,
      user3_tag2_sidebar_section_link.id,
    ]
  end

  before do
    # Clean up random users created as part of fabrication to make assertions easier to understand.
    User.real.where(""id NOT IN (?)"", [user.id, user2.id, user3.id, staged_user.id]).delete_all
  end

  it ""raises an error when class is initialized with invalid setting name"" do
    expect do
      described_class.new(""some_random_setting_name"", previous_value: """", new_value: """")
    end.to raise_error(RuntimeError, ""Invalid setting_name"")
  end

  describe ""#backfill!"" do
    context ""for default_navigation_menu_categories setting"" do
      it ""deletes the right sidebar section link records when categories are removed"" do
        backfiller =
          described_class.new(
            ""default_navigation_menu_categories"",
            previous_value: ""#{category.id}|#{category2.id}|#{category3.id}"",
            new_value: ""#{category3.id}"",
          )

        expect do backfiller.backfill! end.to change { SidebarSectionLink.count }.by(-3)

        expect(SidebarSectionLink.exists?(id: category_sidebar_section_link_ids)).to eq(false)
      end

      it ""updates the right sidebar section link records when categories are added"" do
        backfiller =
          described_class.new(
            ""default_navigation_menu_categories"",
            previous_value: ""#{category.id}|#{category2.id}"",
            new_value: ""#{category.id}|#{category2.id}|#{category3.id}"",
          )

        expect do backfiller.backfill! end.to change { SidebarSectionLink.count }.by(3)

        expect(
          SidebarSectionLink.where(linkable_type: ""Category"", linkable_id: category3.id).pluck(
            :user_id,
          ),
        ).to contain_exactly(user.id, user2.id, user3.id)
      end

      it ""creates the right sidebar section link records when categories are added"" do
        backfiller =
          described_class.new(
            ""default_navigation_menu_categories"",
            previous_value: """",
            new_value: ""#{category.id}|#{category2.id}|#{category3.id}"",
          )

        expect do backfiller.backfill! end.to change { SidebarSectionLink.count }.by(6)

        expect(
          SidebarSectionLink.where(linkable_type: ""Category"", linkable_id: category.id).pluck(
            :user_id,
          ),
        ).to contain_exactly(user.id, user2.id, user3.id)

        expect(
          SidebarSectionLink.where(linkable_type: ""Category"", linkable_id: category2.id).pluck(
            :user_id,
          ),
        ).to contain_exactly(user.id, user2.id, user3.id)

        expect(
          SidebarSectionLink.where(linkable_type: ""Category"", linkable_id: category3.id).pluck(
            :user_id,
          ),
        ).to contain_exactly(user.id, user2.id, user3.id)
      end

      it ""deletes and creates the right sidebar section link records when categories are added and removed"" do
        backfiller =
          described_class.new(
            ""default_navigation_menu_categories"",
            previous_value: ""#{category.id}|#{category2.id}"",
            new_value: ""#{category3.id}"",
          )

        original_count = SidebarSectionLink.count

        expect do backfiller.backfill! end.to change {
          SidebarSectionLink.where(linkable_type: ""Category"", linkable_id: category.id).count
        }.by(-2).and change {
                SidebarSectionLink.where(linkable_type: ""Category"", linkable_id: category2.id).count
              }.by(-1).and change {
                      SidebarSectionLink.where(
                        linkable_type: ""Category"",
                        linkable_id: category3.id,
                      ).count
                    }.by(3)

        expect(SidebarSectionLink.count).to eq(original_count) # Net change of 0

        expect(
          SidebarSectionLink.where(linkable_type: ""Category"", linkable_id: category3.id).pluck(
            :user_id,
          ),
        ).to contain_exactly(user.id, user2.id, user3.id)
      end
    end

    context ""for default_navigation_menu_tags setting"" do
      it ""deletes the right sidebar section link records when tags are removed"" do
        backfiller =
          described_class.new(
            ""default_navigation_menu_tags"",
            previous_value: ""#{tag.name}|#{tag2.name}|#{tag3.name}"",
            new_value: ""#{tag3.name}"",
          )

        expect do backfiller.backfill! end.to change { SidebarSectionLink.count }.by(-3)

        expect(SidebarSectionLink.exists?(id: tag_sidebar_section_link_ids)).to eq(false)
      end

      it ""creates the right sidebar section link records when tags are added"" do
        backfiller =
          described_class.new(
            ""default_navigation_menu_tags"",
            previous_value: ""#{tag.name}|#{tag2.name}"",
            new_value: ""#{tag.name}|#{tag2.name}|#{tag3.name}"",
          )

        expect do backfiller.backfill! end.to change { SidebarSectionLink.count }.by(3)

        expect(
          SidebarSectionLink.where(linkable_type: ""Tag"", linkable_id: tag3.id).pluck(:user_id),
        ).to contain_exactly(user.id, user2.id, user3.id)
      end

      it ""deletes and creates the right sidebar section link records when tags are added and removed"" do
        backfiller =
          described_class.new(
            ""default_navigation_menu_tags"",
            previous_value: ""#{tag.name}|#{tag2.name}"",
            new_value: ""#{tag3.name}"",
          )

        original_count = SidebarSectionLink.count

        expect do backfiller.backfill! end.to change {
          SidebarSectionLink.where(linkable_type: ""Tag"", linkable_id: tag.id).count
        }.by(-2).and change {
                SidebarSectionLink.where(linkable_type: ""Tag"", linkable_id: tag2.id).count
              }.by(-1).and change {
                      SidebarSectionLink.where(linkable_type: ""Tag"", linkable_id: tag3.id).count
                    }.by(3)

        expect(SidebarSectionLink.count).to eq(original_count) # net change of 0

        expect(
          SidebarSectionLink.where(linkable_type: ""Tag"", linkable_id: tag3.id).pluck(:user_id),
        ).to contain_exactly(user.id, user2.id, user3.id)
      end
    end
  end

  describe ""#number_of_users_to_backfill"" do
    context ""for default_navigation_menu_categories setting"" do
      it ""returns 3 for the user count when a new category for all users is added"" do
        backfiller =
          described_class.new(
            ""default_navigation_menu_categories"",
            previous_value: """",
            new_value: ""#{category3.id}"",
          )

        expect(backfiller.number_of_users_to_backfill).to eq(3)
      end

      it ""returns 2 for the user count when category which 2 users have configured in sidebar is removed"" do
        backfiller =
          described_class.new(
            ""default_navigation_menu_categories"",
            previous_value: ""#{category.id}|#{category2.id}"",
            new_value: ""#{category2.id}"",
          )

        expect(backfiller.number_of_users_to_backfill).to eq(2)
      end

      # category, category2 => category2, category3
      it ""returns 3 for the user count when a new category is added and a category is removed"" do
        backfiller =
          described_class.new(
            ""default_navigation_menu_categories"",
            previous_value: ""#{category.id}|#{category2.id}"",
            new_value: ""#{category2.id}|#{category3.id}"",
          )

        expect(backfiller.number_of_users_to_backfill).to eq(3)
      end

      it ""returns 0 for the user count when no new category is added or removed"" do
        backfiller =
          described_class.new(
            ""default_navigation_menu_categories"",
            previous_value: """",
            new_value: """",
          )

        expect(backfiller.number_of_users_to_backfill).to eq(0)
      end
    end

    context ""for default_navigation_menu_tags setting"" do
      it ""returns 3 for the user count when a new tag for all users is added"" do
        backfiller =
          described_class.new(
            ""default_navigation_menu_tags"",
            previous_value: """",
            new_value: ""#{tag3.name}"",
          )

        expect(backfiller.number_of_users_to_backfill).to eq(3)
      end

      # tag, tag2 => tag2
      it ""returns 2 for the user count when tag which 2 users have configured in sidebar is removed"" do
        backfiller =
          described_class.new(
            ""default_navigation_menu_tags"",
            previous_value: ""#{tag.name}|#{tag2.name}"",
            new_value: ""#{tag2.name}"",
          )

        expect(backfiller.number_of_users_to_backfill).to eq(2)
      end

      # tag, tag2 => tag2, tag3
      it ""returns 3 for the user count when a new tag is added and a tag is removed"" do
        backfiller =
          described_class.new(
            ""default_navigation_menu_tags"",
            previous_value: ""#{tag.name}|#{tag2.name}"",
            new_value: ""#{tag2.name}|#{tag3.name}"",
          )

        expect(backfiller.number_of_users_to_backfill).to eq(3)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class DestroyTask
  def initialize(io = STDOUT)
    @io = io
  end

  def destroy_topics(category, parent_category = nil, delete_system_topics = false)
    c = Category.find_by_slug(category, parent_category)
    descriptive_slug = parent_category ? ""#{parent_category}/#{category}"" : category
    return @io.puts ""A category with the slug: #{descriptive_slug} could not be found"" if c.nil?
    if delete_system_topics
      topics = Topic.where(category_id: c.id, pinned_at: nil)
    else
      topics = Topic.where(category_id: c.id, pinned_at: nil).where.not(user_id: -1)
    end
    @io.puts ""There are #{topics.count} topics to delete in #{descriptive_slug} category""
    topics.find_each do |topic|
      @io.puts ""Deleting #{topic.slug}...""
      first_post = topic.ordered_posts.first
      return @io.puts ""Topic.ordered_posts.first was nil"" if first_post.nil?
      @io.puts PostDestroyer.new(Discourse.system_user, first_post).destroy
    end
  end

  def destroy_topics_in_category(category_id, delete_system_topics = false)
    c = Category.find(category_id)
    return @io.puts ""A category with the id: #{category_id} could not be found"" if c.nil?
    if delete_system_topics
      topics = Topic.where(category_id: c.id, pinned_at: nil)
    else
      topics = Topic.where(category_id: c.id, pinned_at: nil).where.not(user_id: -1)
    end
    @io.puts ""There are #{topics.count} topics to delete in #{c.slug} category""
    topics.find_each do |topic|
      first_post = topic.ordered_posts.first
      return @io.puts ""Topic.ordered_posts.first was nil for topic: #{topic.id}"" if first_post.nil?
      PostDestroyer.new(Discourse.system_user, first_post).destroy
    end
    topics = Topic.where(category_id: c.id, pinned_at: nil)
    @io.puts ""There are #{topics.count} topics that could not be deleted in #{c.slug} category""
  end

  def destroy_topics_all_categories
    categories = Category.all
    categories.each { |c| @io.puts destroy_topics(c.slug, c.parent_category&.slug) }
  end

  def destroy_private_messages
    Topic
      .where(archetype: ""private_message"")
      .find_each do |pm|
        @io.puts ""Destroying #{pm.slug} pm""
        first_post = pm.ordered_posts.first
        @io.puts PostDestroyer.new(Discourse.system_user, first_post).destroy
      end
  end

  def destroy_category(category_id, destroy_system_topics = false)
    c = Category.find_by_id(category_id)
    return @io.puts ""A category with the id: #{category_id} could not be found"" if c.nil?
    subcategories = Category.where(parent_category_id: c.id)
    @io.puts ""There are #{subcategories.count} subcategories to delete"" if subcategories
    subcategories.each { |s| category_topic_destroyer(s, destroy_system_topics) }
    category_topic_destroyer(c, destroy_system_topics)
  end

  def destroy_groups
    groups = Group.where(automatic: false)
    groups.each do |group|
      @io.puts ""destroying group: #{group.id}""
      @io.puts group.destroy
    end
  end

  def destroy_users
    User
      .human_users
      .where(admin: false)
      .find_each do |user|
        begin
          if UserDestroyer.new(Discourse.system_user).destroy(
               user,
               delete_posts: true,
               context: ""destroy task"",
             )
            @io.puts ""#{user.username} deleted""
          else
            @io.puts ""#{user.username} not deleted""
          end
        rescue UserDestroyer::PostsExistError
          raise Discourse::InvalidAccess.new(
                  ""User #{user.username} has #{user.post_count} posts, so can't be deleted."",
                )
        rescue NoMethodError
          @io.puts ""#{user.username} could not be deleted""
        rescue Discourse::InvalidAccess => e
          @io.puts ""#{user.username} #{e.message}""
        end
      end
  end

  def destroy_stats
    ApplicationRequest.delete_all
    IncomingLink.delete_all
    UserVisit.delete_all
    UserProfileView.delete_all
    UserProfile.update_all(views: 0)
    PostAction.unscoped.delete_all
    EmailLog.delete_all
  end

  private

  def category_topic_destroyer(category, destroy_system_topics = false)
    destroy_topics_in_category(category.id, destroy_system_topics)
    @io.puts ""Destroying #{category.slug} category""
    category.destroy
  end
end

```","# frozen_string_literal: true

RSpec.describe DestroyTask do
  describe ""destroy topics"" do
    fab!(:c) { Fabricate(:category_with_definition) }
    fab!(:t) { Fabricate(:topic, category: c) }
    let!(:p) { Fabricate(:post, topic: t) }
    fab!(:c2) { Fabricate(:category_with_definition) }
    fab!(:t2) { Fabricate(:topic, category: c2) }
    let!(:p2) { Fabricate(:post, topic: t2) }
    fab!(:sc) { Fabricate(:category_with_definition, parent_category: c2) }
    fab!(:t3) { Fabricate(:topic, category: sc) }
    let!(:p3) { Fabricate(:post, topic: t3) }

    it ""destroys all topics in a category"" do
      destroy_task = DestroyTask.new(StringIO.new)
      expect { destroy_task.destroy_topics(c.slug) }.to change {
        Topic.where(category_id: c.id).count
      }.by (-1)
    end

    it ""destroys all topics in a sub category"" do
      destroy_task = DestroyTask.new(StringIO.new)
      expect { destroy_task.destroy_topics(sc.slug, c2.slug) }.to change {
        Topic.where(category_id: sc.id).count
      }.by(-1)
    end

    it ""doesn't destroy system topics"" do
      destroy_task = DestroyTask.new(StringIO.new)
      destroy_task.destroy_topics(c2.slug)
      expect(Topic.where(category_id: c2.id).count).to eq 1
    end

    it ""destroys topics in all categories"" do
      destroy_task = DestroyTask.new(StringIO.new)
      destroy_task.destroy_topics_all_categories
      expect(Post.where(topic_id: [t.id, t2.id, t3.id]).count).to eq 0
    end
  end

  describe ""destroy categories"" do
    fab!(:c) { Fabricate(:category_with_definition) }
    fab!(:t) { Fabricate(:topic, category: c) }
    let!(:p) { Fabricate(:post, topic: t) }
    fab!(:c2) { Fabricate(:category_with_definition) }
    fab!(:t2) { Fabricate(:topic, category: c) }
    let!(:p2) { Fabricate(:post, topic: t2) }
    fab!(:sc) { Fabricate(:category_with_definition, parent_category: c2) }
    fab!(:t3) { Fabricate(:topic, category: sc) }
    let!(:p3) { Fabricate(:post, topic: t3) }

    it ""destroys specified category"" do
      destroy_task = DestroyTask.new(StringIO.new)

      expect { destroy_task.destroy_category(c.id) }.to change {
        Category.where(id: c.id).count
      }.by (-1)
    end

    it ""destroys sub-categories when destroying parent category"" do
      destroy_task = DestroyTask.new(StringIO.new)

      expect { destroy_task.destroy_category(c2.id) }.to change {
        Category.where(id: sc.id).count
      }.by (-1)
    end
  end

  describe ""private messages"" do
    let!(:pm) { Fabricate(:private_message_post) }
    let!(:pm2) { Fabricate(:private_message_post) }

    it ""destroys all private messages"" do
      destroy_task = DestroyTask.new(StringIO.new)
      destroy_task.destroy_private_messages
      expect(Topic.where(archetype: ""private_message"").count).to eq 0
    end
  end

  describe ""groups"" do
    let!(:g) { Fabricate(:group) }
    let!(:g2) { Fabricate(:group) }

    it ""destroys all groups"" do
      destroy_task = DestroyTask.new(StringIO.new)
      destroy_task.destroy_groups
      expect(Group.where(automatic: false).count).to eq 0
    end

    it ""doesn't destroy default groups"" do
      destroy_task = DestroyTask.new(StringIO.new)
      before_count = Group.count
      destroy_task.destroy_groups
      expect(Group.count).to eq before_count - 2
    end
  end

  describe ""users"" do
    it ""destroys all non-admin users"" do
      before_count = User.count

      Fabricate(:user)
      Fabricate(:user)
      Fabricate(:admin)

      destroy_task = DestroyTask.new(StringIO.new)
      destroy_task.destroy_users
      expect(User.where(admin: false).count).to eq 0
      # admin does not get destroyed
      expect(User.count).to eq before_count + 1
    end
  end

  describe ""stats"" do
    it ""destroys all site stats"" do
      destroy_task = DestroyTask.new(StringIO.new)
      destroy_task.destroy_stats
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

require ""net/imap""
require ""net/smtp""
require ""net/pop""

class EmailSettingsExceptionHandler
  EXPECTED_EXCEPTIONS = [
    Net::POPAuthenticationError,
    Net::IMAP::NoResponseError,
    Net::IMAP::Error,
    Net::SMTPAuthenticationError,
    Net::SMTPServerBusy,
    Net::SMTPSyntaxError,
    Net::SMTPFatalError,
    Net::SMTPUnknownError,
    Net::OpenTimeout,
    Net::ReadTimeout,
    SocketError,
    Errno::ECONNREFUSED,
  ]

  class GenericProvider
    def initialize(exception)
      @exception = exception
    end

    def message
      case @exception
      when Net::POPAuthenticationError
        net_pop_authentication_error
      when Net::IMAP::NoResponseError
        net_imap_no_response_error
      when Net::IMAP::Error
        net_imap_unhandled_error
      when Net::SMTPAuthenticationError
        net_smtp_authentication_error
      when Net::SMTPServerBusy
        net_smtp_server_busy
      when Net::SMTPSyntaxError, Net::SMTPFatalError, Net::SMTPUnknownError
        net_smtp_unhandled_error
      when SocketError, Errno::ECONNREFUSED
        socket_connection_error
      when Net::OpenTimeout, Net::ReadTimeout
        net_timeout_error
      else
        unhandled_error
      end
    end

    private

    def net_pop_authentication_error
      I18n.t(""email_settings.pop3_authentication_error"")
    end

    def net_imap_no_response_error
      # Most of IMAP's errors are lumped under the NoResponseError, including invalid
      # credentials errors, because it is raised when a ""NO"" response is
      # raised from the IMAP server https://datatracker.ietf.org/doc/html/rfc3501#section-7.1.2
      #
      # Generally, it should be fairly safe to just return the error message as is.
      if @exception.message.match(/Invalid credentials/)
        I18n.t(""email_settings.imap_authentication_error"")
      else
        I18n.t(
          ""email_settings.imap_no_response_error"",
          message: @exception.message.gsub("" (Failure)"", """"),
        )
      end
    end

    def net_imap_unhandled_error
      I18n.t(""email_settings.imap_unhandled_error"", message: @exception.message)
    end

    def net_smtp_authentication_error
      I18n.t(""email_settings.smtp_authentication_error"")
    end

    def net_smtp_server_busy
      I18n.t(""email_settings.smtp_server_busy_error"")
    end

    def net_smtp_unhandled_error
      I18n.t(""email_settings.smtp_unhandled_error"", message: @exception.message)
    end

    def socket_connection_error
      I18n.t(""email_settings.connection_error"")
    end

    def net_timeout_error
      I18n.t(""email_settings.timeout_error"")
    end

    def unhandled_error
      I18n.t(""email_settings.unhandled_error"", message: @exception.message)
    end
  end

  class GmailProvider < GenericProvider
    def net_smtp_authentication_error
      # Gmail requires use of application-specific passwords when 2FA is enabled and return
      # a special error message calling this out.
      if @exception.message.match(/Application-specific password required/)
        I18n.t(""email_settings.authentication_error_gmail_app_password"")
      else
        super
      end
    end

    def net_imap_no_response_error
      # Gmail requires use of application-specific passwords when 2FA is enabled and return
      # a special error message calling this out.
      if @exception.message.match(/Application-specific password required/)
        I18n.t(""email_settings.authentication_error_gmail_app_password"")
      else
        super
      end
    end
  end

  def self.friendly_exception_message(exception, host)
    if host.include?(""gmail.com"")
      EmailSettingsExceptionHandler::GmailProvider.new(exception).message
    else
      EmailSettingsExceptionHandler::GenericProvider.new(exception).message
    end
  end
end

```","# frozen_string_literal: true

RSpec.describe EmailSettingsExceptionHandler do
  describe ""#friendly_exception_message"" do
    it ""formats a Net::POPAuthenticationError"" do
      exception = Net::POPAuthenticationError.new(""invalid credentials"")
      expect(described_class.friendly_exception_message(exception, ""pop.test.com"")).to eq(
        I18n.t(""email_settings.pop3_authentication_error""),
      )
    end

    it ""formats a Net::IMAP::NoResponseError for invalid credentials"" do
      exception = Net::IMAP::NoResponseError.new(stub(data: stub(text: ""Invalid credentials"")))
      expect(described_class.friendly_exception_message(exception, ""imap.test.com"")).to eq(
        I18n.t(""email_settings.imap_authentication_error""),
      )
    end

    it ""formats a general Net::IMAP::NoResponseError"" do
      exception = Net::IMAP::NoResponseError.new(stub(data: stub(text: ""NO bad problem (Failure)"")))
      expect(described_class.friendly_exception_message(exception, ""imap.test.com"")).to eq(
        I18n.t(""email_settings.imap_no_response_error"", message: ""NO bad problem""),
      )
    end

    it ""formats a general Net::IMAP::NoResponseError with application-specific password Gmail error"" do
      exception =
        Net::IMAP::NoResponseError.new(
          stub(data: stub(text: ""NO Application-specific password required"")),
        )
      expect(described_class.friendly_exception_message(exception, ""imap.gmail.com"")).to eq(
        I18n.t(""email_settings.authentication_error_gmail_app_password""),
      )
    end

    it ""formats a Net::SMTPAuthenticationError"" do
      exception = Net::SMTPAuthenticationError.new(""invalid credentials"")
      expect(described_class.friendly_exception_message(exception, ""smtp.test.com"")).to eq(
        I18n.t(""email_settings.smtp_authentication_error""),
      )
    end

    it ""formats a Net::SMTPAuthenticationError with application-specific password Gmail error"" do
      exception =
        Net::SMTPAuthenticationError.new(nil, message: ""Application-specific password required"")
      expect(described_class.friendly_exception_message(exception, ""smtp.gmail.com"")).to eq(
        I18n.t(""email_settings.authentication_error_gmail_app_password""),
      )
    end

    it ""formats a Net::SMTPServerBusy"" do
      exception = Net::SMTPServerBusy.new(""call me maybe later"")
      expect(described_class.friendly_exception_message(exception, ""smtp.test.com"")).to eq(
        I18n.t(""email_settings.smtp_server_busy_error""),
      )
    end

    it ""formats a Net::SMTPSyntaxError, Net::SMTPFatalError, and Net::SMTPUnknownError"" do
      exception = Net::SMTPSyntaxError.new(nil, message: ""bad syntax"")
      expect(described_class.friendly_exception_message(exception, ""smtp.test.com"")).to eq(
        I18n.t(""email_settings.smtp_unhandled_error"", message: exception.message),
      )
      exception = Net::SMTPFatalError.new(nil, message: ""fatal"")
      expect(described_class.friendly_exception_message(exception, ""smtp.test.com"")).to eq(
        I18n.t(""email_settings.smtp_unhandled_error"", message: exception.message),
      )
      exception = Net::SMTPUnknownError.new(nil, message: ""unknown"")
      expect(described_class.friendly_exception_message(exception, ""smtp.test.com"")).to eq(
        I18n.t(""email_settings.smtp_unhandled_error"", message: exception.message),
      )
    end

    it ""formats a SocketError and Errno::ECONNREFUSED"" do
      exception = SocketError.new(""bad socket"")
      expect(described_class.friendly_exception_message(exception, ""smtp.test.com"")).to eq(
        I18n.t(""email_settings.connection_error""),
      )
      exception = Errno::ECONNREFUSED.new(""no thanks"")
      expect(described_class.friendly_exception_message(exception, ""smtp.test.com"")).to eq(
        I18n.t(""email_settings.connection_error""),
      )
    end

    it ""formats a Net::OpenTimeout and Net::ReadTimeout error"" do
      exception = Net::OpenTimeout.new(""timed out"")
      expect(described_class.friendly_exception_message(exception, ""smtp.test.com"")).to eq(
        I18n.t(""email_settings.timeout_error""),
      )
      exception = Net::ReadTimeout.new(""timed out"")
      expect(described_class.friendly_exception_message(exception, ""smtp.test.com"")).to eq(
        I18n.t(""email_settings.timeout_error""),
      )
    end

    it ""formats unhandled errors"" do
      exception = StandardError.new(""unknown"")
      expect(described_class.friendly_exception_message(exception, ""smtp.test.com"")).to eq(
        I18n.t(""email_settings.unhandled_error"", message: exception.message),
      )
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class PostOwnerChanger
  def initialize(params)
    @post_ids = params[:post_ids]
    @topic = Topic.with_deleted.find_by(id: params[:topic_id].to_i)
    @new_owner = params[:new_owner]
    @acting_user = params[:acting_user]
    @skip_revision = params[:skip_revision] || false

    %i[post_ids topic new_owner acting_user].each do |arg|
      raise ArgumentError.new(arg) if self.instance_variable_get(""@#{arg}"").blank?
    end
  end

  def change_owner!
    @post_ids.each do |post_id|
      next unless post = Post.with_deleted.find_by(id: post_id, topic_id: @topic.id)

      if post.is_first_post?
        @topic.user = @new_owner
        @topic.recover! if post.user.nil?
      end

      post.topic = @topic
      post.set_owner(@new_owner, @acting_user, @skip_revision)
      PostActionDestroyer.destroy(@new_owner, post, :like, skip_delete_check: true)

      level = post.is_first_post? ? :watching : :tracking
      TopicUser.change(
        @new_owner.id,
        @topic.id,
        notification_level: NotificationLevels.topic_levels[level],
        posted: true,
      )

      if post ==
           @topic
             .posts
             .order(""post_number DESC"")
             .where(""NOT hidden AND posts.deleted_at IS NULL"")
             .first
        @topic.last_poster = @new_owner
      end

      @topic.update_statistics

      @new_owner.user_stat.update(
        first_post_created_at: @new_owner.reload.posts.order(""created_at ASC"").first&.created_at,
      )

      Post.where(topic_id: @topic.id, reply_to_post_number: post.post_number).update_all(
        reply_to_user_id: @new_owner.id,
      )

      @topic.save!(validate: false)
    end
  end
end

```","# frozen_string_literal: true

RSpec.describe PostOwnerChanger do
  describe ""#change_owner!"" do
    fab!(:editor) { Fabricate(:admin) }
    fab!(:user_a) { Fabricate(:user) }
    let(:p1) { create_post(post_number: 1) }
    let(:topic) { p1.topic }
    let(:p2) { create_post(topic: topic, post_number: 2) }
    let(:p3) { create_post }

    it ""raises an error with a parameter missing"" do
      expect {
        PostOwnerChanger.new(
          post_ids: [p1.id],
          topic_id: topic.id,
          new_owner: nil,
          acting_user: editor,
        )
      }.to raise_error(ArgumentError, /new_owner/)
    end

    it ""calls PostRevisor"" do
      PostRevisor.any_instance.expects(:revise!)
      PostOwnerChanger.new(
        post_ids: [p1.id],
        topic_id: topic.id,
        new_owner: user_a,
        acting_user: editor,
      ).change_owner!
    end

    it ""changes the user"" do
      bumped_at = freeze_time topic.bumped_at
      now = Time.zone.now
      freeze_time(now - 1.day)

      old_user = p1.user
      PostActionCreator.like(user_a, p1)
      p1.reload
      expect(p1.topic.like_count).to eq(1)

      freeze_time(now)
      PostOwnerChanger.new(
        post_ids: [p1.id],
        topic_id: topic.id,
        new_owner: user_a,
        acting_user: editor,
      ).change_owner!
      p1.reload
      expect(p1.topic.like_count).to eq(0)
      expect(p1.topic.bumped_at).to eq_time(bumped_at)
      expect(p1.topic.last_post_user_id).to eq(user_a.id)
      expect(old_user).not_to eq(p1.user)
      expect(p1.user).to eq(user_a)
    end

    it ""changes multiple posts"" do
      PostOwnerChanger.new(
        post_ids: [p1.id, p2.id],
        topic_id: topic.id,
        new_owner: user_a,
        acting_user: editor,
      ).change_owner!
      p1.reload
      p2.reload
      expect(p1.user).not_to eq(nil)
      expect(p1.user).to eq(user_a)
      expect(p1.user).to eq(p2.user)
    end

    it ""ignores posts in other topics"" do
      PostOwnerChanger.new(
        post_ids: [p1.id, p3.id],
        topic_id: topic.id,
        new_owner: user_a,
        acting_user: editor,
      ).change_owner!
      p1.reload
      p3.reload
      expect(p1.user).to eq(user_a)

      expect(p3.topic_id).not_to eq(p1.topic_id)
      expect(p2.user).not_to eq(user_a)
    end

    it ""skips creating new post revision if skip_revision is true"" do
      PostOwnerChanger.new(
        post_ids: [p1.id, p2.id],
        topic_id: topic.id,
        new_owner: user_a,
        acting_user: editor,
        skip_revision: true,
      ).change_owner!
      p1.reload
      p2.reload
      expect(p1.revisions.size).to eq(0)
      expect(p2.revisions.size).to eq(0)
    end

    it ""changes the user even when the post does not pass validation"" do
      p1.update_attribute(:raw, ""foo"")
      PostOwnerChanger.new(
        post_ids: [p1.id],
        topic_id: topic.id,
        new_owner: user_a,
        acting_user: editor,
      ).change_owner!
      expect(p1.reload.user).to eq(user_a)
    end

    it ""changes the user even when the topic does not pass validation"" do
      topic.update_column(:title, ""short"")

      PostOwnerChanger.new(
        post_ids: [p1.id],
        topic_id: topic.id,
        new_owner: user_a,
        acting_user: editor,
      ).change_owner!
      expect(p1.reload.user).to eq(user_a)
    end

    it ""changes the owner when the post is deleted"" do
      p4 = Fabricate(:post, topic: topic, reply_to_post_number: p2.post_number)
      PostDestroyer.new(editor, p4).destroy

      PostOwnerChanger.new(
        post_ids: [p4.id],
        topic_id: topic.id,
        new_owner: user_a,
        acting_user: editor,
      ).change_owner!
      expect(p4.reload.user).to eq(user_a)
    end

    it ""sets 'posted' for TopicUser to true"" do
      PostOwnerChanger.new(
        post_ids: [p1.id],
        topic_id: topic.id,
        new_owner: user_a,
        acting_user: editor,
      ).change_owner!
      expect(TopicUser.find_by(topic_id: topic.id, user_id: user_a.id).posted).to eq(true)
    end

    context ""when setting topic notification level for the new owner"" do
      let(:p4) { create_post(post_number: 2, topic: topic) }

      it ""'watching' if the first post gets a new owner"" do
        PostOwnerChanger.new(
          post_ids: [p1.id],
          topic_id: topic.id,
          new_owner: user_a,
          acting_user: editor,
        ).change_owner!
        tu = TopicUser.find_by(user_id: user_a.id, topic_id: topic.id)
        expect(tu.notification_level).to eq(3)
      end

      it ""'tracking' if other than the first post gets a new owner"" do
        PostOwnerChanger.new(
          post_ids: [p4.id],
          topic_id: topic.id,
          new_owner: user_a,
          acting_user: editor,
        ).change_owner!
        tu = TopicUser.find_by(user_id: user_a.id, topic_id: topic.id)
        expect(tu.notification_level).to eq(2)
      end
    end

    context ""with integration tests"" do
      subject(:change_owners) do
        PostOwnerChanger.new(
          post_ids: [p1.id, p2.id],
          topic_id: topic.id,
          new_owner: user_a,
          acting_user: editor,
        ).change_owner!
      end

      let(:p1user) { p1.user }
      let(:p2user) { p2.user }

      before do
        topic.update!(user_id: p1user.id)

        p1user.user_stat.update!(
          topic_count: 1,
          post_count: 0,
          first_post_created_at: p1.created_at,
        )

        p2user.user_stat.update!(
          topic_count: 0,
          post_count: 1,
          first_post_created_at: p2.created_at,
        )

        UserAction.create!(
          action_type: UserAction::NEW_TOPIC,
          user_id: p1user.id,
          acting_user_id: p1user.id,
          target_post_id: -1,
          target_topic_id: p1.topic_id,
          created_at: p1.created_at,
        )
        UserAction.create!(
          action_type: UserAction::REPLY,
          user_id: p2user.id,
          acting_user_id: p2user.id,
          target_post_id: p2.id,
          target_topic_id: p2.topic_id,
          created_at: p2.created_at,
        )

        UserActionManager.enable
      end

      it ""updates users' topic and post counts"" do
        PostActionCreator.like(p2user, p1)
        expect(p1user.user_stat.reload.likes_received).to eq(1)

        change_owners

        p1user.reload
        p2user.reload
        user_a.reload
        expect(p1user.topic_count).to eq(0)
        expect(p1user.post_count).to eq(0)
        expect(p2user.topic_count).to eq(0)
        expect(p2user.post_count).to eq(0)
        expect(user_a.topic_count).to eq(1)
        expect(user_a.post_count).to eq(1)

        p1_user_stat = p1user.user_stat

        expect(p1_user_stat.first_post_created_at).to eq(nil)
        expect(p1_user_stat.likes_received).to eq(0)

        p2_user_stat = p2user.user_stat

        expect(p2_user_stat.first_post_created_at).to eq(nil)

        user_a_stat = user_a.user_stat

        expect(user_a_stat.first_post_created_at).to be_present
        expect(user_a_stat.likes_received).to eq(1)
      end

      it ""handles whispers"" do
        whisper =
          PostCreator.new(
            editor,
            topic_id: p1.topic_id,
            reply_to_post_number: 1,
            post_type: Post.types[:whisper],
            raw: ""this is a whispered reply"",
          ).create

        user_stat = editor.user_stat

        expect {
          PostOwnerChanger.new(
            post_ids: [whisper.id],
            topic_id: topic.id,
            new_owner: Fabricate(:admin),
            acting_user: editor,
          ).change_owner!
        }.to_not change { user_stat.reload.post_count }
      end

      context ""with private message topic"" do
        let(:pm) { create_post(archetype: ""private_message"", target_usernames: [p2user.username]) }
        let(:pm_poster) { pm.user }

        it ""should update users' counts"" do
          PostActionCreator.like(p2user, pm)

          expect {
            PostOwnerChanger.new(
              post_ids: [pm.id],
              topic_id: pm.topic_id,
              new_owner: user_a,
              acting_user: editor,
            ).change_owner!
          }.to_not change { pm_poster.user_stat.post_count }

          expect(pm_poster.user_stat.likes_received).to eq(0)

          user_a_stat = user_a.user_stat
          expect(user_a_stat.first_post_created_at).to be_present
          expect(user_a_stat.likes_received).to eq(0)
          expect(user_a_stat.post_count).to eq(0)
        end
      end

      it ""updates UserAction records"" do
        g = Guardian.new(editor)
        expect(UserAction.stats(user_a.id, g)).to eq([])

        change_owners

        expect(UserAction.stats(p1user.id, g)).to eq([])
        expect(UserAction.stats(p2user.id, g)).to eq([])
        stats = UserAction.stats(user_a.id, g)
        expect(stats.size).to eq(2)
        expect(stats[0].action_type).to eq(UserAction::NEW_TOPIC)
        expect(stats[0].count).to eq(1)
        expect(stats[1].action_type).to eq(UserAction::REPLY)
        expect(stats[1].count).to eq(1)
      end

      it ""updates reply_to_user_id"" do
        p4 =
          Fabricate(
            :post,
            topic: topic,
            reply_to_post_number: p1.post_number,
            reply_to_user_id: p1.user_id,
          )
        p5 =
          Fabricate(
            :post,
            topic: topic,
            reply_to_post_number: p2.post_number,
            reply_to_user_id: p2.user_id,
          )

        PostOwnerChanger.new(
          post_ids: [p1.id],
          topic_id: topic.id,
          new_owner: user_a,
          acting_user: editor,
        ).change_owner!
        p4.reload
        p5.reload

        expect(p4.reply_to_user_id).to eq(user_a.id)
        expect(p5.reply_to_user_id).to eq(p2.user_id)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class TopicTimestampChanger
  class InvalidTimestampError < StandardError
  end

  def initialize(timestamp:, topic: nil, topic_id: nil)
    @topic = topic || Topic.with_deleted.find(topic_id)
    @posts = @topic.posts
    @current_timestamp = Time.zone.now
    @timestamp = Time.zone.at(timestamp)

    raise InvalidTimestampError if @timestamp.to_f > @current_timestamp.to_f

    @time_difference = calculate_time_difference
  end

  def change!
    ActiveRecord::Base.transaction do
      last_posted_at = @timestamp

      @posts.each do |post|
        if post.is_first_post?
          update_post(post, @timestamp)
        else
          new_created_at = Time.at(post.created_at.to_f + @time_difference)
          new_created_at = @current_timestamp if new_created_at > @current_timestamp
          last_posted_at = new_created_at if new_created_at > last_posted_at
          update_post(post, new_created_at)
        end
      end

      @topic.reset_bumped_at
      update_topic(last_posted_at)

      yield(@topic) if block_given?
    end

    # Burst the cache for stats
    [AdminDashboardData, About].each { |klass| Discourse.redis.del klass.stats_cache_key }
  end

  private

  def calculate_time_difference
    @timestamp - @topic.created_at
  end

  def update_topic(last_posted_at)
    @topic.update(created_at: @timestamp, updated_at: @timestamp, last_posted_at: last_posted_at)
  end

  def update_post(post, timestamp)
    post.update(created_at: timestamp, updated_at: timestamp)
  end
end

```","# frozen_string_literal: true

RSpec.describe TopicTimestampChanger do
  describe ""#change!"" do
    let(:old_timestamp) { Time.zone.now }
    let(:topic) { Fabricate(:topic, created_at: old_timestamp) }
    let!(:p1) { Fabricate(:post, topic: topic, created_at: old_timestamp) }
    let!(:p2) { Fabricate(:post, topic: topic, created_at: old_timestamp + 1.day) }

    context ""when new timestamp is in the future"" do
      let(:new_timestamp) { old_timestamp + 2.day }

      it ""should raise the right error"" do
        expect {
          TopicTimestampChanger.new(topic: topic, timestamp: new_timestamp.to_f).change!
        }.to raise_error(TopicTimestampChanger::InvalidTimestampError)
      end
    end

    context ""when new timestamp is in the past"" do
      let(:new_timestamp) { old_timestamp - 2.day }

      it ""changes the timestamp of the topic and opening post"" do
        freeze_time
        TopicTimestampChanger.new(topic: topic, timestamp: new_timestamp.to_f).change!

        topic.reload
        p1.reload
        p2.reload
        last_post_created_at = p2.created_at

        expect(topic.created_at).to eq_time(new_timestamp)
        expect(topic.updated_at).to eq_time(new_timestamp)
        expect(topic.bumped_at).to eq_time(last_post_created_at)
        expect(topic.last_posted_at).to eq_time(last_post_created_at)

        expect(p1.created_at).to eq_time(new_timestamp)
        expect(p1.updated_at).to eq_time(new_timestamp)

        expect(p2.created_at).to eq_time(new_timestamp + 1.day)
        expect(p2.updated_at).to eq_time(new_timestamp + 1.day)
      end

      context ""when posts have timestamps in the future"" do
        it ""should set the new timestamp as the default timestamp"" do
          new_timestamp = freeze_time

          p3 = Fabricate(:post, topic: topic, created_at: new_timestamp + 3.days)
          TopicTimestampChanger.new(topic: topic, timestamp: new_timestamp.to_f).change!

          p3.reload

          expect(p3.created_at).to eq_time(new_timestamp)
          expect(p3.updated_at).to eq_time(new_timestamp)
        end
      end
    end

    it ""deletes the stats cache"" do
      Discourse.redis.set AdminDashboardData.stats_cache_key, ""X""
      Discourse.redis.set About.stats_cache_key, ""X""

      TopicTimestampChanger.new(topic: topic, timestamp: Time.zone.now.to_f).change!

      expect(Discourse.redis.get(AdminDashboardData.stats_cache_key)).to eq(nil)
      expect(Discourse.redis.get(About.stats_cache_key)).to eq(nil)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class TrustLevelGranter
  def initialize(trust_level, user)
    @trust_level, @user = trust_level, user
  end

  def self.grant(trust_level, user)
    TrustLevelGranter.new(trust_level, user).grant
  end

  def grant
    if @user.trust_level < @trust_level
      @user.change_trust_level!(@trust_level)
      @user.save!
    end
  end
end

```","# frozen_string_literal: true

RSpec.describe TrustLevelGranter do
  describe ""grant"" do
    it ""grants trust level"" do
      user = Fabricate(:user, email: ""foo@bar.com"", trust_level: 0)
      TrustLevelGranter.grant(3, user)

      user.reload
      expect(user.trust_level).to eq(3)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class ThemeSettingsMigrationsRunner
  Migration = Struct.new(:version, :name, :original_name, :code, :theme_field_id)

  MIGRATION_ENTRY_POINT_JS = <<~JS
    const migrate = require(""discourse/theme/migration"")?.default;
    function main(settingsObj) {
      if (!migrate) {
        throw new Error(""no_exported_migration_function"");
      }
      if (typeof migrate !== ""function"") {
        throw new Error(""default_export_is_not_a_function"");
      }
      const map = new Map(Object.entries(settingsObj));
      const updatedMap = migrate(map);
      if (!updatedMap) {
        throw new Error(""migration_function_no_returned_value"");
      }
      if (!(updatedMap instanceof Map)) {
        throw new Error(""migration_function_wrong_return_type"");
      }
      return Object.fromEntries(updatedMap.entries());
    }
  JS

  private_constant :Migration, :MIGRATION_ENTRY_POINT_JS

  def self.loader_js_lib_content
    @loader_js_lib_content ||=
      File.read(
        File.join(
          Rails.root,
          ""app/assets/javascripts/node_modules/loader.js/dist/loader/loader.js"",
        ),
      )
  end

  def initialize(theme, limit: 100, timeout: 100, memory: 2.megabytes)
    @theme = theme
    @limit = limit
    @timeout = timeout
    @memory = memory
  end

  def run
    fields = lookup_pending_migrations_fields

    count = fields.count
    return [] if count == 0

    raise_error(""themes.import_error.migrations.too_many_pending_migrations"") if count > @limit

    migrations = convert_fields_to_migrations(fields)
    migrations.sort_by!(&:version)

    current_migration_version =
      @theme.theme_settings_migrations.order(version: :desc).pick(:version)
    current_migration_version ||= -Float::INFINITY

    current_settings = lookup_overriden_settings

    migrations.map do |migration|
      if migration.version <= current_migration_version
        raise_error(
          ""themes.import_error.migrations.out_of_sequence"",
          name: migration.original_name,
          current: current_migration_version,
        )
      end

      migrated_settings = execute(migration, current_settings)
      results = {
        version: migration.version,
        name: migration.name,
        original_name: migration.original_name,
        theme_field_id: migration.theme_field_id,
        settings_before: current_settings,
        settings_after: migrated_settings,
      }
      current_settings = migrated_settings
      current_migration_version = migration.version
      results
    rescue DiscourseJsProcessor::TranspileError => error
      raise_error(
        ""themes.import_error.migrations.syntax_error"",
        name: migration.original_name,
        error: error.message,
      )
    rescue MiniRacer::V8OutOfMemoryError
      raise_error(
        ""themes.import_error.migrations.exceeded_memory_limit"",
        name: migration.original_name,
      )
    rescue MiniRacer::ScriptTerminatedError
      raise_error(""themes.import_error.migrations.timed_out"", name: migration.original_name)
    rescue MiniRacer::RuntimeError => error
      message = error.message
      if message.include?(""no_exported_migration_function"")
        raise_error(
          ""themes.import_error.migrations.no_exported_function"",
          name: migration.original_name,
        )
      elsif message.include?(""default_export_is_not_a_function"")
        raise_error(
          ""themes.import_error.migrations.default_export_not_a_function"",
          name: migration.original_name,
        )
      elsif message.include?(""migration_function_no_returned_value"")
        raise_error(
          ""themes.import_error.migrations.no_returned_value"",
          name: migration.original_name,
        )
      elsif message.include?(""migration_function_wrong_return_type"")
        raise_error(
          ""themes.import_error.migrations.wrong_return_type"",
          name: migration.original_name,
        )
      else
        raise_error(
          ""themes.import_error.migrations.runtime_error"",
          name: migration.original_name,
          error: message,
        )
      end
    end
  end

  private

  def lookup_pending_migrations_fields
    @theme
      .migration_fields
      .left_joins(:theme_settings_migration)
      .where(theme_settings_migration: { id: nil })
  end

  def convert_fields_to_migrations(fields)
    fields.map do |field|
      match_data = /\A(?<version>\d{4})-(?<name>.+)/.match(field.name)

      if !match_data
        raise_error(""themes.import_error.migrations.invalid_filename"", filename: field.name)
      end

      version = match_data[:version].to_i
      name = match_data[:name]
      original_name = field.name

      Migration.new(
        version: version,
        name: name,
        original_name: original_name,
        code: field.value,
        theme_field_id: field.id,
      )
    end
  end

  def lookup_overriden_settings
    hash = {}
    @theme.theme_settings.each { |row| hash[row.name] = ThemeSettingsManager.cast_row_value(row) }
    hash
  end

  def execute(migration, settings)
    context = MiniRacer::Context.new(timeout: @timeout, max_memory: @memory)

    context.eval(self.class.loader_js_lib_content, filename: ""loader.js"")

    context.eval(
      DiscourseJsProcessor.transpile(migration.code, """", ""discourse/theme/migration""),
      filename: ""theme-#{@theme.id}-migration.js"",
    )

    context.eval(MIGRATION_ENTRY_POINT_JS, filename: ""migration-entrypoint.js"")
    context.call(""main"", settings)
  ensure
    context&.dispose
  end

  def raise_error(message_key, **i18n_args)
    raise Theme::SettingsMigrationError.new(I18n.t(message_key, **i18n_args))
  end
end

```","# frozen_string_literal: true

describe ThemeSettingsMigrationsRunner do
  fab!(:theme)
  fab!(:migration_field) { Fabricate(:migration_theme_field, version: 1, theme: theme) }
  fab!(:settings_field) { Fabricate(:settings_theme_field, theme: theme, value: <<~YAML) }
      integer_setting: 1
      boolean_setting: true
      string_setting: """"
    YAML

  describe ""#run"" do
    it ""passes values of overridden settings only to migrations"" do
      theme.update_setting(:integer_setting, 1)
      theme.update_setting(:string_setting, ""osama"")
      theme.save!

      migration_field.update!(value: <<~JS)
        export default function migrate(settings) {
          if (settings.get(""integer_setting"") !== 1) {
            throw new Error(`expected integer_setting to equal 1, but it's actually ${settings.get(""integer_setting"")}`);
          }
          if (settings.get(""string_setting"") !== ""osama"") {
            throw new Error(`expected string_setting to equal ""osama"", but it's actually ""${settings.get(""string_setting"")}""`);
          }
          if (settings.size !== 2) {
            throw new Error(`expected the settings map to have only 2 keys, but instead got ${settings.size} keys`);
          }
          return settings;
        }
      JS
      results = described_class.new(theme).run
      expect(results.first[:theme_field_id]).to eq(migration_field.id)
      expect(results.first[:settings_before]).to eq(
        { ""integer_setting"" => 1, ""string_setting"" => ""osama"" },
      )
    end

    it ""passes the output of the previous migration as input to the next one"" do
      theme.update_setting(:integer_setting, 1)

      migration_field.update!(value: <<~JS)
        export default function migrate(settings) {
          settings.set(""integer_setting"", 111);
          return settings;
        }
      JS

      another_migration_field =
        Fabricate(:migration_theme_field, theme: theme, version: 2, value: <<~JS)
        export default function migrate(settings) {
          if (settings.get(""integer_setting"") !== 111) {
            throw new Error(`expected integer_setting to equal 111, but it's actually ${settings.get(""integer_setting"")}`);
          }
          settings.set(""integer_setting"", 222);
          return settings;
        }
      JS

      results = described_class.new(theme).run

      expect(results.size).to eq(2)

      expect(results[0][:theme_field_id]).to eq(migration_field.id)
      expect(results[1][:theme_field_id]).to eq(another_migration_field.id)

      expect(results[0][:settings_before]).to eq({})
      expect(results[0][:settings_after]).to eq({ ""integer_setting"" => 111 })

      expect(results[1][:settings_before]).to eq({ ""integer_setting"" => 111 })
      expect(results[1][:settings_after]).to eq({ ""integer_setting"" => 222 })
    end

    it ""doesn't run migrations that have already been ran"" do
      Fabricate(:theme_settings_migration, theme: theme, theme_field: migration_field)

      pending_field = Fabricate(:migration_theme_field, theme: theme, version: 23)

      results = described_class.new(theme).run

      expect(results.size).to eq(1)

      expect(results.first[:version]).to eq(23)
      expect(results.first[:theme_field_id]).to eq(pending_field.id)
    end

    it ""doesn't error when no migrations have been ran yet"" do
      results = described_class.new(theme).run

      expect(results.size).to eq(1)
      expect(results.first[:version]).to eq(1)
      expect(results.first[:theme_field_id]).to eq(migration_field.id)
    end

    it ""doesn't error when there are no pending migrations"" do
      Fabricate(:theme_settings_migration, theme: theme, theme_field: migration_field)

      results = described_class.new(theme).run

      expect(results.size).to eq(0)
    end

    it ""raises an error when there are too many pending migrations"" do
      Fabricate(:migration_theme_field, theme: theme, version: 2)

      expect do described_class.new(theme, limit: 1).run end.to raise_error(
        Theme::SettingsMigrationError,
        I18n.t(""themes.import_error.migrations.too_many_pending_migrations""),
      )
    end

    it ""raises an error if a migration field has a badly formatted name"" do
      migration_field.update_attribute(:name, ""020-some-name"")

      expect do described_class.new(theme).run end.to raise_error(
        Theme::SettingsMigrationError,
        I18n.t(""themes.import_error.migrations.invalid_filename"", filename: ""020-some-name""),
      )

      migration_field.update_attribute(:name, ""0020some-name"")

      expect do described_class.new(theme).run end.to raise_error(
        Theme::SettingsMigrationError,
        I18n.t(""themes.import_error.migrations.invalid_filename"", filename: ""0020some-name""),
      )

      migration_field.update_attribute(:name, ""0020"")

      expect do described_class.new(theme).run end.to raise_error(
        Theme::SettingsMigrationError,
        I18n.t(""themes.import_error.migrations.invalid_filename"", filename: ""0020""),
      )
    end

    it ""raises an error if a pending migration has version lower than the last ran migration"" do
      migration_field.update!(name: ""0020-some-name"")
      Fabricate(:theme_settings_migration, theme: theme, theme_field: migration_field, version: 20)

      Fabricate(:migration_theme_field, theme: theme, version: 19, name: ""0019-failing-migration"")

      expect do described_class.new(theme).run end.to raise_error(
        Theme::SettingsMigrationError,
        I18n.t(
          ""themes.import_error.migrations.out_of_sequence"",
          name: ""0019-failing-migration"",
          current: 20,
        ),
      )
    end

    it ""detects bad syntax in migrations and raises an error"" do
      migration_field.update!(value: <<~JS)
        export default function migrate() {
      JS
      expect do described_class.new(theme).run end.to raise_error(
        Theme::SettingsMigrationError,
        I18n.t(
          ""themes.import_error.migrations.syntax_error"",
          name: ""0001-some-name"",
          error:
            'SyntaxError: ""/discourse/theme/migration: Unexpected token (2:0)\n\n  1 | export default function migrate() {\n> 2 |\n    | ^""',
        ),
      )
    end

    it ""imposes memory limit on migrations and raises an error if they exceed the limit"" do
      migration_field.update!(value: <<~JS)
        export default function migrate(settings) {
          let a = new Array(10000);
          while(true) {
            a = a.concat(new Array(10000));
          }
          return settings;
        }
      JS

      expect do described_class.new(theme, memory: 10.kilobytes).run end.to raise_error(
        Theme::SettingsMigrationError,
        I18n.t(""themes.import_error.migrations.exceeded_memory_limit"", name: ""0001-some-name""),
      )
    end

    it ""imposes time limit on migrations and raises an error if they exceed the limit"" do
      migration_field.update!(value: <<~JS)
        export default function migrate(settings) {
          let a = 1;
          while(true) {
            a += 1;
          }
          return settings;
        }
      JS

      expect do described_class.new(theme, timeout: 10).run end.to raise_error(
        Theme::SettingsMigrationError,
        I18n.t(""themes.import_error.migrations.timed_out"", name: ""0001-some-name""),
      )
    end

    it ""raises a clear error message when the migration file doesn't export anything"" do
      migration_field.update!(value: <<~JS)
        function migrate(settings) {
          return settings;
        }
      JS

      expect do described_class.new(theme).run end.to raise_error(
        Theme::SettingsMigrationError,
        I18n.t(""themes.import_error.migrations.no_exported_function"", name: ""0001-some-name""),
      )
    end

    it ""raises a clear error message when the migration file exports the default as something that's not a function"" do
      migration_field.update!(value: <<~JS)
        export function migrate(settings) {
          return settings;
        }

        const AA = 1;
        export default AA;
      JS

      expect do described_class.new(theme).run end.to raise_error(
        Theme::SettingsMigrationError,
        I18n.t(
          ""themes.import_error.migrations.default_export_not_a_function"",
          name: ""0001-some-name"",
        ),
      )
    end

    it ""raises a clear error message when the migration function doesn't return anything"" do
      migration_field.update!(value: <<~JS)
        export default function migrate(settings) {}
      JS

      expect do described_class.new(theme).run end.to raise_error(
        Theme::SettingsMigrationError,
        I18n.t(""themes.import_error.migrations.no_returned_value"", name: ""0001-some-name""),
      )
    end

    it ""raises a clear error message when the migration function doesn't return a Map"" do
      migration_field.update!(value: <<~JS)
        export default function migrate(settings) {
          return {};
        }
      JS

      expect do described_class.new(theme).run end.to raise_error(
        Theme::SettingsMigrationError,
        I18n.t(""themes.import_error.migrations.wrong_return_type"", name: ""0001-some-name""),
      )
    end

    it ""surfaces runtime errors that occur within the migration"" do
      migration_field.update!(value: <<~JS)
        export default function migrate(settings) {
          null.toString();
          return settings;
        }
      JS

      expect do described_class.new(theme).run end.to raise_error(
        Theme::SettingsMigrationError,
        I18n.t(
          ""themes.import_error.migrations.runtime_error"",
          name: ""0001-some-name"",
          error: ""TypeError: Cannot read properties of null (reading 'toString')"",
        ),
      )
    end

    it ""returns a list of objects that each has data representing the migration and the results"" do
      results = described_class.new(theme).run

      expect(results[0][:version]).to eq(1)
      expect(results[0][:name]).to eq(""some-name"")
      expect(results[0][:original_name]).to eq(""0001-some-name"")
      expect(results[0][:theme_field_id]).to eq(migration_field.id)
      expect(results[0][:settings_before]).to eq({})
      expect(results[0][:settings_after]).to eq({})
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Responsible for destroying a User record
class UserDestroyer
  class PostsExistError < RuntimeError
  end

  def initialize(actor)
    @actor = actor
    raise Discourse::InvalidParameters.new(""acting user is nil"") unless @actor && @actor.is_a?(User)
    @guardian = Guardian.new(actor)
  end

  # Returns false if the user failed to be deleted.
  # Returns a frozen instance of the User if the delete succeeded.
  def destroy(user, opts = {})
    raise Discourse::InvalidParameters.new(""user is nil"") unless user && user.is_a?(User)
    raise PostsExistError if !opts[:delete_posts] && user.posts.joins(:topic).count != 0
    @guardian.ensure_can_delete_user!(user)

    # default to using a transaction
    opts[:transaction] = true if opts[:transaction] != false

    prepare_for_destroy(user) if opts[:prepare_for_destroy] == true

    result = nil

    optional_transaction(open_transaction: opts[:transaction]) do
      UserSecurityKey.where(user_id: user.id).delete_all
      Bookmark.where(user_id: user.id).delete_all
      Draft.where(user_id: user.id).delete_all
      Reviewable.where(created_by_id: user.id).delete_all

      category_topic_ids = Category.where(""topic_id IS NOT NULL"").pluck(:topic_id)

      if opts[:delete_posts]
        DiscoursePluginRegistry.user_destroyer_on_content_deletion_callbacks.each do |cb|
          cb.call(user, @guardian, opts)
        end

        agree_with_flags(user) if opts[:delete_as_spammer]
        block_external_urls(user) if opts[:block_urls]
        delete_posts(user, category_topic_ids, opts)
      end

      user.post_actions.find_each { |post_action| post_action.remove_act!(Discourse.system_user) }

      # Add info about the user to staff action logs
      UserHistory.staff_action_records(
        Discourse.system_user,
        acting_user: user.username,
      ).update_all(
        [""details = CONCAT(details, ?)"", ""\nuser_id: #{user.id}\nusername: #{user.username}""],
      )

      # keep track of emails used
      user_emails = user.user_emails.pluck(:email)

      if result = user.destroy
        if opts[:block_email]
          user_emails.each do |email|
            ScreenedEmail.block(email, ip_address: result.ip_address)&.record_match!
          end
        end

        if opts[:block_ip] && result.ip_address
          ScreenedIpAddress.watch(result.ip_address)&.record_match!
          if result.registration_ip_address && result.ip_address != result.registration_ip_address
            ScreenedIpAddress.watch(result.registration_ip_address)&.record_match!
          end
        end

        Post.unscoped.where(user_id: result.id).update_all(user_id: nil)

        # If this user created categories, fix those up:
        Category
          .where(user_id: result.id)
          .each do |c|
            c.user_id = Discourse::SYSTEM_USER_ID
            c.save!
            if topic = Topic.unscoped.find_by(id: c.topic_id)
              topic.recover!
              topic.user_id = Discourse::SYSTEM_USER_ID
              topic.save!
            end
          end

        Invite
          .where(email: user_emails)
          .each do |invite|
            # invited_users will be removed by dependent destroy association when user is destroyed
            invite.invited_groups.destroy_all
            invite.topic_invites.destroy_all
            invite.destroy
          end

        unless opts[:quiet]
          if @actor == user
            deleted_by = Discourse.system_user
            opts[:context] = I18n.t(""staff_action_logs.user_delete_self"", url: opts[:context])
          else
            deleted_by = @actor
          end
          StaffActionLogger.new(deleted_by).log_user_deletion(user, opts.slice(:context))
          if opts.slice(:context).blank?
            Rails.logger.warn(""User destroyed without context from: #{caller_locations(14, 1)[0]}"")
          end
        end
        MessageBus.publish ""/logout/#{result.id}"", result.id, user_ids: [result.id]
      end
    end

    # After the user is deleted, remove the reviewable
    if reviewable = ReviewableUser.pending.find_by(target: user)
      reviewable.perform(@actor, :delete_user)
    end

    result
  end

  protected

  def block_external_urls(user)
    TopicLink
      .where(user: user, internal: false)
      .find_each do |link|
        next if Oneboxer.engine(link.url) != Onebox::Engine::AllowlistedGenericOnebox
        ScreenedUrl.watch(link.url, link.domain, ip_address: user.ip_address)&.record_match!
      end
  end

  def agree_with_flags(user)
    ReviewableFlaggedPost
      .where(target_created_by: user)
      .find_each do |reviewable|
        if reviewable.actions_for(@guardian).has?(:agree_and_keep)
          reviewable.perform(@actor, :agree_and_keep)
        end
      end

    ReviewablePost
      .where(target_created_by: user)
      .find_each do |reviewable|
        if reviewable.actions_for(@guardian).has?(:reject_and_delete)
          reviewable.perform(@actor, :reject_and_delete)
        end
      end
  end

  def delete_posts(user, category_topic_ids, opts)
    user.posts.find_each do |post|
      if post.is_first_post? && category_topic_ids.include?(post.topic_id)
        post.update!(user: Discourse.system_user)
      else
        PostDestroyer.new(@actor.staff? ? @actor : Discourse.system_user, post).destroy
      end

      if post.topic && post.is_first_post?
        Topic.unscoped.where(id: post.topic_id).update_all(user_id: nil)
      end
    end
  end

  def prepare_for_destroy(user)
    PostAction.where(user_id: user.id).delete_all
    UserAction.where(
      ""user_id = :user_id OR target_user_id = :user_id OR acting_user_id = :user_id"",
      user_id: user.id,
    ).delete_all
    PostTiming.where(user_id: user.id).delete_all
    TopicViewItem.where(user_id: user.id).delete_all
    TopicUser.where(user_id: user.id).delete_all
    TopicAllowedUser.where(user_id: user.id).delete_all
    Notification.where(user_id: user.id).delete_all
  end

  def optional_transaction(open_transaction: true)
    if open_transaction
      User.transaction { yield }
    else
      yield
    end
  end
end

```","# frozen_string_literal: true

RSpec.describe UserDestroyer do
  fab!(:user) { Fabricate(:user_with_secondary_email) }
  fab!(:admin)

  describe "".new"" do
    it ""raises an error when user is nil"" do
      expect { UserDestroyer.new(nil) }.to raise_error(Discourse::InvalidParameters)
    end

    it ""raises an error when user is not a User"" do
      expect { UserDestroyer.new(5) }.to raise_error(Discourse::InvalidParameters)
    end
  end

  describe ""#destroy"" do
    it ""raises an error when user is nil"" do
      expect { UserDestroyer.new(admin).destroy(nil) }.to raise_error(Discourse::InvalidParameters)
    end

    it ""raises an error when user is not a User"" do
      expect { UserDestroyer.new(admin).destroy(""nothing"") }.to raise_error(
        Discourse::InvalidParameters,
      )
    end

    it ""raises an error when regular user tries to delete another user"" do
      expect { UserDestroyer.new(user).destroy(Fabricate(:user)) }.to raise_error(
        Discourse::InvalidAccess,
      )
    end

    shared_examples ""successfully destroy a user"" do
      it ""should delete the user"" do
        expect { destroy }.to change { User.count }.by(-1)
      end

      it ""should return the deleted user record"" do
        return_value = destroy
        expect(return_value).to eq(user)
        expect(return_value).to be_destroyed
      end

      it ""should log the action"" do
        StaffActionLogger.any_instance.expects(:log_user_deletion).with(user, anything).once
        destroy
      end

      it ""should not log the action if quiet is true"" do
        expect {
          UserDestroyer.new(admin).destroy(user, destroy_opts.merge(quiet: true))
        }.to_not change { UserHistory.where(action: UserHistory.actions[:delete_user]).count }
      end

      it ""triggers a extensibility event"" do
        event = DiscourseEvent.track_events { destroy }.last

        expect(event[:event_name]).to eq(:user_destroyed)
        expect(event[:params].first).to eq(user)
      end
    end

    shared_examples ""email block list"" do
      it ""doesn't add email to block list by default"" do
        ScreenedEmail.expects(:block).never
        destroy
      end

      it ""adds emails to block list if block_email is true"" do
        expect {
          UserDestroyer.new(admin).destroy(user, destroy_opts.merge(block_email: true))
        }.to change { ScreenedEmail.count }.by(2)
      end
    end

    context ""when user deletes self"" do
      subject(:destroy) { UserDestroyer.new(user).destroy(user, destroy_opts) }

      let(:destroy_opts) { { delete_posts: true, context: ""/u/username/preferences/account"" } }

      include_examples ""successfully destroy a user""

      it ""should log proper context"" do
        destroy
        expect(UserHistory.where(action: UserHistory.actions[:delete_user]).last.context).to eq(
          I18n.t(""staff_action_logs.user_delete_self"", url: ""/u/username/preferences/account""),
        )
      end
    end

    context ""when context is missing"" do
      it ""logs warning message if context is missing"" do
        logger = track_log_messages { UserDestroyer.new(admin).destroy(user) }
        expect(logger.warnings).to include(/User destroyed without context from:/)
      end
    end

    context ""with a reviewable post"" do
      let!(:reviewable) { Fabricate(:reviewable, created_by: user) }

      it ""removes the queued post"" do
        UserDestroyer.new(admin).destroy(user)
        expect(Reviewable.where(created_by_id: user.id).count).to eq(0)
      end
    end

    context ""with a reviewable user"" do
      let(:reviewable) { Fabricate(:reviewable, created_by: admin) }

      it ""sets the reviewable user as rejected"" do
        UserDestroyer.new(admin).destroy(reviewable.target)

        expect(reviewable.reload).to be_rejected
      end
    end

    context ""with a directory item record"" do
      it ""removes the directory item"" do
        DirectoryItem.create!(
          user: user,
          period_type: 1,
          likes_received: 0,
          likes_given: 0,
          topics_entered: 0,
          topic_count: 0,
          post_count: 0,
        )
        UserDestroyer.new(admin).destroy(user)
        expect(DirectoryItem.where(user_id: user.id).count).to eq(0)
      end
    end

    context ""with a draft"" do
      let!(:draft) { Draft.set(user, ""test"", 0, ""test"") }

      it ""removed the draft"" do
        UserDestroyer.new(admin).destroy(user)
        expect(Draft.where(user_id: user.id).count).to eq(0)
      end
    end

    context ""when user has posts"" do
      let!(:topic_starter) { Fabricate(:user) }
      let!(:topic) { Fabricate(:topic, user: topic_starter) }
      let!(:first_post) { Fabricate(:post, user: topic_starter, topic: topic) }
      let!(:post) { Fabricate(:post, user: user, topic: topic) }

      context ""when delete_posts is false"" do
        subject(:destroy) { UserDestroyer.new(admin).destroy(user) }

        before do
          user.stubs(:post_count).returns(1)
          user.stubs(:first_post_created_at).returns(Time.zone.now)
        end

        it ""should raise the right error"" do
          StaffActionLogger.any_instance.expects(:log_user_deletion).never
          expect { destroy }.to raise_error(UserDestroyer::PostsExistError)
          expect(user.reload.id).to be_present
        end
      end

      context ""when delete_posts is true"" do
        let(:destroy_opts) { { delete_posts: true } }

        context ""when staff deletes user"" do
          subject(:destroy) { UserDestroyer.new(admin).destroy(user, destroy_opts) }

          include_examples ""successfully destroy a user""
          include_examples ""email block list""

          it ""deletes the posts"" do
            destroy
            expect(post.reload.deleted_at).not_to eq(nil)
            expect(post.user_id).to eq(nil)
          end

          it ""does not delete topics started by others in which the user has replies"" do
            destroy
            expect(topic.reload.deleted_at).to eq(nil)
            expect(topic.user_id).not_to eq(nil)
          end

          it ""deletes topics started by the deleted user"" do
            spammer_topic = Fabricate(:topic, user: user)
            Fabricate(:post, user: user, topic: spammer_topic)
            destroy
            expect(spammer_topic.reload.deleted_at).not_to eq(nil)
            expect(spammer_topic.user_id).to eq(nil)
          end

          context ""when delete_as_spammer is true"" do
            before { destroy_opts[:delete_as_spammer] = true }

            it ""approves reviewable flags"" do
              spammer_post = Fabricate(:post, user: user)
              reviewable = PostActionCreator.inappropriate(admin, spammer_post).reviewable
              expect(reviewable).to be_pending

              destroy

              reviewable.reload
              expect(reviewable).to be_approved
            end

            it ""rejects pending posts"" do
              post = Fabricate(:post, user: user)
              reviewable =
                Fabricate(
                  :reviewable,
                  type: ""ReviewablePost"",
                  target_type: ""Post"",
                  target_id: post.id,
                  created_by: Discourse.system_user,
                  target_created_by: user,
                )

              expect(reviewable).to be_pending

              destroy

              reviewable.reload
              expect(reviewable).to be_rejected
            end
          end
        end

        context ""when users deletes self"" do
          subject(:destroy) { UserDestroyer.new(user).destroy(user, destroy_opts) }

          include_examples ""successfully destroy a user""
          include_examples ""email block list""

          it ""deletes the posts"" do
            destroy
            expect(post.reload.deleted_at).not_to eq(nil)
            expect(post.user_id).to eq(nil)
          end
        end
      end
    end

    context ""when user was invited"" do
      it ""should delete the invite of user"" do
        invite = Fabricate(:invite)
        topic_invite = invite.topic_invites.create!(topic: Fabricate(:topic))
        invited_group = invite.invited_groups.create!(group: Fabricate(:group))
        user = Fabricate(:user)
        user.user_emails.create!(email: invite.email)

        UserDestroyer.new(admin).destroy(user)

        expect(Invite.exists?(invite.id)).to eq(false)
        expect(InvitedGroup.exists?(invited_group.id)).to eq(false)
        expect(TopicInvite.exists?(topic_invite.id)).to eq(false)
      end
    end

    context ""when user created category"" do
      let!(:topic) { Fabricate(:topic, user: user) }
      let!(:first_post) { Fabricate(:post, user: user, topic: topic) }
      let!(:second_post) { Fabricate(:post, user: user, topic: topic) }
      let!(:category) { Fabricate(:category, user: user, topic_id: topic.id) }

      it ""changes author of first category post to system user and still deletes second post"" do
        UserDestroyer.new(admin).destroy(user, delete_posts: true)

        expect(first_post.reload.deleted_at).to eq(nil)
        expect(first_post.user_id).to eq(Discourse.system_user.id)

        expect(second_post.reload.deleted_at).not_to eq(nil)
        expect(second_post.user_id).to eq(nil)
      end
    end

    context ""when user has no posts, but user_stats table has post_count > 0"" do
      subject(:destroy) { UserDestroyer.new(user).destroy(user, delete_posts: false) }

      let(:destroy_opts) { {} }

      before do
        # out of sync user_stat data shouldn't break UserDestroyer
        user.user_stat.update_attribute(:post_count, 1)
      end

      include_examples ""successfully destroy a user""
    end

    context ""when user has deleted posts"" do
      let!(:deleted_post) { Fabricate(:post, user: user, deleted_at: 1.hour.ago) }

      it ""should mark the user's deleted posts as belonging to a nuked user"" do
        expect { UserDestroyer.new(admin).destroy(user) }.to change { User.count }.by(-1)
        expect(deleted_post.reload.user_id).to eq(nil)
      end
    end

    context ""when user has no posts"" do
      context ""when destroy succeeds"" do
        subject(:destroy) { UserDestroyer.new(admin).destroy(user) }

        let(:destroy_opts) { {} }

        include_examples ""successfully destroy a user""
        include_examples ""email block list""
      end

      context ""when destroy fails"" do
        subject(:destroy) { UserDestroyer.new(admin).destroy(user) }

        it ""should not log the action"" do
          user.stubs(:destroy).returns(false)
          StaffActionLogger.any_instance.expects(:log_user_deletion).never
          destroy
        end
      end
    end

    context ""when user has posts with links"" do
      context ""with external links"" do
        before do
          @post = Fabricate(:post_with_external_links, user: user)
          TopicLink.extract_from(@post)
        end

        it ""doesn't add ScreenedUrl records by default"" do
          ScreenedUrl.expects(:watch).never
          UserDestroyer.new(admin).destroy(user, delete_posts: true)
        end

        it ""adds ScreenedUrl records when :block_urls is true"" do
          ScreenedUrl.expects(:watch).with(anything, anything, has_key(:ip_address)).at_least_once
          UserDestroyer.new(admin).destroy(user, delete_posts: true, block_urls: true)
        end
      end

      context ""with internal links"" do
        before do
          @post = Fabricate(:post_with_external_links, user: user)
          TopicLink.extract_from(@post)
          TopicLink.where(user: user).update_all(internal: true)
        end

        it ""doesn't add ScreenedUrl records"" do
          ScreenedUrl.expects(:watch).never
          UserDestroyer.new(admin).destroy(user, delete_posts: true, block_urls: true)
        end
      end

      context ""with oneboxed links"" do
        before do
          @post = Fabricate(:post_with_youtube, user: user)
          TopicLink.extract_from(@post)
        end

        it ""doesn't add ScreenedUrl records"" do
          ScreenedUrl.expects(:watch).never
          UserDestroyer.new(admin).destroy(user, delete_posts: true, block_urls: true)
        end
      end
    end

    context ""with ip address screening"" do
      it ""doesn't create screened_ip_address records by default"" do
        ScreenedIpAddress.expects(:watch).never
        UserDestroyer.new(admin).destroy(user)
      end

      context ""when block_ip is true"" do
        it ""creates a new screened_ip_address record"" do
          ScreenedIpAddress.expects(:watch).with(user.ip_address).returns(stub_everything)
          UserDestroyer.new(admin).destroy(user, block_ip: true)
        end

        it ""creates two new screened_ip_address records when registration_ip_address is different than last ip_address"" do
          user.registration_ip_address = ""12.12.12.12""
          ScreenedIpAddress.expects(:watch).with(user.ip_address).returns(stub_everything)
          ScreenedIpAddress
            .expects(:watch)
            .with(user.registration_ip_address)
            .returns(stub_everything)
          UserDestroyer.new(admin).destroy(user, block_ip: true)
        end
      end
    end

    context ""when user created a category"" do
      let!(:category) { Fabricate(:category_with_definition, user: user) }

      it ""assigns the system user to the categories"" do
        UserDestroyer.new(admin).destroy(user, delete_posts: true)
        expect(category.reload.user_id).to eq(Discourse.system_user.id)
        expect(category.topic).to be_present
        expect(category.topic.user_id).to eq(Discourse.system_user.id)
      end
    end

    describe ""Destroying a user with security key"" do
      let!(:security_key) { Fabricate(:user_security_key_with_random_credential, user: user) }

      it ""removes the security key"" do
        UserDestroyer.new(admin).destroy(user)
        expect(UserSecurityKey.where(user_id: user.id).count).to eq(0)
      end
    end

    describe ""Destroying a user with a bookmark"" do
      let!(:bookmark) { Fabricate(:bookmark, user: user) }

      it ""removes the bookmark"" do
        UserDestroyer.new(admin).destroy(user)
        expect(Bookmark.where(user_id: user.id).count).to eq(0)
      end
    end

    context ""when user liked things"" do
      before do
        @topic = Fabricate(:topic, user: Fabricate(:user))
        @post = Fabricate(:post, user: @topic.user, topic: @topic)
        PostActionCreator.like(user, @post)
      end

      it ""should destroy the like"" do
        expect { UserDestroyer.new(admin).destroy(user, delete_posts: true) }.to change {
          PostAction.count
        }.by(-1)
        expect(@post.reload.like_count).to eq(0)
      end
    end

    context ""when user belongs to groups that grant trust level"" do
      let(:group) { Fabricate(:group, grant_trust_level: 4) }

      before { group.add(user) }

      it ""can delete the user"" do
        d = UserDestroyer.new(admin)
        expect { d.destroy(user) }.to change { User.count }.by(-1)
      end

      it ""can delete the user if they have a manual locked trust level and have no email"" do
        user.update(manual_locked_trust_level: 3)

        UserEmail.where(user: user).delete_all
        user.reload
        expect { UserDestroyer.new(admin).destroy(user) }.to change { User.count }.by(-1)
      end

      it ""can delete the user if they were to fall into another trust level and have no email"" do
        g2 = Fabricate(:group, grant_trust_level: 1)
        g2.add(user)

        UserEmail.where(user: user).delete_all
        user.reload
        expect { UserDestroyer.new(admin).destroy(user) }.to change { User.count }.by(-1)
      end
    end

    context ""when user has staff action logs"" do
      before do
        logger = StaffActionLogger.new(user)
        logger.log_site_setting_change(
          ""site_description"",
          ""Our friendly community"",
          ""My favourite community"",
        )
        logger.log_site_setting_change(
          ""site_description"",
          ""Our friendly community"",
          ""My favourite community"",
          details: ""existing details"",
        )
      end

      it ""should keep the staff action log and add the username"" do
        username = user.username
        ids =
          UserHistory.staff_action_records(Discourse.system_user, acting_user: username).map(&:id)
        UserDestroyer.new(admin).destroy(user, delete_posts: true)
        details = UserHistory.where(id: ids).map(&:details)
        expect(details).to contain_exactly(
          ""\nuser_id: #{user.id}\nusername: #{username}"",
          ""existing details\nuser_id: #{user.id}\nusername: #{username}"",
        )
      end
    end

    context ""when user got an email"" do
      let!(:email_log) { Fabricate(:email_log, user: user) }

      it ""does not delete the email log"" do
        expect { UserDestroyer.new(admin).destroy(user, delete_posts: true) }.to_not change {
          EmailLog.count
        }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WildcardDomainChecker
  def self.check_domain(domain, external_domain)
    escaped_domain =
      domain[0] == ""*"" ? Regexp.escape(domain).sub(""\\*"", '\S*') : Regexp.escape(domain)
    domain_regex = Regexp.new(""\\A#{escaped_domain}\\z"", ""i"")

    external_domain.match(domain_regex)
  end
end

```","# frozen_string_literal: true

RSpec.describe WildcardDomainChecker do
  describe "".check_domain"" do
    context ""when domain is valid"" do
      it ""returns correct domain"" do
        result1 =
          WildcardDomainChecker.check_domain(
            ""*.discourse.org"",
            ""anything.is.possible.discourse.org"",
          )
        expect(result1[0]).to eq(""anything.is.possible.discourse.org"")

        result2 = WildcardDomainChecker.check_domain(""www.discourse.org"", ""www.discourse.org"")
        expect(result2[0]).to eq(""www.discourse.org"")

        result3 = WildcardDomainChecker.check_domain(""*"", ""hello.discourse.org"")
        expect(result3[0]).to eq(""hello.discourse.org"")
      end
    end

    context ""when domain is invalid"" do
      it ""doesn't return the domain"" do
        result1 =
          WildcardDomainChecker.check_domain(""*.discourse.org"", ""bad-domain.discourse.org.evil.com"")
        expect(result1).to eq(nil)

        result2 =
          WildcardDomainChecker.check_domain(""www.discourse.org"", ""www.discourse.org.evil.com"")
        expect(result2).to eq(nil)

        result3 = WildcardDomainChecker.check_domain(""www.discourse.org"", ""www.www.discourse.org"")
        expect(result3).to eq(nil)

        result4 = WildcardDomainChecker.check_domain(""www.*.discourse.org"", ""www.www.discourse.org"")
        expect(result4).to eq(nil)

        result5 =
          WildcardDomainChecker.check_domain(
            ""www.discourse.org"",
            ""www.discourse.org\nwww.discourse.org.evil.com"",
          )
        expect(result5).to eq(nil)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# GroupMessage sends a private message to a group.
# It will also avoid sending the same message repeatedly, which can happen with
# notifications to moderators when spam is detected.
#
# Options:
#
#   user: (User) If the message is about a user, pass the user object.
#   limit_once_per: (seconds) Limit sending the given type of message once every X seconds.
#                   The default is 24 hours. Set to false to always send the message.

class GroupMessage
  include Rails.application.routes.url_helpers

  RECENT_MESSAGE_PERIOD = 3.months

  def self.create(group_name, message_type, opts = {})
    GroupMessage.new(group_name, message_type, opts).create
  end

  def initialize(group_name, message_type, opts = {})
    @group_name = group_name
    @message_type = message_type
    @opts = opts
  end

  def create
    return false if sent_recently?

    post =
      PostCreator.create(
        Discourse.system_user,
        target_group_names: [@group_name],
        archetype: Archetype.private_message,
        subtype: TopicSubtype.system_message,
        title: I18n.t(""system_messages.#{@message_type}.subject_template"", message_params),
        raw: I18n.t(""system_messages.#{@message_type}.text_body_template"", message_params),
      )
    remember_message_sent
    post
  end

  def delete_previous!(respect_sent_recently: true, match_raw: true)
    return false if respect_sent_recently && sent_recently?

    posts =
      Post
        .joins(topic: { topic_allowed_groups: :group })
        .where(
          topic: {
            posts_count: 1,
            user_id: Discourse.system_user,
            archetype: Archetype.private_message,
            subtype: TopicSubtype.system_message,
            title: I18n.t(""system_messages.#{@message_type}.subject_template"", message_params),
            topic_allowed_groups: {
              groups: {
                name: @group_name,
              },
            },
          },
        )
        .where(""posts.created_at > ?"", RECENT_MESSAGE_PERIOD.ago)

    if match_raw
      posts =
        posts.where(
          raw: I18n.t(""system_messages.#{@message_type}.text_body_template"", message_params).rstrip,
        )
    end

    posts.find_each { |post| PostDestroyer.new(Discourse.system_user, post).destroy }
  end

  def message_params
    @message_params ||=
      begin
        h = { base_url: Discourse.base_url }.merge(@opts[:message_params] || {})
        if @opts[:user]
          h.merge!(username: @opts[:user].username, user_url: user_path(@opts[:user].username))
        end
        h
      end
  end

  def sent_recently?
    return false if @opts[:limit_once_per] == false
    Discourse.redis.get(sent_recently_key).present?
  end

  # default is to send no more than once every 24 hours (24 * 60 * 60 = 86,400 seconds)
  def remember_message_sent
    unless @opts[:limit_once_per] == false
      Discourse.redis.setex(sent_recently_key, @opts[:limit_once_per].try(:to_i) || 86_400, 1)
    end
  end

  def sent_recently_key
    ""grpmsg:#{@group_name}:#{@message_type}:#{@opts[:user] ? @opts[:user].username : """"}""
  end
end

```","# frozen_string_literal: true

RSpec.describe GroupMessage do
  subject(:send_group_message) do
    GroupMessage.create(moderators_group, :user_automatically_silenced, user: user)
  end

  let(:moderators_group) { Group[:moderators].name }

  let!(:admin) { Fabricate.build(:admin, id: 999) }
  let!(:user) { Fabricate.build(:user, id: 111) }

  before { Discourse.stubs(:system_user).returns(admin) }

  describe ""not sent recently"" do
    before { GroupMessage.any_instance.stubs(:sent_recently?).returns(false) }

    it ""should send a private message to the given group"" do
      PostCreator
        .expects(:create)
        .with do |from_user, opts|
          from_user.id == (admin.id) && opts[:target_group_names] &&
            opts[:target_group_names].include?(Group[:moderators].name) &&
            opts[:archetype] == (Archetype.private_message) && opts[:title].present? &&
            opts[:raw].present?
        end
        .returns(stub_everything)
      send_group_message
    end

    it ""returns whatever PostCreator returns"" do
      the_output = stub_everything
      PostCreator.stubs(:create).returns(the_output)
      expect(send_group_message).to eq(the_output)
    end

    it ""remembers that it was sent so it doesn't spam the group with the same message"" do
      PostCreator.stubs(:create).returns(stub_everything)
      GroupMessage.any_instance.expects(:remember_message_sent)
      send_group_message
    end
  end

  describe ""sent recently"" do
    subject(:group_message) do
      GroupMessage.create(moderators_group, :user_automatically_silenced, user: user)
    end

    before { GroupMessage.any_instance.stubs(:sent_recently?).returns(true) }

    it { is_expected.to eq(false) }

    it ""should not send the same notification again"" do
      PostCreator.expects(:create).never
      group_message
    end
  end

  describe ""message_params"" do
    let(:user) { Fabricate.build(:user, id: 123_123) }
    shared_examples ""common message params for group messages"" do
      it ""returns the correct params"" do
        expect(message_params[:username]).to eq(user.username)
        expect(message_params[:user_url]).to be_present
      end
    end

    context ""with user_automatically_silenced"" do
      subject(:message_params) do
        GroupMessage.new(moderators_group, :user_automatically_silenced, user: user).message_params
      end

      include_examples ""common message params for group messages""
    end

    context ""with spam_post_blocked"" do
      subject(:message_params) do
        GroupMessage.new(moderators_group, :spam_post_blocked, user: user).message_params
      end

      include_examples ""common message params for group messages""
    end
  end

  describe ""methods that use redis"" do
    subject(:group_message) do
      GroupMessage.new(moderators_group, :user_automatically_silenced, user: user)
    end

    let(:user) { Fabricate.build(:user, id: 123_123) }

    before do
      PostCreator.stubs(:create).returns(stub_everything)
      group_message.stubs(:sent_recently_key).returns(""the_key"")
    end

    describe ""sent_recently?"" do
      it ""returns true if redis says so"" do
        Discourse.redis.stubs(:get).with(group_message.sent_recently_key).returns(""1"")
        expect(group_message.sent_recently?).to be_truthy
      end

      it ""returns false if redis returns nil"" do
        Discourse.redis.stubs(:get).with(group_message.sent_recently_key).returns(nil)
        expect(group_message.sent_recently?).to be_falsey
      end

      it ""always returns false if limit_once_per is false"" do
        gm =
          GroupMessage.new(
            moderators_group,
            :user_automatically_silenced,
            user: user,
            limit_once_per: false,
          )
        gm.stubs(:sent_recently_key).returns(""the_key"")
        Discourse.redis.stubs(:get).with(gm.sent_recently_key).returns(""1"")
        expect(gm.sent_recently?).to be_falsey
      end
    end

    describe ""remember_message_sent"" do
      it ""stores a key in redis that expires after 24 hours"" do
        Discourse
          .redis
          .expects(:setex)
          .with(group_message.sent_recently_key, 24 * 60 * 60, anything)
          .returns(""OK"")
        group_message.remember_message_sent
      end

      it ""can use a given expiry time"" do
        Discourse.redis.expects(:setex).with(anything, 30 * 60, anything).returns(""OK"")
        GroupMessage.new(
          moderators_group,
          :user_automatically_silenced,
          user: user,
          limit_once_per: 30.minutes,
        ).remember_message_sent
      end

      it ""can be disabled"" do
        Discourse.redis.expects(:setex).never
        GroupMessage.new(
          moderators_group,
          :user_automatically_silenced,
          user: user,
          limit_once_per: false,
        ).remember_message_sent
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class UserMerger
  def initialize(source_user, target_user, acting_user = nil)
    @source_user = source_user
    @target_user = target_user
    @acting_user = acting_user
    @user_id = source_user.id
    @source_primary_email = source_user.email
  end

  def merge!
    update_username
    move_posts
    update_user_ids
    merge_given_daily_likes
    merge_post_timings
    merge_user_visits
    update_site_settings
    merge_user_attributes

    DiscourseEvent.trigger(:merging_users, @source_user, @target_user)
    update_user_stats

    delete_source_user
    log_merge

    @target_user.reload
  end

  protected

  def update_username
    return if @source_user.username == @target_user.username

    if @acting_user
      ::MessageBus.publish ""/merge_user"",
                           { message: I18n.t(""admin.user.merge_user.updating_username"") },
                           user_ids: [@acting_user.id]
    end
    UsernameChanger.update_username(
      user_id: @source_user.id,
      old_username: @source_user.username,
      new_username: @target_user.username,
      avatar_template: @target_user.avatar_template,
      asynchronous: false,
    )
  end

  def move_posts
    posts =
      Post
        .with_deleted
        .where(user_id: @source_user.id)
        .order(:topic_id, :post_number)
        .pluck(:topic_id, :id)

    return if posts.count == 0

    if @acting_user
      ::MessageBus.publish ""/merge_user"",
                           { message: I18n.t(""admin.user.merge_user.changing_post_ownership"") },
                           user_ids: [@acting_user.id]
    end

    last_topic_id = nil
    post_ids = []

    posts.each do |current_topic_id, current_post_id|
      if last_topic_id != current_topic_id && post_ids.any?
        change_post_owner(last_topic_id, post_ids)
        post_ids = []
      end

      last_topic_id = current_topic_id
      post_ids << current_post_id
    end

    change_post_owner(last_topic_id, post_ids) if post_ids.any?
  end

  def change_post_owner(topic_id, post_ids)
    PostOwnerChanger.new(
      topic_id: topic_id,
      post_ids: post_ids,
      new_owner: @target_user,
      acting_user: Discourse.system_user,
      skip_revision: true,
    ).change_owner!
  end

  def merge_given_daily_likes
    if @acting_user
      ::MessageBus.publish ""/merge_user"",
                           { message: I18n.t(""admin.user.merge_user.merging_given_daily_likes"") },
                           user_ids: [@acting_user.id]
    end

    sql = <<~SQL
      INSERT INTO given_daily_likes AS g (user_id, likes_given, given_date, limit_reached)
        SELECT
          :target_user_id                AS user_id,
          COUNT(1)                       AS likes_given,
          a.created_at::DATE             AS given_date,
          COUNT(1) >= :max_likes_per_day AS limit_reached
        FROM post_actions AS a
        WHERE a.user_id = :target_user_id
              AND a.deleted_at IS NULL
              AND EXISTS(
                  SELECT 1
                  FROM given_daily_likes AS g
                  WHERE g.user_id = :source_user_id AND a.created_at::DATE = g.given_date
              )
        GROUP BY given_date
      ON CONFLICT (user_id, given_date)
        DO UPDATE
          SET likes_given = EXCLUDED.likes_given,
            limit_reached = EXCLUDED.limit_reached
    SQL

    DB.exec(
      sql,
      source_user_id: @source_user.id,
      target_user_id: @target_user.id,
      max_likes_per_day: SiteSetting.max_likes_per_day,
      action_type_id: PostActionType.types[:like],
    )
  end

  def merge_post_timings
    if @acting_user
      ::MessageBus.publish ""/merge_user"",
                           { message: I18n.t(""admin.user.merge_user.merging_post_timings"") },
                           user_ids: [@acting_user.id]
    end

    update_user_id(
      :post_timings,
      conditions: [""x.topic_id = y.topic_id"", ""x.post_number = y.post_number""],
    )
    sql = <<~SQL
      UPDATE post_timings AS t
      SET msecs = LEAST(t.msecs::bigint + s.msecs, 2^31 - 1)
      FROM post_timings AS s
      WHERE t.user_id = :target_user_id AND s.user_id = :source_user_id
            AND t.topic_id = s.topic_id AND t.post_number = s.post_number
    SQL

    DB.exec(sql, source_user_id: @source_user.id, target_user_id: @target_user.id)
  end

  def merge_user_visits
    if @acting_user
      ::MessageBus.publish ""/merge_user"",
                           { message: I18n.t(""admin.user.merge_user.merging_user_visits"") },
                           user_ids: [@acting_user.id]
    end

    update_user_id(:user_visits, conditions: ""x.visited_at = y.visited_at"")

    sql = <<~SQL
      UPDATE user_visits AS t
      SET posts_read = t.posts_read + s.posts_read,
        mobile       = t.mobile OR s.mobile,
        time_read    = t.time_read + s.time_read
      FROM user_visits AS s
      WHERE t.user_id = :target_user_id AND s.user_id = :source_user_id
            AND t.visited_at = s.visited_at
    SQL

    DB.exec(sql, source_user_id: @source_user.id, target_user_id: @target_user.id)
  end

  def update_site_settings
    if @acting_user
      ::MessageBus.publish ""/merge_user"",
                           { message: I18n.t(""admin.user.merge_user.updating_site_settings"") },
                           user_ids: [@acting_user.id]
    end

    SiteSetting
      .all_settings(include_hidden: true)
      .each do |setting|
        if setting[:type] == ""username"" && setting[:value] == @source_user.username
          SiteSetting.set_and_log(setting[:setting], @target_user.username)
        end
      end
  end

  def update_user_stats
    if @acting_user
      ::MessageBus.publish ""/merge_user"",
                           { message: I18n.t(""admin.user.merge_user.updating_user_stats"") },
                           user_ids: [@acting_user.id]
    end

    # topics_entered
    DB.exec(<<~SQL, target_user_id: @target_user.id)
      UPDATE user_stats
      SET topics_entered = (
        SELECT COUNT(topic_id)
        FROM topic_views
        WHERE user_id = :target_user_id
      )
      WHERE user_id = :target_user_id
    SQL

    # time_read and days_visited
    DB.exec(<<~SQL, target_user_id: @target_user.id)
      UPDATE user_stats
      SET time_read  = COALESCE(x.time_read, 0),
        days_visited = COALESCE(x.days_visited, 0)
      FROM (
             SELECT
               SUM(time_read) AS time_read,
               COUNT(1)       AS days_visited
             FROM user_visits
             WHERE user_id = :target_user_id
           ) AS x
      WHERE user_id = :target_user_id
    SQL

    # posts_read_count
    DB.exec(<<~SQL, target_user_id: @target_user.id)
      UPDATE user_stats
      SET posts_read_count = (
        SELECT COUNT(1)
        FROM post_timings AS pt
        WHERE pt.user_id = :target_user_id AND EXISTS(
            SELECT 1
            FROM topics AS t
            WHERE t.archetype = 'regular' AND t.deleted_at IS NULL
        ))
      WHERE user_id = :target_user_id
    SQL

    # likes_given, likes_received, new_since, read_faq, first_post_created_at
    DB.exec(<<~SQL, source_user_id: @source_user.id, target_user_id: @target_user.id)
      UPDATE user_stats AS t
      SET likes_given         = t.likes_given + s.likes_given,
        likes_received        = t.likes_received + s.likes_received,
        new_since             = LEAST(t.new_since, s.new_since),
        read_faq              = LEAST(t.read_faq, s.read_faq),
        first_post_created_at = LEAST(t.first_post_created_at, s.first_post_created_at)
      FROM user_stats AS s
      WHERE t.user_id = :target_user_id AND s.user_id = :source_user_id
    SQL
  end

  def merge_user_attributes
    if @acting_user
      ::MessageBus.publish ""/merge_user"",
                           { message: I18n.t(""admin.user.merge_user.merging_user_attributes"") },
                           user_ids: [@acting_user.id]
    end

    DB.exec(<<~SQL, source_user_id: @source_user.id, target_user_id: @target_user.id)
      UPDATE users AS t
      SET created_at              = LEAST(t.created_at, s.created_at),
        updated_at                = LEAST(t.updated_at, s.updated_at),
        seen_notification_id      = GREATEST(t.seen_notification_id, s.seen_notification_id),
        last_posted_at            = GREATEST(t.last_seen_at, s.last_seen_at),
        last_seen_at              = GREATEST(t.last_seen_at, s.last_seen_at),
        admin                     = t.admin OR s.admin,
        last_emailed_at           = GREATEST(t.last_emailed_at, s.last_emailed_at),
        trust_level               = GREATEST(t.trust_level, s.trust_level),
        previous_visit_at         = GREATEST(t.previous_visit_at, s.previous_visit_at),
        date_of_birth             = COALESCE(t.date_of_birth, s.date_of_birth),
        ip_address                = COALESCE(t.ip_address, s.ip_address),
        moderator                 = t.moderator OR s.moderator,
        title                     = COALESCE(t.title, s.title),
        primary_group_id          = COALESCE(t.primary_group_id, s.primary_group_id),
        registration_ip_address   = COALESCE(t.registration_ip_address, s.registration_ip_address),
        first_seen_at             = LEAST(t.first_seen_at, s.first_seen_at),
        manual_locked_trust_level = GREATEST(t.manual_locked_trust_level, s.manual_locked_trust_level)
      FROM users AS s
      WHERE t.id = :target_user_id AND s.id = :source_user_id
    SQL

    DB.exec(<<~SQL, source_user_id: @source_user.id, target_user_id: @target_user.id)
      UPDATE user_profiles AS t
      SET location           = COALESCE(t.location, s.location),
        website              = COALESCE(t.website, s.website),
        bio_raw              = COALESCE(t.bio_raw, s.bio_raw),
        bio_cooked           = COALESCE(t.bio_cooked, s.bio_cooked),
        bio_cooked_version   = COALESCE(t.bio_cooked_version, s.bio_cooked_version),
        profile_background_upload_id = COALESCE(t.profile_background_upload_id, s.profile_background_upload_id),
        dismissed_banner_key = COALESCE(t.dismissed_banner_key, s.dismissed_banner_key),
        granted_title_badge_id = COALESCE(t.granted_title_badge_id, s.granted_title_badge_id),
        card_background_upload_id = COALESCE(t.card_background_upload_id, s.card_background_upload_id),
        views                = t.views + s.views
      FROM user_profiles AS s
      WHERE t.user_id = :target_user_id AND s.user_id = :source_user_id
    SQL
  end

  def update_user_ids
    if @acting_user
      ::MessageBus.publish ""/merge_user"",
                           { message: I18n.t(""admin.user.merge_user.updating_user_ids"") },
                           user_ids: [@acting_user.id]
    end

    Category.where(user_id: @source_user.id).update_all(user_id: @target_user.id)

    update_user_id(:category_users, conditions: [""x.category_id = y.category_id""])

    update_user_id(:developers)

    update_user_id(:draft_sequences, conditions: ""x.draft_key = y.draft_key"")
    update_user_id(:drafts, conditions: ""x.draft_key = y.draft_key"")

    update_user_id(:dismissed_topic_users, conditions: ""x.topic_id = y.topic_id"")

    EmailLog.where(user_id: @source_user.id).update_all(user_id: @target_user.id)

    GroupHistory.where(acting_user_id: @source_user.id).update_all(acting_user_id: @target_user.id)
    GroupHistory.where(target_user_id: @source_user.id).update_all(target_user_id: @target_user.id)

    update_user_id(:group_users, conditions: ""x.group_id = y.group_id"")

    IncomingEmail.where(user_id: @source_user.id).update_all(user_id: @target_user.id)

    IncomingLink.where(user_id: @source_user.id).update_all(user_id: @target_user.id)
    IncomingLink.where(current_user_id: @source_user.id).update_all(
      current_user_id: @target_user.id,
    )

    InvitedUser.where(user_id: @source_user.id).update_all(user_id: @target_user.id)
    Invite
      .with_deleted
      .where(invited_by_id: @source_user.id)
      .update_all(invited_by_id: @target_user.id)
    Invite
      .with_deleted
      .where(deleted_by_id: @source_user.id)
      .update_all(deleted_by_id: @target_user.id)

    update_user_id(:muted_users, conditions: ""x.muted_user_id = y.muted_user_id"")
    update_user_id(
      :muted_users,
      user_id_column_name: ""muted_user_id"",
      conditions: ""x.user_id = y.user_id"",
    )

    update_user_id(:ignored_users, conditions: ""x.ignored_user_id = y.ignored_user_id"")
    update_user_id(
      :ignored_users,
      user_id_column_name: ""ignored_user_id"",
      conditions: ""x.user_id = y.user_id"",
    )

    Notification.where(user_id: @source_user.id).update_all(user_id: @target_user.id)

    update_user_id(
      :post_actions,
      conditions: [
        ""x.post_id = y.post_id"",
        ""x.post_action_type_id = y.post_action_type_id"",
        ""x.targets_topic = y.targets_topic"",
      ],
    )

    PostAction.where(deleted_by_id: @source_user.id).update_all(deleted_by_id: @target_user.id)
    PostAction.where(deferred_by_id: @source_user.id).update_all(deferred_by_id: @target_user.id)
    PostAction.where(agreed_by_id: @source_user.id).update_all(agreed_by_id: @target_user.id)
    PostAction.where(disagreed_by_id: @source_user.id).update_all(disagreed_by_id: @target_user.id)

    PostRevision.where(user_id: @source_user.id).update_all(user_id: @target_user.id)

    Post
      .with_deleted
      .where(deleted_by_id: @source_user.id)
      .update_all(deleted_by_id: @target_user.id)
    Post
      .with_deleted
      .where(last_editor_id: @source_user.id)
      .update_all(last_editor_id: @target_user.id)
    Post.with_deleted.where(locked_by_id: @source_user.id).update_all(locked_by_id: @target_user.id)
    Post
      .with_deleted
      .where(reply_to_user_id: @source_user.id)
      .update_all(reply_to_user_id: @target_user.id)

    Reviewable.where(created_by_id: @source_user.id).update_all(created_by_id: @target_user.id)
    ReviewableHistory.where(created_by_id: @source_user.id).update_all(
      created_by_id: @target_user.id,
    )

    SearchLog.where(user_id: @source_user.id).update_all(user_id: @target_user.id)

    update_user_id(:tag_users, conditions: ""x.tag_id = y.tag_id"")

    Theme.where(user_id: @source_user.id).update_all(user_id: @target_user.id)

    update_user_id(:topic_allowed_users, conditions: ""x.topic_id = y.topic_id"")

    TopicEmbed
      .with_deleted
      .where(deleted_by_id: @source_user.id)
      .update_all(deleted_by_id: @target_user.id)

    TopicLink.where(user_id: @source_user.id).update_all(user_id: @target_user.id)
    TopicLinkClick.where(user_id: @source_user.id).update_all(user_id: @target_user.id)

    TopicTimer
      .with_deleted
      .where(deleted_by_id: @source_user.id)
      .update_all(deleted_by_id: @target_user.id)

    update_user_id(
      :topic_timers,
      conditions: [
        ""x.status_type = y.status_type"",
        ""x.topic_id = y.topic_id"",
        ""y.deleted_at IS NULL"",
      ],
    )

    update_user_id(:topic_users, conditions: ""x.topic_id = y.topic_id"")

    update_user_id(:topic_views, conditions: ""x.topic_id = y.topic_id"")

    Topic
      .with_deleted
      .where(deleted_by_id: @source_user.id)
      .update_all(deleted_by_id: @target_user.id)

    UnsubscribeKey.where(user_id: @source_user.id).update_all(user_id: @target_user.id)

    Upload.where(user_id: @source_user.id).update_all(user_id: @target_user.id)

    update_user_id(:user_archived_messages, conditions: ""x.topic_id = y.topic_id"")

    update_user_id(
      :user_actions,
      user_id_column_name: ""user_id"",
      conditions: [
        ""x.action_type = y.action_type"",
        ""x.target_topic_id IS NOT DISTINCT FROM y.target_topic_id"",
        ""x.target_post_id IS NOT DISTINCT FROM y.target_post_id"",
        ""(x.acting_user_id IN (:source_user_id, :target_user_id) OR x.acting_user_id IS NOT DISTINCT FROM y.acting_user_id)"",
      ],
    )
    update_user_id(
      :user_actions,
      user_id_column_name: ""acting_user_id"",
      conditions: [
        ""x.action_type = y.action_type"",
        ""x.user_id = y.user_id"",
        ""x.target_topic_id IS NOT DISTINCT FROM y.target_topic_id"",
        ""x.target_post_id IS NOT DISTINCT FROM y.target_post_id"",
      ],
    )

    update_user_id(
      :user_badges,
      conditions: [
        ""x.badge_id = y.badge_id"",
        ""x.seq = y.seq"",
        ""x.post_id IS NOT DISTINCT FROM y.post_id"",
      ],
    )

    UserBadge.where(granted_by_id: @source_user.id).update_all(granted_by_id: @target_user.id)

    update_user_id(:user_custom_fields, conditions: ""x.name = y.name"")

    if @target_user.human?
      update_user_id(
        :user_emails,
        conditions: ""x.email = y.email OR y.primary = false"",
        updates: '""primary"" = false',
      )
    end

    UserExport.where(user_id: @source_user.id).update_all(user_id: @target_user.id)

    UserHistory.where(target_user_id: @source_user.id).update_all(target_user_id: @target_user.id)
    UserHistory.where(acting_user_id: @source_user.id).update_all(acting_user_id: @target_user.id)

    UserProfileView.where(user_profile_id: @source_user.id).update_all(
      user_profile_id: @target_user.id,
    )
    UserProfileView.where(user_id: @source_user.id).update_all(user_id: @target_user.id)

    UserWarning.where(user_id: @source_user.id).update_all(user_id: @target_user.id)
    UserWarning.where(created_by_id: @source_user.id).update_all(created_by_id: @target_user.id)

    User.where(approved_by_id: @source_user.id).update_all(approved_by_id: @target_user.id)
  end

  def delete_source_user
    if @acting_user
      ::MessageBus.publish ""/merge_user"",
                           { message: I18n.t(""admin.user.merge_user.deleting_source_user"") },
                           user_ids: [@acting_user.id]
    end

    @source_user.reload

    @source_user.skip_email_validation = true
    @source_user.update(
      admin: false,
      email: ""#{@source_user.username}_#{SecureRandom.hex}@no-email.invalid"",
    )

    UserDestroyer.new(Discourse.system_user).destroy(@source_user, quiet: true)
  end

  def log_merge
    logger = StaffActionLogger.new(@acting_user || Discourse.system_user)
    logger.log_user_merge(@target_user, @source_user.username, @source_primary_email || """")
  end

  def update_user_id(table_name, opts = {})
    builder = update_user_id_sql_builder(table_name, opts)
    builder.exec(source_user_id: @source_user.id, target_user_id: @target_user.id)
  end

  def update_user_id_sql_builder(table_name, opts = {})
    user_id_column_name = opts[:user_id_column_name] || :user_id
    conditions = Array.wrap(opts[:conditions])
    updates = Array.wrap(opts[:updates])

    builder = DB.build(<<~SQL)
      UPDATE #{table_name} AS x
      /*set*/
      WHERE x.#{user_id_column_name} = :source_user_id AND NOT EXISTS(
          SELECT 1
          FROM #{table_name} AS y
          /*where*/
      )
    SQL

    builder.set(""#{user_id_column_name} = :target_user_id"")
    updates.each { |u| builder.set(u) }

    builder.where(""y.#{user_id_column_name} = :target_user_id"")
    conditions.each { |c| builder.where(c) }

    builder
  end
end

```","# frozen_string_literal: true

RSpec.describe UserMerger do
  fab!(:target_user) { Fabricate(:user, username: ""alice"", email: ""alice@example.com"") }
  fab!(:source_user) { Fabricate(:user, username: ""alice1"", email: ""alice@work.com"") }
  fab!(:walter) { Fabricate(:walter_white) }
  fab!(:coding_horror)

  fab!(:p1) { Fabricate(:post) }
  fab!(:p2) { Fabricate(:post) }
  fab!(:p3) { Fabricate(:post) }
  fab!(:p4) { Fabricate(:post) }
  fab!(:p5) { Fabricate(:post) }
  fab!(:p6) { Fabricate(:post) }

  before { Group.refresh_automatic_groups! }

  def merge_users!(source = nil, target = nil)
    source ||= source_user
    target ||= target_user
    UserMerger.new(source, target).merge!
  end

  it ""changes owner of topics and posts"" do
    topic1 = Fabricate(:topic, user: source_user)
    post1 = Fabricate(:post, topic: topic1, user: source_user)
    post2 = Fabricate(:post, topic: topic1, user: walter)
    post3 = Fabricate(:post, topic: topic1, user: target_user)
    post4 = Fabricate(:post, topic: topic1, user: walter)
    post5 = Fabricate(:post, topic: topic1, user: source_user)

    topic2 = Fabricate(:topic, user: walter)
    post6 = Fabricate(:post, topic: topic2, user: walter)
    post7 = Fabricate(:post, topic: topic2, user: source_user)
    post8 = Fabricate(:post, topic: topic2, user: source_user, deleted_at: Time.now)

    merge_users!

    [topic1, post1, post3, post5, post7, post8].each do |x|
      expect(x.reload.user).to eq(target_user)
    end

    [post2, post4, topic2, post6].each { |x| expect(x.reload.user).to eq(walter) }
  end

  it ""changes owner of personal messages"" do
    pm_topic =
      Fabricate(
        :private_message_topic,
        topic_allowed_users: [
          Fabricate.build(:topic_allowed_user, user: target_user),
          Fabricate.build(:topic_allowed_user, user: walter),
          Fabricate.build(:topic_allowed_user, user: source_user),
        ],
      )

    post1 = Fabricate(:post, topic: pm_topic, user: source_user)
    post2 = Fabricate(:post, topic: pm_topic, user: walter)
    post3 = Fabricate(:post, topic: pm_topic, user: target_user)
    post4 = Fabricate(:post, topic: pm_topic, user: source_user, deleted_at: Time.now)

    small1 = pm_topic.add_small_action(source_user, ""invited_user"", ""carol"")
    small2 = pm_topic.add_small_action(target_user, ""invited_user"", ""david"")
    small3 = pm_topic.add_small_action(walter, ""invited_user"", ""eve"")

    merge_users!

    expect(post1.reload.user).to eq(target_user)
    expect(post2.reload.user).to eq(walter)
    expect(post3.reload.user).to eq(target_user)
    expect(post4.reload.user).to eq(target_user)

    expect(small1.reload.user).to eq(target_user)
    expect(small2.reload.user).to eq(target_user)
    expect(small3.reload.user).to eq(walter)
  end

  it ""changes owner of categories"" do
    category = Fabricate(:category, user: source_user)
    merge_users!

    expect(category.reload.user).to eq(target_user)
  end

  it ""merges category notification settings"" do
    category1 = Fabricate(:category)
    category2 = Fabricate(:category)
    category3 = Fabricate(:category)
    watching = CategoryUser.notification_levels[:watching]

    CategoryUser.batch_set(source_user, :watching, [category1.id, category2.id])
    CategoryUser.batch_set(target_user, :watching, [category2.id, category3.id])

    merge_users!

    category_ids =
      CategoryUser.where(user_id: target_user.id, notification_level: watching).pluck(:category_id)
    expect(category_ids).to contain_exactly(category1.id, category2.id, category3.id)

    category_ids =
      CategoryUser.where(user_id: source_user.id, notification_level: watching).pluck(:category_id)
    expect(category_ids).to be_empty
  end

  context ""with developer flag"" do
    it ""moves the developer flag when the target user isn't a developer yet"" do
      Developer.create!(user_id: source_user.id)
      merge_users!

      expect(Developer.where(user_id: source_user.id).count).to eq(0)
      expect(Developer.where(user_id: target_user.id).count).to eq(1)
    end

    it ""deletes the source's developer flag when the target user is already a developer"" do
      Developer.create!(user_id: source_user.id)
      Developer.create!(user_id: target_user.id)
      merge_users!

      expect(Developer.where(user_id: source_user.id).count).to eq(0)
      expect(Developer.where(user_id: target_user.id).count).to eq(1)
    end
  end

  context ""with drafts"" do
    def create_draft(user, key, text)
      seq = DraftSequence.next!(user, key)
      Draft.set(user, key, seq, text)
    end

    def current_target_user_draft(key)
      seq = DraftSequence.current(target_user, key)
      Draft.get(target_user, key, seq)
    end

    it ""merges drafts"" do
      key_topic_17 = ""#{Draft::EXISTING_TOPIC}#{17}""
      key_topic_19 = ""#{Draft::EXISTING_TOPIC}#{19}""

      create_draft(source_user, Draft::NEW_TOPIC, ""new topic draft by alice1"")
      create_draft(source_user, key_topic_17, ""draft by alice1"")
      create_draft(source_user, key_topic_19, ""draft by alice1"")
      create_draft(target_user, key_topic_19, ""draft by alice"")

      merge_users!

      expect(current_target_user_draft(Draft::NEW_TOPIC)).to eq(""new topic draft by alice1"")
      expect(current_target_user_draft(key_topic_17)).to eq(""draft by alice1"")
      expect(current_target_user_draft(key_topic_19)).to eq(""draft by alice"")

      expect(DraftSequence.where(user_id: source_user.id).count).to eq(0)
      expect(Draft.where(user_id: source_user.id).count).to eq(0)
    end
  end

  it ""updates email logs"" do
    Fabricate(:email_log, user: source_user)
    merge_users!

    expect(EmailLog.where(user_id: source_user.id).count).to eq(0)
    expect(EmailLog.where(user_id: target_user.id).count).to eq(1)
  end

  context ""with likes"" do
    def given_daily_like_count_for(user, date)
      GivenDailyLike.find_for(user.id, date).pluck(:likes_given)[0] || 0
    end

    it ""merges likes"" do
      now = Time.zone.now

      freeze_time(now - 1.day)
      PostActionCreator.like(source_user, p1)
      PostActionCreator.like(source_user, p2)
      PostActionCreator.like(target_user, p2)
      PostActionCreator.like(target_user, p3)

      freeze_time(now)
      PostActionCreator.like(source_user, p4)
      PostActionCreator.like(source_user, p5)
      PostActionCreator.like(target_user, p5)
      PostActionCreator.like(source_user, p6)
      PostActionDestroyer.destroy(source_user, p6, :like)

      merge_users!

      [p1, p2, p3, p4, p5].each { |p| expect(p.reload.like_count).to eq(1) }
      expect(PostAction.with_deleted.where(user_id: source_user.id).count).to eq(0)
      expect(PostAction.with_deleted.where(user_id: target_user.id).count).to eq(6)

      expect(given_daily_like_count_for(source_user, Date.yesterday)).to eq(0)
      expect(given_daily_like_count_for(target_user, Date.yesterday)).to eq(3)
      expect(given_daily_like_count_for(source_user, Date.today)).to eq(0)
      expect(given_daily_like_count_for(target_user, Date.today)).to eq(2)
    end
  end

  it ""updates group history"" do
    group = Fabricate(:group)
    group.add_owner(source_user)
    logger = GroupActionLogger.new(source_user, group)
    logger.log_add_user_to_group(walter)
    logger.log_add_user_to_group(target_user)

    group = Fabricate(:group)
    group.add_owner(target_user)
    logger = GroupActionLogger.new(target_user, group)
    logger.log_add_user_to_group(walter)
    logger.log_add_user_to_group(source_user)

    merge_users!

    expect(GroupHistory.where(acting_user_id: source_user.id).count).to eq(0)
    expect(GroupHistory.where(acting_user_id: target_user.id).count).to eq(4)

    expect(GroupHistory.where(target_user_id: source_user.id).count).to eq(0)
    expect(GroupHistory.where(target_user_id: target_user.id).count).to eq(2)
  end

  it ""merges group memberships"" do
    group1 = Fabricate(:group)
    group1.add_owner(target_user)
    group1.bulk_add([walter.id, source_user.id])

    group2 = Fabricate(:group)
    group2.bulk_add([walter.id, target_user.id])

    group3 = Fabricate(:group)
    group3.add_owner(source_user)
    group3.add(walter)

    merge_users!

    [group1, group2, group3].each do |g|
      owner = [group1, group3].include?(g)
      expect(GroupUser.where(group_id: g.id, user_id: target_user.id, owner: owner).count).to eq(1)
      expect(Group.where(id: g.id).pick(:user_count)).to eq(2)
    end
    expect(GroupUser.where(user_id: source_user.id).count).to eq(0)
  end

  it ""updates incoming emails"" do
    email = Fabricate(:incoming_email, user: source_user)
    merge_users!

    expect(email.reload.user).to eq(target_user)
  end

  it ""updates incoming links"" do
    link1 = Fabricate(:incoming_link, user: source_user)
    link2 = Fabricate(:incoming_link, current_user_id: source_user.id)

    merge_users!

    expect(link1.reload.user).to eq(target_user)
    expect(link2.reload.current_user_id).to eq(target_user.id)
  end

  it ""updates invites"" do
    invite1 = Fabricate(:invite, invited_by: walter)
    Fabricate(:invited_user, invite: invite1, user: source_user)
    invite2 = Fabricate(:invite, invited_by: source_user)
    invite3 = Fabricate(:invite, invited_by: source_user)
    invite3.trash!(source_user)

    merge_users!

    [invite1, invite2, invite3].each { |x| x.reload }

    expect(invite1.invited_users.first.user).to eq(target_user)
    expect(invite2.invited_by).to eq(target_user)
    expect(invite3.invited_by).to eq(target_user)
    expect(invite3.deleted_by).to eq(target_user)
  end

  it ""merges muted users"" do
    muted1 = Fabricate(:user)
    muted2 = Fabricate(:user)
    muted3 = Fabricate(:user)

    MutedUser.create!(user_id: source_user.id, muted_user_id: muted1.id)
    MutedUser.create!(user_id: source_user.id, muted_user_id: muted2.id)
    MutedUser.create!(user_id: target_user.id, muted_user_id: muted2.id)
    MutedUser.create!(user_id: target_user.id, muted_user_id: muted3.id)
    MutedUser.create!(user_id: walter.id, muted_user_id: source_user.id)
    MutedUser.create!(user_id: coding_horror.id, muted_user_id: source_user.id)
    MutedUser.create!(user_id: coding_horror.id, muted_user_id: target_user.id)

    merge_users!

    [muted1, muted2, muted3].each do |m|
      expect(MutedUser.where(user_id: target_user.id, muted_user_id: m.id).count).to eq(1)
    end
    expect(MutedUser.where(user_id: source_user.id).count).to eq(0)

    expect(MutedUser.where(user_id: walter.id, muted_user_id: target_user.id).count).to eq(1)
    expect(MutedUser.where(user_id: coding_horror.id, muted_user_id: target_user.id).count).to eq(1)
    expect(MutedUser.where(muted_user_id: source_user.id).count).to eq(0)
  end

  it ""merges ignored users"" do
    ignored1 = Fabricate(:user)
    ignored2 = Fabricate(:user)
    ignored3 = Fabricate(:user)

    Fabricate(:ignored_user, user: source_user, ignored_user: ignored1)
    Fabricate(:ignored_user, user: source_user, ignored_user: ignored2)
    Fabricate(:ignored_user, user: target_user, ignored_user: ignored2)
    Fabricate(:ignored_user, user: target_user, ignored_user: ignored3)
    Fabricate(:ignored_user, user: walter, ignored_user: source_user)
    Fabricate(:ignored_user, user: coding_horror, ignored_user: source_user)
    Fabricate(:ignored_user, user: coding_horror, ignored_user: target_user)

    merge_users!

    [ignored1, ignored2, ignored3].each do |m|
      expect(IgnoredUser.where(user_id: target_user.id, ignored_user_id: m.id).count).to eq(1)
    end
    expect(IgnoredUser.where(user_id: source_user.id).count).to eq(0)

    expect(IgnoredUser.where(user_id: walter.id, ignored_user_id: target_user.id).count).to eq(1)
    expect(
      IgnoredUser.where(user_id: coding_horror.id, ignored_user_id: target_user.id).count,
    ).to eq(1)
    expect(IgnoredUser.where(ignored_user_id: source_user.id).count).to eq(0)
  end

  context ""with notifications"" do
    it ""updates notifications"" do
      Fabricate(:notification, user: source_user)
      Fabricate(:notification, user: source_user)
      Fabricate(:notification, user: walter)

      merge_users!

      expect(Notification.where(user_id: target_user.id).count).to eq(2)
      expect(Notification.where(user_id: source_user.id).count).to eq(0)
    end
  end

  context ""with post actions"" do
    it ""merges post actions"" do
      type_ids = PostActionType.public_type_ids + [PostActionType.flag_types.values.first]

      type_ids.each do |type|
        PostActionCreator.new(source_user, p1, type).perform
        PostActionCreator.new(source_user, p2, type).perform
        PostActionCreator.new(target_user, p2, type).perform
        PostActionCreator.new(target_user, p3, type).perform
      end

      merge_users!

      type_ids.each do |type|
        expect(
          PostAction.where(user_id: target_user.id, post_action_type_id: type).pluck(:post_id),
        ).to contain_exactly(p1.id, p2.id, p3.id)
      end

      expect(PostAction.where(user_id: source_user.id).count).to eq(0)
    end

    it ""updates post actions"" do
      action1 = PostActionCreator.create(source_user, p1, :off_topic).post_action
      action1.update_attribute(:deleted_by_id, source_user.id)

      action2 = PostActionCreator.create(source_user, p2, :off_topic).post_action
      action2.update_attribute(:deferred_by_id, source_user.id)

      action3 = PostActionCreator.create(source_user, p3, :off_topic).post_action
      action3.update_attribute(:agreed_by_id, source_user.id)

      action4 = PostActionCreator.create(source_user, p4, :off_topic).post_action
      action4.update_attribute(:disagreed_by_id, source_user.id)

      merge_users!

      expect(action1.reload.deleted_by_id).to eq(target_user.id)
      expect(action2.reload.deferred_by_id).to eq(target_user.id)
      expect(action3.reload.agreed_by_id).to eq(target_user.id)
      expect(action4.reload.disagreed_by_id).to eq(target_user.id)
    end
  end

  it ""updates post revisions"" do
    post = p1
    post_revision = Fabricate(:post_revision, post: post, user: source_user)

    merge_users!
    expect(post_revision.reload.user).to eq(target_user)
  end

  context ""with post timings"" do
    def create_post_timing(post, user, msecs)
      PostTiming.create!(
        topic_id: post.topic_id,
        post_number: post.post_number,
        user_id: user.id,
        msecs: msecs,
      )
    end

    def post_timing_msecs_for(post, user)
      PostTiming.where(
        topic_id: post.topic_id,
        post_number: post.post_number,
        user_id: user.id,
      ).pluck(:msecs)[
        0
      ] || 0
    end

    it ""merges post timings"" do
      post1 = p1
      post2 = p2
      post3 = p3
      post4 = p4

      create_post_timing(post1, source_user, 12_345)
      create_post_timing(post2, source_user, 9876)
      create_post_timing(post4, source_user, 2**31 - 100)
      create_post_timing(post2, target_user, 3333)
      create_post_timing(post3, target_user, 10_000)
      create_post_timing(post4, target_user, 5000)

      merge_users!

      expect(post_timing_msecs_for(post1, target_user)).to eq(12_345)
      expect(post_timing_msecs_for(post2, target_user)).to eq(13_209)
      expect(post_timing_msecs_for(post3, target_user)).to eq(10_000)
      expect(post_timing_msecs_for(post4, target_user)).to eq(2**31 - 1)

      expect(PostTiming.where(user_id: source_user.id).count).to eq(0)
    end
  end

  context ""with posts"" do
    it ""updates user ids of posts"" do
      source_user.update_attribute(:moderator, true)

      topic = Fabricate(:topic)
      Fabricate(:post, topic: topic, user: source_user)

      post2 = Fabricate(:basic_reply, topic: topic, user: walter)
      post2.revise(source_user, raw: ""#{post2.raw} foo"")
      PostLocker.new(post2, source_user).lock
      post2.trash!(source_user)

      merge_users!
      post2.reload

      expect(post2.deleted_by).to eq(target_user)
      expect(post2.last_editor).to eq(target_user)
      expect(post2.locked_by_id).to eq(target_user.id)
      expect(post2.reply_to_user).to eq(target_user)
    end

    it ""updates post action counts"" do
      posts = {}

      PostActionType.types.each do |type_name, type_id|
        posts[type_name] = post = Fabricate(:post, user: walter)
        PostActionCreator.new(source_user, post, type_id).perform
        PostActionCreator.new(target_user, post, type_id).perform
      end

      merge_users!

      posts.each do |type, post|
        post.reload
        expect(post.public_send(""#{type}_count"")).to eq(1)
      end
    end
  end

  it ""updates reviewables and reviewable history"" do
    reviewable = Fabricate(:reviewable_queued_post, created_by: source_user)

    merge_users!

    expect(reviewable.reload.created_by).to eq(target_user)
    expect(reviewable.reviewable_histories.first.created_by).to eq(target_user)
  end

  describe ""search logs"" do
    after { SearchLog.clear_debounce_cache! }

    it ""updates search log entries"" do
      SearchLog.log(
        term: ""hello"",
        search_type: :full_page,
        ip_address: ""192.168.0.1"",
        user_id: source_user.id,
      )
      SearchLog.log(
        term: ""world"",
        search_type: :full_page,
        ip_address: ""192.168.0.1"",
        user_id: source_user.id,
      )
      SearchLog.log(
        term: ""star trek"",
        search_type: :full_page,
        ip_address: ""192.168.0.2"",
        user_id: target_user.id,
      )
      SearchLog.log(
        term: ""bad"",
        search_type: :full_page,
        ip_address: ""192.168.0.3"",
        user_id: walter.id,
      )

      merge_users!

      expect(SearchLog.where(user_id: target_user.id).count).to eq(3)
      expect(SearchLog.where(user_id: source_user.id).count).to eq(0)
      expect(SearchLog.where(user_id: walter.id).count).to eq(1)
    end
  end

  it ""merges tag notification settings"" do
    tag1 = Fabricate(:tag)
    tag2 = Fabricate(:tag)
    tag3 = Fabricate(:tag)
    watching = TagUser.notification_levels[:watching]

    TagUser.batch_set(source_user, :watching, [tag1.name, tag2.name])
    TagUser.batch_set(target_user, :watching, [tag2.name, tag3.name])

    merge_users!

    tag_ids = TagUser.where(user_id: target_user.id, notification_level: watching).pluck(:tag_id)
    expect(tag_ids).to contain_exactly(tag1.id, tag2.id, tag3.id)

    tag_ids = TagUser.where(user_id: source_user.id, notification_level: watching).pluck(:tag_id)
    expect(tag_ids).to be_empty
  end

  it ""updates themes"" do
    theme = Fabricate(:theme, user: source_user)
    merge_users!

    expect(theme.reload.user_id).to eq(target_user.id)
  end

  it ""merges allowed users for topics"" do
    pm_topic1 =
      Fabricate(
        :private_message_topic,
        topic_allowed_users: [
          Fabricate.build(:topic_allowed_user, user: target_user),
          Fabricate.build(:topic_allowed_user, user: walter),
          Fabricate.build(:topic_allowed_user, user: source_user),
        ],
      )

    pm_topic2 =
      Fabricate(
        :private_message_topic,
        topic_allowed_users: [
          Fabricate.build(:topic_allowed_user, user: walter),
          Fabricate.build(:topic_allowed_user, user: source_user),
        ],
      )

    merge_users!

    expect(pm_topic1.allowed_users).to contain_exactly(target_user, walter)
    expect(pm_topic2.allowed_users).to contain_exactly(target_user, walter)
    expect(TopicAllowedUser.where(user_id: source_user.id).count).to eq(0)
  end

  it ""updates topic embeds"" do
    topic_embed = Fabricate(:topic_embed, embed_url: ""http://example.com/post/248"")
    topic_embed.trash!(source_user)

    merge_users!

    expect(topic_embed.reload.deleted_by).to eq(target_user)
  end

  it ""updates topic links"" do
    topic = Fabricate(:topic, user: source_user)
    post = Fabricate(:post_with_external_links, user: source_user, topic: topic)
    TopicLink.extract_from(post)
    link = topic.topic_links.first

    TopicLinkClick.create!(topic_link_id: link.id, user_id: source_user.id, ip_address: ""127.0.0.1"")
    TopicLinkClick.create!(topic_link_id: link.id, user_id: target_user.id, ip_address: ""127.0.0.1"")
    TopicLinkClick.create!(topic_link_id: link.id, user_id: walter.id, ip_address: ""127.0.0.1"")

    merge_users!

    expect(TopicLink.where(user_id: target_user.id).count).to be > 0
    expect(TopicLink.where(user_id: source_user.id).count).to eq(0)

    expect(TopicLinkClick.where(user_id: target_user.id).count).to eq(2)
    expect(TopicLinkClick.where(user_id: source_user.id).count).to eq(0)
    expect(TopicLinkClick.where(user_id: walter.id).count).to eq(1)
  end

  context ""with topic timers"" do
    def create_topic_timer(topic, user, status_type, deleted_by = nil)
      timer =
        Fabricate(
          :topic_timer,
          topic: topic,
          user: user,
          status_type: TopicTimer.types[status_type],
        )
      timer.trash!(deleted_by) if deleted_by
      timer.reload
    end

    it ""merges topic timers"" do
      topic1 = Fabricate(:topic)
      timer1 = create_topic_timer(topic1, source_user, :close, Discourse.system_user)
      timer2 = create_topic_timer(topic1, source_user, :close)
      timer3 = create_topic_timer(topic1, source_user, :reminder, source_user)
      timer4 = create_topic_timer(topic1, target_user, :reminder, target_user)
      timer5 = create_topic_timer(topic1, source_user, :reminder)

      topic2 = Fabricate(:topic)
      timer6 = create_topic_timer(topic2, target_user, :close)
      timer7 = create_topic_timer(topic2, target_user, :reminder, Discourse.system_user)
      create_topic_timer(topic2, source_user, :reminder, Discourse.system_user)

      merge_users!

      [timer1, timer2, timer3, timer4, timer5, timer6, timer7].each do |t|
        expect(t.reload.user).to eq(target_user)
      end

      expect(TopicTimer.with_deleted.where(user_id: source_user.id).count).to eq(0)
      expect(TopicTimer.with_deleted.where(deleted_by_id: target_user.id).count).to eq(2)
      expect(TopicTimer.with_deleted.where(deleted_by_id: source_user.id).count).to eq(0)
    end
  end

  it ""merges topic notification settings"" do
    topic1 = Fabricate(:topic)
    topic2 = Fabricate(:topic)
    topic3 = Fabricate(:topic)
    watching = TopicUser.notification_levels[:watching]

    Fabricate(:topic_user, notification_level: watching, topic: topic1, user: source_user)
    Fabricate(:topic_user, notification_level: watching, topic: topic2, user: source_user)
    Fabricate(:topic_user, notification_level: watching, topic: topic2, user: target_user)
    Fabricate(:topic_user, notification_level: watching, topic: topic3, user: target_user)

    merge_users!

    topic_ids =
      TopicUser.where(user_id: target_user.id, notification_level: watching).pluck(:topic_id)
    expect(topic_ids).to contain_exactly(topic1.id, topic2.id, topic3.id)

    topic_ids =
      TopicUser.where(user_id: source_user.id, notification_level: watching).pluck(:topic_id)
    expect(topic_ids).to be_empty
  end

  it ""merges topic views"" do
    topic1 = Fabricate(:topic)
    topic2 = Fabricate(:topic)
    topic3 = Fabricate(:topic)
    ip = ""127.0.0.1""

    TopicViewItem.add(topic1.id, ip, source_user.id)
    TopicViewItem.add(topic2.id, ip, source_user.id)
    TopicViewItem.add(topic2.id, ip, target_user.id)
    TopicViewItem.add(topic3.id, ip, target_user.id)

    merge_users!

    topic_ids = TopicViewItem.where(user_id: target_user.id).pluck(:topic_id)
    expect(topic_ids).to contain_exactly(topic1.id, topic2.id, topic3.id)
    expect(TopicViewItem.where(user_id: source_user.id).count).to eq(0)
  end

  it ""updates topics"" do
    topic = Fabricate(:topic)
    Fabricate(:post, user: walter, topic: topic)
    Fabricate(:post, user: source_user, topic: topic)
    topic.trash!(source_user)

    merge_users!
    topic.reload

    expect(topic.deleted_by).to eq(target_user)
    expect(topic.last_poster).to eq(target_user)
  end

  it ""updates unsubscribe keys"" do
    UnsubscribeKey.create_key_for(source_user, UnsubscribeKey::DIGEST_TYPE)
    UnsubscribeKey.create_key_for(target_user, UnsubscribeKey::DIGEST_TYPE)
    UnsubscribeKey.create_key_for(walter, UnsubscribeKey::DIGEST_TYPE)

    merge_users!

    expect(UnsubscribeKey.where(user_id: target_user.id).count).to eq(2)
    expect(UnsubscribeKey.where(user_id: source_user.id).count).to eq(0)
  end

  it ""updates uploads"" do
    Fabricate(:upload, user: source_user)
    Fabricate(:upload, user: target_user)
    Fabricate(:upload, user: walter)

    merge_users!

    expect(Upload.where(user_id: target_user.id).count).to eq(2)
    expect(Upload.where(user_id: source_user.id).count).to eq(0)
  end

  context ""with user actions"" do
    # action_type and user_id are not nullable
    # target_topic_id and acting_user_id are nullable, but always have a value

    fab!(:post1) { p1 }
    fab!(:post2) { p2 }

    def log_like_action(acting_user, user, post)
      UserAction.log_action!(
        action_type: UserAction::LIKE,
        user_id: user.id,
        acting_user_id: acting_user.id,
        target_topic_id: post.topic_id,
        target_post_id: post.id,
      )
    end

    def log_got_private_message(acting_user, user, topic)
      UserAction.log_action!(
        action_type: UserAction::GOT_PRIVATE_MESSAGE,
        user_id: user.id,
        acting_user_id: acting_user.id,
        target_topic_id: topic.id,
        target_post_id: -1,
      )
    end

    it ""merges when target_post_id is set"" do
      _a1 = log_like_action(source_user, walter, post1)
      a2 = log_like_action(target_user, walter, post1)
      a3 = log_like_action(source_user, walter, post2)

      merge_users!

      expect(UserAction.count).to eq(2)

      action_ids =
        UserAction.where(
          action_type: UserAction::LIKE,
          user_id: walter.id,
          acting_user_id: target_user.id,
        ).pluck(:id)
      expect(action_ids).to contain_exactly(a2.id, a3.id)
    end

    it ""merges when acting_user is neither source_user nor target_user"" do
      pm_topic1 =
        Fabricate(
          :private_message_topic,
          topic_allowed_users: [
            Fabricate.build(:topic_allowed_user, user: walter),
            Fabricate.build(:topic_allowed_user, user: source_user),
            Fabricate.build(:topic_allowed_user, user: target_user),
            Fabricate.build(:topic_allowed_user, user: coding_horror),
          ],
        )

      pm_topic2 =
        Fabricate(
          :private_message_topic,
          topic_allowed_users: [
            Fabricate.build(:topic_allowed_user, user: walter),
            Fabricate.build(:topic_allowed_user, user: source_user),
          ],
        )

      pm_topic3 =
        Fabricate(
          :private_message_topic,
          topic_allowed_users: [
            Fabricate.build(:topic_allowed_user, user: walter),
            Fabricate.build(:topic_allowed_user, user: target_user),
          ],
        )

      _a1 = log_got_private_message(walter, source_user, pm_topic1)
      a2 = log_got_private_message(walter, target_user, pm_topic1)
      _a3 = log_got_private_message(walter, coding_horror, pm_topic1)
      a4 = log_got_private_message(walter, source_user, pm_topic2)
      a5 = log_got_private_message(walter, target_user, pm_topic3)

      merge_users!

      expect(UserAction.count).to eq(4)

      action_ids =
        UserAction.where(
          action_type: UserAction::GOT_PRIVATE_MESSAGE,
          user_id: target_user.id,
          acting_user_id: walter.id,
        ).pluck(:id)
      expect(action_ids).to contain_exactly(a2.id, a4.id, a5.id)
    end
  end

  it ""merges archived messages"" do
    pm_topic1 =
      Fabricate(
        :private_message_topic,
        topic_allowed_users: [
          Fabricate.build(:topic_allowed_user, user: target_user),
          Fabricate.build(:topic_allowed_user, user: walter),
          Fabricate.build(:topic_allowed_user, user: source_user),
        ],
      )

    pm_topic2 =
      Fabricate(
        :private_message_topic,
        topic_allowed_users: [
          Fabricate.build(:topic_allowed_user, user: walter),
          Fabricate.build(:topic_allowed_user, user: source_user),
        ],
      )

    UserArchivedMessage.archive!(source_user.id, pm_topic1)
    UserArchivedMessage.archive!(target_user.id, pm_topic1)
    UserArchivedMessage.archive!(source_user.id, pm_topic2)
    UserArchivedMessage.archive!(walter.id, pm_topic2)

    merge_users!

    topic_ids = UserArchivedMessage.where(user_id: target_user.id).pluck(:topic_id)
    expect(topic_ids).to contain_exactly(pm_topic1.id, pm_topic2.id)
    expect(UserArchivedMessage.where(user_id: source_user.id).count).to eq(0)
  end

  context ""with badges"" do
    def create_badge(badge, user, opts = {})
      UserBadge.create!(
        badge: badge,
        user: user,
        granted_by: opts[:granted_by] || Discourse.system_user,
        granted_at: opts[:granted_at] || Time.now,
        post: opts[:post],
        seq: opts[:seq] || 0,
      )
    end

    it ""merges user badges"" do
      anniversary_badge = Badge.find(Badge::Anniversary)
      create_badge(anniversary_badge, source_user, seq: 1)
      b1 = create_badge(anniversary_badge, target_user, seq: 1)
      b2 = create_badge(anniversary_badge, source_user, seq: 2)

      great_post_badge = Badge.find(Badge::GreatPost)
      b3 = create_badge(great_post_badge, target_user, post: Fabricate(:post, user: target_user))
      b4 = create_badge(great_post_badge, source_user, post: Fabricate(:post, user: source_user))

      autobiographer_badge = Badge.find(Badge::Autobiographer)
      b5 = create_badge(autobiographer_badge, source_user)

      merge_users!

      user_badge_ids = UserBadge.where(user_id: target_user.id).pluck(:id)
      expect(user_badge_ids).to contain_exactly(b1.id, b2.id, b3.id, b4.id, b5.id)
      expect(UserBadge.where(user_id: source_user.id).count).to eq(0)
    end

    it ""updates granted_by for user badges"" do
      badge = Badge.create!(name: ""Hero"", badge_type_id: BadgeType::Gold)
      user_badge = create_badge(badge, walter, seq: 1, granted_by: source_user)

      merge_users!

      expect(user_badge.reload.granted_by).to eq(target_user)
    end
  end

  it ""merges user custom fields"" do
    UserCustomField.create!(user_id: source_user.id, name: ""foo"", value: ""123"")
    UserCustomField.create!(user_id: source_user.id, name: ""bar"", value: ""456"")
    UserCustomField.create!(user_id: source_user.id, name: ""duplicate"", value: ""source"")
    UserCustomField.create!(user_id: target_user.id, name: ""duplicate"", value: ""target"")
    UserCustomField.create!(user_id: target_user.id, name: ""baz"", value: ""789"")

    merge_users!

    fields = UserCustomField.where(user_id: target_user.id).pluck(:name, :value)
    expect(fields).to contain_exactly(%w[foo 123], %w[bar 456], %w[duplicate target], %w[baz 789])
    expect(UserCustomField.where(user_id: source_user.id).count).to eq(0)
  end

  it ""merges email addresses"" do
    merge_users!

    emails = UserEmail.where(user_id: target_user.id).pluck(:email, :primary)
    expect(emails).to contain_exactly([""alice@example.com"", true], [""alice@work.com"", false])
    expect(UserEmail.where(user_id: source_user.id).count).to eq(0)
  end

  it ""skips merging email addresses when a secondary email address exists"" do
    merge_users!(source_user, target_user)

    alice2 = Fabricate(:user, username: ""alice2"", email: ""alice@foo.com"")
    merge_users!(alice2, target_user)

    emails = UserEmail.where(user_id: target_user.id).pluck(:email, :primary)
    expect(emails).to contain_exactly([""alice@example.com"", true], [""alice@work.com"", false])
    expect(UserEmail.where(user_id: source_user.id).count).to eq(0)
  end

  it ""skips merging email addresses when target user is not human"" do
    target_user = Discourse.system_user
    merge_users!(source_user, target_user)

    emails = UserEmail.where(user_id: target_user.id).pluck(:email, :primary)
    expect(emails).to contain_exactly([target_user.email, true])
    expect(UserEmail.exists?(user_id: source_user.id)).to eq(false)
  end

  it ""updates exports"" do
    UserExport.create(file_name: ""user-archive-alice1-190218-003249"", user_id: source_user.id)

    merge_users!

    expect(UserExport.where(user_id: target_user.id).count).to eq(1)
    expect(UserExport.where(user_id: source_user.id).count).to eq(0)
  end

  it ""updates user history"" do
    UserHistory.create(
      action: UserHistory.actions[:notified_about_get_a_room],
      target_user_id: source_user.id,
    )
    UserHistory.create(
      action: UserHistory.actions[:anonymize_user],
      target_user_id: walter.id,
      acting_user_id: source_user.id,
    )

    merge_users!
    UserHistory.where(
      action: UserHistory.actions[:merge_user],
      target_user_id: target_user.id,
    ).delete_all

    expect(UserHistory.where(target_user_id: target_user.id).count).to eq(1)
    expect(UserHistory.where(target_user_id: source_user.id).count).to eq(0)

    expect(UserHistory.where(acting_user_id: target_user.id).count).to eq(1)
    expect(UserHistory.where(acting_user_id: source_user.id).count).to eq(0)
  end

  it ""updates user profile views"" do
    ip = ""127.0.0.1""
    UserProfileView.add(source_user.id, ip, walter.id, Time.now, true)
    UserProfileView.add(source_user.id, ip, target_user.id, Time.now, true)
    UserProfileView.add(target_user.id, ip, source_user.id, Time.now, true)
    UserProfileView.add(walter.id, ip, source_user.id, Time.now, true)

    merge_users!

    expect(UserProfileView.where(user_profile_id: target_user.id).count).to eq(3)
    expect(UserProfileView.where(user_profile_id: walter.id).count).to eq(1)
    expect(UserProfileView.where(user_profile_id: source_user.id).count).to eq(0)

    expect(UserProfileView.where(user_id: target_user.id).count).to eq(3)
    expect(UserProfileView.where(user_id: walter.id).count).to eq(1)
    expect(UserProfileView.where(user_id: source_user.id).count).to eq(0)
  end

  it ""merges user visits"" do
    freeze_time DateTime.parse(""2010-01-01 12:00"")

    UserVisit.create!(
      user_id: source_user.id,
      visited_at: 2.days.ago,
      posts_read: 22,
      mobile: false,
      time_read: 400,
    )
    UserVisit.create!(
      user_id: source_user.id,
      visited_at: Date.yesterday,
      posts_read: 8,
      mobile: false,
      time_read: 100,
    )
    UserVisit.create!(
      user_id: target_user.id,
      visited_at: Date.yesterday,
      posts_read: 12,
      mobile: true,
      time_read: 270,
    )
    UserVisit.create!(
      user_id: target_user.id,
      visited_at: Date.today,
      posts_read: 10,
      mobile: true,
      time_read: 150,
    )

    merge_users!

    expect(UserVisit.where(user_id: target_user.id).count).to eq(3)
    expect(UserVisit.where(user_id: source_user.id).count).to eq(0)

    expect(
      UserVisit.where(
        user_id: target_user.id,
        visited_at: 2.days.ago,
        posts_read: 22,
        mobile: false,
        time_read: 400,
      ).count,
    ).to eq(1)
    expect(
      UserVisit.where(
        user_id: target_user.id,
        visited_at: Date.yesterday,
        posts_read: 20,
        mobile: true,
        time_read: 370,
      ).count,
    ).to eq(1)
    expect(
      UserVisit.where(
        user_id: target_user.id,
        visited_at: Date.today,
        posts_read: 10,
        mobile: true,
        time_read: 150,
      ).count,
    ).to eq(1)
  end

  it ""updates user warnings"" do
    UserWarning.create!(topic: Fabricate(:topic), user: source_user, created_by: walter)
    UserWarning.create!(topic: Fabricate(:topic), user: target_user, created_by: walter)
    UserWarning.create!(topic: Fabricate(:topic), user: walter, created_by: source_user)

    merge_users!

    expect(UserWarning.where(user_id: target_user.id).count).to eq(2)
    expect(UserWarning.where(user_id: source_user.id).count).to eq(0)

    expect(UserWarning.where(created_by_id: target_user.id).count).to eq(1)
    expect(UserWarning.where(created_by_id: source_user.id).count).to eq(0)
  end

  it ""triggers :merging_users event"" do
    events = DiscourseEvent.track_events { merge_users! }

    expect(events).to include(event_name: :merging_users, params: [source_user, target_user])
  end

  context ""with site settings"" do
    it ""updates usernames in site settings"" do
      SiteSetting.site_contact_username = source_user.username
      SiteSetting.embed_by_username = source_user.username

      merge_users!

      expect(SiteSetting.site_contact_username).to eq(target_user.username)
      expect(SiteSetting.embed_by_username).to eq(target_user.username)
    end

    it ""updates only the old username in site settings"" do
      SiteSetting.site_contact_username = source_user.username
      SiteSetting.embed_by_username = walter.username

      merge_users!

      expect(SiteSetting.site_contact_username).to eq(target_user.username)
      expect(SiteSetting.embed_by_username).to eq(walter.username)
    end
  end

  it ""updates users"" do
    walter.update!(approved_by: source_user)
    upload = Fabricate(:upload)

    source_user.update!(admin: true)

    source_user.user_profile.update!(
      card_background_upload: upload,
      profile_background_upload: upload,
    )

    merge_users!

    expect(walter.reload.approved_by).to eq(target_user)

    target_user.reload

    expect(target_user.admin).to eq(true)
    expect(target_user.card_background_upload).to eq(upload)
    expect(target_user.profile_background_upload).to eq(upload)
  end

  it ""deletes the source user even when it's an admin"" do
    source_user.update_attribute(:admin, true)

    expect(User.find_by_username(source_user.username)).to be_present
    merge_users!
    expect(User.find_by_username(source_user.username)).to be_nil
  end

  it ""deletes the source user even when it is a member of a group that grants a trust level"" do
    group = Fabricate(:group, grant_trust_level: 3)
    group.bulk_add([source_user.id, target_user.id])

    merge_users!

    expect(User.find_by_username(source_user.username)).to be_nil
  end

  it ""works even when email domains are restricted"" do
    SiteSetting.allowed_email_domains = ""example.com|work.com""
    source_user.update_attribute(:admin, true)

    expect(User.find_by_username(source_user.username)).to be_present
    merge_users!
    expect(User.find_by_username(source_user.username)).to be_nil
  end

  it ""deletes external auth infos of source user"" do
    UserAssociatedAccount.create(
      user_id: source_user.id,
      provider_name: ""facebook"",
      provider_uid: ""1234"",
    )
    SingleSignOnRecord.create(
      user_id: source_user.id,
      external_id: ""example"",
      last_payload: ""looks good"",
    )

    merge_users!

    expect(UserAssociatedAccount.where(user_id: source_user.id).count).to eq(0)
    expect(SingleSignOnRecord.where(user_id: source_user.id).count).to eq(0)
  end

  it ""deletes auth tokens"" do
    Fabricate(:api_key, user: source_user)
    Fabricate(:readonly_user_api_key, user: source_user)
    Fabricate(:user_second_factor_totp, user: source_user)

    SiteSetting.verbose_auth_token_logging = true
    UserAuthToken.generate!(user_id: source_user.id, user_agent: ""Firefox"", client_ip: ""127.0.0.1"")

    merge_users!

    expect(ApiKey.where(user_id: source_user.id).count).to eq(0)
    expect(UserApiKey.where(user_id: source_user.id).count).to eq(0)
    expect(UserSecondFactor.where(user_id: source_user.id).count).to eq(0)
    expect(UserAuthToken.where(user_id: source_user.id).count).to eq(0)
    expect(UserAuthTokenLog.where(user_id: source_user.id).count).to eq(0)
  end

  it ""cleans up all remaining references to the source user"" do
    DirectoryItem.refresh!
    Fabricate(:email_change_request, user: source_user)
    Fabricate(:email_token, user: source_user)
    Fabricate(:user_avatar, user: source_user)

    merge_users!

    expect(DirectoryItem.where(user_id: source_user.id).count).to eq(0)
    expect(EmailChangeRequest.where(user_id: source_user.id).count).to eq(0)
    expect(EmailToken.where(user_id: source_user.id).count).to eq(0)
    expect(UserAvatar.where(user_id: source_user.id).count).to eq(0)

    expect(User.find_by_username(source_user.username)).to be_nil
  end

  it ""updates the username"" do
    Jobs::UpdateUsername
      .any_instance
      .expects(:execute)
      .with(
        {
          user_id: source_user.id,
          old_username: ""alice1"",
          new_username: ""alice"",
          avatar_template: target_user.avatar_template,
        },
      )
      .once

    merge_users!
  end

  it ""correctly logs the merge"" do
    expect { merge_users! }.to change { UserHistory.count }.by(1)

    log_entry = UserHistory.last
    expect(log_entry.action).to eq(UserHistory.actions[:merge_user])
    expect(log_entry.acting_user_id).to eq(Discourse::SYSTEM_USER_ID)
    expect(log_entry.target_user_id).to eq(target_user.id)
    expect(log_entry.context).to eq(
      I18n.t(""staff_action_logs.user_merged"", username: source_user.username),
    )
    expect(log_entry.email).to eq(""alice@work.com"")
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class PostAlerter
  USER_BATCH_SIZE = 100

  def self.post_created(post, opts = {})
    PostAlerter.new(opts).after_save_post(post, true)
    post
  end

  def self.post_edited(post, opts = {})
    PostAlerter.new(opts).after_save_post(post, false)
    post
  end

  def self.create_notification_alert(user:, post:, notification_type:, excerpt: nil, username: nil)
    return if user.suspended?

    if post_url = post.url
      payload = {
        notification_type: notification_type,
        post_number: post.post_number,
        topic_title: post.topic.title,
        topic_id: post.topic.id,
        excerpt:
          excerpt ||
            post.excerpt(
              400,
              text_entities: true,
              strip_links: true,
              remap_emoji: true,
              plain_hashtags: true,
            ),
        username: username || post.username,
        post_url: post_url,
      }

      DiscourseEvent.trigger(:pre_notification_alert, user, payload)

      if user.allow_live_notifications?
        MessageBus.publish(""/notification-alert/#{user.id}"", payload, user_ids: [user.id])
      end

      push_notification(user, payload)

      # deprecated. use push_notification instead
      DiscourseEvent.trigger(:post_notification_alert, user, payload)
    end
  end

  def self.push_notification(user, payload)
    return if user.do_not_disturb?

    DiscoursePluginRegistry.push_notification_filters.each do |filter|
      return unless filter.call(user, payload)
    end

    if user.push_subscriptions.exists?
      if user.seen_since?(SiteSetting.push_notification_time_window_mins.minutes.ago)
        delay =
          (SiteSetting.push_notification_time_window_mins - (Time.now - user.last_seen_at) / 60)
        Jobs.enqueue_in(delay.minutes, :send_push_notification, user_id: user.id, payload: payload)
      else
        Jobs.enqueue(:send_push_notification, user_id: user.id, payload: payload)
      end
    end

    if SiteSetting.allow_user_api_key_scopes.split(""|"").include?(""push"") &&
         SiteSetting.allowed_user_api_push_urls.present?
      clients =
        user
          .user_api_keys
          .joins(:scopes)
          .where(""user_api_key_scopes.name IN ('push', 'notifications')"")
          .where(""push_url IS NOT NULL AND push_url <> ''"")
          .where(""position(push_url IN ?) > 0"", SiteSetting.allowed_user_api_push_urls)
          .where(""revoked_at IS NULL"")
          .order(client_id: :asc)
          .pluck(:client_id, :push_url)

      if clients.length > 0
        Jobs.enqueue(:push_notification, clients: clients, payload: payload, user_id: user.id)
      end
    end

    DiscourseEvent.trigger(:push_notification, user, payload)
  end

  def initialize(default_opts = {})
    @default_opts = default_opts
  end

  def not_allowed?(user, post)
    user.blank? || user.bot? || user.id == post.user_id
  end

  def all_allowed_users(post)
    @all_allowed_users ||= post.topic.all_allowed_users.reject { |u| not_allowed?(u, post) }
  end

  def allowed_users(post)
    @allowed_users ||= post.topic.allowed_users.reject { |u| not_allowed?(u, post) }
  end

  def allowed_group_users(post)
    @allowed_group_users ||= post.topic.allowed_group_users.reject { |u| not_allowed?(u, post) }
  end

  def directly_targeted_users(post)
    allowed_users(post) - allowed_group_users(post)
  end

  def indirectly_targeted_users(post)
    allowed_group_users(post)
  end

  def only_allowed_users(users, post)
    return users unless post.topic.private_message?
    users.select { |u| all_allowed_users(post).include?(u) }
  end

  def notify_about_reply?(post)
    # small actions can be whispers in this case they will have an action code
    # we never want to notify on this
    post.post_type == Post.types[:regular] ||
      (post.post_type == Post.types[:whisper] && post.action_code.nil?)
  end

  def after_save_post(post, new_record = false)
    notified = [post.user, post.last_editor].uniq

    DiscourseEvent.trigger(:post_alerter_before_mentions, post, new_record, notified)

    # mentions (users/groups)
    mentioned_groups, mentioned_users, mentioned_here = extract_mentions(post)

    if mentioned_groups || mentioned_users || mentioned_here
      mentioned_opts = {}
      editor = post.last_editor

      if post.last_editor_id != post.user_id
        # Mention comes from an edit by someone else, so notification should say who added the mention.
        mentioned_opts = {
          user_id: editor.id,
          original_username: editor.username,
          display_username: editor.username,
        }
      end

      if mentioned_users
        mentioned_users = only_allowed_users(mentioned_users, post)
        mentioned_users = mentioned_users - pm_watching_users(post)
        notified += notify_users(mentioned_users - notified, :mentioned, post, mentioned_opts)
      end

      expand_group_mentions(mentioned_groups, post) do |group, users|
        users = only_allowed_users(users, post)
        to_notify =
          DiscoursePluginRegistry.apply_modifier(
            :expand_group_mention_users,
            users - notified,
            group,
          )

        notified +=
          notify_users(to_notify, :group_mentioned, post, mentioned_opts.merge(group: group))
      end

      if mentioned_here
        users = expand_here_mention(post, exclude_ids: notified.map(&:id))
        users = only_allowed_users(users, post)
        notified += notify_users(users - notified, :mentioned, post, mentioned_opts)
      end
    end

    DiscourseEvent.trigger(:post_alerter_before_replies, post, new_record, notified)

    # replies
    reply_to_user = post.reply_notification_target

    if new_record && notify_about_reply?(post)
      if reply_to_user && !notified.include?(reply_to_user)
        notified += notify_non_pm_users(reply_to_user, :replied, post)
      end

      topic_author = post.topic.user
      if topic_author && !notified.include?(topic_author) &&
           user_watching_topic?(topic_author, post.topic)
        notified += notify_non_pm_users(topic_author, :replied, post)
      end
    end

    DiscourseEvent.trigger(:post_alerter_before_quotes, post, new_record, notified)

    # quotes
    quoted_users = extract_quoted_users(post)
    notified += notify_non_pm_users(quoted_users - notified, :quoted, post)

    DiscourseEvent.trigger(:post_alerter_before_linked, post, new_record, notified)

    # linked
    linked_users = extract_linked_users(post)
    notified += notify_non_pm_users(linked_users - notified, :linked, post)

    DiscourseEvent.trigger(:post_alerter_before_post, post, new_record, notified)

    notified = notified + category_or_tag_muters(post.topic)

    if new_record
      if post.topic.private_message?
        # private messages
        notified += notify_pm_users(post, reply_to_user, quoted_users, notified, new_record)
      elsif notify_about_reply?(post)
        # posts
        notified +=
          notify_post_users(
            post,
            notified,
            new_record: new_record,
            include_category_watchers: false,
            include_tag_watchers: false,
          )
        notified +=
          notify_post_users(
            post,
            notified,
            new_record: new_record,
            include_topic_watchers: false,
            notification_type: :watching_category_or_tag,
          )
      end
    end

    sync_group_mentions(post, mentioned_groups)

    DiscourseEvent.trigger(:post_alerter_before_first_post, post, new_record, notified)

    if new_record && post.post_number == 1
      topic = post.topic

      if topic.present?
        watchers = category_watchers(topic) + tag_watchers(topic) + group_watchers(topic)
        # Notify only users who can see the topic
        watchers &= topic.all_allowed_users.pluck(:id) if post.topic.private_message?
        notified += notify_first_post_watchers(post, watchers, notified)
      end
    end

    DiscourseEvent.trigger(:post_alerter_after_save_post, post, new_record, notified)
  end

  def group_watchers(topic)
    GroupUser.where(
      group_id: topic.allowed_groups.pluck(:group_id),
      notification_level: GroupUser.notification_levels[:watching_first_post],
    ).pluck(:user_id)
  end

  def tag_watchers(topic)
    topic
      .tag_users
      .notification_level_visible([TagUser.notification_levels[:watching_first_post]])
      .distinct(:user_id)
      .pluck(:user_id)
  end

  def category_watchers(topic)
    topic
      .category_users
      .where(notification_level: CategoryUser.notification_levels[:watching_first_post])
      .pluck(:user_id)
  end

  def category_or_tag_muters(topic)
    user_option_condition_sql_fragment =
      if SiteSetting.watched_precedence_over_muted
        ""uo.watched_precedence_over_muted IS false""
      else
        ""(uo.watched_precedence_over_muted IS NULL OR uo.watched_precedence_over_muted IS false)""
      end

    user_ids_sql = <<~SQL
        SELECT uo.user_id FROM user_options uo
        LEFT JOIN topic_users tus ON tus.user_id = uo.user_id AND tus.topic_id = #{topic.id}
        LEFT JOIN category_users cu ON cu.user_id = uo.user_id AND cu.category_id = #{topic.category_id.to_i}
        LEFT JOIN tag_users tu ON tu.user_id = uo.user_id
        JOIN topic_tags tt ON tt.tag_id = tu.tag_id AND tt.topic_id = #{topic.id}
        WHERE
          (tus.id IS NULL OR tus.notification_level != #{TopicUser.notification_levels[:watching]})
          AND (cu.notification_level = #{CategoryUser.notification_levels[:muted]} OR tu.notification_level = #{TagUser.notification_levels[:muted]})
          AND #{user_option_condition_sql_fragment}
        SQL

    User.where(""id IN (#{user_ids_sql})"")
  end

  def notify_first_post_watchers(post, user_ids, notified = nil)
    return [] if user_ids.blank?
    user_ids.uniq!

    warn_if_not_sidekiq

    # Don't notify the OP and last editor
    user_ids -= [post.user_id, post.last_editor_id]
    users = User.where(id: user_ids).includes(:do_not_disturb_timings)
    users = users.where.not(id: notified.map(&:id)) if notified.present?

    DiscourseEvent.trigger(:before_create_notifications_for_users, users, post)
    each_user_in_batches(users) do |user|
      create_notification(user, Notification.types[:watching_first_post], post)
    end

    users
  end

  def sync_group_mentions(post, mentioned_groups)
    GroupMention.where(post_id: post.id).destroy_all
    return if mentioned_groups.blank?

    now = Time.zone.now

    # insert_all instead of insert_all! since multiple post_alert jobs might be
    # running concurrently
    GroupMention.insert_all(
      mentioned_groups.map do |group|
        { post_id: post.id, group_id: group.id, created_at: now, updated_at: now }
      end,
    )
  end

  def unread_posts(user, topic)
    Post
      .secured(Guardian.new(user))
      .where(
        ""post_number > COALESCE((
               SELECT last_read_post_number FROM topic_users tu
               WHERE tu.user_id = ? AND tu.topic_id = ? ),0)"",
        user.id,
        topic.id,
      )
      .where(
        ""reply_to_user_id = :user_id
        OR exists(SELECT 1 from topic_users tu
                  WHERE tu.user_id = :user_id AND
                    tu.topic_id = :topic_id AND
                    notification_level = :topic_level)
        OR exists(SELECT 1 from category_users cu
                  WHERE cu.user_id = :user_id AND
                    cu.category_id = :category_id AND
                    notification_level = :category_level)
        OR exists(SELECT 1 from tag_users tu
                  WHERE tu.user_id = :user_id AND
                    tu.tag_id IN (SELECT tag_id FROM topic_tags WHERE topic_id = :topic_id) AND
                    notification_level = :tag_level)"",
        user_id: user.id,
        topic_id: topic.id,
        category_id: topic.category_id,
        topic_level: TopicUser.notification_levels[:watching],
        category_level: CategoryUser.notification_levels[:watching],
        tag_level: TagUser.notification_levels[:watching],
      )
      .where(topic_id: topic.id)
  end

  def first_unread_post(user, topic)
    unread_posts(user, topic).order(""post_number"").first
  end

  def unread_count(user, topic)
    unread_posts(user, topic).count
  end

  def destroy_notifications(user, types, topic)
    return if user.blank?
    return unless Guardian.new(user).can_see?(topic)

    User.transaction do
      user.notifications.where(notification_type: types, topic_id: topic.id).destroy_all

      # Reload so notification counts sync up correctly
      user.reload
    end
  end

  NOTIFIABLE_TYPES =
    %i[
      mentioned
      replied
      quoted
      posted
      linked
      private_message
      group_mentioned
      watching_first_post
      watching_category_or_tag
      event_reminder
      event_invitation
    ].map { |t| Notification.types[t] }

  def group_stats(topic)
    sql = <<~SQL
      SELECT COUNT(*) FROM topics t
      JOIN topic_allowed_groups g ON g.group_id = :group_id AND g.topic_id = t.id
      LEFT JOIN group_archived_messages a ON a.topic_id = t.id AND a.group_id = g.group_id
      WHERE a.id IS NULL AND t.deleted_at is NULL AND t.archetype = 'private_message'
    SQL

    topic.allowed_groups.map do |g|
      {
        group_id: g.id,
        group_name: g.name,
        inbox_count: DB.query_single(sql, group_id: g.id).first.to_i,
      }
    end
  end

  def notify_group_summary(user, topic, acting_user_id: nil)
    @group_stats ||= {}
    stats = (@group_stats[topic.id] ||= group_stats(topic))
    return unless stats

    group_id = topic.topic_allowed_groups.where(group_id: user.groups).pick(:group_id)

    stat = stats.find { |s| s[:group_id] == group_id }
    return unless stat

    DistributedMutex.synchronize(""group_message_notify_#{user.id}"") do
      if stat[:inbox_count] > 0
        Notification.consolidate_or_create!(
          notification_type: Notification.types[:group_message_summary],
          user_id: user.id,
          read: user.id === acting_user_id ? true : false,
          data: {
            group_id: stat[:group_id],
            group_name: stat[:group_name],
            inbox_count: stat[:inbox_count],
            username: user.username_lower,
          }.to_json,
        )
      else
        Notification
          .where(user_id: user.id, notification_type: Notification.types[:group_message_summary])
          .where(""data::json ->> 'group_id' = ?"", stat[:group_id].to_s)
          .delete_all
      end
    end

    # TODO decide if it makes sense to also publish a desktop notification
  end

  def should_notify_edit?(notification, post, opts)
    notification.created_at < 1.day.ago ||
      notification.data_hash[""display_username""] !=
        (opts[:display_username].presence || post.user.username)
  end

  def should_notify_like?(user, notification)
    if user.user_option.like_notification_frequency ==
         UserOption.like_notification_frequency_type[:always]
      return true
    end
    if user.user_option.like_notification_frequency ==
         UserOption.like_notification_frequency_type[:first_time_and_daily] &&
         notification.created_at < 1.day.ago
      return true
    end
    false
  end

  def should_notify_previous?(user, post, notification, opts)
    case notification.notification_type
    when Notification.types[:edited]
      should_notify_edit?(notification, post, opts)
    when Notification.types[:liked]
      should_notify_like?(user, notification)
    else
      false
    end
  end

  COLLAPSED_NOTIFICATION_TYPES ||= [
    Notification.types[:replied],
    Notification.types[:posted],
    Notification.types[:private_message],
    Notification.types[:watching_category_or_tag],
  ]

  def create_notification(user, type, post, opts = {})
    opts = @default_opts.merge(opts)

    DiscourseEvent.trigger(:before_create_notification, user, type, post, opts)

    return if user.blank? || user.bot? || post.blank?
    return if (topic = post.topic).blank?

    is_liked = type == Notification.types[:liked]
    if is_liked &&
         user.user_option.like_notification_frequency ==
           UserOption.like_notification_frequency_type[:never]
      return
    end

    return if !Guardian.new(user).can_receive_post_notifications?(post)

    return if user.staged? && topic.category&.mailinglist_mirror?

    notifier_id = opts[:user_id] || post.user_id # xxxxx look at revision history
    if notifier_id &&
         UserCommScreener.new(
           acting_user_id: notifier_id,
           target_user_ids: user.id,
         ).ignoring_or_muting_actor?(user.id)
      return
    end

    # skip if muted on the topic
    if TopicUser.where(
         topic: topic,
         user: user,
         notification_level: TopicUser.notification_levels[:muted],
       ).exists?
      return
    end

    # skip if muted on the group
    if group = opts[:group]
      if GroupUser.where(
           group_id: opts[:group_id],
           user_id: user.id,
           notification_level: TopicUser.notification_levels[:muted],
         ).exists?
        return
      end
    end

    existing_notifications =
      user
        .notifications
        .order(""notifications.id DESC"")
        .where(topic_id: post.topic_id, post_number: post.post_number)
        .limit(10)

    # Don't notify the same user about the same type of notification on the same post
    existing_notification_of_same_type =
      existing_notifications.find { |n| n.notification_type == type }

    if existing_notification_of_same_type &&
         !should_notify_previous?(user, post, existing_notification_of_same_type, opts)
      return
    end

    # linked, quoted, mentioned, chat_quoted may be suppressed if you already have a reply notification
    if [
         Notification.types[:quoted],
         Notification.types[:linked],
         Notification.types[:mentioned],
         Notification.types[:chat_quoted],
       ].include?(type)
      if existing_notifications.find { |n| n.notification_type == Notification.types[:replied] }
        return
      end
    end

    collapsed = false

    if COLLAPSED_NOTIFICATION_TYPES.include?(type)
      destroy_notifications(user, COLLAPSED_NOTIFICATION_TYPES, topic)
      collapsed = true
    end

    original_post = post
    original_username = opts[:display_username].presence || post.username

    if collapsed
      post = first_unread_post(user, topic) || post
      count = unread_count(user, topic)
      if count > 1
        I18n.with_locale(user.effective_locale) do
          opts[:display_username] = I18n.t(""embed.replies"", count: count)
        end
      end
    end

    UserActionManager.notification_created(original_post, user, type, opts[:acting_user_id])

    topic_title = topic.title
    # when sending a private message email, keep the original title
    if topic.private_message? && modifications = post.revisions.map(&:modifications)
      if first_title_modification = modifications.find { |m| m.has_key?(""title"") }
        topic_title = first_title_modification[""title""][0]
      end
    end

    notification_data = {
      topic_title: topic_title,
      original_post_id: original_post.id,
      original_post_type: original_post.post_type,
      original_username: original_username,
      revision_number: opts[:revision_number],
      display_username: opts[:display_username] || post.user.username,
    }

    opts[:custom_data].each { |k, v| notification_data[k] = v } if opts[:custom_data]&.is_a?(Hash)

    if group = opts[:group]
      notification_data[:group_id] = group.id
      notification_data[:group_name] = group.name
    end

    if opts[:skip_send_email_to]&.include?(user.email)
      skip_send_email = true
    elsif original_post.via_email && (incoming_email = original_post.incoming_email)
      skip_send_email =
        incoming_email.to_addresses_split.include?(user.email) ||
          incoming_email.cc_addresses_split.include?(user.email)
    else
      skip_send_email = opts[:skip_send_email]
    end

    # Create the notification
    notification_data =
      DiscoursePluginRegistry.apply_modifier(:notification_data, notification_data)

    created =
      user.notifications.consolidate_or_create!(
        notification_type: type,
        topic_id: post.topic_id,
        post_number: post.post_number,
        post_action_id: opts[:post_action_id],
        data: notification_data.to_json,
        skip_send_email: skip_send_email,
      )

    if created.id && existing_notifications.empty? && NOTIFIABLE_TYPES.include?(type)
      create_notification_alert(
        user: user,
        post: original_post,
        notification_type: type,
        username: original_username,
      )
    end

    created.id ? created : nil
  end

  def create_notification_alert(user:, post:, notification_type:, excerpt: nil, username: nil)
    self.class.create_notification_alert(
      user: user,
      post: post,
      notification_type: notification_type,
      excerpt: excerpt,
      username: username,
    )
  end

  def push_notification(user, payload)
    self.class.push_notification(user, payload)
  end

  def expand_group_mentions(groups, post)
    return unless post.user && groups

    Group
      .mentionable(post.user, include_public: false)
      .where(id: groups.map(&:id))
      .each do |group|
        next if group.user_count >= SiteSetting.max_users_notified_per_group_mention
        yield group, group.users
      end
  end

  def expand_here_mention(post, exclude_ids: nil)
    posts = Post.where(topic_id: post.topic_id)
    posts = posts.where.not(user_id: exclude_ids) if exclude_ids.present?

    if post.user.staff?
      posts = posts.where(post_type: [Post.types[:regular], Post.types[:whisper]])
    else
      posts = posts.where(post_type: Post.types[:regular])
    end

    User.real.where(id: posts.select(:user_id)).limit(SiteSetting.max_here_mentioned)
  end

  # TODO: Move to post-analyzer?
  def extract_mentions(post)
    mentions = post.raw_mentions
    return if mentions.blank?

    groups = Group.where(""LOWER(name) IN (?)"", mentions)
    mentions -= groups.map(&:name).map(&:downcase)
    groups = nil if groups.empty?

    if mentions.present?
      users =
        User
          .where(username_lower: mentions)
          .includes(:do_not_disturb_timings)
          .where.not(id: post.user_id)
      users = nil if users.empty?
    end

    # @here can be a user mention and then this feature is disabled
    here = mentions.include?(SiteSetting.here_mention) && Guardian.new(post.user).can_mention_here?

    [groups, users, here]
  end

  # TODO: Move to post-analyzer?
  # Returns a list of users who were quoted in the post
  def extract_quoted_users(post)
    usernames =
      if SiteSetting.display_name_on_posts && !SiteSetting.prioritize_username_in_ux
        post.raw.scan(/username:([[:alnum:]]*)""(?=\])/)
      else
        post.raw.scan(/\[quote=\""([^,]+),.+\""\]/)
      end.uniq.map { |q| q.first.strip.downcase }
    User.where.not(id: post.user_id).where(username_lower: usernames)
  end

  def extract_linked_users(post)
    users =
      post
        .topic_links
        .where(reflection: false)
        .map do |link|
          linked_post = link.link_post
          if !linked_post && topic = link.link_topic
            linked_post = topic.posts.find_by(post_number: 1)
          end
          (linked_post && post.user_id != linked_post.user_id && linked_post.user) || nil
        end
        .compact

    DiscourseEvent.trigger(:after_extract_linked_users, users, post)

    users
  end

  # Notify a bunch of users
  def notify_non_pm_users(users, type, post, opts = {})
    return [] if post.topic&.private_message?

    notify_users(users, type, post, opts)
  end

  def notify_users(users, type, post, opts = {})
    users = [users] unless users.is_a?(Array)
    users.reject!(&:staged?) if post.topic&.private_message?

    warn_if_not_sidekiq

    DiscourseEvent.trigger(:before_create_notifications_for_users, users, post)
    users.each { |u| create_notification(u, Notification.types[type], post, opts) }

    users
  end

  def pm_watching_users(post)
    return [] if !post.topic.private_message?
    directly_targeted_users(post).filter do |u|
      notification_level = TopicUser.get(post.topic, u)&.notification_level
      notification_level == TopicUser.notification_levels[:watching]
    end
  end

  def notify_pm_users(post, reply_to_user, quoted_users, notified, new_record = false)
    return [] unless post.topic

    warn_if_not_sidekiq

    # To simplify things and to avoid IMAP double sync issues, and to cut down
    # on emails sent via SMTP, any topic_allowed_users (except those who are
    # not_allowed?) for a group that has SMTP enabled will have their notification
    # email combined into one and sent via a single group SMTP email with CC addresses.
    emails_to_skip_send = email_using_group_smtp_if_configured(post)

    # We create notifications for all directly_targeted_users and email those
    # who do _not_ have their email addresses in the emails_to_skip_send array
    # (which will include all topic allowed users' email addresses if group SMTP
    # is enabled).
    users = directly_targeted_users(post).reject { |u| notified.include?(u) }
    DiscourseEvent.trigger(:before_create_notifications_for_users, users, post)
    users.each do |user|
      if reply_to_user == user || pm_watching_users(post).include?(user) || user.staged?
        create_notification(
          user,
          Notification.types[:private_message],
          post,
          skip_send_email_to: emails_to_skip_send,
        )
      end
    end

    # Users that are part of all mentioned groups. Emails sent by this notification
    # flow will not be sent via group SMTP if it is enabled.
    users = indirectly_targeted_users(post).reject { |u| notified.include?(u) }
    DiscourseEvent.trigger(:before_create_notifications_for_users, users, post)
    users.each do |user|
      case TopicUser.get(post.topic, user)&.notification_level
      when TopicUser.notification_levels[:watching]
        create_pm_notification(user, post, emails_to_skip_send)
      when TopicUser.notification_levels[:tracking]
        # TopicUser is the canonical source of topic notification levels, except for
        # new topics created within a group with default notification level set to
        # `watching_first_post`. TopicUser notification level is set to `tracking`
        # for these.
        if is_replying?(user, reply_to_user, quoted_users) ||
             (new_record && group_watched_first_post?(user, post))
          create_pm_notification(user, post, emails_to_skip_send)
        else
          notify_group_summary(user, post.topic)
        end
      when TopicUser.notification_levels[:regular]
        if is_replying?(user, reply_to_user, quoted_users)
          create_pm_notification(user, post, emails_to_skip_send)
        end
      end
    end
  end

  def group_notifying_via_smtp(post)
    return if !SiteSetting.enable_smtp || post.post_type != Post.types[:regular]
    return if post.topic.allowed_groups.none?

    return post.topic.first_smtp_enabled_group if post.topic.allowed_groups.count == 1

    topic_incoming_email = post.topic.incoming_email.first
    return if topic_incoming_email.blank?

    group = Group.find_by_email(topic_incoming_email.to_addresses)
    return post.topic.first_smtp_enabled_group if !group&.smtp_enabled
    group
  end

  def email_using_group_smtp_if_configured(post)
    emails_to_skip_send = []
    group = group_notifying_via_smtp(post)
    return emails_to_skip_send if group.blank?

    to_address = nil
    cc_addresses = []

    # We need to use topic_allowed_users here instead of directly_targeted_users
    # because we want to make sure the to_address goes to the OP of the topic.
    topic_allowed_users_by_age =
      post
        .topic
        .topic_allowed_users
        .includes(:user)
        .order(:created_at)
        .reject { |tau| not_allowed?(tau.user, post) }
    return emails_to_skip_send if topic_allowed_users_by_age.empty?

    # This should usually be the OP of the topic, unless they are the one
    # replying by email (they are excluded by not_allowed? then)
    to_address = topic_allowed_users_by_age.first.user.email
    cc_addresses = topic_allowed_users_by_age[1..-1].map { |tau| tau.user.email }
    email_addresses = [to_address, cc_addresses].flatten

    # If any of these email addresses were cc address on the
    # incoming email for the target post, do not send them emails (they
    # already have been notified by the CC on the email)
    if post.incoming_email.present?
      cc_addresses = cc_addresses - post.incoming_email.cc_addresses_split

      # If the to address is one of the recently added CC addresses, then we
      # need to bail early, because otherwise we are sending a notification
      # email to the user who was just added by CC. In this case the OP probably
      # replied and CC'd some people, and they are the only other topic users.
      return if post.incoming_email.cc_addresses_split.include?(to_address)

      # We don't want to create an email storm if someone emails the group and
      # CC's 50 support addresses from various places, which all then respond
      # with auto-responders saying they have received our email. Any auto-generated
      # emails should not propagate notifications to anyone else, not even
      # the regular topic user notifications.
      return email_addresses.dup.uniq if post.incoming_email.is_auto_generated?
    end

    # Send a single email using group SMTP settings to cut down on the
    # number of emails sent via SMTP, also to replicate how support systems
    # and group inboxes generally work in other systems.
    #
    # We need to send this on a delay to allow for editing and finalising
    # posts, the same way we do for private_message user emails/notifications.
    Jobs.enqueue_in(
      SiteSetting.personal_email_time_window_seconds,
      :group_smtp_email,
      group_id: group.id,
      post_id: post.id,
      email: to_address,
      cc_emails: cc_addresses,
    )

    # Add the group's email_username into the array, because it is used for
    # skip_send_email_to in the case of user private message notifications
    # (we do not want the group to be sent any emails from here because it
    # will make another email for IMAP to pick up in the group's mailbox)
    emails_to_skip_send = email_addresses.dup if email_addresses.any?
    emails_to_skip_send << group.email_username
    emails_to_skip_send.uniq
  end

  def notify_post_users(
    post,
    notified,
    group_ids: nil,
    include_topic_watchers: true,
    include_category_watchers: true,
    include_tag_watchers: true,
    new_record: false,
    notification_type: nil
  )
    return [] unless post.topic

    warn_if_not_sidekiq

    condition = +<<~SQL
      users.id IN (
        SELECT id FROM users WHERE false
        /*topic*/
        /*category*/
        /*tags*/
      )
    SQL
    condition.sub! ""/*topic*/"", <<~SQL if include_topic_watchers
        UNION
        SELECT user_id
          FROM topic_users
         WHERE notification_level = :watching
           AND topic_id = :topic_id
      SQL

    condition.sub! ""/*category*/"", <<~SQL if include_category_watchers
        UNION

        SELECT cu.user_id
          FROM category_users cu
     LEFT JOIN topic_users tu ON tu.user_id = cu.user_id
                             AND tu.topic_id = :topic_id
         WHERE cu.notification_level = :watching
           AND cu.category_id = :category_id
           AND (tu.user_id IS NULL OR tu.notification_level = :watching)
      SQL

    tag_ids = post.topic.topic_tags.pluck(""topic_tags.tag_id"")

    condition.sub! ""/*tags*/"", <<~SQL if include_tag_watchers && tag_ids.present?
        UNION

        SELECT tag_users.user_id
          FROM tag_users
     LEFT JOIN topic_users tu ON tu.user_id = tag_users.user_id
                             AND tu.topic_id = :topic_id
     LEFT JOIN tag_group_memberships tgm ON tag_users.tag_id = tgm.tag_id
     LEFT JOIN tag_group_permissions tgp ON tgm.tag_group_id = tgp.tag_group_id
     LEFT JOIN group_users gu ON gu.user_id = tag_users.user_id
         WHERE (
            tgp.group_id IS NULL OR
            tgp.group_id = gu.group_id OR
            tgp.group_id = :everyone_group_id OR
            gu.group_id = :staff_group_id
          )
               AND (tag_users.notification_level = :watching
                    AND tag_users.tag_id IN (:tag_ids)
                    AND (tu.user_id IS NULL OR tu.notification_level = :watching))
      SQL

    notify =
      User.where(
        condition,
        watching: TopicUser.notification_levels[:watching],
        topic_id: post.topic_id,
        category_id: post.topic.category_id,
        tag_ids: tag_ids,
        staff_group_id: Group::AUTO_GROUPS[:staff],
        everyone_group_id: Group::AUTO_GROUPS[:everyone],
      )

    if group_ids.present?
      notify = notify.joins(:group_users).where(""group_users.group_id IN (?)"", group_ids)
    end

    notify = notify.where(staged: false).staff if post.topic.private_message?

    exclude_user_ids = notified.map(&:id)
    notify = notify.where(""users.id NOT IN (?)"", exclude_user_ids) if exclude_user_ids.present?

    DiscourseEvent.trigger(:before_create_notifications_for_users, notify, post)

    already_seen_user_ids =
      Set.new(
        TopicUser
          .where(topic_id: post.topic.id)
          .where(""last_read_post_number >= ?"", post.post_number)
          .pluck(:user_id),
      )

    each_user_in_batches(notify) do |user|
      calculated_type =
        if !new_record && already_seen_user_ids.include?(user.id)
          Notification.types[:edited]
        elsif notification_type
          Notification.types[notification_type]
        else
          Notification.types[:posted]
        end
      opts = {}
      opts[:display_username] = post.last_editor.username if calculated_type ==
        Notification.types[:edited]
      create_notification(user, calculated_type, post, opts)
    end

    notify
  end

  def warn_if_not_sidekiq
    unless Sidekiq.server?
      Rails.logger.warn(
        ""PostAlerter.#{caller_locations(1, 1)[0].label} was called outside of sidekiq"",
      )
    end
  end

  private

  def each_user_in_batches(users)
    # This is race-condition-safe, unlike #find_in_batches
    users
      .pluck(:id)
      .each_slice(USER_BATCH_SIZE) do |user_ids_batch|
        User.where(id: user_ids_batch).includes(:do_not_disturb_timings).each { |user| yield(user) }
      end
  end

  def create_pm_notification(user, post, emails_to_skip_send)
    create_notification(
      user,
      Notification.types[:private_message],
      post,
      skip_send_email_to: emails_to_skip_send,
    )
  end

  def is_replying?(user, reply_to_user, quoted_users)
    reply_to_user == user || quoted_users.include?(user)
  end

  def user_watching_topic?(user, topic)
    TopicUser.exists?(
      user_id: user.id,
      topic_id: topic.id,
      notification_level: TopicUser.notification_levels[:watching],
    )
  end

  def group_watched_first_post?(user, post)
    post.is_first_post? && group_watchers(post.topic).include?(user.id)
  end
end

```","# frozen_string_literal: true

RSpec::Matchers.define :add_notification do |user, notification_type|
  match(notify_expectation_failures: true) do |actual|
    notifications = user.notifications
    before = notifications.count

    actual.call

    expect(notifications.count).to eq(before + 1),
    ""expected 1 new notification, got #{notifications.count - before}""

    last_notification_type = notifications.last.notification_type
    expect(last_notification_type).to eq(Notification.types[notification_type]),
    ""expected notification type to be '#{notification_type}', got '#{Notification.types.key(last_notification_type)}'""
  end

  match_when_negated do |actual|
    expect { actual.call }.to_not change {
      user.notifications.where(notification_type: Notification.types[notification_type]).count
    }
  end

  supports_block_expectations
end

RSpec::Matchers.define_negated_matcher :not_add_notification, :add_notification

RSpec.describe PostAlerter do
  fab!(:category)

  fab!(:topic)
  fab!(:post)

  fab!(:private_message_topic)
  fab!(:private_message_topic_post1) { Fabricate(:post, topic: private_message_topic) }
  fab!(:private_message_topic_post2) { Fabricate(:post, topic: private_message_topic) }

  fab!(:group)

  fab!(:admin)
  fab!(:evil_trout)
  fab!(:coding_horror)
  fab!(:walterwhite) { Fabricate(:walter_white) }
  fab!(:user)
  fab!(:tl2_user) { Fabricate(:user, trust_level: TrustLevel[2]) }

  fab!(:private_category) do
    Fabricate(
      :private_category,
      group: group,
      email_in: ""test@test.com"",
      email_in_allow_strangers: true,
    )
  end

  def create_post_with_alerts(args = {})
    post = Fabricate(:post, args)
    PostAlerter.post_created(post)
  end

  def setup_push_notification_subscription_for(user:)
    2.times do |i|
      UserApiKey.create!(
        user_id: user.id,
        client_id: ""xxx#{i}"",
        application_name: ""iPhone#{i}"",
        scopes: [""notifications""].map { |name| UserApiKeyScope.new(name: name) },
        push_url: ""https://site2.com/push"",
      )
    end
  end

  context ""with private message"" do
    it ""notifies for pms correctly"" do
      pm = Fabricate(:topic, archetype: ""private_message"", category_id: nil)
      op = Fabricate(:post, user: pm.user)
      pm.allowed_users << pm.user
      PostAlerter.post_created(op)

      reply = Fabricate(:post, user: pm.user, topic: pm, reply_to_post_number: 1)
      PostAlerter.post_created(reply)

      reply2 = Fabricate(:post, topic: pm, reply_to_post_number: 1)
      PostAlerter.post_created(reply2)

      # we get a green notification for a reply
      expect(Notification.where(user_id: pm.user_id).pick(:notification_type)).to eq(
        Notification.types[:private_message],
      )

      TopicUser.change(
        pm.user_id,
        pm.id,
        notification_level: TopicUser.notification_levels[:tracking],
      )

      Notification.destroy_all

      reply3 = Fabricate(:post, topic: pm)
      PostAlerter.post_created(reply3)

      # no notification cause we are tracking
      expect(Notification.where(user_id: pm.user_id).count).to eq(0)

      Notification.destroy_all

      reply4 = Fabricate(:post, topic: pm, reply_to_post_number: 1)
      PostAlerter.post_created(reply4)

      # yes notification cause we were replied to
      expect(Notification.where(user_id: pm.user_id).count).to eq(1)
    end

    it ""notifies about private message even if direct mention"" do
      pm = Fabricate(:topic, archetype: ""private_message"", category_id: nil)
      op =
        Fabricate(:post, topic: pm, user: pm.user, raw: ""Hello @#{user.username}, nice to meet you"")
      pm.allowed_users << pm.user
      pm.allowed_users << user
      TopicUser.create!(
        user_id: user.id,
        topic_id: pm.id,
        notification_level: TopicUser.notification_levels[:watching],
      )
      PostAlerter.post_created(op)

      expect(Notification.where(user_id: user.id).pick(:notification_type)).to eq(
        Notification.types[:private_message],
      )
    end

    context ""with group inboxes"" do
      fab!(:user1) { Fabricate(:user) }
      fab!(:user2) { Fabricate(:user) }
      fab!(:group) do
        Fabricate(:group, users: [user2], name: ""TestGroup"", default_notification_level: 2)
      end
      fab!(:watching_first_post_group) do
        Fabricate(
          :group,
          name: ""some_group"",
          users: [evil_trout, coding_horror],
          messageable_level: Group::ALIAS_LEVELS[:everyone],
          default_notification_level: NotificationLevels.all[:watching_first_post],
        )
      end
      fab!(:pm) do
        Fabricate(:topic, archetype: ""private_message"", category_id: nil, allowed_groups: [group])
      end
      fab!(:op) { Fabricate(:post, user: pm.user, topic: pm) }

      it ""triggers :before_create_notifications_for_users"" do
        pm.allowed_users << user1
        events = DiscourseEvent.track_events { PostAlerter.post_created(op) }

        expect(events).to include(
          event_name: :before_create_notifications_for_users,
          params: [[user1], op],
        )
        expect(events).to include(
          event_name: :before_create_notifications_for_users,
          params: [[user2], op],
        )
      end

      it ""triggers group summary notification"" do
        Jobs.run_immediately!
        TopicUser.change(
          user2.id,
          pm.id,
          notification_level: TopicUser.notification_levels[:tracking],
        )

        PostAlerter.post_created(op)
        group_summary_notification = Notification.where(user_id: user2.id)

        expect(group_summary_notification.count).to eq(1)
        expect(group_summary_notification.first.notification_type).to eq(
          Notification.types[:group_message_summary],
        )

        notification_payload = JSON.parse(group_summary_notification.first.data)
        expect(notification_payload[""group_name""]).to eq(group.name)
        expect(notification_payload[""inbox_count""]).to eq(1)

        # archiving the only PM clears the group summary notification
        GroupArchivedMessage.archive!(group.id, pm)
        expect(Notification.where(user_id: user2.id)).to be_blank

        # moving to inbox the only PM restores the group summary notification
        GroupArchivedMessage.move_to_inbox!(group.id, pm)
        group_summary_notification = Notification.where(user_id: user2.id)
        expect(group_summary_notification.first.notification_type).to eq(
          Notification.types[:group_message_summary],
        )

        updated_payload = JSON.parse(group_summary_notification.first.data)
        expect(updated_payload[""group_name""]).to eq(group.name)
        expect(updated_payload[""inbox_count""]).to eq(1)

        # adding a second PM updates the count
        pm2 =
          Fabricate(:topic, archetype: ""private_message"", category_id: nil, allowed_groups: [group])
        op2 = Fabricate(:post, user: pm2.user, topic: pm2)
        TopicUser.change(
          user2.id,
          pm2.id,
          notification_level: TopicUser.notification_levels[:tracking],
        )

        PostAlerter.post_created(op2)
        group_summary_notification = Notification.where(user_id: user2.id)
        updated_payload = JSON.parse(group_summary_notification.first.data)

        expect(updated_payload[""group_name""]).to eq(group.name)
        expect(updated_payload[""inbox_count""]).to eq(2)

        # archiving the second PM quietly updates the group summary count for the acting user
        GroupArchivedMessage.archive!(group.id, pm2, acting_user_id: user2.id)
        group_summary_notification = Notification.where(user_id: user2.id)
        expect(group_summary_notification.first.read).to eq(true)
        updated_payload = JSON.parse(group_summary_notification.first.data)

        expect(updated_payload[""inbox_count""]).to eq(1)

        # moving to inbox the second PM quietly updates the group summary count for the acting user
        GroupArchivedMessage.move_to_inbox!(group.id, pm2, acting_user_id: user2.id)
        group_summary_notification = Notification.where(user_id: user2.id)
        expect(group_summary_notification.first.read).to eq(true)
        updated_payload = JSON.parse(group_summary_notification.first.data)

        expect(updated_payload[""group_name""]).to eq(group.name)
        expect(updated_payload[""inbox_count""]).to eq(2)
      end

      it ""updates the consolidated group summary inbox count and bumps the notification"" do
        user2.update!(last_seen_at: 5.minutes.ago)
        TopicUser.change(
          user2.id,
          pm.id,
          notification_level: TopicUser.notification_levels[:tracking],
        )
        PostAlerter.post_created(op)

        starting_count =
          Notification
            .where(user_id: user2.id, notification_type: Notification.types[:group_message_summary])
            .pluck(""data::json ->> 'inbox_count'"")
            .last
            .to_i

        another_pm =
          Fabricate(:topic, archetype: ""private_message"", category_id: nil, allowed_groups: [group])
        another_post = Fabricate(:post, user: another_pm.user, topic: another_pm)
        TopicUser.change(
          user2.id,
          another_pm.id,
          notification_level: TopicUser.notification_levels[:tracking],
        )

        message_data =
          MessageBus
            .track_publish(""/notification/#{user2.id}"") { PostAlerter.post_created(another_post) }
            .first
            .data

        expect(Notification.where(user: user2).count).to eq(1)
        expect(message_data.dig(:last_notification, :notification, :data, :inbox_count)).to eq(
          starting_count + 1,
        )
        expect(message_data[:unread_notifications]).to eq(1)
      end

      it ""sends a PM notification when replying to a member tracking the topic"" do
        group.add(user1)

        post = Fabricate(:post, topic: pm, user: user1)
        TopicUser.change(
          user1.id,
          pm.id,
          notification_level: TopicUser.notification_levels[:tracking],
        )

        expect {
          create_post_with_alerts(
            raw: ""this is a reply to your post..."",
            topic: pm,
            user: user2,
            reply_to_post_number: post.post_number,
          )
        }.to change(
          user1.notifications.where(notification_type: Notification.types[:private_message]),
          :count,
        ).by(1)
      end

      it ""notifies a group member if someone replies to their post"" do
        group.add(user1)

        post = Fabricate(:post, topic: pm, user: user1)
        TopicUser.change(
          user1.id,
          pm.id,
          notification_level: TopicUser.notification_levels[:regular],
        )

        expect {
          create_post_with_alerts(
            raw: ""this is a reply to your post..."",
            topic: pm,
            user: user2,
            reply_to_post_number: post.post_number,
          )
        }.to change(user1.notifications, :count).by(1)
      end

      it ""notifies a group member if someone quotes their post"" do
        group.add(user1)

        post = Fabricate(:post, topic: pm, user: user1)
        TopicUser.change(
          user1.id,
          pm.id,
          notification_level: TopicUser.notification_levels[:regular],
        )
        quote_raw = <<~MD
          [quote=""#{user1.username}, post:1, topic:#{pm.id}""]#{post.raw}[/quote]
        MD

        expect { create_post_with_alerts(raw: quote_raw, topic: pm, user: user2) }.to change(
          user1.notifications,
          :count,
        ).by(1)
      end

      it ""Doesn't notify non-admin users when their post is quoted inside a whisper"" do
        group.add(admin)

        TopicUser.change(
          user2.id,
          pm.id,
          notification_level: TopicUser.notification_levels[:regular],
        )
        quote_raw = <<~MD
          [quote=""#{user2.username}, post:1, topic:#{pm.id}""]#{op.raw}[/quote]
        MD

        expect {
          create_post_with_alerts(
            raw: quote_raw,
            topic: pm,
            user: admin,
            post_type: Post.types[:whisper],
          )
        }.not_to change(user2.notifications, :count)
      end

      context ""with watching_first_post notification level"" do
        it ""notifies group members of first post"" do
          post =
            PostCreator.create!(
              user,
              title: ""Hi there, welcome to my topic"",
              raw: ""This is my awesome message"",
              archetype: Archetype.private_message,
              target_group_names: watching_first_post_group.name,
            )

          PostAlerter.new.after_save_post(post, true)

          expect(
            evil_trout
              .notifications
              .where(notification_type: Notification.types[:private_message])
              .count,
          ).to eq(1)
          expect(
            coding_horror
              .notifications
              .where(notification_type: Notification.types[:private_message])
              .count,
          ).to eq(1)
        end

        it ""doesn't notify group members of replies"" do
          post =
            PostCreator.create!(
              user,
              title: ""Hi there, welcome to my topic"",
              raw: ""This is my awesome message"",
              archetype: Archetype.private_message,
              target_group_names: watching_first_post_group.name,
            )

          expect(
            evil_trout
              .notifications
              .where(notification_type: Notification.types[:private_message])
              .count,
          ).to eq(0)
          expect(
            coding_horror
              .notifications
              .where(notification_type: Notification.types[:private_message])
              .count,
          ).to eq(0)

          PostAlerter.new.after_save_post(post, true)

          expect(
            evil_trout
              .notifications
              .where(notification_type: Notification.types[:private_message])
              .count,
          ).to eq(1)
          expect(
            coding_horror
              .notifications
              .where(notification_type: Notification.types[:private_message])
              .count,
          ).to eq(1)

          reply =
            Fabricate(
              :post,
              raw: ""Reply to PM"",
              user: user,
              topic: post.topic,
              reply_to_post_number: post.post_number,
            )

          expect do PostAlerter.new.after_save_post(reply, false) end.to_not change {
            Notification.count
          }
        end
      end
    end
  end

  context ""with unread"" do
    it ""does not return whispers as unread posts"" do
      _whisper =
        Fabricate(
          :post,
          raw: ""this is a whisper post"",
          user: admin,
          topic: post.topic,
          reply_to_post_number: post.post_number,
          post_type: Post.types[:whisper],
        )

      expect(PostAlerter.new.first_unread_post(post.user, post.topic)).to be_blank
    end
  end

  context ""with edits"" do
    it ""notifies correctly on edits"" do
      Jobs.run_immediately!
      PostActionNotifier.enable

      post = Fabricate(:post, raw: ""I love waffles"")

      expect do post.revise(admin, raw: ""I made a revision"") end.to add_notification(
        post.user,
        :edited,
      )

      # lets also like this post which should trigger a notification
      expect do
        PostActionCreator.new(admin, post, PostActionType.types[:like]).perform
      end.to add_notification(post.user, :liked)

      # skip this notification cause we already notified on an edit by the same user
      # in the previous edit
      freeze_time 2.hours.from_now

      expect do post.revise(admin, raw: ""I made another revision"") end.to_not change {
        Notification.count
      }

      # this we do not skip cause 1 day has passed
      freeze_time 23.hours.from_now

      expect do post.revise(admin, raw: ""I made another revision xyz"") end.to add_notification(
        post.user,
        :edited,
      )

      expect do post.revise(Fabricate(:admin), raw: ""I made a revision"") end.to add_notification(
        post.user,
        :edited,
      )

      freeze_time 2.hours.from_now

      expect do post.revise(admin, raw: ""I made another revision"") end.to add_notification(
        post.user,
        :edited,
      )
    end

    it ""notifies flaggers when flagged post gets unhidden by edit"" do
      post = create_post

      PostActionNotifier.enable
      Reviewable.set_priorities(high: 4.0)
      SiteSetting.hide_post_sensitivity = Reviewable.sensitivities[:low]

      PostActionCreator.spam(evil_trout, post)
      PostActionCreator.spam(walterwhite, post)

      post.reload
      expect(post.hidden).to eq(true)

      expect { post.revise(post.user, raw: post.raw + "" ha I edited it "") }.to add_notification(
        evil_trout,
        :edited,
      ).and add_notification(walterwhite, :edited)

      post.reload
      expect(post.hidden).to eq(false)

      notification = walterwhite.notifications.last
      expect(notification.topic_id).to eq(post.topic.id)
      expect(notification.post_number).to eq(post.post_number)
      expect(notification.data_hash[""display_username""]).to eq(post.user.username)

      PostActionCreator.create(coding_horror, post, :spam)
      PostActionCreator.create(walterwhite, post, :off_topic)

      post.reload
      expect(post.hidden).to eq(true)

      expect {
        post.revise(post.user, raw: post.raw + "" ha I edited it again "")
      }.to not_add_notification(evil_trout, :edited).and not_add_notification(
              coding_horror,
              :edited,
            ).and not_add_notification(walterwhite, :edited)
    end
  end

  context ""with quotes"" do
    fab!(:category)
    fab!(:topic) { Fabricate(:topic, category: category) }

    it ""does not notify for muted users"" do
      post = Fabricate(:post, raw: '[quote=""Eviltrout, post:1""]whatup[/quote]', topic: topic)
      MutedUser.create!(user_id: evil_trout.id, muted_user_id: post.user_id)

      expect { PostAlerter.post_created(post) }.not_to change(evil_trout.notifications, :count)
    end

    it ""does not notify for ignored users"" do
      post = Fabricate(:post, raw: '[quote=""EvilTrout, post:1""]whatup[/quote]', topic: topic)
      Fabricate(:ignored_user, user: evil_trout, ignored_user: post.user)

      expect { PostAlerter.post_created(post) }.not_to change(evil_trout.notifications, :count)
    end

    it ""does not notify for users with new reply notification"" do
      post = Fabricate(:post, raw: '[quote=""eviltRout, post:1""]whatup[/quote]', topic: topic)
      notification =
        Notification.create!(
          topic: post.topic,
          post_number: post.post_number,
          read: false,
          notification_type: Notification.types[:replied],
          user: evil_trout,
          data: { topic_title: ""test topic"" }.to_json,
        )
      expect { PostAlerter.post_edited(post) }.not_to change(evil_trout.notifications, :count)

      notification.destroy
      expect { PostAlerter.post_edited(post) }.to change(evil_trout.notifications, :count).by(1)
    end

    it ""does not collapse quote notifications"" do
      expect {
        2.times do
          create_post_with_alerts(raw: '[quote=""eviltrout, post:1""]whatup[/quote]', topic: topic)
        end
      }.to change(evil_trout.notifications, :count).by(2)
    end

    it ""won't notify the user a second time on revision"" do
      p1 = create_post_with_alerts(raw: '[quote=""Evil Trout, post:1""]whatup[/quote]')
      expect {
        p1.revise(p1.user, raw: '[quote=""Evil Trout, post:1""]whatup now?[/quote]')
      }.not_to change(evil_trout.notifications, :count)
    end

    it ""doesn't notify the poster"" do
      topic = create_post_with_alerts.topic
      expect {
        Fabricate(
          :post,
          topic: topic,
          user: topic.user,
          raw: '[quote=""Bruce Wayne, post:1""]whatup[/quote]',
        )
      }.not_to change(topic.user.notifications, :count)
    end

    it ""triggers :before_create_notifications_for_users"" do
      post = Fabricate(:post, raw: '[quote=""eviltrout, post:1""]whatup[/quote]')
      events = DiscourseEvent.track_events { PostAlerter.post_created(post) }
      expect(events).to include(
        event_name: :before_create_notifications_for_users,
        params: [[evil_trout], post],
      )
    end

    context ""with notifications when prioritizing full names"" do
      before do
        SiteSetting.prioritize_username_in_ux = false
        SiteSetting.display_name_on_posts = true
      end

      it ""sends to correct user"" do
        quote = <<~MD
          [quote=""#{evil_trout.name}, post:1, username:#{evil_trout.username}""]whatup[/quote]
        MD

        expect { create_post_with_alerts(raw: quote, topic: topic) }.to change(
          evil_trout.notifications,
          :count,
        ).by(1)
      end

      it ""sends to correct users when nested quotes with multiple users"" do
        quote = <<~MD
          [quote=""#{evil_trout.name}, post:1, username:#{evil_trout.username}""]this [quote=""#{walterwhite.name}, post:2, username:#{walterwhite.username}""]whatup[/quote][/quote]
        MD

        expect { create_post_with_alerts(raw: quote, topic: topic) }.to change(
          evil_trout.notifications,
          :count,
        ).by(1).and change(walterwhite.notifications, :count).by(1)
      end

      it ""sends to correct users when multiple quotes"" do
        user = Fabricate(:user)
        quote = <<~MD
          [quote=""#{evil_trout.name}, post:1, username:#{evil_trout.username}""]""username:#{user.username}"" [/quote]/n [quote=""#{walterwhite.name}, post:2, username:#{walterwhite.username}""]whatup[/quote]
        MD

        expect { create_post_with_alerts(raw: quote, topic: topic) }.to change(
          evil_trout.notifications,
          :count,
        ).by(1).and change(walterwhite.notifications, :count).by(1).and not_change(
                      user.notifications,
                      :count,
                    )
      end

      it ""sends to correct user when user has a full name that matches another user's username"" do
        user_with_matching_full_name = Fabricate(:user, name: evil_trout.username)
        quote = <<~MD
          [quote=""#{user_with_matching_full_name.name}, post:1, username:#{user_with_matching_full_name.username}""]this [/quote]
        MD

        expect { create_post_with_alerts(raw: quote, topic: topic) }.to change(
          user_with_matching_full_name.notifications,
          :count,
        ).by(1).and not_change(evil_trout.notifications, :count)
      end
    end
  end

  context ""with linked"" do
    let(:post1) { create_post }
    let(:user) { post1.user }
    let(:linking_post) { create_post(raw: ""my magic topic\n##{Discourse.base_url}#{post1.url}"") }

    before { Jobs.run_immediately! }

    it ""will notify correctly on linking"" do
      linking_post

      expect(user.notifications.count).to eq(1)

      watcher = Fabricate(:user)
      TopicUser.create!(
        user_id: watcher.id,
        topic_id: topic.id,
        notification_level: TopicUser.notification_levels[:watching],
      )

      create_post(
        topic_id: topic.id,
        user: user,
        raw: ""my magic topic\n##{Discourse.base_url}#{post1.url}"",
      )

      user.reload
      expect(user.notifications.where(notification_type: Notification.types[:linked]).count).to eq(
        1,
      )

      expect(watcher.notifications.count).to eq(1)

      # don't notify on reflection
      post1.reload
      expect(PostAlerter.new.extract_linked_users(post1).length).to eq(0)
    end

    it ""triggers :before_create_notifications_for_users"" do
      events = DiscourseEvent.track_events { linking_post }
      expect(events).to include(
        event_name: :before_create_notifications_for_users,
        params: [[user], linking_post],
      )
    end

    it ""doesn't notify the linked user if the user is staged and the category is restricted and allows strangers"" do
      staged_user = Fabricate(:staged)
      group_member = Fabricate(:user)
      group.add(group_member)

      staged_user_post = create_post(user: staged_user, category: private_category)

      create_post(
        user: group_member,
        category: private_category,
        raw: ""my magic topic\n##{Discourse.base_url}#{staged_user_post.url}"",
      )

      staged_user.reload
      expect(
        staged_user.notifications.where(notification_type: Notification.types[:linked]).count,
      ).to eq(0)
    end
  end

  context ""with @here"" do
    let(:post) do
      create_post_with_alerts(raw: ""Hello @here how are you?"", user: tl2_user, topic: topic)
    end
    fab!(:other_post) { Fabricate(:post, topic: topic) }

    before { Jobs.run_immediately! }

    it ""does not notify unrelated users"" do
      expect { post }.not_to change(evil_trout.notifications, :count)
    end

    it ""does not work if user here exists"" do
      Fabricate(:user, username: SiteSetting.here_mention)
      expect { post }.not_to change(other_post.user.notifications, :count)
    end

    it ""notifies users who replied"" do
      post2 = Fabricate(:post, topic: topic, post_type: Post.types[:whisper])
      post3 = Fabricate(:post, topic: topic)

      expect { post }.to change(other_post.user.notifications, :count).by(1).and not_change(
              post2.user.notifications,
              :count,
            ).and change(post3.user.notifications, :count).by(1)
    end

    it ""notifies users who whispered"" do
      post2 = Fabricate(:post, topic: topic, post_type: Post.types[:whisper])
      post3 = Fabricate(:post, topic: topic)

      tl2_user.grant_admin!

      expect { post }.to change(other_post.user.notifications, :count).by(1).and change(
              post2.user.notifications,
              :count,
            ).by(1).and change(post3.user.notifications, :count).by(1)
    end

    it ""notifies only last max_here_mentioned users"" do
      SiteSetting.max_here_mentioned = 2
      3.times { Fabricate(:post, topic: topic) }
      expect { post }.to change { Notification.count }.by(2)
    end
  end

  context ""with @group mentions"" do
    fab!(:group) do
      Fabricate(:group, name: ""group"", mentionable_level: Group::ALIAS_LEVELS[:everyone])
    end
    let(:post) { create_post_with_alerts(raw: ""Hello @group how are you?"") }
    before { group.add(evil_trout) }

    it ""notifies users correctly"" do
      expect { post }.to change(evil_trout.notifications, :count).by(1)

      expect(GroupMention.count).to eq(1)

      Fabricate(:group, name: ""group-alt"", mentionable_level: Group::ALIAS_LEVELS[:everyone])

      expect {
        create_post_with_alerts(raw: ""Hello, @group-alt should not trigger a notification?"")
      }.not_to change(evil_trout.notifications, :count)

      expect(GroupMention.count).to eq(2)

      group.update_columns(mentionable_level: Group::ALIAS_LEVELS[:members_mods_and_admins])
      expect { create_post_with_alerts(raw: ""Hello @group you are not mentionable"") }.not_to change(
        evil_trout.notifications,
        :count,
      )

      expect(GroupMention.count).to eq(3)

      group.update_columns(mentionable_level: Group::ALIAS_LEVELS[:owners_mods_and_admins])
      group.add_owner(user)
      expect {
        create_post_with_alerts(raw: ""Hello @group the owner can mention you"", user: user)
      }.to change(evil_trout.notifications, :count).by(1)

      expect(GroupMention.count).to eq(4)
    end

    it ""takes private mention as precedence"" do
      expect {
        create_post_with_alerts(raw: ""Hello @group and @eviltrout, nice to meet you"")
      }.to change(evil_trout.notifications, :count).by(1)
      expect(evil_trout.notifications.last.notification_type).to eq(Notification.types[:mentioned])
    end

    it ""triggers :before_create_notifications_for_users"" do
      events = DiscourseEvent.track_events { post }
      expect(events).to include(
        event_name: :before_create_notifications_for_users,
        params: [[evil_trout], post],
      )
    end
  end

  context ""with @mentions"" do
    let(:mention_post) { create_post_with_alerts(user: user, raw: ""Hello @eviltrout"") }
    let(:topic) { mention_post.topic }

    before { Jobs.run_immediately! }

    it ""notifies a user"" do
      expect { mention_post }.to change(evil_trout.notifications, :count).by(1)
    end

    it ""won't notify the user a second time on revision"" do
      mention_post
      expect {
        mention_post.revise(
          mention_post.user,
          raw: ""New raw content that still mentions @eviltrout"",
        )
      }.not_to change(evil_trout.notifications, :count)
    end

    it ""doesn't notify the user who created the topic in regular mode"" do
      topic.notify_regular!(user)
      mention_post
      expect {
        create_post_with_alerts(user: user, raw: ""second post"", topic: topic)
      }.not_to change(user.notifications, :count)
    end

    it ""triggers :before_create_notifications_for_users"" do
      events = DiscourseEvent.track_events { mention_post }
      expect(events).to include(
        event_name: :before_create_notifications_for_users,
        params: [[evil_trout], mention_post],
      )
    end

    it ""notification comes from editor if mention is added later"" do
      post = create_post_with_alerts(user: user, raw: ""No mention here."")
      expect { post.revise(admin, raw: ""Mention @eviltrout in this edit."") }.to change(
        evil_trout.notifications,
        :count,
      )
      n = evil_trout.notifications.last
      expect(n.data_hash[""original_username""]).to eq(admin.username)
    end

    it ""doesn't notify the last post editor if they mention themselves"" do
      post = create_post_with_alerts(user: user, raw: ""Post without a mention."")
      expect { post.revise(evil_trout, raw: ""O hai, @eviltrout!"") }.not_to change(
        evil_trout.notifications,
        :count,
      )
    end

    fab!(:alice) { Fabricate(:user, username: ""alice"") }
    fab!(:bob) { Fabricate(:user, username: ""bob"") }
    fab!(:carol) { Fabricate(:admin, username: ""carol"") }
    fab!(:dave) { Fabricate(:user, username: ""dave"") }
    fab!(:eve) { Fabricate(:user, username: ""eve"") }
    fab!(:group) do
      Fabricate(:group, name: ""group"", mentionable_level: Group::ALIAS_LEVELS[:everyone])
    end

    before { group.bulk_add([alice.id, eve.id]) }

    def create_post_with_alerts(args = {})
      post = Fabricate(:post, args)
      PostAlerter.post_created(post)
    end

    def set_topic_notification_level(user, topic, level_name)
      TopicUser.change(
        user.id,
        topic.id,
        notification_level: TopicUser.notification_levels[level_name],
      )
    end

    context ""with topic"" do
      fab!(:topic) { Fabricate(:topic, user: alice) }

      %i[watching tracking regular].each do |notification_level|
        context ""when notification level is '#{notification_level}'"" do
          before { set_topic_notification_level(alice, topic, notification_level) }

          it ""notifies about @username mention"" do
            args = { user: bob, topic: topic, raw: ""Hello @alice"" }
            expect { create_post_with_alerts(args) }.to add_notification(alice, :mentioned)
          end
        end
      end

      context ""when notification level is 'muted'"" do
        before { set_topic_notification_level(alice, topic, :muted) }

        it ""does not notify about @username mention"" do
          args = { user: bob, topic: topic, raw: ""Hello @alice"" }
          expect { create_post_with_alerts(args) }.to_not add_notification(alice, :mentioned)
        end
      end
    end

    context ""with message to users"" do
      fab!(:pm_topic) do
        Fabricate(
          :private_message_topic,
          user: alice,
          topic_allowed_users: [
            Fabricate.build(:topic_allowed_user, user: alice),
            Fabricate.build(:topic_allowed_user, user: bob),
            Fabricate.build(:topic_allowed_user, user: Discourse.system_user),
          ],
        )
      end

      context ""when user is part of conversation"" do
        %i[watching tracking regular].each do |notification_level|
          context ""when notification level is '#{notification_level}'"" do
            before { set_topic_notification_level(alice, pm_topic, notification_level) }
            let(:expected_notification) do
              notification_level == :watching ? :private_message : :mentioned
            end

            it ""notifies about @username mention"" do
              args = { user: bob, topic: pm_topic, raw: ""Hello @alice"" }
              expect { create_post_with_alerts(args) }.to add_notification(
                alice,
                expected_notification,
              )
            end

            it ""notifies about @username mentions by non-human users"" do
              args = { user: Discourse.system_user, topic: pm_topic, raw: ""Hello @alice"" }
              expect { create_post_with_alerts(args) }.to add_notification(
                alice,
                expected_notification,
              )
            end

            it ""notifies about @group mention when allowed user is part of group"" do
              args = { user: bob, topic: pm_topic, raw: ""Hello @group"" }
              expect { create_post_with_alerts(args) }.to add_notification(alice, :group_mentioned)
            end
          end
        end

        context ""when notification level is 'muted'"" do
          before { set_topic_notification_level(alice, pm_topic, :muted) }

          it ""does not notify about @username mention"" do
            args = { user: bob, topic: pm_topic, raw: ""Hello @alice"" }
            expect { create_post_with_alerts(args) }.to_not add_notification(alice, :mentioned)
          end
        end
      end

      context ""when user is not part of conversation"" do
        it ""does not notify about @username mention even though mentioned user is an admin"" do
          args = { user: bob, topic: pm_topic, raw: ""Hello @carol"" }
          expect { create_post_with_alerts(args) }.to_not add_notification(carol, :mentioned)
        end

        it ""does not notify about @username mention by non-human user even though mentioned user is an admin"" do
          args = { user: Discourse.system_user, topic: pm_topic, raw: ""Hello @carol"" }
          expect { create_post_with_alerts(args) }.to_not add_notification(carol, :mentioned)
        end

        it ""does not notify about @username mention when mentioned user is not allowed to see message"" do
          args = { user: bob, topic: pm_topic, raw: ""Hello @dave"" }
          expect { create_post_with_alerts(args) }.to_not add_notification(dave, :mentioned)
        end

        it ""does not notify about @group mention when user is not an allowed user"" do
          args = { user: bob, topic: pm_topic, raw: ""Hello @group"" }
          expect { create_post_with_alerts(args) }.to_not add_notification(eve, :group_mentioned)
        end
      end
    end

    context ""with message to group"" do
      fab!(:some_group) do
        Fabricate(:group, name: ""some_group"", mentionable_level: Group::ALIAS_LEVELS[:everyone])
      end
      fab!(:pm_topic) do
        Fabricate(
          :private_message_topic,
          user: alice,
          topic_allowed_groups: [Fabricate.build(:topic_allowed_group, group: group)],
          topic_allowed_users: [Fabricate.build(:topic_allowed_user, user: Discourse.system_user)],
        )
      end

      before { some_group.bulk_add([alice.id, carol.id]) }

      context ""when group is part of conversation"" do
        %i[watching tracking regular].each do |notification_level|
          context ""when notification level is '#{notification_level}'"" do
            before { set_topic_notification_level(alice, pm_topic, notification_level) }

            it ""notifies about @group mention"" do
              args = { user: bob, topic: pm_topic, raw: ""Hello @group"" }
              expect { create_post_with_alerts(args) }.to add_notification(alice, :group_mentioned)
            end

            it ""notifies about @group mentions by non-human users"" do
              args = { user: Discourse.system_user, topic: pm_topic, raw: ""Hello @group"" }
              expect { create_post_with_alerts(args) }.to add_notification(alice, :group_mentioned)
            end

            it ""notifies about @username mention when user belongs to allowed group"" do
              args = { user: bob, topic: pm_topic, raw: ""Hello @alice"" }
              expect { create_post_with_alerts(args) }.to add_notification(alice, :mentioned)
            end
          end
        end

        context ""when notification level is 'muted'"" do
          before { set_topic_notification_level(alice, pm_topic, :muted) }

          it ""does not notify about @group mention"" do
            args = { user: bob, topic: pm_topic, raw: ""Hello @group"" }
            expect { create_post_with_alerts(args) }.to_not add_notification(
              alice,
              :group_mentioned,
            )
          end
        end
      end

      context ""when group is not part of conversation"" do
        it ""does not notify about @group mention even though mentioned user is an admin"" do
          args = { user: bob, topic: pm_topic, raw: ""Hello @some_group"" }
          expect { create_post_with_alerts(args) }.to_not add_notification(carol, :group_mentioned)
        end

        it ""does not notify about @group mention by non-human user even though mentioned user is an admin"" do
          args = { user: Discourse.system_user, topic: pm_topic, raw: ""Hello @some_group"" }
          expect { create_post_with_alerts(args) }.to_not add_notification(carol, :group_mentioned)
        end

        it ""does not notify about @username mention when user doesn't belong to allowed group"" do
          args = { user: bob, topic: pm_topic, raw: ""Hello @dave"" }
          expect { create_post_with_alerts(args) }.to_not add_notification(dave, :mentioned)
        end
      end
    end
  end

  describe "".create_notification"" do
    fab!(:topic) { Fabricate(:private_message_topic, user: user, created_at: 1.hour.ago) }
    fab!(:post) { Fabricate(:post, topic: topic, created_at: 1.hour.ago) }
    let(:type) { Notification.types[:private_message] }

    it ""creates a notification for PMs"" do
      post.revise(user, { raw: ""This is the revised post"" }, revised_at: Time.zone.now)

      expect { PostAlerter.new.create_notification(user, type, post) }.to change {
        user.notifications.count
      }.by(1)

      expect(user.notifications.last.data_hash[""topic_title""]).to eq(topic.title)
    end

    it ""keeps the original title for PMs"" do
      original_title = topic.title

      post.revise(user, { title: ""This is the revised title"" }, revised_at: Time.now)

      expect { PostAlerter.new.create_notification(user, type, post) }.to change {
        user.notifications.count
      }.by(1)

      expect(user.notifications.last.data_hash[""topic_title""]).to eq(original_title)
    end

    it ""triggers :pre_notification_alert"" do
      events = DiscourseEvent.track_events { PostAlerter.new.create_notification(user, type, post) }

      payload = {
        notification_type: type,
        post_number: post.post_number,
        topic_title: post.topic.title,
        topic_id: post.topic.id,
        excerpt: post.excerpt(400, text_entities: true, strip_links: true, remap_emoji: true),
        username: post.username,
        post_url: post.url,
      }

      expect(events).to include(event_name: :pre_notification_alert, params: [user, payload])
    end

    it ""does not alert when revising and changing notification type"" do
      PostAlerter.new.create_notification(user, type, post)

      post.revise(
        user,
        { raw: ""Editing post to fake include a mention of @eviltrout"" },
        revised_at: Time.now,
      )

      events =
        DiscourseEvent.track_events do
          PostAlerter.new.create_notification(user, Notification.types[:mentioned], post)
        end

      payload = {
        notification_type: type,
        post_number: post.post_number,
        topic_title: post.topic.title,
        topic_id: post.topic.id,
        excerpt: post.excerpt(400, text_entities: true, strip_links: true, remap_emoji: true),
        username: post.username,
        post_url: post.url,
      }

      expect(events).not_to include(event_name: :pre_notification_alert, params: [user, payload])
    end

    it ""triggers :before_create_notification"" do
      type = Notification.types[:private_message]
      events =
        DiscourseEvent.track_events do
          PostAlerter.new.create_notification(user, type, post, { revision_number: 1 })
        end
      expect(events).to include(
        event_name: :before_create_notification,
        params: [user, type, post, { revision_number: 1 }],
      )
    end

    it ""applies modifiers to notification_data"" do
      Plugin::Instance
        .new
        .register_modifier(:notification_data) do |notification_data|
          notification_data[:silly_key] = ""silly value""
          notification_data
        end

      notification = PostAlerter.new.create_notification(user, type, post)
      expect(notification.data_hash[:silly_key]).to eq(""silly value"")

      DiscoursePluginRegistry.clear_modifiers!
    end
  end

  describe "".push_notification"" do
    let(:mention_post) { create_post_with_alerts(user: user, raw: ""Hello @eviltrout :heart:"") }
    let(:topic) { mention_post.topic }

    before do
      SiteSetting.allowed_user_api_push_urls = ""https://site.com/push|https://site2.com/push""
      setup_push_notification_subscription_for(user: evil_trout)
    end

    describe ""DiscoursePluginRegistry#push_notification_filters"" do
      it ""sends push notifications when all filters pass"" do
        Plugin::Instance.new.register_push_notification_filter { |user, payload| true }

        expect { mention_post }.to change { Jobs::PushNotification.jobs.count }.by(1)
        DiscoursePluginRegistry.reset!
      end

      it ""does not send push notifications when a filters returns false"" do
        Plugin::Instance.new.register_push_notification_filter { |user, payload| false }
        expect { mention_post }.not_to change { Jobs::PushNotification.jobs.count }

        events = DiscourseEvent.track_events { mention_post }
        expect(events.find { |event| event[:event_name] == :push_notification }).not_to be_present

        DiscoursePluginRegistry.reset!
      end
    end

    it ""triggers the push notification event"" do
      events = DiscourseEvent.track_events { mention_post }

      push_notification_event = events.find { |event| event[:event_name] == :push_notification }
      expect(push_notification_event).to be_present
      expect(push_notification_event[:params][0].username).to eq(""eviltrout"")
      expect(push_notification_event[:params][1][:username]).to eq(user.username)
      expect(push_notification_event[:params][1][:excerpt]).to eq(""Hello @eviltrout ❤"")
    end

    it ""pushes nothing to suspended users"" do
      evil_trout.update_columns(suspended_till: 1.year.from_now)
      expect { mention_post }.to_not change { Jobs::PushNotification.jobs.count }

      events = DiscourseEvent.track_events { mention_post }
      expect(events.find { |event| event[:event_name] == :push_notification }).not_to be_present
    end

    it ""pushes nothing when the user is in 'do not disturb'"" do
      Fabricate(
        :do_not_disturb_timing,
        user: evil_trout,
        starts_at: Time.zone.now,
        ends_at: 1.day.from_now,
      )

      expect { mention_post }.to_not change { Jobs::PushNotification.jobs.count }

      events = DiscourseEvent.track_events { mention_post }
      expect(events.find { |event| event[:event_name] == :push_notification }).not_to be_present
    end

    it ""correctly pushes notifications if configured correctly"" do
      Jobs.run_immediately!
      body = nil
      headers = nil

      stub_request(:post, ""https://site2.com/push"").to_return do |request|
        body = request.body
        headers = request.headers
        { status: 200, body: ""OK"" }
      end

      set_subfolder ""/subpath""
      payload = {
        ""secret_key"" => SiteSetting.push_api_secret_key,
        ""url"" => Discourse.base_url,
        ""title"" => SiteSetting.title,
        ""description"" => SiteSetting.site_description,
        ""notifications"" => [
          {
            ""notification_type"" => 1,
            ""post_number"" => 1,
            ""topic_title"" => topic.title,
            ""topic_id"" => topic.id,
            ""excerpt"" => ""Hello @eviltrout ❤"",
            ""username"" => user.username,
            ""url"" => UrlHelper.absolute(Discourse.base_path + mention_post.url),
            ""client_id"" => ""xxx0"",
          },
          {
            ""notification_type"" => 1,
            ""post_number"" => 1,
            ""topic_title"" => topic.title,
            ""topic_id"" => topic.id,
            ""excerpt"" => ""Hello @eviltrout ❤"",
            ""username"" => user.username,
            ""url"" => UrlHelper.absolute(Discourse.base_path + mention_post.url),
            ""client_id"" => ""xxx1"",
          },
        ],
      }

      post = mention_post

      expect(JSON.parse(body)).to eq(payload)
      expect(headers[""Content-Type""]).to eq(""application/json"")

      TopicUser.change(
        evil_trout.id,
        topic.id,
        notification_level: TopicUser.notification_levels[:watching],
      )

      post = Fabricate(:post, topic: post.topic, user_id: evil_trout.id)
      user2 = Fabricate(:user)

      # if we collapse a reply notification we should get notified on the correct post
      new_post =
        create_post_with_alerts(
          topic: post.topic,
          user_id: user.id,
          reply_to_post_number: post.post_number,
          raw: ""this is my first reply"",
        )

      changes = {
        ""notification_type"" => Notification.types[:posted],
        ""post_number"" => new_post.post_number,
        ""username"" => new_post.user.username,
        ""excerpt"" => new_post.raw,
        ""url"" => UrlHelper.absolute(Discourse.base_path + new_post.url),
      }

      payload[""notifications""][0].merge! changes
      payload[""notifications""][1].merge! changes

      expect(JSON.parse(body)).to eq(payload)

      new_post =
        create_post_with_alerts(
          topic: post.topic,
          user_id: user2.id,
          reply_to_post_number: post.post_number,
          raw: ""this is my second reply"",
        )

      changes = {
        ""post_number"" => new_post.post_number,
        ""username"" => new_post.user.username,
        ""excerpt"" => new_post.raw,
        ""url"" => UrlHelper.absolute(Discourse.base_path + new_post.url),
      }

      payload[""notifications""][0].merge! changes
      payload[""notifications""][1].merge! changes

      expect(JSON.parse(body)).to eq(payload)
    end

    it ""does not have invalid HTML in the excerpt"" do
      Fabricate(:category, slug: ""random"")
      Jobs.run_immediately!
      body = nil

      stub_request(:post, ""https://site2.com/push"").to_return do |request|
        body = request.body
        { status: 200, body: ""OK"" }
      end
      create_post_with_alerts(user: user, raw: ""this, @eviltrout, is a test with #random"")
      expect(JSON.parse(body)[""notifications""][0][""excerpt""]).to eq(
        ""this, @eviltrout, is a test with #random"",
      )
    end

    context ""with push subscriptions"" do
      before do
        Fabricate(:push_subscription, user: evil_trout)
        SiteSetting.push_notification_time_window_mins = 10
      end

      it ""delays sending push notification for active online user"" do
        evil_trout.update!(last_seen_at: 5.minutes.ago)

        expect { mention_post }.to change { Jobs::SendPushNotification.jobs.count }
        expect(Jobs::SendPushNotification.jobs[0][""at""]).not_to be_nil
      end

      it ""delays sending push notification for active online user for the correct delay ammount"" do
        evil_trout.update!(last_seen_at: 5.minutes.ago)

        # SiteSetting.push_notification_time_window_mins is 10
        # last_seen_at is 5 minutes ago
        # 10 minutes from now - 5 minutes ago = 5 minutes
        delay = 5.minutes.from_now.to_f

        expect { mention_post }.to change { Jobs::SendPushNotification.jobs.count }
        expect(Jobs::SendPushNotification.jobs[0][""at""]).to be_within(30.second).of(delay)
      end

      it ""does not delay push notification for inactive offline user"" do
        evil_trout.update!(last_seen_at: 40.minutes.ago)

        expect { mention_post }.to change { Jobs::SendPushNotification.jobs.count }
        expect(Jobs::SendPushNotification.jobs[0][""at""]).to be_nil
      end
    end
  end

  describe "".create_notification_alert"" do
    it ""does nothing for suspended users"" do
      evil_trout.update_columns(suspended_till: 1.year.from_now)

      events = nil
      messages =
        MessageBus.track_publish do
          events =
            DiscourseEvent.track_events do
              PostAlerter.create_notification_alert(
                user: evil_trout,
                post: post,
                notification_type: Notification.types[:custom],
                excerpt: ""excerpt"",
                username: ""username"",
              )
            end
        end

      expect(events.size).to eq(0)
      expect(messages.size).to eq(0)
      expect(Jobs::PushNotification.jobs.size).to eq(0)
    end

    it ""does not publish to MessageBus /notification-alert if the user has not been seen for > 30 days, but still sends a push notification"" do
      evil_trout.update_columns(last_seen_at: 31.days.ago)

      SiteSetting.allowed_user_api_push_urls = ""https://site2.com/push""
      UserApiKey.create!(
        user_id: evil_trout.id,
        client_id: ""xxx#1"",
        application_name: ""iPhone1"",
        scopes: [""notifications""].map { |name| UserApiKeyScope.new(name: name) },
        push_url: ""https://site2.com/push"",
      )

      events = nil
      messages =
        MessageBus.track_publish do
          events =
            DiscourseEvent.track_events do
              PostAlerter.create_notification_alert(
                user: evil_trout,
                post: post,
                notification_type: Notification.types[:custom],
                excerpt: ""excerpt"",
                username: ""username"",
              )
            end
        end

      expect(events.map { |event| event[:event_name] }).to include(
        :pre_notification_alert,
        :push_notification,
        :post_notification_alert,
      )
      expect(messages.size).to eq(0)
      expect(Jobs::PushNotification.jobs.size).to eq(1)
    end
  end

  describe ""watching_first_post"" do
    fab!(:user)
    fab!(:category)
    fab!(:tag)
    fab!(:topic) { Fabricate(:topic, category: category, tags: [tag]) }
    fab!(:post) { Fabricate(:post, topic: topic) }

    it ""doesn't notify people who aren't watching"" do
      PostAlerter.post_created(post)
      expect(
        user.notifications.where(notification_type: Notification.types[:watching_first_post]).count,
      ).to eq(0)
    end

    it ""notifies the user who is following the first post category"" do
      level = CategoryUser.notification_levels[:watching_first_post]
      CategoryUser.set_notification_level_for_category(user, level, category.id)
      PostAlerter.new.after_save_post(post, true)
      expect(
        user.notifications.where(notification_type: Notification.types[:watching_first_post]).count,
      ).to eq(1)
    end

    it ""doesn't notify when the record is not new"" do
      level = CategoryUser.notification_levels[:watching_first_post]
      CategoryUser.set_notification_level_for_category(user, level, category.id)
      PostAlerter.new.after_save_post(post, false)
      expect(
        user.notifications.where(notification_type: Notification.types[:watching_first_post]).count,
      ).to eq(0)
    end

    it ""notifies the user who is following the first post tag"" do
      level = TagUser.notification_levels[:watching_first_post]
      TagUser.change(user.id, tag.id, level)
      PostAlerter.post_created(post)
      expect(
        user.notifications.where(notification_type: Notification.types[:watching_first_post]).count,
      ).to eq(1)
    end

    it ""notifies the user who is following the first post group"" do
      GroupUser.create(group_id: group.id, user_id: user.id)
      GroupUser.create(group_id: group.id, user_id: post.user.id)
      topic.topic_allowed_groups.create(group_id: group.id)

      level = GroupUser.notification_levels[:watching_first_post]
      GroupUser.where(user_id: user.id, group_id: group.id).update_all(notification_level: level)

      PostAlerter.post_created(post)
      expect(
        user.notifications.where(notification_type: Notification.types[:watching_first_post]).count,
      ).to eq(1)
    end

    it ""triggers :before_create_notifications_for_users"" do
      level = CategoryUser.notification_levels[:watching_first_post]
      CategoryUser.set_notification_level_for_category(user, level, category.id)
      events = DiscourseEvent.track_events { PostAlerter.new.after_save_post(post, true) }
      expect(events).to include(
        event_name: :before_create_notifications_for_users,
        params: [[user], post],
      )
    end

    it ""sends a push notification when user has a push subscription"" do
      setup_push_notification_subscription_for(user: user)

      level = CategoryUser.notification_levels[:watching_first_post]
      CategoryUser.set_notification_level_for_category(user, level, category.id)
      events =
        DiscourseEvent.track_events(:push_notification) do
          PostAlerter.new.after_save_post(post, true)
        end

      expect(
        events.detect do |e|
          e[:params][0] == user &&
            e[:params][1][:notification_type] == Notification.types[:watching_first_post]
        end,
      ).to be_present
    end
  end

  context ""with replies"" do
    it ""triggers :before_create_notifications_for_users"" do
      _post = Fabricate(:post, user: user, topic: topic)
      reply = Fabricate(:post, topic: topic, reply_to_post_number: 1)
      events = DiscourseEvent.track_events { PostAlerter.post_created(reply) }
      expect(events).to include(
        event_name: :before_create_notifications_for_users,
        params: [[user], reply],
      )
    end

    it ""notifies about regular reply"" do
      _post = Fabricate(:post, user: user, topic: topic)

      reply = Fabricate(:post, topic: topic, reply_to_post_number: 1)
      PostAlerter.post_created(reply)

      expect(user.notifications.where(notification_type: Notification.types[:replied]).count).to eq(
        1,
      )
    end

    it ""does not notify admins when suppress_secured_categories_from_admin is enabled"" do
      SiteSetting.suppress_secured_categories_from_admin = true

      topic = Fabricate(:topic, category: private_category)
      post = Fabricate(:post, raw: ""hello @#{admin.username} how are you today?"", topic: topic)

      PostAlerter.post_created(post)

      expect(admin.notifications.count).to eq(0)
    end

    it ""doesn't notify regular user about whispered reply"" do
      _post = Fabricate(:post, user: user, topic: topic)

      whispered_reply =
        Fabricate(
          :post,
          user: admin,
          topic: topic,
          post_type: Post.types[:whisper],
          reply_to_post_number: 1,
        )
      PostAlerter.post_created(whispered_reply)

      expect(user.notifications.where(notification_type: Notification.types[:replied]).count).to eq(
        0,
      )
    end

    it ""notifies staff user about whispered reply"" do
      admin1 = Fabricate(:admin)
      admin2 = Fabricate(:admin)

      _post = Fabricate(:post, user: user, topic: topic)

      whispered_reply1 =
        Fabricate(
          :post,
          user: admin1,
          topic: topic,
          post_type: Post.types[:whisper],
          reply_to_post_number: 1,
        )
      whispered_reply2 =
        Fabricate(
          :post,
          user: admin2,
          topic: topic,
          post_type: Post.types[:whisper],
          reply_to_post_number: 2,
        )
      PostAlerter.post_created(whispered_reply1)
      PostAlerter.post_created(whispered_reply2)

      expect(
        admin1.notifications.where(notification_type: Notification.types[:replied]).count,
      ).to eq(1)

      TopicUser.change(
        admin1.id,
        topic.id,
        notification_level: TopicUser.notification_levels[:watching],
      )

      # this should change nothing cause the moderator post has an action code
      # if we have an action code then we should never have notifications, this is rare but
      # assign whispers are like this
      whispered_reply3 =
        topic.add_moderator_post(
          admin2,
          ""i am a reply"",
          post_type: Post.types[:whisper],
          action_code: ""moderator_thing"",
        )
      PostAlerter.post_created(whispered_reply3)

      # if this whisper is not ignored like it should we would see a posted notification and no replied notifications
      notifications = admin1.notifications.where(topic_id: topic.id).to_a

      expect(notifications.first.notification_type).to eq(Notification.types[:replied])
      expect(notifications.length).to eq(1)
      expect(notifications.first.post_number).to eq(whispered_reply2.post_number)
    end

    it ""sends email notifications only to users not on CC list of incoming email"" do
      alice = Fabricate(:user, username: ""alice"", email: ""alice@example.com"")
      bob = Fabricate(:user, username: ""bob"", email: ""bob@example.com"")
      carol = Fabricate(:user, username: ""carol"", email: ""carol@example.com"", staged: true)
      dave = Fabricate(:user, username: ""dave"", email: ""dave@example.com"", staged: true)
      erin = Fabricate(:user, username: ""erin"", email: ""erin@example.com"")

      topic =
        Fabricate(
          :private_message_topic,
          topic_allowed_users: [
            Fabricate.build(:topic_allowed_user, user: alice),
            Fabricate.build(:topic_allowed_user, user: bob),
            Fabricate.build(:topic_allowed_user, user: carol),
            Fabricate.build(:topic_allowed_user, user: dave),
            Fabricate.build(:topic_allowed_user, user: erin),
          ],
        )
      _post = Fabricate(:post, user: alice, topic: topic)

      TopicUser.change(
        alice.id,
        topic.id,
        notification_level: TopicUser.notification_levels[:watching],
      )
      TopicUser.change(
        bob.id,
        topic.id,
        notification_level: TopicUser.notification_levels[:watching],
      )
      TopicUser.change(
        erin.id,
        topic.id,
        notification_level: TopicUser.notification_levels[:watching],
      )

      email =
        Fabricate(
          :incoming_email,
          raw: <<~RAW,
                          Return-Path: <bob@example.com>
                          From: Bob <bob@example.com>
                          To: meta+1234@discoursemail.com, dave@example.com
                          CC: carol@example.com, erin@example.com
                          Subject: Hello world
                          Date: Fri, 15 Jan 2016 00:12:43 +0100
                          Message-ID: <12345@example.com>
                          Mime-Version: 1.0
                          Content-Type: text/plain; charset=UTF-8
                          Content-Transfer-Encoding: quoted-printable

                          This post was created by email.
                        RAW
          from_address: ""bob@example.com"",
          to_addresses: ""meta+1234@discoursemail.com;dave@example.com"",
          cc_addresses: ""carol@example.com;erin@example.com"",
        )
      reply =
        Fabricate(
          :post_via_email,
          user: bob,
          topic: topic,
          incoming_email: email,
          reply_to_post_number: 1,
        )

      NotificationEmailer.expects(:process_notification).with { |n| n.user_id == alice.id }.once
      NotificationEmailer.expects(:process_notification).with { |n| n.user_id == bob.id }.never
      NotificationEmailer.expects(:process_notification).with { |n| n.user_id == carol.id }.never
      NotificationEmailer.expects(:process_notification).with { |n| n.user_id == dave.id }.never
      NotificationEmailer.expects(:process_notification).with { |n| n.user_id == erin.id }.never

      PostAlerter.post_created(reply)

      expect(alice.notifications.count).to eq(1)
      expect(bob.notifications.count).to eq(0)
      expect(carol.notifications.count).to eq(1)
      expect(dave.notifications.count).to eq(1)
      expect(erin.notifications.count).to eq(1)
    end

    it ""does not send email notifications to staged users when notification originates in mailinglist mirror category"" do
      category = Fabricate(:mailinglist_mirror_category)
      topic = Fabricate(:topic, category: category)
      user = Fabricate(:staged)
      _post = Fabricate(:post, user: user, topic: topic)
      reply = Fabricate(:post, topic: topic, reply_to_post_number: 1)

      NotificationEmailer.expects(:process_notification).never
      expect { PostAlerter.post_created(reply) }.not_to change(user.notifications, :count)

      category.mailinglist_mirror = false
      NotificationEmailer.expects(:process_notification).once
      expect { PostAlerter.post_created(reply) }.to change(user.notifications, :count).by(1)
    end

    it ""creates a notification of type `replied` instead of `posted` for the topic author if they're watching the topic"" do
      Jobs.run_immediately!

      u1 = Fabricate(:admin)
      u2 = Fabricate(:admin)

      topic = create_topic(user: u1)

      u1.notifications.destroy_all

      expect do create_post(topic: topic, user: u2) end.to change {
        u1.reload.notifications.count
      }.by(1)
      expect(
        u1.notifications.exists?(
          topic_id: topic.id,
          notification_type: Notification.types[:replied],
          post_number: 1,
          read: false,
        ),
      ).to eq(true)
    end

    it ""it doesn't notify about small action posts when the topic author is watching the topic "" do
      Jobs.run_immediately!

      u1 = Fabricate(:admin)
      u2 = Fabricate(:admin)

      topic = create_topic(user: u1)

      u1.notifications.destroy_all

      expect do topic.update_status(""closed"", true, u2, message: ""hello world"") end.not_to change {
        u1.reload.notifications.count
      }
    end
  end

  context ""with category"" do
    context ""with watching"" do
      it ""triggers :before_create_notifications_for_users"" do
        topic = Fabricate(:topic, category: category)
        post = Fabricate(:post, topic: topic)
        level = CategoryUser.notification_levels[:watching]
        CategoryUser.set_notification_level_for_category(user, level, category.id)
        events = DiscourseEvent.track_events { PostAlerter.post_created(post) }
        expect(events).to include(
          event_name: :before_create_notifications_for_users,
          params: [[user], post],
        )
      end

      it ""notifies staff about whispered post"" do
        topic = Fabricate(:topic, category: category)
        level = CategoryUser.notification_levels[:watching]
        CategoryUser.set_notification_level_for_category(admin, level, category.id)
        CategoryUser.set_notification_level_for_category(user, level, category.id)
        whispered_post =
          Fabricate(:post, user: Fabricate(:admin), topic: topic, post_type: Post.types[:whisper])
        expect { PostAlerter.post_created(whispered_post) }.to add_notification(
          admin,
          :watching_category_or_tag,
        )
        expect { PostAlerter.post_created(whispered_post) }.not_to add_notification(
          user,
          :watching_category_or_tag,
        )
      end

      it ""notifies a staged user about a private post, but only if the user has access"" do
        staged_member = Fabricate(:staged)
        staged_non_member = Fabricate(:staged)
        group_member = Fabricate(:user)

        group.add(group_member)
        group.add(staged_member)

        level = CategoryUser.notification_levels[:watching]
        CategoryUser.set_notification_level_for_category(group_member, level, private_category.id)
        CategoryUser.set_notification_level_for_category(staged_member, level, private_category.id)
        CategoryUser.set_notification_level_for_category(
          staged_non_member,
          level,
          private_category.id,
        )

        topic = Fabricate(:topic, category: private_category, user: group_member)
        post = Fabricate(:post, topic: topic)

        expect { PostAlerter.post_created(post) }.to add_notification(
          staged_member,
          :watching_category_or_tag,
        ).and not_add_notification(staged_non_member, :watching_category_or_tag)
      end

      it ""does not update existing unread notification"" do
        CategoryUser.set_notification_level_for_category(
          user,
          CategoryUser.notification_levels[:watching],
          category.id,
        )
        topic = Fabricate(:topic, category: category)

        post = Fabricate(:post, topic: topic)
        PostAlerter.post_created(post)
        notification = Notification.last
        expect(notification.topic_id).to eq(topic.id)
        expect(notification.post_number).to eq(1)

        post = Fabricate(:post, topic: topic)
        PostAlerter.post_created(post)
        notification = Notification.last
        expect(notification.topic_id).to eq(topic.id)
        expect(notification.post_number).to eq(1)
        notification_data = JSON.parse(notification.data)
        expect(notification_data[""display_username""]).to eq(I18n.t(""embed.replies"", count: 2))
      end

      it ""sends a push notification when user has a push subscription"" do
        setup_push_notification_subscription_for(user: user)

        topic = Fabricate(:topic, category: category)
        post = Fabricate(:post, topic: topic)
        level = CategoryUser.notification_levels[:watching]
        CategoryUser.set_notification_level_for_category(user, level, category.id)
        events = DiscourseEvent.track_events(:push_notification) { PostAlerter.post_created(post) }

        expect(
          events.detect do |e|
            e[:params][0] == user &&
              e[:params][1][:notification_type] == Notification.types[:watching_category_or_tag]
          end,
        ).to be_present
      end
    end
  end

  context ""with tags"" do
    context ""with watching"" do
      it ""triggers :before_create_notifications_for_users"" do
        tag = Fabricate(:tag)
        topic = Fabricate(:topic, tags: [tag])
        post = Fabricate(:post, topic: topic)
        level = TagUser.notification_levels[:watching]
        TagUser.change(user.id, tag.id, level)
        events = DiscourseEvent.track_events { PostAlerter.post_created(post) }
        expect(events).to include(
          event_name: :before_create_notifications_for_users,
          params: [[user], post],
        )
      end

      it ""does not update existing unread notification"" do
        tag = Fabricate(:tag)
        TagUser.change(user.id, tag.id, TagUser.notification_levels[:watching])
        topic = Fabricate(:topic, tags: [tag])

        post = Fabricate(:post, topic: topic)
        PostAlerter.post_created(post)
        notification = Notification.last
        expect(notification.topic_id).to eq(topic.id)
        expect(notification.post_number).to eq(1)

        post = Fabricate(:post, topic: topic)
        PostAlerter.post_created(post)
        notification = Notification.last
        expect(notification.topic_id).to eq(topic.id)
        expect(notification.post_number).to eq(1)
        notification_data = JSON.parse(notification.data)
        expect(notification_data[""display_username""]).to eq(I18n.t(""embed.replies"", count: 2))
      end

      it ""does not add notification if user does not belong to tag group with permissions"" do
        tag = Fabricate(:tag)
        topic = Fabricate(:topic, tags: [tag])
        post = Fabricate(:post, topic: topic)

        tag_group = TagGroup.new(name: ""Only visible to group"", tag_names: [tag.name])
        tag_group.permissions = [[group.id, TagGroupPermission.permission_types[:full]]]
        tag_group.save!

        TagUser.change(user.id, tag.id, TagUser.notification_levels[:watching])

        expect { PostAlerter.post_created(post) }.not_to change { Notification.count }
      end

      it ""adds notification if user belongs to tag group with permissions"" do
        tag = Fabricate(:tag)
        topic = Fabricate(:topic, tags: [tag])
        post = Fabricate(:post, topic: topic)
        tag_group = Fabricate(:tag_group, tags: [tag])
        Fabricate(:group_user, group: group, user: user)
        Fabricate(:tag_group_permission, tag_group: tag_group, group: group)

        TagUser.change(user.id, tag.id, TagUser.notification_levels[:watching])

        expect { PostAlerter.post_created(post) }.to change { Notification.count }.by(1)
      end
    end

    context ""with category and tags"" do
      fab!(:muted_category) do
        Fabricate(:category).tap do |category|
          CategoryUser.set_notification_level_for_category(
            user,
            CategoryUser.notification_levels[:muted],
            category.id,
          )
        end
      end
      fab!(:muted_tag) do
        Fabricate(:tag).tap do |tag|
          TagUser.create!(
            user: user,
            tag: tag,
            notification_level: TagUser.notification_levels[:muted],
          )
        end
      end
      fab!(:watched_tag) do
        Fabricate(:tag).tap do |tag|
          TagUser.create!(
            user: user,
            tag: tag,
            notification_level: TagUser.notification_levels[:watching],
          )
        end
      end
      fab!(:topic_with_muted_tag_and_watched_category) do
        Fabricate(:topic, category: category, tags: [muted_tag])
      end
      fab!(:topic_with_muted_category_and_watched_tag) do
        Fabricate(:topic, category: muted_category, tags: [watched_tag])
      end
      fab!(:directly_watched_topic) do
        Fabricate(:topic, category: muted_category, tags: [muted_tag])
      end
      fab!(:topic_user) do
        Fabricate(
          :topic_user,
          topic: directly_watched_topic,
          user: user,
          notification_level: TopicUser.notification_levels[:watching],
        )
      end
      fab!(:topic_with_watched_category) { Fabricate(:topic, category: category) }
      fab!(:post) { Fabricate(:post, topic: topic_with_muted_tag_and_watched_category) }
      fab!(:post_2) { Fabricate(:post, topic: topic_with_muted_category_and_watched_tag) }
      fab!(:post_3) { Fabricate(:post, topic: topic_with_watched_category) }
      fab!(:post_4) { Fabricate(:post, topic: directly_watched_topic) }

      before do
        CategoryUser.set_notification_level_for_category(
          user,
          CategoryUser.notification_levels[:watching],
          category.id,
        )
      end

      it ""adds notification when watched_precedence_over_muted setting is true"" do
        SiteSetting.watched_precedence_over_muted = true
        expect {
          PostAlerter.post_created(topic_with_muted_tag_and_watched_category.posts.first)
        }.to change { Notification.count }.by(1)
        expect {
          PostAlerter.post_created(topic_with_muted_category_and_watched_tag.posts.first)
        }.to change { Notification.count }.by(1)
        expect { PostAlerter.post_created(directly_watched_topic.posts.first) }.to change {
          Notification.count
        }.by(1)
      end

      it ""respects user option even if watched_precedence_over_muted site setting is true"" do
        SiteSetting.watched_precedence_over_muted = true
        user.user_option.update!(watched_precedence_over_muted: false)
        expect {
          PostAlerter.post_created(topic_with_muted_tag_and_watched_category.posts.first)
        }.not_to change { Notification.count }
        expect {
          PostAlerter.post_created(topic_with_muted_category_and_watched_tag.posts.first)
        }.not_to change { Notification.count }
        expect { PostAlerter.post_created(directly_watched_topic.posts.first) }.to change {
          Notification.count
        }.by(1)
      end

      it ""does not add notification when watched_precedence_over_muted setting is false"" do
        SiteSetting.watched_precedence_over_muted = false
        expect {
          PostAlerter.post_created(topic_with_muted_tag_and_watched_category.posts.first)
        }.not_to change { Notification.count }
        expect {
          PostAlerter.post_created(topic_with_muted_category_and_watched_tag.posts.first)
        }.not_to change { Notification.count }
        expect { PostAlerter.post_created(topic_with_watched_category.posts.first) }.to change {
          Notification.count
        }.by(1)
        expect { PostAlerter.post_created(directly_watched_topic.posts.first) }.to change {
          Notification.count
        }.by(1)
      end

      it ""respects user option even if watched_precedence_over_muted site setting is false"" do
        SiteSetting.watched_precedence_over_muted = false
        user.user_option.update!(watched_precedence_over_muted: true)
        expect {
          PostAlerter.post_created(topic_with_muted_tag_and_watched_category.posts.first)
        }.to change { Notification.count }.by(1)
        expect {
          PostAlerter.post_created(topic_with_muted_category_and_watched_tag.posts.first)
        }.to change { Notification.count }.by(1)
        expect { PostAlerter.post_created(directly_watched_topic.posts.first) }.to change {
          Notification.count
        }.by(1)
      end
    end

    context ""with on change"" do
      fab!(:user)
      fab!(:other_tag) { Fabricate(:tag) }
      fab!(:watched_tag) { Fabricate(:tag) }

      before do
        SiteSetting.tagging_enabled = true
        Jobs.run_immediately!
        TagUser.change(user.id, watched_tag.id, TagUser.notification_levels[:watching_first_post])
        TopicUser.change(
          Fabricate(:user).id,
          post.topic.id,
          notification_level: TopicUser.notification_levels[:watching],
        )
      end

      it ""triggers a notification"" do
        expect(
          user
            .notifications
            .where(notification_type: Notification.types[:watching_first_post])
            .count,
        ).to eq(0)

        expect {
          PostRevisor.new(post).revise!(Fabricate(:user), tags: [other_tag.name, watched_tag.name])
        }.to change { Notification.where(user_id: user.id).count }.by(1)
        expect(
          user
            .notifications
            .where(notification_type: Notification.types[:watching_first_post])
            .count,
        ).to eq(1)

        expect {
          PostRevisor.new(post).revise!(Fabricate(:user), tags: [watched_tag.name, other_tag.name])
        }.not_to change { Notification.count }
        expect(
          user
            .notifications
            .where(notification_type: Notification.types[:watching_first_post])
            .count,
        ).to eq(1)
      end

      it ""doesn't trigger a notification if topic is unlisted"" do
        post.topic.update_column(:visible, false)

        expect(
          user
            .notifications
            .where(notification_type: Notification.types[:watching_first_post])
            .count,
        ).to eq(0)

        PostRevisor.new(post).revise!(Fabricate(:user), tags: [other_tag.name, watched_tag.name])
        expect(
          user
            .notifications
            .where(notification_type: Notification.types[:watching_first_post])
            .count,
        ).to eq(0)
      end
    end

    context ""with private message"" do
      fab!(:post) { Fabricate(:private_message_post) }
      fab!(:other_tag) { Fabricate(:tag) }
      fab!(:other_tag2) { Fabricate(:tag) }
      fab!(:other_tag3) { Fabricate(:tag) }
      fab!(:user)
      fab!(:staged)

      before do
        SiteSetting.tagging_enabled = true
        SiteSetting.pm_tags_allowed_for_groups = ""1|2|3""
        Jobs.run_immediately!
        TopicUser.change(
          user.id,
          post.topic.id,
          notification_level: TopicUser.notification_levels[:watching],
        )
        TopicUser.change(
          staged.id,
          post.topic.id,
          notification_level: TopicUser.notification_levels[:watching],
        )
        TopicUser.change(
          admin.id,
          post.topic.id,
          notification_level: TopicUser.notification_levels[:watching],
        )
        TagUser.change(staged.id, other_tag.id, TagUser.notification_levels[:watching])
        TagUser.change(admin.id, other_tag3.id, TagUser.notification_levels[:watching])
        post.topic.allowed_users << user
        post.topic.allowed_users << staged
      end

      it ""only notifies staff watching added tag"" do
        expect(PostRevisor.new(post).revise!(Fabricate(:admin), tags: [other_tag.name])).to be true
        expect(Notification.where(user_id: staged.id).count).to eq(0)
        expect(PostRevisor.new(post).revise!(Fabricate(:admin), tags: [other_tag2.name])).to be true
        expect(Notification.where(user_id: admin.id).count).to eq(0)
        expect(PostRevisor.new(post).revise!(Fabricate(:admin), tags: [other_tag3.name])).to be true
        expect(Notification.where(user_id: admin.id).count).to eq(1)
      end
    end

    context ""with tag groups"" do
      fab!(:tag)
      fab!(:user)
      fab!(:topic) { Fabricate(:topic, tags: [tag]) }
      fab!(:post) { Fabricate(:post, topic: topic) }

      shared_examples ""tag user with notification level"" do |notification_level, notification_type|
        it ""notifies a user who is watching a tag that does not belong to a tag group"" do
          TagUser.change(user.id, tag.id, TagUser.notification_levels[notification_level])
          PostAlerter.post_created(post)
          expect(
            user
              .notifications
              .where(notification_type: Notification.types[notification_type])
              .count,
          ).to eq(1)
        end

        it ""does not notify a user watching a tag with tag group permissions that he does not belong to"" do
          tag_group = Fabricate(:tag_group, tags: [tag], permissions: { group.name => 1 })

          TagUser.change(user.id, tag.id, TagUser.notification_levels[notification_level])

          PostAlerter.post_created(post)

          expect(
            user
              .notifications
              .where(notification_type: Notification.types[notification_type])
              .count,
          ).to eq(0)
        end

        it ""notifies a user watching a tag with tag group permissions that he belongs to"" do
          Fabricate(:group_user, group: group, user: user)

          TagUser.change(user.id, tag.id, TagUser.notification_levels[notification_level])

          PostAlerter.post_created(post)

          expect(
            user
              .notifications
              .where(notification_type: Notification.types[notification_type])
              .count,
          ).to eq(1)
        end

        it ""notifies a staff watching a tag with tag group permissions that he does not belong to"" do
          tag_group = Fabricate(:tag_group, tags: [tag])
          Fabricate(:tag_group_permission, tag_group: tag_group, group: group)
          staff_group = Group.find(Group::AUTO_GROUPS[:staff])
          Fabricate(:group_user, group: staff_group, user: user)

          TagUser.change(user.id, tag.id, TagUser.notification_levels[notification_level])

          PostAlerter.post_created(post)

          expect(
            user
              .notifications
              .where(notification_type: Notification.types[notification_type])
              .count,
          ).to eq(1)
        end
      end

      context ""with :watching notification level"" do
        include_examples ""tag user with notification level"", :watching, :watching_category_or_tag
      end

      context ""with :watching_first_post notification level"" do
        include_examples ""tag user with notification level"",
                         :watching_first_post,
                         :watching_first_post
      end
    end
  end

  describe ""#extract_linked_users"" do
    fab!(:post) { Fabricate(:post, topic: topic) }
    fab!(:post2) { Fabricate(:post) }

    describe ""when linked post has been deleted"" do
      let(:topic_link) do
        TopicLink.create!(
          url: ""/t/#{topic.id}"",
          topic_id: topic.id,
          link_topic_id: post2.topic.id,
          link_post_id: nil,
          post_id: post.id,
          user: user,
          domain: ""test.com"",
        )
      end

      it ""should use the first post of the topic"" do
        topic_link
        expect(PostAlerter.new.extract_linked_users(post.reload)).to eq([post2.user])
      end
    end
  end

  describe ""#notify_post_users"" do
    fab!(:post) { Fabricate(:post, topic: topic) }
    fab!(:last_editor) { Fabricate(:user) }
    fab!(:tag)
    fab!(:category)

    it ""creates single edit notification when post is modified"" do
      TopicUser.create!(
        user_id: user.id,
        topic_id: topic.id,
        notification_level: TopicUser.notification_levels[:watching],
        last_read_post_number: post.post_number,
      )

      PostRevisor.new(post).revise!(last_editor, tags: [tag.name])
      PostAlerter.new.notify_post_users(post, [])
      expect(Notification.count).to eq(1)
      expect(Notification.last.notification_type).to eq(Notification.types[:edited])
      expect(JSON.parse(Notification.last.data)[""display_username""]).to eq(last_editor.username)

      PostAlerter.new.notify_post_users(post, [])
      expect(Notification.count).to eq(1)
    end

    it ""creates posted notification when Sidekiq is slow"" do
      CategoryUser.set_notification_level_for_category(
        user,
        CategoryUser.notification_levels[:watching],
        category.id,
      )

      post =
        PostCreator.create!(
          Fabricate(:user),
          title: ""one of my first topics"",
          raw: ""one of my first posts"",
          category: category.id,
        )

      TopicUser.change(user, post.topic_id, last_read_post_number: post.post_number)

      # Manually run job after the user read the topic to simulate a slow
      # Sidekiq.
      job_args = Jobs::PostAlert.jobs[0][""args""][0]
      expect { Jobs::PostAlert.new.execute(job_args.with_indifferent_access) }.to change {
        Notification.count
      }.by(1)

      expect(Notification.last.notification_type).to eq(Notification.types[:posted])
    end
  end

  context ""with SMTP (group_smtp_email)"" do
    before do
      SiteSetting.enable_smtp = true
      SiteSetting.email_in = true
      Jobs.run_immediately!
    end

    fab!(:group) do
      Fabricate(
        :group,
        smtp_server: ""smtp.gmail.com"",
        smtp_port: 587,
        smtp_ssl: true,
        imap_server: ""imap.gmail.com"",
        imap_port: 993,
        imap_ssl: true,
        email_username: ""discourse@example.com"",
        email_password: ""password"",
        smtp_enabled: true,
        imap_enabled: true,
      )
    end

    def create_post_with_incoming
      raw_mail = <<~EMAIL
      From: Foo <foo@discourse.org>
      To: discourse@example.com
      Cc: bar@discourse.org, jim@othersite.com
      Subject: Full email group username flow
      Date: Fri, 15 Jan 2021 00:12:43 +0100
      Message-ID: <u4w8c9r4y984yh98r3h69873@example.com.mail>
      Mime-Version: 1.0
      Content-Type: text/plain
      Content-Transfer-Encoding: 7bit

      This is the first email.
      EMAIL

      Email::Receiver.new(raw_mail, {}).process!
    end

    it ""does not error if SMTP is enabled and the topic has no incoming email or allowed groups"" do
      expect { PostAlerter.new.after_save_post(post, true) }.not_to raise_error
    end

    it ""does not error if SMTP is enabled and the topic has no incoming email but does have an allowed group"" do
      TopicAllowedGroup.create(topic: private_message_topic, group: group)
      expect { PostAlerter.new.after_save_post(post, true) }.not_to raise_error
    end

    it ""does not error if SMTP is enabled and the topic has no incoming email but has multiple allowed groups"" do
      TopicAllowedGroup.create(topic: private_message_topic, group: group)
      TopicAllowedGroup.create(topic: private_message_topic, group: Fabricate(:group))
      expect { PostAlerter.new.after_save_post(post, true) }.not_to raise_error
    end

    it ""sends a group smtp email because SMTP is enabled for the site and the group"" do
      incoming_email_post = create_post_with_incoming
      topic = incoming_email_post.topic
      post = Fabricate(:post, topic: topic)
      expect { PostAlerter.new.after_save_post(post, true) }.to change {
        ActionMailer::Base.deliveries.size
      }.by(1)
      email = ActionMailer::Base.deliveries.last
      expect(email.from).to include(group.email_username)
      expect(email.to).to contain_exactly(
        topic.reload.topic_allowed_users.order(:created_at).first.user.email,
      )
      expect(email.cc).to match_array(%w[bar@discourse.org jim@othersite.com])
      expect(email.subject).to eq(""Re: #{topic.title}"")
    end

    it ""sends a group smtp email when the original group has had SMTP disabled and there is an additional topic allowed group"" do
      incoming_email_post = create_post_with_incoming
      topic = incoming_email_post.topic
      other_allowed_group = Fabricate(:smtp_group)
      TopicAllowedGroup.create(group: other_allowed_group, topic: topic)
      post = Fabricate(:post, topic: topic)
      group.update!(smtp_enabled: false)

      expect { PostAlerter.new.after_save_post(post, true) }.to change {
        ActionMailer::Base.deliveries.size
      }.by(1)

      email = ActionMailer::Base.deliveries.last
      expect(email.from).to include(other_allowed_group.email_username)
      expect(email.to).to contain_exactly(
        topic.reload.topic_allowed_users.order(:created_at).first.user.email,
      )
      expect(email.cc).to match_array(%w[bar@discourse.org jim@othersite.com])
      expect(email.subject).to eq(""Re: #{topic.title}"")
    end

    it ""does not send a group smtp email if smtp is not enabled for the group"" do
      group.update!(smtp_enabled: false)
      incoming_email_post = create_post_with_incoming
      topic = incoming_email_post.topic
      post = Fabricate(:post, topic: topic)
      expect { PostAlerter.new.after_save_post(post, true) }.not_to change {
        ActionMailer::Base.deliveries.size
      }
    end

    it ""does not send a group smtp email if SiteSetting.enable_smtp is false"" do
      SiteSetting.enable_smtp = false
      incoming_email_post = create_post_with_incoming
      topic = incoming_email_post.topic
      post = Fabricate(:post, topic: topic)
      expect { PostAlerter.new.after_save_post(post, true) }.not_to change {
        ActionMailer::Base.deliveries.size
      }
    end

    it ""does not send group smtp emails for a whisper"" do
      incoming_email_post = create_post_with_incoming
      topic = incoming_email_post.topic
      post = Fabricate(:post, topic: topic, post_type: Post.types[:whisper])
      expect { PostAlerter.new.after_save_post(post, true) }.not_to change {
        ActionMailer::Base.deliveries.size
      }
    end

    it ""sends the group smtp email job with a delay of personal_email_time_window_seconds"" do
      freeze_time
      incoming_email_post = create_post_with_incoming
      topic = incoming_email_post.topic
      post = Fabricate(:post, topic: topic)
      PostAlerter.new.after_save_post(post, true)
      job_enqueued?(
        job: :group_smtp_email,
        args: {
          group_id: group.id,
          post_id: post.id,
          email: topic.reload.topic_allowed_users.order(:created_at).first.user.email,
          cc_emails: %w[bar@discourse.org jim@othersite.com],
        },
        at: Time.zone.now + SiteSetting.personal_email_time_window_seconds.seconds,
      )
    end

    it ""does not send a group smtp email for anyone if the reply post originates from an incoming email that is auto generated"" do
      incoming_email_post = create_post_with_incoming
      topic = incoming_email_post.topic
      post = Fabricate(:post, topic: topic)
      Fabricate(:incoming_email, post: post, topic: topic, is_auto_generated: true)
      expect_not_enqueued_with(job: :group_smtp_email) do
        expect { PostAlerter.new.after_save_post(post, true) }.not_to change {
          ActionMailer::Base.deliveries.size
        }
      end
    end

    it ""skips sending a notification email to the group and all other email addresses that are _not_ members of the group,
    sends a group_smtp_email instead"" do
      NotificationEmailer.enable

      incoming_email_post = create_post_with_incoming
      topic = incoming_email_post.topic

      group_user1 = Fabricate(:group_user, group: group)
      group_user2 = Fabricate(:group_user, group: group)
      TopicUser.create(
        user: group_user1.user,
        notification_level: TopicUser.notification_levels[:watching],
        topic: topic,
      )
      post = Fabricate(:post, topic: topic.reload)

      # Sends an email for:
      #
      # 1. the group user that is watching the post (but does not send this email with group SMTO)
      # 2. the group smtp email to notify all topic_users not in the group
      expect { PostAlerter.new.after_save_post(post, true) }.to change {
        ActionMailer::Base.deliveries.size
      }.by(2).and change { Notification.count }.by(2)

      # The group smtp email
      email = ActionMailer::Base.deliveries.first
      expect(email.from).to eq([group.email_username])
      expect(email.to).to contain_exactly(""foo@discourse.org"")
      expect(email.cc).to match_array(%w[bar@discourse.org jim@othersite.com])
      expect(email.subject).to eq(""Re: #{topic.title}"")

      # The watching group user notification email
      email = ActionMailer::Base.deliveries.last
      expect(email.from).to eq([SiteSetting.notification_email])
      expect(email.to).to contain_exactly(group_user1.user.email)
      expect(email.cc).to eq(nil)
      expect(email.subject).to eq(""[Discourse] [PM] #{topic.title}"")
    end

    it ""skips sending a notification email to the cc address that was added on the same post with an incoming email"" do
      NotificationEmailer.enable

      incoming_email_post = create_post_with_incoming
      topic = incoming_email_post.topic

      post = Fabricate(:post, topic: topic.reload)
      expect { PostAlerter.new.after_save_post(post, true) }.to change {
        ActionMailer::Base.deliveries.size
      }.by(1).and change { Notification.count }.by(1)
      email = ActionMailer::Base.deliveries.last

      # the reply post from someone who was emailed
      reply_raw_mail = <<~EMAIL
      From: Bar <bar@discourse.org>
      To: discourse@example.com
      Cc: someothernewcc@baz.com, finalnewcc@doom.com
      Subject: #{email.subject}
      Date: Fri, 16 Jan 2021 00:12:43 +0100
      Message-ID: <sdugj3o4iyu4832x3487@discourse.org.mail>
      In-Reply-To: #{email.message_id}
      Mime-Version: 1.0
      Content-Type: text/plain
      Content-Transfer-Encoding: 7bit

      Hey here is my reply!
      EMAIL

      reply_post_from_email = nil
      expect {
        reply_post_from_email = Email::Receiver.new(reply_raw_mail, {}).process!
      }.to change {
        User.count # the two new cc addresses have users created
      }.by(2).and change {
              TopicAllowedUser.where(topic: topic).count # and they are added as topic allowed users
            }.by(2).and change {
                    # but they are not sent emails because they were cc'd on an email, only jim@othersite.com
                    # is emailed because he is a topic allowed user cc'd on the _original_ email and he is not
                    # the one creating the post, and foo@discourse.org, who is the OP of the topic
                    ActionMailer::Base.deliveries.size
                  }.by(1).and change {
                          Notification.count # and they are still sent their normal discourse notification
                        }.by(2)

      email = ActionMailer::Base.deliveries.last

      expect(email.to).to eq([""foo@discourse.org""])
      expect(email.cc).to eq([""jim@othersite.com""])
      expect(email.from).to eq([group.email_username])
      expect(email.subject).to eq(""Re: #{topic.title}"")
    end

    it ""handles the OP of the topic replying by email and sends a group email to the other topic allowed users successfully"" do
      NotificationEmailer.enable

      incoming_email_post = create_post_with_incoming
      topic = incoming_email_post.topic
      post = Fabricate(:post, topic: topic.reload)
      expect { PostAlerter.new.after_save_post(post, true) }.to change {
        ActionMailer::Base.deliveries.size
      }.by(1).and change { Notification.count }.by(1)
      email = ActionMailer::Base.deliveries.last

      # the reply post from someone who was emailed
      reply_raw_mail = <<~EMAIL
      From: Foo <foo@discourse.org>
      To: discourse@example.com
      Cc: someothernewcc@baz.com, finalnewcc@doom.com
      Subject: #{email.subject}
      Date: Fri, 16 Jan 2021 00:12:43 +0100
      Message-ID: <sgk094238uc0348c334483@discourse.org.mail>
      In-Reply-To: #{email.message_id}
      Mime-Version: 1.0
      Content-Type: text/plain
      Content-Transfer-Encoding: 7bit

      I am ~~Commander Shepherd~~ the OP and I approve of this message.
      EMAIL

      reply_post_from_email = nil
      expect {
        reply_post_from_email = Email::Receiver.new(reply_raw_mail, {}).process!
      }.to change {
        User.count # the two new cc addresses have users created
      }.by(2).and change {
              TopicAllowedUser.where(topic: topic).count # and they are added as topic allowed users
            }.by(2).and change {
                    # but they are not sent emails because they were cc'd on an email, only jim@othersite.com
                    # is emailed because he is a topic allowed user cc'd on the _original_ email and he is not
                    # the one creating the post
                    ActionMailer::Base.deliveries.size
                  }.by(1).and change {
                          Notification.count # and they are still sent their normal discourse notification
                        }.by(2)

      email = ActionMailer::Base.deliveries.last

      expect(email.to).to eq([""bar@discourse.org""])
      expect(email.cc).to eq([""jim@othersite.com""])
      expect(email.from).to eq([group.email_username])
      expect(email.subject).to eq(""Re: #{topic.title}"")
    end

    it ""handles the OP of the topic replying by email and cc'ing new people, and does not send a group SMTP email to those newly cc'd users"" do
      NotificationEmailer.enable

      # this is a special case where we are not CC'ing on the original email,
      # only on the follow up email
      raw_mail = <<~EMAIL
      From: Foo <foo@discourse.org>
      To: discourse@example.com
      Subject: Full email group username flow
      Date: Fri, 14 Jan 2021 00:12:43 +0100
      Message-ID: <f4832ujfc3498u398i3@example.com.mail>
      Mime-Version: 1.0
      Content-Type: text/plain
      Content-Transfer-Encoding: 7bit

      This is the first email.
      EMAIL

      incoming_email_post = Email::Receiver.new(raw_mail, {}).process!
      topic = incoming_email_post.topic
      post = Fabricate(:post, topic: topic.reload)
      expect { PostAlerter.new.after_save_post(post, true) }.to change {
        ActionMailer::Base.deliveries.size
      }.by(1).and change { Notification.count }.by(1)
      email = ActionMailer::Base.deliveries.last

      # the reply post from the OP, cc'ing new people in
      reply_raw_mail = <<~EMAIL
      From: Foo <foo@discourse.org>
      To: discourse@example.com
      Cc: someothernewcc@baz.com, finalnewcc@doom.com
      Subject: #{email.subject}
      Date: Fri, 16 Jan 2021 00:12:43 +0100
      Message-ID: <3849cu9843yncr9834yr9348x934@discourse.org.mail>
      In-Reply-To: #{email.message_id}
      Mime-Version: 1.0
      Content-Type: text/plain
      Content-Transfer-Encoding: 7bit

      I am inviting my mates to this email party.
      EMAIL

      reply_post_from_email = nil
      expect {
        reply_post_from_email = Email::Receiver.new(reply_raw_mail, {}).process!
      }.to change {
        User.count # the two new cc addresses have users created
      }.by(2).and change {
              TopicAllowedUser.where(topic: topic).count # and they are added as topic allowed users
            }.by(2).and not_change {
                    # but they are not sent emails because they were cc'd on an email.
                    # no group smtp message is sent because the OP is not sent an email,
                    # they made this post.
                    ActionMailer::Base.deliveries.size
                  }.and change {
                          Notification.count # and they are still sent their normal discourse notification
                        }.by(2)

      last_email = ActionMailer::Base.deliveries.last
      expect(email).to eq(last_email)
    end
  end

  describe ""storing custom data"" do
    let(:custom_data) { ""custom_string"" }

    it ""stores custom data inside a notification"" do
      PostAlerter.new.create_notification(
        admin,
        Notification.types[:liked],
        post,
        custom_data: {
          custom_key: custom_data,
        },
      )

      liked_notification = Notification.where(notification_type: Notification.types[:liked]).last

      expect(liked_notification.data_hash[:custom_key]).to eq(custom_data)
    end
  end

  it ""does not create notifications for PMs if not invited"" do
    SiteSetting.pm_tags_allowed_for_groups = ""#{Group::AUTO_GROUPS[:everyone]}""
    watching_first_post_tag = Fabricate(:tag)
    TagUser.change(
      admin.id,
      watching_first_post_tag.id,
      TagUser.notification_levels[:watching_first_post],
    )
    watching_tag = Fabricate(:tag)
    TagUser.change(admin.id, watching_tag.id, TagUser.notification_levels[:watching])

    post =
      create_post(
        tags: [watching_first_post_tag.name, watching_tag.name],
        archetype: Archetype.private_message,
        target_usernames: ""#{evil_trout.username}"",
      )
    expect { PostAlerter.new.after_save_post(post, true) }.to change { Notification.count }.by(1)

    notification = Notification.last
    expect(notification.user).to eq(evil_trout)
    expect(notification.notification_type).to eq(Notification.types[:private_message])
    expect(notification.topic).to eq(post.topic)
    expect(notification.post_number).to eq(1)
  end

  it ""does not create multiple notifications for same post"" do
    category = Fabricate(:category)
    CategoryUser.set_notification_level_for_category(
      user,
      NotificationLevels.all[:tracking],
      category.id,
    )
    watching_first_post_tag = Fabricate(:tag)
    TagUser.change(
      user.id,
      watching_first_post_tag.id,
      TagUser.notification_levels[:watching_first_post],
    )
    watching_tag = Fabricate(:tag)
    TagUser.change(user.id, watching_tag.id, TagUser.notification_levels[:watching])

    post = create_post(category: category, tags: [watching_first_post_tag.name, watching_tag.name])
    expect { PostAlerter.new.after_save_post(post, true) }.to change { Notification.count }.by(1)

    notification = Notification.last
    expect(notification.user).to eq(user)
    expect(notification.notification_type).to eq(Notification.types[:watching_category_or_tag])
    expect(notification.topic).to eq(post.topic)
    expect(notification.post_number).to eq(1)
  end

  it ""triggers all discourse events"" do
    expected_events = %i[
      post_alerter_before_mentions
      post_alerter_before_replies
      post_alerter_before_quotes
      post_alerter_before_linked
      post_alerter_before_post
      post_alerter_before_first_post
      post_alerter_after_save_post
    ]

    events = DiscourseEvent.track_events { PostAlerter.new.after_save_post(post, true) }

    # Expect all the notification events are called
    # There are some other events triggered from outside after_save_post
    expect(events.map { |e| e[:event_name] }).to include(*expected_events)

    # Expect each notification event is called with the right parameters
    events.each do |event|
      if expected_events.include?(event[:event_name])
        expect(event[:params]).to eq([post, true, [post.user]])
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class ExternalUploadManager
  DOWNLOAD_LIMIT = 100.megabytes
  SIZE_MISMATCH_BAN_MINUTES = 5
  BAN_USER_REDIS_PREFIX = ""ban_user_from_external_uploads_""

  UPLOAD_TYPES_EXCLUDED_FROM_UPLOAD_PROMOTION = [""backup""].freeze

  class ChecksumMismatchError < StandardError
  end
  class DownloadFailedError < StandardError
  end
  class CannotPromoteError < StandardError
  end
  class SizeMismatchError < StandardError
  end

  attr_reader :external_upload_stub

  def self.ban_user_from_external_uploads!(user:, ban_minutes: 5)
    Discourse.redis.setex(""#{BAN_USER_REDIS_PREFIX}#{user.id}"", ban_minutes.minutes.to_i, ""1"")
  end

  def self.user_banned?(user)
    Discourse.redis.get(""#{BAN_USER_REDIS_PREFIX}#{user.id}"") == ""1""
  end

  def self.create_direct_upload(current_user:, file_name:, file_size:, upload_type:, metadata: {})
    store = store_for_upload_type(upload_type)
    url, signed_headers = store.signed_request_for_temporary_upload(file_name, metadata: metadata)
    key = store.s3_helper.path_from_url(url)

    upload_stub =
      ExternalUploadStub.create!(
        key: key,
        created_by: current_user,
        original_filename: file_name,
        upload_type: upload_type,
        filesize: file_size,
      )

    {
      url: url,
      key: key,
      unique_identifier: upload_stub.unique_identifier,
      signed_headers: signed_headers,
    }
  end

  def self.create_direct_multipart_upload(
    current_user:,
    file_name:,
    file_size:,
    upload_type:,
    metadata: {}
  )
    content_type = MiniMime.lookup_by_filename(file_name)&.content_type
    store = store_for_upload_type(upload_type)
    multipart_upload = store.create_multipart(file_name, content_type, metadata: metadata)

    upload_stub =
      ExternalUploadStub.create!(
        key: multipart_upload[:key],
        created_by: current_user,
        original_filename: file_name,
        upload_type: upload_type,
        external_upload_identifier: multipart_upload[:upload_id],
        multipart: true,
        filesize: file_size,
      )

    {
      external_upload_identifier: upload_stub.external_upload_identifier,
      key: upload_stub.key,
      unique_identifier: upload_stub.unique_identifier,
    }
  end

  def self.store_for_upload_type(upload_type)
    if upload_type == ""backup""
      if !SiteSetting.enable_backups? ||
           SiteSetting.backup_location != BackupLocationSiteSetting::S3
        raise Discourse::InvalidAccess.new
      end
      BackupRestore::BackupStore.create
    else
      Discourse.store
    end
  end

  def initialize(external_upload_stub, upload_create_opts = {})
    @external_upload_stub = external_upload_stub
    @upload_create_opts = upload_create_opts
    @store = ExternalUploadManager.store_for_upload_type(external_upload_stub.upload_type)
  end

  def can_promote?
    external_upload_stub.status == ExternalUploadStub.statuses[:created]
  end

  def transform!
    raise CannotPromoteError if !can_promote?
    external_upload_stub.update!(status: ExternalUploadStub.statuses[:uploaded])

    # We require that the file size is specified ahead of time, and compare
    # it here to make sure that people are not uploading excessively large
    # files to the external provider. If this happens, the user will be banned
    # from uploading to the external provider for N minutes.
    if external_size != external_upload_stub.filesize
      ExternalUploadManager.ban_user_from_external_uploads!(
        user: external_upload_stub.created_by,
        ban_minutes: SIZE_MISMATCH_BAN_MINUTES,
      )
      raise SizeMismatchError.new(
              ""expected: #{external_upload_stub.filesize}, actual: #{external_size}"",
            )
    end

    if UPLOAD_TYPES_EXCLUDED_FROM_UPLOAD_PROMOTION.include?(external_upload_stub.upload_type)
      move_to_final_destination
    else
      promote_to_upload
    end
  rescue StandardError
    if !SiteSetting.enable_upload_debug_mode
      # We don't need to do anything special to abort multipart uploads here,
      # because at this point (calling promote_to_upload!), the multipart
      # upload would already be complete.
      @store.delete_file(external_upload_stub.key)
      external_upload_stub.destroy!
    else
      external_upload_stub.update(status: ExternalUploadStub.statuses[:failed])
    end

    raise
  end

  private

  def promote_to_upload
    # This could be legitimately nil, if it's too big to download on the
    # server, or it could have failed. To this end we set a should_download
    # variable as well to check.
    tempfile = nil
    should_download = external_size < DOWNLOAD_LIMIT

    if should_download
      tempfile = download(external_upload_stub.key, external_upload_stub.upload_type)

      raise DownloadFailedError if tempfile.blank?

      actual_sha1 = Upload.generate_digest(tempfile)
      raise ChecksumMismatchError if external_sha1 && external_sha1 != actual_sha1
    end

    opts = {
      type: external_upload_stub.upload_type,
      existing_external_upload_key: external_upload_stub.key,
      external_upload_too_big: external_size > DOWNLOAD_LIMIT,
      filesize: external_size,
    }.merge(@upload_create_opts)

    UploadCreator.new(tempfile, external_upload_stub.original_filename, opts).create_for(
      external_upload_stub.created_by_id,
    )
  ensure
    tempfile&.close!
  end

  def move_to_final_destination
    content_type = MiniMime.lookup_by_filename(external_upload_stub.original_filename).content_type
    @store.move_existing_stored_upload(
      existing_external_upload_key: external_upload_stub.key,
      original_filename: external_upload_stub.original_filename,
      content_type: content_type,
    )
    Struct.new(:errors).new([])
  end

  def external_stub_object
    @external_stub_object ||= @store.object_from_path(external_upload_stub.key)
  end

  def external_etag
    @external_etag ||= external_stub_object.etag
  end

  def external_size
    @external_size ||= external_stub_object.size
  end

  def external_sha1
    @external_sha1 ||= external_stub_object.metadata[""sha1-checksum""]
  end

  def download(key, type)
    url = @store.signed_url_for_path(external_upload_stub.key)
    uri = URI(url)
    FileHelper.download(
      url,
      max_file_size: DOWNLOAD_LIMIT,
      tmp_file_name: ""discourse-upload-#{type}"",
      follow_redirect: true,
      # Local S3 servers (like minio) do not use port 80, and the Aws::Sigv4::Signer
      # includes the port number in the Host header when presigning URLs if the
      # port is not 80, so we have to make sure the Host header sent by
      # FinalDestination includes the port, otherwise we will get a
      # `SignatureDoesNotMatch` error.
      include_port_in_host_header: uri.scheme == ""http"" && uri.port != 80,
    )
  end
end

```","# frozen_string_literal: true

RSpec.describe ExternalUploadManager do
  subject(:manager) { ExternalUploadManager.new(external_upload_stub) }

  fab!(:user)

  let!(:logo_file) { file_from_fixtures(""logo.png"") }
  let!(:pdf_file) { file_from_fixtures(""large.pdf"", ""pdf"") }
  let(:object_size) { 1.megabyte }
  let(:etag) { ""e696d20564859cbdf77b0f51cbae999a"" }
  let(:client_sha1) { Upload.generate_digest(object_file) }
  let(:sha1) { Upload.generate_digest(object_file) }
  let(:object_file) { logo_file }
  let(:external_upload_stub_metadata) { {} }
  let!(:external_upload_stub) { Fabricate(:image_external_upload_stub, created_by: user) }
  let(:s3_bucket_name) { SiteSetting.s3_upload_bucket }

  before do
    SiteSetting.authorized_extensions += ""|pdf""
    SiteSetting.max_attachment_size_kb = 210.megabytes / 1000

    setup_s3

    SiteSetting.s3_backup_bucket = ""s3-backup-bucket""
    SiteSetting.backup_location = BackupLocationSiteSetting::S3

    prepare_fake_s3
    stub_download_object_filehelper
  end

  describe ""#ban_user_from_external_uploads!"" do
    after { Discourse.redis.flushdb }

    it ""bans the user from external uploads using a redis key"" do
      ExternalUploadManager.ban_user_from_external_uploads!(user: user)
      expect(ExternalUploadManager.user_banned?(user)).to eq(true)
    end
  end

  describe ""#can_promote?"" do
    it ""returns false if the external stub status is not created"" do
      external_upload_stub.update!(status: ExternalUploadStub.statuses[:uploaded])
      expect(manager.can_promote?).to eq(false)
    end
  end

  describe ""#transform!"" do
    context ""when stubbed upload is < DOWNLOAD_LIMIT (small enough to download + generate sha)"" do
      let!(:external_upload_stub) do
        Fabricate(:image_external_upload_stub, created_by: user, filesize: object_size)
      end
      let(:object_size) { 1.megabyte }
      let(:object_file) { logo_file }

      context ""when the download of the s3 file fails"" do
        before { FileHelper.stubs(:download).returns(nil) }

        it ""raises an error"" do
          expect { manager.transform! }.to raise_error(ExternalUploadManager::DownloadFailedError)
        end
      end

      context ""when the upload is not in the created status"" do
        before { external_upload_stub.update!(status: ExternalUploadStub.statuses[:uploaded]) }

        it ""raises an error"" do
          expect { manager.transform! }.to raise_error(ExternalUploadManager::CannotPromoteError)
        end
      end

      context ""when the upload does not get changed in UploadCreator (resized etc.)"" do
        it ""copies the stubbed upload on S3 to its new destination and deletes it"" do
          upload = manager.transform!

          bucket = @fake_s3.bucket(SiteSetting.s3_upload_bucket)
          expect(@fake_s3.operation_called?(:copy_object)).to eq(true)
          expect(bucket.find_object(Discourse.store.get_path_for_upload(upload))).to be_present
          expect(bucket.find_object(external_upload_stub.key)).to be_nil
        end

        it ""errors if the image upload is too big"" do
          SiteSetting.max_image_size_kb = 1
          upload = manager.transform!
          expect(upload.errors.full_messages).to include(
            ""Filesize "" +
              I18n.t(
                ""upload.images.too_large_humanized"",
                max_size:
                  ActiveSupport::NumberHelper.number_to_human_size(
                    SiteSetting.max_image_size_kb.kilobytes,
                  ),
              ),
          )
        end

        it ""errors if the extension is not supported"" do
          SiteSetting.authorized_extensions = """"
          upload = manager.transform!
          expect(upload.errors.full_messages).to include(
            ""Original filename "" + I18n.t(""upload.unauthorized"", authorized_extensions: """"),
          )
        end
      end

      context ""when the upload does get changed by the UploadCreator"" do
        let(:object_file) { file_from_fixtures(""should_be_jpeg.heic"", ""images"") }
        let(:object_size) { 1.megabyte }
        let(:external_upload_stub) do
          Fabricate(
            :image_external_upload_stub,
            original_filename: ""should_be_jpeg.heic"",
            filesize: object_size,
          )
        end

        it ""creates a new upload in s3 (not copy) and deletes the original stubbed upload"" do
          upload = manager.transform!

          bucket = @fake_s3.bucket(SiteSetting.s3_upload_bucket)
          expect(@fake_s3.operation_called?(:copy_object)).to eq(false)
          expect(bucket.find_object(Discourse.store.get_path_for_upload(upload))).to be_present
          expect(bucket.find_object(external_upload_stub.key)).to be_nil
        end
      end

      context ""when the sha has been set on the s3 object metadata by the clientside JS"" do
        let(:external_upload_stub_metadata) { { ""sha1-checksum"" => client_sha1 } }

        context ""when the downloaded file sha1 does not match the client sha1"" do
          let(:client_sha1) { ""blahblah"" }

          it ""raises an error, deletes the stub"" do
            expect { manager.transform! }.to raise_error(
              ExternalUploadManager::ChecksumMismatchError,
            )
            expect(ExternalUploadStub.exists?(id: external_upload_stub.id)).to eq(false)

            bucket = @fake_s3.bucket(SiteSetting.s3_upload_bucket)
            expect(bucket.find_object(external_upload_stub.key)).to be_nil
          end

          it ""does not delete the stub if enable_upload_debug_mode"" do
            SiteSetting.enable_upload_debug_mode = true
            expect { manager.transform! }.to raise_error(
              ExternalUploadManager::ChecksumMismatchError,
            )
            external_stub = ExternalUploadStub.find(external_upload_stub.id)
            expect(external_stub.status).to eq(ExternalUploadStub.statuses[:failed])

            bucket = @fake_s3.bucket(SiteSetting.s3_upload_bucket)
            expect(bucket.find_object(external_upload_stub.key)).to be_present
          end
        end
      end

      context ""when the downloaded file size does not match the expected file size for the upload stub"" do
        before { external_upload_stub.update!(filesize: 10) }

        after { Discourse.redis.flushdb }

        it ""raises an error, deletes the file immediately, and prevents the user from uploading external files for a few minutes"" do
          expect { manager.transform! }.to raise_error(ExternalUploadManager::SizeMismatchError)
          expect(ExternalUploadStub.exists?(id: external_upload_stub.id)).to eq(false)
          expect(
            Discourse.redis.get(
              ""#{ExternalUploadManager::BAN_USER_REDIS_PREFIX}#{external_upload_stub.created_by_id}"",
            ),
          ).to eq(""1"")

          bucket = @fake_s3.bucket(SiteSetting.s3_upload_bucket)
          expect(bucket.find_object(external_upload_stub.key)).to be_nil
        end

        it ""does not delete the stub if enable_upload_debug_mode"" do
          SiteSetting.enable_upload_debug_mode = true
          expect { manager.transform! }.to raise_error(ExternalUploadManager::SizeMismatchError)
          external_stub = ExternalUploadStub.find(external_upload_stub.id)
          expect(external_stub.status).to eq(ExternalUploadStub.statuses[:failed])

          bucket = @fake_s3.bucket(SiteSetting.s3_upload_bucket)
          expect(bucket.find_object(external_upload_stub.key)).to be_present
        end
      end
    end

    context ""when stubbed upload is > DOWNLOAD_LIMIT (too big to download, generate a fake sha)"" do
      let(:object_size) { 200.megabytes }
      let(:object_file) { pdf_file }
      let!(:external_upload_stub) do
        Fabricate(:attachment_external_upload_stub, created_by: user, filesize: object_size)
      end

      before do
        UploadCreator
          .any_instance
          .stubs(:generate_fake_sha1_hash)
          .returns(""testbc60eb18e8f974cbfae8bb0f069c3a311024"")
      end

      it ""does not try and download the file"" do
        FileHelper.expects(:download).never
        manager.transform!
      end

      it ""generates a fake sha for the upload record"" do
        upload = manager.transform!
        expect(upload.sha1).not_to eq(sha1)
        expect(upload.original_sha1).to eq(nil)
        expect(upload.filesize).to eq(object_size)
      end

      it ""marks the stub as uploaded"" do
        manager.transform!
        expect(external_upload_stub.reload.status).to eq(ExternalUploadStub.statuses[:uploaded])
      end

      it ""copies the stubbed upload on S3 to its new destination and deletes it"" do
        upload = manager.transform!

        bucket = @fake_s3.bucket(SiteSetting.s3_upload_bucket)
        expect(bucket.find_object(Discourse.store.get_path_for_upload(upload))).to be_present
        expect(bucket.find_object(external_upload_stub.key)).to be_nil
      end
    end

    context ""when the upload type is backup"" do
      let(:object_size) { 200.megabytes }
      let(:object_file) { file_from_fixtures(""backup_since_v1.6.tar.gz"", ""backups"") }
      let!(:external_upload_stub) do
        Fabricate(
          :attachment_external_upload_stub,
          created_by: user,
          filesize: object_size,
          upload_type: ""backup"",
          original_filename: ""backup_since_v1.6.tar.gz"",
          folder_prefix: RailsMultisite::ConnectionManagement.current_db,
        )
      end
      let(:s3_bucket_name) { SiteSetting.s3_backup_bucket }

      it ""does not try and download the file"" do
        FileHelper.expects(:download).never
        manager.transform!
      end

      it ""raises an error when backups are disabled"" do
        SiteSetting.enable_backups = false
        expect { manager.transform! }.to raise_error(Discourse::InvalidAccess)
      end

      it ""raises an error when backups are local, not s3"" do
        SiteSetting.backup_location = BackupLocationSiteSetting::LOCAL
        expect { manager.transform! }.to raise_error(Discourse::InvalidAccess)
      end

      it ""does not create an upload record"" do
        expect { manager.transform! }.not_to change { Upload.count }
      end

      it ""copies the stubbed upload on S3 to its new destination and deletes it"" do
        bucket = @fake_s3.bucket(SiteSetting.s3_backup_bucket)
        expect(bucket.find_object(external_upload_stub.key)).to be_present

        manager.transform!

        expect(
          bucket.find_object(
            ""#{RailsMultisite::ConnectionManagement.current_db}/backup_since_v1.6.tar.gz"",
          ),
        ).to be_present
        expect(bucket.find_object(external_upload_stub.key)).to be_nil
      end
    end
  end

  def stub_download_object_filehelper
    signed_url = Discourse.store.signed_url_for_path(external_upload_stub.key)
    uri = URI.parse(signed_url)
    signed_url = uri.to_s.gsub(uri.query, """")
    stub_request(:get, signed_url).with(query: hash_including({})).to_return(
      status: 200,
      body: object_file.read,
    )
  end

  def prepare_fake_s3
    @fake_s3 = FakeS3.create

    @fake_s3.bucket(s3_bucket_name).put_object(
      key: external_upload_stub.key,
      size: object_size,
      last_modified: Time.zone.now,
      metadata: external_upload_stub_metadata,
    )
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

##
# Anything that we want to be able to bookmark must be registered as a
# bookmarkable type using Plugin::Instance#register_bookmarkable(bookmarkable_klass),
# where the bookmarkable_klass is a class that implements this BaseBookmarkable
# interface. Some examples are TopicBookmarkable and PostBookmarkable.
#
# These methods are then called by the RegisteredBookmarkable class through a public
# interface, used in places where we need to list, send reminders for,
# or otherwise interact with bookmarks in a way that is unique to the
# bookmarkable type.
#
# See RegisteredBookmarkable for additional documentation.
class BaseBookmarkable
  attr_reader :model, :serializer, :preload_associations

  # @return [ActiveRecord::Base] The ActiveRecord model class which will be used to denote
  #                              the type of the bookmarkable upon registration along with
  #                              querying.
  def self.model
    raise NotImplementedError
  end

  # @return [ApplicationSerializer] The serializer class inheriting from UserBookmarkBaseSerializer
  def self.serializer
    raise NotImplementedError
  end

  # @return [Array] Used for preloading associations on the bookmarks for listing
  #                 purposes. Should be in the same format used for .includes() e.g.
  #
  #                 [{ topic: [:topic_users, :tags] }, :user]
  def self.preload_associations
    nil
  end

  def self.has_preloads?
    preload_associations.present?
  end

  ##
  #
  # Implementations can define their own preloading logic here
  # @param [Array] bookmarks_of_type The list of bookmarks to preload data for. Already filtered to be of the correct class.
  # @param [Guardian] guardian An instance of Guardian for the current_user
  def self.perform_custom_preload!(bookmarks_of_type, guardian)
    nil
  end

  ##
  # This is where the main query to filter the bookmarks by the provided bookmarkable
  # type should occur. This should join on additional tables that are required later
  # on to preload additional data for serializers, and also is the place where the
  # bookmarks should be filtered based on security checks, which is why the Guardian
  # instance is provided.
  #
  # @param [User] user The user to perform the query for, this scopes the bookmarks returned.
  # @param [Guardian] guardian An instance of Guardian for the user to be used for security filters.
  # @return [Bookmark::ActiveRecord_AssociationRelation] Should be an appropriately scoped list of bookmarks for the user.
  def self.list_query(user, guardian)
    raise NotImplementedError
  end

  ##
  # Called from BookmarkQuery when the initial results have been returned by
  # perform_list_query. The search_query should join additional tables required
  # to filter the bookmarks further, as well as defining a string used for
  # where_sql, which can include comparisons with the :q parameter.
  #
  # @param [Bookmark::ActiveRecord_Relation] bookmarks The bookmark records returned by perform_list_query
  # @param [String] query The search query from the user surrounded by the %% wildcards
  # @param [String] ts_query The postgres TSQUERY string used for comparisons with full text search columns
  # @param [Block] bookmarkable_search This block _must_ be called with the additional WHERE clause SQL relevant
  #                                    for the bookmarkable to be searched, as well as the bookmarks relation
  #                                    with any additional joins applied.
  # @return [Bookmark::ActiveRecord_AssociationRelation] The list of bookmarks from perform_list_query filtered further by
  #                                                      the query parameter.
  def self.search_query(bookmarks, query, ts_query, &bookmarkable_search)
    raise NotImplementedError
  end

  ##
  # When sending bookmark reminders, we want to make sure that whatever we
  # are sending the reminder for has not been deleted or is otherwise inaccessible.
  # Most of the time we can just check if the bookmarkable record is present
  # because it will be trashable, though in some cases there will be additional
  # conditions in the form of a lambda that we should use instead.
  #
  # The logic around whether it is the right time to send a reminder does not belong
  # here, that is done in the BookmarkReminderNotifications job.
  #
  # @param [Bookmark] bookmark The bookmark that we are considering sending a reminder for.
  # @return [Boolean]
  def self.reminder_conditions(bookmark)
    raise NotImplementedError
  end

  ##
  # Different bookmarkables may have different ways of notifying a user or presenting
  # the reminder and what it is for, so it is up to the bookmarkable to register
  # its preferred method of sending the reminder.
  #
  # @param [Bookmark] bookmark The bookmark that we are sending the reminder notification for.
  # @return [void]
  def self.reminder_handler(bookmark)
    raise NotImplementedError
  end

  ##
  # Can be used by the inheriting class via reminder_handler, most of the
  # time we just want to make a Notification for a bookmark reminder, this
  # gives consumers a way to do it without having provide all of the required
  # data themselves.
  #
  # @param [Bookmark] bookmark          The bookmark that we are sending the reminder notification for.
  # @param [Hash]     notification_data Any data, either top-level (e.g. topic_id, post_number) or inside
  #                                     the data sub-key, which should be stored when the notification is
  #                                     created.
  # @return [void]
  def self.send_reminder_notification(bookmark, notification_data)
    if notification_data[:data].blank? || notification_data[:data][:bookmarkable_url].blank? ||
         notification_data[:data][:title].blank?
      raise Discourse::InvalidParameters.new(
              ""A `data` key must be present with at least `bookmarkable_url` and `title` entries."",
            )
    end

    notification_data[:data] = notification_data[:data].merge(
      display_username: bookmark.user.username,
      bookmark_name: bookmark.name,
      bookmark_id: bookmark.id,
    ).to_json
    notification_data[:notification_type] = Notification.types[:bookmark_reminder]
    bookmark.user.notifications.create!(notification_data)
  end

  ##
  # Access control is dependent on what has been bookmarked, the appropriate guardian
  # can_see_X? method should be called from the bookmarkable class to determine
  # whether the bookmarkable record (e.g. Post, Topic) is accessible by the guardian user.
  #
  # @param [Guardian] guardian The guardian class for the user that we are performing the access check for.
  # @param [Bookmark] bookmark The bookmark which we are checking access for using the bookmarkable association.
  # @return [Boolean]
  def self.can_see?(guardian, bookmark)
    raise NotImplementedError
  end

  ##
  # Some additional information about the bookmark or the surrounding relations
  # may be required when the bookmark is created or destroyed. For example, when
  # destroying a bookmark within a topic we need to know whether there are other
  # bookmarks still remaining in the topic.
  #
  # @param [Bookmark] bookmark The bookmark that we are retrieving additional metadata for.
  # @param [User] user The current user which is accessing the bookmark metadata.
  # @return [Hash] (optional)
  def self.bookmark_metadata(bookmark, user)
    {}
  end

  ##
  # Optional bookmarkable specific validations may need to be run before a bookmark is created
  # via the BookmarkManager. From here an error should be raised if there is an issue
  # with the bookmarkable.
  #
  # @param [Guardian] guardian The guardian for the user which is creating the bookmark.
  # @param [Model] bookmarkable The ActiveRecord model which is acting as the bookmarkable for the new bookmark.
  def self.validate_before_create(guardian, bookmarkable)
    # noop
  end

  ##
  # Optional additional actions may need to occur after a bookmark is created
  # via the BookmarkManager.
  #
  # @param [Guardian] guardian The guardian for the user which is creating the bookmark.
  # @param [Model] bookmark The bookmark which was created.
  # @param [Hash] opts Additional options that may be passed down via BookmarkManager.
  def self.after_create(guardian, bookmark, opts)
    # noop
  end

  ##
  # Optional additional actions may need to occur after a bookmark is destroyed
  # via the BookmarkManager.
  #
  # @param [Guardian] guardian The guardian for the user which is destroying the bookmark.
  # @param [Model] bookmark The bookmark which was destroyed.
  # @param [Hash] opts Additional options that may be passed down via BookmarkManager.
  def self.after_destroy(guardian, bookmark, opts)
    # noop
  end

  ##
  # Some bookmarkable records are Trashable, and as such we don't delete the
  # bookmark with dependent_destroy. This should be used to delete those records
  # after a grace period, defined by the bookmarkable. For example, post bookmarks
  # may be deleted 3 days after the post or topic is deleted.
  #
  # In the case of bookmarkable records that are not trashable, and where
  # dependent_destroy is not used, this should just delete the bookmarks pointing
  # to the record which no longer exists in the database.
  def self.cleanup_deleted
    # noop
  end
end

```","# frozen_string_literal: true

RSpec.describe BaseBookmarkable do
  fab!(:bookmark) { Fabricate(:bookmark, bookmarkable: Fabricate(:post)) }

  describe ""#send_reminder_notification"" do
    it ""raises an error if the data, data.bookmarkable_url, or data.title values are missing from notification_data"" do
      expect { BaseBookmarkable.send_reminder_notification(bookmark, {}) }.to raise_error(
        Discourse::InvalidParameters,
      )
      expect { BaseBookmarkable.send_reminder_notification(bookmark, { data: {} }) }.to raise_error(
        Discourse::InvalidParameters,
      )
      expect {
        BaseBookmarkable.send_reminder_notification(
          bookmark,
          { data: { title: ""test"", bookmarkable_url: ""test"" } },
        )
      }.not_to raise_error
    end

    it ""creates a Notification with the required data from the bookmark"" do
      BaseBookmarkable.send_reminder_notification(
        bookmark,
        {
          topic_id: bookmark.bookmarkable.topic_id,
          post_number: bookmark.bookmarkable.post_number,
          data: {
            title: bookmark.bookmarkable.topic.title,
            bookmarkable_url: bookmark.bookmarkable.url,
          },
        },
      )
      notif = bookmark.user.notifications.last
      expect(notif.notification_type).to eq(Notification.types[:bookmark_reminder])
      expect(notif.topic_id).to eq(bookmark.bookmarkable.topic_id)
      expect(notif.post_number).to eq(bookmark.bookmarkable.post_number)
      expect(notif.data).to eq(
        {
          title: bookmark.bookmarkable.topic.title,
          bookmarkable_url: bookmark.bookmarkable.url,
          display_username: bookmark.user.username,
          bookmark_name: bookmark.name,
          bookmark_id: bookmark.id,
        }.to_json,
      )
    end

    it ""does not allow the consumer to override display_username, bookmark_name, or bookmark_id"" do
      BaseBookmarkable.send_reminder_notification(
        bookmark,
        {
          topic_id: bookmark.bookmarkable.topic_id,
          post_number: bookmark.bookmarkable.post_number,
          data: {
            title: bookmark.bookmarkable.topic.title,
            bookmarkable_url: bookmark.bookmarkable.url,
            display_username: ""bad username"",
            bookmark_name: ""bad name"",
            bookmark_id: -89_854,
          },
        },
      )

      notif = bookmark.user.notifications.last
      data = JSON.parse(notif[:data])
      expect(data[:display_username]).not_to eq(""bad username"")
      expect(data[:name]).not_to eq(""bad name"")
      expect(data[:bookmark_id]).not_to eq(-89_854)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Used as a data source via HashtagAutocompleteService to provide category
# results when looking up a category slug via markdown or searching for
# categories via the # autocomplete character.
class CategoryHashtagDataSource
  def self.enabled?
    true
  end

  def self.icon
    ""folder""
  end

  def self.type
    ""category""
  end

  def self.category_to_hashtag_item(category)
    HashtagAutocompleteService::HashtagItem.new.tap do |item|
      item.text = category.name
      item.slug = category.slug
      item.description = category.description_text
      item.icon = icon
      item.relative_url = category.url
      item.id = category.id

      # Single-level category hierarchy should be enough to distinguish between
      # categories here.
      item.ref = category.slug_ref
    end
  end

  def self.lookup(guardian, slugs)
    user_categories =
      Category
        .secured(guardian)
        .includes(:parent_category)
        .order(""parent_category_id ASC NULLS FIRST, id ASC"")
    Category
      .query_loaded_from_slugs(slugs, user_categories)
      .map { |category| category_to_hashtag_item(category) }
  end

  def self.search(
    guardian,
    term,
    limit,
    condition = HashtagAutocompleteService.search_conditions[:contains]
  )
    base_search =
      Category
        .secured(guardian)
        .select(:id, :parent_category_id, :slug, :name, :description)
        .includes(:parent_category)

    if condition == HashtagAutocompleteService.search_conditions[:starts_with]
      base_search = base_search.where(""LOWER(slug) LIKE :term"", term: ""#{term}%"")
    elsif condition == HashtagAutocompleteService.search_conditions[:contains]
      base_search =
        base_search.where(""LOWER(name) LIKE :term OR LOWER(slug) LIKE :term"", term: ""%#{term}%"")
    else
      raise Discourse::InvalidParameters.new(""Unknown search condition: #{condition}"")
    end

    base_search.take(limit).map { |category| category_to_hashtag_item(category) }
  end

  def self.search_sort(search_results, term)
    if term.present?
      search_results.sort_by { |item| [item.slug == term ? 0 : 1, item.text.downcase] }
    else
      search_results.sort_by { |item| item.text.downcase }
    end
  end

  def self.search_without_term(guardian, limit)
    Category
      .includes(:parent_category)
      .secured(guardian)
      .where(
        ""categories.id NOT IN (#{
          CategoryUser
            .muted_category_ids_query(guardian.user, include_direct: true)
            .select(""categories.id"")
            .to_sql
        })"",
      )
      .order(topic_count: :desc)
      .take(limit)
      .map { |category| category_to_hashtag_item(category) }
  end
end

```","# frozen_string_literal: true

RSpec.describe CategoryHashtagDataSource do
  fab!(:parent_category) { Fabricate(:category, slug: ""fun"", topic_count: 2) }
  fab!(:category1) do
    Fabricate(:category, slug: ""random"", topic_count: 12, parent_category: parent_category)
  end
  fab!(:category2) { Fabricate(:category, name: ""Book Section"", slug: ""books"", topic_count: 566) }
  fab!(:category3) { Fabricate(:category, slug: ""movies"", topic_count: 245) }
  fab!(:group)
  fab!(:category4) { Fabricate(:private_category, slug: ""secret"", group: group, topic_count: 40) }
  fab!(:category5) { Fabricate(:category, slug: ""casual"", topic_count: 99) }
  fab!(:user)
  let(:guardian) { Guardian.new(user) }
  let(:uncategorized_category) { Category.find(SiteSetting.uncategorized_category_id) }

  describe ""#lookup"" do
    it ""finds categories using their slug, downcasing for matches"" do
      result = described_class.lookup(guardian, [""movies""]).first
      expect(result.ref).to eq(""movies"")
      expect(result.slug).to eq(""movies"")

      result = described_class.lookup(guardian, [""BoOKs""]).first
      expect(result.ref).to eq(""books"")
      expect(result.slug).to eq(""books"")
    end

    it ""finds categories using the parent:child slug format"" do
      result = described_class.lookup(guardian, [""fun:random""]).first
      expect(result.ref).to eq(""fun:random"")
      expect(result.slug).to eq(""random"")
    end

    it ""does not find child categories by their standalone slug"" do
      expect(described_class.lookup(guardian, [""random""]).first).to eq(nil)
    end

    it ""does not find categories the user cannot access"" do
      expect(described_class.lookup(guardian, [""secret""]).first).to eq(nil)
      group.add(user)
      expect(described_class.lookup(Guardian.new(user), [""secret""]).first).not_to eq(nil)
    end

    context ""with sub-sub-categories"" do
      before { SiteSetting.max_category_nesting = 3 }

      it ""returns the first matching grandchild category (ordered by IDs) when there are multiple categories with the same slug"" do
        parent1 = Fabricate(:category, slug: ""parent1"")
        parent2 = Fabricate(:category, slug: ""parent2"")

        parent1_child = Fabricate(:category, slug: ""child"", parent_category_id: parent1.id)
        parent1_child_grandchild =
          Fabricate(:category, slug: ""grandchild"", parent_category_id: parent1_child.id)

        parent2_child = Fabricate(:category, slug: ""child"", parent_category_id: parent2.id)
        parent2_child_grandchild =
          Fabricate(:category, slug: ""grandchild"", parent_category_id: parent2_child.id)

        result = described_class.lookup(guardian, [""child:grandchild""])
        expect(result.map(&:relative_url)).to eq([parent1_child_grandchild.url])

        parent1_child.destroy
        parent1_child = Fabricate(:category, slug: ""child"", parent_category_id: parent1.id)

        result = described_class.lookup(guardian, [""child:grandchild""])
        expect(result.map(&:relative_url)).to eq([parent2_child_grandchild.url])
      end

      it ""returns the correct grandchild category when there are multiple children with the same slug and only one of them has the correct grandchild"" do
        parent1 = Fabricate(:category, slug: ""parent1"")
        parent1_child = Fabricate(:category, slug: ""child"", parent_category_id: parent1.id)
        parent1_child_grandchild =
          Fabricate(:category, slug: ""another-grandchild"", parent_category_id: parent1_child.id)

        parent2 = Fabricate(:category, slug: ""parent2"")
        parent2_child = Fabricate(:category, slug: ""child"", parent_category_id: parent2.id)
        parent2_child_grandchild =
          Fabricate(:category, slug: ""grandchild"", parent_category_id: parent2_child.id)

        result = described_class.lookup(guardian, [""child:grandchild""])
        expect(result.map(&:relative_url)).to eq([parent2_child_grandchild.url])
      end
    end
  end

  describe ""#search"" do
    it ""finds categories by partial name"" do
      result = described_class.search(guardian, ""mov"", 5).first
      expect(result.ref).to eq(""movies"")
      expect(result.slug).to eq(""movies"")
    end

    it ""finds categories by partial slug"" do
      result = described_class.search(guardian, ""ook sec"", 5).first
      expect(result.ref).to eq(""books"")
      expect(result.slug).to eq(""books"")
    end

    it ""does not find categories the user cannot access"" do
      expect(described_class.search(guardian, ""secret"", 5).first).to eq(nil)
      group.add(user)
      expect(described_class.search(Guardian.new(user), ""secret"", 5).first).not_to eq(nil)
    end

    it ""uses the correct ref format for a parent:child category that is found"" do
      result = described_class.search(guardian, ""random"", 5).first
      expect(result.ref).to eq(""fun:random"")
      expect(result.slug).to eq(""random"")
    end
  end

  describe ""#search_without_term"" do
    it ""returns distinct categories ordered by topic_count"" do
      expect(described_class.search_without_term(guardian, 5).map(&:slug)).to eq(
        %w[books movies casual random fun],
      )
    end

    it ""does not return categories the user does not have permission to view"" do
      expect(described_class.search_without_term(guardian, 5).map(&:slug)).not_to include(""secret"")
      group.add(user)
      expect(described_class.search_without_term(Guardian.new(user), 5).map(&:slug)).to include(
        ""secret"",
      )
    end

    it ""does not return categories the user has muted"" do
      CategoryUser.create!(
        user: user,
        category: category1,
        notification_level: CategoryUser.notification_levels[:muted],
      )
      expect(described_class.search_without_term(guardian, 5).map(&:slug)).not_to include(""random"")
    end

    it ""does not return child categories where the user has muted the parent"" do
      CategoryUser.create!(
        user: user,
        category: parent_category,
        notification_level: CategoryUser.notification_levels[:muted],
      )
      expect(described_class.search_without_term(guardian, 5).map(&:slug)).not_to include(""random"")
    end
  end

  describe ""#search_sort"" do
    it ""orders by exact slug match then text"" do
      results_to_sort = [
        HashtagAutocompleteService::HashtagItem.new(
          text: ""System Tests"",
          slug: ""system-test-development"",
        ),
        HashtagAutocompleteService::HashtagItem.new(text: ""Ruby Dev"", slug: ""ruby-dev""),
        HashtagAutocompleteService::HashtagItem.new(text: ""Dev"", slug: ""dev""),
        HashtagAutocompleteService::HashtagItem.new(text: ""Dev Tools"", slug: ""dev-tools""),
        HashtagAutocompleteService::HashtagItem.new(text: ""Dev Lore"", slug: ""dev-lore""),
      ]
      expect(described_class.search_sort(results_to_sort, ""dev"").map(&:slug)).to eq(
        %w[dev dev-lore dev-tools ruby-dev system-test-development],
      )
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class UserAnonymizer
  attr_reader :user_history

  EMAIL_SUFFIX = ""@anonymized.invalid""

  # opts:
  #   anonymize_ip  - an optional new IP to update their logs with
  def initialize(user, actor = nil, opts = nil)
    @user = user
    @actor = actor
    @user_history = nil
    @opts = opts || {}
  end

  def self.make_anonymous(user, actor = nil, opts = nil)
    self.new(user, actor, opts).make_anonymous
  end

  def make_anonymous
    User.transaction do
      @prev_email = @user.email
      @prev_username = @user.username

      unless UsernameChanger.new(@user, make_anon_username).change(run_update_job: false)
        raise ""Failed to change username""
      end

      @user.reload
      @user.password = SecureRandom.hex
      @user.name = SiteSetting.full_name_required ? @user.username : nil
      @user.date_of_birth = nil
      @user.title = nil
      @user.uploaded_avatar_id = nil

      if @opts.has_key?(:anonymize_ip)
        @user.ip_address = @opts[:anonymize_ip]
        @user.registration_ip_address = @opts[:anonymize_ip]
      end

      @user.save!
      @user.primary_email.update_attribute(:email, ""#{@user.username}#{EMAIL_SUFFIX}"")

      options = @user.user_option
      options.mailing_list_mode = false
      options.email_digests = false
      options.email_level = UserOption.email_level_types[:never]
      options.email_messages_level = UserOption.email_level_types[:never]
      options.save!

      if profile = @user.user_profile
        profile.update!(
          location: nil,
          website: nil,
          bio_raw: nil,
          bio_cooked: nil,
          profile_background_upload: nil,
          card_background_upload: nil,
        )
      end

      @user.clear_status!

      @user.user_avatar&.destroy!
      @user.single_sign_on_record&.destroy!
      @user.oauth2_user_infos.destroy_all
      @user.user_associated_accounts.destroy_all
      @user.api_keys.destroy_all
      @user.user_api_keys.destroy_all
      @user.user_emails.secondary.destroy_all

      @user_history = log_action
    end

    UsernameChanger.update_username(
      user_id: @user.id,
      old_username: @prev_username,
      new_username: @user.username,
      avatar_template: @user.avatar_template,
    )

    Jobs.enqueue(
      :anonymize_user,
      user_id: @user.id,
      prev_email: @prev_email,
      anonymize_ip: @opts[:anonymize_ip],
    )

    DiscourseEvent.trigger(:user_anonymized, user: @user, opts: @opts)
    @user
  end

  private

  def make_anon_username
    100.times do
      new_username = ""anon#{(SecureRandom.random_number * 100_000_000).to_i}""
      return new_username unless User.where(username_lower: new_username).exists?
    end
    raise ""Failed to generate an anon username""
  end

  def log_action
    history_details = {
      action: UserHistory.actions[:anonymize_user],
      target_user_id: @user.id,
      acting_user_id: @actor ? @actor.id : @user.id,
    }

    if SiteSetting.log_anonymizer_details?
      history_details[:email] = @prev_email
      history_details[:details] = ""username: #{@prev_username}""
    end

    UserHistory.create!(history_details)
  end
end

```","# frozen_string_literal: true

RSpec.describe UserAnonymizer do
  let(:admin) { Fabricate(:admin) }

  describe ""event"" do
    subject(:make_anonymous) do
      described_class.make_anonymous(user, admin, anonymize_ip: ""2.2.2.2"")
    end

    let(:user) { Fabricate(:user, username: ""edward"") }

    it ""triggers the event"" do
      events = DiscourseEvent.track_events { make_anonymous }

      anon_event = events.detect { |e| e[:event_name] == :user_anonymized }
      expect(anon_event).to be_present
      params_hash = anon_event[:params][0]

      expect(params_hash[:user]).to eq(user)
      expect(params_hash[:opts][:anonymize_ip]).to eq(""2.2.2.2"")
    end
  end

  describe "".make_anonymous"" do
    subject(:make_anonymous) { described_class.make_anonymous(user, admin) }

    let(:original_email) { ""edward@example.net"" }
    let(:user) { Fabricate(:user, username: ""edward"", email: original_email) }
    fab!(:another_user) { Fabricate(:evil_trout) }

    it ""changes username"" do
      make_anonymous
      expect(user.reload.username).to match(/^anon\d{3,}$/)
    end

    it ""changes the primary email address"" do
      make_anonymous
      expect(user.reload.email).to eq(""#{user.username}@anonymized.invalid"")
    end

    it ""changes the primary email address when there is an email domain allowlist"" do
      SiteSetting.allowed_email_domains = ""example.net|wayne.com|discourse.org""

      make_anonymous
      expect(user.reload.email).to eq(""#{user.username}@anonymized.invalid"")
    end

    it ""deletes secondary email addresses"" do
      Fabricate(:secondary_email, user: user, email: ""secondary_email@example.com"")

      make_anonymous
      expect(user.reload.secondary_emails).to be_blank
    end

    it ""turns off all notifications"" do
      user.user_option.update_columns(
        email_level: UserOption.email_level_types[:always],
        email_messages_level: UserOption.email_level_types[:always],
      )

      make_anonymous
      user.reload
      expect(user.user_option.email_digests).to eq(false)
      expect(user.user_option.email_level).to eq(UserOption.email_level_types[:never])
      expect(user.user_option.email_messages_level).to eq(UserOption.email_level_types[:never])
      expect(user.user_option.mailing_list_mode).to eq(false)
    end

    context ""when Site Settings do not require full name"" do
      before { SiteSetting.full_name_required = false }

      it ""resets profile to default values"" do
        user.update!(name: ""Bibi"", date_of_birth: 19.years.ago, title: ""Super Star"")

        profile = user.reload.user_profile
        upload = Fabricate(:upload)

        profile.update!(
          location: ""Moose Jaw"",
          website: ""http://www.bim.com"",
          bio_raw: ""I'm Bibi from Moosejaw. I sing and dance."",
          bio_cooked: ""I'm Bibi from Moosejaw. I sing and dance."",
          profile_background_upload: upload,
          bio_cooked_version: 2,
          card_background_upload: upload,
        )

        prev_username = user.username

        UserAuthToken.generate!(user_id: user.id)

        make_anonymous
        user.reload

        expect(user.username).not_to eq(prev_username)
        expect(user.name).not_to be_present
        expect(user.date_of_birth).to eq(nil)
        expect(user.title).not_to be_present
        expect(user.user_auth_tokens.count).to eq(0)

        profile = user.reload.user_profile
        expect(profile.location).to eq(nil)
        expect(profile.website).to eq(nil)
        expect(profile.bio_cooked).to eq(nil)
        expect(profile.profile_background_upload).to eq(nil)
        expect(profile.bio_cooked_version).to eq(UserProfile::BAKED_VERSION)
        expect(profile.card_background_upload).to eq(nil)
      end
    end

    it ""clears existing user status"" do
      user_status = Fabricate(:user_status, user: user)

      expect do
        make_anonymous
        user.reload
      end.to change { user.user_status }.from(user_status).to(nil)
    end

    context ""when Site Settings require full name"" do
      before { SiteSetting.full_name_required = true }

      it ""changes name to anonymized username"" do
        prev_username = user.username

        user.update(name: ""Bibi"", date_of_birth: 19.years.ago, title: ""Super Star"")

        make_anonymous
        user.reload

        expect(user.name).not_to eq(prev_username)
        expect(user.name).to eq(user.username)
      end
    end

    it ""removes the avatar"" do
      upload = Fabricate(:upload, user: user)
      user.user_avatar = UserAvatar.new(user_id: user.id, custom_upload_id: upload.id)
      user.uploaded_avatar_id = upload.id # chosen in user preferences
      user.save!
      make_anonymous
      user.reload
      expect(user.user_avatar).to eq(nil)
      expect(user.uploaded_avatar_id).to eq(nil)
    end

    it ""updates the avatar in posts"" do
      Jobs.run_immediately!
      upload = Fabricate(:upload, user: user)
      user.user_avatar = UserAvatar.new(user_id: user.id, custom_upload_id: upload.id)
      user.uploaded_avatar_id = upload.id # chosen in user preferences
      user.save!

      topic = Fabricate(:topic, user: user)
      quoted_post = create_post(user: user, topic: topic, post_number: 1, raw: ""quoted post"")

      stub_image_size
      post = create_post(raw: <<~RAW)
        Lorem ipsum

        [quote=""#{quoted_post.username}, post:1, topic:#{quoted_post.topic.id}""]
        quoted post
        [/quote]
      RAW

      old_avatar_url = user.avatar_template.gsub(""{size}"", ""48"")
      expect(post.cooked).to include(old_avatar_url)

      make_anonymous
      post.reload
      new_avatar_url = user.reload.avatar_template.gsub(""{size}"", ""48"")

      expect(post.cooked).to_not include(old_avatar_url)
      expect(post.cooked).to include(new_avatar_url)
    end

    it ""logs the action with the original details"" do
      SiteSetting.log_anonymizer_details = true
      helper = UserAnonymizer.new(user, admin)
      orig_email = user.email
      orig_username = user.username
      helper.make_anonymous

      history = helper.user_history
      expect(history).to be_present
      expect(history.email).to eq(orig_email)
      expect(history.details).to match(orig_username)
    end

    it ""logs the action without the original details"" do
      SiteSetting.log_anonymizer_details = false
      helper = UserAnonymizer.new(user, admin)
      orig_email = user.email
      orig_username = user.username
      helper.make_anonymous

      history = helper.user_history
      expect(history).to be_present
      expect(history.email).not_to eq(orig_email)
      expect(history.details).not_to match(orig_username)
    end

    it ""removes external auth associations"" do
      user.user_associated_accounts = [
        UserAssociatedAccount.create(
          user_id: user.id,
          provider_uid: ""example"",
          provider_name: ""facebook"",
        ),
      ]
      user.single_sign_on_record =
        SingleSignOnRecord.create(
          user_id: user.id,
          external_id: ""example"",
          last_payload: ""looks good"",
        )
      make_anonymous
      user.reload
      expect(user.user_associated_accounts).to be_empty
      expect(user.single_sign_on_record).to eq(nil)
    end

    it ""removes api key"" do
      ApiKey.create!(user_id: user.id)

      expect { make_anonymous }.to change { ApiKey.count }.by(-1)

      user.reload
      expect(user.api_keys).to be_empty
    end

    it ""removes user api key"" do
      user_api_key = Fabricate(:user_api_key, user: user)

      expect { make_anonymous }.to change { UserApiKey.count }.by(-1)

      user.reload
      expect(user.user_api_keys).to be_empty
    end

    context ""when executing jobs"" do
      before { Jobs.run_immediately! }

      it ""removes invites"" do
        Fabricate(:invited_user, invite: Fabricate(:invite), user: user)
        Fabricate(:invited_user, invite: Fabricate(:invite), user: another_user)

        expect { make_anonymous }.to change { InvitedUser.count }.by(-1)
        expect(InvitedUser.where(user_id: user.id).count).to eq(0)
      end

      it ""removes email tokens"" do
        Fabricate(:email_token, user: user)
        Fabricate(:email_token, user: another_user)

        expect { make_anonymous }.to change { EmailToken.count }.by(-1)
        expect(EmailToken.where(user_id: user.id).count).to eq(0)
      end

      it ""removes email log entries"" do
        Fabricate(:email_log, user: user)
        Fabricate(:email_log, user: another_user)

        expect { make_anonymous }.to change { EmailLog.count }.by(-1)
        expect(EmailLog.where(user_id: user.id).count).to eq(0)
      end

      it ""removes incoming emails"" do
        Fabricate(:incoming_email, user: user, from_address: user.email)
        Fabricate(:incoming_email, from_address: user.email, error: ""Some error"")
        Fabricate(:incoming_email, user: another_user, from_address: another_user.email)

        expect { make_anonymous }.to change { IncomingEmail.count }.by(-2)
        expect(IncomingEmail.where(user_id: user.id).count).to eq(0)
        expect(IncomingEmail.where(from_address: original_email).count).to eq(0)
      end

      it ""removes raw email from posts"" do
        post1 = Fabricate(:post, user: user, via_email: true, raw_email: ""raw email from user"")
        post2 =
          Fabricate(
            :post,
            user: another_user,
            via_email: true,
            raw_email: ""raw email from another user"",
          )

        make_anonymous

        expect(post1.reload).to have_attributes(via_email: true, raw_email: nil)
        expect(post2.reload).to have_attributes(
          via_email: true,
          raw_email: ""raw email from another user"",
        )
      end

      it ""does not delete profile views"" do
        UserProfileView.add(user.id, ""127.0.0.1"", another_user.id, Time.now, true)
        expect { make_anonymous }.to_not change { UserProfileView.count }
      end

      it ""removes user field values"" do
        field1 = Fabricate(:user_field)
        field2 = Fabricate(:user_field)

        user.custom_fields = {
          some_field: ""123"",
          ""user_field_#{field1.id}"": ""foo"",
          ""user_field_#{field2.id}"": ""bar"",
          another_field: ""456"",
        }

        expect { make_anonymous }.to change { user.custom_fields }
        expect(user.reload.custom_fields).to eq(""some_field"" => ""123"", ""another_field"" => ""456"")
      end
    end
  end

  describe ""anonymize_ip"" do
    let(:old_ip) { ""1.2.3.4"" }
    let(:anon_ip) { ""0.0.0.0"" }
    let(:user) { Fabricate(:user, ip_address: old_ip, registration_ip_address: old_ip) }
    fab!(:post)
    let(:topic) { post.topic }

    it ""doesn't anonymize ips by default"" do
      UserAnonymizer.make_anonymous(user, admin)
      expect(user.ip_address).to eq(old_ip)
    end

    it ""is called if you pass an option"" do
      UserAnonymizer.make_anonymous(user, admin, anonymize_ip: anon_ip)
      user.reload
      expect(user.ip_address).to eq(anon_ip)
    end

    it ""exhaustively replaces all user ips"" do
      Jobs.run_immediately!
      link = IncomingLink.create!(current_user_id: user.id, ip_address: old_ip, post_id: post.id)

      screened_email = ScreenedEmail.create!(email: user.email, ip_address: old_ip)

      search_log =
        SearchLog.create!(
          term: ""wat"",
          search_type: SearchLog.search_types[:header],
          user_id: user.id,
          ip_address: old_ip,
        )

      topic_link =
        TopicLink.create!(
          user_id: admin.id,
          topic_id: topic.id,
          url: ""https://discourse.org"",
          domain: ""discourse.org"",
        )

      topic_link_click =
        TopicLinkClick.create!(topic_link_id: topic_link.id, user_id: user.id, ip_address: old_ip)

      user_profile_view =
        UserProfileView.create!(
          user_id: user.id,
          user_profile_id: admin.user_profile.id,
          ip_address: old_ip,
          viewed_at: Time.now,
        )

      TopicViewItem.create!(
        topic_id: topic.id,
        user_id: user.id,
        ip_address: old_ip,
        viewed_at: Time.now,
      )
      delete_history = StaffActionLogger.new(admin).log_user_deletion(user)
      user_history = StaffActionLogger.new(user).log_backup_create

      UserAnonymizer.make_anonymous(user, admin, anonymize_ip: anon_ip)
      expect(user.registration_ip_address).to eq(anon_ip)
      expect(link.reload.ip_address).to eq(anon_ip)
      expect(screened_email.reload.ip_address).to eq(anon_ip)
      expect(search_log.reload.ip_address).to eq(anon_ip)
      expect(topic_link_click.reload.ip_address).to eq(anon_ip)
      topic_view = TopicViewItem.where(topic_id: topic.id, user_id: user.id).first
      expect(topic_view.ip_address).to eq(anon_ip)
      expect(delete_history.reload.ip_address).to eq(anon_ip)
      expect(user_history.reload.ip_address).to eq(anon_ip)
      expect(user_profile_view.reload.ip_address).to eq(anon_ip)
    end
  end

  describe ""anonymize_emails"" do
    it ""destroys all associated invites"" do
      invite = Fabricate(:invite, email: ""test@example.com"")
      user = invite.redeem

      Jobs.run_immediately!
      described_class.make_anonymous(user, admin)

      expect(user.email).not_to eq(""test@example.com"")
      expect(Invite.exists?(id: invite.id)).to eq(false)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class UserActivator
  attr_reader :user, :request, :session, :cookies, :message

  def initialize(user, request, session, cookies)
    @user = user
    @session = session
    @cookies = cookies
    @request = request
    @message = nil
  end

  def start
  end

  def finish
    @message = activator.activate
  end

  def success_message
    activator.success_message
  end

  private

  def activator
    factory.new(user, request, session, cookies)
  end

  def factory
    invite = Invite.find_by(email: Email.downcase(@user.email))

    if !user.active?
      EmailActivator
    elsif SiteSetting.must_approve_users? && !(invite.present? && invite.redeemable?)
      ApprovalActivator
    else
      LoginActivator
    end
  end
end

class ApprovalActivator < UserActivator
  def activate
    success_message
  end

  def success_message
    I18n.t(""login.wait_approval"")
  end
end

class EmailActivator < UserActivator
  def activate
    email_token = user.email_tokens.create!(email: user.email, scope: EmailToken.scopes[:signup])
    EmailToken.enqueue_signup_email(email_token)
    success_message
  end

  def success_message
    I18n.t(""login.activate_email"", email: Rack::Utils.escape_html(user.email))
  end
end

class LoginActivator < UserActivator
  include CurrentUser

  def activate
    log_on_user(user)
    user.enqueue_welcome_message(""welcome_user"")
    success_message
  end

  def success_message
    I18n.t(""login.active"")
  end
end

```","# frozen_string_literal: true

RSpec.describe UserActivator do
  fab!(:user)
  let!(:email_token) { Fabricate(:email_token, user: user) }

  describe ""email_activator"" do
    let(:activator) { EmailActivator.new(user, nil, nil, nil) }

    it ""create email token and enqueues user email"" do
      now = freeze_time
      activator.activate
      email_token = user.reload.email_tokens.last
      expect(email_token.created_at).to eq_time(now)
      job_args = Jobs::CriticalUserEmail.jobs.last[""args""].first
      expect(job_args[""user_id""]).to eq(user.id)
      expect(job_args[""type""]).to eq(""signup"")
      expect(EmailToken.hash_token(job_args[""email_token""])).to eq(email_token.token_hash)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class PushNotificationPusher
  TOKEN_VALID_FOR_SECONDS ||= 5 * 60
  CONNECTION_TIMEOUT_SECONDS = 5

  def self.push(user, payload)
    message = nil
    I18n.with_locale(user.effective_locale) do
      notification_icon_name = Notification.types[payload[:notification_type]]
      if !File.exist?(
           File.expand_path(
             ""../../app/assets/images/push-notifications/#{notification_icon_name}.png"",
             __dir__,
           ),
         )
        notification_icon_name = ""discourse""
      end
      notification_icon =
        ActionController::Base.helpers.image_url(""push-notifications/#{notification_icon_name}.png"")

      message = {
        title: payload[:translated_title] || title(payload),
        body: payload[:excerpt],
        badge: get_badge,
        icon: notification_icon,
        tag: payload[:tag] || ""#{Discourse.current_hostname}-#{payload[:topic_id]}"",
        base_url: Discourse.base_url,
        url: payload[:post_url],
        hide_when_active: true,
      }

      subscriptions(user).each { |subscription| send_notification(user, subscription, message) }
    end

    message
  end

  def self.title(payload)
    translation_key =
      case payload[:notification_type]
      when Notification.types[:watching_category_or_tag]
        # For watching_category_or_tag, the notification could be for either a new post or new topic.
        # Instead of duplicating translations, we can rely on 'watching_first_post' for new topics,
        # and 'posted' for new posts.
        type = payload[:post_number] == 1 ? ""watching_first_post"" : ""posted""
        ""discourse_push_notifications.popup.#{type}""
      else
        ""discourse_push_notifications.popup.#{Notification.types[payload[:notification_type]]}""
      end

    I18n.t(
      translation_key,
      site_title: SiteSetting.title,
      topic: payload[:topic_title],
      username: payload[:username],
    )
  end

  def self.subscriptions(user)
    user.push_subscriptions
  end

  def self.clear_subscriptions(user)
    user.push_subscriptions.clear
  end

  def self.subscribe(user, push_params, send_confirmation)
    data = push_params.to_json
    subscriptions = PushSubscription.where(user: user, data: data)
    subscriptions_count = subscriptions.count

    new_subscription =
      if subscriptions_count > 1
        subscriptions.destroy_all
        PushSubscription.create!(user: user, data: data)
      elsif subscriptions_count == 0
        PushSubscription.create!(user: user, data: data)
      end

    if send_confirmation == ""true""
      message = {
        title:
          I18n.t(""discourse_push_notifications.popup.confirm_title"", site_title: SiteSetting.title),
        body: I18n.t(""discourse_push_notifications.popup.confirm_body""),
        icon: ActionController::Base.helpers.image_url(""push-notifications/check.png""),
        badge: get_badge,
        tag: ""#{Discourse.current_hostname}-subscription"",
      }

      send_notification(user, new_subscription, message)
    end
  end

  def self.unsubscribe(user, subscription)
    PushSubscription.find_by(user: user, data: subscription.to_json)&.destroy!
  end

  def self.get_badge
    if (url = SiteSetting.site_push_notifications_icon_url).present?
      url
    else
      ActionController::Base.helpers.image_url(""push-notifications/discourse.png"")
    end
  end

  MAX_ERRORS ||= 3
  MIN_ERROR_DURATION ||= 86_400 # 1 day

  def self.handle_generic_error(subscription, error, user, endpoint, message)
    subscription.error_count += 1
    subscription.first_error_at ||= Time.zone.now

    delta = Time.zone.now - subscription.first_error_at
    if subscription.error_count >= MAX_ERRORS && delta > MIN_ERROR_DURATION
      subscription.destroy!
    else
      subscription.save!
    end

    Discourse.warn_exception(
      error,
      message: ""Failed to send push notification"",
      env: {
        user_id: user.id,
        endpoint: endpoint,
        message: message.to_json,
      },
    )
  end

  def self.send_notification(user, subscription, message)
    parsed_data = subscription.parsed_data

    endpoint = parsed_data[""endpoint""]
    p256dh = parsed_data.dig(""keys"", ""p256dh"")
    auth = parsed_data.dig(""keys"", ""auth"")

    if (endpoint.blank? || p256dh.blank? || auth.blank?)
      subscription.destroy!
      return
    end

    begin
      WebPush.payload_send(
        endpoint: endpoint,
        message: message.to_json,
        p256dh: p256dh,
        auth: auth,
        vapid: {
          subject: Discourse.base_url,
          public_key: SiteSetting.vapid_public_key,
          private_key: SiteSetting.vapid_private_key,
          expiration: TOKEN_VALID_FOR_SECONDS,
        },
        open_timeout: CONNECTION_TIMEOUT_SECONDS,
        read_timeout: CONNECTION_TIMEOUT_SECONDS,
        ssl_timeout: CONNECTION_TIMEOUT_SECONDS,
      )

      if subscription.first_error_at || subscription.error_count != 0
        subscription.update_columns(error_count: 0, first_error_at: nil)
      end
    rescue WebPush::ExpiredSubscription
      subscription.destroy!
    rescue WebPush::ResponseError => e
      if e.response.message == ""MismatchSenderId""
        subscription.destroy!
      else
        handle_generic_error(subscription, e, user, endpoint, message)
      end
    rescue Timeout::Error => e
      handle_generic_error(subscription, e, user, endpoint, message)
    rescue OpenSSL::SSL::SSLError => e
      handle_generic_error(subscription, e, user, endpoint, message)
    end
  end

  private_class_method :send_notification
  private_class_method :handle_generic_error
end

```","# frozen_string_literal: true

RSpec.describe PushNotificationPusher do
  it ""returns badges url by default"" do
    expect(PushNotificationPusher.get_badge).to eq(""/assets/push-notifications/discourse.png"")
  end

  it ""returns custom badges url"" do
    upload = Fabricate(:upload)
    SiteSetting.push_notifications_icon = upload

    expect(PushNotificationPusher.get_badge).to eq(UrlHelper.absolute(upload.url))
  end

  context ""with user"" do
    fab!(:user)
    let(:topic_title) { ""Topic"" }
    let(:username) { ""system"" }

    def create_subscription
      data = <<~JSON
      {
        ""endpoint"": ""endpoint"",
        ""keys"": {
          ""p256dh"": ""p256dh"",
          ""auth"": ""auth""
        }
      }
      JSON
      PushSubscription.create!(user_id: user.id, data: data)
    end

    def execute_push(notification_type: 1, post_number: 1)
      PushNotificationPusher.push(
        user,
        {
          topic_title: topic_title,
          username: username,
          excerpt: ""description"",
          topic_id: 1,
          post_url: ""https://example.com/t/1/2"",
          notification_type: notification_type,
          post_number: post_number,
        },
      )
    end

    it ""correctly guesses an image if missing"" do
      message = execute_push(notification_type: -1)
      expect(message[:icon]).to eq(""/assets/push-notifications/discourse.png"")
    end

    it ""correctly finds image if exists"" do
      message = execute_push(notification_type: 1)
      expect(message[:icon]).to eq(""/assets/push-notifications/mentioned.png"")
    end

    it ""sends notification in user's locale"" do
      SiteSetting.allow_user_locale = true
      user.update!(locale: ""pt_BR"")

      TranslationOverride.upsert!(
        ""pt_BR"",
        ""discourse_push_notifications.popup.mentioned"",
        ""pt_BR notification"",
      )

      WebPush
        .expects(:payload_send)
        .with { |*args| JSON.parse(args.first[:message])[""title""] == ""pt_BR notification"" }
        .once

      create_subscription
      execute_push
    end

    it ""deletes subscriptions which are erroring regularly"" do
      start = freeze_time

      sub = create_subscription

      response = Struct.new(:body, :inspect, :message).new(""test"", ""test"", ""failed"")
      error = WebPush::ResponseError.new(response, ""localhost"")

      WebPush.expects(:payload_send).raises(error).times(4)

      # 3 failures in more than 24 hours
      3.times do
        execute_push

        freeze_time 1.minute.from_now
      end

      sub.reload
      expect(sub.error_count).to eq(3)
      expect(sub.first_error_at).to eq_time(start)

      freeze_time(2.days.from_now)

      execute_push

      expect(PushSubscription.where(id: sub.id).exists?).to eq(false)
    end

    it ""deletes invalid subscriptions during send"" do
      missing_endpoint =
        PushSubscription.create!(
          user_id: user.id,
          data: { p256dh: ""public ECDH key"", keys: { auth: ""private ECDH key"" } }.to_json,
        )

      missing_p256dh =
        PushSubscription.create!(
          user_id: user.id,
          data: { endpoint: ""endpoint 1"", keys: { auth: ""private ECDH key"" } }.to_json,
        )

      missing_auth =
        PushSubscription.create!(
          user_id: user.id,
          data: { endpoint: ""endpoint 2"", keys: { p256dh: ""public ECDH key"" } }.to_json,
        )

      valid_subscription =
        PushSubscription.create!(
          user_id: user.id,
          data: {
            endpoint: ""endpoint 3"",
            keys: {
              p256dh: ""public ECDH key"",
              auth: ""private ECDH key"",
            },
          }.to_json,
        )

      expect(PushSubscription.where(user_id: user.id)).to contain_exactly(
        missing_endpoint,
        missing_p256dh,
        missing_auth,
        valid_subscription,
      )
      WebPush
        .expects(:payload_send)
        .with(
          has_entries(endpoint: ""endpoint 3"", p256dh: ""public ECDH key"", auth: ""private ECDH key""),
        )
        .once

      execute_push

      expect(PushSubscription.where(user_id: user.id)).to contain_exactly(valid_subscription)
    end

    it ""handles timeouts"" do
      WebPush.expects(:payload_send).raises(Net::ReadTimeout.new)
      subscription = create_subscription

      expect { execute_push }.to_not raise_exception

      subscription.reload
      expect(subscription.error_count).to eq(1)
    end

    describe ""`watching_category_or_tag` notifications"" do
      it ""Uses the 'watching_first_post' translation when new topic was created"" do
        message =
          execute_push(
            notification_type: Notification.types[:watching_category_or_tag],
            post_number: 1,
          )

        expect(message[:title]).to eq(
          I18n.t(
            ""discourse_push_notifications.popup.watching_first_post"",
            site_title: SiteSetting.title,
            topic: topic_title,
            username: username,
          ),
        )
      end

      it ""Uses the 'posted' translation when new post was created"" do
        message =
          execute_push(
            notification_type: Notification.types[:watching_category_or_tag],
            post_number: 2,
          )

        expect(message[:title]).to eq(
          I18n.t(
            ""discourse_push_notifications.popup.posted"",
            site_title: SiteSetting.title,
            topic: topic_title,
            username: username,
          ),
        )
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class AnonymousShadowCreator
  attr_reader :user

  def self.get_master(user)
    new(user).get_master
  end

  def self.get(user)
    new(user).get
  end

  def initialize(user)
    @user = user
  end

  def get_master
    return unless user
    return unless SiteSetting.allow_anonymous_posting

    user.master_user
  end

  def get
    return unless user
    return unless SiteSetting.allow_anonymous_posting
    return if !user.in_any_groups?(SiteSetting.anonymous_posting_allowed_groups_map)
    return if SiteSetting.must_approve_users? && !user.approved?

    shadow = user.shadow_user

    if shadow && (shadow.post_count + shadow.topic_count) > 0 && shadow.last_posted_at &&
         shadow.last_posted_at < SiteSetting.anonymous_account_duration_minutes.minutes.ago
      shadow = nil
    end

    shadow || create_shadow!
  end

  private

  def create_shadow!
    username = resolve_username

    User.transaction do
      shadow =
        User.create!(
          password: SecureRandom.hex,
          email: ""#{SecureRandom.hex}@anon.#{Discourse.current_hostname}"",
          skip_email_validation: true,
          name: username, # prevents error when names are required
          username: username,
          active: true,
          trust_level: 1,
          manual_locked_trust_level: 1,
          approved: true,
          approved_at: 1.day.ago,
          created_at: 1.day.ago, # bypass new user restrictions
        )

      shadow.user_option.update_columns(
        email_messages_level: UserOption.email_level_types[:never],
        email_digests: false,
      )

      shadow.email_tokens.update_all(confirmed: true)
      shadow.activate

      AnonymousUser.where(master_user_id: user.id, active: true).update_all(active: false)
      AnonymousUser.create!(user_id: shadow.id, master_user_id: user.id, active: true)

      shadow.reload
      user.reload

      shadow
    end
  end

  def resolve_username
    username = I18n.t(""anonymous"").downcase
    username = ""anonymous"" unless UserNameSuggester.sanitize_username(username).present?

    UserNameSuggester.suggest(username)
  end
end

```","# frozen_string_literal: true

RSpec.describe AnonymousShadowCreator do
  it ""returns no shadow by default"" do
    expect(AnonymousShadowCreator.get(Fabricate.build(:user))).to eq(nil)
  end

  context ""when anonymous posting is enabled"" do
    fab!(:user) { Fabricate(:user, trust_level: 3) }

    before do
      SiteSetting.allow_anonymous_posting = true
      SiteSetting.anonymous_posting_allowed_groups = ""11""
      Group.refresh_automatic_groups!
    end

    it ""returns no shadow if the user is not in a group that is allowed to anonymously post"" do
      user = Fabricate(:user, trust_level: 0)
      Group.refresh_automatic_groups!
      expect(AnonymousShadowCreator.get(user)).to eq(nil)
    end

    it ""returns no shadow if must_approve_users is true and user is not approved"" do
      SiteSetting.must_approve_users = true
      expect(AnonymousShadowCreator.get(Fabricate.build(:user, approved: false))).to eq(nil)
    end

    it ""returns a new shadow once time expires"" do
      SiteSetting.anonymous_account_duration_minutes = 1

      shadow = AnonymousShadowCreator.get(user)

      freeze_time 2.minutes.from_now
      shadow2 = AnonymousShadowCreator.get(user)

      expect(shadow.id).to eq(shadow2.id)
      create_post(user: shadow)

      user.reload
      shadow.reload

      freeze_time 4.minutes.from_now
      shadow3 = AnonymousShadowCreator.get(user)

      expect(shadow3.user_option.email_digests).to eq(false)
      expect(shadow3.user_option.email_messages_level).to eq(UserOption.email_level_types[:never])

      expect(shadow2.id).not_to eq(shadow3.id)
    end

    it ""returns a shadow for a legit user"" do
      shadow = AnonymousShadowCreator.get(user)
      shadow2 = AnonymousShadowCreator.get(user)

      expect(shadow.id).to eq(shadow2.id)

      expect(shadow.trust_level).to eq(1)
      expect(shadow.username).to eq(""anonymous"")

      expect(shadow.created_at).not_to eq_time(user.created_at)

      p = create_post

      expect(Guardian.new(shadow).post_can_act?(p, :like)).to eq(false)
      expect(Guardian.new(user).post_can_act?(p, :like)).to eq(true)

      expect(user.anonymous?).to eq(false)
      expect(shadow.anonymous?).to eq(true)
    end

    it ""works even when names are required"" do
      SiteSetting.full_name_required = true

      expect { AnonymousShadowCreator.get(user) }.to_not raise_error
    end

    it ""works when there is an email allowlist"" do
      SiteSetting.allowed_email_domains = ""wayne.com""

      expect { AnonymousShadowCreator.get(user) }.to_not raise_error
    end

    it ""falls back to username 'anonymous' if the translation for 'anonymous' consists entirely of disallowed characters"" do
      # use russian locale but do not allow russian characters:
      I18n.locale = :ru
      SiteSetting.unicode_usernames = true
      SiteSetting.allowed_unicode_username_characters = ""[äöü]""

      shadow = AnonymousShadowCreator.get(user)

      expect(shadow.username).to eq(""anonymous"")
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class InlineUploads
  PLACEHOLDER = ""__replace__""
  PATH_PLACEHOLDER = ""__replace_path__""

  UPLOAD_REGEXP_PATTERN = ""/original/(\\dX/(?:\\h/)*\\h{40}[a-zA-Z0-9.]*)(\\?v=\\d+)?""
  private_constant :UPLOAD_REGEXP_PATTERN

  def self.process(markdown, on_missing: nil)
    markdown = markdown.dup

    match_md_reference(markdown) do |match, src, replacement, index|
      if upload = Upload.get_from_url(src)
        markdown = markdown.sub(match, replacement.sub!(PATH_PLACEHOLDER, ""__#{upload.sha1}__""))
      end
    end

    cooked_fragment = Nokogiri::HTML5.fragment(PrettyText.cook(markdown, disable_emojis: true))
    link_occurrences = []

    cooked_fragment.traverse do |node|
      if node.name == ""img""
        # Do nothing
      elsif !(
            node.children.count == 1 &&
              (node.children[0].name != ""img"" && node.children[0].children.blank?)
          ) &&
            !(
              node.name == ""a"" && node.children.count > 1 &&
                !node_children_names(node).include?(""img"")
            )
        next
      end

      if seen_link = matched_uploads(node).first
        if (actual_link = (node.attributes[""href""]&.value || node.attributes[""src""]&.value))
          link_occurrences << { link: actual_link, is_valid: true }
        elsif node.name != ""p""
          link_occurrences << { link: seen_link, is_valid: false }
        end
      end
    end

    raw_matches = []

    match_bbcode_img(markdown) do |match, src, replacement, index|
      raw_matches << [match, src, replacement, index]
    end

    match_md_inline_img(markdown) do |match, src, replacement, index|
      raw_matches << [match, src, replacement, index]
    end

    match_img(markdown) do |match, src, replacement, index|
      raw_matches << [match, src, replacement, index]
    end

    match_anchor(markdown) do |match, href, replacement, index|
      raw_matches << [match, href, replacement, index]
    end

    regexps = [
      %r{(https?://[a-zA-Z0-9\./-]+/#{Discourse.store.upload_path}#{UPLOAD_REGEXP_PATTERN})},
    ]

    if Discourse.store.external?
      regexps << /((?:https?:)?#{SiteSetting.Upload.s3_base_url}#{UPLOAD_REGEXP_PATTERN})/
      regexps << /(#{SiteSetting.Upload.s3_cdn_url}#{UPLOAD_REGEXP_PATTERN})/
    end

    regexps.each do |regexp|
      indexes = Set.new

      markdown.scan(/(\n{2,}|\A)#{regexp}$/) do |match|
        if match[1].present? && match[2].present?
          extension = match[2].split(""."")[-1].downcase
          index = $~.offset(2)[0]
          indexes << index
          if FileHelper.supported_images.include?(extension)
            raw_matches << [match[1], match[1], +""![](#{PLACEHOLDER})"", index]
          else
            raw_matches << [match[1], match[1], +""#{Discourse.base_url}#{PATH_PLACEHOLDER}"", index]
          end
        end
      end

      markdown.scan(/^#{regexp}(\s)/) do |match|
        if match[0].present?
          index = $~.offset(0)[0]
          next if !indexes.add?(index)
          raw_matches << [match[0], match[0], +""#{Discourse.base_url}#{PATH_PLACEHOLDER}"", index]
        end
      end

      markdown.scan(/\[[^\[\]]*\]: #{regexp}/) do |match|
        indexes.add($~.offset(1)[0]) if match[0].present?
      end

      markdown.scan(/(([\n\s\)\]\<])+)#{regexp}/) do |match|
        if matched_uploads(match[2]).present?
          next if !indexes.add?($~.offset(3)[0])
          index = $~.offset(0)[0]
          raw_matches << [match[2], match[2], +""#{Discourse.base_url}#{PATH_PLACEHOLDER}"", index]
        end
      end
    end

    raw_matches
      .sort { |a, b| a[3] <=> b[3] }
      .each do |match, link, replace_with, _index|
        node_info = link_occurrences.shift
        next unless node_info&.dig(:is_valid)

        if link.include?(node_info[:link])
          begin
            uri = URI(link)
          rescue URI::Error
          end

          if !Discourse.store.external?
            host = uri&.host

            hosts = [Discourse.current_hostname]

            if cdn_url = GlobalSetting.cdn_url
              hosts << URI(GlobalSetting.cdn_url).hostname
            end

            next if host && !hosts.include?(host)
          end

          upload = Upload.get_from_url(link)

          if upload
            replace_with.sub!(PLACEHOLDER, upload.short_url)
            replace_with.sub!(PATH_PLACEHOLDER, upload.short_path)
            markdown.sub!(match, replace_with)
          else
            on_missing.call(link) if on_missing
          end
        end
      end

    markdown.scan(/(__(\h{40})__)/) do |match|
      upload = Upload.find_by(sha1: match[1])
      markdown = markdown.sub(match[0], upload.short_path)
    end

    markdown
  end

  def self.match_md_inline_img(markdown, external_src: false)
    markdown.scan(/(!?\[([^\[\]]*)\]\(([^\s\)]+)([ ]*['""]{1}[^\)]*['""]{1}[ ]*)?\))/) do |match|
      if (external_src || matched_uploads(match[2]).present?) && block_given?
        yield(
          match[0],
          match[2],
          +""#{match[0].start_with?(""!"") ? ""!"" : """"}[#{match[1]}](#{PLACEHOLDER}#{match[3]})"",
          $~.offset(0)[0]
        )
      end
    end
  end

  def self.match_bbcode_img(markdown, external_src: false)
    markdown.scan(%r{(\[img\]\s*([^\[\]\s]+)\s*\[/img\])}i) do |match|
      if (external_src || (matched_uploads(match[1]).present?)) && block_given?
        yield(match[0], match[1], +""![](#{PLACEHOLDER})"", $~.offset(0)[0])
      end
    end
  end

  def self.match_md_reference(markdown)
    markdown.scan(/(\[([^\]]+)\]:([ ]+)(\S+))/) do |match|
      if match[3] && matched_uploads(match[3]).present? && block_given?
        yield(
          match[0],
          match[3],
          +""[#{match[1]}]:#{match[2]}#{Discourse.base_url}#{PATH_PLACEHOLDER}"",
          $~.offset(0)[0]
        )
      end
    end
  end

  def self.match_anchor(markdown, external_href: false)
    markdown.scan(%r{((<a[^<]+>)([^<\a>]*?)</a>)}i) do |match|
      node = Nokogiri::HTML5.fragment(match[0]).children[0]
      href = node.attributes[""href""]&.value

      if href && (external_href || matched_uploads(href).present?)
        has_attachment = node.attributes[""class""]&.value
        index = $~.offset(0)[0]
        text = match[2].strip.gsub(""\n"", """").gsub(/ +/, "" "")
        text = ""#{text}|attachment"" if has_attachment

        yield(match[0], href, +""[#{text}](#{PLACEHOLDER})"", index) if block_given?
      end
    end
  end

  def self.match_img(markdown, external_src: false, uploads: nil)
    markdown.scan(%r{(<(?!img)[^<>]+/?>)?(\s*)(<img [^>\n]+>)}i) do |match|
      node = Nokogiri::HTML5.fragment(match[2].strip).children[0]
      src = node&.attributes&.[](""src"")&.value

      if src && (external_src || matched_uploads(src).present?)
        upload = uploads&.[](src)
        node[""src""] = upload&.short_url || PLACEHOLDER

        spaces_before = match[1].present? ? match[1][/ +$/].size : 0
        replacement = +""#{"" "" * spaces_before}#{node.to_s}""

        yield(match[2], src, replacement, $~.offset(0)[0]) if block_given?
      end
    end
  end

  def self.replace_hotlinked_image_urls(raw:, &blk)
    replace =
      Proc.new do |match, match_src, replacement, _index|
        upload = blk.call(match_src)
        next if !upload

        replacement =
          if replacement.include?(InlineUploads::PLACEHOLDER)
            replacement.sub(InlineUploads::PLACEHOLDER, upload.short_url)
          elsif replacement.include?(InlineUploads::PATH_PLACEHOLDER)
            replacement.sub(InlineUploads::PATH_PLACEHOLDER, upload.short_path)
          end

        raw = raw.gsub(match, replacement)
      end

    # there are 6 ways to insert an image in a post
    # HTML tag - <img src=""http://..."">
    InlineUploads.match_img(raw, external_src: true, &replace)

    # BBCode tag - [img]http://...[/img]
    InlineUploads.match_bbcode_img(raw, external_src: true, &replace)

    # Markdown linked image - [![alt](http://...)](http://...)
    # Markdown inline - ![alt](http://...)
    # Markdown inline - ![](http://... ""image title"")
    # Markdown inline - ![alt](http://... ""image title"")
    InlineUploads.match_md_inline_img(raw, external_src: true, &replace)

    raw =
      raw.gsub(%r{^(https?://\S+)(\s?)$}) do |match|
        if upload = blk.call(match)
          ""![](#{upload.short_url})""
        else
          match
        end
      end

    raw
  end

  def self.matched_uploads(node)
    upload_path = Discourse.store.upload_path
    base_url = Discourse.base_url.sub(%r{https?://}, ""(https?://)"")

    regexps = [
      %r{(upload://([a-zA-Z0-9]+)[a-zA-Z0-9\.]*)},
      %r{(/uploads/short-url/([a-zA-Z0-9]+)[a-zA-Z0-9\.]*)},
      %r{(#{base_url}/uploads/short-url/([a-zA-Z0-9]+)[a-zA-Z0-9\.]*)},
      %r{(#{GlobalSetting.relative_url_root}/#{upload_path}#{UPLOAD_REGEXP_PATTERN})},
      %r{(#{base_url}/#{upload_path}#{UPLOAD_REGEXP_PATTERN})},
    ]

    if GlobalSetting.cdn_url && (cdn_url = GlobalSetting.cdn_url.sub(%r{https?://}, ""(https?://)""))
      regexps << %r{(#{cdn_url}/#{upload_path}#{UPLOAD_REGEXP_PATTERN})}
      if GlobalSetting.relative_url_root.present?
        regexps << %r{(#{cdn_url}#{GlobalSetting.relative_url_root}/#{upload_path}#{UPLOAD_REGEXP_PATTERN})}
      end
    end

    if Discourse.store.external?
      if Rails.configuration.multisite
        regexps << %r{((https?:)?#{SiteSetting.Upload.s3_base_url}/#{upload_path}#{UPLOAD_REGEXP_PATTERN})}
        regexps << %r{(#{SiteSetting.Upload.s3_cdn_url}/#{upload_path}#{UPLOAD_REGEXP_PATTERN})}
      else
        regexps << /((https?:)?#{SiteSetting.Upload.s3_base_url}#{UPLOAD_REGEXP_PATTERN})/
        regexps << /(#{SiteSetting.Upload.s3_cdn_url}#{UPLOAD_REGEXP_PATTERN})/
      end
    end

    matches = []
    node = node.to_s

    regexps.each do |regexp|
      node.scan(/(^|[\n\s""'\(>])#{regexp}($|[\n\s""'\)<])/) { |matched| matches << matched[1] }
    end

    matches
  end
  private_class_method :matched_uploads

  def self.node_children_names(node, names = Set.new)
    if node.children.blank?
      names << node.name
      return names
    end

    node.children.each { |child| names = node_children_names(child, names) }

    names
  end
  private_class_method :node_children_names
end

```","# frozen_string_literal: true
RSpec.describe InlineUploads do
  before { set_cdn_url ""https://awesome.com"" }

  describe "".process"" do
    context ""with local uploads"" do
      fab!(:upload)
      fab!(:upload2) { Fabricate(:upload) }
      fab!(:upload3) { Fabricate(:upload) }

      it ""should not correct existing inline uploads"" do
        md = <<~MD
        ![test](#{upload.short_url})haha
        [test]#{upload.short_url}
        MD

        expect(InlineUploads.process(md)).to eq(md)

        md = <<~MD
        ![test](#{upload.short_url})
        [test|attachment](#{upload.short_url})
        MD

        expect(InlineUploads.process(md)).to eq(md)
      end

      it ""should not escape existing content"" do
        md = ""1 > 2""

        expect(InlineUploads.process(md)).to eq(md)
      end

      it ""should not escape invalid HTML tags"" do
        md = ""<x>.<y>""

        expect(InlineUploads.process(md)).to eq(md)
      end

      it ""should work with invalid img tags"" do
        md = <<~MD
        <img src=""#{upload.url}"">

        This is an invalid `<img ...>` tag
        MD

        expect(InlineUploads.process(md)).to eq(<<~MD)
        <img src=""#{upload.short_url}"">

        This is an invalid `<img ...>` tag
        MD

        md = '<img data-id=""<>"">'
        expect(InlineUploads.process(md)).to eq(md)
      end

      it ""should not correct code blocks"" do
        md = ""`<a class=\""attachment\"" href=\""#{upload2.url}\"">In Code Block</a>`""

        expect(InlineUploads.process(md)).to eq(md)

        md = ""    <a class=\""attachment\"" href=\""#{upload2.url}\"">In Code Block</a>""

        expect(InlineUploads.process(md)).to eq(md)
      end

      it ""should not correct invalid links in quotes"" do
        post = Fabricate(:post)
        user = Fabricate(:user)

        md = <<~MD
        [quote=""#{user.username}, post:#{post.post_number}, topic:#{post.topic.id}""]
        <img src=""#{upload.url}""
        someothertext#{upload2.url}someothertext

        <img src=""#{upload.url}""

        sometext#{upload2.url}sometext

        #{upload3.url}

        #{Discourse.base_url}#{upload3.url}
        [/quote]

        <img src=""#{upload2.url}"">
        MD

        expect(InlineUploads.process(md)).to eq(<<~MD)
        [quote=""#{user.username}, post:#{post.post_number}, topic:#{post.topic.id}""]
        <img src=""#{upload.url}""
        someothertext#{upload2.url}someothertext

        <img src=""#{upload.url}""

        sometext#{upload2.url}sometext

        #{upload3.url}

        ![](#{upload3.short_url})
        [/quote]

        <img src=""#{upload2.short_url}"">
        MD
      end

      it ""should correct links in quotes"" do
        post = Fabricate(:post)
        user = Fabricate(:user)

        md = <<~MD
        [quote=""#{user.username}, post:#{post.post_number}, topic:#{post.topic.id}""]
        some quote

        #{Discourse.base_url}#{upload3.url}

        ![](#{upload.url})
        [/quote]
        MD

        expect(InlineUploads.process(md)).to eq(<<~MD)
        [quote=""#{user.username}, post:#{post.post_number}, topic:#{post.topic.id}""]
        some quote

        ![](#{upload3.short_url})

        ![](#{upload.short_url})
        [/quote]
        MD
      end

      it ""should correct markdown linked images"" do
        md = <<~MD
        [![](#{upload.url})](https://somelink.com)

        [![some test](#{upload2.url})](https://somelink.com)
        MD

        expect(InlineUploads.process(md)).to eq(<<~MD)
        [![](#{upload.short_url})](https://somelink.com)

        [![some test](#{upload2.short_url})](https://somelink.com)
        MD
      end

      it ""should correct markdown images with title"" do
        md = <<~MD
        ![](#{upload.url} ""some alt"")
        ![testing](#{upload2.url}  'some alt'  )
        MD

        expect(InlineUploads.process(md)).to eq(<<~MD)
        ![](#{upload.short_url} ""some alt"")
        ![testing](#{upload2.short_url}  'some alt'  )
        MD
      end

      it ""should correct bbcode img URLs to the short version"" do
        md = <<~MD
        [img]http://some.external.img[/img]
        [img]#{upload.url}[/img]
        <img src=""#{upload3.url}"">

        [img]
        #{upload2.url}
        [/img]

        [img]#{upload.url}[/img][img]#{upload2.url}[/img]
        MD

        expect(InlineUploads.process(md)).to eq(<<~MD)
        [img]http://some.external.img[/img]
        ![](#{upload.short_url})
        <img src=""#{upload3.short_url}"">

        ![](#{upload2.short_url})

        ![](#{upload.short_url})![](#{upload2.short_url})
        MD
      end

      it ""should correct markdown references"" do
        md = <<~MD
        [link3][3]

        [3]: #{Discourse.base_url}#{upload2.url}

        This is a [link1][1] test [link2][2] something

        <img src=""#{upload.url}"">

        [1]: #{Discourse.base_url}#{upload.url}
        [2]: #{Discourse.base_url.sub(""http://"", ""https://"")}#{upload2.url}
        MD

        expect(InlineUploads.process(md)).to eq(<<~MD)
        [link3][3]

        [3]: #{Discourse.base_url}#{upload2.short_path}

        This is a [link1][1] test [link2][2] something

        <img src=""#{upload.short_url}"">

        [1]: #{Discourse.base_url}#{upload.short_path}
        [2]: #{Discourse.base_url}#{upload2.short_path}
        MD
      end

      it ""should correct html and markdown uppercase references"" do
        md = <<~MD
        [IMG]#{upload.url}[/IMG]
        <IMG src=""#{upload2.url}"" />
        <A class=""attachment"" href=""#{upload3.url}"">Text</A>
        MD

        expect(InlineUploads.process(md)).to eq(<<~MD)
        ![](#{upload.short_url})
        <img src=""#{upload2.short_url}"">
        [Text|attachment](#{upload3.short_url})
        MD
      end

      it ""should correct image URLs with v parameters"" do
        md = <<~MD
        <img src=""#{upload.url}?v=1"">

        <img src=""#{Discourse.base_url}#{upload.url}?v=2"">

        <img src=""#{GlobalSetting.cdn_url}#{upload.url}?v=3"">

        #{Discourse.base_url}#{upload.url}?v=45

        #{GlobalSetting.cdn_url}#{upload.url}?v=999
        MD

        expect(InlineUploads.process(md)).to eq(<<~MD)
        <img src=""#{upload.short_url}"">

        <img src=""#{upload.short_url}"">

        <img src=""#{upload.short_url}"">

        ![](#{upload.short_url})

        ![](#{upload.short_url})
        MD
      end

      context ""with subfolder"" do
        before { set_subfolder ""/community"" }

        it ""should correct subfolder images"" do
          md = <<~MD
            <img src=""/community#{upload.url}"">

            #{Discourse.base_url}#{upload.url}
          MD

          expect(InlineUploads.process(md)).to eq(<<~MD)
            <img src=""#{upload.short_url}"">

            ![](#{upload.short_url})
          MD
        end
      end

      it ""should correct raw image URLs to the short url and paths"" do
        md = <<~MD
        #{Discourse.base_url}#{upload.url}

        #{Discourse.base_url}#{upload.url} #{Discourse.base_url}#{upload2.url}

        #{Discourse.base_url}#{upload3.url}

        #{GlobalSetting.cdn_url}#{upload3.url}
        MD

        expect(InlineUploads.process(md)).to eq(<<~MD)
        ![](#{upload.short_url})

        #{Discourse.base_url}#{upload.short_path} #{Discourse.base_url}#{upload2.short_path}

        ![](#{upload3.short_url})

        ![](#{upload3.short_url})
        MD
      end

      it ""should correct non image URLs to the short url"" do
        SiteSetting.authorized_extensions = ""mp4""
        upload = Fabricate(:video_upload)
        upload2 = Fabricate(:video_upload)

        md = <<~MD
        #{Discourse.base_url}#{upload.url}

        #{Discourse.base_url}#{upload.url} #{Discourse.base_url}#{upload2.url}

        #{GlobalSetting.cdn_url}#{upload2.url}
        MD

        expect(InlineUploads.process(md)).to eq(<<~MD)
        #{Discourse.base_url}#{upload.short_path}

        #{Discourse.base_url}#{upload.short_path} #{Discourse.base_url}#{upload2.short_path}

        #{Discourse.base_url}#{upload2.short_path}
        MD
      end

      it ""should correct img tags with uppercase upload extension"" do
        md = <<~MD
        test<img src=""#{upload.url.sub("".png"", "".PNG"")}"">
        MD

        expect(InlineUploads.process(md)).to eq(<<~MD)
        test<img src=""#{upload.short_url}"">
        MD
      end

      it ""should correct image URLs that follows an image md"" do
        md = <<~MD
        ![image|690x290](#{upload.short_url})#{Discourse.base_url}#{upload2.url}

        <#{Discourse.base_url}#{upload2.url}>
        MD

        expect(InlineUploads.process(md)).to eq(<<~MD)
        ![image|690x290](#{upload.short_url})#{Discourse.base_url}#{upload2.short_path}

        <#{Discourse.base_url}#{upload2.short_path}>
        MD
      end

      it ""should correct image URLs to the short version"" do
        md = <<~MD
        ![image|690x290](#{upload.short_url})

        ![IMAge|690x190,60%](#{upload.short_url})

        ![image](#{upload2.url})
        ![image|100x100](#{upload3.url})

        <img src=""#{Discourse.base_url}#{upload.url}"" alt=""some image"" title=""some title"" />
        <img src=""#{Discourse.base_url}#{upload2.url}"" alt=""some image""><img src=""#{Discourse.base_url}#{upload3.url}"" alt=""some image"">

        #{Discourse.base_url}#{upload3.url} #{Discourse.base_url}#{upload3.url}

        <img src=""#{upload.url}"" width=""5"" height=""4"">
        <img src=""#{upload.url}"" width=""5px"" height=""auto"">

        `<img src=""#{upload.url}"" alt=""image inside code quotes"">`

        ```
        <img src=""#{upload.url}"" alt=""image inside code fences"">
        ```

            <img src=""#{upload.url}"" alt=""image inside code block"">
        MD

        expect(InlineUploads.process(md)).to eq(<<~MD)
        ![image|690x290](#{upload.short_url})

        ![IMAge|690x190,60%](#{upload.short_url})

        ![image](#{upload2.short_url})
        ![image|100x100](#{upload3.short_url})

        <img src=""#{upload.short_url}"" alt=""some image"" title=""some title"">
        <img src=""#{upload2.short_url}"" alt=""some image""><img src=""#{upload3.short_url}"" alt=""some image"">

        #{Discourse.base_url}#{upload3.short_path} #{Discourse.base_url}#{upload3.short_path}

        <img src=""#{upload.short_url}"" width=""5"" height=""4"">
        <img src=""#{upload.short_url}"" width=""5px"" height=""auto"">

        `<img src=""#{upload.url}"" alt=""image inside code quotes"">`

        ```
        <img src=""#{upload.url}"" alt=""image inside code fences"">
        ```

            <img src=""#{upload.url}"" alt=""image inside code block"">
        MD
      end

      it ""should not replace identical markdown in code blocks"", skip: ""Known issue"" do
        md = <<~MD
        `![image|690x290](#{upload.url})`
        ![image|690x290](#{upload.url})
        MD

        expect(InlineUploads.process(md)).to eq(<<~MD)
        `![image|690x290](#{upload.url})`
        ![image|690x290](#{upload.short_url})
        MD
      end

      it ""should not be affected by an emoji"" do
        CustomEmoji.create!(name: ""test"", upload: upload3)
        Emoji.clear_cache

        md = <<~MD
        :test:

        ![image|690x290](#{upload.url})
        MD

        expect(InlineUploads.process(md)).to eq(<<~MD)
        :test:

        ![image|690x290](#{upload.short_url})
        MD
      end

      it ""should correctly update images sources within anchor tags with indentation"" do
        md = <<~MD
        <h1></h1>
                        <a href=""http://somelink.com"">
                          <img src=""#{upload2.url}"" alt=""test"" width=""500"" height=""500"">
                        </a>

                        <a href=""http://somelink.com"">
                          <img src=""#{upload2.url}"" alt=""test"" width=""500"" height=""500"">
                        </a>
        MD

        expect(InlineUploads.process(md)).to eq(<<~MD)
        <h1></h1>
                        <a href=""http://somelink.com"">
                          <img src=""#{upload2.short_url}"" alt=""test"" width=""500"" height=""500"">
                        </a>

                        <a href=""http://somelink.com"">
                          <img src=""#{upload2.url}"" alt=""test"" width=""500"" height=""500"">
                        </a>
        MD

        md =
          ""<h1></h1>\r\n<a href=\""http://somelink.com\"">\r\n        <img src=\""#{upload.url}\"" alt=\""test\"" width=\""500\"" height=\""500\"">\r\n</a>""

        expect(InlineUploads.process(md)).to eq(
          ""<h1></h1>\r\n<a href=\""http://somelink.com\"">\r\n        <img src=\""#{upload.short_url}\"" alt=\""test\"" width=\""500\"" height=\""500\"">\r\n</a>"",
        )
      end

      it ""should correctly update image sources within anchor or paragraph tags"" do
        md = <<~MD
        <a href=""http://somelink.com"">
          <img src=""#{upload.url}"" alt=""test"" width=""500"" height=""500"">
        </a>

        <p>
          <img src=""#{upload2.url}"" alt=""test"">
        </p>

        <a href=""http://somelink.com""><img src=""#{upload3.url}"" alt=""test"" width=""500"" height=""500""></a>

        <a href=""http://somelink.com"">  <img src=""#{upload.url}"" alt=""test"" width=""500"" height=""500"">  </a>

        <a href=""http://somelink.com"">


        <img src=""#{upload.url}"" alt=""test"" width=""500"" height=""500"">

        </a>

        <p>Test <img src=""#{upload2.url}"" alt=""test"" width=""500"" height=""500""></p>

        <hr/>
        <img src=""#{upload2.url}"" alt=""test"" width=""500"" height=""500"">
        MD

        expect(InlineUploads.process(md)).to eq(<<~MD)
        <a href=""http://somelink.com"">
          <img src=""#{upload.short_url}"" alt=""test"" width=""500"" height=""500"">
        </a>

        <p>
          <img src=""#{upload2.short_url}"" alt=""test"">
        </p>

        <a href=""http://somelink.com""><img src=""#{upload3.short_url}"" alt=""test"" width=""500"" height=""500""></a>

        <a href=""http://somelink.com"">  <img src=""#{upload.short_url}"" alt=""test"" width=""500"" height=""500"">  </a>

        <a href=""http://somelink.com"">


        <img src=""#{upload.short_url}"" alt=""test"" width=""500"" height=""500"">

        </a>

        <p>Test <img src=""#{upload2.short_url}"" alt=""test"" width=""500"" height=""500""></p>

        <hr/>
        <img src=""#{upload2.short_url}"" alt=""test"" width=""500"" height=""500"">
        MD
      end

      it ""should not be affected by fake HTML tags"" do
        md = <<~MD
        ```
        This is some <img src="" and <a href=""
        ```

        <img src=""#{upload.url}"" alt=""test"">

        <img src=""#{upload2.url}"" alt=""test"" height=""150<img"">

        > some quote

        <a class=""attachment"" href=""#{upload2.url}"">test2</a>
        MD

        expect(InlineUploads.process(md)).to eq(<<~MD)
        ```
        This is some <img src="" and <a href=""
        ```

        <img src=""#{upload.short_url}"" alt=""test"">

        <img src=""#{upload2.short_url}"" alt=""test"" height=""150<img"">

        > some quote

        [test2|attachment](#{upload2.short_url})
        MD
      end

      it ""should not be affected by an external or invalid links"" do
        md = <<~MD
        <a id=""test"">invalid</a>

        [test](""https://this.is.some.external.link"")

        <a href=""https://some.external.com/link"">test</a>

        <a class=""attachment"" href=""#{upload2.url}"">test2</a>
        MD

        expect(InlineUploads.process(md)).to eq(<<~MD)
        <a id=""test"">invalid</a>

        [test](""https://this.is.some.external.link"")

        <a href=""https://some.external.com/link"">test</a>

        [test2|attachment](#{upload2.short_url})
        MD
      end

      it ""should correct attachment URLS to the short version when raw contains inline image"" do
        md = <<~MD
        ![image](#{upload.short_url}) ![image](#{upload.short_url})

        [some complicated.doc %50](#{upload3.url})

        <a class=""attachment"" href=""#{upload2.url}"">test2</a>
        MD

        expect(InlineUploads.process(md)).to eq(<<~MD)
        ![image](#{upload.short_url}) ![image](#{upload.short_url})

        [some complicated.doc %50](#{upload3.short_url})

        [test2|attachment](#{upload2.short_url})
        MD
      end

      it ""should correct attachment URLs to the short version"" do
        md = <<~MD
        <a class=""attachment"" href=""#{upload.url}"">
          this
          is
          some
          attachment

        </a>

        - <a class=""attachment"" href=""#{upload.url}"">test2</a>
          - <a class=""attachment"" href=""#{upload2.url}"">test2</a>
            - <a class=""attachment"" href=""#{upload3.url}"">test2</a>

        <a class=""test attachment"" href=""#{upload.url}"">test3</a>
        <a class=""test attachment"" href=""#{upload2.url}"">test3</a><a class=""test attachment"" href=""#{upload3.url}"">test3</a>

        <a class=""test attachment"" href=""#{upload3.url}"">This is some _test_ here</a>
        MD

        expect(InlineUploads.process(md)).to eq(<<~MD)
        [this is some attachment|attachment](#{upload.short_url})

        - [test2|attachment](#{upload.short_url})
          - [test2|attachment](#{upload2.short_url})
            - [test2|attachment](#{upload3.short_url})

        [test3|attachment](#{upload.short_url})
        [test3|attachment](#{upload2.short_url})[test3|attachment](#{upload3.short_url})

        [This is some _test_ here|attachment](#{upload3.short_url})
        MD
      end

      it ""should correct full upload url to the shorter version"" do
        md = <<~MD
        Some random text

        ![test](#{upload.short_url})
        [test|attachment](#{upload.short_url})

        <a class=""test attachment"" href=""#{upload.url}"">
          test
        </a>

        `<a class=""attachment"" href=""#{upload2.url}"">In Code Block</a>`

            <a class=""attachment"" href=""#{upload3.url}"">In Code Block</a>

        <a href=""#{upload.url}"">newtest</a>
        <a href=""#{Discourse.base_url_no_prefix}#{upload.url}"">newtest</a>

        <a href=""https://somerandomesite.com#{upload.url}"">test</a>
        <a class=""attachment"" href=""https://somerandom.com/url"">test</a>
        MD

        expect(InlineUploads.process(md)).to eq(<<~MD)
        Some random text

        ![test](#{upload.short_url})
        [test|attachment](#{upload.short_url})

        [test|attachment](#{upload.short_url})

        `<a class=""attachment"" href=""#{upload2.url}"">In Code Block</a>`

            <a class=""attachment"" href=""#{upload3.url}"">In Code Block</a>

        [newtest](#{upload.short_url})
        [newtest](#{upload.short_url})

        <a href=""https://somerandomesite.com#{upload.url}"">test</a>
        <a class=""attachment"" href=""https://somerandom.com/url"">test</a>
        MD
      end

      it ""accepts a block that yields when link does not match an upload in the db"" do
        url = ""#{Discourse.base_url}#{upload.url}""

        md = <<~MD
        <img src=""#{url}"" alt=""some image"">
        <img src=""#{upload2.url}"" alt=""some image"">
        MD

        upload.destroy!

        InlineUploads.process(md, on_missing: lambda { |link| expect(link).to eq(url) })
      end
    end

    context ""with s3 uploads"" do
      let(:upload) { Fabricate(:upload_s3) }
      let(:upload2) { Fabricate(:upload_s3) }
      let(:upload3) { Fabricate(:upload) }

      before do
        upload3
        setup_s3
        SiteSetting.s3_cdn_url = ""https://s3.cdn.com""
      end

      it ""should correct image URLs to the short version"" do
        md = <<~MD
        #{upload.url}
        <img src=""#{upload.url}"" alt=""some image"">
        test<img src=""#{upload2.url}"" alt=""some image"">test
        <img src=""#{URI.join(SiteSetting.s3_cdn_url, URI.parse(upload2.url).path).to_s}"" alt=""some image"">
        MD

        expect(InlineUploads.process(md)).to eq(<<~MD)
        ![](#{upload.short_url})
        <img src=""#{upload.short_url}"" alt=""some image"">
        test<img src=""#{upload2.short_url}"" alt=""some image"">test
        <img src=""#{upload2.short_url}"" alt=""some image"">
        MD
      end

      it ""should correct markdown references"" do
        md = <<~MD
        This is a [some reference] something

        [some reference]: https:#{upload.url}
        MD

        expect(InlineUploads.process(md)).to eq(<<~MD)
        This is a [some reference] something

        [some reference]: #{Discourse.base_url}#{upload.short_path}
        MD
      end
    end
  end

  describe "".match_md_inline_img"" do
    it ""matches URLs with various characters"" do
      md = <<~MD
      ![test](https://some-site.com/a_test?q=1&b=hello%20there)
      MD

      url = nil
      InlineUploads.match_md_inline_img(md, external_src: true) { |_match, src| url = src }

      expect(url).to eq(""https://some-site.com/a_test?q=1&b=hello%20there"")
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class UserSilencer
  attr_reader :user_history

  def initialize(user, by_user = nil, opts = {})
    @user, @by_user, @opts = user, by_user, opts
  end

  def self.silence(user, by_user = nil, opts = {})
    UserSilencer.new(user, by_user, opts).silence
  end

  def self.unsilence(user, by_user = nil, opts = {})
    UserSilencer.new(user, by_user, opts).unsilence
  end

  def self.was_silenced_for?(post)
    return false if post.blank?

    UserHistory.where(action: UserHistory.actions[:silence_user], post: post).exists?
  end

  def silence
    hide_posts unless @opts[:keep_posts]
    return false if @user.silenced_till.present?
    @user.silenced_till = @opts[:silenced_till] || 1000.years.from_now
    if @user.save
      message_type = @opts[:message] || :silenced_by_staff

      details = StaffMessageFormat.new(:silence, @opts[:reason], @opts[:message_body]).format

      context = ""#{message_type}: #{@opts[:reason]}""

      if @by_user
        log_params = { context: context, details: details }
        log_params[:post_id] = @opts[:post_id].to_i if @opts[:post_id]

        @user_history = StaffActionLogger.new(@by_user).log_silence_user(@user, log_params)
      end

      silence_message_params = {}
      DiscourseEvent.trigger(
        :user_silenced,
        user: @user,
        silenced_by: @by_user,
        reason: @opts[:reason],
        message: @opts[:message_body],
        user_history: @user_history,
        post_id: @opts[:post_id],
        silenced_till: @user.silenced_till,
        silenced_at: DateTime.now,
        silence_message_params: silence_message_params,
      )

      silence_message_params.merge!(post_alert_options: { skip_send_email: true })
      SystemMessage.create(@user, message_type, silence_message_params)
      true
    end
  end

  def hide_posts
    return unless @user.trust_level == TrustLevel[0]

    Post
      .where(user_id: @user.id)
      .where(""created_at > ?"", 24.hours.ago)
      .update_all(
        [
          ""hidden = true, hidden_reason_id = COALESCE(hidden_reason_id, ?)"",
          Post.hidden_reasons[:new_user_spam_threshold_reached],
        ],
      )
    topic_ids =
      Post
        .where(user_id: @user.id, post_number: 1)
        .where(""created_at > ?"", 24.hours.ago)
        .pluck(:topic_id)
    Topic.where(id: topic_ids).update_all(visible: false) unless topic_ids.empty?
  end

  def unsilence
    @user.silenced_till = nil
    if @user.save
      DiscourseEvent.trigger(:user_unsilenced, user: @user, by_user: @by_user)
      SystemMessage.create(@user, :unsilenced)
      StaffActionLogger.new(@by_user).log_unsilence_user(@user) if @by_user
    end
  end
end

```","# frozen_string_literal: true

RSpec.describe UserSilencer do
  fab!(:user) { Fabricate(:user, trust_level: 0) }
  fab!(:post) { Fabricate(:post, user: user) }
  fab!(:admin)

  describe ""silence"" do
    subject(:silence_user) { silencer.silence }

    let(:silencer) { UserSilencer.new(user) }

    it ""silences the user correctly"" do
      expect { UserSilencer.silence(user, admin) }.to change { user.reload.silenced? }

      # no need to silence as we are already silenced
      expect { UserSilencer.silence(user) }.not_to change { Post.count }

      # post should be hidden
      post.reload
      expect(post.topic.visible).to eq(false)
      expect(post.hidden).to eq(true)

      # history should be right
      count =
        UserHistory.where(
          action: UserHistory.actions[:silence_user],
          acting_user_id: admin.id,
          target_user_id: user.id,
        ).count

      expect(count).to eq(1)
    end

    it ""skips sending the email for the silence PM via post alert"" do
      NotificationEmailer.enable
      Jobs.run_immediately!
      UserSilencer.silence(user, admin)
      expect(ActionMailer::Base.deliveries.size).to eq(0)
    end

    it ""does not hide posts for tl1"" do
      user.update!(trust_level: 1)

      UserSilencer.silence(user, admin)

      post.reload
      expect(post.topic.visible).to eq(true)
      expect(post.hidden).to eq(false)
    end

    it ""allows us to silence the user for a particular post"" do
      expect(UserSilencer.was_silenced_for?(post)).to eq(false)
      UserSilencer.new(user, Discourse.system_user, post_id: post.id).silence
      expect(user).to be_silenced
      expect(UserSilencer.was_silenced_for?(post)).to eq(true)
    end

    it ""only hides posts from the past 24 hours"" do
      old_post = Fabricate(:post, user: user, created_at: 2.days.ago)

      UserSilencer.new(user, Discourse.system_user, post_id: post.id).silence

      expect(post.reload).to be_hidden
      expect(post.topic.reload).to_not be_visible
      old_post.reload
      expect(old_post).to_not be_hidden
      expect(old_post.topic).to be_visible
    end

    context ""with a plugin hook"" do
      before do
        @override_silence_message = ->(opts) do
          opts[:silence_message_params][:message_title] = ""override title""
          opts[:silence_message_params][:message_raw] = ""override raw""
        end

        DiscourseEvent.on(:user_silenced, &@override_silence_message)
      end

      after { DiscourseEvent.off(:user_silenced, &@override_silence_message) }

      it ""allows the message to be overridden"" do
        UserSilencer.silence(user, admin)
        # force a reload in case instance has no posts
        system_user = User.find(Discourse::SYSTEM_USER_ID)

        post = system_user.posts.order(""posts.id desc"").first

        expect(post.topic.title).to eq(""override title"")
        expect(post.raw).to eq(""override raw"")
      end
    end
  end

  describe ""unsilence"" do
    it ""unsilences the user correctly"" do
      user.update!(silenced_till: 1.year.from_now)

      expect { UserSilencer.unsilence(user, admin) }.to change { user.reload.silenced? }

      # sends a message
      pm = user.topics_allowed.order(""topics.id desc"").first
      title = I18n.t(""system_messages.unsilenced.subject_template"")
      expect(pm.title).to eq(title)

      # logs it
      count =
        UserHistory.where(
          action: UserHistory.actions[:unsilence_user],
          acting_user_id: admin.id,
          target_user_id: user.id,
        ).count

      expect(count).to eq(1)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class TopicBookmarkable < BaseBookmarkable
  include TopicPostBookmarkableHelper

  def self.model
    Topic
  end

  def self.serializer
    UserTopicBookmarkSerializer
  end

  def self.preload_associations
    [:category, :tags, { first_post: :user }]
  end

  def self.perform_custom_preload!(topic_bookmarks, guardian)
    topics = topic_bookmarks.map(&:bookmarkable)
    topic_user_lookup = TopicUser.lookup_for(guardian.user, topics)

    topics.each { |topic| topic.user_data = topic_user_lookup[topic.id] }
  end

  def self.list_query(user, guardian)
    topics = Topic.listable_topics.secured(guardian)
    pms = Topic.private_messages_for_user(user)
    topic_bookmarks =
      user
        .bookmarks_of_type(""Topic"")
        .joins(
          ""INNER JOIN topics ON topics.id = bookmarks.bookmarkable_id AND bookmarks.bookmarkable_type = 'Topic'"",
        )
        .joins(""LEFT JOIN topic_users ON topic_users.topic_id = topics.id"")
        .where(""topic_users.user_id = ?"", user.id)
    guardian.filter_allowed_categories(topic_bookmarks.merge(topics.or(pms)))
  end

  def self.search_query(bookmarks, query, ts_query, &bookmarkable_search)
    bookmarkable_search.call(
      bookmarks.joins(
        ""LEFT JOIN posts ON posts.topic_id = topics.id AND posts.post_number = 1"",
      ).joins(""LEFT JOIN post_search_data ON post_search_data.post_id = posts.id""),
      ""#{ts_query} @@ post_search_data.search_data"",
    )
  end

  def self.reminder_handler(bookmark)
    send_reminder_notification(
      bookmark,
      topic_id: bookmark.bookmarkable_id,
      post_number: 1,
      data: {
        title: bookmark.bookmarkable.title,
        bookmarkable_url: bookmark.bookmarkable.first_post.url,
      },
    )
  end

  def self.reminder_conditions(bookmark)
    bookmark.bookmarkable.present? && self.can_see?(bookmark.user.guardian, bookmark)
  end

  def self.can_see?(guardian, bookmark)
    guardian.can_see_topic?(bookmark.bookmarkable)
  end

  def self.bookmark_metadata(bookmark, user)
    { topic_bookmarked: Bookmark.for_user_in_topic(user.id, bookmark.bookmarkable.id).exists? }
  end

  def self.validate_before_create(guardian, bookmarkable)
    raise Discourse::InvalidAccess if bookmarkable.blank? || !guardian.can_see_topic?(bookmarkable)
  end

  def self.after_create(guardian, bookmark, opts)
    sync_topic_user_bookmarked(guardian.user, bookmark.bookmarkable, opts)
  end

  def self.after_destroy(guardian, bookmark, opts)
    sync_topic_user_bookmarked(guardian.user, bookmark.bookmarkable, opts)
  end

  def self.cleanup_deleted
    related_topics = DB.query(<<~SQL, grace_time: 3.days.ago)
      DELETE FROM bookmarks b
      USING topics t
      WHERE b.bookmarkable_id = t.id AND b.bookmarkable_type = 'Topic'
      AND (t.deleted_at < :grace_time)
      RETURNING t.id AS topic_id
    SQL

    related_topics_ids = related_topics.map(&:topic_id).uniq
    related_topics_ids.each do |topic_id|
      Jobs.enqueue(:sync_topic_user_bookmarked, topic_id: topic_id)
    end
  end
end

```","# frozen_string_literal: true

require ""rails_helper""

RSpec.describe TopicBookmarkable do
  subject(:registered_bookmarkable) { RegisteredBookmarkable.new(TopicBookmarkable) }

  fab!(:user)
  fab!(:private_category) { Fabricate(:private_category, group: Fabricate(:group)) }

  let(:guardian) { Guardian.new(user) }

  let!(:topic1) { Fabricate(:topic) }
  let!(:topic2) { Fabricate(:topic) }
  let!(:post) { Fabricate(:post, topic: topic1) }
  let!(:bookmark1) do
    Fabricate(:bookmark, user: user, bookmarkable: topic1, name: ""something i gotta do"")
  end
  let!(:bookmark2) { Fabricate(:bookmark, user: user, bookmarkable: topic2) }
  let!(:bookmark3) { Fabricate(:bookmark) }
  let!(:topic_user1) { Fabricate(:topic_user, user: user, topic: topic1) }
  let!(:topic_user2) { Fabricate(:topic_user, user: user, topic: topic2) }

  describe ""#perform_list_query"" do
    it ""returns all the user's bookmarks"" do
      expect(registered_bookmarkable.perform_list_query(user, guardian).map(&:id)).to match_array(
        [bookmark1.id, bookmark2.id],
      )
    end

    it ""does not return bookmarks for posts where the user does not have access to the topic category"" do
      bookmark1.bookmarkable.update!(category: private_category)
      expect(registered_bookmarkable.perform_list_query(user, guardian).map(&:id)).to match_array(
        [bookmark2.id],
      )
    end

    it ""does not return bookmarks for posts where the user does not have access to the private message"" do
      bookmark1.update!(bookmarkable: Fabricate(:private_message_topic))
      expect(registered_bookmarkable.perform_list_query(user, guardian).map(&:id)).to match_array(
        [bookmark2.id],
      )
    end
  end

  describe ""#perform_search_query"" do
    before { SearchIndexer.enable }

    it ""returns bookmarks that match by name"" do
      ts_query = Search.ts_query(term: ""gotta"", ts_config: ""simple"")
      expect(
        registered_bookmarkable.perform_search_query(
          registered_bookmarkable.perform_list_query(user, guardian),
          ""%gotta%"",
          ts_query,
        ).map(&:id),
      ).to match_array([bookmark1.id])
    end

    it ""returns bookmarks that match by post search data (topic title or post content)"" do
      post.update(raw: ""some post content"")
      topic1.update(title: ""a great topic title"")

      ts_query = Search.ts_query(term: ""post content"", ts_config: ""simple"")
      expect(
        registered_bookmarkable.perform_search_query(
          registered_bookmarkable.perform_list_query(user, guardian),
          ""%post content%"",
          ts_query,
        ).map(&:id),
      ).to match_array([bookmark1.id])

      ts_query = Search.ts_query(term: ""great topic"", ts_config: ""simple"")
      expect(
        registered_bookmarkable.perform_search_query(
          registered_bookmarkable.perform_list_query(user, guardian),
          ""%great topic%"",
          ts_query,
        ).map(&:id),
      ).to match_array([bookmark1.id])

      ts_query = Search.ts_query(term: ""blah"", ts_config: ""simple"")
      expect(
        registered_bookmarkable.perform_search_query(
          registered_bookmarkable.perform_list_query(user, guardian),
          ""%blah%"",
          ts_query,
        ).map(&:id),
      ).to eq([])
    end
  end

  describe ""#can_send_reminder?"" do
    it ""cannot send reminder if the topic is deleted"" do
      expect(registered_bookmarkable.can_send_reminder?(bookmark1)).to eq(true)
      bookmark1.bookmarkable.trash!
      bookmark1.reload
      expect(registered_bookmarkable.can_send_reminder?(bookmark1)).to eq(false)
    end

    it ""cannot send reminder if the user cannot access the topic"" do
      expect(registered_bookmarkable.can_send_reminder?(bookmark1)).to eq(true)
      bookmark1.bookmarkable.update!(category: private_category)
      bookmark1.reload
      expect(registered_bookmarkable.can_send_reminder?(bookmark1)).to eq(false)
    end
  end

  describe ""#reminder_handler"" do
    it ""creates a notification for the user with the correct details"" do
      expect { registered_bookmarkable.send_reminder_notification(bookmark1) }.to change {
        Notification.count
      }.by(1)
      notif = user.notifications.last
      expect(notif.notification_type).to eq(Notification.types[:bookmark_reminder])
      expect(notif.topic_id).to eq(bookmark1.bookmarkable_id)
      expect(notif.post_number).to eq(1)
      expect(notif.data).to eq(
        {
          title: bookmark1.bookmarkable.title,
          bookmarkable_url: bookmark1.bookmarkable.first_post.url,
          display_username: bookmark1.user.username,
          bookmark_name: bookmark1.name,
          bookmark_id: bookmark1.id,
        }.to_json,
      )
    end
  end

  describe ""#can_see?"" do
    it ""returns false if the post is in a private category or private message the user cannot see"" do
      expect(registered_bookmarkable.can_see?(guardian, bookmark1)).to eq(true)
      bookmark1.bookmarkable.update!(category: private_category)
      expect(registered_bookmarkable.can_see?(guardian, bookmark1)).to eq(false)
      bookmark1.update!(bookmarkable: Fabricate(:private_message_topic))
      expect(registered_bookmarkable.can_see?(guardian, bookmark1)).to eq(false)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class PostBookmarkable < BaseBookmarkable
  include TopicPostBookmarkableHelper

  def self.model
    Post
  end

  def self.serializer
    UserPostBookmarkSerializer
  end

  def self.preload_associations
    [{ topic: %i[tags category] }, :user]
  end

  def self.list_query(user, guardian)
    topics = Topic.listable_topics.secured(guardian)
    pms = Topic.private_messages_for_user(user)
    post_bookmarks =
      user
        .bookmarks_of_type(""Post"")
        .joins(
          ""INNER JOIN posts ON posts.id = bookmarks.bookmarkable_id AND bookmarks.bookmarkable_type = 'Post'"",
        )
        .joins(""LEFT JOIN topics ON topics.id = posts.topic_id"")
        .joins(""LEFT JOIN topic_users ON topic_users.topic_id = topics.id"")
        .where(""topic_users.user_id = ?"", user.id)
    guardian.filter_allowed_categories(
      post_bookmarks.merge(topics.or(pms)).merge(Post.secured(guardian)),
    )
  end

  def self.search_query(bookmarks, query, ts_query, &bookmarkable_search)
    bookmarkable_search.call(
      bookmarks.joins(
        ""LEFT JOIN post_search_data ON post_search_data.post_id = bookmarks.bookmarkable_id AND bookmarks.bookmarkable_type = 'Post'"",
      ),
      ""#{ts_query} @@ post_search_data.search_data"",
    )
  end

  def self.reminder_handler(bookmark)
    send_reminder_notification(
      bookmark,
      topic_id: bookmark.bookmarkable.topic_id,
      post_number: bookmark.bookmarkable.post_number,
      data: {
        title: bookmark.bookmarkable.topic.title,
        bookmarkable_url: bookmark.bookmarkable.url,
      },
    )
  end

  def self.reminder_conditions(bookmark)
    bookmark.bookmarkable.present? && bookmark.bookmarkable.topic.present? &&
      self.can_see?(bookmark.user.guardian, bookmark)
  end

  def self.can_see?(guardian, bookmark)
    guardian.can_see_post?(bookmark.bookmarkable)
  end

  def self.bookmark_metadata(bookmark, user)
    {
      topic_bookmarked: Bookmark.for_user_in_topic(user.id, bookmark.bookmarkable.topic_id).exists?,
    }
  end

  def self.validate_before_create(guardian, bookmarkable)
    if bookmarkable.blank? || bookmarkable.topic.blank? ||
         !guardian.can_see_topic?(bookmarkable.topic) || !guardian.can_see_post?(bookmarkable)
      raise Discourse::InvalidAccess
    end
  end

  def self.after_create(guardian, bookmark, opts)
    sync_topic_user_bookmarked(guardian.user, bookmark.bookmarkable.topic, opts)
  end

  def self.after_destroy(guardian, bookmark, opts)
    sync_topic_user_bookmarked(guardian.user, bookmark.bookmarkable.topic, opts)
  end

  def self.cleanup_deleted
    related_topics = DB.query(<<~SQL, grace_time: 3.days.ago)
      DELETE FROM bookmarks b
      USING topics t, posts p
      WHERE t.id = p.topic_id AND b.bookmarkable_id = p.id AND b.bookmarkable_type = 'Post'
      AND (t.deleted_at < :grace_time OR p.deleted_at < :grace_time)
      RETURNING t.id AS topic_id
    SQL

    related_topics_ids = related_topics.map(&:topic_id).uniq
    related_topics_ids.each do |topic_id|
      Jobs.enqueue(:sync_topic_user_bookmarked, topic_id: topic_id)
    end
  end
end

```","# frozen_string_literal: true

require ""rails_helper""

RSpec.describe PostBookmarkable do
  subject(:registered_bookmarkable) { RegisteredBookmarkable.new(PostBookmarkable) }

  fab!(:user)
  fab!(:private_category) { Fabricate(:private_category, group: Fabricate(:group)) }

  let(:guardian) { Guardian.new(user) }

  let!(:post1) { Fabricate(:post) }
  let!(:post2) { Fabricate(:post) }
  let!(:bookmark1) do
    Fabricate(:bookmark, user: user, bookmarkable: post1, name: ""something i gotta do"")
  end
  let!(:bookmark2) { Fabricate(:bookmark, user: user, bookmarkable: post2) }
  let!(:bookmark3) { Fabricate(:bookmark) }
  let!(:topic_user1) { Fabricate(:topic_user, user: user, topic: post1.topic) }
  let!(:topic_user2) { Fabricate(:topic_user, user: user, topic: post2.topic) }

  describe ""#perform_list_query"" do
    it ""returns all the user's bookmarks"" do
      expect(registered_bookmarkable.perform_list_query(user, guardian).map(&:id)).to match_array(
        [bookmark1.id, bookmark2.id],
      )
    end

    it ""does not return bookmarks for posts where the user does not have access to the topic category"" do
      bookmark1.bookmarkable.topic.update(category: private_category)
      expect(registered_bookmarkable.perform_list_query(user, guardian).map(&:id)).to match_array(
        [bookmark2.id],
      )
    end

    it ""does not return bookmarks for posts where the user does not have access to the private message"" do
      bookmark1.bookmarkable.update(topic: Fabricate(:private_message_topic))
      expect(registered_bookmarkable.perform_list_query(user, guardian).map(&:id)).to match_array(
        [bookmark2.id],
      )
    end
  end

  describe ""#perform_search_query"" do
    before { SearchIndexer.enable }

    it ""returns bookmarks that match by name"" do
      ts_query = Search.ts_query(term: ""gotta"", ts_config: ""simple"")
      expect(
        registered_bookmarkable.perform_search_query(
          registered_bookmarkable.perform_list_query(user, guardian),
          ""%gotta%"",
          ts_query,
        ).map(&:id),
      ).to match_array([bookmark1.id])
    end

    it ""returns bookmarks that match by post search data (topic title or post content)"" do
      post2.update(raw: ""some post content"")
      post2.topic.update(title: ""a great topic title"")

      ts_query = Search.ts_query(term: ""post content"", ts_config: ""simple"")
      expect(
        registered_bookmarkable.perform_search_query(
          registered_bookmarkable.perform_list_query(user, guardian),
          ""%post content%"",
          ts_query,
        ).map(&:id),
      ).to match_array([bookmark2.id])

      ts_query = Search.ts_query(term: ""great topic"", ts_config: ""simple"")
      expect(
        registered_bookmarkable.perform_search_query(
          registered_bookmarkable.perform_list_query(user, guardian),
          ""%great topic%"",
          ts_query,
        ).map(&:id),
      ).to match_array([bookmark2.id])

      ts_query = Search.ts_query(term: ""blah"", ts_config: ""simple"")
      expect(
        registered_bookmarkable.perform_search_query(
          registered_bookmarkable.perform_list_query(user, guardian),
          ""%blah%"",
          ts_query,
        ).map(&:id),
      ).to eq([])
    end
  end

  describe ""#can_send_reminder?"" do
    it ""cannot send reminder if the post or topic is deleted"" do
      expect(registered_bookmarkable.can_send_reminder?(bookmark1)).to eq(true)
      bookmark1.bookmarkable.trash!
      bookmark1.reload
      expect(registered_bookmarkable.can_send_reminder?(bookmark1)).to eq(false)
      Post.with_deleted.find_by(id: bookmark1.bookmarkable_id).recover!
      bookmark1.reload
      bookmark1.bookmarkable.topic.trash!
      bookmark1.reload
      expect(registered_bookmarkable.can_send_reminder?(bookmark1)).to eq(false)
    end

    it ""cannot send reminder if the user cannot access the topic"" do
      expect(registered_bookmarkable.can_send_reminder?(bookmark1)).to eq(true)
      bookmark1.bookmarkable.topic.update!(category: private_category)
      bookmark1.reload
      expect(registered_bookmarkable.can_send_reminder?(bookmark1)).to eq(false)
    end
  end

  describe ""#reminder_handler"" do
    it ""creates a notification for the user with the correct details"" do
      expect { registered_bookmarkable.send_reminder_notification(bookmark1) }.to change {
        Notification.count
      }.by(1)
      notif = user.notifications.last
      expect(notif.notification_type).to eq(Notification.types[:bookmark_reminder])
      expect(notif.topic_id).to eq(bookmark1.bookmarkable.topic_id)
      expect(notif.post_number).to eq(bookmark1.bookmarkable.post_number)
      expect(notif.data).to eq(
        {
          title: bookmark1.bookmarkable.topic.title,
          bookmarkable_url: bookmark1.bookmarkable.url,
          display_username: bookmark1.user.username,
          bookmark_name: bookmark1.name,
          bookmark_id: bookmark1.id,
        }.to_json,
      )
    end
  end

  describe ""#can_see?"" do
    it ""returns false if the post is in a private category or private message the user cannot see"" do
      expect(registered_bookmarkable.can_see?(guardian, bookmark1)).to eq(true)
      bookmark1.bookmarkable.topic.update(category: private_category)
      expect(registered_bookmarkable.can_see?(guardian, bookmark1)).to eq(false)
      bookmark1.bookmarkable.update(topic: Fabricate(:private_message_topic))
      expect(registered_bookmarkable.can_see?(guardian, bookmark1)).to eq(false)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module WildcardUrlChecker
  def self.check_url(url, url_to_check)
    return false if !valid_url?(url_to_check)

    escaped_url = Regexp.escape(url).sub(""\\*"", '\S*')
    url_regex = Regexp.new(""\\A#{escaped_url}\\z"", ""i"")

    url_to_check.match?(url_regex)
  end

  private

  def self.valid_url?(url)
    uri = URI.parse(url)
    uri&.scheme.present? && uri&.host.present?
  rescue URI::InvalidURIError
    false
  end
end

```","# frozen_string_literal: true

RSpec.describe WildcardUrlChecker do
  describe "".check_url"" do
    context ""when url is valid"" do
      it ""returns true"" do
        result1 =
          described_class.check_url(
            ""https://*.discourse.org"",
            ""https://anything.is.possible.discourse.org"",
          )
        expect(result1).to eq(true)

        result2 =
          described_class.check_url(""https://www.discourse.org"", ""https://www.discourse.org"")
        expect(result2).to eq(true)

        result3 = described_class.check_url(""*"", ""https://hello.discourse.org"")
        expect(result3).to eq(true)

        result4 =
          described_class.check_url(""discourse://auth_redirect"", ""discourse://auth_redirect"")
        expect(result4).to eq(true)

        result5 =
          described_class.check_url(
            ""customprotocol://www.discourse.org"",
            ""customprotocol://www.discourse.org"",
          )
        expect(result5).to eq(true)
      end
    end

    context ""when url is invalid"" do
      it ""returns false"" do
        result1 =
          described_class.check_url(
            ""https://*.discourse.org"",
            ""https://bad-domain.discourse.org.evil.com"",
          )
        expect(result1).to eq(false)

        result2 =
          described_class.check_url(
            ""https://www.discourse.org"",
            ""https://www.discourse.org.evil.com"",
          )
        expect(result2).to eq(false)

        result3 =
          described_class.check_url(""https://www.discourse.org"", ""https://www.www.discourse.org"")
        expect(result3).to eq(false)

        result4 =
          described_class.check_url(
            ""https://www.discourse.org"",
            ""https://www.discourse.org\nwww.discourse.org.evil.com"",
          )
        expect(result4).to eq(false)

        result5 = described_class.check_url(""https://"", ""https://"")
        expect(result5).to eq(false)

        result6 =
          described_class.check_url(
            ""invalid$protocol://www.discourse.org"",
            ""invalid$protocol://www.discourse.org"",
          )
        expect(result6).to eq(false)

        result7 = described_class.check_url(""noscheme"", ""noscheme"")
        expect(result7).to eq(false)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class EmailStyleUpdater
  attr_reader :errors

  def initialize(user)
    @user = user
    @errors = []
  end

  def update(attrs)
    if attrs.has_key?(:html) && !attrs[:html].include?(""%{email_content}"")
      @errors << I18n.t(""email_style.html_missing_placeholder"", placeholder: ""%{email_content}"")
    end

    if attrs.has_key?(:css)
      begin
        compiled_css = SassC::Engine.new(attrs[:css], style: :compressed).render
      rescue SassC::SyntaxError => e
        # @errors << I18n.t('email_style.css_syntax_error')
        @errors << e.message[0...(e.message.index(""\n""))]
      end
    end

    return false unless @errors.empty?

    if attrs.has_key?(:html)
      if attrs[:html] == EmailStyle.default_template
        SiteSetting.remove_override!(:email_custom_template)
      else
        SiteSetting.email_custom_template = attrs[:html]
      end
    end

    if attrs.has_key?(:css)
      if attrs[:css] == EmailStyle.default_css
        SiteSetting.remove_override!(:email_custom_css)
        SiteSetting.remove_override!(:email_custom_css_compiled)
      else
        SiteSetting.email_custom_css = attrs[:css]
        SiteSetting.email_custom_css_compiled = compiled_css
      end
    end

    @errors.empty?
  end
end

```","# frozen_string_literal: true

RSpec.describe EmailStyleUpdater do
  fab!(:admin)
  let(:default_html) { File.read(""#{Rails.root}/app/views/email/default_template.html"") }
  let(:updater) { EmailStyleUpdater.new(admin) }

  def expect_settings_to_be_unset
    expect(SiteSetting.email_custom_template).to_not be_present
    expect(SiteSetting.email_custom_css).to_not be_present
    expect(SiteSetting.email_custom_css_compiled).to_not be_present
  end

  describe ""update"" do
    it ""can change the settings"" do
      expect(updater.update(html: ""For you: %{email_content}"", css: ""h1 { color: blue; }"")).to eq(
        true,
      )
      expect(SiteSetting.email_custom_template).to eq(""For you: %{email_content}"")
      expect(SiteSetting.email_custom_css).to eq(""h1 { color: blue; }"")
      expect(SiteSetting.email_custom_css_compiled.strip).to eq(""h1{color:blue}"")
    end

    it ""will not store defaults"" do
      updater.update(html: default_html, css: """")
      expect_settings_to_be_unset
    end

    it ""can clear settings if defaults given"" do
      SiteSetting.email_custom_template = ""For you: %{email_content}""
      SiteSetting.email_custom_css = ""h1 { color: blue; }""
      SiteSetting.email_custom_css_compiled = ""h1{color:blue}""
      updater.update(html: default_html, css: """")
      expect_settings_to_be_unset
    end

    it ""fails if html is missing email_content"" do
      expect(updater.update(html: ""No email content"", css: """")).to eq(false)
      expect(updater.errors).to include(
        I18n.t(""email_style.html_missing_placeholder"", placeholder: ""%{email_content}""),
      )
      expect_settings_to_be_unset
    end

    it ""fails if css is not valid scss"" do
      expect(updater.update(html: ""For you: %{email_content}"", css: ""h1 { color: blue;"")).to eq(
        false,
      )
      expect(updater.errors).to_not be_empty
      expect(updater.errors.first).to include('Error: expected ""}"".')
      expect_settings_to_be_unset
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class SearchIndexer
  MIN_POST_BLURB_INDEX_VERSION = 4

  POST_INDEX_VERSION = 5
  TOPIC_INDEX_VERSION = 4
  CATEGORY_INDEX_VERSION = 3
  USER_INDEX_VERSION = 3
  TAG_INDEX_VERSION = 3

  # version to apply when issuing a background reindex
  REINDEX_VERSION = 0
  TS_VECTOR_PARSE_REGEX = /('([^']*|'')*'\:)(([0-9]+[A-D]?,?)+)/

  def self.disable
    @disabled = true
  end

  def self.enable
    @disabled = false
  end

  def self.update_index(table:, id:, a_weight: nil, b_weight: nil, c_weight: nil, d_weight: nil)
    raw_data = { a: a_weight, b: b_weight, c: c_weight, d: d_weight }

    # The version used in excerpts
    search_data = raw_data.transform_values { |data| Search.prepare_data(data || """", :index) }

    # The version used to build the index
    indexed_data =
      search_data.transform_values do |data|
        data.gsub(/\S+/) { |word| word[0...SiteSetting.search_max_indexed_word_length] }
      end

    table_name = ""#{table}_search_data""
    foreign_key = ""#{table}_id""

    # for user login and name use ""simple"" lowercase stemmer
    stemmer = table == ""user"" ? ""simple"" : Search.ts_config

    ranked_index = <<~SQL
      setweight(to_tsvector('#{stemmer}', #{Search.wrap_unaccent(""coalesce(:a,''))"")}, 'A') ||
      setweight(to_tsvector('#{stemmer}', #{Search.wrap_unaccent(""coalesce(:b,''))"")}, 'B') ||
      setweight(to_tsvector('#{stemmer}', #{Search.wrap_unaccent(""coalesce(:c,''))"")}, 'C') ||
      setweight(to_tsvector('#{stemmer}', #{Search.wrap_unaccent(""coalesce(:d,''))"")}, 'D')
    SQL

    tsvector = DB.query_single(""SELECT #{ranked_index}"", indexed_data)[0]
    additional_lexemes = []

    # we also want to index parts of a domain name
    # that way stemmed single word searches will match
    additional_words = []

    tsvector
      .scan(/'(([a-zA-Z0-9]+\.)+[a-zA-Z0-9]+)'\:([\w+,]+)/)
      .reduce(additional_lexemes) do |array, (lexeme, _, positions)|
        count = 0

        if lexeme !~ /\A(\d+\.)?(\d+\.)*(\*|\d+)\z/
          loop do
            count += 1
            break if count >= 10 # Safeguard here to prevent infinite loop when a term has many dots
            term, _, remaining = lexeme.partition(""."")
            break if remaining.blank?

            additional_words << [term, positions]

            array << ""'#{remaining}':#{positions}""
            lexeme = remaining
          end
        end

        array
      end

    extra_domain_word_terms =
      if additional_words.length > 0
        DB
          .query_single(
            ""SELECT to_tsvector(?, ?)"",
            stemmer,
            additional_words.map { |term, _| term }.join("" ""),
          )
          .first
          .scan(TS_VECTOR_PARSE_REGEX)
          .map do |term, _, indexes|
            new_indexes =
              indexes
                .split("","")
                .map do |index|
                  existing_positions = additional_words[index.to_i - 1]
                  if existing_positions
                    existing_positions[1]
                  else
                    index
                  end
                end
                .join("","")
            ""#{term}#{new_indexes}""
          end
          .join("" "")
      end

    tsvector = ""#{tsvector} #{additional_lexemes.join("" "")} #{extra_domain_word_terms}""

    if (max_dupes = SiteSetting.max_duplicate_search_index_terms) > 0
      reduced = []
      tsvector
        .scan(TS_VECTOR_PARSE_REGEX)
        .each do |term, _, indexes|
          family_counts = Hash.new(0)
          new_index_array = []

          indexes
            .split("","")
            .each do |index|
              family = nil
              family = index[-1] if index[-1].match?(/[A-D]/)
              # title dupes can completely dominate the index
              # so we limit them to 1
              if (family_counts[family] += 1) <= (family == ""A"" ? 1 : max_dupes)
                new_index_array << index
              end
            end
          reduced << ""#{term.strip}#{new_index_array.join("","")}""
        end
      tsvector = reduced.join("" "")
    end

    indexed_data =
      if table.to_s == ""post""
        clean_post_raw_data!(search_data[:d])
      else
        search_data.values.select { |d| d.length > 0 }.join("" "")
      end

    params = {
      ""raw_data"" => indexed_data,
      ""#{foreign_key}"" => id,
      ""locale"" => SiteSetting.default_locale,
      ""version"" => const_get(""#{table.upcase}_INDEX_VERSION""),
      ""search_data"" => tsvector,
    }

    yield params if block_given?
    table_name.camelize.constantize.upsert(params)
  rescue => e
    if Rails.env.test?
      raise
    else
      # TODO is there any way we can safely avoid this?
      # best way is probably pushing search indexer into a dedicated process so it no longer happens on save
      # instead in the post processor
      Discourse.warn_exception(
        e,
        message: ""Unexpected error while indexing #{table} for search"",
        env: {
          id: id,
        },
      )
    end
  end

  def self.update_topics_index(topic_id, title, cooked)
    # a bit inconsistent that we use title as A and body as B when in
    # the post index body is D
    update_index(
      table: ""topic"",
      id: topic_id,
      a_weight: title,
      b_weight: HtmlScrubber.scrub(cooked)[0...Topic::MAX_SIMILAR_BODY_LENGTH],
    )
  end

  def self.update_posts_index(
    post_id:,
    topic_title:,
    category_name:,
    topic_tags:,
    cooked:,
    private_message:
  )
    update_index(
      table: ""post"",
      id: post_id,
      a_weight: topic_title,
      b_weight: category_name,
      c_weight: topic_tags,
      # The tsvector resulted from parsing a string can be double the size of
      # the original string. Since there is no way to estimate the length of
      # the expected tsvector, we limit the input to ~50% of the maximum
      # length of a tsvector (1_048_576 bytes).
      d_weight: HtmlScrubber.scrub(cooked)[0..600_000],
    ) { |params| params[""private_message""] = private_message }
  end

  def self.update_users_index(user_id, username, name, custom_fields)
    update_index(
      table: ""user"",
      id: user_id,
      a_weight: username,
      b_weight: name,
      c_weight: custom_fields,
    )
  end

  def self.update_categories_index(category_id, name)
    update_index(table: ""category"", id: category_id, a_weight: name)
  end

  def self.update_tags_index(tag_id, name)
    update_index(table: ""tag"", id: tag_id, a_weight: name.downcase)
  end

  def self.queue_category_posts_reindex(category_id)
    return if @disabled

    DB.exec(<<~SQL, category_id: category_id, version: REINDEX_VERSION)
      UPDATE post_search_data
      SET version = :version
      FROM posts
      INNER JOIN topics ON posts.topic_id = topics.id
      INNER JOIN categories ON topics.category_id = categories.id
      WHERE post_search_data.post_id = posts.id
      AND categories.id = :category_id
    SQL
  end

  def self.queue_users_reindex(user_ids)
    return if @disabled

    DB.exec(<<~SQL, user_ids: user_ids, version: REINDEX_VERSION)
      UPDATE user_search_data
      SET version = :version
      WHERE user_search_data.user_id IN (:user_ids)
    SQL
  end

  def self.queue_post_reindex(topic_id)
    return if @disabled

    DB.exec(<<~SQL, topic_id: topic_id, version: REINDEX_VERSION)
      UPDATE post_search_data
      SET version = :version
      FROM posts
      WHERE post_search_data.post_id = posts.id
      AND posts.topic_id = :topic_id
    SQL
  end

  def self.index(obj, force: false)
    return if @disabled

    category_name = nil
    tag_names = nil
    topic = nil

    if Topic === obj
      topic = obj
    elsif Post === obj
      topic = obj.topic
    end

    category_name = topic.category&.name if topic

    if topic
      tags = topic.tags.select(:id, :name).to_a

      if tags.present?
        tag_names =
          (tags.map(&:name) + Tag.where(target_tag_id: tags.map(&:id)).pluck(:name)).join("" "")
      end
    end

    if Post === obj && obj.raw.present? &&
         (force || obj.saved_change_to_cooked? || obj.saved_change_to_topic_id?)
      if topic
        SearchIndexer.update_posts_index(
          post_id: obj.id,
          topic_title: topic.title,
          category_name: category_name,
          topic_tags: tag_names,
          cooked: obj.cooked,
          private_message: topic.private_message?,
        )

        SearchIndexer.update_topics_index(topic.id, topic.title, obj.cooked) if obj.is_first_post?
      end
    end

    if User === obj && (obj.saved_change_to_username? || obj.saved_change_to_name? || force)
      SearchIndexer.update_users_index(
        obj.id,
        obj.username_lower || """",
        obj.name ? obj.name.downcase : """",
        obj.user_custom_fields.searchable.map(&:value).join("" ""),
      )
    end

    if Topic === obj && (obj.saved_change_to_title? || force)
      if obj.posts
        if post = obj.posts.find_by(post_number: 1)
          SearchIndexer.update_posts_index(
            post_id: post.id,
            topic_title: obj.title,
            category_name: category_name,
            topic_tags: tag_names,
            cooked: post.cooked,
            private_message: obj.private_message?,
          )

          SearchIndexer.update_topics_index(obj.id, obj.title, post.cooked)
        end
      end
    end

    if Category === obj && (obj.saved_change_to_name? || force)
      SearchIndexer.queue_category_posts_reindex(obj.id)
      SearchIndexer.update_categories_index(obj.id, obj.name)
    end

    if Tag === obj && (obj.saved_change_to_name? || force)
      SearchIndexer.update_tags_index(obj.id, obj.name)
    end
  end

  def self.clean_post_raw_data!(raw_data)
    urls = Set.new
    raw_data.scan(Discourse::Utils::URI_REGEXP) { urls << $& }

    urls.each do |url|
      begin
        case File.extname(URI(url).path || """")
        when Oneboxer::VIDEO_REGEX
          raw_data.gsub!(url, I18n.t(""search.video""))
        when Oneboxer::AUDIO_REGEX
          raw_data.gsub!(url, I18n.t(""search.audio""))
        end
      rescue URI::InvalidURIError
      end
    end

    raw_data
  end
  private_class_method :clean_post_raw_data!

  class HtmlScrubber < Nokogiri::XML::SAX::Document
    attr_reader :scrubbed

    def initialize
      @scrubbed = +""""
    end

    def self.scrub(html)
      return +"""" if html.blank?

      begin
        document = Nokogiri.HTML5(""<div>#{html}</div>"", nil, Encoding::UTF_8.to_s)
      rescue ArgumentError
        return +""""
      end

      nodes = document.css(""div.#{CookedPostProcessor::LIGHTBOX_WRAPPER_CSS_CLASS}"")

      if nodes.present?
        nodes.each do |node|
          node.traverse do |child_node|
            next if child_node == node

            if %w[a img].exclude?(child_node.name)
              child_node.remove
            elsif child_node.name == ""a""
              ATTRIBUTES.each { |attribute| child_node.remove_attribute(attribute) }
            end
          end
        end
      end

      document.css(""img.emoji"").each { |node| node.remove_attribute(""alt"") }

      document
        .css(""a[href]"")
        .each do |node|
          if node[""href""] == node.text || MENTION_CLASSES.include?(node[""class""])
            node.remove_attribute(""href"")
          end

          if node[""class""] == ""anchor"" && node[""href""].starts_with?(""#"")
            node.remove_attribute(""href"")
          end
        end

      html_scrubber = new
      Nokogiri::HTML::SAX::Parser.new(html_scrubber).parse(document.to_html)
      html_scrubber.scrubbed.squish
    end

    MENTION_CLASSES ||= %w[mention mention-group]
    ATTRIBUTES ||= %w[alt title href data-video-title]

    def start_element(_name, attributes = [])
      attributes = Hash[*attributes.flatten]

      ATTRIBUTES.each do |attribute_name|
        if attributes[attribute_name].present? &&
             !(attribute_name == ""href"" && UrlHelper.is_local(attributes[attribute_name]))
          characters(attributes[attribute_name])
        end
      end
    end

    def characters(str)
      scrubbed << "" #{str} ""
    end
  end
end

```","# frozen_string_literal: true

RSpec.describe SearchIndexer do
  let(:post_id) { 99 }

  before { SearchIndexer.enable }

  after { SearchIndexer.disable }

  it ""correctly indexes chinese"" do
    SiteSetting.default_locale = ""zh_CN""
    data = ""你好世界""

    SearchIndexer.update_posts_index(
      post_id: post_id,
      topic_title: """",
      category_name: """",
      topic_tags: """",
      cooked: data,
      private_message: false,
    )

    post_search_data = PostSearchData.find_by(post_id: post_id)

    expect(post_search_data.raw_data).to eq(""你好 世界"")
    expect(post_search_data.search_data).to eq(""'世界':2 '你好':1"")
  end

  it ""extract youtube title"" do
    html =
      ""<div class=\""lazy-video-container\"" data-video-id=\""lmFgeFh2nlw\"" data-video-title=\""Metallica Mixer Explains Missing Bass on 'And Justice for All' [Exclusive]\"" data-provider-name=\""youtube\""></div>""
    scrubbed = SearchIndexer::HtmlScrubber.scrub(html)
    expect(scrubbed).to eq(
      ""Metallica Mixer Explains Missing Bass on 'And Justice for All' [Exclusive]"",
    )
  end

  it ""extract a link"" do
    html = ""<a href='http://meta.discourse.org/'>link</a>""
    scrubbed = SearchIndexer::HtmlScrubber.scrub(html)
    expect(scrubbed).to eq(""http://meta.discourse.org/ link"")
  end

  it ""ignores autogenerated link anchors"" do
    html = ""<a class='anchor' href='#something-special'>something special</a>""
    scrubbed = SearchIndexer::HtmlScrubber.scrub(html)
    expect(scrubbed).to eq(""something special"")
  end

  it ""extracts @username from mentions"" do
    html =
      '<p><a class=""mention"" href=""/u/%E7%8B%AE%E5%AD%90"">@狮子</a> <a class=""mention"" href=""/u/foo"">@foo</a></p>'
    scrubbed = SearchIndexer::HtmlScrubber.scrub(html)
    expect(scrubbed).to eq(""@狮子 @foo"")
  end

  it ""extracts @groupname from group mentions"" do
    html =
      '<p><a class=""mention-group"" href=""/groups/%D0%B0%D0%B2%D1%82%D0%BE%D0%BC%D0%BE%D0%B1%D0%B8%D0%BB%D0%B8%D1%81%D1%82"">@автомобилист</a></p>'
    scrubbed = SearchIndexer::HtmlScrubber.scrub(html)
    expect(scrubbed).to eq(""@автомобилист"")
  end

  it ""extracts emoji name from emoji image"" do
    emoji = Emoji[""wink""]
    html =
      %Q|<img src=\""#{URI.join(Discourse.base_url_no_prefix, emoji.url)}\"" title=\"":wink:\"" class=\""emoji only-emoji\"" alt=\"":wink:\"" loading=\""lazy\"" width=\""20\"" height=\""20\"">|
    scrubbed = SearchIndexer::HtmlScrubber.scrub(html)

    expect(scrubbed).to eq("":wink:"")
  end

  it ""doesn't index local files"" do
    html = <<~HTML
      <p><img src=""https://www.discourse.org/logo.png"" alt=""Discourse""></p>
      <p><img src=""#{Discourse.base_url_no_prefix}/uploads/episodeinteractive/original/3X/0/f/0f40b818356bdc1d80acfa905034e95cfd112a3a.png"" alt=""51%20PM"" width=""289"" height=""398""></p>
      <div class=""lightbox-wrapper"">
        <a class=""lightbox"" href=""#{Discourse.base_url_no_prefix}/uploads/episodeinteractive/original/3X/1/6/16790095df3baf318fb2eb1d7e5d7860dc45d48b.jpg"" data-download-href=""#{Discourse.base_url_no_prefix}/uploads/episodeinteractive/16790095df3baf318fb2eb1d7e5d7860dc45d48b"" title=""Untitled design (21).jpg"" rel=""nofollow noopener"">
          <img src=""#{Discourse.base_url_no_prefix}/uploads/episodeinteractive/optimized/3X/1/6/16790095df3baf318fb2eb1d7e5d7860dc45d48b_1_563x500.jpg"" alt=""Untitled%20design%20(21)"" width=""563"" height=""500"">
          <div class=""meta"">
            <svg class=""fa d-icon d-icon-far-image svg-icon"" aria-hidden=""true""><use href=""#far-image""></use></svg>
            <span class=""filename"">Untitled design (21).jpg</span>
            <span class=""informations"">1280x1136 472 KB</span>
            <svg class=""fa d-icon d-icon-discourse-expand svg-icon"" aria-hidden=""true""><use href=""#discourse-expand""></use></svg>
          </div>
        </a>
      </div>
    HTML

    scrubbed = SearchIndexer::HtmlScrubber.scrub(html)

    expect(scrubbed).to eq(""Discourse 51%20PM Untitled%20design%20(21)"")
  end

  it ""correctly indexes a post according to version"" do
    # Preparing so that they can be indexed to right version
    SearchIndexer.update_posts_index(
      post_id: post_id,
      topic_title: ""dummy"",
      category_name: """",
      topic_tags: nil,
      cooked: nil,
      private_message: false,
    )

    PostSearchData.find_by(post_id: post_id).update!(version: -1)

    data = ""<a>This</a> is a test""

    SearchIndexer.update_posts_index(
      post_id: post_id,
      topic_title: """",
      category_name: """",
      topic_tags: nil,
      cooked: data,
      private_message: false,
    )

    raw_data, locale, version =
      PostSearchData.where(post_id: post_id).pluck(:raw_data, :locale, :version)[0]
    expect(raw_data).to eq(""This is a test"")
    expect(locale).to eq(SiteSetting.default_locale)
    expect(version).to eq(SearchIndexer::POST_INDEX_VERSION)
  end

  describe "".index"" do
    let(:topic) { Fabricate(:topic, title: ""this is a title that I am testing"") }
    let(:post) { Fabricate(:post, topic: topic) }

    it ""should index posts correctly"" do
      expect { post }.to change { PostSearchData.count }.by(1)

      expect { post.update!(raw: ""this is new content"") }.to change {
        post.reload.post_search_data.search_data
      }

      expect { post.update!(topic_id: Fabricate(:topic).id) }.to change {
        post.reload.post_search_data.search_data
      }
    end

    it ""should work with edge case domain names"" do
      # 00E5A4 stems to 00e5 and a4, which is odd, but by-design
      # this may cause internal indexing to fail due to indexes not aligning
      # when stuffing terms for domains
      post.update!(cooked: <<~HTML)
        Test.00E5A4.1
      HTML

      SearchIndexer.update_posts_index(
        post_id: post.id,
        topic_title: post.topic.title,
        category_name: post.topic.category&.name,
        topic_tags: post.topic.tags.map(&:name).join("" ""),
        cooked: post.cooked,
        private_message: post.topic.private_message?,
      )
    end

    it ""should work with invalid HTML"" do
      post.update!(cooked: ""<FD>"" * Nokogiri::Gumbo::DEFAULT_MAX_TREE_DEPTH)

      SearchIndexer.update_posts_index(
        post_id: post.id,
        topic_title: post.topic.title,
        category_name: post.topic.category&.name,
        topic_tags: post.topic.tags.map(&:name).join("" ""),
        cooked: post.cooked,
        private_message: post.topic.private_message?,
      )
    end

    it ""should not index posts with empty raw"" do
      expect do
        post = Fabricate.build(:post, raw: """", post_type: Post.types[:small_action])
        post.save!(validate: false)
      end.to_not change { PostSearchData.count }
    end

    it ""should not tokenize urls and duplicate title and href in <a>"" do
      post.update!(raw: <<~RAW)
      https://meta.discourse.org/some.png
      RAW

      post.rebake!
      post.reload

      expect(post.post_search_data.raw_data).to eq(""https://meta.discourse.org/some.png"")

      expect(post.post_search_data.search_data).to eq_ts_vector(
        ""'/some.png':12 'discourse.org':11 'meta.discourse.org':11 'meta.discourse.org/some.png':10 'org':11 'test':8A 'titl':4A 'uncategor':9B 'meta':11 'discours':11"",
      )
    end

    it ""should not tokenize versions"" do
      post.update!(raw: ""123.223"")

      expect(post.post_search_data.search_data).to eq(
        ""'123.223':10 'test':8A 'titl':4A 'uncategor':9B"",
      )

      post.update!(raw: ""15.2.231.423"")
      post.reload

      expect(post.post_search_data.search_data).to eq(
        ""'15.2.231.423':10 'test':8A 'titl':4A 'uncategor':9B"",
      )
    end

    it ""should tokenize host of a URL and removes query string"" do
      category = Fabricate(:category, name: ""awesome category"")
      topic = Fabricate(:topic, category: category, title: ""this is a test topic"")

      post = Fabricate(:post, topic: topic, raw: <<~RAW)
      a https://car.com?bob=1, http://efg.com.au?bill=1 b hij.net/xyz=1
      www.klm.net/?IGNORE=1 <a href=""http://abc.de.nop.co.uk?IGNORE=1&ignore2=2"">test</a> https://cars.com
      RAW

      post.rebake!
      post.reload
      topic = post.topic

      # Note, a random non URL string should be tokenized properly,
      # hence www.klm.net?IGNORE=1 it was inserted in autolinking.
      # We could consider amending the auto linker to add
      # more context to say ""hey, this part of <a href>...</a> was a guess by autolinker.
      # A blanket treating of non-urls without this logic is risky.
      expect(post.post_search_data.raw_data).to eq(
        ""a https://car.com , http://efg.com.au b http://hij.net/xyz=1 hij.net/xyz=1 http://www.klm.net/ www.klm.net/?IGNORE=1 http://abc.de.nop.co.uk test https://cars.com"",
      )

      expect(post.post_search_data.search_data).to eq_ts_vector(
        ""'/?ignore=1':21 '/xyz=1':14,17 'car.com':9 'cars.com':24 'abc.de.nop.co.uk':22 'au':10 'awesom':6B 'b':11 'categori':7B 'co.uk':22 'com':9,10,24 'com.au':10 'de.nop.co.uk':22 'efg.com.au':10 'hij.net':13,16 'hij.net/xyz=1':12,15 'klm.net':18,20 'net':13,16,18,20 'nop.co.uk':22 'test':4A,23 'topic':5A 'uk':22 'www.klm.net':18,20 'www.klm.net/?ignore=1':19 'car':9,24 'co':22 'de':22 'efg':10 'hij':13,16 'klm':18,20 'nop':22 'www':18,20 'abc':22"",
      )
    end

    it ""should not include lightbox in search"" do
      Jobs.run_immediately!
      SiteSetting.max_image_width = 1

      stub_request(:get, ""https://1.2.3.4/some.png"").to_return(
        status: 200,
        body: file_from_fixtures(""logo.png"").read,
      )

      src = ""https://meta.discourse.org/some.png""

      post = Fabricate(:post, raw: <<~RAW)
      Let me see how I can fix this image
      <img src=""#{src}"" title=""GOT"" alt=""white walkers"" width=""2"" height=""2"">
      RAW

      post.rebake!
      post.reload

      expect(post.cooked).not_to include(CookedPostProcessor::LIGHTBOX_WRAPPER_CSS_CLASS)

      expect(post.post_search_data.raw_data).to eq(
        ""Let me see how I can fix this image white walkers GOT"",
      )
    end

    it ""should strips audio and videos URLs from raw data"" do
      SiteSetting.authorized_extensions = ""mp4""
      Fabricate(:video_upload)

      post.update!(raw: <<~RAW)
      link to an external page: https://google.com/?u=bar

      link to an audio file: https://somesite.com/audio.m4a

      link to a video file: https://somesite.com/content/somethingelse.MOV

      link to an invalid URL: http:error]
      RAW

      expect(post.post_search_data.raw_data).to eq(
        ""link to an external page: https://google.com/ link to an audio file: #{I18n.t(""search.audio"")} link to a video file: #{I18n.t(""search.video"")} link to an invalid URL: http:error]"",
      )

      expect(post.post_search_data.search_data).to eq_ts_vector(
        ""'/audio.m4a':23 '/content/somethingelse.mov':31 'audio':19 'com':15,22,30 'error':38 'extern':13 'file':20,28 'google.com':15 'http':37 'invalid':35 'link':10,16,24,32 'page':14 'somesite.com':22,30 'somesite.com/audio.m4a':21 'somesite.com/content/somethingelse.mov':29 'test':8A 'titl':4A 'uncategor':9B 'url':36 'video':27 'googl':15 'somesit':22,30"",
      )
    end

    it ""should unaccent indexed content"" do
      SiteSetting.search_ignore_accents = true
      post.update!(raw: ""Cette oeuvre d'art n'est pas une œuvre"")
      post.post_search_data.reload
      expect(post.post_search_data.search_data).not_to include(""œuvr"")
      expect(post.post_search_data.search_data).to include(""oeuvr"")

      SiteSetting.search_ignore_accents = false
      SearchIndexer.index(post, force: true)
      post.post_search_data.reload
      expect(post.post_search_data.search_data).to include(""œuvr"")
      expect(post.post_search_data.search_data).to include(""oeuvr"")
    end

    it ""truncates long words in the index"" do
      SiteSetting.search_max_indexed_word_length = 4
      title = ""A title that is long enough""
      contents = ""I am the best beige object http://example.com/long/url""

      topic.update!(title: title)
      post.update!(raw: contents)
      post_search_data = post.post_search_data
      post_search_data.reload

      expect(post_search_data.raw_data).to eq(contents)

      words = post_search_data.search_data.scan(/'([^']*)'/).map { |match| match[0] }
      expect(words).to contain_exactly(
        ""best"",
        ""beig"",
        ""obj"",
        ""http"",
        ""titl"",
        ""long"",
        ""enou"",
        ""unca"",
      )
    end

    it ""limits number of repeated terms when max_duplicate_search_index_terms site setting has been configured"" do
      SiteSetting.max_duplicate_search_index_terms = 5

      contents = <<~TEXT
        #{""sam "" * 10}
        <a href=""https://something.com/path:path'path?term='hello'"">url</a>
        <a href=""https://somethings.com/path:path'path?term='hello'"">url</a>
      TEXT

      post.update!(raw: contents)

      post_search_data = post.post_search_data
      post_search_data.reload

      terms =
        ""'/path:path''path':22,26 'com':21,25 'sam':10,11,12,13,14 'something.com':21 'something.com/path:path''path':20 'test':8A 'titl':4A 'uncategor':9B 'url':23,27 'someth':21,25 'somethings.com':25 'somethings.com/path:path''path':24""

      expect(post_search_data.search_data).to eq_ts_vector(terms)
    end
  end

  describe "".queue_post_reindex"" do
    let(:post) { Fabricate(:post) }
    let(:topic) { post.topic }

    it ""should reset the version of search data for all posts in the topic"" do
      post2 = Fabricate(:post)

      SearchIndexer.queue_post_reindex(topic.id)

      expect(post.reload.post_search_data.version).to eq(SearchIndexer::REINDEX_VERSION)

      expect(post2.reload.post_search_data.version).to eq(SearchIndexer::POST_INDEX_VERSION)
    end
  end

  describe "".queue_users_reindex"" do
    let!(:user) { Fabricate(:user) }
    let!(:user2) { Fabricate(:user) }

    it ""should reset the version of search data for all users"" do
      SearchIndexer.index(user, force: true)
      SearchIndexer.index(user2, force: true)
      SearchIndexer.queue_users_reindex([user.id])

      expect(user.reload.user_search_data.version).to eq(SearchIndexer::REINDEX_VERSION)

      expect(user2.reload.user_search_data.version).to eq(SearchIndexer::USER_INDEX_VERSION)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

class UserNotificationScheduleProcessor
  attr_accessor :schedule, :user, :timezone_name

  def initialize(schedule)
    @schedule = schedule
    @user = schedule.user
    @timezone_name = user.user_option.timezone
  end

  def create_do_not_disturb_timings
    local_time = Time.now.in_time_zone(timezone_name)

    create_timings_for(local_time, days: 2)
  end

  def self.create_do_not_disturb_timings_for(schedule)
    processor = UserNotificationScheduleProcessor.new(schedule)
    processor.create_do_not_disturb_timings
  end

  private

  def create_timings_for(local_time, days: 0, previous_timing: nil)
    weekday = transform_wday(local_time.wday)
    start_minute = schedule[""day_#{weekday}_start_time""]
    end_minute = schedule[""day_#{weekday}_end_time""]

    previous_timing = find_previous_timing(local_time) if previous_timing.nil? && start_minute != 0

    if start_minute > 0
      previous_timing.ends_at = utc_time_at_minute(local_time, start_minute - 1)
      if previous_timing.id
        previous_timing.save
      else
        user.do_not_disturb_timings.find_or_create_by(previous_timing.attributes.except(""id""))
      end

      next_timing =
        user.do_not_disturb_timings.new(
          starts_at: utc_time_at_minute(local_time, end_minute),
          scheduled: true,
        )
      save_timing_and_continue(local_time, next_timing, days)
    else
      save_timing_and_continue(local_time, previous_timing, days)
    end
  end

  private

  def find_previous_timing(local_time)
    # Try and find a previously scheduled dnd timing that we can extend if the
    # ends_at is at the previous midnight. fallback to a new timing if not.
    previous =
      user.do_not_disturb_timings.find_by(
        ends_at: (local_time - 1.day).end_of_day.utc,
        scheduled: true,
      )
    previous ||
      user.do_not_disturb_timings.new(starts_at: local_time.beginning_of_day.utc, scheduled: true)
  end

  def save_timing_and_continue(local_time, timing, days)
    if days == 0
      if timing
        timing.ends_at = local_time.end_of_day.utc
        user.do_not_disturb_timings.find_or_create_by(timing.attributes.except(""id""))
      end
      user.publish_do_not_disturb(ends_at: user.do_not_disturb_until)
    else
      create_timings_for(local_time + 1.day, days: days - 1, previous_timing: timing)
    end
  end

  def utc_time_at_minute(base_time, total_minutes)
    hour = total_minutes / 60
    minute = total_minutes % 60
    Time.new(
      base_time.year,
      base_time.month,
      base_time.day,
      hour,
      minute,
      0,
      base_time.formatted_offset,
    ).utc
  end

  def transform_wday(wday)
    wday == 0 ? 6 : wday - 1
  end
end

```","# frozen_string_literal: true

RSpec.describe UserNotificationScheduleProcessor do
  include ActiveSupport::Testing::TimeHelpers

  fab!(:user)
  let(:standard_schedule) do
    schedule =
      UserNotificationSchedule.create({ user: user }.merge(UserNotificationSchedule::DEFAULT))
    schedule.enabled = true
    schedule.save
    schedule
  end

  describe ""#create_do_not_disturb_timings"" do
    [
      { timezone: ""UTC"", offset: ""+00:00"" },
      { timezone: ""America/Chicago"", offset: ""-06:00"" },
      { timezone: ""Australia/Sydney"", offset: ""+11:00"" },
    ].each do |timezone_info|
      it ""creates dnd timings correctly for each timezone"" do
        user.user_option.update(timezone: timezone_info[:timezone])

        travel_to Time.new(2020, 1, 4, 12, 0, 0, ""+00:00"") do
          UserNotificationScheduleProcessor.create_do_not_disturb_timings_for(standard_schedule)

          # The default schedule is 8am - 5pm.
          # Expect DND timings to fill gaps before/after those times for 3 days.
          dnd_timings = user.do_not_disturb_timings
          offset = timezone_info[:offset]
          expect(dnd_timings[0].starts_at).to eq_time(Time.new(2020, 1, 4, 0, 0, 0, offset))
          expect(dnd_timings[0].ends_at).to eq_time(Time.new(2020, 1, 4, 7, 59, 0, offset))

          expect(dnd_timings[1].starts_at).to eq_time(Time.new(2020, 1, 4, 17, 0, 0, offset))
          expect(dnd_timings[1].ends_at).to eq_time(Time.new(2020, 1, 5, 7, 59, 0, offset))

          expect(dnd_timings[2].starts_at).to eq_time(Time.new(2020, 1, 5, 17, 0, 0, offset))
          expect(dnd_timings[2].ends_at).to eq_time(Time.new(2020, 1, 6, 7, 59, 0, offset))

          expect(dnd_timings[3].starts_at).to eq_time(Time.new(2020, 1, 6, 17, 0, 0, offset))
          expect(dnd_timings[3].ends_at).to be_within(1.second).of Time.new(
                 2020,
                 1,
                 6,
                 23,
                 59,
                 59,
                 offset,
               )
        end
      end
    end

    it ""does not create duplicate record, but ensures the correct records exist"" do
      user.user_option.update(timezone: ""UTC"")

      travel_to Time.new(2020, 1, 4, 12, 0, 0, ""+00:00"") do
        UserNotificationScheduleProcessor.create_do_not_disturb_timings_for(standard_schedule)
        expect(user.do_not_disturb_timings.count).to eq(4)
        # All duplicates, so no new timings should be created
        UserNotificationScheduleProcessor.create_do_not_disturb_timings_for(standard_schedule)
        expect(user.do_not_disturb_timings.count).to eq(4)
      end

      travel_to Time.new(2020, 1, 5, 12, 0, 0, ""+00:00"") do
        UserNotificationScheduleProcessor.create_do_not_disturb_timings_for(standard_schedule)
        # There is 1 overlap, so expect only 3 more to be created
        expect(user.do_not_disturb_timings.count).to eq(7)
      end

      travel_to Time.new(2020, 1, 10, 12, 0, 0, ""+00:00"") do
        UserNotificationScheduleProcessor.create_do_not_disturb_timings_for(standard_schedule)
        # There is no overlap, so expect only 4 more to be created
        expect(user.do_not_disturb_timings.count).to eq(11)
      end
    end

    it ""extends previously scheduled dnd timings to remove gaps"" do
      user.user_option.update(timezone: ""UTC"")

      travel_to Time.new(2020, 1, 4, 12, 0, 0, ""+00:00"") do
        existing_timing =
          user.do_not_disturb_timings.create(
            scheduled: true,
            starts_at: 1.day.ago,
            ends_at: Time.new(2020, 1, 03, 11, 0, 0, ""+00:00"").end_of_day,
          )
        UserNotificationScheduleProcessor.create_do_not_disturb_timings_for(standard_schedule)
        expect(existing_timing.reload.ends_at).to eq_time(Time.new(2020, 1, 4, 7, 59, 0, ""+00:00""))
      end
    end

    it ""creates the correct timings when the whole schedule is DND (-1)"" do
      user.user_option.update(timezone: ""UTC"")
      schedule = standard_schedule
      schedule.update(
        day_0_start_time: -1,
        day_1_start_time: -1,
        day_2_start_time: -1,
        day_3_start_time: -1,
        day_4_start_time: -1,
        day_5_start_time: -1,
        day_6_start_time: -1,
      )

      travel_to Time.new(2020, 1, 4, 12, 0, 0, ""+00:00"") do
        UserNotificationScheduleProcessor.create_do_not_disturb_timings_for(schedule)
        expect(user.do_not_disturb_timings.count).to eq(1)
        expect(user.do_not_disturb_timings.first.starts_at).to eq_time(
          Time.new(2020, 1, 4, 0, 0, 0, ""+00:00""),
        )
        expect(user.do_not_disturb_timings.first.ends_at).to be_within(1.second).of Time.new(
               2020,
               1,
               6,
               23,
               59,
               59,
               ""+00:00"",
             )
      end
    end

    it ""creates the correct timings at the end of a month and year"" do
      user.user_option.update(timezone: ""UTC"")
      schedule = standard_schedule
      schedule.update(
        day_3_start_time: -1, # December 31, 2020 was a thursday. testing more cases.
      )

      travel_to Time.new(2020, 12, 31, 12, 0, 0, ""+00:00"") do
        UserNotificationScheduleProcessor.create_do_not_disturb_timings_for(schedule)
        expect(user.do_not_disturb_timings[0].starts_at).to eq_time(
          Time.new(2020, 12, 31, 0, 0, 0, ""+00:00""),
        )
        expect(user.do_not_disturb_timings[0].ends_at).to eq_time(
          Time.new(2021, 1, 1, 7, 59, 0, ""+00:00""),
        )
        expect(user.do_not_disturb_timings[1].starts_at).to eq_time(
          Time.new(2021, 1, 1, 17, 0, 0, ""+00:00""),
        )
        expect(user.do_not_disturb_timings[1].ends_at).to eq_time(
          Time.new(2021, 1, 2, 7, 59, 0, ""+00:00""),
        )
        expect(user.do_not_disturb_timings[2].starts_at).to eq_time(
          Time.new(2021, 1, 2, 17, 0, 0, ""+00:00""),
        )
        expect(user.do_not_disturb_timings[2].ends_at).to be_within(1.second).of Time.new(
               2021,
               1,
               2,
               23,
               59,
               59,
               ""+00:00"",
             )
      end
    end

    it ""handles midnight to midnight for multiple days (no timings created)"" do
      user.user_option.update(timezone: ""UTC"")
      schedule = standard_schedule
      schedule.update(
        day_0_start_time: 0,
        day_0_end_time: 1440,
        day_1_start_time: 0,
        day_1_end_time: 1440,
        day_2_start_time: 0,
        day_2_end_time: 1440,
      )
      travel_to Time.new(2021, 1, 4, 12, 0, 0, ""+00:00"") do
        UserNotificationScheduleProcessor.create_do_not_disturb_timings_for(schedule)
        expect(user.do_not_disturb_timings.count).to eq(0)
      end
    end

    it ""publishes to message bus when the user should enter DND"" do
      user.user_option.update(timezone: ""UTC"")
      schedule = standard_schedule
      travel_to Time.new(2020, 12, 31, 1, 0, 0, ""+00:00"") do
        messages =
          MessageBus.track_publish(""/do-not-disturb/#{user.id}"") do
            UserNotificationScheduleProcessor.create_do_not_disturb_timings_for(schedule)
          end

        expect(messages.size).to eq(1)
        expect(messages[0].data[:ends_at]).to eq(
          Time.new(2020, 12, 31, 7, 59, 0, ""+00:00"").httpdate,
        )
        expect(messages[0].user_ids).to contain_exactly(user.id)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# Consolidate notifications based on a threshold and a time window.
#
# If a consolidated notification already exists, we'll update it instead.
# If it doesn't and creating a new one would match the threshold, we delete existing ones and create a consolidated one.
# Otherwise, save the original one.
#
# Constructor arguments:
#
# - from: The notification type of the unconsolidated notification. e.g. `Notification.types[:private_message]`
# - to: The type the consolidated notification will have. You can use the same value as from to flatten notifications or bump existing ones.
# - threshold: If creating a new notification would match this number, we'll destroy existing ones and create a consolidated one. It also accepts a lambda that returns a number.
# - consolidation_window: Only consolidate notifications created since this value (Pass a ActiveSupport::Duration instance, and we'll call #ago on it).
# - unconsolidated_query_blk: A block with additional queries to apply when fetching for unconsolidated notifications.
# - consolidated_query_blk: A block with additional queries to apply when fetching for a consolidated notification.
#
# Need to call #set_precondition to configure this:
#
# - precondition_blk: A block that receives the mutated data and returns true if we have everything we need to consolidate.
#
# Need to call #set_mutations to configure this:
#
# - set_data_blk: A block that receives the notification data hash and mutates it, adding additional data needed for consolidation.
#
# Need to call #before_consolidation_callbacks to configure this:
#
# - before_update_blk: A block that is called before updating an already consolidated notification.
#                      Receives the consolidated object, the data hash, and the original notification.
#
# - before_consolidation_blk: A block that is called before creating a consolidated object.
#                             Receives an ActiveRecord::Relation with notifications about to be consolidated, and the new data hash.
#

module Notifications
  class ConsolidateNotifications < ConsolidationPlan
    def initialize(
      from:,
      to:,
      consolidation_window: nil,
      unconsolidated_query_blk: nil,
      consolidated_query_blk: nil,
      threshold:
    )
      @from = from
      @to = to
      @threshold = threshold
      @consolidation_window = consolidation_window
      @consolidated_query_blk = consolidated_query_blk
      @unconsolidated_query_blk = unconsolidated_query_blk
      @precondition_blk = nil
      @set_data_blk = nil
      @bump_notification = bump_notification
    end

    def before_consolidation_callbacks(before_update_blk: nil, before_consolidation_blk: nil)
      @before_update_blk = before_update_blk
      @before_consolidation_blk = before_consolidation_blk
      self
    end

    def can_consolidate_data?(notification)
      return false if get_threshold.zero? || to.blank?
      return false if notification.notification_type != from

      @data = consolidated_data(notification)

      return true if @precondition_blk.nil?
      @precondition_blk.call(data, notification)
    end

    def consolidate_or_save!(notification)
      @data ||= consolidated_data(notification)
      return unless can_consolidate_data?(notification)

      update_consolidated_notification!(notification) ||
        create_consolidated_notification!(notification) || notification.tap(&:save!)
    end

    private

    attr_reader(
      :notification,
      :from,
      :to,
      :data,
      :threshold,
      :consolidated_query_blk,
      :unconsolidated_query_blk,
      :consolidation_window,
      :bump_notification,
    )

    def update_consolidated_notification!(notification)
      notifications = user_notifications(notification, to)

      if consolidated_query_blk.present?
        notifications = consolidated_query_blk.call(notifications, data)
      end
      consolidated = notifications.first
      return if consolidated.blank?

      data_hash = consolidated.data_hash.merge(data)
      data_hash[:count] += 1 if data_hash[:count].present?

      @before_update_blk.call(consolidated, data_hash, notification) if @before_update_blk

      # Hack: We don't want to cache the old data if we're about to update it.
      consolidated.instance_variable_set(:@data_hash, nil)

      consolidated.update!(data: data_hash.to_json, read: false, updated_at: timestamp)

      consolidated
    end

    def create_consolidated_notification!(notification)
      notifications = user_notifications(notification, from)
      if unconsolidated_query_blk.present?
        notifications = unconsolidated_query_blk.call(notifications, data)
      end

      # Saving the new notification would pass the threshold? Consolidate instead.
      count_after_saving_notification = notifications.count + 1
      return if count_after_saving_notification <= get_threshold

      timestamp = notifications.last.created_at
      data[:count] = count_after_saving_notification

      @before_consolidation_blk.call(notifications, data) if @before_consolidation_blk

      consolidated = nil

      Notification.transaction do
        notifications.destroy_all

        consolidated =
          Notification.create!(
            notification_type: to,
            user_id: notification.user_id,
            data: data.to_json,
            updated_at: timestamp,
            created_at: timestamp,
          )
      end

      consolidated
    end

    def get_threshold
      threshold.is_a?(Proc) ? threshold.call : threshold
    end

    def user_notifications(notification, type)
      notifications = super(notification, type)

      if consolidation_window.present?
        notifications = notifications.where(""created_at > ?"", consolidation_window.ago)
      end

      notifications
    end

    def timestamp
      @timestamp ||= Time.zone.now
    end
  end
end

```","# frozen_string_literal: true

RSpec.describe Notifications::ConsolidateNotifications do
  describe ""#before_consolidation_callbacks"" do
    fab!(:user)
    let(:rule) do
      described_class.new(
        from: Notification.types[:liked],
        to: Notification.types[:liked],
        consolidation_window: 10.minutes,
        consolidated_query_blk:
          Proc.new { |notifications| notifications.where(""(data::json ->> 'consolidated')::bool"") },
        threshold: 1,
      ).set_mutations(set_data_blk: Proc.new { |n| n.data_hash.merge(consolidated: true) })
    end

    it ""applies a callback when consolidating a notification"" do
      rule.before_consolidation_callbacks(
        before_consolidation_blk:
          Proc.new { |_, data| data[:consolidation_callback_called] = true },
      )

      rule.consolidate_or_save!(build_like_notification)
      rule.consolidate_or_save!(build_like_notification)

      consolidated_notification = Notification.where(user: user).last

      expect(consolidated_notification.data_hash[:consolidation_callback_called]).to eq(true)
    end

    it ""applies a callback when updating a consolidated notification"" do
      rule.before_consolidation_callbacks(
        before_update_blk: Proc.new { |_, data| data[:update_callback_called] = true },
      )

      rule.consolidate_or_save!(build_like_notification)
      rule.consolidate_or_save!(build_like_notification)

      consolidated_notification = Notification.where(user: user).last

      expect(consolidated_notification.data_hash[:update_callback_called]).to be_nil

      rule.consolidate_or_save!(build_like_notification)

      consolidated_notification = Notification.where(user: user).last

      expect(consolidated_notification.data_hash[:update_callback_called]).to eq(true)
    end

    def build_like_notification
      Fabricate.build(
        :notification,
        user: user,
        notification_type: Notification.types[:liked],
        data: {}.to_json,
      )
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

module Notifications
  class ConsolidationPlanner
    def consolidate_or_save!(notification)
      plan = plan_for(notification)
      return :no_plan if plan.nil?

      plan.consolidate_or_save!(notification)
    end

    private

    def plan_for(notification)
      consolidation_plans = [
        liked_by_two_users,
        liked,
        group_message_summary,
        group_membership,
        new_features_notification,
      ]
      consolidation_plans.concat(DiscoursePluginRegistry.notification_consolidation_plans)

      consolidation_plans.detect { |plan| plan.can_consolidate_data?(notification) }
    end

    def liked
      ConsolidateNotifications
        .new(
          from: Notification.types[:liked],
          to: Notification.types[:liked_consolidated],
          threshold: -> { SiteSetting.notification_consolidation_threshold },
          consolidation_window: SiteSetting.likes_notification_consolidation_window_mins.minutes,
          unconsolidated_query_blk:
            Proc.new do |notifications, data|
              key = ""display_username""
              value = data[key.to_sym]
              filtered = notifications.where(""data::json ->> 'username2' IS NULL"")

              filtered = filtered.where(""data::json ->> '#{key}' = ?"", value) if value

              filtered
            end,
          consolidated_query_blk: filtered_by_data_attribute(""display_username""),
        )
        .set_mutations(
          set_data_blk:
            Proc.new do |notification|
              data = notification.data_hash
              data.merge(username: data[:display_username])
            end,
        )
        .set_precondition(precondition_blk: Proc.new { |data| data[:username2].blank? })
    end

    def liked_by_two_users
      DeletePreviousNotifications
        .new(
          type: Notification.types[:liked],
          previous_query_blk:
            Proc.new do |notifications, data|
              notifications.where(id: data[:previous_notification_id])
            end,
        )
        .set_mutations(
          set_data_blk:
            Proc.new do |notification|
              existing_notification_of_same_type =
                Notification
                  .where(user: notification.user)
                  .order(""notifications.id DESC"")
                  .where(topic_id: notification.topic_id, post_number: notification.post_number)
                  .where(notification_type: notification.notification_type)
                  .where(""created_at > ?"", 1.day.ago)
                  .first

              data = notification.data_hash
              if existing_notification_of_same_type
                same_type_data = existing_notification_of_same_type.data_hash
                data.merge(
                  previous_notification_id: existing_notification_of_same_type.id,
                  username2: same_type_data[:display_username],
                  count: (same_type_data[:count] || 1).to_i + 1,
                )
              else
                data
              end
            end,
        )
        .set_precondition(
          precondition_blk:
            Proc.new do |data, notification|
              always_freq = UserOption.like_notification_frequency_type[:always]

              notification.user&.user_option&.like_notification_frequency == always_freq &&
                data[:previous_notification_id].present?
            end,
        )
    end

    def group_membership
      ConsolidateNotifications
        .new(
          from: Notification.types[:private_message],
          to: Notification.types[:membership_request_consolidated],
          threshold: -> { SiteSetting.notification_consolidation_threshold },
          consolidation_window: Notification::MEMBERSHIP_REQUEST_CONSOLIDATION_WINDOW_HOURS.hours,
          unconsolidated_query_blk: filtered_by_data_attribute(""topic_title""),
          consolidated_query_blk: filtered_by_data_attribute(""group_name""),
        )
        .set_precondition(precondition_blk: Proc.new { |data| data[:group_name].present? })
        .set_mutations(
          set_data_blk:
            Proc.new do |notification|
              data = notification.data_hash
              post_id = data[:original_post_id]
              custom_field =
                PostCustomField.select(:value).find_by(post_id: post_id, name: ""requested_group_id"")
              group_id = custom_field&.value
              group_name =
                group_id.present? ? Group.select(:name).find_by(id: group_id.to_i)&.name : nil

              data[:group_name] = group_name
              data
            end,
        )
    end

    def group_message_summary
      DeletePreviousNotifications.new(
        type: Notification.types[:group_message_summary],
        previous_query_blk: filtered_by_data_attribute(""group_id""),
      ).set_precondition(precondition_blk: Proc.new { |data| data[:group_id].present? })
    end

    def filtered_by_data_attribute(attribute_name)
      Proc.new do |notifications, data|
        if (value = data[attribute_name.to_sym])
          notifications.where(""data::json ->> '#{attribute_name}' = ?"", value.to_s)
        else
          notifications
        end
      end
    end

    def new_features_notification
      DeletePreviousNotifications.new(type: Notification.types[:new_features])
    end
  end
end

```","# frozen_string_literal: true

RSpec.describe Notifications::ConsolidationPlanner do
  subject(:planner) { described_class.new }

  describe ""#consolidate_or_save!"" do
    let(:threshold) { 1 }
    fab!(:user)
    let(:like_user) { ""user1"" }

    before { SiteSetting.notification_consolidation_threshold = threshold }

    it ""does nothing it haven't passed the consolidation threshold yet"" do
      notification = build_notification(:liked, { display_username: like_user })

      saved_like = planner.consolidate_or_save!(notification)

      expect(saved_like.id).to be_present
      expect(saved_like.notification_type).to eq(Notification.types[:liked])
    end

    it ""consolidates multiple notifications into a new one"" do
      first_notification =
        Fabricate(
          :notification,
          user: user,
          notification_type: Notification.types[:liked],
          data: { display_username: like_user }.to_json,
        )
      notification = build_notification(:liked, { display_username: like_user })

      consolidated_like = planner.consolidate_or_save!(notification)

      expect(consolidated_like.id).not_to eq(first_notification.id)
      expect(consolidated_like.notification_type).to eq(Notification.types[:liked_consolidated])
      data = JSON.parse(consolidated_like.data)
      expect(data[""count""]).to eq(threshold + 1)
    end

    it ""updates the notification if we already consolidated it"" do
      count = 5
      Fabricate(
        :notification,
        user: user,
        notification_type: Notification.types[:liked_consolidated],
        data: { count: count, display_username: like_user }.to_json,
      )
      notification = build_notification(:liked, { display_username: like_user })

      updated = planner.consolidate_or_save!(notification)

      expect { notification.reload }.to raise_error(ActiveRecord::RecordNotFound)
      data = JSON.parse(updated.data)
      expect(data[""count""]).to eq(count + 1)
    end
  end

  def build_notification(type_sym, data)
    Fabricate.build(
      :notification,
      user: user,
      notification_type: Notification.types[type_sym],
      data: data.to_json,
    )
  end

  def plan_for(notification)
    planner.plan_for(notification)
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class SearchService
  pattr_initialize [:current_user!, :current_account!, :params!, :search_type!]

  def perform
    case search_type
    when 'Message'
      { messages: filter_messages }
    when 'Conversation'
      { conversations: filter_conversations }
    when 'Contact'
      { contacts: filter_contacts }
    else
      { contacts: filter_contacts, messages: filter_messages, conversations: filter_conversations }
    end
  end

  private

  def accessable_inbox_ids
    @accessable_inbox_ids ||= @current_user.assigned_inboxes.pluck(:id)
  end

  def search_query
    @search_query ||= params[:q].to_s.strip
  end

  def filter_conversations
    @conversations = current_account.conversations.where(inbox_id: accessable_inbox_ids)
                                    .joins('INNER JOIN contacts ON conversations.contact_id = contacts.id')
                                    .where(""cast(conversations.display_id as text) ILIKE :search OR contacts.name ILIKE :search OR contacts.email
                            ILIKE :search OR contacts.phone_number ILIKE :search OR contacts.identifier ILIKE :search"", search: ""%#{search_query}%"")
                                    .order('conversations.created_at DESC')
                                    .limit(10)
  end

  def filter_messages
    @messages = current_account.messages.where(inbox_id: accessable_inbox_ids)
                               .where('messages.content ILIKE :search', search: ""%#{search_query}%"")
                               .where('created_at >= ?', 3.months.ago)
                               .reorder('created_at DESC')
                               .limit(10)
  end

  def filter_contacts
    @contacts = current_account.contacts.where(
      ""name ILIKE :search OR email ILIKE :search OR phone_number
      ILIKE :search OR identifier ILIKE :search"", search: ""%#{search_query}%""
    ).resolved_contacts.order_on_last_activity_at('desc').limit(10)
  end
end

```","require 'rails_helper'

describe SearchService do
  subject(:search) { described_class.new(current_user: user, current_account: account, params: params, search_type: search_type) }

  let(:search_type) { 'all' }
  let!(:account) { create(:account) }
  let!(:user) { create(:user, account: account) }
  let!(:inbox) { create(:inbox, account: account, enable_auto_assignment: false) }
  let!(:harry) { create(:contact, name: 'Harry Potter', email: 'test@test.com', account_id: account.id) }
  let!(:conversation) { create(:conversation, contact: harry, inbox: inbox, account: account) }
  let!(:message) { create(:message, account: account, inbox: inbox, content: 'Harry Potter is a wizard') }

  before do
    create(:inbox_member, user: user, inbox: inbox)
    Current.account = account
  end

  after do
    Current.account = nil
  end

  describe '#perform' do
    context 'when search types' do
      let(:params) { { q: 'Potter' } }

      it 'returns all for all' do
        search_type = 'all'
        search = described_class.new(current_user: user, current_account: account, params: params, search_type: search_type)
        expect(search.perform.keys).to match_array(%i[contacts messages conversations])
      end

      it 'returns contacts for contacts' do
        search_type = 'Contact'
        search = described_class.new(current_user: user, current_account: account, params: params, search_type: search_type)
        expect(search.perform.keys).to match_array(%i[contacts])
      end

      it 'returns messages for messages' do
        search_type = 'Message'
        search = described_class.new(current_user: user, current_account: account, params: params, search_type: search_type)
        expect(search.perform.keys).to match_array(%i[messages])
      end

      it 'returns conversations for conversations' do
        search_type = 'Conversation'
        search = described_class.new(current_user: user, current_account: account, params: params, search_type: search_type)
        expect(search.perform.keys).to match_array(%i[conversations])
      end
    end

    context 'when contact search' do
      it 'searches across name, email, phone_number and identifier and returns in the order of contact last_activity_at' do
        # random contact
        create(:contact, account_id: account.id)
        # unresolved contact -> no identifying info
        # will not appear in search results
        create(:contact, name: 'Harry Potter', account_id: account.id)
        harry2 = create(:contact, email: 'HarryPotter@test.com', account_id: account.id, last_activity_at: 2.days.ago)
        harry3 = create(:contact, identifier: 'Potter123', account_id: account.id, last_activity_at: 1.day.ago)
        harry4 = create(:contact, identifier: 'Potter1235', account_id: account.id, last_activity_at: 2.minutes.ago)

        params = { q: 'Potter ' }
        search = described_class.new(current_user: user, current_account: account, params: params, search_type: 'Contact')
        expect(search.perform[:contacts].map(&:id)).to eq([harry4.id, harry3.id, harry2.id, harry.id])
      end
    end

    context 'when message search' do
      it 'searches across message content and return in created_at desc' do
        # random messages in another account
        create(:message, content: 'Harry Potter is a wizard')
        # random messsage in inbox with out access
        create(:message, account: account, inbox: create(:inbox, account: account), content: 'Harry Potter is a wizard')
        message2 = create(:message, account: account, inbox: inbox, content: 'harry is cool')
        params = { q: 'Harry' }
        search = described_class.new(current_user: user, current_account: account, params: params, search_type: 'Message')
        expect(search.perform[:messages].map(&:id)).to eq([message2.id, message.id])
      end
    end

    context 'when conversation search' do
      it 'searches across conversations using contact information and order by created_at desc' do
        # random messages in another inbox
        random = create(:contact, account_id: account.id)
        create(:conversation, contact: random, inbox: inbox, account: account)
        conv2 = create(:conversation, contact: harry, inbox: inbox, account: account)
        params = { q: 'Harry' }
        search = described_class.new(current_user: user, current_account: account, params: params, search_type: 'Conversation')
        expect(search.perform[:conversations].map(&:id)).to eq([conv2.id, conversation.id])
      end

      it 'searches across conversations with display id' do
        random = create(:contact, account_id: account.id, name: 'random', email: 'random@random.test', identifier: 'random')
        new_converstion = create(:conversation, contact: random, inbox: inbox, account: account)
        params = { q: new_converstion.display_id }
        search = described_class.new(current_user: user, current_account: account, params: params, search_type: 'Conversation')
        expect(search.perform[:conversations].map(&:id)).to include new_converstion.id
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class ActionService
  include EmailHelper

  def initialize(conversation)
    @conversation = conversation.reload
  end

  def mute_conversation(_params)
    @conversation.mute!
  end

  def snooze_conversation(_params)
    @conversation.snoozed!
  end

  def resolve_conversation(_params)
    @conversation.resolved!
  end

  def change_status(status)
    @conversation.update!(status: status[0])
  end

  def change_priority(priority)
    @conversation.update!(priority: (priority[0] == 'nil' ? nil : priority[0]))
  end

  def add_label(labels)
    return if labels.empty?

    @conversation.reload.add_labels(labels)
  end

  def assign_agent(agent_ids = [])
    return @conversation.update!(assignee_id: nil) if agent_ids[0] == 'nil'

    return unless agent_belongs_to_inbox?(agent_ids)

    @agent = @account.users.find_by(id: agent_ids)

    @conversation.update!(assignee_id: @agent.id) if @agent.present?
  end

  def remove_label(labels)
    return if labels.empty?

    labels = @conversation.label_list - labels
    @conversation.update(label_list: labels)
  end

  def assign_team(team_ids = [])
    return unassign_team if team_ids[0].zero?
    return unless team_belongs_to_account?(team_ids)

    @conversation.update!(team_id: team_ids[0])
  end

  def remove_assigned_team(_params)
    @conversation.update!(team_id: nil)
  end

  def send_email_transcript(emails)
    emails = emails[0].gsub(/\s+/, '').split(',')

    emails.each do |email|
      email = parse_email_variables(@conversation, email)
      ConversationReplyMailer.with(account: @conversation.account).conversation_transcript(@conversation, email)&.deliver_later
    end
  end

  private

  def agent_belongs_to_inbox?(agent_ids)
    member_ids = @conversation.inbox.members.pluck(:user_id)
    assignable_agent_ids = member_ids + @account.administrators.ids

    assignable_agent_ids.include?(agent_ids[0])
  end

  def team_belongs_to_account?(team_ids)
    @account.team_ids.include?(team_ids[0])
  end

  def conversation_a_tweet?
    return false if @conversation.additional_attributes.blank?

    @conversation.additional_attributes['type'] == 'tweet'
  end
end

```","require 'rails_helper'

describe ActionService do
  let(:account) { create(:account) }

  describe '#resolve_conversation' do
    let(:conversation) { create(:conversation) }
    let(:action_service) { described_class.new(conversation) }

    it 'resolves the conversation' do
      expect(conversation.status).to eq('open')
      action_service.resolve_conversation(nil)
      expect(conversation.reload.status).to eq('resolved')
    end
  end

  describe '#change_priority' do
    let(:conversation) { create(:conversation) }
    let(:action_service) { described_class.new(conversation) }

    it 'changes the priority of the conversation to medium' do
      action_service.change_priority(['medium'])
      expect(conversation.reload.priority).to eq('medium')
    end

    it 'changes the priority of the conversation to nil' do
      action_service.change_priority(['nil'])
      expect(conversation.reload.priority).to be_nil
    end
  end

  describe '#assign_agent' do
    let(:agent) { create(:user, account: account, role: :agent) }
    let(:conversation) { create(:conversation, account: account) }
    let(:inbox_member) { create(:inbox_member, inbox: conversation.inbox, user: agent) }
    let(:action_service) { described_class.new(conversation) }

    it 'unassigns the conversation if agent id is nil' do
      action_service.assign_agent(['nil'])
      expect(conversation.reload.assignee).to be_nil
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Twitter::WebhookSubscribeService
  include Rails.application.routes.url_helpers

  pattr_initialize [:inbox_id]

  def perform
    ensure_webhook
    unless subscription?
      subscribe_response = twitter_client.create_subscription
      raise StandardError, 'Twitter Subscription Failed' unless subscribe_response.status == '204'
    end

    true
  end

  private

  delegate :channel, to: :inbox
  delegate :twitter_client, to: :channel

  def inbox
    Inbox.find(inbox_id)
  end

  def twitter_url
    webhooks_twitter_url(protocol: 'https')
  end

  def ensure_webhook
    webhooks = fetch_webhooks
    return true if webhooks&.first&.try(:[], 'url') == twitter_url

    # twitter supports only one webhook url per environment
    # so we will delete the existing one if its not chatwoot
    unregister_webhook(webhooks.first) if webhooks&.first
    register_webhook
  end

  def unregister_webhook(webhook)
    unregister_response = twitter_client.unregister_webhook(id: webhook.try(:[], 'id'))
    Rails.logger.info ""TWITTER_UNREGISTER_WEBHOOK: #{unregister_response.body}""
  end

  def register_webhook
    register_response = twitter_client.register_webhook(url: twitter_url)
    Rails.logger.info ""TWITTER_REGISTER_WEBHOOK: #{register_response.body}""
  end

  def subscription?
    response = twitter_client.fetch_subscriptions
    response.status == '204'
  end

  def fetch_webhooks
    twitter_client.fetch_webhooks.body
  end
end

```","require 'rails_helper'

describe Twitter::WebhookSubscribeService do
  subject(:webhook_subscribe_service) { described_class.new(inbox_id: twitter_inbox.id) }

  let(:twitter_client) { instance_double(Twitty::Facade) }
  let(:twitter_success_response) { instance_double(Twitty::Response, status: '200', body: { message: 'Valid' }) }
  let(:twitter_error_response) { instance_double(Twitty::Response, status: '422', body: { message: 'Invalid request' }) }
  let(:account) { create(:account) }
  let(:twitter_channel) { create(:channel_twitter_profile, account: account) }
  let(:twitter_inbox) { create(:inbox, channel: twitter_channel, account: account) }

  before do
    allow(Twitty::Facade).to receive(:new).and_return(twitter_client)
    allow(twitter_client).to receive(:register_webhook).and_return(twitter_success_response)
    allow(twitter_client).to receive(:unregister_webhook).and_return(twitter_success_response)
    allow(twitter_client).to receive(:fetch_subscriptions).and_return(instance_double(Twitty::Response, status: '204', body: { message: 'Valid' }))
    allow(twitter_client).to receive(:create_subscription).and_return(instance_double(Twitty::Response, status: '204', body: { message: 'Valid' }))
  end

  describe '#perform' do
    context 'when webhook is not registered' do
      it 'calls register_webhook' do
        allow(twitter_client).to receive(:fetch_webhooks).and_return(
          instance_double(Twitty::Response, status: '200', body: {})
        )
        webhook_subscribe_service.perform
        expect(twitter_client).not_to have_received(:unregister_webhook)
        expect(twitter_client).to have_received(:register_webhook)
      end
    end

    context 'when valid webhook is registered' do
      it 'calls unregister_webhook and then register webhook' do
        allow(twitter_client).to receive(:fetch_webhooks).and_return(
          instance_double(Twitty::Response, status: '200',
                                            body: [{ 'url' => webhook_subscribe_service.send(:twitter_url) }])
        )
        webhook_subscribe_service.perform
        expect(twitter_client).not_to have_received(:unregister_webhook)
        expect(twitter_client).not_to have_received(:register_webhook)
      end
    end

    context 'when invalid webhook is registered' do
      it 'calls unregister_webhook and then register webhook' do
        allow(twitter_client).to receive(:fetch_webhooks).and_return(
          instance_double(Twitty::Response, status: '200',
                                            body: [{ 'url' => 'invalid_url' }])
        )
        webhook_subscribe_service.perform
        expect(twitter_client).to have_received(:unregister_webhook)
        expect(twitter_client).to have_received(:register_webhook)
      end
    end

    context 'when correct webhook is present' do
      it 'calls create subscription if subscription is not present' do
        allow(twitter_client).to receive(:fetch_webhooks).and_return(
          instance_double(Twitty::Response, status: '200',
                                            body: [{ 'url' => webhook_subscribe_service.send(:twitter_url) }])
        )
        allow(twitter_client).to receive(:fetch_subscriptions).and_return(instance_double(Twitty::Response, status: '500'))
        webhook_subscribe_service.perform
        expect(twitter_client).to have_received(:create_subscription)
      end

      it 'does not call create subscription if subscription is already present' do
        allow(twitter_client).to receive(:fetch_webhooks).and_return(
          instance_double(Twitty::Response, status: '200',
                                            body: [{ 'url' => webhook_subscribe_service.send(:twitter_url) }])
        )
        webhook_subscribe_service.perform
        expect(twitter_client).not_to have_received(:create_subscription)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Twitter::SendOnTwitterService < Base::SendOnChannelService
  pattr_initialize [:message!]

  private

  delegate :additional_attributes, to: :contact

  def channel_class
    Channel::TwitterProfile
  end

  def perform_reply
    conversation_type == 'tweet' ? send_tweet_reply : send_direct_message
  end

  def twitter_client
    Twitty::Facade.new do |config|
      config.consumer_key = ENV.fetch('TWITTER_CONSUMER_KEY', nil)
      config.consumer_secret = ENV.fetch('TWITTER_CONSUMER_SECRET', nil)
      config.access_token = channel.twitter_access_token
      config.access_token_secret = channel.twitter_access_token_secret
      config.base_url = 'https://api.twitter.com'
      config.environment = ENV.fetch('TWITTER_ENVIRONMENT', '')
    end
  end

  def conversation_type
    conversation.additional_attributes['type']
  end

  def screen_name
    return ""@#{reply_to_message.inbox.name}"" if reply_to_message.outgoing?

    ""@#{reply_to_message.sender&.additional_attributes.try(:[], 'screen_name') || ''}""
  end

  def send_direct_message
    twitter_client.send_direct_message(
      recipient_id: contact_inbox.source_id,
      message: message.content
    )
  end

  def reply_to_message
    @reply_to_message ||= if message.in_reply_to
                            conversation.messages.find(message.in_reply_to)
                          else
                            conversation.messages.incoming.last
                          end
  end

  def send_tweet_reply
    response = twitter_client.send_tweet_reply(
      reply_to_tweet_id: reply_to_message.source_id,
      tweet: ""#{screen_name} #{message.content}""
    )
    if response.status == '200'
      tweet_data = response.body
      message.update!(source_id: tweet_data['id_str'])
    else
      Rails.logger.error ""TWITTER_TWEET_REPLY_ERROR #{response.body}""
    end
  end
end

```","require 'rails_helper'

describe Twitter::SendOnTwitterService do
  subject(:send_reply_service) { described_class.new(message: message) }

  let(:twitter_client) { instance_double(Twitty::Facade) }
  let(:twitter_response) { instance_double(Twitty::Response) }
  let(:account) { create(:account) }
  let(:widget_inbox) { create(:inbox, account: account) }
  let(:twitter_channel) { create(:channel_twitter_profile, account: account) }
  let(:twitter_inbox) { create(:inbox, channel: twitter_channel, account: account) }
  let(:contact) { create(:contact, account: account, additional_attributes: { screen_name: 'test_user' }) }
  let(:contact_inbox) { create(:contact_inbox, contact: contact, inbox: twitter_inbox) }
  let(:dm_conversation) do
    create(
      :conversation,
      contact: contact,
      inbox: twitter_inbox,
      contact_inbox: contact_inbox,
      additional_attributes: { type: 'direct_message' }
    )
  end
  let(:tweet_conversation) do
    create(
      :conversation,
      contact: contact,
      inbox: twitter_inbox,
      contact_inbox: contact_inbox,
      additional_attributes: { type: 'tweet', tweet_id: '1234' }
    )
  end

  before do
    allow(Twitty::Facade).to receive(:new).and_return(twitter_client)
    allow(twitter_client).to receive(:send_direct_message).and_return(true)
    allow(twitter_client).to receive(:send_tweet_reply).and_return(twitter_response)
    allow(twitter_response).to receive(:status).and_return('200')
    allow(twitter_response).to receive(:body).and_return(JSON.parse({ id_str: '12345' }.to_json))
  end

  describe '#perform' do
    context 'without reply' do
      it 'if inbox channel is not twitter profile' do
        message = create(:message, message_type: 'outgoing', inbox: widget_inbox, account: account)
        expect { described_class.new(message: message).perform }.to raise_error 'Invalid channel service was called'
        expect(twitter_client).not_to have_received(:send_direct_message)
      end

      it 'if message is private' do
        message = create(:message, message_type: 'outgoing', private: true, inbox: twitter_inbox, account: account)
        described_class.new(message: message).perform
        expect(twitter_client).not_to have_received(:send_direct_message)
      end

      it 'if message has source_id' do
        message = create(:message, message_type: 'outgoing', source_id: '123', inbox: twitter_inbox, account: account)
        described_class.new(message: message).perform
        expect(twitter_client).not_to have_received(:send_direct_message)
      end

      it 'if message is not outgoing' do
        message = create(:message, message_type: 'incoming', inbox: twitter_inbox, account: account)
        described_class.new(message: message).perform
        expect(twitter_client).not_to have_received(:send_direct_message)
      end
    end

    context 'with reply' do
      it 'if conversation is a direct message' do
        create(:message, message_type: :incoming, inbox: twitter_inbox, account: account, conversation: dm_conversation)
        message = create(:message, message_type: :outgoing, inbox: twitter_inbox, account: account, conversation: dm_conversation)
        described_class.new(message: message).perform
        expect(twitter_client).to have_received(:send_direct_message)
      end

      context 'when conversation is a tweet' do
        it 'creates a response with correct reply if reply to message is incoming' do
          create(
            :message,
            message_type: :incoming,
            sender: contact,
            source_id: 'test-source-id-1',
            inbox: twitter_inbox,
            account: account,
            conversation: tweet_conversation
          )
          message = create(:message, message_type: :outgoing, inbox: twitter_inbox, account: account, conversation: tweet_conversation)
          described_class.new(message: message).perform
          expect(twitter_client).to have_received(:send_tweet_reply).with(
            reply_to_tweet_id: 'test-source-id-1',
            tweet: ""@test_user #{message.content}""
          )
          expect(message.reload.source_id).to eq '12345'
        end

        it 'creates a response with correct reply if reply to message is outgoing' do
          outgoing_message = create(
            :message,
            message_type: :outgoing,
            source_id: 'test-source-id-1',
            inbox: twitter_inbox,
            account: account,
            conversation: tweet_conversation
          )
          reply_message = create(
            :message,
            message_type: :outgoing,
            inbox: twitter_inbox,
            account: account,
            conversation: tweet_conversation,
            in_reply_to: outgoing_message.id
          )
          described_class.new(message: reply_message).perform
          expect(twitter_client).to have_received(:send_tweet_reply).with(
            reply_to_tweet_id: 'test-source-id-1',
            tweet: ""@#{twitter_inbox.name} #{reply_message.content}""
          )
          expect(reply_message.reload.source_id).to eq '12345'
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class AutoAssignment::InboxRoundRobinService
  pattr_initialize [:inbox!]

  # called on inbox delete
  def clear_queue
    ::Redis::Alfred.delete(round_robin_key)
  end

  # called on inbox member create
  def add_agent_to_queue(user_id)
    ::Redis::Alfred.lpush(round_robin_key, user_id)
  end

  # called on inbox member delete
  def remove_agent_from_queue(user_id)
    ::Redis::Alfred.lrem(round_robin_key, user_id)
  end

  def reset_queue
    clear_queue
    add_agent_to_queue(inbox.inbox_members.map(&:user_id))
  end

  # end of queue management functions

  # allowed member ids = [assignable online agents supplied by the assignement service]
  # the values of allowed member ids should be in string format
  def available_agent(allowed_agent_ids: [])
    reset_queue unless validate_queue?
    user_id = get_member_from_allowed_agent_ids(allowed_agent_ids)
    inbox.inbox_members.find_by(user_id: user_id)&.user if user_id.present?
  end

  private

  def get_member_from_allowed_agent_ids(allowed_agent_ids)
    return nil if allowed_agent_ids.blank?

    user_id = queue.intersection(allowed_agent_ids).pop
    pop_push_to_queue(user_id)
    user_id
  end

  def pop_push_to_queue(user_id)
    return if user_id.blank?

    remove_agent_from_queue(user_id)
    add_agent_to_queue(user_id)
  end

  def validate_queue?
    return true if inbox.inbox_members.map(&:user_id).sort == queue.map(&:to_i).sort
  end

  def queue
    ::Redis::Alfred.lrange(round_robin_key)
  end

  def round_robin_key
    format(::Redis::Alfred::ROUND_ROBIN_AGENTS, inbox_id: inbox.id)
  end
end

```","require 'rails_helper'

describe AutoAssignment::InboxRoundRobinService do
  subject(:inbox_round_robin_service) { described_class.new(inbox: inbox) }

  let!(:account) { create(:account) }
  let!(:inbox) { create(:inbox, account: account) }
  let!(:inbox_members) { create_list(:inbox_member, 5, inbox: inbox) }

  describe '#available_agent' do
    it 'returns nil if allowed_agent_ids is not passed or empty' do
      expect(described_class.new(inbox: inbox).available_agent).to be_nil
    end

    it 'gets the first available agent in allowed_agent_ids and move agent to end of the list' do
      expected_queue = [inbox_members[0].user_id, inbox_members[4].user_id, inbox_members[3].user_id, inbox_members[2].user_id,
                        inbox_members[1].user_id].map(&:to_s)
      described_class.new(inbox: inbox).available_agent(allowed_agent_ids: [inbox_members[0].user_id, inbox_members[4].user_id].map(&:to_s))
      expect(inbox_round_robin_service.send(:queue)).to eq(expected_queue)
    end

    it 'constructs round_robin_queue if queue is not present' do
      inbox_round_robin_service.clear_queue
      expect(inbox_round_robin_service.send(:queue)).to eq([])
      inbox_round_robin_service.available_agent
      # the service constructed the redis queue before performing
      expect(inbox_round_robin_service.send(:queue).map(&:to_i)).to match_array(inbox_members.map(&:user_id))
    end

    it 'validates the queue and correct it before performing round robin' do
      # adding some invalid ids to queue
      inbox_round_robin_service.add_agent_to_queue([2, 3, 5, 9])
      expect(inbox_round_robin_service.send(:queue).map(&:to_i)).not_to match_array(inbox_members.map(&:user_id))
      inbox_round_robin_service.available_agent
      # the service have refreshed the redis queue before performing
      expect(inbox_round_robin_service.send(:queue).map(&:to_i)).to match_array(inbox_members.map(&:user_id))
    end

    context 'when allowed_agent_ids is passed' do
      it 'will get the first allowed member and move it to the end of the queue' do
        expected_queue = [inbox_members[3].user_id, inbox_members[2].user_id, inbox_members[4].user_id, inbox_members[1].user_id,
                          inbox_members[0].user_id].map(&:to_s)
        expect(described_class.new(inbox: inbox).available_agent(
                 allowed_agent_ids: [
                   inbox_members[3].user_id,
                   inbox_members[2].user_id
                 ].map(&:to_s)
               )).to eq inbox_members[2].user
        expect(described_class.new(inbox: inbox).available_agent(
                 allowed_agent_ids: [
                   inbox_members[3].user_id,
                   inbox_members[2].user_id
                 ].map(&:to_s)
               )).to eq inbox_members[3].user
        expect(inbox_round_robin_service.send(:queue)).to eq(expected_queue)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class AutoAssignment::AgentAssignmentService
  # Allowed agent ids: array
  # This is the list of agents from which an agent can be assigned to this conversation
  # examples: Agents with assignment capacity, Agents who are members of a team etc
  pattr_initialize [:conversation!, :allowed_agent_ids!]

  def find_assignee
    round_robin_manage_service.available_agent(allowed_agent_ids: allowed_online_agent_ids)
  end

  def perform
    new_assignee = find_assignee
    conversation.update(assignee: new_assignee) if new_assignee
  end

  private

  def online_agent_ids
    online_agents = OnlineStatusTracker.get_available_users(conversation.account_id)
    online_agents.select { |_key, value| value.eql?('online') }.keys if online_agents.present?
  end

  def allowed_online_agent_ids
    # We want to perform roundrobin only over online agents
    # Hence taking an intersection of online agents and allowed member ids

    # the online user ids are string, since its from redis, allowed member ids are integer, since its from active record
    @allowed_online_agent_ids ||= online_agent_ids & allowed_agent_ids&.map(&:to_s)
  end

  def round_robin_manage_service
    @round_robin_manage_service ||= AutoAssignment::InboxRoundRobinService.new(inbox: conversation.inbox)
  end

  def round_robin_key
    format(::Redis::Alfred::ROUND_ROBIN_AGENTS, inbox_id: conversation.inbox_id)
  end
end

```","require 'rails_helper'

RSpec.describe AutoAssignment::AgentAssignmentService do
  let!(:account) { create(:account) }
  let!(:inbox) { create(:inbox, account: account, enable_auto_assignment: false) }
  let!(:inbox_members) { create_list(:inbox_member, 5, inbox: inbox) }
  let!(:conversation) { create(:conversation, inbox: inbox, account: account) }
  let!(:online_users) do
    {
      inbox_members[0].user_id.to_s => 'busy',
      inbox_members[1].user_id.to_s => 'busy',
      inbox_members[2].user_id.to_s => 'busy',
      inbox_members[3].user_id.to_s => 'online',
      inbox_members[4].user_id.to_s => 'online'
    }
  end

  before do
    inbox_members.each { |inbox_member| create(:account_user, account: account, user: inbox_member.user) }
    allow(OnlineStatusTracker).to receive(:get_available_users).and_return(online_users)
  end

  describe '#perform' do
    it 'will assign an online agent to the conversation' do
      expect(conversation.reload.assignee).to be_nil
      described_class.new(conversation: conversation, allowed_agent_ids: inbox_members.map(&:user_id).map(&:to_s)).perform
      expect(conversation.reload.assignee).not_to be_nil
    end
  end

  describe '#find_assignee' do
    it 'will return an online agent from the allowed agent ids in roud robin' do
      expect(described_class.new(conversation: conversation,
                                 allowed_agent_ids: inbox_members.map(&:user_id).map(&:to_s)).find_assignee).to eq(inbox_members[3].user)
      expect(described_class.new(conversation: conversation,
                                 allowed_agent_ids: inbox_members.map(&:user_id).map(&:to_s)).find_assignee).to eq(inbox_members[4].user)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Messages::MentionService
  pattr_initialize [:message!]

  def perform
    return unless valid_mention_message?(message)

    validated_mentioned_ids = filter_mentioned_ids_by_inbox
    return if validated_mentioned_ids.blank?

    Conversations::UserMentionJob.perform_later(validated_mentioned_ids, message.conversation.id, message.account.id)
    generate_notifications_for_mentions(validated_mentioned_ids)
    add_mentioned_users_as_participants(validated_mentioned_ids)
  end

  private

  def valid_mention_message?(message)
    message.private? && message.content.present? && mentioned_ids.present?
  end

  def mentioned_ids
    @mentioned_ids ||= message.content.scan(%r{\(mention://(user|team)/(\d+)/(.+?)\)}).map(&:second).uniq
  end

  def filter_mentioned_ids_by_inbox
    inbox = message.inbox
    valid_mentionable_ids = inbox.account.administrators.map(&:id) + inbox.members.map(&:id)
    # Intersection of ids
    mentioned_ids & valid_mentionable_ids.uniq.map(&:to_s)
  end

  def generate_notifications_for_mentions(validated_mentioned_ids)
    validated_mentioned_ids.each do |user_id|
      NotificationBuilder.new(
        notification_type: 'conversation_mention',
        user: User.find(user_id),
        account: message.account,
        primary_actor: message
      ).perform
    end
  end

  def add_mentioned_users_as_participants(validated_mentioned_ids)
    validated_mentioned_ids.each do |user_id|
      message.conversation.conversation_participants.find_or_create_by(user_id: user_id)
    end
  end
end

```","require 'rails_helper'

describe Messages::MentionService do
  let!(:account) { create(:account) }
  let!(:user) { create(:user, account: account) }
  let!(:first_agent) { create(:user, account: account) }
  let!(:second_agent) { create(:user, account: account) }
  let!(:inbox) { create(:inbox, account: account) }
  let!(:conversation) { create(:conversation, account: account, inbox: inbox, assignee: user) }
  let(:builder) { double }

  before do
    create(:inbox_member, user: first_agent, inbox: inbox)
    create(:inbox_member, user: second_agent, inbox: inbox)
    conversation.reload
    allow(NotificationBuilder).to receive(:new).and_return(builder)
    allow(builder).to receive(:perform)
  end

  context 'when message contains mention' do
    it 'creates notifications for inbox member who was mentioned' do
      message = build(
        :message,
        conversation: conversation,
        account: account,
        content: ""hi [#{first_agent.name}](mention://user/#{first_agent.id}/#{first_agent.name})"",
        private: true
      )

      described_class.new(message: message).perform

      expect(NotificationBuilder).to have_received(:new).with(notification_type: 'conversation_mention',
                                                              user: first_agent,
                                                              account: account,
                                                              primary_actor: message)
    end
  end

  context 'when message contains multiple mentions' do
    let(:message) do
      build(
        :message,
        conversation: conversation,
        account: account,
        content: ""hey [#{second_agent.name}](mention://user/#{second_agent.id}/#{second_agent.name})/
                  [#{first_agent.name}](mention://user/#{first_agent.id}/#{first_agent.name}),
                   please look in to this?"",
        private: true
      )
    end

    it 'creates notifications for inbox member who was mentioned' do
      described_class.new(message: message).perform

      expect(NotificationBuilder).to have_received(:new).with(notification_type: 'conversation_mention',
                                                              user: second_agent,
                                                              account: account,
                                                              primary_actor: message)
      expect(NotificationBuilder).to have_received(:new).with(notification_type: 'conversation_mention',
                                                              user: first_agent,
                                                              account: account,
                                                              primary_actor: message)
    end

    it 'add the users to the participants list' do
      described_class.new(message: message).perform
      expect(conversation.conversation_participants.map(&:user_id)).to contain_exactly(first_agent.id, second_agent.id)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Messages::NewMessageNotificationService
  pattr_initialize [:message!]

  def perform
    return unless message.notifiable?

    notify_participating_users
    notify_conversation_assignee
  end

  private

  delegate :conversation, :sender, :account, to: :message

  def notify_participating_users
    participating_users = conversation.conversation_participants.map(&:user)
    participating_users -= [sender] if sender.is_a?(User)

    participating_users.uniq.each do |participant|
      NotificationBuilder.new(
        notification_type: 'participating_conversation_new_message',
        user: participant,
        account: account,
        primary_actor: message
      ).perform
    end
  end

  def notify_conversation_assignee
    return if conversation.assignee.blank?
    return if assignee_already_notified_via_participation?
    return if conversation.assignee == sender

    NotificationBuilder.new(
      notification_type: 'assigned_conversation_new_message',
      user: conversation.assignee,
      account: account,
      primary_actor: message
    ).perform
  end

  def assignee_already_notified_via_participation?
    return unless conversation.conversation_participants.map(&:user).include?(conversation.assignee)

    # check whether participation notifcation is disabled for assignee
    notification_setting = conversation.assignee.notification_settings.find_by(account_id: account.id)
    notification_setting.public_send(:email_participating_conversation_new_message?) || notification_setting
      .public_send(:push_participating_conversation_new_message?)
  end
end

```","require 'rails_helper'

describe Messages::NewMessageNotificationService do
  context 'when message is not notifiable' do
    it 'will not create any notifications' do
      message = build(:message, message_type: :activity)
      expect(NotificationBuilder).not_to receive(:new)
      described_class.new(message: message).perform
    end
  end

  context 'when message is notifiable' do
    let(:account) { create(:account) }
    let(:assignee) { create(:user, account: account) }
    let(:participating_agent_1) { create(:user, account: account) }
    let(:participating_agent_2) { create(:user, account: account) }
    let(:inbox) { create(:inbox, account: account) }
    let(:conversation) { create(:conversation, account: account, inbox: inbox, assignee: assignee) }
    let(:builder) { double }

    before do
      create(:inbox_member, inbox: inbox, user: participating_agent_1)
      create(:inbox_member, inbox: inbox, user: participating_agent_2)
      create(:inbox_member, inbox: inbox, user: assignee)
      create(:conversation_participant, conversation: conversation, user: participating_agent_1)
      create(:conversation_participant, conversation: conversation, user: participating_agent_2)
      create(:conversation_participant, conversation: conversation, user: assignee)
      allow(NotificationBuilder).to receive(:new).and_return(builder)
      allow(builder).to receive(:perform)
    end

    context 'when message is created by a participant' do
      let(:message) { create(:message, conversation: conversation, account: account, sender: participating_agent_1) }

      before do
        described_class.new(message: message).perform
      end

      it 'creates notifications for other participating users' do
        expect(NotificationBuilder).to have_received(:new).with(notification_type: 'participating_conversation_new_message',
                                                                user: participating_agent_2,
                                                                account: account,
                                                                primary_actor: message)
      end

      it 'creates notifications for assignee' do
        expect(NotificationBuilder).to have_received(:new).with(notification_type: 'assigned_conversation_new_message',
                                                                user: assignee,
                                                                account: account,
                                                                primary_actor: message)
      end

      it 'will not create notifications for the user who created the message' do
        expect(NotificationBuilder).not_to have_received(:new).with(notification_type: 'participating_conversation_new_message',
                                                                    user: participating_agent_1,
                                                                    account: account,
                                                                    primary_actor: message)
      end
    end

    context 'when message is created by a contact' do
      let(:message) { create(:message, conversation: conversation, account: account) }

      before do
        described_class.new(message: message).perform
      end

      it 'creates notifications for assignee' do
        expect(NotificationBuilder).to have_received(:new).with(notification_type: 'assigned_conversation_new_message',
                                                                user: assignee,
                                                                account: account,
                                                                primary_actor: message)
      end

      it 'creates notifications for all participating users' do
        expect(NotificationBuilder).to have_received(:new).with(notification_type: 'participating_conversation_new_message',
                                                                user: participating_agent_1,
                                                                account: account,
                                                                primary_actor: message)
        expect(NotificationBuilder).to have_received(:new).with(notification_type: 'participating_conversation_new_message',
                                                                user: participating_agent_2,
                                                                account: account,
                                                                primary_actor: message)
      end
    end

    context 'with multiple notifications are subscribed' do
      let(:message) { create(:message, conversation: conversation, account: account) }

      before do
        assignee.notification_settings.find_by(account_id: account.id).update(selected_email_flags: %w[email_assigned_conversation_new_message
                                                                                                       email_participating_conversation_new_message])
        described_class.new(message: message).perform
      end

      it 'will not create assignee notifications for the assignee if participating notification was send' do
        expect(NotificationBuilder).not_to have_received(:new).with(notification_type: 'assigned_conversation_new_message',
                                                                    user: assignee,
                                                                    account: account,
                                                                    primary_actor: message)
      end
    end

    context 'when message is created by assignee' do
      let(:message) { create(:message, conversation: conversation, account: account, sender: assignee) }

      before do
        described_class.new(message: message).perform
      end

      it 'will not create notifications for the user who created the message' do
        expect(NotificationBuilder).not_to have_received(:new).with(notification_type: 'participating_conversation_new_message',
                                                                    user: assignee,
                                                                    account: account,
                                                                    primary_actor: message)
        expect(NotificationBuilder).not_to have_received(:new).with(notification_type: 'assigned_conversation_new_message',
                                                                    user: assignee,
                                                                    account: account,
                                                                    primary_actor: message)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Sms::DeliveryStatusService
  pattr_initialize [:inbox!, :params!]

  def perform
    return unless supported_status?

    process_status if message.present?
  end

  private

  def process_status
    @message.status = status
    @message.external_error = external_error if error_occurred?
    @message.save!
  end

  def supported_status?
    %w[message-delivered message-failed].include?(params[:type])
  end

  # Relevant documentation:
  # https://dev.bandwidth.com/docs/mfa/webhooks/international/message-delivered
  # https://dev.bandwidth.com/docs/mfa/webhooks/international/message-failed
  def status
    type_mapping = {
      'message-delivered' => 'delivered',
      'message-failed' => 'failed'
    }

    type_mapping[params[:type]]
  end

  def external_error
    return nil unless error_occurred?

    error_message = params[:description]
    error_code = params[:errorCode]

    ""#{error_code} - #{error_message}""
  end

  def error_occurred?
    params[:errorCode] && params[:type] == 'message-failed'
  end

  def message
    return unless params[:message][:id]

    @message ||= inbox.messages.find_by(source_id: params[:message][:id])
  end
end

```","require 'rails_helper'

describe Sms::DeliveryStatusService do
  describe '#perform' do
    let!(:account) { create(:account) }
    let!(:sms_channel) { create(:channel_sms) }
    let!(:contact) { create(:contact, account: account, phone_number: '+12345') }
    let(:contact_inbox) { create(:contact_inbox, source_id: '+12345', contact: contact, inbox: sms_channel.inbox) }
    let!(:conversation) { create(:conversation, contact: contact, inbox: sms_channel.inbox, contact_inbox: contact_inbox) }

    describe '#perform' do
      context 'when message delivery status is fired' do
        before do
          create(:message, account: account, inbox: sms_channel.inbox, conversation: conversation, status: :sent,
                           source_id: 'SMd560ac79e4a4d36b3ce59f1f50471986')
        end

        it 'updates the message if the message status is delivered' do
          params = {
            time: '2022-02-02T23:14:05.309Z',
            type: 'message-delivered',
            to: sms_channel.phone_number,
            description: 'ok',
            message: {
              'id': conversation.messages.last.source_id
            }
          }

          described_class.new(params: params, inbox: sms_channel.inbox).perform
          expect(conversation.reload.messages.last.status).to eq('delivered')
        end

        it 'updates the message if the message status is failed' do
          params = {
            time: '2022-02-02T23:14:05.309Z',
            type: 'message-failed',
            to: sms_channel.phone_number,
            description: 'Undeliverable',
            errorCode: 995,
            message: {
              'id': conversation.messages.last.source_id
            }
          }

          described_class.new(params: params, inbox: sms_channel.inbox).perform
          expect(conversation.reload.messages.last.status).to eq('failed')

          expect(conversation.reload.messages.last.external_error).to eq('995 - Undeliverable')
        end

        it 'does not update the message if the status is not a support status' do
          params = {
            time: '2022-02-02T23:14:05.309Z',
            type: 'queued',
            to: sms_channel.phone_number,
            description: 'ok',
            message: {
              'id': conversation.messages.last.source_id
            }
          }

          described_class.new(params: params, inbox: sms_channel.inbox).perform
          expect(conversation.reload.messages.last.status).to eq('sent')
        end

        it 'does not update the message if the message is not present' do
          params = {
            time: '2022-02-02T23:14:05.309Z',
            type: 'message-delivered',
            to: sms_channel.phone_number,
            description: 'ok',
            message: {
              'id': '123'
            }
          }

          described_class.new(params: params, inbox: sms_channel.inbox).perform
          expect(conversation.reload.messages.last.status).to eq('sent')
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Sms::IncomingMessageService
  include ::FileTypeHelper

  pattr_initialize [:inbox!, :params!]

  def perform
    set_contact
    set_conversation
    @message = @conversation.messages.create!(
      content: params[:text],
      account_id: @inbox.account_id,
      inbox_id: @inbox.id,
      message_type: :incoming,
      sender: @contact,
      source_id: params[:id]
    )
    attach_files
    @message.save!
  end

  private

  def account
    @account ||= @inbox.account
  end

  def channel
    @channel ||= @inbox.channel
  end

  def phone_number
    params[:from]
  end

  def formatted_phone_number
    TelephoneNumber.parse(phone_number).international_number
  end

  def set_contact
    contact_inbox = ::ContactInboxWithContactBuilder.new(
      source_id: params[:from],
      inbox: @inbox,
      contact_attributes: contact_attributes
    ).perform

    @contact_inbox = contact_inbox
    @contact = contact_inbox.contact
  end

  def conversation_params
    {
      account_id: @inbox.account_id,
      inbox_id: @inbox.id,
      contact_id: @contact.id,
      contact_inbox_id: @contact_inbox.id
    }
  end

  def set_conversation
    # if lock to single conversation is disabled, we will create a new conversation if previous conversation is resolved
    @conversation = if @inbox.lock_to_single_conversation
                      @contact_inbox.conversations.last
                    else
                      @contact_inbox.conversations.where
                                    .not(status: :resolved).last
                    end
    return if @conversation

    @conversation = ::Conversation.create!(conversation_params)
  end

  def contact_attributes
    {
      name: formatted_phone_number,
      phone_number: phone_number
    }
  end

  def attach_files
    return if params[:media].blank?

    params[:media].each do |media_url|
      # we don't need to process this files since chatwoot doesn't support it
      next if media_url.end_with?('.smil', '.xml')

      attachment_file = Down.download(
        media_url,
        http_basic_authentication: [channel.provider_config['api_key'], channel.provider_config['api_secret']]
      )

      @message.attachments.new(
        account_id: @message.account_id,
        file_type: file_type(attachment_file.content_type),
        file: {
          io: attachment_file,
          filename: attachment_file.original_filename,
          content_type: attachment_file.content_type
        }
      )
    end
  end
end

```","require 'rails_helper'

describe Sms::IncomingMessageService do
  describe '#perform' do
    let!(:sms_channel) { create(:channel_sms) }
    let(:params) do
      {

        'id': '3232420-2323-234324',
        'owner': sms_channel.phone_number,
        'applicationId': '2342349-324234d-32432432',
        'time': '2022-02-02T23:14:05.262Z',
        'segmentCount': 1,
        'direction': 'in',
        'to': [
          sms_channel.phone_number
        ],
        'from': '+14234234234',
        'text': 'test message'

      }.with_indifferent_access
    end

    context 'when valid text message params' do
      it 'creates appropriate conversations, message and contacts' do
        described_class.new(inbox: sms_channel.inbox, params: params).perform
        expect(sms_channel.inbox.conversations.count).not_to eq(0)
        expect(Contact.all.first.name).to eq('+1 423-423-4234')
        expect(sms_channel.inbox.messages.first.content).to eq(params[:text])
      end

      it 'appends to last conversation when if conversation already exisits' do
        contact_inbox = create(:contact_inbox, inbox: sms_channel.inbox, source_id: params[:from])
        2.times.each { create(:conversation, inbox: sms_channel.inbox, contact_inbox: contact_inbox) }
        last_conversation = create(:conversation, inbox: sms_channel.inbox, contact_inbox: contact_inbox)
        described_class.new(inbox: sms_channel.inbox, params: params).perform
        # no new conversation should be created
        expect(sms_channel.inbox.conversations.count).to eq(3)
        # message appended to the last conversation
        expect(last_conversation.messages.last.content).to eq(params[:text])
      end

      it 'reopen last conversation if last conversation is resolved and lock to single conversation is enabled' do
        sms_channel.inbox.update(lock_to_single_conversation: true)
        contact_inbox = create(:contact_inbox, inbox: sms_channel.inbox, source_id: params[:from])
        last_conversation = create(:conversation, inbox: sms_channel.inbox, contact_inbox: contact_inbox)
        last_conversation.update(status: 'resolved')
        described_class.new(inbox: sms_channel.inbox, params: params).perform
        # no new conversation should be created
        expect(sms_channel.inbox.conversations.count).to eq(1)
        expect(sms_channel.inbox.conversations.open.last.messages.last.content).to eq(params[:text])
        expect(sms_channel.inbox.conversations.open.last.status).to eq('open')
      end

      it 'creates a new conversation if last conversation is resolved and lock to single conversation is disabled' do
        sms_channel.inbox.update(lock_to_single_conversation: false)
        contact_inbox = create(:contact_inbox, inbox: sms_channel.inbox, source_id: params[:from])
        last_conversation = create(:conversation, inbox: sms_channel.inbox, contact_inbox: contact_inbox)
        last_conversation.update(status: 'resolved')
        described_class.new(inbox: sms_channel.inbox, params: params).perform
        # new conversation should be created
        expect(sms_channel.inbox.conversations.count).to eq(2)
        # message appended to the last conversation
        expect(contact_inbox.conversations.last.messages.last.content).to eq(params[:text])
      end

      it 'will not create a new conversation if last conversation is not resolved and lock to single conversation is disabled' do
        sms_channel.inbox.update(lock_to_single_conversation: false)
        contact_inbox = create(:contact_inbox, inbox: sms_channel.inbox, source_id: params[:from])
        last_conversation = create(:conversation, inbox: sms_channel.inbox, contact_inbox: contact_inbox)
        last_conversation.update(status: Conversation.statuses.except('resolved').keys.sample)
        described_class.new(inbox: sms_channel.inbox, params: params).perform
        # new conversation should be created
        expect(sms_channel.inbox.conversations.count).to eq(1)
        # message appended to the last conversation
        expect(contact_inbox.conversations.last.messages.last.content).to eq(params[:text])
      end

      it 'creates attachment messages and ignores .smil files' do
        stub_request(:get, 'http://test.com/test.png').to_return(status: 200, body: File.read('spec/assets/sample.png'), headers: {})
        stub_request(:get, 'http://test.com/test2.png').to_return(status: 200, body: File.read('spec/assets/sample.png'), headers: {})

        media_params = { 'media': [
          'http://test.com/test.smil',
          'http://test.com/test.png',
          'http://test.com/test2.png'
        ] }.with_indifferent_access

        described_class.new(inbox: sms_channel.inbox, params: params.merge(media_params)).perform
        expect(sms_channel.inbox.conversations.count).not_to eq(0)
        expect(Contact.all.first.name).to eq('+1 423-423-4234')
        expect(sms_channel.inbox.messages.first.content).to eq('test message')
        expect(sms_channel.inbox.messages.first.attachments.present?).to be true
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Sms::SendOnSmsService < Base::SendOnChannelService
  private

  def channel_class
    Channel::Sms
  end

  def perform_reply
    send_on_sms
  end

  def send_on_sms
    message_id = channel.send_message(message.conversation.contact_inbox.source_id, message)
    message.update!(source_id: message_id) if message_id.present?
  end
end

```","require 'rails_helper'

describe Sms::SendOnSmsService do
  describe '#perform' do
    context 'when a valid message' do
      let(:sms_request) { double }
      let!(:sms_channel) { create(:channel_sms) }
      let!(:contact_inbox) { create(:contact_inbox, inbox: sms_channel.inbox, source_id: '+123456789') }
      let!(:conversation) { create(:conversation, contact_inbox: contact_inbox, inbox: sms_channel.inbox) }

      it 'calls channel.send_message' do
        message = create(:message, message_type: :outgoing, content: 'test',
                                   conversation: conversation)
        allow(HTTParty).to receive(:post).and_return(sms_request)
        allow(sms_request).to receive(:success?).and_return(true)
        allow(sms_request).to receive(:parsed_response).and_return({ 'id' => '123456789' })
        expect(HTTParty).to receive(:post).with(
          'https://messaging.bandwidth.com/api/v2/users/1/messages',
          basic_auth: { username: '1', password: '1' },
          headers: { 'Content-Type' => 'application/json' },
          body: { 'to' => '+123456789', 'from' => sms_channel.phone_number, 'text' => 'test', 'applicationId' => '1' }.to_json
        )
        described_class.new(message: message).perform
        expect(message.reload.source_id).to eq('123456789')
      end

      it 'calls channel.send_message with attachments' do
        message = build(:message, message_type: :outgoing, content: 'test',
                                  conversation: conversation)
        attachment = message.attachments.new(account_id: message.account_id, file_type: :image)
        attachment.file.attach(io: Rails.root.join('spec/assets/avatar.png').open, filename: 'avatar.png', content_type: 'image/png')
        attachment2 = message.attachments.new(account_id: message.account_id, file_type: :image)
        attachment2.file.attach(io: Rails.root.join('spec/assets/avatar.png').open, filename: 'avatar.png', content_type: 'image/png')
        message.save!

        allow(HTTParty).to receive(:post).and_return(sms_request)
        allow(sms_request).to receive(:success?).and_return(true)
        allow(sms_request).to receive(:parsed_response).and_return({ 'id' => '123456789' })
        allow(attachment).to receive(:download_url).and_return('url1')
        allow(attachment2).to receive(:download_url).and_return('url2')
        expect(HTTParty).to receive(:post).with(
          'https://messaging.bandwidth.com/api/v2/users/1/messages',
          basic_auth: { username: '1', password: '1' },
          headers: { 'Content-Type' => 'application/json' },
          body: { 'to' => '+123456789', 'from' => sms_channel.phone_number, 'text' => 'test', 'applicationId' => '1',
                  'media' => %w[url1 url2] }.to_json
        )
        described_class.new(message: message).perform
        expect(message.reload.source_id).to eq('123456789')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Sms::OneoffSmsCampaignService
  pattr_initialize [:campaign!]

  def perform
    raise ""Invalid campaign #{campaign.id}"" if campaign.inbox.inbox_type != 'Sms' || !campaign.one_off?
    raise 'Completed Campaign' if campaign.completed?

    # marks campaign completed so that other jobs won't pick it up
    campaign.completed!

    audience_label_ids = campaign.audience.select { |audience| audience['type'] == 'Label' }.pluck('id')
    audience_labels = campaign.account.labels.where(id: audience_label_ids).pluck(:title)
    process_audience(audience_labels)
  end

  private

  delegate :inbox, to: :campaign
  delegate :channel, to: :inbox

  def process_audience(audience_labels)
    campaign.account.contacts.tagged_with(audience_labels, any: true).each do |contact|
      next if contact.phone_number.blank?

      send_message(to: contact.phone_number, content: campaign.message)
    end
  end

  def send_message(to:, content:)
    channel.send_text_message(to, content)
  end
end

```","require 'rails_helper'

describe Sms::OneoffSmsCampaignService do
  subject(:sms_campaign_service) { described_class.new(campaign: campaign) }

  let(:account) { create(:account) }
  let!(:sms_channel) { create(:channel_sms) }
  let!(:sms_inbox) { create(:inbox, channel: sms_channel) }
  let(:label1) { create(:label, account: account) }
  let(:label2) { create(:label, account: account) }
  let!(:campaign) do
    create(:campaign, inbox: sms_inbox, account: account,
                      audience: [{ type: 'Label', id: label1.id }, { type: 'Label', id: label2.id }])
  end

  describe 'perform' do
    before do
      stub_request(:post, 'https://messaging.bandwidth.com/api/v2/users/1/messages').to_return(
        status: 200,
        body: { 'id' => '1' }.to_json,
        headers: {}
      )
    end

    it 'raises error if the campaign is completed' do
      campaign.completed!

      expect { sms_campaign_service.perform }.to raise_error 'Completed Campaign'
    end

    it 'raises error invalid campaign when its not a oneoff sms campaign' do
      campaign = create(:campaign)

      expect { described_class.new(campaign: campaign).perform }.to raise_error ""Invalid campaign #{campaign.id}""
    end

    it 'send messages to contacts in the audience and marks the campaign completed' do
      contact_with_label1, contact_with_label2, contact_with_both_labels = FactoryBot.create_list(:contact, 3, :with_phone_number, account: account)
      contact_with_label1.update_labels([label1.title])
      contact_with_label2.update_labels([label2.title])
      contact_with_both_labels.update_labels([label1.title, label2.title])
      sms_campaign_service.perform
      assert_requested(:post, 'https://messaging.bandwidth.com/api/v2/users/1/messages', times: 3)
      expect(campaign.reload.completed?).to be true
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Notification::PushNotificationService
  include Rails.application.routes.url_helpers

  pattr_initialize [:notification!]

  def perform
    return unless user_subscribed_to_notification?

    notification_subscriptions.each do |subscription|
      send_browser_push(subscription)
      send_fcm_push(subscription)
      send_push_via_chatwoot_hub(subscription)
    end
  end

  private

  delegate :user, to: :notification
  delegate :notification_subscriptions, to: :user
  delegate :notification_settings, to: :user

  def user_subscribed_to_notification?
    notification_setting = notification_settings.find_by(account_id: notification.account.id)
    return true if notification_setting.public_send(""push_#{notification.notification_type}?"")

    false
  end

  def conversation
    @conversation ||= notification.conversation
  end

  def push_message
    {
      title: notification.push_message_title,
      tag: ""#{notification.notification_type}_#{conversation.display_id}_#{notification.id}"",
      url: push_url
    }
  end

  def push_url
    app_account_conversation_url(account_id: conversation.account_id, id: conversation.display_id)
  end

  def send_browser_push?(subscription)
    VapidService.public_key && subscription.browser_push?
  end

  def send_browser_push(subscription)
    return unless send_browser_push?(subscription)

    WebPush.payload_send(
      message: JSON.generate(push_message),
      endpoint: subscription.subscription_attributes['endpoint'],
      p256dh: subscription.subscription_attributes['p256dh'],
      auth: subscription.subscription_attributes['auth'],
      vapid: {
        subject: push_url,
        public_key: VapidService.public_key,
        private_key: VapidService.private_key
      },
      ssl_timeout: 5,
      open_timeout: 5,
      read_timeout: 5
    )
  rescue WebPush::ExpiredSubscription
    subscription.destroy!
  rescue Errno::ECONNRESET, Net::OpenTimeout, Net::ReadTimeout => e
    Rails.logger.error ""WebPush operation error: #{e.message}""
  end

  def send_fcm_push(subscription)
    return unless ENV['FCM_SERVER_KEY']
    return unless subscription.fcm?

    fcm = FCM.new(ENV.fetch('FCM_SERVER_KEY', nil))
    response = fcm.send([subscription.subscription_attributes['push_token']], fcm_options)
    remove_subscription_if_error(subscription, response)
  end

  def send_push_via_chatwoot_hub(subscription)
    return if ENV['FCM_SERVER_KEY']
    return unless ActiveModel::Type::Boolean.new.cast(ENV.fetch('ENABLE_PUSH_RELAY_SERVER', true))
    return unless subscription.fcm?

    ChatwootHub.send_browser_push([subscription.subscription_attributes['push_token']], fcm_options)
  end

  def remove_subscription_if_error(subscription, response)
    subscription.destroy! if JSON.parse(response[:body])['results']&.first&.keys&.include?('error')
  end

  def fcm_options
    {
      notification: {
        title: notification.notification_type.titleize,
        body: notification.push_message_title,
        sound: 'default'
      },
      android: { priority: 'high' },
      data: { notification: notification.fcm_push_data.to_json },
      collapse_key: ""chatwoot_#{notification.primary_actor_type.downcase}_#{notification.primary_actor_id}""
    }
  end
end

```","require 'rails_helper'

describe Notification::PushNotificationService do
  let!(:account) { create(:account) }
  let!(:user) { create(:user, account: account) }
  let!(:notification) { create(:notification, user: user, account: user.accounts.first) }
  let(:fcm_double) { double }

  before do
    allow(WebPush).to receive(:payload_send).and_return(true)
    allow(FCM).to receive(:new).and_return(fcm_double)
    allow(fcm_double).to receive(:send).and_return({ body: { 'results': [] }.to_json })
  end

  describe '#perform' do
    it 'sends webpush notifications for webpush subscription' do
      with_modified_env VAPID_PUBLIC_KEY: 'test' do
        create(:notification_subscription, user: notification.user)

        described_class.new(notification: notification).perform
        expect(WebPush).to have_received(:payload_send)
        expect(FCM).not_to have_received(:new)
      end
    end

    it 'sends a fcm notification for firebase subscription' do
      with_modified_env FCM_SERVER_KEY: 'test', ENABLE_PUSH_RELAY_SERVER: 'false' do
        create(:notification_subscription, user: notification.user, subscription_type: 'fcm')

        described_class.new(notification: notification).perform
        expect(FCM).to have_received(:new)
        expect(WebPush).not_to have_received(:payload_send)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# refer: https://gitlab.com/gitlab-org/ruby/gems/gitlab-mail_room/-/blob/master/lib/mail_room/microsoft_graph/connection.rb
# refer: https://github.com/microsoftgraph/msgraph-sample-rubyrailsapp/tree/b4a6869fe4a438cde42b161196484a929f1bee46
# https://learn.microsoft.com/en-us/azure/active-directory/develop/active-directory-configurable-token-lifetimes
class Microsoft::RefreshOauthTokenService
  pattr_initialize [:channel!]

  # if the token is not expired yet then skip the refresh token step
  def access_token
    provider_config = channel.provider_config.with_indifferent_access
    if Time.current.utc >= expires_on(provider_config['expires_on'])
      # Token expired, refresh
      new_hash = refresh_tokens
      new_hash[:access_token]
    else
      provider_config[:access_token]
    end
  end

  def expires_on(expiry)
    # we will give it a 5 minute gap for safety
    expiry.presence ? DateTime.parse(expiry) - 5.minutes : Time.current.utc
  end

  # <RefreshTokensSnippet>
  def refresh_tokens
    token_hash = channel.provider_config.with_indifferent_access
    oauth_strategy = ::MicrosoftGraphAuth.new(
      nil, ENV.fetch('AZURE_APP_ID', nil), ENV.fetch('AZURE_APP_SECRET', nil)
    )

    token_service = OAuth2::AccessToken.new(
      oauth_strategy.client, token_hash['access_token'],
      refresh_token: token_hash['refresh_token']
    )

    # Refresh the tokens
    new_tokens = token_service.refresh!.to_hash.slice(:access_token, :refresh_token, :expires_at)

    update_channel_provider_config(new_tokens)
    channel.provider_config
  end
  # </RefreshTokensSnippet>

  def update_channel_provider_config(new_tokens)
    new_tokens = new_tokens.with_indifferent_access
    channel.provider_config = {
      access_token: new_tokens[:access_token],
      refresh_token: new_tokens[:refresh_token],
      expires_on: Time.at(new_tokens[:expires_at]).utc.to_s
    }
    channel.save!
  end
end

```","require 'rails_helper'

RSpec.describe Microsoft::RefreshOauthTokenService do
  let(:access_token) { SecureRandom.hex }
  let(:refresh_token) { SecureRandom.hex }
  let(:expires_on) { Time.zone.now + 3600 }

  let!(:microsoft_email_channel) do
    create(:channel_email, provider_config: { access_token: access_token, refresh_token: refresh_token, expires_on: expires_on })
  end
  let(:new_tokens) { { access_token: access_token, refresh_token: refresh_token, expires_at: expires_on.to_i, token_type: 'bearer' } }

  describe '#access_token' do
    context 'when token is not expired' do
      it 'returns the existing access token' do
        expect(described_class.new(channel: microsoft_email_channel).access_token).to eq(access_token)
        expect(microsoft_email_channel.reload.provider_config['refresh_token']).to eq(refresh_token)
      end
    end

    context 'when token is expired' do
      let(:expires_on) { 1.minute.from_now }

      before do
        stub_request(:post, 'https://login.microsoftonline.com/common/oauth2/v2.0/token').with(
          body: { 'grant_type' => 'refresh_token', 'refresh_token' => refresh_token }
        ).to_return(status: 200, body: new_tokens.to_json, headers: { 'Content-Type' => 'application/json' })
      end

      it 'fetches new access token and refresh tokens' do
        microsoft_email_channel.provider_config['expires_on'] = Time.zone.now - 3600
        microsoft_email_channel.save!

        expect(described_class.new(channel: microsoft_email_channel).access_token).not_to eq(access_token)
        expect(microsoft_email_channel.reload.provider_config['access_token']).to eq(new_tokens[:access_token])
        expect(microsoft_email_channel.reload.provider_config['refresh_token']).to eq(new_tokens[:refresh_token])
        expect(microsoft_email_channel.reload.provider_config['expires_on']).to eq(Time.at(new_tokens[:expires_at]).utc.to_s)
      end
    end

    context 'when refresh token is not present in provider config and access token is expired' do
      it 'throws an error' do
        microsoft_email_channel.update(provider_config: {
                                         access_token: access_token,
                                         expires_on: expires_on - 3600
                                       })
        expect do
          described_class.new(channel: microsoft_email_channel).access_token
        end.to raise_error(RuntimeError, 'A refresh_token is not available')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Contacts::ContactableInboxesService
  pattr_initialize [:contact!]

  def get
    account = contact.account
    account.inboxes.filter_map { |inbox| get_contactable_inbox(inbox) }
  end

  private

  def get_contactable_inbox(inbox)
    case inbox.channel_type
    when 'Channel::TwilioSms'
      twilio_contactable_inbox(inbox)
    when 'Channel::Whatsapp'
      whatsapp_contactable_inbox(inbox)
    when 'Channel::Sms'
      sms_contactable_inbox(inbox)
    when 'Channel::Email'
      email_contactable_inbox(inbox)
    when 'Channel::Api'
      api_contactable_inbox(inbox)
    when 'Channel::WebWidget'
      website_contactable_inbox(inbox)
    end
  end

  def website_contactable_inbox(inbox)
    latest_contact_inbox = inbox.contact_inboxes.where(contact: @contact).last
    return unless latest_contact_inbox
    # FIXME : change this when multiple conversations comes in
    return if latest_contact_inbox.conversations.present?

    { source_id: latest_contact_inbox.source_id, inbox: inbox }
  end

  def api_contactable_inbox(inbox)
    latest_contact_inbox = inbox.contact_inboxes.where(contact: @contact).last
    source_id = latest_contact_inbox&.source_id || SecureRandom.uuid

    { source_id: source_id, inbox: inbox }
  end

  def email_contactable_inbox(inbox)
    return unless @contact.email

    { source_id: @contact.email, inbox: inbox }
  end

  def whatsapp_contactable_inbox(inbox)
    return unless @contact.phone_number

    # Remove the plus since thats the format 360 dialog uses
    { source_id: @contact.phone_number.delete('+'), inbox: inbox }
  end

  def sms_contactable_inbox(inbox)
    return unless @contact.phone_number

    { source_id: @contact.phone_number, inbox: inbox }
  end

  def twilio_contactable_inbox(inbox)
    return if @contact.phone_number.blank?

    case inbox.channel.medium
    when 'sms'
      { source_id: @contact.phone_number, inbox: inbox }
    when 'whatsapp'
      { source_id: ""whatsapp:#{@contact.phone_number}"", inbox: inbox }
    end
  end
end

```","require 'rails_helper'

describe Contacts::ContactableInboxesService do
  before do
    stub_request(:post, /graph.facebook.com/)
  end

  let(:account) { create(:account) }
  let(:contact) { create(:contact, account: account, email: 'contact@example.com', phone_number: '+2320000') }
  let!(:twilio_sms) { create(:channel_twilio_sms, account: account) }
  let!(:twilio_sms_inbox) { create(:inbox, channel: twilio_sms, account: account) }
  let!(:twilio_whatsapp) { create(:channel_twilio_sms, medium: :whatsapp, account: account) }
  let!(:twilio_whatsapp_inbox) { create(:inbox, channel: twilio_whatsapp, account: account) }
  let!(:email_channel) { create(:channel_email, account: account) }
  let!(:email_inbox) { create(:inbox, channel: email_channel, account: account) }
  let!(:api_channel) { create(:channel_api, account: account) }
  let!(:api_inbox) { create(:inbox, channel: api_channel, account: account) }
  let!(:website_inbox) { create(:inbox, channel: create(:channel_widget, account: account), account: account) }
  let!(:sms_inbox) { create(:inbox, channel: create(:channel_sms, account: account), account: account) }

  describe '#get' do
    it 'returns the contactable inboxes for the contact' do
      contactable_inboxes = described_class.new(contact: contact).get

      expect(contactable_inboxes).to include({ source_id: contact.phone_number, inbox: twilio_sms_inbox })
      expect(contactable_inboxes).to include({ source_id: ""whatsapp:#{contact.phone_number}"", inbox: twilio_whatsapp_inbox })
      expect(contactable_inboxes).to include({ source_id: contact.email, inbox: email_inbox })
      expect(contactable_inboxes).to include({ source_id: contact.phone_number, inbox: sms_inbox })
    end

    it 'doest not return the non contactable inboxes for the contact' do
      facebook_channel = create(:channel_facebook_page, account: account)
      facebook_inbox = create(:inbox, channel: facebook_channel, account: account)
      twitter_channel = create(:channel_twitter_profile, account: account)
      twitter_inbox = create(:inbox, channel: twitter_channel, account: account)

      contactable_inboxes = described_class.new(contact: contact).get

      expect(contactable_inboxes.pluck(:inbox)).not_to include(website_inbox)
      expect(contactable_inboxes.pluck(:inbox)).not_to include(facebook_inbox)
      expect(contactable_inboxes.pluck(:inbox)).not_to include(twitter_inbox)
    end

    context 'when api inbox is available' do
      it 'returns existing source id if contact inbox exists' do
        contact_inbox = create(:contact_inbox, inbox: api_inbox, contact: contact)

        contactable_inboxes = described_class.new(contact: contact).get
        expect(contactable_inboxes).to include({ source_id: contact_inbox.source_id, inbox: api_inbox })
      end
    end

    context 'when website inbox is available' do
      it 'returns existing source id if contact inbox exists without any conversations' do
        contact_inbox = create(:contact_inbox, inbox: website_inbox, contact: contact)

        contactable_inboxes = described_class.new(contact: contact).get
        expect(contactable_inboxes).to include({ source_id: contact_inbox.source_id, inbox: website_inbox })
      end

      it 'does not return existing source id if contact inbox exists with conversations' do
        contact_inbox = create(:contact_inbox, inbox: website_inbox, contact: contact)
        create(:conversation, contact: contact, inbox: website_inbox, contact_inbox: contact_inbox)

        contactable_inboxes = described_class.new(contact: contact).get
        expect(contactable_inboxes.pluck(:inbox)).not_to include(website_inbox)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Contacts::FilterService < FilterService
  ATTRIBUTE_MODEL = 'contact_attribute'.freeze

  def perform
    @contacts = contact_query_builder

    {
      contacts: @contacts,
      count: @contacts.count
    }
  end

  def contact_query_builder
    contact_filters = @filters['contacts']

    @params[:payload].each_with_index do |query_hash, current_index|
      current_filter = contact_filters[query_hash['attribute_key']]
      @query_string += contact_query_string(current_filter, query_hash, current_index)
    end

    base_relation.where(@query_string, @filter_values.with_indifferent_access)
  end

  def contact_query_string(current_filter, query_hash, current_index)
    attribute_key = query_hash[:attribute_key]
    query_operator = query_hash[:query_operator]
    filter_operator_value = filter_operation(query_hash, current_index)

    return custom_attribute_query(query_hash, 'contact_attribute', current_index) if current_filter.nil?

    case current_filter['attribute_type']
    when 'additional_attributes'
      ""  LOWER(contacts.additional_attributes ->> '#{attribute_key}') #{filter_operator_value} #{query_operator} ""
    when 'date_attributes'
      "" (contacts.#{attribute_key})::#{current_filter['data_type']} #{filter_operator_value}#{current_filter['data_type']} #{query_operator} ""
    when 'standard'
      if attribute_key == 'labels'
        "" #{tag_filter_query('Contact', 'contacts', query_hash, current_index)} ""
      else
        "" LOWER(contacts.#{attribute_key}) #{filter_operator_value} #{query_operator} ""
      end
    end
  end

  def filter_values(query_hash)
    current_val = query_hash['values'][0]
    if query_hash['attribute_key'] == 'phone_number'
      ""+#{current_val}""
    elsif query_hash['attribute_key'] == 'country_code'
      current_val.downcase
    else
      current_val.is_a?(String) ? current_val.downcase : current_val
    end
  end

  def base_relation
    Current.account.contacts
  end

  private

  def equals_to_filter_string(filter_operator, current_index)
    return ""= :value_#{current_index}"" if filter_operator == 'equal_to'

    ""!= :value_#{current_index}""
  end
end

```","require 'rails_helper'

describe Contacts::FilterService do
  subject(:filter_service) { described_class }

  let!(:account) { create(:account) }
  let!(:first_user) { create(:user, account: account) }
  let!(:second_user) { create(:user, account: account) }
  let!(:inbox) { create(:inbox, account: account, enable_auto_assignment: false) }
  let(:en_contact) { create(:contact, account: account, additional_attributes: { 'browser_language': 'en' }) }
  let(:el_contact) { create(:contact, account: account, additional_attributes: { 'browser_language': 'el' }) }
  let(:cs_contact) { create(:contact, account: account, additional_attributes: { 'browser_language': 'cs' }) }

  before do
    create(:inbox_member, user: first_user, inbox: inbox)
    create(:inbox_member, user: second_user, inbox: inbox)
    create(:conversation, account: account, inbox: inbox, assignee: first_user, contact: en_contact)
    create(:conversation, account: account, inbox: inbox, contact: el_contact)
    Current.account = account

    create(:custom_attribute_definition,
           attribute_key: 'contact_additional_information',
           account: account,
           attribute_model: 'contact_attribute',
           attribute_display_type: 'text')
    create(:custom_attribute_definition,
           attribute_key: 'customer_type',
           account: account,
           attribute_model: 'contact_attribute',
           attribute_display_type: 'list',
           attribute_values: %w[regular platinum gold])
    create(:custom_attribute_definition,
           attribute_key: 'signed_in_at',
           account: account,
           attribute_model: 'contact_attribute',
           attribute_display_type: 'date')
  end

  describe '#perform' do
    before do
      en_contact.update_labels(%w[random_label support])
      cs_contact.update_labels('support')

      en_contact.update!(custom_attributes: { contact_additional_information: 'test custom data' })
      el_contact.update!(custom_attributes: { contact_additional_information: 'test custom data', customer_type: 'platinum' })
      cs_contact.update!(custom_attributes: { customer_type: 'platinum', signed_in_at: '2022-01-19' })
    end

    context 'with query present' do
      let!(:params) { { payload: [], page: 1 } }
      let(:payload) do
        [
          {
            attribute_key: 'browser_language',
            filter_operator: 'equal_to',
            values: ['en'],
            query_operator: nil
          }.with_indifferent_access
        ]
      end

      context 'with label filter' do
        it 'returns equal_to filter results properly' do
          params[:payload] = [
            {
              attribute_key: 'labels',
              filter_operator: 'equal_to',
              values: ['support'],
              query_operator: nil
            }.with_indifferent_access
          ]

          result = filter_service.new(params, first_user).perform
          expect(result[:contacts].length).to be 2
          expect(result[:contacts].first.label_list).to include('support')
          expect(result[:contacts].last.label_list).to include('support')
        end

        it 'returns not_equal_to filter results properly' do
          params[:payload] = [
            {
              attribute_key: 'labels',
              filter_operator: 'not_equal_to',
              values: ['support'],
              query_operator: nil
            }.with_indifferent_access
          ]

          result = filter_service.new(params, first_user).perform
          expect(result[:contacts].length).to be 1
          expect(result[:contacts].first.id).to eq el_contact.id
        end

        it 'returns is_present filter results properly' do
          params[:payload] = [
            {
              attribute_key: 'labels',
              filter_operator: 'is_present',
              values: [],
              query_operator: nil
            }.with_indifferent_access
          ]

          result = filter_service.new(params, first_user).perform
          expect(result[:contacts].length).to be 2
          expect(result[:contacts].first.label_list).to include('support')
          expect(result[:contacts].last.label_list).to include('support')
        end

        it 'returns is_not_present filter results properly' do
          params[:payload] = [
            {
              attribute_key: 'labels',
              filter_operator: 'is_not_present',
              values: [],
              query_operator: nil
            }.with_indifferent_access
          ]

          result = filter_service.new(params, first_user).perform
          expect(result[:contacts].length).to be 1
          expect(result[:contacts].first.id).to eq el_contact.id
        end
      end

      it 'filter contacts by additional_attributes' do
        params[:payload] = payload
        result = filter_service.new(params, first_user).perform
        expect(result[:count]).to be 1
        expect(result[:contacts].first.id).to eq(en_contact.id)
      end

      it 'filter contacts by name' do
        params[:payload] = [
          {
            attribute_key: 'name',
            filter_operator: 'equal_to',
            values: [en_contact.name],
            query_operator: nil
          }.with_indifferent_access
        ]

        result = filter_service.new(params, first_user).perform
        expect(result[:count]).to be 1
        expect(result[:contacts].length).to be 1
        expect(result[:contacts].first.name).to eq(en_contact.name)
      end

      it 'filter by custom_attributes and labels' do
        params[:payload] = [
          {
            attribute_key: 'customer_type',
            filter_operator: 'equal_to',
            values: ['platinum'],
            query_operator: 'AND'
          }.with_indifferent_access,
          {
            attribute_key: 'labels',
            filter_operator: 'equal_to',
            values: ['support'],
            query_operator: 'AND'
          }.with_indifferent_access,
          {
            attribute_key: 'signed_in_at',
            filter_operator: 'is_less_than',
            values: ['2022-01-20'],
            query_operator: nil
          }.with_indifferent_access
        ]
        result = filter_service.new(params, first_user).perform
        expect(result[:contacts].length).to be 1
        expect(result[:contacts].first.id).to eq(cs_contact.id)
      end

      it 'filter by custom_attributes and additional_attributes' do
        params[:payload] = [
          {
            attribute_key: 'customer_type',
            filter_operator: 'equal_to',
            values: ['platinum'],
            query_operator: 'AND'
          }.with_indifferent_access,
          {
            attribute_key: 'browser_language',
            filter_operator: 'equal_to',
            values: ['el'],
            query_operator: 'AND'
          }.with_indifferent_access,
          {
            attribute_key: 'contact_additional_information',
            filter_operator: 'equal_to',
            values: ['test custom data'],
            query_operator: nil
          }.with_indifferent_access
        ]
        result = filter_service.new(params, first_user).perform
        expect(result[:contacts].length).to be 1
        expect(result[:contacts].first.id).to eq(el_contact.id)
      end

      it 'filter by created_at and custom_attributes' do
        tomorrow = Date.tomorrow.strftime
        params[:payload] = [
          {
            attribute_key: 'customer_type',
            filter_operator: 'equal_to',
            values: ['platinum'],
            query_operator: 'AND'
          }.with_indifferent_access,
          {
            attribute_key: 'created_at',
            filter_operator: 'is_less_than',
            values: [tomorrow.to_s],
            query_operator: nil
          }.with_indifferent_access
        ]
        result = filter_service.new(params, first_user).perform
        expected_count = Contact.where(""created_at < ? AND custom_attributes->>'customer_type' = ?"", Date.tomorrow, 'platinum').count

        expect(result[:contacts].length).to be expected_count
        expect(result[:contacts].pluck(:id)).to include(el_contact.id)
      end

      context 'with x_days_before filter' do
        before do
          Time.zone = 'UTC'
          el_contact.update(last_activity_at: (Time.zone.today - 4.days))
          cs_contact.update(last_activity_at: (Time.zone.today - 5.days))
          en_contact.update(last_activity_at: (Time.zone.today - 2.days))
        end

        it 'filter by last_activity_at 3_days_before and custom_attributes' do
          params[:payload] = [
            {
              attribute_key: 'last_activity_at',
              filter_operator: 'days_before',
              values: [3],
              query_operator: 'AND'
            }.with_indifferent_access,
            {
              attribute_key: 'contact_additional_information',
              filter_operator: 'equal_to',
              values: ['test custom data'],
              query_operator: nil
            }.with_indifferent_access
          ]

          expected_count = Contact.where(
            ""last_activity_at < ? AND
            custom_attributes->>'contact_additional_information' = ?"",
            (Time.zone.today - 3.days),
            'test custom data'
          ).count

          result = filter_service.new(params, first_user).perform
          expect(result[:contacts].length).to be expected_count
          expect(result[:contacts].first.id).to eq(el_contact.id)
        end

        it 'filter by last_activity_at 2_days_before and custom_attributes' do
          params[:payload] = [
            {
              attribute_key: 'last_activity_at',
              filter_operator: 'days_before',
              values: [2],
              query_operator: nil
            }.with_indifferent_access
          ]

          expected_count = Contact.where('last_activity_at < ?', (Time.zone.today - 2.days)).count

          result = filter_service.new(params, first_user).perform
          expect(result[:contacts].length).to be expected_count
          expect(result[:contacts].pluck(:id)).to include(el_contact.id)
          expect(result[:contacts].pluck(:id)).to include(cs_contact.id)
          expect(result[:contacts].pluck(:id)).not_to include(en_contact.id)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Labels::UpdateService
  pattr_initialize [:new_label_title!, :old_label_title!, :account_id!]

  def perform
    tagged_conversations.find_in_batches do |conversation_batch|
      conversation_batch.each do |conversation|
        conversation.label_list.remove(old_label_title)
        conversation.label_list.add(new_label_title)
        conversation.save!
      end
    end

    tagged_contacts.find_in_batches do |contact_batch|
      contact_batch.each do |contact|
        contact.label_list.remove(old_label_title)
        contact.label_list.add(new_label_title)
        contact.save!
      end
    end
  end

  private

  def tagged_conversations
    account.conversations.tagged_with(old_label_title)
  end

  def tagged_contacts
    account.contacts.tagged_with(old_label_title)
  end

  def account
    @account ||= Account.find(account_id)
  end
end

```","require 'rails_helper'

describe Labels::UpdateService do
  let(:account) { create(:account) }
  let(:conversation) { create(:conversation, account: account) }
  let(:label) { create(:label, account: account) }
  let(:contact) { conversation.contact }

  before do
    conversation.label_list.add(label.title)
    conversation.save!

    contact.label_list.add(label.title)
    contact.save!
  end

  describe '#perform' do
    it 'updates associated conversations/contacts labels' do
      expect(conversation.label_list).to eq([label.title])
      expect(contact.label_list).to eq([label.title])

      described_class.new(
        new_label_title: 'updated-label-title',
        old_label_title: label.title,
        account_id: account.id
      ).perform

      expect(conversation.reload.label_list).to eq(['updated-label-title'])
      expect(contact.reload.label_list).to eq(['updated-label-title'])
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Internal::RemoveStaleContactInboxesService
  def perform
    return unless remove_stale_contact_inbox_job_enabled?

    time_period = 90.days.ago
    contact_inboxes_to_delete = stale_contact_inboxes(time_period)

    log_stale_contact_inboxes_deletion(contact_inboxes_to_delete, time_period)

    # Since the number of records to delete is very high,
    # delete_all would be faster than destroy_all since it operates at database level
    # and avoid loading all the records in memory
    # Transaction and batching is used to avoid deadlock and memory issues
    ContactInbox.transaction do
      contact_inboxes_to_delete
        .find_in_batches(batch_size: 10_000) do |group|
          ContactInbox.where(id: group.map(&:id)).delete_all
        end
    end
  end

  private

  def remove_stale_contact_inbox_job_enabled?
    job_status = ENV.fetch('REMOVE_STALE_CONTACT_INBOX_JOB_STATUS', false)
    return false unless ActiveModel::Type::Boolean.new.cast(job_status)

    true
  end

  def stale_contact_inboxes(time_period)
    ContactInbox.stale_without_conversations(time_period)
  end

  def log_stale_contact_inboxes_deletion(contact_inboxes, time_period)
    count = contact_inboxes.count
    Rails.logger.info ""Deleting #{count} stale contact inboxes older than #{time_period}""

    # Log the SQL query without executing it
    sql_query = contact_inboxes.to_sql
    Rails.logger.info(""SQL Query: #{sql_query}"")
  end
end

```","# spec/services/remove_stale_contact_inboxes_service_spec.rb

require 'rails_helper'

RSpec.describe Internal::RemoveStaleContactInboxesService do
  describe '#perform' do
    it 'does not delete stale contact inboxes if REMOVE_STALE_CONTACT_INBOX_JOB_STATUS is false' do
      # default value of REMOVE_STALE_CONTACT_INBOX_JOB_STATUS is false
      create(:contact_inbox, created_at: 3.days.ago)
      create(:contact_inbox, created_at: 91.days.ago)
      create(:contact_inbox, created_at: 92.days.ago)
      create(:contact_inbox, created_at: 93.days.ago)
      create(:contact_inbox, created_at: 94.days.ago)

      service = described_class.new
      expect { service.perform }.not_to change(ContactInbox, :count)
    end

    it 'deletes stale contact inboxes' do
      with_modified_env REMOVE_STALE_CONTACT_INBOX_JOB_STATUS: 'true' do
        create(:contact_inbox, created_at: 3.days.ago)
        create(:contact_inbox, created_at: 91.days.ago)
        create(:contact_inbox, created_at: 92.days.ago)
        create(:contact_inbox, created_at: 93.days.ago)
        create(:contact_inbox, created_at: 94.days.ago)

        service = described_class.new
        expect { service.perform }.to change(ContactInbox, :count).by(-4)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class AgentBots::ValidateBotService
  pattr_initialize [:agent_bot]
  def perform
    return true unless agent_bot.bot_type == 'csml'

    validate_csml_bot
  end

  private

  def csml_client
    @csml_client ||= CsmlEngine.new
  end

  def csml_bot_payload
    {
      id: agent_bot[:name],
      name: agent_bot[:name],
      default_flow: 'Default',
      flows: [
        {
          id: SecureRandom.uuid,
          name: 'Default',
          content: agent_bot.bot_config['csml_content'],
          commands: []
        }
      ]
    }
  end

  def validate_csml_bot
    response = csml_client.validate(csml_bot_payload)
    response.blank? || response['valid']
  rescue StandardError => e
    ChatwootExceptionTracker.new(e, account: agent_bot&.account).capture_exception
    false
  end
end

```","require 'rails_helper'

describe AgentBots::ValidateBotService do
  describe '#perform' do
    it 'returns true if bot_type is not csml' do
      agent_bot = create(:agent_bot)
      valid = described_class.new(agent_bot: agent_bot).perform
      expect(valid).to be true
    end

    it 'returns true if validate csml returns true' do
      agent_bot = create(:agent_bot, :skip_validate, bot_type: 'csml', bot_config: {})
      csml_client = double
      csml_response = double
      allow(CsmlEngine).to receive(:new).and_return(csml_client)
      allow(csml_client).to receive(:validate).and_return(csml_response)
      allow(csml_response).to receive(:blank?).and_return(false)
      allow(csml_response).to receive(:[]).with('valid').and_return(true)

      valid = described_class.new(agent_bot: agent_bot).perform
      expect(valid).to be true
      expect(CsmlEngine).to have_received(:new)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Macros::ExecutionService < ActionService
  def initialize(macro, conversation, user)
    super(conversation)
    @macro = macro
    @account = macro.account
    @user = user
    Current.user = user
  end

  def perform
    @macro.actions.each do |action|
      action = action.with_indifferent_access
      begin
        send(action[:action_name], action[:action_params])
      rescue StandardError => e
        ChatwootExceptionTracker.new(e, account: @account).capture_exception
      end
    end
  ensure
    Current.reset
  end

  private

  def assign_agent(agent_ids)
    agent_ids = agent_ids.map { |id| id == 'self' ? @user.id : id }
    super(agent_ids)
  end

  def add_private_note(message)
    return if conversation_a_tweet?

    params = { content: message[0], private: true }

    # Added reload here to ensure conversation us persistent with the latest updates
    mb = Messages::MessageBuilder.new(@user, @conversation.reload, params)
    mb.perform
  end

  def send_message(message)
    return if conversation_a_tweet?

    params = { content: message[0], private: false }

    # Added reload here to ensure conversation us persistent with the latest updates
    mb = Messages::MessageBuilder.new(@user, @conversation.reload, params)
    mb.perform
  end

  def send_attachment(blob_ids)
    return if conversation_a_tweet?

    return unless @macro.files.attached?

    blobs = ActiveStorage::Blob.where(id: blob_ids)

    return if blobs.blank?

    params = { content: nil, private: false, attachments: blobs }

    # Added reload here to ensure conversation us persistent with the latest updates
    mb = Messages::MessageBuilder.new(@user, @conversation.reload, params)
    mb.perform
  end
end

```","require 'rails_helper'

RSpec.describe Macros::ExecutionService, type: :service do
  let(:account) { create(:account) }
  let(:conversation) { create(:conversation, account: account) }
  let(:user) { create(:user, account: account) }
  let(:macro) { create(:macro, account: account) }
  let(:service) { described_class.new(macro, conversation, user) }

  before do
    create(:inbox_member, user: user, inbox: conversation.inbox)
  end

  describe '#perform' do
    context 'when actions are present' do
      before do
        allow(macro).to receive(:actions).and_return([
                                                       { action_name: 'assign_agent', action_params: ['self'] },
                                                       { action_name: 'add_private_note', action_params: ['Test note'] },
                                                       { action_name: 'send_message', action_params: ['Test message'] },
                                                       { action_name: 'send_attachment', action_params: [1, 2] }
                                                     ])
      end

      it 'executes the actions' do
        expect(service).to receive(:assign_agent).with(['self']).and_call_original
        expect(service).to receive(:add_private_note).with(['Test note']).and_call_original
        expect(service).to receive(:send_message).with(['Test message']).and_call_original
        expect(service).to receive(:send_attachment).with([1, 2]).and_call_original

        service.perform
      end

      context 'when an action raises an error' do
        let(:exception_tracker) { instance_spy(ChatwootExceptionTracker) }

        before do
          allow(ChatwootExceptionTracker).to receive(:new).and_return(exception_tracker)
        end

        it 'captures the exception' do
          allow(service).to receive(:assign_agent).and_raise(StandardError.new('Random error'))
          expect(exception_tracker).to receive(:capture_exception)

          service.perform
        end
      end
    end
  end

  describe '#assign_agent' do
    context 'when agent_ids contains self' do
      it 'updates the conversation assignee to the current user' do
        service.send(:assign_agent, ['self'])
        expect(conversation.reload.assignee).to eq(user)
      end
    end

    context 'when agent_ids does not contain self' do
      let(:other_user) { create(:user, account: account) }

      before do
        create(:inbox_member, user: other_user, inbox: conversation.inbox)
      end

      it 'calls the super method' do
        service.send(:assign_agent, [other_user.id])
        expect(conversation.reload.assignee).to eq(other_user)
      end
    end
  end

  describe '#add_private_note' do
    context 'when conversation is not a tweet' do
      it 'creates a new private message' do
        expect do
          service.send(:add_private_note, ['Test private note'])
        end.to change(Message, :count).by(1)

        message = Message.last
        expect(message.content).to eq('Test private note')
        expect(message.private).to be(true)
      end
    end

    context 'when conversation is a tweet' do
      before { allow(service).to receive(:conversation_a_tweet?).and_return(true) }

      it 'does not create a new message' do
        expect do
          service.send(:add_private_note, ['Test private note'])
        end.not_to change(Message, :count)
      end
    end
  end

  describe '#send_message' do
    context 'when conversation is not a tweet' do
      it 'creates a new public message' do
        expect do
          service.send(:send_message, ['Test message'])
        end.to change(Message, :count).by(1)

        message = Message.last
        expect(message.content).to eq('Test message')
        expect(message.private).to be(false)
      end
    end

    context 'when conversation is a tweet' do
      before { allow(service).to receive(:conversation_a_tweet?).and_return(true) }

      it 'does not create a new message' do
        expect do
          service.send(:send_message, ['Test message'])
        end.not_to change(Message, :count)
      end
    end
  end

  describe '#send_attachment' do
    before do
      macro.files.attach(io: Rails.root.join('spec/assets/avatar.png').open, filename: 'avatar.png', content_type: 'image/png')
      macro.save!
    end

    context 'when conversation is not a tweet and macro has files attached' do
      before { allow(service).to receive(:conversation_a_tweet?).and_return(false) }

      it 'creates a new message with attachments' do
        expect do
          service.send(:send_attachment, [macro.files.first.blob_id])
        end.to change(Message, :count).by(1)

        message = Message.last
        expect(message.attachments).to be_present
      end
    end

    context 'when conversation is a tweet or macro has no files attached' do
      before { allow(service).to receive(:conversation_a_tweet?).and_return(true) }

      it 'does not create a new message' do
        expect do
          service.send(:send_attachment, [macro.files.first.blob_id])
        end.not_to change(Message, :count)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Facebook::SendOnFacebookService < Base::SendOnChannelService
  private

  def channel_class
    Channel::FacebookPage
  end

  def perform_reply
    send_message_to_facebook fb_text_message_params if message.content.present?
    send_message_to_facebook fb_attachment_message_params if message.attachments.present?
  rescue Facebook::Messenger::FacebookError => e
    # TODO : handle specific errors or else page will get disconnected
    handle_facebook_error(e)
    message.update!(status: :failed, external_error: e.message)
  end

  def send_message_to_facebook(delivery_params)
    result = Facebook::Messenger::Bot.deliver(delivery_params, page_id: channel.page_id)
    parsed_result = JSON.parse(result)
    if parsed_result['error'].present?
      message.update!(status: :failed, external_error: external_error(parsed_result))
      Rails.logger.info ""Facebook::SendOnFacebookService: Error sending message to Facebook : Page - #{channel.page_id} : #{result}""
    end
    message.update!(source_id: parsed_result['message_id']) if parsed_result['message_id'].present?
  end

  def fb_text_message_params
    {
      recipient: { id: contact.get_source_id(inbox.id) },
      message: { text: message.content },
      messaging_type: 'MESSAGE_TAG',
      tag: 'ACCOUNT_UPDATE'
    }
  end

  def external_error(response)
    # https://developers.facebook.com/docs/graph-api/guides/error-handling/
    error_message = response['error']['message']
    error_code = response['error']['code']

    ""#{error_code} - #{error_message}""
  end

  def fb_attachment_message_params
    attachment = message.attachments.first
    {
      recipient: { id: contact.get_source_id(inbox.id) },
      message: {
        attachment: {
          type: attachment_type(attachment),
          payload: {
            url: attachment.download_url
          }
        }
      },
      messaging_type: 'MESSAGE_TAG',
      tag: 'ACCOUNT_UPDATE'
    }
  end

  def attachment_type(attachment)
    return attachment.file_type if %w[image audio video file].include? attachment.file_type

    'file'
  end

  def fb_message_params
    if message.attachments.blank?
      fb_text_message_params
    else
      fb_attachment_message_params
    end
  end

  def sent_first_outgoing_message_after_24_hours?
    # we can send max 1 message after 24 hour window
    conversation.messages.outgoing.where('id > ?', conversation.last_incoming_message.id).count == 1
  end

  def handle_facebook_error(exception)
    # Refer: https://github.com/jgorset/facebook-messenger/blob/64fe1f5cef4c1e3fca295b205037f64dfebdbcab/lib/facebook/messenger/error.rb
    return unless exception.to_s.include?('The session has been invalidated') || exception.to_s.include?('Error validating access token')

    channel.authorization_error!
  end
end

```","require 'rails_helper'

describe Facebook::SendOnFacebookService do
  subject(:send_reply_service) { described_class.new(message: message) }

  before do
    allow(Facebook::Messenger::Subscriptions).to receive(:subscribe).and_return(true)
    allow(bot).to receive(:deliver).and_return({ recipient_id: '1008372609250235', message_id: 'mid.1456970487936:c34767dfe57ee6e339' }.to_json)
    create(:message, message_type: :incoming, inbox: facebook_inbox, account: account, conversation: conversation)
  end

  let!(:account) { create(:account) }
  let(:bot) { class_double(Facebook::Messenger::Bot).as_stubbed_const }
  let!(:widget_inbox) { create(:inbox, account: account) }
  let!(:facebook_channel) { create(:channel_facebook_page, account: account) }
  let!(:facebook_inbox) { create(:inbox, channel: facebook_channel, account: account) }
  let!(:contact) { create(:contact, account: account) }
  let(:contact_inbox) { create(:contact_inbox, contact: contact, inbox: facebook_inbox) }
  let(:conversation) { create(:conversation, contact: contact, inbox: facebook_inbox, contact_inbox: contact_inbox) }

  describe '#perform' do
    context 'without reply' do
      it 'if message is private' do
        message = create(:message, message_type: 'outgoing', private: true, inbox: facebook_inbox, account: account)
        described_class.new(message: message).perform
        expect(bot).not_to have_received(:deliver)
      end

      it 'if inbox channel is not facebook page' do
        message = create(:message, message_type: 'outgoing', inbox: widget_inbox, account: account)
        expect { described_class.new(message: message).perform }.to raise_error 'Invalid channel service was called'
        expect(bot).not_to have_received(:deliver)
      end

      it 'if message is not outgoing' do
        message = create(:message, message_type: 'incoming', inbox: facebook_inbox, account: account)
        described_class.new(message: message).perform
        expect(bot).not_to have_received(:deliver)
      end

      it 'if message has an FB ID' do
        message = create(:message, message_type: 'outgoing', inbox: facebook_inbox, account: account, source_id: SecureRandom.uuid)
        described_class.new(message: message).perform
        expect(bot).not_to have_received(:deliver)
      end
    end

    context 'with reply' do
      it 'if message is sent from chatwoot and is outgoing' do
        message = create(:message, message_type: 'outgoing', inbox: facebook_inbox, account: account, conversation: conversation)
        described_class.new(message: message).perform
        expect(bot).to have_received(:deliver)
      end

      it 'raise and exception to validate access token' do
        message = create(:message, message_type: 'outgoing', inbox: facebook_inbox, account: account, conversation: conversation)
        allow(bot).to receive(:deliver).and_raise(Facebook::Messenger::FacebookError.new('message' => 'Error validating access token'))
        described_class.new(message: message).perform

        expect(facebook_channel.authorization_error_count).to eq(1)
        expect(message.reload.status).to eq('failed')
        expect(message.reload.external_error).to eq('Error validating access token')
      end

      it 'if message with attachment is sent from chatwoot and is outgoing' do
        message = build(:message, message_type: 'outgoing', inbox: facebook_inbox, account: account, conversation: conversation)
        attachment = message.attachments.new(account_id: message.account_id, file_type: :image)
        attachment.file.attach(io: Rails.root.join('spec/assets/avatar.png').open, filename: 'avatar.png', content_type: 'image/png')
        message.save!
        allow(attachment).to receive(:download_url).and_return('url1')
        described_class.new(message: message).perform
        expect(bot).to have_received(:deliver).with({
                                                      recipient: { id: contact_inbox.source_id },
                                                      message: { text: message.content },
                                                      messaging_type: 'MESSAGE_TAG',
                                                      tag: 'ACCOUNT_UPDATE'
                                                    }, { page_id: facebook_channel.page_id })
        expect(bot).to have_received(:deliver).with({
                                                      recipient: { id: contact_inbox.source_id },
                                                      message: {
                                                        attachment: {
                                                          type: 'image',
                                                          payload: {
                                                            url: 'url1'
                                                          }
                                                        }
                                                      },
                                                      messaging_type: 'MESSAGE_TAG',
                                                      tag: 'ACCOUNT_UPDATE'
                                                    }, { page_id: facebook_channel.page_id })
      end

      it 'if message sent from chatwoot is failed' do
        message = create(:message, message_type: 'outgoing', inbox: facebook_inbox, account: account, conversation: conversation)
        allow(bot).to receive(:deliver).and_return({ error: { message: 'Invalid OAuth access token.', type: 'OAuthException', code: 190,
                                                              fbtrace_id: 'BLBz/WZt8dN' } }.to_json)
        described_class.new(message: message).perform
        expect(bot).to have_received(:deliver)
        expect(message.reload.status).to eq('failed')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# ref : https://developers.line.biz/en/docs/messaging-api/receiving-messages/#webhook-event-types
# https://developers.line.biz/en/reference/messaging-api/#message-event

class Line::IncomingMessageService
  include ::FileTypeHelper
  pattr_initialize [:inbox!, :params!]

  def perform
    # probably test events
    return if params[:events].blank?

    line_contact_info
    return if line_contact_info['userId'].blank?

    set_contact
    set_conversation
    parse_events
  end

  private

  def parse_events
    params[:events].each do |event|
      next unless message_created? event

      attach_files event['message']
    end
  end

  def message_created?(event)
    return unless event_type_message?(event)

    @message = @conversation.messages.create!(
      content: event['message']['text'],
      account_id: @inbox.account_id,
      inbox_id: @inbox.id,
      message_type: :incoming,
      sender: @contact,
      source_id: event['message']['id'].to_s
    )
    @message
  end

  def attach_files(message)
    return unless message_type_non_text?(message['type'])

    response = inbox.channel.client.get_message_content(message['id'])

    file_name = ""media-#{message['id']}.#{response.content_type.split('/')[1]}""
    temp_file = Tempfile.new(file_name)
    temp_file.binmode
    temp_file << response.body
    temp_file.rewind

    @message.attachments.new(
      account_id: @message.account_id,
      file_type: file_content_type(response),
      file: {
        io: temp_file,
        filename: file_name,
        content_type: response.content_type
      }
    )
    @message.save!
  end

  def event_type_message?(event)
    event['type'] == 'message'
  end

  def message_type_non_text?(type)
    [Line::Bot::Event::MessageType::Video, Line::Bot::Event::MessageType::Audio, Line::Bot::Event::MessageType::Image].include?(type)
  end

  def account
    @account ||= inbox.account
  end

  def line_contact_info
    @line_contact_info ||= JSON.parse(inbox.channel.client.get_profile(params[:events].first['source']['userId']).body)
  end

  def set_contact
    contact_inbox = ::ContactInboxWithContactBuilder.new(
      source_id: line_contact_info['userId'],
      inbox: inbox,
      contact_attributes: contact_attributes
    ).perform

    @contact_inbox = contact_inbox
    @contact = contact_inbox.contact
  end

  def conversation_params
    {
      account_id: @inbox.account_id,
      inbox_id: @inbox.id,
      contact_id: @contact.id,
      contact_inbox_id: @contact_inbox.id
    }
  end

  def set_conversation
    @conversation = @contact_inbox.conversations.first
    return if @conversation

    @conversation = ::Conversation.create!(conversation_params)
  end

  def contact_attributes
    {
      name: line_contact_info['displayName'],
      avatar_url: line_contact_info['pictureUrl']
    }
  end

  def file_content_type(file_content)
    file_type(file_content.content_type)
  end
end

```","require 'rails_helper'

describe Line::IncomingMessageService do
  let!(:line_channel) { create(:channel_line) }
  let(:params) do
    {
      'destination': '2342234234',
      'events': [
        {
          'replyToken': '0f3779fba3b349968c5d07db31eab56f',
          'type': 'message',
          'mode': 'active',
          'timestamp': 1_462_629_479_859,
          'source': {
            'type': 'user',
            'userId': 'U4af4980629'
          },
          'message': {
            'id': '325708',
            'type': 'text',
            'text': 'Hello, world'
          }
        },
        {
          'replyToken': '8cf9239d56244f4197887e939187e19e',
          'type': 'follow',
          'mode': 'active',
          'timestamp': 1_462_629_479_859,
          'source': {
            'type': 'user',
            'userId': 'U4af4980629'
          }
        }
      ]
    }.with_indifferent_access
  end

  let(:image_params) do
    {
      'destination': '2342234234',
      'events': [
        {
          'replyToken': '0f3779fba3b349968c5d07db31eab56f',
          'type': 'message',
          'mode': 'active',
          'timestamp': 1_462_629_479_859,
          'source': {
            'type': 'user',
            'userId': 'U4af4980629'
          },
          'message': {
            'type': 'image',
            'id': '354718',
            'contentProvider': {
              'type': 'line'
            }
          }
        },
        {
          'replyToken': '8cf9239d56244f4197887e939187e19e',
          'type': 'follow',
          'mode': 'active',
          'timestamp': 1_462_629_479_859,
          'source': {
            'type': 'user',
            'userId': 'U4af4980629'
          }
        }
      ]
    }.with_indifferent_access
  end

  let(:video_params) do
    {
      'destination': '2342234234',
      'events': [
        {
          'replyToken': '0f3779fba3b349968c5d07db31eab56f',
          'type': 'message',
          'mode': 'active',
          'timestamp': 1_462_629_479_859,
          'source': {
            'type': 'user',
            'userId': 'U4af4980629'
          },
          'message': {
            'type': 'video',
            'id': '354718',
            'contentProvider': {
              'type': 'line'
            }
          }
        },
        {
          'replyToken': '8cf9239d56244f4197887e939187e19e',
          'type': 'follow',
          'mode': 'active',
          'timestamp': 1_462_629_479_859,
          'source': {
            'type': 'user',
            'userId': 'U4af4980629'
          }
        }
      ]
    }.with_indifferent_access
  end

  describe '#perform' do
    context 'when valid text message params' do
      it 'creates appropriate conversations, message and contacts' do
        line_bot = double
        line_user_profile = double
        allow(Line::Bot::Client).to receive(:new).and_return(line_bot)
        allow(line_bot).to receive(:get_profile).and_return(line_user_profile)
        allow(line_user_profile).to receive(:body).and_return(
          {
            'displayName': 'LINE Test',
            'userId': 'U4af4980629',
            'pictureUrl': 'https://test.com'
          }.to_json
        )
        described_class.new(inbox: line_channel.inbox, params: params).perform
        expect(line_channel.inbox.conversations).not_to eq(0)
        expect(Contact.all.first.name).to eq('LINE Test')
        expect(line_channel.inbox.messages.first.content).to eq('Hello, world')
      end
    end

    context 'when valid image message params' do
      it 'creates appropriate conversations, message and contacts' do
        line_bot = double
        line_user_profile = double
        allow(Line::Bot::Client).to receive(:new).and_return(line_bot)
        allow(line_bot).to receive(:get_profile).and_return(line_user_profile)
        file = fixture_file_upload(Rails.root.join('spec/assets/avatar.png'), 'image/png')
        allow(line_bot).to receive(:get_message_content).and_return(
          OpenStruct.new({
                           body: Base64.encode64(file.read),
                           content_type: 'image/png'
                         })
        )
        allow(line_user_profile).to receive(:body).and_return(
          {
            'displayName': 'LINE Test',
            'userId': 'U4af4980629',
            'pictureUrl': 'https://test.com'
          }.to_json
        )
        described_class.new(inbox: line_channel.inbox, params: image_params).perform
        expect(line_channel.inbox.conversations).not_to eq(0)
        expect(Contact.all.first.name).to eq('LINE Test')
        expect(line_channel.inbox.messages.first.content).to be_nil
        expect(line_channel.inbox.messages.first.attachments.first.file_type).to eq('image')
        expect(line_channel.inbox.messages.first.attachments.first.file.blob.filename.to_s).to eq('media-354718.png')
      end
    end

    context 'when valid video message params' do
      it 'creates appropriate conversations, message and contacts' do
        line_bot = double
        line_user_profile = double
        allow(Line::Bot::Client).to receive(:new).and_return(line_bot)
        allow(line_bot).to receive(:get_profile).and_return(line_user_profile)
        file = fixture_file_upload(Rails.root.join('spec/assets/sample.mp4'), 'video/mp4')
        allow(line_bot).to receive(:get_message_content).and_return(
          OpenStruct.new({
                           body: Base64.encode64(file.read),
                           content_type: 'video/mp4'
                         })
        )
        allow(line_user_profile).to receive(:body).and_return(
          {
            'displayName': 'LINE Test',
            'userId': 'U4af4980629',
            'pictureUrl': 'https://test.com'
          }.to_json
        )
        described_class.new(inbox: line_channel.inbox, params: video_params).perform
        expect(line_channel.inbox.conversations).not_to eq(0)
        expect(Contact.all.first.name).to eq('LINE Test')
        expect(line_channel.inbox.messages.first.content).to be_nil
        expect(line_channel.inbox.messages.first.attachments.first.file_type).to eq('video')
        expect(line_channel.inbox.messages.first.attachments.first.file.blob.filename.to_s).to eq('media-354718.mp4')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Line::SendOnLineService < Base::SendOnChannelService
  private

  def channel_class
    Channel::Line
  end

  def perform_reply
    response = channel.client.push_message(message.conversation.contact_inbox.source_id, build_payload)

    return if response.blank?

    parsed_json = JSON.parse(response.body)

    if response.code == '200'
      # If the request is successful, update the message status to delivered
      message.update!(status: :delivered)
    else
      # If the request is not successful, update the message status to failed and save the external error
      message.update!(status: :failed, external_error: external_error(parsed_json))
    end
  end

  def build_payload
    if message.content && message.attachments.any?
      [text_message, *attachments]
    elsif message.content.nil? && message.attachments.any?
      attachments
    else
      text_message
    end
  end

  def attachments
    message.attachments.map do |attachment|
      # Support only image and video for now, https://developers.line.biz/en/reference/messaging-api/#image-message
      next unless attachment.file_type == 'image' || attachment.file_type == 'video'

      {
        type: attachment.file_type,
        originalContentUrl: attachment.download_url,
        previewImageUrl: attachment.download_url
      }
    end
  end

  # https://developers.line.biz/en/reference/messaging-api/#text-message
  def text_message
    {
      type: 'text',
      text: message.content
    }
  end

  # https://developers.line.biz/en/reference/messaging-api/#error-responses
  def external_error(error)
    # Message containing information about the error. See https://developers.line.biz/en/reference/messaging-api/#error-messages
    message = error['message']
    # An array of error details. If the array is empty, this property will not be included in the response.
    details = error['details']

    return message if details.blank?

    detail_messages = details.map { |detail| ""#{detail['property']}: #{detail['message']}"" }
    [message, detail_messages].join(', ')
  end
end

```","require 'rails_helper'

describe Line::SendOnLineService do
  describe '#perform' do
    let(:line_client) { double }
    let(:line_channel) { create(:channel_line) }
    let(:message) do
      create(:message, message_type: :outgoing, content: 'test',
                       conversation: create(:conversation, inbox: line_channel.inbox))
    end

    before do
      allow(Line::Bot::Client).to receive(:new).and_return(line_client)
    end

    context 'when message send' do
      it 'calls @channel.client.push_message' do
        allow(line_client).to receive(:push_message)
        expect(line_client).to receive(:push_message)
        described_class.new(message: message).perform
      end
    end

    context 'when message send fails without details' do
      let(:error_response) do
        {
          'message' => 'The request was invalid'
        }.to_json
      end

      before do
        allow(line_client).to receive(:push_message).and_return(OpenStruct.new(code: '400', body: error_response))
      end

      it 'updates the message status to failed' do
        described_class.new(message: message).perform
        message.reload
        expect(message.status).to eq('failed')
      end

      it 'updates the external error without details' do
        described_class.new(message: message).perform
        message.reload
        expect(message.external_error).to eq('The request was invalid')
      end
    end

    context 'when message send fails with details' do
      let(:error_response) do
        {
          'message' => 'The request was invalid',
          'details' => [
            {
              'property' => 'messages[0].text',
              'message' => 'May not be empty'
            }
          ]
        }.to_json
      end

      before do
        allow(line_client).to receive(:push_message).and_return(OpenStruct.new(code: '400', body: error_response))
      end

      it 'updates the message status to failed' do
        described_class.new(message: message).perform
        message.reload
        expect(message.status).to eq('failed')
      end

      it 'updates the external error with details' do
        described_class.new(message: message).perform
        message.reload
        expect(message.external_error).to eq('The request was invalid, messages[0].text: May not be empty')
      end
    end

    context 'when message send succeeds' do
      let(:success_response) do
        {
          'message' => 'ok'
        }.to_json
      end

      before do
        allow(line_client).to receive(:push_message).and_return(OpenStruct.new(code: '200', body: success_response))
      end

      it 'updates the message status to delivered' do
        described_class.new(message: message).perform
        message.reload
        expect(message.status).to eq('delivered')
      end
    end

    context 'with message attachments' do
      it 'sends the message with text and attachments' do
        attachment = message.attachments.new(account_id: message.account_id, file_type: :image)
        attachment.file.attach(io: Rails.root.join('spec/assets/avatar.png').open, filename: 'avatar.png', content_type: 'image/png')
        expected_url_regex = %r{rails/active_storage/disk/[a-zA-Z0-9=_\-+]+/avatar\.png}

        expect(line_client).to receive(:push_message).with(
          message.conversation.contact_inbox.source_id,
          [
            { type: 'text', text: message.content },
            {
              type: 'image',
              originalContentUrl: match(expected_url_regex),
              previewImageUrl: match(expected_url_regex)
            }
          ]
        )

        described_class.new(message: message).perform
      end

      it 'sends the message with attachments only' do
        attachment = message.attachments.new(account_id: message.account_id, file_type: :image)
        attachment.file.attach(io: Rails.root.join('spec/assets/avatar.png').open, filename: 'avatar.png', content_type: 'image/png')
        message.update!(content: nil)
        expected_url_regex = %r{rails/active_storage/disk/[a-zA-Z0-9=_\-+]+/avatar\.png}

        expect(line_client).to receive(:push_message).with(
          message.conversation.contact_inbox.source_id,
          [
            {
              type: 'image',
              originalContentUrl: match(expected_url_regex),
              previewImageUrl: match(expected_url_regex)
            }
          ]
        )

        described_class.new(message: message).perform
      end

      it 'sends the message with text only' do
        message.attachments.destroy_all
        expect(line_client).to receive(:push_message).with(
          message.conversation.contact_inbox.source_id,
          { type: 'text', text: message.content }
        )

        described_class.new(message: message).perform
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Conversations::FilterService < FilterService
  ATTRIBUTE_MODEL = 'conversation_attribute'.freeze

  def initialize(params, user, filter_account = nil)
    @account = filter_account || Current.account
    super(params, user)
  end

  def perform
    @conversations = conversation_query_builder
    mine_count, unassigned_count, all_count, = set_count_for_all_conversations
    assigned_count = all_count - unassigned_count

    {
      conversations: conversations,
      count: {
        mine_count: mine_count,
        assigned_count: assigned_count,
        unassigned_count: unassigned_count,
        all_count: all_count
      }
    }
  end

  def conversation_query_builder
    conversation_filters = @filters['conversations']
    @params[:payload].each_with_index do |query_hash, current_index|
      current_filter = conversation_filters[query_hash['attribute_key']]
      @query_string += conversation_query_string(current_filter, query_hash, current_index)
    end

    base_relation.where(@query_string, @filter_values.with_indifferent_access)
  end

  def conversation_query_string(current_filter, query_hash, current_index)
    attribute_key = query_hash[:attribute_key]
    query_operator = query_hash[:query_operator]
    filter_operator_value = filter_operation(query_hash, current_index)

    return custom_attribute_query(query_hash, 'conversation_attribute', current_index) if current_filter.nil?

    case current_filter['attribute_type']
    when 'additional_attributes'
      "" conversations.additional_attributes ->> '#{attribute_key}' #{filter_operator_value} #{query_operator} ""
    when 'date_attributes'
      "" (conversations.#{attribute_key})::#{current_filter['data_type']} #{filter_operator_value}#{current_filter['data_type']} #{query_operator} ""
    when 'standard'
      if attribute_key == 'labels'
        "" #{tag_filter_query('Conversation', 'conversations', query_hash, current_index)} ""
      else
        "" conversations.#{attribute_key} #{filter_operator_value} #{query_operator} ""
      end
    end
  end

  def base_relation
    @account.conversations.includes(
      :taggings, :inbox, { assignee: { avatar_attachment: [:blob] } }, { contact: { avatar_attachment: [:blob] } }, :team, :messages, :contact_inbox
    )
  end

  def current_page
    @params[:page] || 1
  end

  def conversations
    @conversations.latest.page(current_page)
  end
end

```","require 'rails_helper'

describe Conversations::FilterService do
  subject(:filter_service) { described_class }

  let!(:account) { create(:account) }
  let!(:user_1) { create(:user, account: account) }
  let!(:user_2) { create(:user, account: account) }
  let!(:campaign_1) { create(:campaign, title: 'Test Campaign', account: account) }
  let!(:campaign_2) { create(:campaign, title: 'Campaign', account: account) }
  let!(:inbox) { create(:inbox, account: account, enable_auto_assignment: false) }

  let!(:user_2_assigned_conversation) { create(:conversation, account: account, inbox: inbox, assignee: user_2) }
  let!(:en_conversation_1) do
    create(:conversation, account: account, inbox: inbox, assignee: user_1, campaign_id: campaign_1.id,
                          status: 'pending', additional_attributes: { 'browser_language': 'en' })
  end
  let!(:en_conversation_2) do
    create(:conversation, account: account, inbox: inbox, assignee: user_1, campaign_id: campaign_2.id,
                          status: 'pending', additional_attributes: { 'browser_language': 'en' })
  end

  before do
    create(:inbox_member, user: user_1, inbox: inbox)
    create(:inbox_member, user: user_2, inbox: inbox)
    Current.account = account

    en_conversation_1.update!(custom_attributes: { conversation_additional_information: 'test custom data' })
    en_conversation_2.update!(custom_attributes: { conversation_additional_information: 'test custom data', conversation_type: 'platinum' })
    user_2_assigned_conversation.update!(custom_attributes: { conversation_type: 'platinum', conversation_created: '2022-01-19' })
    create(:conversation, account: account, inbox: inbox, assignee: user_1)

    create(:custom_attribute_definition,
           attribute_key: 'conversation_type',
           account: account,
           attribute_model: 'conversation_attribute',
           attribute_display_type: 'list',
           attribute_values: %w[regular platinum gold])
    create(:custom_attribute_definition,
           attribute_key: 'conversation_created',
           account: account,
           attribute_model: 'conversation_attribute',
           attribute_display_type: 'date')
    create(:custom_attribute_definition,
           attribute_key: 'conversation_additional_information',
           account: account,
           attribute_model: 'conversation_attribute',
           attribute_display_type: 'text')
  end

  describe '#perform' do
    context 'with query present' do
      let!(:params) { { payload: [], page: 1 } }
      let(:payload) do
        [
          {
            attribute_key: 'browser_language',
            filter_operator: 'contains',
            values: 'en',
            query_operator: 'AND',
            custom_attribute_type: ''
          }.with_indifferent_access,
          {
            attribute_key: 'status',
            filter_operator: 'not_equal_to',
            values: %w[resolved],
            query_operator: nil,
            custom_attribute_type: ''
          }.with_indifferent_access
        ]
      end

      it 'filter conversations by additional_attributes and status' do
        params[:payload] = payload
        result = filter_service.new(params, user_1).perform
        conversations = Conversation.where(""additional_attributes ->> 'browser_language' IN (?) AND status IN (?)"", ['en'], [1, 2])
        expect(result[:count][:all_count]).to be conversations.count
      end

      it 'filter conversations by additional_attributes and status with pagination' do
        params[:payload] = payload
        params[:page] = 2
        result = filter_service.new(params, user_1).perform
        conversations = Conversation.where(""additional_attributes ->> 'browser_language' IN (?) AND status IN (?)"", ['en'], [1, 2])
        expect(result[:count][:all_count]).to be conversations.count
      end

      it 'filters items with contains filter_operator with values being an array' do
        params[:payload] = [{
          attribute_key: 'browser_language',
          filter_operator: 'contains',
          values: %w[tr fr],
          query_operator: '',
          custom_attribute_type: ''
        }.with_indifferent_access]

        create(:conversation, account: account, inbox: inbox, assignee: user_1, campaign_id: campaign_1.id,
                              status: 'pending', additional_attributes: { 'browser_language': 'fr' })
        create(:conversation, account: account, inbox: inbox, assignee: user_1, campaign_id: campaign_1.id,
                              status: 'pending', additional_attributes: { 'browser_language': 'tr' })

        result = filter_service.new(params, user_1).perform
        expect(result[:count][:all_count]).to be 2
      end

      it 'filters items with does not contain filter operator with values being an array' do
        params[:payload] = [{
          attribute_key: 'browser_language',
          filter_operator: 'does_not_contain',
          values: %w[tr en],
          query_operator: '',
          custom_attribute_type: ''
        }.with_indifferent_access]

        create(:conversation, account: account, inbox: inbox, assignee: user_1, campaign_id: campaign_1.id,
                              status: 'pending', additional_attributes: { 'browser_language': 'fr' })
        create(:conversation, account: account, inbox: inbox, assignee: user_1, campaign_id: campaign_1.id,
                              status: 'pending', additional_attributes: { 'browser_language': 'tr' })

        result = filter_service.new(params, user_1).perform

        expect(result[:count][:all_count]).to be 1
        expect(result[:conversations].first.additional_attributes['browser_language']).to eq 'fr'
      end

      it 'filter conversations by additional_attributes with NOT_IN filter' do
        payload = [{ attribute_key: 'conversation_type', filter_operator: 'not_equal_to', values: 'platinum', query_operator: nil,
                     custom_attribute_type: 'conversation_attribute' }.with_indifferent_access]
        params[:payload] = payload
        result = filter_service.new(params, user_1).perform
        conversations = Conversation.where(
          ""custom_attributes ->> 'conversation_type' NOT IN (?) OR custom_attributes ->> 'conversation_type' IS NULL"", ['platinum']
        )
        expect(result[:count][:all_count]).to be conversations.count
      end

      it 'filter conversations by tags' do
        user_2_assigned_conversation.update_labels('support')
        params[:payload] = [
          {
            attribute_key: 'assignee_id',
            filter_operator: 'equal_to',
            values: [user_1.id, user_2.id],
            query_operator: 'AND'
          }.with_indifferent_access,
          {
            attribute_key: 'labels',
            filter_operator: 'equal_to',
            values: ['support'],
            query_operator: 'AND'
          }.with_indifferent_access,
          {
            attribute_key: 'labels',
            filter_operator: 'not_equal_to',
            values: ['random-label'],
            query_operator: nil
          }.with_indifferent_access
        ]
        result = filter_service.new(params, user_1).perform
        expect(result[:count][:all_count]).to be 1
      end

      it 'filter conversations by is_present filter_operator' do
        params[:payload] = [
          {
            attribute_key: 'assignee_id',
            filter_operator: 'equal_to',
            values: [
              user_1.id,
              user_2.id
            ],
            query_operator: 'AND',
            custom_attribute_type: ''
          }.with_indifferent_access,
          {
            attribute_key: 'campaign_id',
            filter_operator: 'is_present',
            values: [],
            query_operator: nil,
            custom_attribute_type: ''
          }.with_indifferent_access
        ]
        result = filter_service.new(params, user_1).perform

        expect(result[:count][:all_count]).to be 2
        expect(result[:conversations].pluck(:campaign_id).sort).to eq [campaign_2.id, campaign_1.id].sort
      end
    end
  end

  describe '#perform on custom attribute' do
    context 'with query present' do
      let!(:params) { { payload: [], page: 1 } }

      it 'filter by custom_attributes and labels' do
        user_2_assigned_conversation.update_labels('support')
        params[:payload] = [
          {
            attribute_key: 'conversation_type',
            filter_operator: 'equal_to',
            values: ['platinum'],
            query_operator: 'AND'
          }.with_indifferent_access,
          {
            attribute_key: 'conversation_created',
            filter_operator: 'is_less_than',
            values: ['2022-01-20'],
            query_operator: 'OR',
            custom_attribute_type: ''
          }.with_indifferent_access,
          {
            attribute_key: 'labels',
            filter_operator: 'equal_to',
            values: ['support'],
            query_operator: nil
          }.with_indifferent_access
        ]
        result = filter_service.new(params, user_1).perform
        expect(result[:conversations].length).to be 1
        expect(result[:conversations][0][:id]).to be user_2_assigned_conversation.id
      end

      it 'filter by custom_attributes and labels with custom_attribute_type nil' do
        user_2_assigned_conversation.update_labels('support')
        params[:payload] = [
          {
            attribute_key: 'conversation_type',
            filter_operator: 'equal_to',
            values: ['platinum'],
            query_operator: 'AND'
          }.with_indifferent_access,
          {
            attribute_key: 'conversation_created',
            filter_operator: 'is_less_than',
            values: ['2022-01-20'],
            query_operator: 'OR',
            custom_attribute_type: nil
          }.with_indifferent_access,
          {
            attribute_key: 'labels',
            filter_operator: 'equal_to',
            values: ['support'],
            query_operator: nil
          }.with_indifferent_access
        ]
        result = filter_service.new(params, user_1).perform
        expect(result[:conversations].length).to be 1
        expect(result[:conversations][0][:id]).to be user_2_assigned_conversation.id
      end

      it 'filter by custom_attributes' do
        params[:payload] = [
          {
            attribute_key: 'conversation_type',
            filter_operator: 'equal_to',
            values: ['platinum'],
            query_operator: 'AND',
            custom_attribute_type: ''
          }.with_indifferent_access,
          {
            attribute_key: 'conversation_created',
            filter_operator: 'is_less_than',
            values: ['2022-01-20'],
            query_operator: nil,
            custom_attribute_type: ''
          }.with_indifferent_access
        ]
        result = filter_service.new(params, user_1).perform
        expect(result[:conversations].length).to be 1
      end

      it 'filter by custom_attributes with custom_attribute_type nil' do
        params[:payload] = [
          {
            attribute_key: 'conversation_type',
            filter_operator: 'equal_to',
            values: ['platinum'],
            query_operator: 'AND',
            custom_attribute_type: nil
          }.with_indifferent_access,
          {
            attribute_key: 'conversation_created',
            filter_operator: 'is_less_than',
            values: ['2022-01-20'],
            query_operator: nil,
            custom_attribute_type: nil
          }.with_indifferent_access
        ]
        result = filter_service.new(params, user_1).perform
        expect(result[:conversations].length).to be 1
      end

      it 'filter by custom_attributes and additional_attributes' do
        params[:payload] = [
          {
            attribute_key: 'conversation_type',
            filter_operator: 'equal_to',
            values: ['platinum'],
            query_operator: 'AND',
            custom_attribute_type: ''
          }.with_indifferent_access,
          {
            attribute_key: 'browser_language',
            filter_operator: 'is_equal_to',
            values: 'en',
            query_operator: nil,
            custom_attribute_type: ''
          }.with_indifferent_access
        ]
        result = filter_service.new(params, user_1).perform
        expect(result[:conversations].length).to be 1
      end
    end
  end

  describe '#perform on date filter' do
    context 'with query present' do
      let!(:params) { { payload: [], page: 1 } }

      it 'filter by created_at' do
        params[:payload] = [
          {
            attribute_key: 'created_at',
            filter_operator: 'is_greater_than',
            values: ['2022-01-20'],
            query_operator: nil,
            custom_attribute_type: ''
          }.with_indifferent_access
        ]
        result = filter_service.new(params, user_1).perform
        expected_count = Conversation.where('created_at > ?', DateTime.parse('2022-01-20')).count
        expect(result[:conversations].length).to be expected_count
      end

      it 'filter by created_at and conversation_type' do
        params[:payload] = [
          {
            attribute_key: 'conversation_type',
            filter_operator: 'equal_to',
            values: ['platinum'],
            query_operator: 'AND',
            custom_attribute_type: ''
          }.with_indifferent_access,
          {
            attribute_key: 'created_at',
            filter_operator: 'is_greater_than',
            values: ['2022-01-20'],
            query_operator: nil,
            custom_attribute_type: ''
          }.with_indifferent_access
        ]
        result = filter_service.new(params, user_1).perform
        expected_count = Conversation.where(""created_at > ? AND custom_attributes->>'conversation_type' = ?"", DateTime.parse('2022-01-20'),
                                            'platinum').count

        expect(result[:conversations].length).to be expected_count
      end

      context 'with x_days_before filter' do
        before do
          Time.zone = 'UTC'
          en_conversation_1.update!(last_activity_at: (Time.zone.today - 4.days))
          en_conversation_2.update!(last_activity_at: (Time.zone.today - 5.days))
          user_2_assigned_conversation.update!(last_activity_at: (Time.zone.today - 2.days))
        end

        it 'filter by last_activity_at 3_days_before and custom_attributes' do
          params[:payload] = [
            {
              attribute_key: 'last_activity_at',
              filter_operator: 'days_before',
              values: [3],
              query_operator: 'AND',
              custom_attribute_type: ''
            }.with_indifferent_access,
            {
              attribute_key: 'conversation_type',
              filter_operator: 'equal_to',
              values: ['platinum'],
              query_operator: nil,
              custom_attribute_type: ''
            }.with_indifferent_access
          ]

          expected_count = Conversation.where(""last_activity_at < ? AND custom_attributes->>'conversation_type' = ?"", (Time.zone.today - 3.days),
                                              'platinum').count

          result = filter_service.new(params, user_1).perform
          expect(result[:conversations].length).to be expected_count
        end

        it 'filter by last_activity_at 2_days_before' do
          params[:payload] = [
            {
              attribute_key: 'last_activity_at',
              filter_operator: 'days_before',
              values: [3],
              query_operator: nil,
              custom_attribute_type: ''
            }.with_indifferent_access
          ]

          expected_count = Conversation.where('last_activity_at < ?', (Time.zone.today - 2.days)).count

          result = filter_service.new(params, user_1).perform
          expect(result[:conversations].length).to be expected_count
        end
      end
    end
  end

  describe '#perform on date filter with no current account' do
    before do
      Current.account = nil
    end

    context 'with query present' do
      let!(:params) { { payload: [], page: 1 } }

      it 'filter by created_at' do
        params[:payload] = [
          {
            attribute_key: 'created_at',
            filter_operator: 'is_greater_than',
            values: ['2022-01-20'],
            query_operator: nil,
            custom_attribute_type: ''
          }.with_indifferent_access
        ]
        result = filter_service.new(params, user_1, account).perform
        expected_count = Conversation.where('created_at > ?', DateTime.parse('2022-01-20')).count

        expect(Current.account).to be_nil
        expect(result[:conversations].length).to be expected_count
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class AutomationRules::ActionService < ActionService
  def initialize(rule, account, conversation)
    super(conversation)
    @rule = rule
    @account = account
    Current.executed_by = rule
  end

  def perform
    @rule.actions.each do |action|
      @conversation.reload
      action = action.with_indifferent_access
      begin
        send(action[:action_name], action[:action_params])
      rescue StandardError => e
        ChatwootExceptionTracker.new(e, account: @account).capture_exception
      end
    end
  ensure
    Current.reset
  end

  private

  def send_attachment(blob_ids)
    return if conversation_a_tweet?

    return unless @rule.files.attached?

    blobs = ActiveStorage::Blob.where(id: blob_ids)

    return if blobs.blank?

    params = { content: nil, private: false, attachments: blobs }
    Messages::MessageBuilder.new(nil, @conversation, params).perform
  end

  def send_webhook_event(webhook_url)
    payload = @conversation.webhook_data.merge(event: ""automation_event.#{@rule.event_name}"")
    WebhookJob.perform_later(webhook_url[0], payload)
  end

  def send_message(message)
    return if conversation_a_tweet?

    params = { content: message[0], private: false, content_attributes: { automation_rule_id: @rule.id } }
    Messages::MessageBuilder.new(nil, @conversation, params).perform
  end

  def send_email_to_team(params)
    teams = Team.where(id: params[0][:team_ids])

    teams.each do |team|
      TeamNotifications::AutomationNotificationMailer.conversation_creation(@conversation, team, params[0][:message])&.deliver_now
    end
  end
end

```","require 'rails_helper'

RSpec.describe AutomationRules::ActionService do
  let(:account) { create(:account) }
  let(:agent) { create(:user, account: account) }
  let(:conversation) { create(:conversation, account: account) }
  let!(:rule) do
    create(:automation_rule, account: account,
                             actions: [
                               { action_name: 'send_webhook_event', action_params: ['https://example.com'] },
                               { action_name: 'send_message', action_params: { message: 'Hello' } }
                             ])
  end

  describe '#perform' do
    context 'when actions are defined in the rule' do
      it 'will call the actions' do
        expect(Messages::MessageBuilder).to receive(:new)
        expect(WebhookJob).to receive(:perform_later)
        described_class.new(rule, account, conversation).perform
      end
    end

    describe '#perform with send_attachment action' do
      let(:message_builder) { double }

      before do
        allow(Messages::MessageBuilder).to receive(:new).and_return(message_builder)
        rule.actions.delete_if { |a| a['action_name'] == 'send_message' }
        rule.files.attach(io: Rails.root.join('spec/assets/avatar.png').open, filename: 'avatar.png', content_type: 'image/png')
        rule.save!
        rule.actions << { action_name: 'send_attachment', action_params: [rule.files.first.blob_id] }
      end

      it 'will send attachment' do
        expect(message_builder).to receive(:perform)
        described_class.new(rule, account, conversation).perform
      end

      it 'will not send attachment is conversation is a tweet' do
        twitter_inbox = create(:inbox, channel: create(:channel_twitter_profile, account: account))
        conversation = create(:conversation, inbox: twitter_inbox, additional_attributes: { type: 'tweet' })
        expect(message_builder).not_to receive(:perform)
        described_class.new(rule, account, conversation).perform
      end
    end

    describe '#perform with send_webhook_event action' do
      it 'will send webhook event' do
        expect(rule.actions.pluck('action_name')).to include('send_webhook_event')
        expect(WebhookJob).to receive(:perform_later)
        described_class.new(rule, account, conversation).perform
      end
    end

    describe '#perform with send_message action' do
      let(:message_builder) { double }

      before do
        allow(Messages::MessageBuilder).to receive(:new).and_return(message_builder)
      end

      it 'will send message' do
        expect(rule.actions.pluck('action_name')).to include('send_message')
        expect(message_builder).to receive(:perform)
        described_class.new(rule, account, conversation).perform
      end

      it 'will not send message if conversation is a tweet' do
        expect(rule.actions.pluck('action_name')).to include('send_message')
        twitter_inbox = create(:inbox, channel: create(:channel_twitter_profile, account: account))
        conversation = create(:conversation, inbox: twitter_inbox, additional_attributes: { type: 'tweet' })
        expect(message_builder).not_to receive(:perform)
        described_class.new(rule, account, conversation).perform
      end
    end

    describe '#perform with send_email_to_team action' do
      let!(:team) { create(:team, account: account) }

      before do
        rule.actions << { action_name: 'send_email_to_team', action_params: [{ team_ids: [team.id], message: 'Hello' }] }
      end

      it 'will send email to team' do
        expect(TeamNotifications::AutomationNotificationMailer).to receive(:conversation_creation).with(conversation, team, 'Hello').and_call_original
        described_class.new(rule, account, conversation).perform
      end
    end

    describe '#perform with send_email_transcript action' do
      before do
        rule.actions << { action_name: 'send_email_transcript', action_params: ['contact@example.com, agent@example.com,agent1@example.com'] }
        rule.save
      end

      it 'will send email to transcript to action params emails' do
        mailer = double
        allow(ConversationReplyMailer).to receive(:with).and_return(mailer)
        allow(mailer).to receive(:conversation_transcript).with(conversation, 'contact@example.com')
        allow(mailer).to receive(:conversation_transcript).with(conversation, 'agent@example.com')
        allow(mailer).to receive(:conversation_transcript).with(conversation, 'agent1@example.com')

        described_class.new(rule, account, conversation).perform
        expect(mailer).to have_received(:conversation_transcript).exactly(3).times
      end

      it 'will send email to transcript to contacts' do
        rule.actions = [{ action_name: 'send_email_transcript', action_params: ['{{contact.email}}'] }]
        rule.save

        mailer = double
        allow(ConversationReplyMailer).to receive(:with).and_return(mailer)
        allow(mailer).to receive(:conversation_transcript).with(conversation, conversation.contact.email)

        described_class.new(rule.reload, account, conversation).perform
        expect(mailer).to have_received(:conversation_transcript).exactly(1).times
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
require 'json'

class AutomationRules::ConditionsFilterService < FilterService
  ATTRIBUTE_MODEL = 'contact_attribute'.freeze

  def initialize(rule, conversation = nil, options = {})
    super([], nil)
    @rule = rule
    @conversation = conversation
    @account = conversation.account
    file = File.read('./lib/filters/filter_keys.json')
    @filters = JSON.parse(file)
    @options = options
    @changed_attributes = options[:changed_attributes]
  end

  def perform
    @conversation_filters = @filters['conversations']
    @contact_filters = @filters['contacts']
    @message_filters = @filters['messages']
    @attribute_changed_query_filter = []

    @rule.conditions.each_with_index do |query_hash, current_index|
      @attribute_changed_query_filter << query_hash and next if query_hash['filter_operator'] == 'attribute_changed'

      apply_filter(query_hash, current_index)
    end

    records = base_relation.where(@query_string, @filter_values.with_indifferent_access)

    records = perform_attribute_changed_filter(records) if @attribute_changed_query_filter.any?

    records.any?
  end

  def filter_operation(query_hash, current_index)
    if query_hash[:filter_operator] == 'starts_with'
      @filter_values[""value_#{current_index}""] = ""#{string_filter_values(query_hash)}%""
      like_filter_string(query_hash[:filter_operator], current_index)
    else
      super
    end
  end

  def apply_filter(query_hash, current_index)
    conversation_filter = @conversation_filters[query_hash['attribute_key']]
    contact_filter = @contact_filters[query_hash['attribute_key']]
    message_filter = @message_filters[query_hash['attribute_key']]

    if conversation_filter
      @query_string += conversation_query_string('conversations', conversation_filter, query_hash.with_indifferent_access, current_index)
    elsif contact_filter
      @query_string += contact_query_string(contact_filter, query_hash.with_indifferent_access, current_index)
    elsif message_filter
      @query_string += message_query_string(message_filter, query_hash.with_indifferent_access, current_index)
    elsif custom_attribute(query_hash['attribute_key'], @account, query_hash['custom_attribute_type'])
      # send table name according to attribute key right now we are supporting contact based custom attribute filter
      @query_string += custom_attribute_query(query_hash.with_indifferent_access, query_hash['custom_attribute_type'], current_index)
    end
  end

  # If attribute_changed type filter is present perform this against array
  def perform_attribute_changed_filter(records)
    @attribute_changed_records = []
    current_attribute_changed_record = base_relation
    filter_based_on_attribute_change(records, current_attribute_changed_record)

    @attribute_changed_records.uniq
  end

  # Loop through attribute_changed_query_filter
  def filter_based_on_attribute_change(records, current_attribute_changed_record)
    @attribute_changed_query_filter.each do |filter|
      @changed_attributes = @changed_attributes.with_indifferent_access
      changed_attribute = @changed_attributes[filter['attribute_key']].presence

      if changed_attribute[0].in?(filter['values']['from']) && changed_attribute[1].in?(filter['values']['to'])
        @attribute_changed_records = attribute_changed_filter_query(filter, records, current_attribute_changed_record)
      end
      current_attribute_changed_record = @attribute_changed_records
    end
  end

  # We intersect with the record if query_operator-AND is present and union if query_operator-OR is present
  def attribute_changed_filter_query(filter, records, current_attribute_changed_record)
    if filter['query_operator'] == 'AND'
      @attribute_changed_records + (current_attribute_changed_record & records)
    else
      @attribute_changed_records + (current_attribute_changed_record | records)
    end
  end

  def message_query_string(current_filter, query_hash, current_index)
    attribute_key = query_hash['attribute_key']
    query_operator = query_hash['query_operator']

    attribute_key = 'processed_message_content' if attribute_key == 'content'

    filter_operator_value = filter_operation(query_hash, current_index)

    case current_filter['attribute_type']
    when 'standard'
      if current_filter['data_type'] == 'text'
        "" LOWER(messages.#{attribute_key}) #{filter_operator_value} #{query_operator} ""
      else
        "" messages.#{attribute_key} #{filter_operator_value} #{query_operator} ""
      end
    end
  end

  # This will be used in future for contact automation rule
  def contact_query_string(current_filter, query_hash, current_index)
    attribute_key = query_hash['attribute_key']
    query_operator = query_hash['query_operator']

    filter_operator_value = filter_operation(query_hash, current_index)

    case current_filter['attribute_type']
    when 'additional_attributes'
      "" contacts.additional_attributes ->> '#{attribute_key}' #{filter_operator_value} #{query_operator} ""
    when 'standard'
      "" contacts.#{attribute_key} #{filter_operator_value} #{query_operator} ""
    end
  end

  def conversation_query_string(table_name, current_filter, query_hash, current_index)
    attribute_key = query_hash['attribute_key']
    query_operator = query_hash['query_operator']
    filter_operator_value = filter_operation(query_hash, current_index)

    case current_filter['attribute_type']
    when 'additional_attributes'
      "" #{table_name}.additional_attributes ->> '#{attribute_key}' #{filter_operator_value} #{query_operator} ""
    when 'standard'
      if attribute_key == 'labels'
        "" tags.id #{filter_operator_value} #{query_operator} ""
      else
        "" #{table_name}.#{attribute_key} #{filter_operator_value} #{query_operator} ""
      end
    end
  end

  private

  def base_relation
    records = Conversation.where(id: @conversation.id).joins(
      'LEFT OUTER JOIN contacts on conversations.contact_id = contacts.id'
    ).joins(
      'LEFT OUTER JOIN messages on messages.conversation_id = conversations.id'
    )
    records = records.where(messages: { id: @options[:message].id }) if @options[:message].present?
    records
  end
end

```","require 'rails_helper'

RSpec.describe AutomationRules::ConditionsFilterService do
  let(:account) { create(:account) }
  let(:conversation) { create(:conversation, account: account) }
  let(:email_channel) { create(:channel_email, account: account) }
  let(:email_inbox) { create(:inbox, channel: email_channel, account: account) }
  let(:message) do
    create(:message, account: account, conversation: conversation, content: 'test text', inbox: conversation.inbox, message_type: :incoming)
  end
  let(:rule) { create(:automation_rule, account: account) }

  before do
    conversation = create(:conversation, account: account)
    conversation.contact.update(phone_number: '+918484828282', email: 'test@test.com')
    create(:conversation, account: account)
    create(:conversation, account: account)
  end

  describe '#perform' do
    context 'when conditions based on filter_operator equal_to' do
      before do
        rule.conditions = [{ 'values': ['open'], 'attribute_key': 'status', 'query_operator': nil, 'filter_operator': 'equal_to' }]
        rule.save
      end

      context 'when conditions in rule matches with object' do
        it 'will return true' do
          expect(described_class.new(rule, conversation, { changed_attributes: { status: [nil, 'open'] } }).perform).to be(true)
        end
      end

      context 'when conditions in rule does not match with object' do
        it 'will return false' do
          conversation.update(status: 'resolved')
          expect(described_class.new(rule, conversation, { changed_attributes: { status: %w[open resolved] } }).perform).to be(false)
        end
      end
    end

    context 'when conditions based on filter_operator start_with' do
      before do
        contact = conversation.contact
        contact.update(phone_number: '+918484848484')
        rule.conditions = [
          { 'values': ['+918484'], 'attribute_key': 'phone_number', 'query_operator': 'OR', 'filter_operator': 'starts_with' },
          { 'values': ['test'], 'attribute_key': 'email', 'query_operator': nil, 'filter_operator': 'contains' }
        ]
        rule.save
      end

      context 'when conditions in rule matches with object' do
        it 'will return true' do
          expect(described_class.new(rule, conversation, { changed_attributes: {} }).perform).to be(true)
        end
      end

      context 'when conditions in rule does not match with object' do
        it 'will return false' do
          conversation.contact.update(phone_number: '+918585858585')
          expect(described_class.new(rule, conversation, { changed_attributes: {} }).perform).to be(false)
        end
      end
    end

    context 'when conditions based on messages attributes' do
      context 'when filter_operator is equal_to' do
        before do
          rule.conditions = [
            { 'values': ['test text'], 'attribute_key': 'content', 'query_operator': 'AND', 'filter_operator': 'equal_to' },
            { 'values': ['incoming'], 'attribute_key': 'message_type', 'query_operator': nil, 'filter_operator': 'equal_to' }
          ]
          rule.save
        end

        it 'will return true when conditions matches' do
          expect(described_class.new(rule, conversation, { message: message, changed_attributes: {} }).perform).to be(true)
        end

        it 'will return false when conditions in rule does not match' do
          message.update!(message_type: :outgoing)
          expect(described_class.new(rule, conversation, { message: message, changed_attributes: {} }).perform).to be(false)
        end
      end

      context 'when filter_operator is on processed_message_content' do
        before do
          rule.conditions = [
            { 'values': ['help'], 'attribute_key': 'content', 'query_operator': 'AND', 'filter_operator': 'contains' },
            { 'values': ['incoming'], 'attribute_key': 'message_type', 'query_operator': nil, 'filter_operator': 'equal_to' }
          ]
          rule.save
        end

        let(:conversation) { create(:conversation, account: account, inbox: email_inbox) }
        let(:message) do
          create(:message, account: account, conversation: conversation, content: ""We will help you\n\n\n test"",
                           inbox: conversation.inbox, message_type: :incoming,
                           content_attributes: { email: { text_content: { quoted: 'We will help you' } } })
        end

        it 'will return true for processed_message_content matches' do
          message
          expect(described_class.new(rule, conversation, { message: message, changed_attributes: {} }).perform).to be(true)
        end

        it 'will return false when processed_message_content does no match' do
          rule.update(conditions: [{ 'values': ['text'], 'attribute_key': 'content', 'query_operator': nil, 'filter_operator': 'contains' }])

          expect(described_class.new(rule, conversation, { message: message, changed_attributes: {} }).perform).to be(false)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# Find the various telegram payload samples here: https://core.telegram.org/bots/webhooks#testing-your-bot-with-updates
# https://core.telegram.org/bots/api#available-types

class Telegram::UpdateMessageService
  pattr_initialize [:inbox!, :params!]

  def perform
    find_contact_inbox
    find_conversation
    find_message
    update_message
  rescue StandardError => e
    Rails.logger.error ""Error while processing telegram message update #{e.message}""
  end

  private

  def find_contact_inbox
    @contact_inbox = inbox.contact_inboxes.find_by!(source_id: params[:edited_message][:chat][:id])
  end

  def find_conversation
    @conversation = @contact_inbox.conversations.last
  end

  def find_message
    @message = @conversation.messages.find_by(source_id: params[:edited_message][:message_id])
  end

  def update_message
    @message.update!(content: params[:edited_message][:text])
  end
end

```","require 'rails_helper'

describe Telegram::UpdateMessageService do
  let!(:telegram_channel) { create(:channel_telegram) }
  let!(:update_params) do
    {
      'update_id': 2_323_484,
      'edited_message': {
        'message_id': 48,
        'from': {
          'id': 512_313_123_171_248,
          'is_bot': false,
          'first_name': 'Sojan',
          'last_name': 'Jose',
          'username': 'sojan'
        },
        'chat': {
          'id': 517_123_213_211_248,
          'first_name': 'Sojan',
          'last_name': 'Jose',
          'username': 'sojan',
          'type': 'private'
        },
        'date': 1_680_088_034,
        'edit_date': 1_680_088_056,
        'text': 'updated message'
      }
    }
  end

  describe '#perform' do
    context 'when valid update message params' do
      it 'updates the appropriate message' do
        contact_inbox = create(:contact_inbox, inbox: telegram_channel.inbox, source_id: update_params[:edited_message][:chat][:id])
        conversation = create(:conversation, contact_inbox: contact_inbox)
        message = create(:message, conversation: conversation, source_id: update_params[:edited_message][:message_id])
        described_class.new(inbox: telegram_channel.inbox, params: update_params.with_indifferent_access).perform
        expect(message.reload.content).to eq('updated message')
      end
    end

    context 'when invalid update message params' do
      it 'will not raise errors' do
        expect do
          described_class.new(inbox: telegram_channel.inbox, params: {}).perform
        end.not_to raise_error
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# Find the various telegram payload samples here: https://core.telegram.org/bots/webhooks#testing-your-bot-with-updates
# https://core.telegram.org/bots/api#available-types

class Telegram::IncomingMessageService
  include ::FileTypeHelper
  include ::Telegram::ParamHelpers
  pattr_initialize [:inbox!, :params!]

  def perform
    # chatwoot doesn't support group conversations at the moment
    return unless private_message?

    set_contact
    update_contact_avatar
    set_conversation
    @message = @conversation.messages.build(
      content: telegram_params_message_content,
      account_id: @inbox.account_id,
      inbox_id: @inbox.id,
      message_type: :incoming,
      sender: @contact,
      content_attributes: telegram_params_content_attributes,
      source_id: telegram_params_message_id.to_s
    )

    process_message_attachments if message_params?
    @message.save!
  end

  private

  def set_contact
    contact_inbox = ::ContactInboxWithContactBuilder.new(
      source_id: telegram_params_from_id,
      inbox: inbox,
      contact_attributes: contact_attributes
    ).perform

    @contact_inbox = contact_inbox
    @contact = contact_inbox.contact
  end

  def process_message_attachments
    attach_location
    attach_files
  end

  def update_contact_avatar
    return if @contact.avatar.attached?

    avatar_url = inbox.channel.get_telegram_profile_image(telegram_params_from_id)
    ::Avatar::AvatarFromUrlJob.perform_later(@contact, avatar_url) if avatar_url
  end

  def conversation_params
    {
      account_id: @inbox.account_id,
      inbox_id: @inbox.id,
      contact_id: @contact.id,
      contact_inbox_id: @contact_inbox.id,
      additional_attributes: conversation_additional_attributes
    }
  end

  def set_conversation
    @conversation = @contact_inbox.conversations.first
    return if @conversation

    @conversation = ::Conversation.create!(conversation_params)
  end

  def contact_attributes
    {
      name: ""#{telegram_params_first_name} #{telegram_params_last_name}"",
      additional_attributes: additional_attributes
    }
  end

  def additional_attributes
    {
      username: telegram_params_username,
      language_code: telegram_params_language_code
    }
  end

  def conversation_additional_attributes
    {
      chat_id: telegram_params_chat_id
    }
  end

  def file_content_type
    return :image if params[:message][:photo].present? || params.dig(:message, :sticker, :thumb).present?
    return :audio if params[:message][:voice].present? || params[:message][:audio].present?
    return :video if params[:message][:video].present?

    file_type(params[:message][:document][:mime_type])
  end

  def attach_files
    return unless file

    attachment_file = Down.download(
      inbox.channel.get_telegram_file_path(file[:file_id])
    )

    @message.attachments.new(
      account_id: @message.account_id,
      file_type: file_content_type,
      file: {
        io: attachment_file,
        filename: attachment_file.original_filename,
        content_type: attachment_file.content_type
      }
    )
  end

  def attach_location
    return unless location

    @message.attachments.new(
      account_id: @message.account_id,
      file_type: :location,
      coordinates_lat: location['latitude'],
      coordinates_long: location['longitude']
    )
  end

  def file
    @file ||= visual_media_params || params[:message][:voice].presence || params[:message][:audio].presence || params[:message][:document].presence
  end

  def location
    @location ||= params.dig(:message, :location).presence
  end

  def visual_media_params
    params[:message][:photo].presence&.last || params.dig(:message, :sticker, :thumb).presence || params[:message][:video].presence
  end
end

```","require 'rails_helper'

describe Telegram::IncomingMessageService do
  before do
    stub_request(:any, /api.telegram.org/).to_return(headers: { content_type: 'application/json' }, body: {}.to_json, status: 200)
    stub_request(:get, 'https://chatwoot-assets.local/sample.png').to_return(
      status: 200,
      body: File.read('spec/assets/sample.png'),
      headers: {}
    )
    stub_request(:get, 'https://chatwoot-assets.local/sample.mov').to_return(
      status: 200,
      body: File.read('spec/assets/sample.mov'),
      headers: {}
    )
    stub_request(:get, 'https://chatwoot-assets.local/sample.mp3').to_return(
      status: 200,
      body: File.read('spec/assets/sample.mp3'),
      headers: {}
    )
    stub_request(:get, 'https://chatwoot-assets.local/sample.ogg').to_return(
      status: 200,
      body: File.read('spec/assets/sample.ogg'),
      headers: {}
    )
    stub_request(:get, 'https://chatwoot-assets.local/sample.pdf').to_return(
      status: 200,
      body: File.read('spec/assets/sample.pdf'),
      headers: {}
    )
  end

  let!(:telegram_channel) { create(:channel_telegram) }
  let!(:message_params) do
    {
      'message_id' => 1,
      'from' => {
        'id' => 23, 'is_bot' => false, 'first_name' => 'Sojan', 'last_name' => 'Jose', 'username' => 'sojan', 'language_code' => 'en'
      },
      'chat' => { 'id' => 23, 'first_name' => 'Sojan', 'last_name' => 'Jose', 'username' => 'sojan', 'type' => 'private' },
      'date' => 1_631_132_077
    }
  end

  describe '#perform' do
    context 'when valid text message params' do
      it 'creates appropriate conversations, message and contacts' do
        params = {
          'update_id' => 2_342_342_343_242,
          'message' => { 'text' => 'test' }.merge(message_params)
        }.with_indifferent_access
        described_class.new(inbox: telegram_channel.inbox, params: params).perform
        expect(telegram_channel.inbox.conversations.count).not_to eq(0)
        expect(Contact.all.first.name).to eq('Sojan Jose')
        expect(telegram_channel.inbox.messages.first.content).to eq('test')
      end
    end

    context 'when valid caption params' do
      it 'creates appropriate conversations, message and contacts' do
        params = {
          'update_id' => 2_342_342_343_242,
          'message' => { 'caption' => 'test' }.merge(message_params)
        }.with_indifferent_access
        described_class.new(inbox: telegram_channel.inbox, params: params).perform
        expect(telegram_channel.inbox.conversations.count).not_to eq(0)
        expect(Contact.all.first.name).to eq('Sojan Jose')
        expect(telegram_channel.inbox.messages.first.content).to eq('test')
      end
    end

    context 'when group messages' do
      it 'doesnot create conversations, message and contacts' do
        params = {
          'update_id' => 2_342_342_343_242,
          'message' => {
            'message_id' => 1,
            'from' => {
              'id' => 23, 'is_bot' => false, 'first_name' => 'Sojan', 'last_name' => 'Jose', 'username' => 'sojan', 'language_code' => 'en'
            },
            'chat' => { 'id' => 23, 'first_name' => 'Sojan', 'last_name' => 'Jose', 'username' => 'sojan', 'type' => 'group' },
            'date' => 1_631_132_077, 'text' => 'test'
          }
        }.with_indifferent_access
        described_class.new(inbox: telegram_channel.inbox, params: params).perform
        expect(telegram_channel.inbox.conversations.count).to eq(0)
      end
    end

    context 'when valid audio messages params' do
      it 'creates appropriate conversations, message and contacts' do
        allow(telegram_channel.inbox.channel).to receive(:get_telegram_file_path).and_return('https://chatwoot-assets.local/sample.mp3')
        params = {
          'update_id' => 2_342_342_343_242,
          'message' => {
            'audio' => {
              'file_id' => 'AwADBAADbXXXXXXXXXXXGBdhD2l6_XX',
              'duration' => 243,
              'mime_type' => 'audio/mpeg',
              'file_size' => 3_897_500,
              'title' => 'Test music file'
            }
          }.merge(message_params)
        }.with_indifferent_access
        described_class.new(inbox: telegram_channel.inbox, params: params).perform
        expect(telegram_channel.inbox.conversations.count).not_to eq(0)
        expect(Contact.all.first.name).to eq('Sojan Jose')
        expect(telegram_channel.inbox.messages.first.attachments.first.file_type).to eq('audio')
      end
    end

    context 'when valid image attachment params' do
      it 'creates appropriate conversations, message and contacts' do
        allow(telegram_channel.inbox.channel).to receive(:get_telegram_file_path).and_return('https://chatwoot-assets.local/sample.png')
        params = {
          'update_id' => 2_342_342_343_242,
          'message' => {
            'photo' => [{
              'file_id' => 'AgACAgUAAxkBAAODYV3aGZlD6vhzKsE2WNmblsr6zKwAAi-tMRvCoeBWNQ1ENVBzJdwBAAMCAANzAAMhBA',
              'file_unique_id' => 'AQADL60xG8Kh4FZ4', 'file_size' => 1883, 'width' => 90, 'height' => 67
            }]
          }.merge(message_params)
        }.with_indifferent_access
        described_class.new(inbox: telegram_channel.inbox, params: params).perform
        expect(telegram_channel.inbox.conversations.count).not_to eq(0)
        expect(Contact.all.first.name).to eq('Sojan Jose')
        expect(telegram_channel.inbox.messages.first.attachments.first.file_type).to eq('image')
      end
    end

    context 'when valid sticker attachment params' do
      it 'creates appropriate conversations, message and contacts' do
        allow(telegram_channel.inbox.channel).to receive(:get_telegram_file_path).and_return('https://chatwoot-assets.local/sample.png')
        params = {
          'update_id' => 2_342_342_343_242,
          'message' => {
            'sticker' => {
              'emoji' => '👍', 'width' => 512, 'height' => 512, 'set_name' => 'a834556273_by_HopSins_1_anim', 'is_animated' => 1,
              'thumb' => {
                'file_id' => 'AAMCAQADGQEAA0dhXpKorj9CiRpNX3QOn7YPZ6XS4AAC4wADcVG-MexptyOf8SbfAQAHbQADIQQ',
                'file_unique_id' => 'AQAD4wADcVG-MXI', 'file_size' => 4690, 'width' => 128, 'height' => 128
              },
              'file_id' => 'CAACAgEAAxkBAANHYV6SqK4_QokaTV90Dp-2D2el0uAAAuMAA3FRvjHsabcjn_Em3yEE',
              'file_unique_id' => 'AgAD4wADcVG-MQ',
              'file_size' => 7340
            }
          }.merge(message_params)
        }.with_indifferent_access
        described_class.new(inbox: telegram_channel.inbox, params: params).perform
        expect(telegram_channel.inbox.conversations.count).not_to eq(0)
        expect(Contact.all.first.name).to eq('Sojan Jose')
        expect(telegram_channel.inbox.messages.first.attachments.first.file_type).to eq('image')
      end
    end

    context 'when valid video messages params' do
      it 'creates appropriate conversations, message and contacts' do
        allow(telegram_channel.inbox.channel).to receive(:get_telegram_file_path).and_return('https://chatwoot-assets.local/sample.mov')
        params = {
          'update_id' => 2_342_342_343_242,
          'message' => {
            'video' => {
              'duration' => 1, 'width' => 720, 'height' => 1280, 'file_name' => 'IMG_2170.MOV', 'mime_type' => 'video/mp4', 'thumb' => {
                'file_id' => 'AAMCBQADGQEAA4ZhXd78Xz6_c6gCzbdIkgGiXJcwwwACqwMAAp3x8Fbhf3EWamgCWAEAB20AAyEE', 'file_unique_id' => 'AQADqwMAAp3x8FZy',
                'file_size' => 11_462, 'width' => 180, 'height' => 320
              }, 'file_id' => 'BAACAgUAAxkBAAOGYV3e_F8-v3OoAs23SJIBolyXMMMAAqsDAAKd8fBW4X9xFmpoAlghBA', 'file_unique_id' => 'AgADqwMAAp3x8FY',
              'file_size' => 291_286
            }
          }.merge(message_params)
        }.with_indifferent_access
        described_class.new(inbox: telegram_channel.inbox, params: params).perform
        expect(telegram_channel.inbox.conversations.count).not_to eq(0)
        expect(Contact.all.first.name).to eq('Sojan Jose')
        expect(telegram_channel.inbox.messages.first.attachments.first.file_type).to eq('video')
      end
    end

    context 'when valid voice attachment params' do
      it 'creates appropriate conversations, message and contacts' do
        allow(telegram_channel.inbox.channel).to receive(:get_telegram_file_path).and_return('https://chatwoot-assets.local/sample.ogg')
        params = {
          'update_id' => 2_342_342_343_242,
          'message' => {
            'voice' => {
              'duration' => 2, 'mime_type' => 'audio/ogg', 'file_id' => 'AwACAgUAAxkBAANjYVwnWF_w8LYTchqVdK9dY7mbwYEAAskDAALCoeBWFvS2u4zS6HAhBA',
              'file_unique_id' => 'AgADyQMAAsKh4FY', 'file_size' => 11_833
            }
          }.merge(message_params)
        }.with_indifferent_access
        described_class.new(inbox: telegram_channel.inbox, params: params).perform
        expect(telegram_channel.inbox.conversations.count).not_to eq(0)
        expect(Contact.all.first.name).to eq('Sojan Jose')
        expect(telegram_channel.inbox.messages.first.attachments.first.file_type).to eq('audio')
      end
    end

    context 'when valid document message params' do
      it 'creates appropriate conversations, message and contacts' do
        allow(telegram_channel.inbox.channel).to receive(:get_telegram_file_path).and_return('https://chatwoot-assets.local/sample.pdf')
        params = {
          'update_id' => 2_342_342_343_242,
          'message' => {
            'document' => {
              'file_id' => 'AwADBAADbXXXXXXXXXXXGBdhD2l6_XX',
              'file_name' => 'Screenshot 2021-09-27 at 2.01.14 PM.png',
              'mime_type' => 'application/png',
              'file_size' => 536_392
            }
          }.merge(message_params)
        }.with_indifferent_access
        described_class.new(inbox: telegram_channel.inbox, params: params).perform
        expect(telegram_channel.inbox.conversations.count).not_to eq(0)
        expect(Contact.all.first.name).to eq('Sojan Jose')
        expect(telegram_channel.inbox.messages.first.attachments.first.file_type).to eq('file')
      end
    end

    context 'when valid location message params' do
      it 'creates appropriate conversations, message and contacts' do
        params = {
          'update_id' => 2_342_342_343_242,
          'message' => {
            'location': {
              'latitude': 37.7893768,
              'longitude': -122.3895553
            }
          }.merge(message_params)
        }.with_indifferent_access
        described_class.new(inbox: telegram_channel.inbox, params: params).perform
        expect(telegram_channel.inbox.conversations.count).not_to eq(0)
        expect(Contact.all.first.name).to eq('Sojan Jose')
        expect(telegram_channel.inbox.messages.first.attachments.first.file_type).to eq('location')
      end
    end

    context 'when valid callback_query params' do
      it 'creates appropriate conversations, message and contacts' do
        params = {
          'update_id' => 2_342_342_343_242,
          'callback_query' => {
            'id' => '2342342309929423',
            'from' => {
              'id' => 5_171_248,
              'is_bot' => false,
              'first_name' => 'Sojan',
              'last_name' => 'Jose',
              'username' => 'sojan',
              'language_code' => 'en',
              'is_premium' => true
            },
            'message' => message_params,
            'chat_instance' => '-89923842384923492',
            'data' => 'Option 1'
          }
        }.with_indifferent_access

        described_class.new(inbox: telegram_channel.inbox, params: params).perform
        expect(telegram_channel.inbox.conversations.count).not_to eq(0)
        expect(Contact.all.first.name).to eq('Sojan Jose')
        expect(telegram_channel.inbox.messages.first.content).to eq('Option 1')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Telegram::SendOnTelegramService < Base::SendOnChannelService
  private

  def channel_class
    Channel::Telegram
  end

  def perform_reply
    ## send reply to telegram message api
    # https://core.telegram.org/bots/api#sendmessage
    message_id = channel.send_message_on_telegram(message)
    message.update!(source_id: message_id) if message_id.present?
  end

  def inbox
    @inbox ||= message.inbox
  end

  def channel
    @channel ||= inbox.channel
  end
end

```","require 'rails_helper'

describe Telegram::SendOnTelegramService do
  describe '#perform' do
    context 'when a valid message' do
      it 'calls channel.send_message_on_telegram' do
        telegram_request = double
        telegram_channel = create(:channel_telegram)
        message = create(:message, message_type: :outgoing, content: 'test',
                                   conversation: create(:conversation, inbox: telegram_channel.inbox, additional_attributes: { 'chat_id' => '123' }))
        allow(HTTParty).to receive(:post).and_return(telegram_request)
        allow(telegram_request).to receive(:success?).and_return(true)
        allow(telegram_request).to receive(:parsed_response).and_return({ 'result' => { 'message_id' => 'telegram_123' } })
        described_class.new(message: message).perform
        expect(message.source_id).to eq('telegram_123')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class MessageTemplates::HookExecutionService
  pattr_initialize [:message!]

  def perform
    return if conversation.campaign.present?
    return if conversation.last_incoming_message.blank?

    trigger_templates
  end

  private

  delegate :inbox, :conversation, to: :message
  delegate :contact, to: :conversation

  def trigger_templates
    ::MessageTemplates::Template::OutOfOffice.new(conversation: conversation).perform if should_send_out_of_office_message?
    ::MessageTemplates::Template::Greeting.new(conversation: conversation).perform if should_send_greeting?
    ::MessageTemplates::Template::EmailCollect.new(conversation: conversation).perform if inbox.enable_email_collect && should_send_email_collect?
    ::MessageTemplates::Template::CsatSurvey.new(conversation: conversation).perform if should_send_csat_survey?
  end

  def should_send_out_of_office_message?
    # should not send if its a tweet message
    return false if conversation.tweet?
    # should not send for outbound messages
    return false unless message.incoming?

    inbox.out_of_office? && conversation.messages.today.template.empty? && inbox.out_of_office_message.present?
  end

  def first_message_from_contact?
    conversation.messages.outgoing.count.zero? && conversation.messages.template.count.zero?
  end

  def should_send_greeting?
    # should not send if its a tweet message
    return false if conversation.tweet?

    first_message_from_contact? && inbox.greeting_enabled? && inbox.greeting_message.present?
  end

  def email_collect_was_sent?
    conversation.messages.where(content_type: 'input_email').present?
  end

  # TODO: we should be able to reduce this logic once we have a toggle for email collect messages
  def should_send_email_collect?
    !contact_has_email? && inbox.web_widget? && !email_collect_was_sent?
  end

  def contact_has_email?
    contact.email
  end

  def csat_enabled_conversation?
    return false unless conversation.resolved?
    # should not sent since the link will be public
    return false if conversation.tweet?
    return false unless inbox.csat_survey_enabled?

    true
  end

  def should_send_csat_survey?
    return unless csat_enabled_conversation?

    # only send CSAT once in a conversation
    return if conversation.messages.where(content_type: :input_csat).present?

    true
  end
end
MessageTemplates::HookExecutionService.prepend_mod_with('MessageTemplates::HookExecutionService')

```","require 'rails_helper'

describe MessageTemplates::HookExecutionService do
  context 'when there is no incoming message in conversation' do
    it 'will not call any hooks' do
      contact = create(:contact, email: nil)
      conversation = create(:conversation, contact: contact)
      # ensure greeting hook is enabled
      conversation.inbox.update(greeting_enabled: true, enable_email_collect: true)

      email_collect_service = double

      allow(MessageTemplates::Template::EmailCollect).to receive(:new).and_return(email_collect_service)
      allow(email_collect_service).to receive(:perform).and_return(true)
      allow(MessageTemplates::Template::Greeting).to receive(:new)

      # described class gets called in message after commit
      create(:message, conversation: conversation, message_type: 'activity', content: 'Conversation marked resolved!!')

      expect(MessageTemplates::Template::Greeting).not_to have_received(:new)
      expect(MessageTemplates::Template::EmailCollect).not_to have_received(:new)
    end
  end

  context 'when Greeting Message' do
    it 'doesnot calls ::MessageTemplates::Template::Greeting if greeting_message is empty' do
      contact = create(:contact, email: nil)
      conversation = create(:conversation, contact: contact)
      # ensure greeting hook is enabled
      conversation.inbox.update(greeting_enabled: true, enable_email_collect: true)

      email_collect_service = double

      allow(MessageTemplates::Template::EmailCollect).to receive(:new).and_return(email_collect_service)
      allow(email_collect_service).to receive(:perform).and_return(true)
      allow(MessageTemplates::Template::Greeting).to receive(:new)

      # described class gets called in message after commit
      message = create(:message, conversation: conversation)

      expect(MessageTemplates::Template::Greeting).not_to have_received(:new)
      expect(MessageTemplates::Template::EmailCollect).to have_received(:new).with(conversation: message.conversation)
      expect(email_collect_service).to have_received(:perform)
    end

    it 'will not call ::MessageTemplates::Template::Greeting if its a tweet conversation' do
      twitter_channel = create(:channel_twitter_profile)
      twitter_inbox = create(:inbox, channel: twitter_channel)
      # ensure greeting hook is enabled and greeting_message is present
      twitter_inbox.update(greeting_enabled: true, greeting_message: 'Hi, this is a greeting message')

      conversation = create(:conversation, inbox: twitter_inbox, additional_attributes: { type: 'tweet' })
      greeting_service = double
      allow(MessageTemplates::Template::Greeting).to receive(:new).and_return(greeting_service)
      allow(greeting_service).to receive(:perform).and_return(true)

      message = create(:message, conversation: conversation)
      expect(MessageTemplates::Template::Greeting).not_to have_received(:new).with(conversation: message.conversation)
    end
  end

  context 'when it is a first message from web widget' do
    it 'calls ::MessageTemplates::Template::EmailCollect' do
      contact = create(:contact, email: nil)
      conversation = create(:conversation, contact: contact)

      # ensure greeting hook is enabled and greeting_message is present
      conversation.inbox.update(greeting_enabled: true, enable_email_collect: true, greeting_message: 'Hi, this is a greeting message')

      email_collect_service = double
      greeting_service = double
      allow(MessageTemplates::Template::EmailCollect).to receive(:new).and_return(email_collect_service)
      allow(email_collect_service).to receive(:perform).and_return(true)
      allow(MessageTemplates::Template::Greeting).to receive(:new).and_return(greeting_service)
      allow(greeting_service).to receive(:perform).and_return(true)

      # described class gets called in message after commit
      message = create(:message, conversation: conversation)

      expect(MessageTemplates::Template::Greeting).to have_received(:new).with(conversation: message.conversation)
      expect(greeting_service).to have_received(:perform)
      expect(MessageTemplates::Template::EmailCollect).to have_received(:new).with(conversation: message.conversation)
      expect(email_collect_service).to have_received(:perform)
    end

    it 'doesnot calls ::MessageTemplates::Template::EmailCollect on campaign conversations' do
      contact = create(:contact, email: nil)
      conversation = create(:conversation, contact: contact, campaign: create(:campaign))

      allow(MessageTemplates::Template::EmailCollect).to receive(:new).and_return(true)

      # described class gets called in message after commit
      message = create(:message, conversation: conversation)

      expect(MessageTemplates::Template::EmailCollect).not_to have_received(:new).with(conversation: message.conversation)
    end

    it 'doesnot calls ::MessageTemplates::Template::EmailCollect when enable_email_collect form is disabled' do
      contact = create(:contact, email: nil)
      conversation = create(:conversation, contact: contact)

      conversation.inbox.update(enable_email_collect: false)
      # ensure prechat form is enabled
      conversation.inbox.channel.update(pre_chat_form_enabled: true)
      allow(MessageTemplates::Template::EmailCollect).to receive(:new).and_return(true)

      # described class gets called in message after commit
      message = create(:message, conversation: conversation)

      expect(MessageTemplates::Template::EmailCollect).not_to have_received(:new).with(conversation: message.conversation)
    end
  end

  context 'when CSAT Survey' do
    let(:csat_survey) { double }
    let(:conversation) { create(:conversation) }

    before do
      allow(MessageTemplates::Template::CsatSurvey).to receive(:new).and_return(csat_survey)
      allow(csat_survey).to receive(:perform).and_return(true)
      create(:message, conversation: conversation, message_type: 'incoming')
    end

    it 'calls ::MessageTemplates::Template::CsatSurvey when a conversation is resolved in an inbox with survey enabled' do
      conversation.inbox.update(csat_survey_enabled: true)

      conversation.resolved!
      Conversations::ActivityMessageJob.perform_now(conversation,
                                                    { account_id: conversation.account_id, inbox_id: conversation.inbox_id, message_type: :activity,
                                                      content: 'Conversation marked resolved!!' })

      expect(MessageTemplates::Template::CsatSurvey).to have_received(:new).with(conversation: conversation)
      expect(csat_survey).to have_received(:perform)
    end

    it 'will not call ::MessageTemplates::Template::CsatSurvey when Csat is not enabled' do
      conversation.inbox.update(csat_survey_enabled: false)

      conversation.resolved!
      Conversations::ActivityMessageJob.perform_now(conversation,
                                                    { account_id: conversation.account_id, inbox_id: conversation.inbox_id, message_type: :activity,
                                                      content: 'Conversation marked resolved!!' })

      expect(MessageTemplates::Template::CsatSurvey).not_to have_received(:new).with(conversation: conversation)
      expect(csat_survey).not_to have_received(:perform)
    end

    it 'will not call ::MessageTemplates::Template::CsatSurvey if its a tweet conversation' do
      twitter_channel = create(:channel_twitter_profile)
      twitter_inbox = create(:inbox, channel: twitter_channel)
      conversation = create(:conversation, inbox: twitter_inbox, additional_attributes: { type: 'tweet' })
      conversation.inbox.update(csat_survey_enabled: true)

      conversation.resolved!
      Conversations::ActivityMessageJob.perform_now(conversation,
                                                    { account_id: conversation.account_id, inbox_id: conversation.inbox_id, message_type: :activity,
                                                      content: 'Conversation marked resolved!!' })

      expect(MessageTemplates::Template::CsatSurvey).not_to have_received(:new).with(conversation: conversation)
      expect(csat_survey).not_to have_received(:perform)
    end

    it 'will not call ::MessageTemplates::Template::CsatSurvey if another Csat was already sent' do
      conversation.inbox.update(csat_survey_enabled: true)
      conversation.messages.create!(message_type: 'outgoing', content_type: :input_csat, account: conversation.account, inbox: conversation.inbox)

      conversation.resolved!
      Conversations::ActivityMessageJob.perform_now(conversation,
                                                    { account_id: conversation.account_id, inbox_id: conversation.inbox_id, message_type: :activity,
                                                      content: 'Conversation marked resolved!!' })

      expect(MessageTemplates::Template::CsatSurvey).not_to have_received(:new).with(conversation: conversation)
      expect(csat_survey).not_to have_received(:perform)
    end
  end

  context 'when it is after working hours' do
    it 'calls ::MessageTemplates::Template::OutOfOffice' do
      contact = create(:contact)
      conversation = create(:conversation, contact: contact)

      conversation.inbox.update(working_hours_enabled: true, out_of_office_message: 'We are out of office')
      conversation.inbox.working_hours.today.update!(closed_all_day: true)

      out_of_office_service = double

      allow(MessageTemplates::Template::OutOfOffice).to receive(:new).and_return(out_of_office_service)
      allow(out_of_office_service).to receive(:perform).and_return(true)

      # described class gets called in message after commit
      message = create(:message, conversation: conversation)

      expect(MessageTemplates::Template::OutOfOffice).to have_received(:new).with(conversation: message.conversation)
      expect(out_of_office_service).to have_received(:perform)
    end

    it 'will not calls ::MessageTemplates::Template::OutOfOffice when outgoing message' do
      contact = create(:contact)
      conversation = create(:conversation, contact: contact)

      conversation.inbox.update(working_hours_enabled: true, out_of_office_message: 'We are out of office')
      conversation.inbox.working_hours.today.update!(closed_all_day: true)

      out_of_office_service = double

      allow(MessageTemplates::Template::OutOfOffice).to receive(:new).and_return(out_of_office_service)
      allow(out_of_office_service).to receive(:perform).and_return(true)

      # described class gets called in message after commit
      message = create(:message, conversation: conversation, message_type: 'outgoing')

      expect(MessageTemplates::Template::OutOfOffice).not_to have_received(:new).with(conversation: message.conversation)
      expect(out_of_office_service).not_to have_received(:perform)
    end

    it 'will not call ::MessageTemplates::Template::OutOfOffice if its a tweet conversation' do
      twitter_channel = create(:channel_twitter_profile)
      twitter_inbox = create(:inbox, channel: twitter_channel)
      twitter_inbox.update(working_hours_enabled: true, out_of_office_message: 'We are out of office')

      conversation = create(:conversation, inbox: twitter_inbox, additional_attributes: { type: 'tweet' })

      out_of_office_service = double

      allow(MessageTemplates::Template::OutOfOffice).to receive(:new).and_return(out_of_office_service)
      allow(out_of_office_service).to receive(:perform).and_return(false)

      message = create(:message, conversation: conversation)
      expect(MessageTemplates::Template::OutOfOffice).not_to have_received(:new).with(conversation: message.conversation)
      expect(out_of_office_service).not_to receive(:perform)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class MessageTemplates::Template::OutOfOffice
  pattr_initialize [:conversation!]

  def perform
    ActiveRecord::Base.transaction do
      conversation.messages.create!(out_of_office_message_params)
    end
  rescue StandardError => e
    ChatwootExceptionTracker.new(e, account: conversation.account).capture_exception
    true
  end

  private

  delegate :contact, :account, to: :conversation
  delegate :inbox, to: :message

  def out_of_office_message_params
    content = @conversation.inbox&.out_of_office_message

    {
      account_id: @conversation.account_id,
      inbox_id: @conversation.inbox_id,
      message_type: :template,
      content: content
    }
  end
end

```","require 'rails_helper'

describe MessageTemplates::Template::OutOfOffice do
  context 'when this hook is called' do
    let(:conversation) { create(:conversation) }

    it 'creates the out of office messages' do
      described_class.new(conversation: conversation).perform
      expect(conversation.messages.template.count).to eq(1)
      expect(conversation.messages.template.first.content).to eq(conversation.inbox.out_of_office_message)
    end

    it 'creates the out of office messages with template variable' do
      conversation.inbox.update!(out_of_office_message: 'Hey, {{contact.name}} we are unavailable at the moment.')
      described_class.new(conversation: conversation).perform
      expect(conversation.messages.count).to eq(1)
      expect(conversation.messages.last.content).to eq(""Hey, #{conversation.contact.name} we are unavailable at the moment."")
    end

    it 'creates the out of office messages with more than one variable strings' do
      conversation.inbox.update!(out_of_office_message:
        'Hey, {{contact.name}} we are unavailable at the moment. - from {{account.name}}')
      described_class.new(conversation: conversation).perform
      expect(conversation.messages.count).to eq(1)
      expect(conversation.messages.last.content).to eq(
        ""Hey, #{conversation.contact.name} we are unavailable at the moment. - from #{conversation.account.name}""
      )
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class MessageTemplates::Template::CsatSurvey
  pattr_initialize [:conversation!]

  def perform
    ActiveRecord::Base.transaction do
      conversation.messages.create!(csat_survey_message_params)
    end
  end

  private

  delegate :contact, :account, to: :conversation
  delegate :inbox, to: :message

  def csat_survey_message_params
    {
      account_id: @conversation.account_id,
      inbox_id: @conversation.inbox_id,
      message_type: :template,
      content_type: :input_csat,
      content: I18n.t('conversations.templates.csat_input_message_body')
    }
  end
end

```","require 'rails_helper'

describe MessageTemplates::Template::CsatSurvey do
  context 'when this hook is called' do
    let(:conversation) { create(:conversation) }

    it 'creates the out of office messages' do
      described_class.new(conversation: conversation).perform
      expect(conversation.messages.template.count).to eq(1)
      expect(conversation.messages.template.first.content_type).to eq('input_csat')
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class MessageTemplates::Template::EmailCollect
  pattr_initialize [:conversation!]

  def perform
    ActiveRecord::Base.transaction do
      conversation.messages.create!(ways_to_reach_you_message_params)
      conversation.messages.create!(email_input_box_template_message_params)
    end
  rescue StandardError => e
    ChatwootExceptionTracker.new(e, account: conversation.account).capture_exception
    true
  end

  private

  delegate :contact, :account, to: :conversation
  delegate :inbox, to: :message

  def ways_to_reach_you_message_params
    content = I18n.t('conversations.templates.ways_to_reach_you_message_body',
                     account_name: account.name)

    {
      account_id: @conversation.account_id,
      inbox_id: @conversation.inbox_id,
      message_type: :template,
      content: content
    }
  end

  def email_input_box_template_message_params
    content = I18n.t('conversations.templates.email_input_box_message_body',
                     account_name: account.name)

    {
      account_id: @conversation.account_id,
      inbox_id: @conversation.inbox_id,
      message_type: :template,
      content_type: :input_email,
      content: content
    }
  end
end

```","require 'rails_helper'

describe MessageTemplates::Template::EmailCollect do
  context 'when this hook is called' do
    let(:conversation) { create(:conversation) }

    it 'creates the email collect messages' do
      described_class.new(conversation: conversation).perform
      expect(conversation.messages.count).to eq(2)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class MessageTemplates::Template::Greeting
  pattr_initialize [:conversation!]

  def perform
    ActiveRecord::Base.transaction do
      conversation.messages.create!(greeting_message_params)
    end
  rescue StandardError => e
    ChatwootExceptionTracker.new(e, account: conversation.account).capture_exception
    true
  end

  private

  delegate :contact, :account, to: :conversation
  delegate :inbox, to: :message

  def greeting_message_params
    content = @conversation.inbox&.greeting_message

    {
      account_id: @conversation.account_id,
      inbox_id: @conversation.inbox_id,
      message_type: :template,
      content: content
    }
  end
end

```","require 'rails_helper'

describe MessageTemplates::Template::Greeting do
  context 'when this hook is called' do
    let(:conversation) { create(:conversation) }

    it 'creates the email collect messages' do
      described_class.new(conversation: conversation).perform
      expect(conversation.messages.count).to eq(1)
    end

    it 'creates the greeting messages with template variable' do
      conversation.inbox.update!(greeting_message: 'Hey, {{contact.name}} welcome to our board.')
      described_class.new(conversation: conversation).perform
      expect(conversation.messages.count).to eq(1)
      expect(conversation.messages.last.content).to eq(""Hey, #{conversation.contact.name} welcome to our board."")
    end

    it 'creates the greeting messages with more than one variable strings' do
      conversation.inbox.update!(greeting_message: 'Hey, {{contact.name}} welcome to our board. - from {{account.name}}')
      described_class.new(conversation: conversation).perform
      expect(conversation.messages.count).to eq(1)
      expect(conversation.messages.last.content).to eq(""Hey, #{conversation.contact.name} welcome to our board. - from #{conversation.account.name}"")
    end

    it 'creates the greeting messages' do
      conversation.inbox.update!(greeting_message: 'Hello welcome to our board.')
      described_class.new(conversation: conversation).perform
      expect(conversation.messages.count).to eq(1)
      expect(conversation.messages.last.content).to eq('Hello welcome to our board.')
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Instagram::ReadStatusService
  pattr_initialize [:params!]

  def perform
    return if instagram_channel.blank?

    ::Conversations::UpdateMessageStatusJob.perform_later(message.conversation.id, message.created_at) if message.present?
  end

  def instagram_id
    params[:recipient][:id]
  end

  def instagram_channel
    @instagram_channel ||= Channel::FacebookPage.find_by(instagram_id: instagram_id)
  end

  def message
    return unless params[:read][:mid]

    @message ||= @instagram_channel.inbox.messages.find_by(source_id: params[:read][:mid])
  end
end

```","require 'rails_helper'

describe Instagram::ReadStatusService do
  before do
    create(:message, message_type: :incoming, inbox: instagram_inbox, account: account, conversation: conversation,
                     source_id: 'chatwoot-app-user-id-1')
  end

  let!(:account) { create(:account) }
  let!(:instagram_channel) { create(:channel_instagram_fb_page, account: account, instagram_id: 'chatwoot-app-user-id-1') }
  let!(:instagram_inbox) { create(:inbox, channel: instagram_channel, account: account, greeting_enabled: false) }
  let!(:contact) { create(:contact, account: account) }
  let(:contact_inbox) { create(:contact_inbox, contact: contact, inbox: instagram_inbox) }
  let(:conversation) { create(:conversation, contact: contact, inbox: instagram_inbox, contact_inbox: contact_inbox) }

  describe '#perform' do
    context 'when messaging_seen callback is fired' do
      let(:message) { conversation.messages.last }

      before do
        allow(Conversations::UpdateMessageStatusJob).to receive(:perform_later)
      end

      it 'enqueues the UpdateMessageStatusJob with correct parameters if the message is found' do
        params = {
          recipient: {
            id: 'chatwoot-app-user-id-1'
          },
          read: {
            mid: message.source_id
          }
        }
        described_class.new(params: params).perform
        expect(Conversations::UpdateMessageStatusJob).to have_received(:perform_later).with(conversation.id, message.created_at)
      end

      it 'does not enqueue the UpdateMessageStatusJob if the message is not found' do
        params = {
          recipient: {
            id: 'chatwoot-app-user-id-1'
          },
          read: {
            mid: 'random-message-id'
          }
        }
        described_class.new(params: params).perform
        expect(Conversations::UpdateMessageStatusJob).not_to have_received(:perform_later)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Instagram::SendOnInstagramService < Base::SendOnChannelService
  include HTTParty

  pattr_initialize [:message!]

  base_uri 'https://graph.facebook.com/v11.0/me'

  private

  delegate :additional_attributes, to: :contact

  def channel_class
    Channel::FacebookPage
  end

  def perform_reply
    send_to_facebook_page attachament_message_params if message.attachments.present?
    send_to_facebook_page message_params
  rescue StandardError => e
    ChatwootExceptionTracker.new(e, account: message.account, user: message.sender).capture_exception
    # TODO : handle specific errors or else page will get disconnected
    # channel.authorization_error!
  end

  def message_params
    params = {
      recipient: { id: contact.get_source_id(inbox.id) },
      message: {
        text: message.content
      }
    }

    merge_human_agent_tag(params)
  end

  def attachament_message_params
    attachment = message.attachments.first
    params = {
      recipient: { id: contact.get_source_id(inbox.id) },
      message: {
        attachment: {
          type: attachment_type(attachment),
          payload: {
            url: attachment.download_url
          }
        }
      }
    }

    merge_human_agent_tag(params)
  end

  # Deliver a message with the given payload.
  # @see https://developers.facebook.com/docs/messenger-platform/instagram/features/send-message
  def send_to_facebook_page(message_content)
    access_token = channel.page_access_token
    app_secret_proof = calculate_app_secret_proof(GlobalConfigService.load('FB_APP_SECRET', ''), access_token)
    query = { access_token: access_token }
    query[:appsecret_proof] = app_secret_proof if app_secret_proof

    # url = ""https://graph.facebook.com/v11.0/me/messages?access_token=#{access_token}""

    response = HTTParty.post(
      'https://graph.facebook.com/v11.0/me/messages',
      body: message_content,
      query: query
    )

    if response[:error].present?
      Rails.logger.error(""Instagram response: #{response['error']} : #{message_content}"")
      message.status = :failed
      message.external_error = external_error(response)
    end

    message.source_id = response['message_id'] if response['message_id'].present?
    message.save!

    response
  end

  def external_error(response)
    # https://developers.facebook.com/docs/instagram-api/reference/error-codes/
    error_message = response[:error][:message]
    error_code = response[:error][:code]

    ""#{error_code} - #{error_message}""
  end

  def calculate_app_secret_proof(app_secret, access_token)
    Facebook::Messenger::Configuration::AppSecretProofCalculator.call(
      app_secret, access_token
    )
  end

  def attachment_type(attachment)
    return attachment.file_type if %w[image audio video file].include? attachment.file_type

    'file'
  end

  def conversation_type
    conversation.additional_attributes['type']
  end

  def sent_first_outgoing_message_after_24_hours?
    # we can send max 1 message after 24 hour window
    conversation.messages.outgoing.where('id > ?', conversation.last_incoming_message.id).count == 1
  end

  def config
    Facebook::Messenger.config
  end

  def merge_human_agent_tag(params)
    global_config = GlobalConfig.get('ENABLE_MESSENGER_CHANNEL_HUMAN_AGENT')

    return params unless global_config['ENABLE_MESSENGER_CHANNEL_HUMAN_AGENT']

    params[:messaging_type] = 'MESSAGE_TAG'
    params[:tag] = 'HUMAN_AGENT'
    params
  end
end

```","require 'rails_helper'

describe Instagram::SendOnInstagramService do
  subject(:send_reply_service) { described_class.new(message: message) }

  before do
    stub_request(:post, /graph.facebook.com/)
    create(:message, message_type: :incoming, inbox: instagram_inbox, account: account, conversation: conversation)
  end

  let!(:account) { create(:account) }
  let!(:instagram_channel) { create(:channel_instagram_fb_page, account: account, instagram_id: 'chatwoot-app-user-id-1') }
  let!(:instagram_inbox) { create(:inbox, channel: instagram_channel, account: account, greeting_enabled: false) }
  let!(:contact) { create(:contact, account: account) }
  let(:contact_inbox) { create(:contact_inbox, contact: contact, inbox: instagram_inbox) }
  let(:conversation) { create(:conversation, contact: contact, inbox: instagram_inbox, contact_inbox: contact_inbox) }
  let(:response) { double }

  describe '#perform' do
    context 'with reply' do
      before do
        allow(Facebook::Messenger::Configuration::AppSecretProofCalculator).to receive(:call).and_return('app_secret_key', 'access_token')
        allow(HTTParty).to receive(:post).and_return(
          {
            'message_id': 'anyrandommessageid1234567890'
          }
        )
      end

      context 'without message_tag HUMAN_AGENT' do
        before do
          InstallationConfig.where(name: 'ENABLE_MESSENGER_CHANNEL_HUMAN_AGENT').first_or_create(value: false)
        end

        it 'if message is sent from chatwoot and is outgoing' do
          message = create(:message, message_type: 'outgoing', inbox: instagram_inbox, account: account, conversation: conversation)

          allow(HTTParty).to receive(:post).with(
            {
              recipient: { id: contact.get_source_id(instagram_inbox.id) },
              message: {
                text: message.content
              }
            }
          ).and_return(
            {
              'message_id': 'anyrandommessageid1234567890'
            }
          )

          response = described_class.new(message: message).perform

          expect(response).to eq({  message_id: 'anyrandommessageid1234567890' })
        end

        it 'if message with attachment is sent from chatwoot and is outgoing' do
          message = build(:message, message_type: 'outgoing', inbox: instagram_inbox, account: account, conversation: conversation)
          attachment = message.attachments.new(account_id: message.account_id, file_type: :image)
          attachment.file.attach(io: Rails.root.join('spec/assets/avatar.png').open, filename: 'avatar.png', content_type: 'image/png')
          message.save!
          response = described_class.new(message: message).perform

          expect(response).to eq({ message_id: 'anyrandommessageid1234567890' })
        end

        it 'if message sent from chatwoot is failed' do
          message = create(:message, message_type: 'outgoing', inbox: instagram_inbox, account: account, conversation: conversation)

          allow(HTTParty).to receive(:post).and_return(
            {
              'error': {
                'message': 'The Instagram account is restricted.',
                'type': 'OAuthException',
                'code': 400,
                'fbtrace_id': 'anyrandomfbtraceid1234567890'
              }
            }
          )
          described_class.new(message: message).perform
          expect(HTTParty).to have_received(:post)
          expect(message.reload.status).to eq('failed')
          expect(message.reload.external_error).to eq('400 - The Instagram account is restricted.')
        end
      end

      context 'with message_tag HUMAN_AGENT' do
        before do
          InstallationConfig.where(name: 'ENABLE_MESSENGER_CHANNEL_HUMAN_AGENT').first_or_create(value: true)
        end

        it 'if message is sent from chatwoot and is outgoing' do
          message = create(:message, message_type: 'outgoing', inbox: instagram_inbox, account: account, conversation: conversation)

          allow(HTTParty).to receive(:post).with(
            {
              recipient: { id: contact.get_source_id(instagram_inbox.id) },
              message: {
                text: message.content
              },
              messaging_type: 'MESSAGE_TAG',
              tag: 'HUMAN_AGENT'
            }
          ).and_return(
            {
              'message_id': 'anyrandommessageid1234567890'
            }
          )

          described_class.new(message: message).perform
          expect(HTTParty).to have_received(:post)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# https://docs.360dialog.com/whatsapp-api/whatsapp-api/media
# https://developers.facebook.com/docs/whatsapp/api/media/

class Whatsapp::IncomingMessageService < Whatsapp::IncomingMessageBaseService
end

```","require 'rails_helper'

describe Whatsapp::IncomingMessageService do
  describe '#perform' do
    before do
      stub_request(:post, 'https://waba.360dialog.io/v1/configs/webhook')
    end

    let!(:whatsapp_channel) { create(:channel_whatsapp, sync_templates: false) }
    let(:wa_id) { '2423423243' }
    let!(:params) do
      {
        'contacts' => [{ 'profile' => { 'name' => 'Sojan Jose' }, 'wa_id' => wa_id }],
        'messages' => [{ 'from' => wa_id, 'id' => 'SDFADSf23sfasdafasdfa', 'text' => { 'body' => 'Test' },
                         'timestamp' => '1633034394', 'type' => 'text' }]
      }.with_indifferent_access
    end

    context 'when valid text message params' do
      it 'creates appropriate conversations, message and contacts' do
        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
        expect(whatsapp_channel.inbox.conversations.count).not_to eq(0)
        expect(Contact.all.first.name).to eq('Sojan Jose')
        expect(whatsapp_channel.inbox.messages.first.content).to eq('Test')
      end

      it 'appends to last conversation when if conversation already exists' do
        contact_inbox = create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: params[:messages].first[:from])
        2.times.each { create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox) }
        last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
        # no new conversation should be created
        expect(whatsapp_channel.inbox.conversations.count).to eq(3)
        # message appended to the last conversation
        expect(last_conversation.messages.last.content).to eq(params[:messages].first[:text][:body])
      end

      it 'reopen last conversation if last conversation is resolved and lock to single conversation is enabled' do
        whatsapp_channel.inbox.update(lock_to_single_conversation: true)
        contact_inbox = create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: params[:messages].first[:from])
        last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
        last_conversation.update(status: 'resolved')
        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
        # no new conversation should be created
        expect(whatsapp_channel.inbox.conversations.count).to eq(1)
        # message appended to the last conversation
        expect(last_conversation.messages.last.content).to eq(params[:messages].first[:text][:body])
        expect(last_conversation.reload.status).to eq('open')
      end

      it 'creates a new conversation if last conversation is resolved and lock to single conversation is disabled' do
        whatsapp_channel.inbox.update(lock_to_single_conversation: false)
        contact_inbox = create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: params[:messages].first[:from])
        last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
        last_conversation.update(status: 'resolved')
        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
        # new conversation should be created
        expect(whatsapp_channel.inbox.conversations.count).to eq(2)
        expect(contact_inbox.conversations.last.messages.last.content).to eq(params[:messages].first[:text][:body])
      end

      it 'will not create a new conversation if last conversation is not resolved and lock to single conversation is disabled' do
        whatsapp_channel.inbox.update(lock_to_single_conversation: false)
        contact_inbox = create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: params[:messages].first[:from])
        last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
        last_conversation.update(status: Conversation.statuses.except('resolved').keys.sample)
        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
        # new conversation should be created
        expect(whatsapp_channel.inbox.conversations.count).to eq(1)
        expect(contact_inbox.conversations.last.messages.last.content).to eq(params[:messages].first[:text][:body])
      end

      it 'will not create duplicate messages when same message is received' do
        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
        expect(whatsapp_channel.inbox.messages.count).to eq(1)

        # this shouldn't create a duplicate message
        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
        expect(whatsapp_channel.inbox.messages.count).to eq(1)
      end
    end

    context 'when unsupported message types' do
      it 'ignores type ephemeral' do
        params = {
          'contacts' => [{ 'profile' => { 'name' => 'Sojan Jose' }, 'wa_id' => '2423423243' }],
          'messages' => [{ 'from' => '2423423243', 'id' => 'SDFADSf23sfasdafasdfa', 'text' => { 'body' => 'Test' },
                           'timestamp' => '1633034394', 'type' => 'ephemeral' }]
        }.with_indifferent_access

        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
        expect(whatsapp_channel.inbox.conversations.count).not_to eq(0)
        expect(Contact.all.first.name).to eq('Sojan Jose')
        expect(whatsapp_channel.inbox.messages.count).to eq(0)
      end

      it 'ignores type unsupported' do
        params = {
          'contacts' => [{ 'profile' => { 'name' => 'Sojan Jose' }, 'wa_id' => '2423423243' }],
          'messages' => [{
            'errors' => [{ 'code': 131_051, 'title': 'Message type is currently not supported.' }],
            :from => '2423423243', :id => 'wamid.SDFADSf23sfasdafasdfa',
            :timestamp => '1667047370', :type => 'unsupported'
          }]
        }.with_indifferent_access

        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
        expect(whatsapp_channel.inbox.conversations.count).not_to eq(0)
        expect(Contact.all.first.name).to eq('Sojan Jose')
        expect(whatsapp_channel.inbox.messages.count).to eq(0)
      end
    end

    context 'when valid status params' do
      let(:from) { '2423423243' }
      let(:contact_inbox) { create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: from) }
      let(:params) do
        {
          'contacts' => [{ 'profile' => { 'name' => 'Sojan Jose' }, 'wa_id' => from }],
          'messages' => [{ 'from' => from, 'id' => from, 'text' => { 'body' => 'Test' },
                           'timestamp' => '1633034394', 'type' => 'text' }]
        }.with_indifferent_access
      end

      before do
        create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
      end

      it 'update status message to read' do
        status_params = {
          'statuses' => [{ 'recipient_id' => from, 'id' => from, 'status' => 'read' }]
        }.with_indifferent_access
        message = Message.find_by!(source_id: from)
        expect(message.status).to eq('sent')
        described_class.new(inbox: whatsapp_channel.inbox, params: status_params).perform
        expect(message.reload.status).to eq('read')
      end

      it 'update status message to failed' do
        status_params = {
          'statuses' => [{ 'recipient_id' => from, 'id' => from, 'status' => 'failed',
                           'errors' => [{ 'code': 123, 'title': 'abc' }] }]
        }.with_indifferent_access

        message = Message.find_by!(source_id: from)
        expect(message.status).to eq('sent')
        described_class.new(inbox: whatsapp_channel.inbox, params: status_params).perform
        expect(message.reload.status).to eq('failed')
        expect(message.external_error).to eq('123: abc')
      end

      it 'will not throw error if unsupported status' do
        status_params = {
          'statuses' => [{ 'recipient_id' => from, 'id' => from, 'status' => 'deleted',
                           'errors' => [{ 'code': 123, 'title': 'abc' }] }]
        }.with_indifferent_access

        message = Message.find_by!(source_id: from)
        expect(message.status).to eq('sent')
        expect { described_class.new(inbox: whatsapp_channel.inbox, params: status_params).perform }.not_to raise_error
      end
    end

    context 'when valid interactive message params' do
      it 'creates appropriate conversations, message and contacts' do
        params = {
          'contacts' => [{ 'profile' => { 'name' => 'Sojan Jose' }, 'wa_id' => '2423423243' }],
          'messages' => [{ 'from' => '2423423243', 'id' => 'SDFADSf23sfasdafasdfa',
                           :interactive => {
                             'button_reply': {
                               'id': '1',
                               'title': 'First Button'
                             },
                             'type': 'button_reply'
                           },
                           'timestamp' => '1633034394', 'type' => 'interactive' }]
        }.with_indifferent_access
        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
        expect(whatsapp_channel.inbox.conversations.count).not_to eq(0)
        expect(Contact.all.first.name).to eq('Sojan Jose')
        expect(whatsapp_channel.inbox.messages.first.content).to eq('First Button')
      end
    end

    # ref: https://github.com/chatwoot/chatwoot/issues/3795#issuecomment-1018057318
    context 'when valid template button message params' do
      it 'creates appropriate conversations, message and contacts' do
        params = {
          'contacts' => [{ 'profile' => { 'name' => 'Sojan Jose' }, 'wa_id' => '2423423243' }],
          'messages' => [{ 'from' => '2423423243', 'id' => 'SDFADSf23sfasdafasdfa',
                           'button' => {
                             'text' => 'Yes this is a button'
                           },
                           'timestamp' => '1633034394', 'type' => 'button' }]
        }.with_indifferent_access
        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
        expect(whatsapp_channel.inbox.conversations.count).not_to eq(0)
        expect(Contact.all.first.name).to eq('Sojan Jose')
        expect(whatsapp_channel.inbox.messages.first.content).to eq('Yes this is a button')
      end
    end

    context 'when valid attachment message params' do
      it 'creates appropriate conversations, message and contacts' do
        stub_request(:get, whatsapp_channel.media_url('b1c68f38-8734-4ad3-b4a1-ef0c10d683')).to_return(
          status: 200,
          body: File.read('spec/assets/sample.png'),
          headers: {}
        )
        params = {
          'contacts' => [{ 'profile' => { 'name' => 'Sojan Jose' }, 'wa_id' => '2423423243' }],
          'messages' => [{ 'from' => '2423423243', 'id' => 'SDFADSf23sfasdafasdfa',
                           'image' => { 'id' => 'b1c68f38-8734-4ad3-b4a1-ef0c10d683',
                                        'mime_type' => 'image/jpeg',
                                        'sha256' => '29ed500fa64eb55fc19dc4124acb300e5dcca0f822a301ae99944db',
                                        'caption' => 'Check out my product!' },
                           'timestamp' => '1633034394', 'type' => 'image' }]
        }.with_indifferent_access
        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
        expect(whatsapp_channel.inbox.conversations.count).not_to eq(0)
        expect(Contact.all.first.name).to eq('Sojan Jose')
        expect(whatsapp_channel.inbox.messages.first.content).to eq('Check out my product!')
        expect(whatsapp_channel.inbox.messages.first.attachments.present?).to be true
      end
    end

    context 'when valid location message params' do
      it 'creates appropriate conversations, message and contacts' do
        params = {
          'contacts' => [{ 'profile' => { 'name' => 'Sojan Jose' }, 'wa_id' => '2423423243' }],
          'messages' => [{ 'from' => '2423423243', 'id' => 'SDFADSf23sfasdafasdfa',
                           'location' => { 'id' => 'b1c68f38-8734-4ad3-b4a1-ef0c10d683',
                                           :address => 'San Francisco, CA, USA',
                                           :latitude => 37.7893768,
                                           :longitude => -122.3895553,
                                           :name => 'Bay Bridge',
                                           :url => 'http://location_url.test' },
                           'timestamp' => '1633034394', 'type' => 'location' }]
        }.with_indifferent_access
        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
        expect(whatsapp_channel.inbox.conversations.count).not_to eq(0)
        expect(Contact.all.first.name).to eq('Sojan Jose')
        location_attachment = whatsapp_channel.inbox.messages.first.attachments.first
        expect(location_attachment.file_type).to eq('location')
        expect(location_attachment.fallback_title).to eq('Bay Bridge, San Francisco, CA, USA')
        expect(location_attachment.coordinates_lat).to eq(37.7893768)
        expect(location_attachment.coordinates_long).to eq(-122.3895553)
        expect(location_attachment.external_url).to eq('http://location_url.test')
      end
    end

    context 'when valid contact message params' do
      it 'creates appropriate message and attachments' do
        params = { 'contacts' => [{ 'profile' => { 'name' => 'Kedar' }, 'wa_id' => '919746334593' }],
                   'messages' => [{ 'from' => '919446284490',
                                    'id' => 'wamid.SDFADSf23sfasdafasdfa',
                                    'timestamp' => '1675823265',
                                    'type' => 'contacts',
                                    'contacts' => [
                                      {
                                        'name' => { 'formatted_name' => 'Apple Inc.' },
                                        'phones' => [{ 'phone' => '+911800', 'type' => 'MAIN' }]
                                      },
                                      { 'name' => { 'first_name' => 'Chatwoot', 'formatted_name' => 'Chatwoot' },
                                        'phones' => [{ 'phone' => '+1 (415) 341-8386' }] }
                                    ] }] }.with_indifferent_access
        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
        expect(Contact.all.first.name).to eq('Kedar')

        expect(whatsapp_channel.inbox.conversations.count).not_to eq(0)

        # Two messages are tested deliberately to ensure multiple contact attachments work.
        m1 = whatsapp_channel.inbox.messages.first
        contact_attachments = m1.attachments.first
        expect(m1.content).to eq('Apple Inc.')
        expect(contact_attachments.fallback_title).to eq('+911800')

        m2 = whatsapp_channel.inbox.messages.last
        contact_attachments = m2.attachments.first
        expect(m2.content).to eq('Chatwoot')
        expect(contact_attachments.fallback_title).to eq('+1 (415) 341-8386')
      end
    end

    # ref: https://github.com/chatwoot/chatwoot/issues/5840
    describe 'When the incoming waid is a brazilian number in new format with 9 included' do
      let(:wa_id) { '5541988887777' }

      it 'creates appropriate conversations, message and contacts if contact does not exit' do
        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
        expect(whatsapp_channel.inbox.conversations.count).not_to eq(0)
        expect(Contact.all.first.name).to eq('Sojan Jose')
        expect(whatsapp_channel.inbox.messages.first.content).to eq('Test')
        expect(whatsapp_channel.inbox.contact_inboxes.first.source_id).to eq(wa_id)
      end

      it 'appends to existing contact if contact inbox exists' do
        contact_inbox = create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: wa_id)
        last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
        # no new conversation should be created
        expect(whatsapp_channel.inbox.conversations.count).to eq(1)
        # message appended to the last conversation
        expect(last_conversation.messages.last.content).to eq(params[:messages].first[:text][:body])
      end
    end

    describe 'When incoming waid is a brazilian number in old format without the 9 included' do
      let(:wa_id) { '554188887777' }

      context 'when a contact inbox exists in the old format without 9 included' do
        it 'appends to existing contact' do
          contact_inbox = create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: wa_id)
          last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
          described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
          # no new conversation should be created
          expect(whatsapp_channel.inbox.conversations.count).to eq(1)
          # message appended to the last conversation
          expect(last_conversation.messages.last.content).to eq(params[:messages].first[:text][:body])
        end
      end

      context 'when a contact inbox exists in the new format with 9 included' do
        it 'appends to existing contact' do
          contact_inbox = create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: '5541988887777')
          last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
          described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
          # no new conversation should be created
          expect(whatsapp_channel.inbox.conversations.count).to eq(1)
          # message appended to the last conversation
          expect(last_conversation.messages.last.content).to eq(params[:messages].first[:text][:body])
        end
      end

      context 'when a contact inbox does not exist in the new format with 9 included' do
        it 'creates contact inbox with the incoming waid' do
          described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
          expect(whatsapp_channel.inbox.conversations.count).not_to eq(0)
          expect(Contact.all.first.name).to eq('Sojan Jose')
          expect(whatsapp_channel.inbox.messages.first.content).to eq('Test')
          expect(whatsapp_channel.inbox.contact_inboxes.first.source_id).to eq(wa_id)
        end
      end
    end

    describe 'when message processing is in progress' do
      it 'ignores the current message creation request' do
        params = { 'contacts' => [{ 'profile' => { 'name' => 'Kedar' }, 'wa_id' => '919746334593' }],
                   'messages' => [{ 'from' => '919446284490',
                                    'id' => 'wamid.SDFADSf23sfasdafasdfa',
                                    'timestamp' => '1675823265',
                                    'type' => 'contacts',
                                    'contacts' => [
                                      {
                                        'name' => { 'formatted_name' => 'Apple Inc.' },
                                        'phones' => [{ 'phone' => '+911800', 'type' => 'MAIN' }]
                                      },
                                      { 'name' => { 'first_name' => 'Chatwoot', 'formatted_name' => 'Chatwoot' },
                                        'phones' => [{ 'phone' => '+1 (415) 341-8386' }] }
                                    ] }] }.with_indifferent_access

        expect(Message.find_by(source_id: 'wamid.SDFADSf23sfasdafasdfa')).not_to be_present
        key = format(Redis::RedisKeys::MESSAGE_SOURCE_KEY, id: 'wamid.SDFADSf23sfasdafasdfa')

        Redis::Alfred.setex(key, true)
        expect(Redis::Alfred.get(key)).to be_truthy

        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
        expect(whatsapp_channel.inbox.messages.count).to eq(0)
        expect(Message.find_by(source_id: 'wamid.SDFADSf23sfasdafasdfa')).not_to be_present

        expect(Redis::Alfred.get(key)).to be_truthy
        Redis::Alfred.delete(key)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Whatsapp::SendOnWhatsappService < Base::SendOnChannelService
  private

  def channel_class
    Channel::Whatsapp
  end

  def perform_reply
    should_send_template_message = template_params.present? || !message.conversation.can_reply?
    if should_send_template_message
      send_template_message
    else
      send_session_message
    end
  end

  def send_template_message
    name, namespace, lang_code, processed_parameters = processable_channel_message_template

    return if name.blank?

    message_id = channel.send_template(message.conversation.contact_inbox.source_id, {
                                         name: name,
                                         namespace: namespace,
                                         lang_code: lang_code,
                                         parameters: processed_parameters
                                       })
    message.update!(source_id: message_id) if message_id.present?
  end

  # rubocop:disable Metrics/CyclomaticComplexity
  def processable_channel_message_template
    if template_params.present?
      return [
        template_params['name'],
        template_params['namespace'],
        template_params['language'],
        template_params['processed_params']&.map { |_, value| { type: 'text', text: value } }
      ]
    end

    # Delete the following logic once the update for template_params is stable
    # see if we can match the message content to a template
    # An example template may look like ""Your package has been shipped. It will be delivered in {{1}} business days.
    # We want to iterate over these templates with our message body and see if we can fit it to any of the templates
    # Then we use regex to parse the template varibles and convert them into the proper payload
    channel.message_templates&.each do |template|
      match_obj = template_match_object(template)
      next if match_obj.blank?

      # we have a match, now we need to parse the template variables and convert them into the wa recommended format
      processed_parameters = match_obj.captures.map { |x| { type: 'text', text: x } }

      # no need to look up further end the search
      return [template['name'], template['namespace'], template['language'], processed_parameters]
    end
    [nil, nil, nil, nil]
  end
  # rubocop:enable Metrics/CyclomaticComplexity

  def template_match_object(template)
    body_object = validated_body_object(template)
    return if body_object.blank?

    template_match_regex = build_template_match_regex(body_object['text'])
    message.content.match(template_match_regex)
  end

  def build_template_match_regex(template_text)
    # Converts the whatsapp template to a comparable regex string to check against the message content
    # the variables are of the format {{num}} ex:{{1}}

    # transform the template text into a regex string
    # we need to replace the {{num}} with matchers that can be used to capture the variables
    template_text = template_text.gsub(/{{\d}}/, '(.*)')
    # escape if there are regex characters in the template text
    template_text = Regexp.escape(template_text)
    # ensuring only the variables remain as capture groups
    template_text = template_text.gsub(Regexp.escape('(.*)'), '(.*)')

    template_match_string = ""^#{template_text}$""
    Regexp.new template_match_string
  end

  def validated_body_object(template)
    # we don't care if its not approved template
    return if template['status'] != 'approved'

    # we only care about text body object in template. if not present we discard the template
    # we don't support other forms of templates
    template['components'].find { |obj| obj['type'] == 'BODY' && obj.key?('text') }
  end

  def send_session_message
    message_id = channel.send_message(message.conversation.contact_inbox.source_id, message)
    message.update!(source_id: message_id) if message_id.present?
  end

  def template_params
    message.additional_attributes && message.additional_attributes['template_params']
  end
end

```","require 'rails_helper'

describe Whatsapp::SendOnWhatsappService do
  template_params = {
    name: 'sample_shipping_confirmation',
    namespace: '23423423_2342423_324234234_2343224',
    language: 'en_US',
    category: 'Marketing',
    processed_params: { '1' => '3' }
  }

  describe '#perform' do
    before do
      stub_request(:post, 'https://waba.360dialog.io/v1/configs/webhook')
    end

    context 'when a valid message' do
      let(:whatsapp_request) { double }
      let!(:whatsapp_channel) { create(:channel_whatsapp, sync_templates: false) }
      let!(:contact_inbox) { create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: '123456789') }
      let!(:conversation) { create(:conversation, contact_inbox: contact_inbox, inbox: whatsapp_channel.inbox) }

      it 'calls channel.send_message when with in 24 hour limit' do
        # to handle the case of 24 hour window limit.
        create(:message, message_type: :incoming, content: 'test',
                         conversation: conversation)
        message = create(:message, message_type: :outgoing, content: 'test',
                                   conversation: conversation)
        allow(HTTParty).to receive(:post).and_return(whatsapp_request)
        allow(whatsapp_request).to receive(:success?).and_return(true)
        allow(whatsapp_request).to receive(:[]).with('messages').and_return([{ 'id' => '123456789' }])
        expect(HTTParty).to receive(:post).with(
          'https://waba.360dialog.io/v1/messages',
          headers: { 'D360-API-KEY' => 'test_key', 'Content-Type' => 'application/json' },
          body: { 'to' => '123456789', 'text' => { 'body' => 'test' }, 'type' => 'text' }.to_json
        )
        described_class.new(message: message).perform
        expect(message.reload.source_id).to eq('123456789')
      end

      it 'calls channel.send_template when after 24 hour limit' do
        message = create(:message, message_type: :outgoing, content: 'Your package has been shipped. It will be delivered in 3 business days.',
                                   conversation: conversation)
        allow(HTTParty).to receive(:post).and_return(whatsapp_request)
        allow(whatsapp_request).to receive(:success?).and_return(true)
        allow(whatsapp_request).to receive(:[]).with('messages').and_return([{ 'id' => '123456789' }])
        expect(HTTParty).to receive(:post).with(
          'https://waba.360dialog.io/v1/messages',
          headers: { 'D360-API-KEY' => 'test_key', 'Content-Type' => 'application/json' },
          body: {
            to: '123456789',
            template: {
              name: 'sample_shipping_confirmation',
              namespace: '23423423_2342423_324234234_2343224',
              language: { 'policy': 'deterministic', 'code': 'en_US' },
              components: [{ 'type': 'body', 'parameters': [{ 'type': 'text', 'text': '3' }] }]
            },
            type: 'template'
          }.to_json
        )
        described_class.new(message: message).perform
        expect(message.reload.source_id).to eq('123456789')
      end

      it 'calls channel.send_template if template_params are present' do
        message = create(:message, additional_attributes: { template_params: template_params },
                                   content: 'Your package will be delivered in 3 business days.', conversation: conversation, message_type: :outgoing)
        allow(HTTParty).to receive(:post).and_return(whatsapp_request)
        allow(whatsapp_request).to receive(:success?).and_return(true)
        allow(whatsapp_request).to receive(:[]).with('messages').and_return([{ 'id' => '123456789' }])
        expect(HTTParty).to receive(:post).with(
          'https://waba.360dialog.io/v1/messages',
          headers: { 'D360-API-KEY' => 'test_key', 'Content-Type' => 'application/json' },
          body: {
            to: '123456789',
            template: {
              name: 'sample_shipping_confirmation',
              namespace: '23423423_2342423_324234234_2343224',
              language: { 'policy': 'deterministic', 'code': 'en_US' },
              components: [{ 'type': 'body', 'parameters': [{ 'type': 'text', 'text': '3' }] }]
            },
            type: 'template'
          }.to_json
        )
        described_class.new(message: message).perform
        expect(message.reload.source_id).to eq('123456789')
      end

      it 'calls channel.send_template when template has regexp characters' do
        message = create(
          :message,
          message_type: :outgoing,
          content: 'عميلنا العزيز الرجاء الرد على هذه الرسالة بكلمة *نعم* للرد على إستفساركم من قبل خدمة العملاء.',
          conversation: conversation
        )
        allow(HTTParty).to receive(:post).and_return(whatsapp_request)
        allow(whatsapp_request).to receive(:success?).and_return(true)
        allow(whatsapp_request).to receive(:[]).with('messages').and_return([{ 'id' => '123456789' }])
        expect(HTTParty).to receive(:post).with(
          'https://waba.360dialog.io/v1/messages',
          headers: { 'D360-API-KEY' => 'test_key', 'Content-Type' => 'application/json' },
          body: {
            to: '123456789',
            template: {
              name: 'customer_yes_no',
              namespace: '2342384942_32423423_23423fdsdaf23',
              language: { 'policy': 'deterministic', 'code': 'ar' },
              components: [{ 'type': 'body', 'parameters': [] }]
            },
            type: 'template'
          }.to_json
        )
        described_class.new(message: message).perform
        expect(message.reload.source_id).to eq('123456789')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# https://docs.360dialog.com/whatsapp-api/whatsapp-api/media
# https://developers.facebook.com/docs/whatsapp/api/media/

class Whatsapp::IncomingMessageWhatsappCloudService < Whatsapp::IncomingMessageBaseService
  private

  def processed_params
    @processed_params ||= params[:entry].try(:first).try(:[], 'changes').try(:first).try(:[], 'value')
  end

  def download_attachment_file(attachment_payload)
    url_response = HTTParty.get(inbox.channel.media_url(attachment_payload[:id]), headers: inbox.channel.api_headers)
    # This url response will be failure if the access token has expired.
    inbox.channel.authorization_error! if url_response.unauthorized?
    Down.download(url_response.parsed_response['url'], headers: inbox.channel.api_headers) if url_response.success?
  end
end

```","require 'rails_helper'

describe Whatsapp::IncomingMessageWhatsappCloudService do
  describe '#perform' do
    let!(:whatsapp_channel) { create(:channel_whatsapp, provider: 'whatsapp_cloud', sync_templates: false, validate_provider_config: false) }
    let(:params) do
      {
        phone_number: whatsapp_channel.phone_number,
        object: 'whatsapp_business_account',
        entry: [{
          changes: [{
            value: {
              contacts: [{ profile: { name: 'Sojan Jose' }, wa_id: '2423423243' }],
              messages: [{
                from: '2423423243',
                image: {
                  id: 'b1c68f38-8734-4ad3-b4a1-ef0c10d683',
                  mime_type: 'image/jpeg',
                  sha256: '29ed500fa64eb55fc19dc4124acb300e5dcca0f822a301ae99944db',
                  caption: 'Check out my product!'
                },
                timestamp: '1664799904', type: 'image'
              }]
            }
          }]
        }]
      }.with_indifferent_access
    end

    context 'when valid attachment message params' do
      it 'creates appropriate conversations, message and contacts' do
        stub_request(:get, whatsapp_channel.media_url('b1c68f38-8734-4ad3-b4a1-ef0c10d683')).to_return(
          status: 200,
          body: {
            messaging_product: 'whatsapp',
            url: 'https://chatwoot-assets.local/sample.png',
            mime_type: 'image/jpeg',
            sha256: 'sha256',
            file_size: 'SIZE',
            id: 'b1c68f38-8734-4ad3-b4a1-ef0c10d683'
          }.to_json,
          headers: { 'content-type' => 'application/json' }
        )
        stub_request(:get, 'https://chatwoot-assets.local/sample.png').to_return(
          status: 200,
          body: File.read('spec/assets/sample.png')
        )

        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
        expect(whatsapp_channel.inbox.conversations.count).not_to eq(0)
        expect(Contact.all.first.name).to eq('Sojan Jose')
        expect(whatsapp_channel.inbox.messages.first.content).to eq('Check out my product!')
        expect(whatsapp_channel.inbox.messages.first.attachments.present?).to be true
      end

      it 'increments reauthorization count if fetching attachment fails' do
        stub_request(:get, whatsapp_channel.media_url('b1c68f38-8734-4ad3-b4a1-ef0c10d683')).to_return(
          status: 401
        )

        described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
        expect(whatsapp_channel.inbox.conversations.count).not_to eq(0)
        expect(Contact.all.first.name).to eq('Sojan Jose')
        expect(whatsapp_channel.inbox.messages.first.content).to eq('Check out my product!')
        expect(whatsapp_channel.inbox.messages.first.attachments.present?).to be false
        expect(whatsapp_channel.authorization_error_count).to eq(1)
      end
    end

    context 'when invalid attachment message params' do
      let(:error_params) do
        {
          phone_number: whatsapp_channel.phone_number,
          object: 'whatsapp_business_account',
          entry: [{
            changes: [{
              value: {
                contacts: [{ profile: { name: 'Sojan Jose' }, wa_id: '2423423243' }],
                messages: [{
                  from: '2423423243',
                  image: {
                    id: 'b1c68f38-8734-4ad3-b4a1-ef0c10d683',
                    mime_type: 'image/jpeg',
                    sha256: '29ed500fa64eb55fc19dc4124acb300e5dcca0f822a301ae99944db',
                    caption: 'Check out my product!'
                  },
                  errors: [{
                    code: 400,
                    details: 'Last error was: ServerThrottle. Http request error: HTTP response code said error. See logs for details',
                    title: 'Media download failed: Not retrying as download is not retriable at this time'
                  }],
                  timestamp: '1664799904', type: 'image'
                }]
              }
            }]
          }]
        }.with_indifferent_access
      end

      it 'with attachment errors' do
        described_class.new(inbox: whatsapp_channel.inbox, params: error_params).perform
        expect(whatsapp_channel.inbox.conversations.count).not_to eq(0)
        expect(Contact.all.first.name).to eq('Sojan Jose')
        expect(whatsapp_channel.inbox.messages.count).to eq(0)
      end
    end

    context 'when invalid params' do
      it 'will not throw error' do
        described_class.new(inbox: whatsapp_channel.inbox, params: { phone_number: whatsapp_channel.phone_number,
                                                                     object: 'whatsapp_business_account', entry: {} }).perform
        expect(whatsapp_channel.inbox.conversations.count).to eq(0)
        expect(Contact.all.first).to be_nil
        expect(whatsapp_channel.inbox.messages.count).to eq(0)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Whatsapp::Providers::WhatsappCloudService < Whatsapp::Providers::BaseService
  def send_message(phone_number, message)
    if message.attachments.present?
      send_attachment_message(phone_number, message)
    elsif message.content_type == 'input_select'
      send_interactive_text_message(phone_number, message)
    else
      send_text_message(phone_number, message)
    end
  end

  def send_template(phone_number, template_info)
    response = HTTParty.post(
      ""#{phone_id_path}/messages"",
      headers: api_headers,
      body: {
        messaging_product: 'whatsapp',
        to: phone_number,
        template: template_body_parameters(template_info),
        type: 'template'
      }.to_json
    )

    process_response(response)
  end

  def sync_templates
    # ensuring that channels with wrong provider config wouldn't keep trying to sync templates
    whatsapp_channel.mark_message_templates_updated
    templates = fetch_whatsapp_templates(""#{business_account_path}/message_templates?access_token=#{whatsapp_channel.provider_config['api_key']}"")
    whatsapp_channel.update(message_templates: templates, message_templates_last_updated: Time.now.utc) if templates.present?
  end

  def fetch_whatsapp_templates(url)
    response = HTTParty.get(url)
    return [] unless response.success?

    next_url = next_url(response)

    return response['data'] + fetch_whatsapp_templates(next_url) if next_url.present?

    response['data']
  end

  def next_url(response)
    response['paging'] ? response['paging']['next'] : ''
  end

  def validate_provider_config?
    response = HTTParty.get(""#{business_account_path}/message_templates?access_token=#{whatsapp_channel.provider_config['api_key']}"")
    response.success?
  end

  def api_headers
    { 'Authorization' => ""Bearer #{whatsapp_channel.provider_config['api_key']}"", 'Content-Type' => 'application/json' }
  end

  def media_url(media_id)
    ""#{api_base_path}/v13.0/#{media_id}""
  end

  def api_base_path
    ENV.fetch('WHATSAPP_CLOUD_BASE_URL', 'https://graph.facebook.com')
  end

  # TODO: See if we can unify the API versions and for both paths and make it consistent with out facebook app API versions
  def phone_id_path
    ""#{api_base_path}/v13.0/#{whatsapp_channel.provider_config['phone_number_id']}""
  end

  def business_account_path
    ""#{api_base_path}/v14.0/#{whatsapp_channel.provider_config['business_account_id']}""
  end

  def send_text_message(phone_number, message)
    response = HTTParty.post(
      ""#{phone_id_path}/messages"",
      headers: api_headers,
      body: {
        messaging_product: 'whatsapp',
        context: whatsapp_reply_context(message),
        to: phone_number,
        text: { body: message.content },
        type: 'text'
      }.to_json
    )

    process_response(response)
  end

  def send_attachment_message(phone_number, message)
    attachment = message.attachments.first
    type = %w[image audio video].include?(attachment.file_type) ? attachment.file_type : 'document'
    type_content = {
      'link': attachment.download_url
    }
    type_content['caption'] = message.content unless %w[audio sticker].include?(type)
    type_content['filename'] = attachment.file.filename if type == 'document'
    response = HTTParty.post(
      ""#{phone_id_path}/messages"",
      headers: api_headers,
      body: {
        :messaging_product => 'whatsapp',
        :context => whatsapp_reply_context(message),
        'to' => phone_number,
        'type' => type,
        type.to_s => type_content
      }.to_json
    )

    process_response(response)
  end

  def process_response(response)
    if response.success?
      response['messages'].first['id']
    else
      Rails.logger.error response.body
      nil
    end
  end

  def template_body_parameters(template_info)
    {
      name: template_info[:name],
      language: {
        policy: 'deterministic',
        code: template_info[:lang_code]
      },
      components: [{
        type: 'body',
        parameters: template_info[:parameters]
      }]
    }
  end

  def whatsapp_reply_context(message)
    reply_to = message.content_attributes[:in_reply_to_external_id]
    return nil if reply_to.blank?

    {
      message_id: reply_to
    }
  end

  def send_interactive_text_message(phone_number, message)
    payload = create_payload_based_on_items(message)

    response = HTTParty.post(
      ""#{phone_id_path}/messages"",
      headers: api_headers,
      body: {
        messaging_product: 'whatsapp',
        to: phone_number,
        interactive: payload,
        type: 'interactive'
      }.to_json
    )

    process_response(response)
  end
end

```","require 'rails_helper'

describe Whatsapp::Providers::WhatsappCloudService do
  subject(:service) { described_class.new(whatsapp_channel: whatsapp_channel) }

  let(:conversation) { create(:conversation, inbox: whatsapp_channel.inbox) }
  let(:whatsapp_channel) { create(:channel_whatsapp, provider: 'whatsapp_cloud', validate_provider_config: false, sync_templates: false) }

  let(:message) do
    create(:message, conversation: conversation, message_type: :outgoing, content: 'test', inbox: whatsapp_channel.inbox, source_id: 'external_id')
  end

  let(:message_with_reply) do
    create(:message, conversation: conversation, message_type: :outgoing, content: 'reply', inbox: whatsapp_channel.inbox,
                     content_attributes: { in_reply_to: message.id })
  end

  let(:response_headers) { { 'Content-Type' => 'application/json' } }
  let(:whatsapp_response) { { messages: [{ id: 'message_id' }] } }

  before do
    stub_request(:get, 'https://graph.facebook.com/v14.0/123456789/message_templates?access_token=test_key')
  end

  describe '#send_message' do
    context 'when called' do
      it 'calls message endpoints for normal messages' do
        stub_request(:post, 'https://graph.facebook.com/v13.0/123456789/messages')
          .with(
            body: {
              messaging_product: 'whatsapp',
              context: nil,
              to: '+123456789',
              text: { body: message.content },
              type: 'text'
            }.to_json
          )
          .to_return(status: 200, body: whatsapp_response.to_json, headers: response_headers)
        expect(service.send_message('+123456789', message)).to eq 'message_id'
      end

      it 'calls message endpoints for a reply to messages' do
        stub_request(:post, 'https://graph.facebook.com/v13.0/123456789/messages')
          .with(
            body: {
              messaging_product: 'whatsapp',
              context: {
                message_id: message.source_id
              },
              to: '+123456789',
              text: { body: message_with_reply.content },
              type: 'text'
            }.to_json
          )
          .to_return(status: 200, body: whatsapp_response.to_json, headers: response_headers)
        expect(service.send_message('+123456789', message_with_reply)).to eq 'message_id'
      end

      it 'calls message endpoints for image attachment message messages' do
        attachment = message.attachments.new(account_id: message.account_id, file_type: :image)
        attachment.file.attach(io: Rails.root.join('spec/assets/avatar.png').open, filename: 'avatar.png', content_type: 'image/png')

        stub_request(:post, 'https://graph.facebook.com/v13.0/123456789/messages')
          .with(
            body: hash_including({
                                   messaging_product: 'whatsapp',
                                   to: '+123456789',
                                   type: 'image',
                                   image: WebMock::API.hash_including({ caption: message.content, link: anything })
                                 })
          )
          .to_return(status: 200, body: whatsapp_response.to_json, headers: response_headers)
        expect(service.send_message('+123456789', message)).to eq 'message_id'
      end

      it 'calls message endpoints for document attachment message messages' do
        attachment = message.attachments.new(account_id: message.account_id, file_type: :file)
        attachment.file.attach(io: Rails.root.join('spec/assets/sample.pdf').open, filename: 'sample.pdf', content_type: 'application/pdf')

        # ref: https://github.com/bblimke/webmock/issues/900
        # reason for Webmock::API.hash_including
        stub_request(:post, 'https://graph.facebook.com/v13.0/123456789/messages')
          .with(
            body: hash_including({
                                   messaging_product: 'whatsapp',
                                   to: '+123456789',
                                   type: 'document',
                                   document: WebMock::API.hash_including({ filename: 'sample.pdf', caption: message.content, link: anything })
                                 })
          )
          .to_return(status: 200, body: whatsapp_response.to_json, headers: response_headers)
        expect(service.send_message('+123456789', message)).to eq 'message_id'
      end
    end
  end

  describe '#send_interactive message' do
    context 'when called' do
      it 'calls message endpoints with button payload when number of items is less than or equal to 3' do
        message = create(:message, message_type: :outgoing, content: 'test',
                                   inbox: whatsapp_channel.inbox, content_type: 'input_select',
                                   content_attributes: {
                                     items: [
                                       { title: 'Burito', value: 'Burito' },
                                       { title: 'Pasta', value: 'Pasta' },
                                       { title: 'Sushi', value: 'Sushi' }
                                     ]
                                   })
        stub_request(:post, 'https://graph.facebook.com/v13.0/123456789/messages')
          .with(
            body: {
              messaging_product: 'whatsapp', to: '+123456789',
              interactive: {
                type: 'button',
                body: {
                  text: 'test'
                },
                action: '{""buttons"":[{""type"":""reply"",""reply"":{""id"":""Burito"",""title"":""Burito""}},{""type"":""reply"",' \
                        '""reply"":{""id"":""Pasta"",""title"":""Pasta""}},{""type"":""reply"",""reply"":{""id"":""Sushi"",""title"":""Sushi""}}]}'
              }, type: 'interactive'
            }.to_json
          ).to_return(status: 200, body: whatsapp_response.to_json, headers: response_headers)
        expect(service.send_message('+123456789', message)).to eq 'message_id'
      end

      it 'calls message endpoints with list payload when number of items is greater than 3' do
        message = create(:message, message_type: :outgoing, content: 'test', inbox: whatsapp_channel.inbox,
                                   content_type: 'input_select',
                                   content_attributes: {
                                     items: [
                                       { title: 'Burito', value: 'Burito' },
                                       { title: 'Pasta', value: 'Pasta' },
                                       { title: 'Sushi', value: 'Sushi' },
                                       { title: 'Salad', value: 'Salad' }
                                     ]
                                   })
        stub_request(:post, 'https://graph.facebook.com/v13.0/123456789/messages')
          .with(
            body: {
              messaging_product: 'whatsapp', to: '+123456789',
              interactive: {
                type: 'list',
                body: {
                  text: 'test'
                },
                action: '{""button"":""Choose an item"",""sections"":[{""rows"":[{""id"":""Burito"",""title"":""Burito""},' \
                        '{""id"":""Pasta"",""title"":""Pasta""},{""id"":""Sushi"",""title"":""Sushi""},{""id"":""Salad"",""title"":""Salad""}]}]}'
              }, type: 'interactive'
            }.to_json
          ).to_return(status: 200, body: whatsapp_response.to_json, headers: response_headers)
        expect(service.send_message('+123456789', message)).to eq 'message_id'
      end
    end
  end

  describe '#send_template' do
    let(:template_info) do
      {
        name: 'test_template',
        namespace: 'test_namespace',
        lang_code: 'en_US',
        parameters: [{ type: 'text', text: 'test' }]
      }
    end

    let(:template_body) do
      {
        messaging_product: 'whatsapp',
        to: '+123456789',
        template: {
          name: template_info[:name],
          language: {
            policy: 'deterministic',
            code: template_info[:lang_code]
          },
          components: [
            { type: 'body',
              parameters: template_info[:parameters] }
          ]
        },
        type: 'template'
      }
    end

    context 'when called' do
      it 'calls message endpoints with template params for template messages' do
        stub_request(:post, 'https://graph.facebook.com/v13.0/123456789/messages')
          .with(
            body: template_body.to_json
          )
          .to_return(status: 200, body: whatsapp_response.to_json, headers: response_headers)

        expect(service.send_template('+123456789', template_info)).to eq('message_id')
      end
    end
  end

  describe '#sync_templates' do
    context 'when called' do
      it 'updated the message templates' do
        stub_request(:get, 'https://graph.facebook.com/v14.0/123456789/message_templates?access_token=test_key')
          .to_return(
            { status: 200, headers: response_headers,
              body: { data: [
                { id: '123456789', name: 'test_template' }
              ], paging: { next: 'https://graph.facebook.com/v14.0/123456789/message_templates?access_token=test_key' } }.to_json },
            { status: 200, headers: response_headers,
              body: { data: [
                { id: '123456789', name: 'next_template' }
              ], paging: { next: 'https://graph.facebook.com/v14.0/123456789/message_templates?access_token=test_key' } }.to_json },
            { status: 200, headers: response_headers,
              body: { data: [
                { id: '123456789', name: 'last_template' }
              ], paging: { prev: 'https://graph.facebook.com/v14.0/123456789/message_templates?access_token=test_key' } }.to_json }
          )

        timstamp = whatsapp_channel.reload.message_templates_last_updated
        expect(subject.sync_templates).to be(true)
        expect(whatsapp_channel.reload.message_templates.first).to eq({ id: '123456789', name: 'test_template' }.stringify_keys)
        expect(whatsapp_channel.reload.message_templates.second).to eq({ id: '123456789', name: 'next_template' }.stringify_keys)
        expect(whatsapp_channel.reload.message_templates.last).to eq({ id: '123456789', name: 'last_template' }.stringify_keys)
        expect(whatsapp_channel.reload.message_templates_last_updated).not_to eq(timstamp)
      end

      it 'updates message_templates_last_updated even when template request fails' do
        stub_request(:get, 'https://graph.facebook.com/v14.0/123456789/message_templates?access_token=test_key')
          .to_return(status: 401)

        timstamp = whatsapp_channel.reload.message_templates_last_updated
        subject.sync_templates
        expect(whatsapp_channel.reload.message_templates_last_updated).not_to eq(timstamp)
      end
    end
  end

  describe '#validate_provider_config' do
    context 'when called' do
      it 'returns true if valid' do
        stub_request(:get, 'https://graph.facebook.com/v14.0/123456789/message_templates?access_token=test_key')
        expect(subject.validate_provider_config?).to be(true)
        expect(whatsapp_channel.errors.present?).to be(false)
      end

      it 'returns false if invalid' do
        stub_request(:get, 'https://graph.facebook.com/v14.0/123456789/message_templates?access_token=test_key').to_return(status: 401)
        expect(subject.validate_provider_config?).to be(false)
      end
    end
  end

  describe 'Ability to configure Base URL' do
    context 'when environment variable WHATSAPP_CLOUD_BASE_URL is not set' do
      it 'uses the default base url' do
        expect(subject.send(:api_base_path)).to eq('https://graph.facebook.com')
      end
    end

    context 'when environment variable WHATSAPP_CLOUD_BASE_URL is set' do
      it 'uses the base url from the environment variable' do
        with_modified_env WHATSAPP_CLOUD_BASE_URL: 'http://test.com' do
          expect(subject.send(:api_base_path)).to eq('http://test.com')
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Twilio::DeliveryStatusService
  pattr_initialize [:params!]
  # Reference: https://www.twilio.com/docs/messaging/api/message-resource#message-status-values

  def perform
    return if twilio_channel.blank?

    return unless supported_status?

    process_statuses if message.present?
  end

  private

  def process_statuses
    @message.status = status
    @message.external_error = external_error if error_occurred?
    @message.save!
  end

  def supported_status?
    %w[sent delivered read failed undelivered].include?(params[:MessageStatus])
  end

  def status
    params[:MessageStatus] == 'undelivered' ? 'failed' : params[:MessageStatus]
  end

  def external_error
    return nil unless error_occurred?

    error_message = params[:ErrorMessage].presence
    error_code = params[:ErrorCode]

    if error_message.present?
      ""#{error_code} - #{error_message}""
    elsif error_code.present?
      I18n.t('conversations.messages.delivery_status.error_code', error_code: error_code)
    end
  end

  def error_occurred?
    params[:ErrorCode].present? && %w[failed undelivered].include?(params[:MessageStatus])
  end

  def twilio_channel
    @twilio_channel ||= if params[:MessagingServiceSid].present?
                          ::Channel::TwilioSms.find_by(messaging_service_sid: params[:MessagingServiceSid])
                        elsif params[:AccountSid].present? && params[:From].present?
                          ::Channel::TwilioSms.find_by!(account_sid: params[:AccountSid], phone_number: params[:From])
                        end
  end

  def message
    return unless params[:MessageSid]

    @message ||= twilio_channel.inbox.messages.find_by(source_id: params[:MessageSid])
  end
end

```","require 'rails_helper'

describe Twilio::DeliveryStatusService do
  let!(:account) { create(:account) }
  let!(:twilio_channel) do
    create(:channel_twilio_sms, account: account, account_sid: 'ACxxx',
                                inbox: create(:inbox, account: account, greeting_enabled: false))
  end
  let!(:contact) { create(:contact, account: account, phone_number: '+12345') }
  let(:contact_inbox) { create(:contact_inbox, source_id: '+12345', contact: contact, inbox: twilio_channel.inbox) }
  let!(:conversation) { create(:conversation, contact: contact, inbox: twilio_channel.inbox, contact_inbox: contact_inbox) }

  describe '#perform' do
    context 'when message delivery status is fired' do
      before do
        create(:message, account: account, inbox: twilio_channel.inbox, conversation: conversation, status: :sent,
                         source_id: 'SMd560ac79e4a4d36b3ce59f1f50471986')
      end

      it 'updates the message if the status is delivered' do
        params = {
          SmsSid: 'SMxx',
          From: '+12345',
          AccountSid: 'ACxxx',
          MessagingServiceSid: twilio_channel.messaging_service_sid,
          MessageSid: conversation.messages.last.source_id,
          MessageStatus: 'delivered'
        }

        described_class.new(params: params).perform
        expect(conversation.reload.messages.last.status).to eq('delivered')
      end

      it 'updates the message if the status is read' do
        params = {
          SmsSid: 'SMxx',
          From: '+12345',
          AccountSid: 'ACxxx',
          MessagingServiceSid: twilio_channel.messaging_service_sid,
          MessageSid: conversation.messages.last.source_id,
          MessageStatus: 'read'
        }

        described_class.new(params: params).perform
        expect(conversation.reload.messages.last.status).to eq('read')
      end

      it 'does not update the message if the status is not a support status' do
        params = {
          SmsSid: 'SMxx',
          From: '+12345',
          AccountSid: 'ACxxx',
          MessagingServiceSid: twilio_channel.messaging_service_sid,
          MessageSid: conversation.messages.last.source_id,
          MessageStatus: 'queued'
        }

        described_class.new(params: params).perform
        expect(conversation.reload.messages.last.status).to eq('sent')
      end

      it 'updates message status to failed if message status is undelivered' do
        params = {
          SmsSid: 'SMxx',
          From: '+12345',
          AccountSid: 'ACxxx',
          MessagingServiceSid: twilio_channel.messaging_service_sid,
          MessageSid: conversation.messages.last.source_id,
          MessageStatus: 'undelivered',
          ErrorCode: '30002',
          ErrorMessage: 'Account suspended'
        }

        described_class.new(params: params).perform
        expect(conversation.reload.messages.last.status).to eq('failed')
        expect(conversation.reload.messages.last.external_error).to eq('30002 - Account suspended')
      end

      it 'updates message status to failed and updates the error message if message status is failed' do
        params = {
          SmsSid: 'SMxx',
          From: '+12345',
          AccountSid: 'ACxxx',
          MessagingServiceSid: twilio_channel.messaging_service_sid,
          MessageSid: conversation.messages.last.source_id,
          MessageStatus: 'failed',
          ErrorCode: '30008',
          ErrorMessage: 'Unknown error'
        }

        described_class.new(params: params).perform
        expect(conversation.reload.messages.last.status).to eq('failed')
        expect(conversation.reload.messages.last.external_error).to eq('30008 - Unknown error')
      end

      it 'updates the error message if message status is undelivered and error message is not present' do
        params = {
          SmsSid: 'SMxx',
          From: '+12345',
          AccountSid: 'ACxxx',
          MessagingServiceSid: twilio_channel.messaging_service_sid,
          MessageSid: conversation.messages.last.source_id,
          MessageStatus: 'failed',
          ErrorCode: '30008'
        }

        described_class.new(params: params).perform
        expect(conversation.reload.messages.last.status).to eq('failed')
        expect(conversation.reload.messages.last.external_error).to eq('Error code: 30008')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Twilio::IncomingMessageService
  include ::FileTypeHelper

  pattr_initialize [:params!]

  def perform
    return if twilio_channel.blank?

    set_contact
    set_conversation
    @message = @conversation.messages.create!(
      content: message_body,
      account_id: @inbox.account_id,
      inbox_id: @inbox.id,
      message_type: :incoming,
      sender: @contact,
      source_id: params[:SmsSid]
    )
    attach_files
  end

  private

  def twilio_channel
    @twilio_channel ||= ::Channel::TwilioSms.find_by(messaging_service_sid: params[:MessagingServiceSid]) if params[:MessagingServiceSid].present?
    if params[:AccountSid].present? && params[:To].present?
      @twilio_channel ||= ::Channel::TwilioSms.find_by!(account_sid: params[:AccountSid],
                                                        phone_number: params[:To])
    end
    @twilio_channel
  end

  def inbox
    @inbox ||= twilio_channel.inbox
  end

  def account
    @account ||= inbox.account
  end

  def phone_number
    twilio_channel.sms? ? params[:From] : params[:From].gsub('whatsapp:', '')
  end

  def formatted_phone_number
    TelephoneNumber.parse(phone_number).international_number
  end

  def message_body
    params[:Body]&.delete(""\u0000"")
  end

  def set_contact
    contact_inbox = ::ContactInboxWithContactBuilder.new(
      source_id: params[:From],
      inbox: inbox,
      contact_attributes: contact_attributes
    ).perform

    @contact_inbox = contact_inbox
    @contact = contact_inbox.contact
  end

  def conversation_params
    {
      account_id: @inbox.account_id,
      inbox_id: @inbox.id,
      contact_id: @contact.id,
      contact_inbox_id: @contact_inbox.id,
      additional_attributes: additional_attributes
    }
  end

  def set_conversation
    # if lock to single conversation is disabled, we will create a new conversation if previous conversation is resolved
    @conversation = if @inbox.lock_to_single_conversation
                      @contact_inbox.conversations.last
                    else
                      @contact_inbox.conversations.where
                                    .not(status: :resolved).last
                    end
    return if @conversation

    @conversation = ::Conversation.create!(conversation_params)
  end

  def contact_attributes
    {
      name: formatted_phone_number,
      phone_number: phone_number,
      additional_attributes: additional_attributes
    }
  end

  def additional_attributes
    if twilio_channel.sms?
      {
        from_zip_code: params[:FromZip],
        from_country: params[:FromCountry],
        from_state: params[:FromState]
      }
    else
      {}
    end
  end

  def attach_files
    return if params[:MediaUrl0].blank?

    attachment_file = Down.download(
      params[:MediaUrl0],
      # https://support.twilio.com/hc/en-us/articles/223183748-Protect-Media-Access-with-HTTP-Basic-Authentication-for-Programmable-Messaging
      http_basic_authentication: [twilio_channel.account_sid, twilio_channel.auth_token || twilio_channel.api_key_sid]
    )

    attachment = @message.attachments.new(
      account_id: @message.account_id,
      file_type: file_type(params[:MediaContentType0])
    )

    attachment.file.attach(
      io: attachment_file,
      filename: attachment_file.original_filename,
      content_type: attachment_file.content_type
    )

    @message.save!
  end
end

```","require 'rails_helper'

describe Twilio::IncomingMessageService do
  let!(:account) { create(:account) }
  let!(:twilio_channel) do
    create(:channel_twilio_sms, account: account, account_sid: 'ACxxx',
                                inbox: create(:inbox, account: account, greeting_enabled: false))
  end
  let!(:contact) { create(:contact, account: account, phone_number: '+12345') }
  let(:contact_inbox) { create(:contact_inbox, source_id: '+12345', contact: contact, inbox: twilio_channel.inbox) }
  let!(:conversation) { create(:conversation, contact: contact, inbox: twilio_channel.inbox, contact_inbox: contact_inbox) }

  describe '#perform' do
    it 'creates a new message in existing conversation' do
      params = {
        SmsSid: 'SMxx',
        From: '+12345',
        AccountSid: 'ACxxx',
        MessagingServiceSid: twilio_channel.messaging_service_sid,
        Body: 'testing3'
      }

      described_class.new(params: params).perform
      expect(conversation.reload.messages.last.content).to eq('testing3')
    end

    it 'removes null bytes' do
      params = {
        SmsSid: 'SMxx',
        From: '+12345',
        AccountSid: 'ACxxx',
        MessagingServiceSid: twilio_channel.messaging_service_sid,
        Body: ""remove\u0000 null bytes\u0000""
      }

      described_class.new(params: params).perform
      expect(conversation.reload.messages.last.content).to eq('remove null bytes')
    end

    it 'wont throw error when the body is empty' do
      params = {
        SmsSid: 'SMxx',
        From: '+12345',
        AccountSid: 'ACxxx',
        MessagingServiceSid: twilio_channel.messaging_service_sid
      }

      described_class.new(params: params).perform
      expect(conversation.reload.messages.last.content).to be_nil
    end

    it 'creates a new conversation when payload is from different number' do
      params = {
        SmsSid: 'SMxx',
        From: '+123456',
        AccountSid: 'ACxxx',
        MessagingServiceSid: twilio_channel.messaging_service_sid,
        Body: 'new conversation'
      }

      described_class.new(params: params).perform
      expect(twilio_channel.inbox.conversations.count).to eq(2)
    end

    # Since we support the case with phone number as well. the previous case is with accoud_sid and messaging_service_sid
    context 'with a phone number' do
      let!(:twilio_channel) do
        create(:channel_twilio_sms, :with_phone_number, account: account, account_sid: 'ACxxx',
                                                        inbox: create(:inbox, account: account, greeting_enabled: false))
      end

      it 'creates a new message in existing conversation' do
        params = {
          SmsSid: 'SMxx',
          From: '+12345',
          AccountSid: 'ACxxx',
          To: twilio_channel.phone_number,
          Body: 'testing3'
        }

        described_class.new(params: params).perform
        expect(conversation.reload.messages.last.content).to eq('testing3')
      end

      it 'creates a new conversation when payload is from different number' do
        params = {
          SmsSid: 'SMxx',
          From: '+123456',
          AccountSid: 'ACxxx',
          To: twilio_channel.phone_number,
          Body: 'new conversation'
        }

        described_class.new(params: params).perform
        expect(twilio_channel.inbox.conversations.count).to eq(2)
      end

      it 'reopen last conversation if last conversation is resolved and lock to single conversation is enabled' do
        params = {
          SmsSid: 'SMxx',
          From: '+12345',
          AccountSid: 'ACxxx',
          To: twilio_channel.phone_number,
          Body: 'testing3'
        }

        twilio_channel.inbox.update(lock_to_single_conversation: true)
        conversation.update(status: 'resolved')
        described_class.new(params: params).perform
        # message appended to the last conversation
        expect(conversation.reload.messages.last.content).to eq('testing3')
        expect(conversation.reload.status).to eq('open')
      end

      it 'creates a new conversation if last conversation is resolved and lock to single conversation is disabled' do
        params = {
          SmsSid: 'SMxx',
          From: '+12345',
          AccountSid: 'ACxxx',
          To: twilio_channel.phone_number,
          Body: 'testing3'
        }

        twilio_channel.inbox.update(lock_to_single_conversation: false)
        conversation.update(status: 'resolved')
        described_class.new(params: params).perform
        expect(twilio_channel.inbox.conversations.count).to eq(2)
        expect(twilio_channel.inbox.conversations.last.messages.last.content).to eq('testing3')
      end

      it 'will not create a new conversation if last conversation is not resolved and lock to single conversation is disabled' do
        params = {
          SmsSid: 'SMxx',
          From: '+12345',
          AccountSid: 'ACxxx',
          To: twilio_channel.phone_number,
          Body: 'testing3'
        }

        twilio_channel.inbox.update(lock_to_single_conversation: false)
        conversation.update(status: Conversation.statuses.except('resolved').keys.sample)
        described_class.new(params: params).perform
        expect(twilio_channel.inbox.conversations.count).to eq(1)
        expect(twilio_channel.inbox.conversations.last.messages.last.content).to eq('testing3')
      end
    end

    context 'with multiple channels configured' do
      before do
        2.times.each do
          create(:channel_twilio_sms, :with_phone_number, account: account, account_sid: 'ACxxx', messaging_service_sid: nil,
                                                          inbox: create(:inbox, account: account, greeting_enabled: false))
        end
      end

      it 'creates a new conversation in appropriate channel' do
        twilio_sms_channel = create(:channel_twilio_sms, :with_phone_number, account: account, account_sid: 'ACxxx',
                                                                             inbox: create(:inbox, account: account, greeting_enabled: false))

        params = {
          SmsSid: 'SMxx',
          From: '+123456',
          AccountSid: 'ACxxx',
          To: twilio_sms_channel.phone_number,
          Body: 'new conversation'
        }

        described_class.new(params: params).perform
        expect(twilio_sms_channel.inbox.conversations.count).to eq(1)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Twilio::WebhookSetupService
  include Rails.application.routes.url_helpers

  pattr_initialize [:inbox!]

  def perform
    if channel.messaging_service_sid?
      update_messaging_service
    else
      update_phone_number
    end
  end

  private

  def update_messaging_service
    twilio_client
      .messaging.services(channel.messaging_service_sid)
      .update(
        inbound_method: 'POST',
        inbound_request_url: twilio_callback_index_url,
        use_inbound_webhook_on_number: false
      )
  end

  def update_phone_number
    if phone_numbers.empty?
      Rails.logger.warn ""TWILIO_PHONE_NUMBER_NOT_FOUND: #{channel.phone_number}""
    else
      twilio_client
        .incoming_phone_numbers(phonenumber_sid)
        .update(sms_method: 'POST', sms_url: twilio_callback_index_url)
    end
  end

  def phonenumber_sid
    phone_numbers.first.sid
  end

  def phone_numbers
    @phone_numbers ||= twilio_client.incoming_phone_numbers.list(phone_number: channel.phone_number)
  end

  def channel
    @channel ||= inbox.channel
  end

  def twilio_client
    @twilio_client ||= ::Twilio::REST::Client.new(channel.account_sid, channel.auth_token)
  end
end

```","require 'rails_helper'

describe Twilio::WebhookSetupService do
  include Rails.application.routes.url_helpers

  let(:twilio_client) { instance_double(Twilio::REST::Client) }

  before do
    allow(Twilio::REST::Client).to receive(:new).and_return(twilio_client)
  end

  describe '#perform' do
    context 'with a messaging service sid' do
      let(:channel_twilio_sms) { create(:channel_twilio_sms) }

      let(:messaging) { instance_double(Twilio::REST::Messaging) }
      let(:services) { instance_double(Twilio::REST::Messaging::V1::ServiceContext) }

      before do
        allow(twilio_client).to receive(:messaging).and_return(messaging)
        allow(messaging).to receive(:services).with(channel_twilio_sms.messaging_service_sid).and_return(services)
        allow(services).to receive(:update)
      end

      it 'updates the messaging service' do
        described_class.new(inbox: channel_twilio_sms.inbox).perform

        expect(services).to have_received(:update)
      end
    end

    context 'with a phone number' do
      let(:channel_twilio_sms) { create(:channel_twilio_sms, :with_phone_number) }

      let(:phone_double) { double }
      let(:phone_record_double) { double }

      before do
        allow(phone_double).to receive(:update)
        allow(phone_record_double).to receive(:sid).and_return('1234')
      end

      it 'logs error if phone_number is not found' do
        allow(twilio_client).to receive(:incoming_phone_numbers).and_return(phone_double)
        allow(phone_double).to receive(:list).and_return([])

        described_class.new(inbox: channel_twilio_sms.inbox).perform

        expect(phone_double).not_to have_received(:update)
      end

      it 'update webhook_url if phone_number is found' do
        allow(twilio_client).to receive(:incoming_phone_numbers).and_return(phone_double)
        allow(phone_double).to receive(:list).and_return([phone_record_double])

        described_class.new(inbox: channel_twilio_sms.inbox).perform

        expect(phone_double).to have_received(:update).with(
          sms_method: 'POST',
          sms_url: twilio_callback_index_url
        )
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Twilio::SendOnTwilioService < Base::SendOnChannelService
  private

  def channel_class
    Channel::TwilioSms
  end

  def perform_reply
    begin
      twilio_message = channel.send_message(**message_params)
    rescue Twilio::REST::TwilioError, Twilio::REST::RestError => e
      message.update!(status: :failed, external_error: e.message)
    end
    message.update!(source_id: twilio_message.sid) if twilio_message
  end

  def message_params
    {
      body: message.content,
      to: contact_inbox.source_id,
      media_url: attachments
    }
  end

  def attachments
    message.attachments.map(&:download_url)
  end

  def inbox
    @inbox ||= message.inbox
  end

  def channel
    @channel ||= inbox.channel
  end

  def outgoing_message?
    message.outgoing? || message.template?
  end
end

```","require 'rails_helper'

describe Twilio::SendOnTwilioService do
  subject(:outgoing_message_service) { described_class.new(message: message) }

  let(:twilio_client) { instance_double(Twilio::REST::Client) }
  let(:messages_double) { double }
  let(:message_record_double) { double }

  let!(:account) { create(:account) }
  let!(:widget_inbox) { create(:inbox, account: account) }
  let!(:twilio_sms) { create(:channel_twilio_sms, account: account) }
  let!(:twilio_whatsapp) { create(:channel_twilio_sms, medium: :whatsapp, account: account) }
  let!(:twilio_inbox) { create(:inbox, channel: twilio_sms, account: account) }
  let!(:twilio_whatsapp_inbox) { create(:inbox, channel: twilio_whatsapp, account: account) }
  let!(:contact) { create(:contact, account: account) }
  let(:contact_inbox) { create(:contact_inbox, contact: contact, inbox: twilio_inbox) }
  let(:conversation) { create(:conversation, contact: contact, inbox: twilio_inbox, contact_inbox: contact_inbox) }

  before do
    allow(Twilio::REST::Client).to receive(:new).and_return(twilio_client)
    allow(twilio_client).to receive(:messages).and_return(messages_double)
  end

  describe '#perform' do
    context 'without reply' do
      it 'if message is private' do
        message = create(:message, message_type: 'outgoing', private: true, inbox: twilio_inbox, account: account)
        described_class.new(message: message).perform
        expect(twilio_client).not_to have_received(:messages)
        expect(message.reload.source_id).to be_nil
      end

      it 'if inbox channel is not twilio' do
        message = create(:message, message_type: 'outgoing', inbox: widget_inbox, account: account)
        expect { described_class.new(message: message).perform }.to raise_error 'Invalid channel service was called'
        expect(twilio_client).not_to have_received(:messages)
      end

      it 'if message is not outgoing' do
        message = create(:message, message_type: 'incoming', inbox: twilio_inbox, account: account)
        described_class.new(message: message).perform
        expect(twilio_client).not_to have_received(:messages)
        expect(message.reload.source_id).to be_nil
      end

      it 'if message has an source id' do
        message = create(:message, message_type: 'outgoing', inbox: twilio_inbox, account: account, source_id: SecureRandom.uuid)
        described_class.new(message: message).perform
        expect(twilio_client).not_to have_received(:messages)
      end
    end

    context 'with reply' do
      it 'if message is sent from chatwoot and is outgoing' do
        allow(messages_double).to receive(:create).and_return(message_record_double)
        allow(message_record_double).to receive(:sid).and_return('1234')

        outgoing_message = create(
          :message, message_type: 'outgoing', inbox: twilio_inbox, account: account, conversation: conversation
        )
        described_class.new(message: outgoing_message).perform

        expect(outgoing_message.reload.source_id).to eq('1234')
      end
    end

    it 'if outgoing message has attachment and is for whatsapp' do
      # check for message attachment url
      allow(messages_double).to receive(:create).with(hash_including(media_url: [anything])).and_return(message_record_double)
      allow(message_record_double).to receive(:sid).and_return('1234')

      message = build(
        :message, message_type: 'outgoing', inbox: twilio_whatsapp_inbox, account: account, conversation: conversation
      )
      attachment = message.attachments.new(account_id: message.account_id, file_type: :image)
      attachment.file.attach(io: Rails.root.join('spec/assets/avatar.png').open, filename: 'avatar.png', content_type: 'image/png')
      message.save!

      described_class.new(message: message).perform
      expect(messages_double).to have_received(:create).with(hash_including(media_url: [anything]))
    end

    it 'if outgoing message has attachment and is for sms' do
      # check for message attachment url
      allow(messages_double).to receive(:create).with(hash_including(media_url: [anything])).and_return(message_record_double)
      allow(message_record_double).to receive(:sid).and_return('1234')

      message = build(
        :message, message_type: 'outgoing', inbox: twilio_inbox, account: account, conversation: conversation
      )
      attachment = message.attachments.new(account_id: message.account_id, file_type: :image)
      attachment.file.attach(io: Rails.root.join('spec/assets/avatar.png').open, filename: 'avatar.png', content_type: 'image/png')
      message.save!

      described_class.new(message: message).perform
      expect(messages_double).to have_received(:create).with(hash_including(media_url: [anything]))
    end

    it 'if message is sent from chatwoot fails' do
      allow(messages_double).to receive(:create).and_raise(Twilio::REST::TwilioError)

      outgoing_message = create(
        :message, message_type: 'outgoing', inbox: twilio_inbox, account: account, conversation: conversation
      )
      described_class.new(message: outgoing_message).perform
      expect(outgoing_message.reload.status).to eq('failed')
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Twilio::OneoffSmsCampaignService
  pattr_initialize [:campaign!]

  def perform
    raise ""Invalid campaign #{campaign.id}"" if campaign.inbox.inbox_type != 'Twilio SMS' || !campaign.one_off?
    raise 'Completed Campaign' if campaign.completed?

    # marks campaign completed so that other jobs won't pick it up
    campaign.completed!

    audience_label_ids = campaign.audience.select { |audience| audience['type'] == 'Label' }.pluck('id')
    audience_labels = campaign.account.labels.where(id: audience_label_ids).pluck(:title)
    process_audience(audience_labels)
  end

  private

  delegate :inbox, to: :campaign
  delegate :channel, to: :inbox

  def process_audience(audience_labels)
    campaign.account.contacts.tagged_with(audience_labels, any: true).each do |contact|
      next if contact.phone_number.blank?

      channel.send_message(to: contact.phone_number, body: campaign.message)
    end
  end
end

```","require 'rails_helper'

describe Twilio::OneoffSmsCampaignService do
  subject(:sms_campaign_service) { described_class.new(campaign: campaign) }

  let(:account) { create(:account) }
  let!(:twilio_sms) { create(:channel_twilio_sms) }
  let!(:twilio_inbox) { create(:inbox, channel: twilio_sms) }
  let(:label1) { create(:label, account: account) }
  let(:label2) { create(:label, account: account) }
  let!(:campaign) do
    create(:campaign, inbox: twilio_inbox, account: account,
                      audience: [{ type: 'Label', id: label1.id }, { type: 'Label', id: label2.id }])
  end
  let(:twilio_client) { double }
  let(:twilio_messages) { double }

  describe 'perform' do
    before do
      allow(Twilio::REST::Client).to receive(:new).and_return(twilio_client)
      allow(twilio_client).to receive(:messages).and_return(twilio_messages)
    end

    it 'raises error if the campaign is completed' do
      campaign.completed!

      expect { sms_campaign_service.perform }.to raise_error 'Completed Campaign'
    end

    it 'raises error invalid campaign when its not a oneoff sms campaign' do
      campaign = create(:campaign)

      expect { described_class.new(campaign: campaign).perform }.to raise_error ""Invalid campaign #{campaign.id}""
    end

    it 'send messages to contacts in the audience and marks the campaign completed' do
      contact_with_label1, contact_with_label2, contact_with_both_labels = FactoryBot.create_list(:contact, 3, :with_phone_number, account: account)
      contact_with_label1.update_labels([label1.title])
      contact_with_label2.update_labels([label2.title])
      contact_with_both_labels.update_labels([label1.title, label2.title])
      expect(twilio_messages).to receive(:create).with(
        body: campaign.message,
        messaging_service_sid: twilio_sms.messaging_service_sid,
        to: contact_with_label1.phone_number,
        status_callback: 'http://localhost:3000/twilio/delivery_status'
      ).once
      expect(twilio_messages).to receive(:create).with(
        body: campaign.message,
        messaging_service_sid: twilio_sms.messaging_service_sid,
        to: contact_with_label2.phone_number,
        status_callback: 'http://localhost:3000/twilio/delivery_status'
      ).once
      expect(twilio_messages).to receive(:create).with(
        body: campaign.message,
        messaging_service_sid: twilio_sms.messaging_service_sid,
        to: contact_with_both_labels.phone_number,
        status_callback: 'http://localhost:3000/twilio/delivery_status'
      ).once

      sms_campaign_service.perform
      expect(campaign.reload.completed?).to be true
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class PageCrawlerService
  attr_reader :external_link

  def initialize(external_link)
    @external_link = external_link
    @doc = Nokogiri::HTML(HTTParty.get(external_link).body)
  end

  def page_links
    sitemap? ? extract_links_from_sitemap : extract_links_from_html
  end

  def page_title
    title_element = @doc.at_xpath('//title')
    title_element&.text&.strip
  end

  def body_text_content
    ReverseMarkdown.convert @doc.at_xpath('//body'), unknown_tags: :bypass, github_flavored: true
  end

  private

  def sitemap?
    @external_link.end_with?('.xml')
  end

  def extract_links_from_sitemap
    @doc.xpath('//loc').to_set(&:text)
  end

  def extract_links_from_html
    @doc.xpath('//a/@href').to_set do |link|
      absolute_url = URI.join(@external_link, link.value).to_s
      absolute_url
    end
  end
end

```","require 'rails_helper'

describe PageCrawlerService do
  let(:html_link) { 'http://test.com' }
  let(:sitemap_link) { 'http://test.com/sitemap.xml' }
  let(:service_html) { described_class.new(html_link) }
  let(:service_sitemap) { described_class.new(sitemap_link) }

  let(:html_body) do
    <<-HTML
      <html>
        <head><title>Test Title</title></head>
        <body><a href=""link1"">Link 1</a><a href=""link2"">Link 2</a></body>
      </html>
    HTML
  end

  let(:sitemap_body) do
    <<-XML
      <urlset xmlns=""http://www.sitemaps.org/schemas/sitemap/0.9"">
        <url><loc>http://test.com/link1</loc></url>
        <url><loc>http://test.com/link2</loc></url>
      </urlset>
    XML
  end

  before do
    stub_request(:get, html_link).to_return(body: html_body, status: 200)
    stub_request(:get, sitemap_link).to_return(body: sitemap_body, status: 200)
  end

  describe '#page_links' do
    context 'when a HTML page is given' do
      it 'returns all links on the page' do
        expect(service_html.page_links).to eq(Set.new(['http://test.com/link1', 'http://test.com/link2']))
      end
    end

    context 'when a sitemap is given' do
      it 'returns all links in the sitemap' do
        expect(service_sitemap.page_links).to eq(Set.new(['http://test.com/link1', 'http://test.com/link2']))
      end
    end
  end

  describe '#page_title' do
    it 'returns the title of the page' do
      expect(service_html.page_title).to eq('Test Title')
    end
  end

  describe '#body_text_content' do
    it 'returns the markdown converted body content of the page' do
      expect(service_html.body_text_content.strip).to eq('[Link 1](link1)[Link 2](link2)')
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Enterprise::MessageTemplates::ResponseBotService
  pattr_initialize [:conversation!]

  def perform
    ActiveRecord::Base.transaction do
      @response = get_response(conversation.messages.incoming.last.content)
      process_response
    end
  rescue StandardError => e
    process_action('handoff') # something went wrong, pass to agent
    ChatwootExceptionTracker.new(e, account: conversation.account).capture_exception
    true
  end

  def response_sections(content)
    sections = ''

    inbox.get_responses(content).each do |response|
      sections += ""{context_id: #{response.id}, context: #{response.question} ? #{response.answer}},""
    end
    sections
  end

  private

  delegate :contact, :account, :inbox, to: :conversation

  def get_response(content)
    previous_messages = []
    get_previous_messages(previous_messages)
    ChatGpt.new(response_sections(content)).generate_response('', previous_messages)
  end

  def get_previous_messages(previous_messages)
    conversation.messages.where(message_type: [:outgoing, :incoming]).where(private: false).find_each do |message|
      next if message.content_type != 'text'

      role = determine_role(message)
      previous_messages << { content: message.content, role: role }
    end
  end

  def determine_role(message)
    message.message_type == 'incoming' ? 'user' : 'system'
  end

  def process_response
    if @response['response'] == 'conversation_handoff'
      process_action('handoff')
    else
      create_messages
    end
  end

  def process_action(action)
    case action
    when 'handoff'
      conversation.messages.create!('message_type': :outgoing, 'account_id': conversation.account_id, 'inbox_id': conversation.inbox_id,
                                    'content': 'passing to an agent')
      conversation.update(status: :open)
    end
  end

  def create_messages
    message_content = @response['response']
    message_content += generate_sources_section if @response['context_ids'].present?

    create_outgoing_message(message_content)
  end

  def generate_sources_section
    article_ids = @response['context_ids']
    sources_content = ''

    articles_hash = get_article_hash(article_ids.uniq)

    articles_hash.first(3).each do |article_hash|
      sources_content += "" - [#{article_hash[:response].question}](#{article_hash[:response_document].document_link}) \n""
    end
    sources_content = ""\n \n \n **Sources**  \n#{sources_content}"" if sources_content.present?
    sources_content
  end

  def create_outgoing_message(message_content)
    conversation.messages.create!(
      {
        message_type: :outgoing,
        account_id: conversation.account_id,
        inbox_id: conversation.inbox_id,
        content: message_content
      }
    )
  end

  def get_article_hash(article_ids)
    seen_documents = Set.new
    article_ids.uniq.filter_map do |article_id|
      response = Response.find(article_id)
      response_document = response.response_document
      next if response_document.blank? || seen_documents.include?(response_document)

      seen_documents << response_document
      { response: response, response_document: response_document }
    end
  end
end

```","require 'rails_helper'

RSpec.describe Enterprise::MessageTemplates::ResponseBotService, type: :service do
  let!(:conversation) { create(:conversation, status: :pending) }
  let(:service) { described_class.new(conversation: conversation) }
  let(:chat_gpt_double) { instance_double(ChatGpt) }
  let(:response_source) { create(:response_source, account: conversation.account) }
  let(:response_object) { instance_double(Response, id: 1, question: 'Q1', answer: 'A1') }

  before do
    # Uncomment if you want to run the spec in your local machine
    # Features::ResponseBotService.new.enable_in_installation
    skip('Skipping since vector is not enabled in this environment') unless Features::ResponseBotService.new.vector_extension_enabled?
    stub_request(:post, 'https://api.openai.com/v1/embeddings').to_return(status: 200, body: {}.to_json,
                                                                          headers: { Content_Type: 'application/json' })
    create(:message, message_type: :incoming, conversation: conversation, content: 'Hi')
    create(:message, message_type: :outgoing, conversation: conversation, content: 'Hello')
    4.times { create(:response, response_source: response_source) }
    allow(ChatGpt).to receive(:new).and_return(chat_gpt_double)
    allow(chat_gpt_double).to receive(:generate_response).and_return({ 'response' => 'some_response', 'context_ids' => Response.all.map(&:id) })
    allow(conversation.inbox).to receive(:get_responses).with('Hi').and_return([response_object])
  end

  describe '#perform' do
    context 'when successful' do
      it 'creates an outgoing message along with article references' do
        expect do
          service.perform
        end.to change { conversation.messages.where(message_type: :outgoing).count }.by(1)

        last_message = conversation.messages.last
        expect(last_message.content).to include('some_response')
        expect(last_message.content).to include(Response.first.question)
        expect(last_message.content).to include('**Sources**')
      end
    end

    context 'when context_ids are not present' do
      it 'creates an outgoing message without article references' do
        allow(chat_gpt_double).to receive(:generate_response).and_return({ 'response' => 'some_response' })

        expect do
          service.perform
        end.to change { conversation.messages.where(message_type: :outgoing).count }.by(1)

        last_message = conversation.messages.last
        expect(last_message.content).to include('some_response')
        expect(last_message.content).not_to include('**Sources**')
      end
    end

    context 'when response doesnt have response document' do
      it 'creates an outgoing message without article references' do
        response = create(:response, response_source: response_source, response_document: nil)
        allow(chat_gpt_double).to receive(:generate_response).and_return({ 'response' => 'some_response', 'context_ids' => [response.id] })

        expect do
          service.perform
        end.to change { conversation.messages.where(message_type: :outgoing).count }.by(1)

        last_message = conversation.messages.last
        expect(last_message.content).to include('some_response')
        expect(last_message.content).not_to include('**Sources**')
      end
    end

    context 'when JSON::ParserError is raised' do
      it 'creates a handoff message' do
        allow(chat_gpt_double).to receive(:generate_response).and_raise(JSON::ParserError)

        expect do
          service.perform
        end.to change { conversation.messages.where(message_type: :outgoing).count }.by(1)

        expect(conversation.messages.last.content).to eq('passing to an agent')
        expect(conversation.status).to eq('open')
      end
    end

    context 'when StandardError is raised' do
      it 'captures the exception' do
        allow(chat_gpt_double).to receive(:generate_response).and_raise(StandardError)

        expect(ChatwootExceptionTracker).to receive(:new).and_call_original

        expect do
          service.perform
        end.to change { conversation.messages.where(message_type: :outgoing).count }.by(1)

        expect(conversation.messages.last.content).to eq('passing to an agent')
        expect(conversation.status).to eq('open')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Enterprise::Billing::CreateSessionService
  def create_session(customer_id, return_url = ENV.fetch('FRONTEND_URL'))
    Stripe::BillingPortal::Session.create(
      {
        customer: customer_id,
        return_url: return_url
      }
    )
  end
end

```","require 'rails_helper'

describe Enterprise::Billing::CreateSessionService do
  subject(:create_session_service) { described_class }

  describe '#perform' do
    it 'calls stripe billing portal session' do
      customer_id = 'cus_random_number'
      return_url = 'https://www.chatwoot.com'
      allow(Stripe::BillingPortal::Session).to receive(:create).with({ customer: customer_id, return_url: return_url })

      create_session_service.new.create_session(customer_id, return_url)

      expect(Stripe::BillingPortal::Session).to have_received(:create).with(
        {
          customer: customer_id,
          return_url: return_url
        }
      )
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Enterprise::Billing::CreateStripeCustomerService
  pattr_initialize [:account!]

  DEFAULT_QUANTITY = 2

  def perform
    customer_id = prepare_customer_id
    subscription = Stripe::Subscription.create(
      {
        customer: customer_id,
        items: [{ price: price_id, quantity: default_quantity }]
      }
    )
    account.update!(
      custom_attributes: {
        stripe_customer_id: customer_id,
        stripe_price_id: subscription['plan']['id'],
        stripe_product_id: subscription['plan']['product'],
        plan_name: default_plan['name'],
        subscribed_quantity: subscription['quantity']
      }
    )
  end

  private

  def prepare_customer_id
    customer_id = account.custom_attributes['stripe_customer_id']
    if customer_id.blank?
      customer = Stripe::Customer.create({ name: account.name, email: billing_email })
      customer_id = customer.id
    end
    customer_id
  end

  def default_quantity
    default_plan['default_quantity'] || DEFAULT_QUANTITY
  end

  def billing_email
    account.administrators.first.email
  end

  def default_plan
    installation_config = InstallationConfig.find_by(name: 'CHATWOOT_CLOUD_PLANS')
    @default_plan ||= installation_config.value.first
  end

  def price_id
    price_ids = default_plan['price_ids']
    price_ids.first
  end
end

```","require 'rails_helper'

describe Enterprise::Billing::CreateStripeCustomerService do
  subject(:create_stripe_customer_service) { described_class }

  let(:account) { create(:account) }
  let!(:admin1) { create(:user, account: account, role: :administrator) }
  let(:admin2) { create(:user, account: account, role: :administrator) }

  describe '#perform' do
    before do
      create(
        :installation_config,
        { name: 'CHATWOOT_CLOUD_PLANS', value: [
          { 'name' => 'A Plan Name', 'product_id' => ['prod_hacker_random'], 'price_ids' => ['price_hacker_random'] }
        ] }
      )
    end

    it 'does not call stripe methods if customer id is present' do
      account.update!(custom_attributes: { stripe_customer_id: 'cus_random_number' })

      allow(Stripe::Customer).to receive(:create)
      allow(Stripe::Subscription).to receive(:create)
        .and_return(
          {
            plan: { id: 'price_random_number', product: 'prod_random_number' },
            quantity: 2
          }.with_indifferent_access
        )

      create_stripe_customer_service.new(account: account).perform

      expect(Stripe::Customer).not_to have_received(:create)
      expect(Stripe::Subscription)
        .to have_received(:create)
        .with({ customer: 'cus_random_number', items: [{ price: 'price_hacker_random', quantity: 2 }] })

      expect(account.reload.custom_attributes).to eq(
        {
          stripe_customer_id: 'cus_random_number',
          stripe_price_id: 'price_random_number',
          stripe_product_id: 'prod_random_number',
          subscribed_quantity: 2,
          plan_name: 'A Plan Name'
        }.with_indifferent_access
      )
    end

    it 'calls stripe methods to create a customer and updates the account' do
      customer = double
      allow(Stripe::Customer).to receive(:create).and_return(customer)
      allow(customer).to receive(:id).and_return('cus_random_number')
      allow(Stripe::Subscription)
        .to receive(:create)
        .and_return(
          {
            plan: { id: 'price_random_number', product: 'prod_random_number' },
            quantity: 2
          }.with_indifferent_access
        )

      create_stripe_customer_service.new(account: account).perform

      expect(Stripe::Customer).to have_received(:create).with({ name: account.name, email: admin1.email })
      expect(Stripe::Subscription)
        .to have_received(:create)
        .with({ customer: customer.id, items: [{ price: 'price_hacker_random', quantity: 2 }] })

      expect(account.reload.custom_attributes).to eq(
        {
          stripe_customer_id: customer.id,
          stripe_price_id: 'price_random_number',
          stripe_product_id: 'prod_random_number',
          subscribed_quantity: 2,
          plan_name: 'A Plan Name'
        }.with_indifferent_access
      )
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class Enterprise::Billing::HandleStripeEventService
  def perform(event:)
    ensure_event_context(event)
    case @event.type
    when 'customer.subscription.updated'
      process_subscription_updated
    when 'customer.subscription.deleted'
      process_subscription_deleted
    else
      Rails.logger.debug { ""Unhandled event type: #{event.type}"" }
    end
  end

  private

  def process_subscription_updated
    plan = find_plan(subscription['plan']['product'])
    # skipping self hosted plan events
    return if plan.blank? || account.blank?

    update_account_attributes(subscription, plan)

    change_plan_features
  end

  def update_account_attributes(subscription, plan)
    # https://stripe.com/docs/api/subscriptions/object

    account.update(
      custom_attributes: {
        stripe_customer_id: subscription.customer,
        stripe_price_id: subscription['plan']['id'],
        stripe_product_id: subscription['plan']['product'],
        plan_name: plan['name'],
        subscribed_quantity: subscription['quantity'],
        subscription_status: subscription['status'],
        subscription_ends_on: Time.zone.at(subscription['current_period_end'])
      }
    )
  end

  def process_subscription_deleted
    # skipping self hosted plan events
    return if account.blank?

    Enterprise::Billing::CreateStripeCustomerService.new(account: account).perform
  end

  def change_plan_features
    if default_plan?
      account.disable_features(*features_to_update)
    else
      account.enable_features(*features_to_update)
    end
    account.save!
  end

  def ensure_event_context(event)
    @event = event
  end

  def features_to_update
    %w[help_center campaigns team_management channel_twitter channel_facebook channel_email]
  end

  def subscription
    @subscription ||= @event.data.object
  end

  def account
    @account ||= Account.where(""custom_attributes->>'stripe_customer_id' = ?"", subscription.customer).first
  end

  def find_plan(plan_id)
    installation_config = InstallationConfig.find_by(name: 'CHATWOOT_CLOUD_PLANS')
    installation_config.value.find { |config| config['product_id'].include?(plan_id) }
  end

  def default_plan?
    installation_config = InstallationConfig.find_by(name: 'CHATWOOT_CLOUD_PLANS')
    default_plan = installation_config.value.first
    @account.custom_attributes['plan_name'] == default_plan['name']
  end
end

```","require 'rails_helper'

describe Enterprise::Billing::HandleStripeEventService do
  subject(:stripe_event_service) { described_class }

  let(:event) { double }
  let(:data) { double }
  let(:subscription) { double }
  let!(:account) { create(:account, custom_attributes: { stripe_customer_id: 'cus_123' }) }

  before do
    allow(event).to receive(:data).and_return(data)
    allow(data).to receive(:object).and_return(subscription)
    allow(subscription).to receive(:[]).with('plan')
                                       .and_return({
                                                     'id' => 'test', 'product' => 'plan_id', 'name' => 'plan_name'
                                                   })
    allow(subscription).to receive(:[]).with('quantity').and_return('10')
    allow(subscription).to receive(:[]).with('status').and_return('active')
    allow(subscription).to receive(:[]).with('current_period_end').and_return(1_686_567_520)
    allow(subscription).to receive(:customer).and_return('cus_123')
    create(:installation_config, {
             name: 'CHATWOOT_CLOUD_PLANS',
             value: [
               {
                 'name' => 'Hacker',
                 'product_id' => ['plan_id'],
                 'price_ids' => ['price_1']
               },
               {
                 'name' => 'Startups',
                 'product_id' => ['plan_id_2'],
                 'price_ids' => ['price_2']
               }
             ]
           })
  end

  describe '#perform' do
    it 'handle customer.subscription.updated' do
      allow(event).to receive(:type).and_return('customer.subscription.updated')
      allow(subscription).to receive(:customer).and_return('cus_123')
      stripe_event_service.new.perform(event: event)
      expect(account.reload.custom_attributes).to eq({
                                                       'stripe_customer_id' => 'cus_123',
                                                       'stripe_price_id' => 'test',
                                                       'stripe_product_id' => 'plan_id',
                                                       'plan_name' => 'Hacker',
                                                       'subscribed_quantity' => '10',
                                                       'subscription_ends_on' => Time.zone.at(1_686_567_520).as_json,
                                                       'subscription_status' => 'active'
                                                     })
    end

    it 'disable features on customer.subscription.updated for default plan' do
      allow(event).to receive(:type).and_return('customer.subscription.updated')
      allow(subscription).to receive(:customer).and_return('cus_123')
      stripe_event_service.new.perform(event: event)
      expect(account.reload.custom_attributes).to eq({
                                                       'stripe_customer_id' => 'cus_123',
                                                       'stripe_price_id' => 'test',
                                                       'stripe_product_id' => 'plan_id',
                                                       'plan_name' => 'Hacker',
                                                       'subscribed_quantity' => '10',
                                                       'subscription_ends_on' => Time.zone.at(1_686_567_520).as_json,
                                                       'subscription_status' => 'active'
                                                     })
      expect(account).not_to be_feature_enabled('channel_email')
      expect(account).not_to be_feature_enabled('help_center')
    end

    it 'handles customer.subscription.deleted' do
      stripe_customer_service = double
      allow(event).to receive(:type).and_return('customer.subscription.deleted')
      allow(Enterprise::Billing::CreateStripeCustomerService).to receive(:new).and_return(stripe_customer_service)
      allow(stripe_customer_service).to receive(:perform)
      stripe_event_service.new.perform(event: event)
      expect(Enterprise::Billing::CreateStripeCustomerService).to have_received(:new).with(account: account)
    end
  end

  describe '#perform for Startups plan' do
    before do
      allow(event).to receive(:data).and_return(data)
      allow(data).to receive(:object).and_return(subscription)
      allow(subscription).to receive(:[]).with('plan')
                                         .and_return({
                                                       'id' => 'test', 'product' => 'plan_id_2', 'name' => 'plan_name'
                                                     })
      allow(subscription).to receive(:[]).with('quantity').and_return('10')
      allow(subscription).to receive(:customer).and_return('cus_123')
    end

    it 'enable features on customer.subscription.updated' do
      allow(event).to receive(:type).and_return('customer.subscription.updated')
      allow(subscription).to receive(:customer).and_return('cus_123')
      stripe_event_service.new.perform(event: event)
      expect(account.reload.custom_attributes).to eq({
                                                       'stripe_customer_id' => 'cus_123',
                                                       'stripe_price_id' => 'test',
                                                       'stripe_product_id' => 'plan_id_2',
                                                       'plan_name' => 'Startups',
                                                       'subscribed_quantity' => '10',
                                                       'subscription_ends_on' => Time.zone.at(1_686_567_520).as_json,
                                                       'subscription_status' => 'active'
                                                     })
      expect(account).to be_feature_enabled('channel_email')
      expect(account).to be_feature_enabled('help_center')
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class UpdateQueryFromParamsService
  def initialize(query, user)
    self.query = query
    self.current_user = user
  end

  # rubocop:disable Metrics/AbcSize
  def call(params, valid_subset: false)
    apply_group_by(params)

    apply_sort_by(params)

    apply_filters(params)

    apply_columns(params)

    apply_sums(params)

    apply_timeline(params)

    apply_hierarchy(params)

    apply_highlighting(params)

    apply_display_representation(params)

    apply_include_subprojects(params)

    apply_timestamps(params)

    disable_hierarchy_when_only_grouped_by(params)

    if valid_subset
      query.valid_subset!
    end

    if query.valid?
      ServiceResult.success(result: query)
    else
      ServiceResult.failure(errors: query.errors)
    end
  end
  # rubocop:enable Metrics/AbcSize

  private

  def apply_group_by(params)
    query.group_by = params[:group_by] if params.key?(:group_by)
  end

  def apply_sort_by(params)
    query.sort_criteria = params[:sort_by] if params[:sort_by]
  end

  def apply_filters(params)
    return unless params[:filters]

    query.filters = []

    params[:filters].each do |filter|
      query.add_filter(filter[:field], filter[:operator], filter[:values])
    end
  end

  def apply_columns(params)
    query.column_names = params[:columns] if params[:columns]
  end

  def apply_sums(params)
    query.display_sums = params[:display_sums] if params.key?(:display_sums)
  end

  def apply_timeline(params)
    query.timeline_visible = params[:timeline_visible] if params.key?(:timeline_visible)
    query.timeline_zoom_level = params[:timeline_zoom_level] if params.key?(:timeline_zoom_level)
    query.timeline_labels = params[:timeline_labels] if params.key?(:timeline_labels)
  end

  def apply_hierarchy(params)
    query.show_hierarchies = params[:show_hierarchies] if params.key?(:show_hierarchies)
  end

  def apply_highlighting(params)
    query.highlighting_mode = params[:highlighting_mode] if params.key?(:highlighting_mode)
    query.highlighted_attributes = params[:highlighted_attributes] if params.key?(:highlighted_attributes)
  end

  def apply_display_representation(params)
    query.display_representation = params[:display_representation] if params.key?(:display_representation)
  end

  def apply_include_subprojects(params)
    query.include_subprojects = params[:include_subprojects] if params.key?(:include_subprojects)
  end

  def apply_timestamps(params)
    query.timestamps = params[:timestamps] if params.key?(:timestamps)
  end

  def disable_hierarchy_when_only_grouped_by(params)
    if params.key?(:group_by) && !params.key?(:show_hierarchies)
      query.show_hierarchies = false
    end
  end

  attr_accessor :query,
                :current_user,
                :params
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe UpdateQueryFromParamsService,
               type: :model do
  let(:user) { build_stubbed(:user) }
  let(:query) { build_stubbed(:query) }

  let(:instance) { described_class.new(query, user) }

  let(:params) { {} }

  describe '#call' do
    subject { instance.call(params) }

    context 'group_by' do
      context 'for an existing value' do
        let(:params) { { group_by: 'status' } }

        it 'sets the value' do
          subject

          expect(query.group_by)
            .to eql('status')
        end
      end

      context 'for an explicitly nil value' do
        let(:params) { { group_by: nil } }

        it 'sets the value' do
          subject

          expect(query.group_by)
            .to be_nil
        end
      end
    end

    context 'filters' do
      let(:params) do
        { filters: [{ field: 'status_id', operator: '=', values: ['1', '2'] }] }
      end

      context 'for a valid filter' do
        it 'sets the filter' do
          subject

          expect(query.filters.length)
            .to be(1)
          expect(query.filters[0].name)
            .to be(:status_id)
          expect(query.filters[0].operator)
            .to eql('=')
          expect(query.filters[0].values)
            .to eql(['1', '2'])
        end
      end
    end

    context 'sort_by' do
      let(:params) do
        { sort_by: [['status_id', 'desc']] }
      end

      it 'sets the order' do
        subject

        expect(query.sort_criteria)
          .to eql([['status_id', 'desc']])
      end
    end

    context 'columns' do
      let(:params) do
        { columns: ['assigned_to', 'author', 'category', 'subject'] }
      end

      it 'sets the columns' do
        subject

        expect(query.column_names)
          .to match_array(params[:columns].map(&:to_sym))
      end
    end

    context 'display representation' do
      let(:params) do
        { display_representation: 'list' }
      end

      it 'sets the display_representation' do
        subject

        expect(query.display_representation)
          .to eq('list')
      end
    end

    context 'highlighting mode', with_ee: %i[conditional_highlighting] do
      let(:params) do
        { highlighting_mode: 'status' }
      end

      it 'sets the highlighting_mode' do
        subject

        expect(query.highlighting_mode)
          .to eq(:status)
      end
    end

    context 'default highlighting mode', with_ee: %i[conditional_highlighting] do
      let(:params) do
        {}
      end

      it 'sets the highlighting_mode' do
        subject

        expect(query.highlighting_mode)
          .to eq(:inline)
      end
    end

    context 'highlighting mode without EE' do
      let(:params) do
        { highlighting_mode: 'status' }
      end

      it 'sets the highlighting_mode' do
        subject

        expect(query.highlighting_mode)
          .to eq(:none)
      end
    end

    context 'when using include subprojects' do
      let(:params) do
        { include_subprojects: }
      end

      context 'when true' do
        let(:include_subprojects) { true }

        it 'sets the display_representation' do
          subject

          expect(query.include_subprojects)
            .to be true
        end
      end

      context 'when false' do
        let(:include_subprojects) { false }

        it 'sets the display_representation' do
          subject

          expect(query.include_subprojects)
            .to be false
        end
      end
    end

    context ""when providing timestamps"" do
      let(:timestamps) do
        [
          Timestamp.parse(""2022-10-29T23:01:23Z""),
          Timestamp.parse(""oneWeekAgo@12:00+00:00""),
          Timestamp.parse(""PT0S"")
        ]
      end
      let(:params) { { timestamps: } }

      it 'sets the timestamps' do
        subject

        expect(query.timestamps).to eq timestamps
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class UpdateProjectsTypesService < BaseProjectService
  def call(type_ids)
    type_ids = standard_types if type_ids.blank?

    if types_missing?(type_ids)
      project.errors.add(:types,
                         :in_use_by_work_packages,
                         types: missing_types(type_ids).map(&:name).join(', '))
      false
    else
      update_project_types(type_ids)

      true
    end
  end

  protected

  def standard_types
    type = ::Type.standard_type
    if type.nil?
      []
    else
      [type.id]
    end
  end

  def types_missing?(type_ids)
    !missing_types(type_ids).empty?
  end

  def missing_types(type_ids)
    types_used_by_work_packages.select { |t| type_ids.exclude?(t.id) }
  end

  def types_used_by_work_packages
    @types_used_by_work_packages ||= project.types_used_by_work_packages
  end

  def update_project_types(type_ids)
    new_types_to_add = type_ids - project.type_ids
    project.type_ids = type_ids
    project.work_package_custom_field_ids |= WorkPackageCustomField.joins(:types).where(types: { id: new_types_to_add }).ids
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.

require 'spec_helper'

RSpec.describe UpdateProjectsTypesService do
  let(:project) { instance_double(Project, types_used_by_work_packages: []) }
  let(:standard_type) { build_stubbed(:type_standard) }

  subject(:instance) { described_class.new(project) }

  before do
    allow(Type).to receive(:standard_type).and_return standard_type
  end

  describe '.call' do
    subject { instance.call(ids) }

    before do
      allow(project).to receive(:type_ids=)
    end

    shared_examples 'activating custom fields' do
      let(:project) { create(:project, no_types: true) }
      let!(:custom_field) { create(:text_wp_custom_field, types:) }

      it 'updates the active custom fields' do
        expect { subject }
          .to change { project.reload.work_package_custom_field_ids }
          .from([])
          .to([custom_field.id])
      end

      it 'does not activates the same custom field twice' do
        expect { subject }.to change { project.reload.work_package_custom_field_ids }
        expect { subject }.not_to change { project.reload.work_package_custom_field_ids }
      end

      context 'for a project with already existing types' do
        let(:project) { create(:project, types:, work_package_custom_fields: [create(:text_wp_custom_field)]) }

        it 'does not change custom fields' do
          expect { subject }.not_to change { project.reload.work_package_custom_field_ids }
        end
      end
    end

    context 'with ids provided' do
      let(:ids) { [1, 2, 3] }

      it 'returns true and updates the ids' do
        expect(subject).to be_truthy
        expect(project).to have_received(:type_ids=).with(ids)
      end

      include_examples 'activating custom fields' do
        let(:types) { create_list(:type, 2) }
        let(:ids) { types.collect(&:id) }
      end
    end

    context 'with no id passed' do
      let(:ids) { [] }

      it 'adds the id of the default type and returns true' do
        expect(subject).to be_truthy
        expect(project).to have_received(:type_ids=).with([standard_type.id])
      end

      include_examples 'activating custom fields' do
        let(:standard_type) { create(:type_standard) }
        let(:types) { [standard_type] }
      end
    end

    context 'with nil passed' do
      let(:ids) { nil }

      it 'adds the id of the default type and returns true' do
        expect(subject).to be_truthy
        expect(project).to have_received(:type_ids=).with([standard_type.id])
      end

      include_examples 'activating custom fields' do
        let(:standard_type) { create(:type_standard) }
        let(:types) { [standard_type] }
      end
    end

    context 'when the id of a type in use is not provided' do
      let(:type) { build_stubbed(:type) }
      let(:ids) { [1] }

      before do
        allow(project).to receive(:types_used_by_work_packages).and_return([type])
        allow(project).to receive(:work_package_custom_field_ids=).and_return([type])
      end

      it 'returns false and sets an error message' do
        errors = instance_double(ActiveModel::Errors)
        allow(errors).to receive(:add)
        allow(project).to receive(:errors).and_return(errors)

        expect(subject).to be_falsey
        expect(errors).to have_received(:add).with(:types, :in_use_by_work_packages, types: type.name)
        expect(project).not_to have_received(:type_ids=)
        expect(project).not_to have_received(:work_package_custom_field_ids=)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module Authorization
  module_function

  # Returns all users having a certain permission within a project
  def users(action, project)
    Authorization::UserAllowedQuery.query(action, project)
  end

  # Returns all projects a user has a certain permission in
  def projects(action, user)
    Project.allowed_to(user, action)
  end

  # Returns all work packages a user has a certain permission in (or in the project it belongs to)
  def work_packages(action, user)
    WorkPackage.allowed_to(user, action)
  end

  # Returns all roles a user has in a certain project, for a specific entity or globally
  def roles(user, context = nil)
    if context.is_a?(Project)
      Authorization::UserProjectRolesQuery.query(user, context)
    elsif Member.can_be_member_of?(context)
      Authorization::UserEntityRolesQuery.query(user, context)
    else
      Authorization::UserGlobalRolesQuery.query(user)
    end
  end

  # Normalizes the different types of permission arguments into Permission objects.
  # Possible arguments
  #  - Symbol permission names (e.g. :view_work_packages)
  #  - Hash with :controller and :action (e.g. { controller: 'work_packages', action: 'show' })
  #
  # Exceptions
  #  - When there is no permission matching the +action+ parameter, either an empty array is returned
  #    or an +UnknownPermissionError+ is raised (depending on the +raise_on_unknown+ parameter).
  # .  Additionally a debugger message is logged.
  #    If the permission is disabled, it will not raise an error or log debug output.
  def permissions_for(action, raise_on_unknown: false) # rubocop:disable Metrics/PerceivedComplexity, Metrics/AbcSize
    return [action] if action.is_a?(OpenProject::AccessControl::Permission)
    return action if action.is_a?(Array) && (action.empty? || action.all?(OpenProject::AccessControl::Permission))

    perms = if action.is_a?(Hash)
              OpenProject::AccessControl.allow_actions(action)
            else
              [OpenProject::AccessControl.permission(action)].compact
            end

    if perms.blank?
      if !OpenProject::AccessControl.disabled_permission?(action)
        Rails.logger.debug { ""Used permission \""#{action}\"" that is not defined. It will never return true."" }
        raise UnknownPermissionError.new(action) if raise_on_unknown
      end

      return []
    end

    perms
  end

  # Returns a set of normalized permissions filtered for a given context
  #  - When there are no permissions available for the given context (based on +permissible_on+
  #    attribute of the permission), an +IllegalPermissionContextError+ is raised
  def contextual_permissions(action, context, raise_on_unknown: false)
    perms = permissions_for(action, raise_on_unknown:)
    return [] if perms.blank?

    context_perms = perms.select { |p| p.permissible_on?(context) }
    raise IllegalPermissionContextError.new(action, perms, context) if context_perms.blank?

    context_perms
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Authorization do
  let(:user) { build_stubbed(:user) }
  let(:action) { :view_work_packages }

  describe '.users' do
    it 'calls Authorization::UserAllowedQuery' do
      expect(Authorization::UserAllowedQuery).to receive(:query).with(action, user)
      described_class.users(action, user)
    end
  end

  describe '.projects' do
    it 'uses the .allowed_to scope on Project' do
      expect(Project).to receive(:allowed_to).with(user, action)
      described_class.projects(action, user)
    end
  end

  describe '.work_packages' do
    it 'uses the .allowed_to scope on WorkPackage' do
      expect(WorkPackage).to receive(:allowed_to).with(user, action)
      described_class.work_packages(action, user)
    end
  end

  describe '.roles' do
    context 'with a project' do
      let(:context) { build_stubbed(:project) }

      it 'calls Authorization::UserProjectRolesQuery' do
        expect(Authorization::UserProjectRolesQuery).to receive(:query).with(user, context)
        described_class.roles(user, context)
      end
    end

    context 'with a WorkPackage' do
      let(:context) { build_stubbed(:work_package) }

      it 'calls Authorization::UserEntityRolesQuery' do
        expect(Authorization::UserEntityRolesQuery).to receive(:query).with(user, context)
        described_class.roles(user, context)
      end
    end

    context 'without a context' do
      let(:context) { nil }

      it 'calls Authorization::UserGlobalRolesQuery' do
        expect(Authorization::UserGlobalRolesQuery).to receive(:query).with(user)
        described_class.roles(user, context)
      end
    end
  end

  describe '.permissions_for' do
    let(:raise_on_unknown) { false }

    subject { described_class.permissions_for(action, raise_on_unknown:) }

    context 'when called with a Permission object' do
      let(:action) { OpenProject::AccessControl.permission(:view_work_packages) }

      it 'returns the Permission object wrapped in an array' do
        expect(subject).to eq([action])
      end
    end

    context 'when called with an array of Permission objects' do
      let(:action) do
        [
          OpenProject::AccessControl.permission(:view_work_packages),
          OpenProject::AccessControl.permission(:edit_work_packages)
        ]
      end

      it 'returns the Permission array' do
        expect(subject).to eq(action)
      end
    end

    context 'when action is a Hash where controller starts with a slash' do
      let(:action) do
        { controller: '/work_packages', action: 'show' }
      end

      it 'returns all permissions that grant the permission to this URL' do
        # there might be more permissions granting access to this URL, we check for a known one
        expect(subject).to include(OpenProject::AccessControl.permission(:view_work_packages))
      end
    end

    context 'when action is a Hash where controller does not start with a slash' do
      let(:action) do
        { controller: 'work_packages', action: 'show' }
      end

      it 'returns all permissions that grant the permission to this URL' do
        # there might be more permissions granting access to this URL, we check for a known one
        expect(subject).to include(OpenProject::AccessControl.permission(:view_work_packages))
      end
    end

    context 'when action is a permission name' do
      let(:action) { :view_work_packages }

      it 'returns the Permission object wrapped in an array' do
        expect(subject).to eq([OpenProject::AccessControl.permission(:view_work_packages)])
      end
    end

    context 'when there is a permission but it is disabled' do
      let(:permission_object) { OpenProject::AccessControl.permission(:manage_user) }
      let(:action) { permission_object.name }

      around do |example|
        permission_object.disable!
        OpenProject::AccessControl.clear_caches
        example.run
      ensure
        permission_object.enable!
        OpenProject::AccessControl.clear_caches
      end

      it 'returns an empty array and does not warn or raise' do
        expect(Rails.logger).not_to receive(:debug)
        expect do
          expect(subject).to be_empty
        end.not_to raise_error
      end
    end

    context 'when there is no permission' do
      let(:action) { :this_permission_does_not_exist }

      context 'and raise_on_unknown is false' do
        let(:raise_on_unknown) { false }

        it 'warns and returns an empty array' do
          allow(Rails.logger).to receive(:debug)

          expect(subject).to be_empty

          expect(Rails.logger).to have_received(:debug) do |_, &block|
            expect(block.call).to include(""Used permission \""#{action}\"" that is not defined."")
          end
        end
      end

      context 'and raise_on_unknown is true' do
        let(:raise_on_unknown) { true }

        it 'warns and raises' do
          allow(Rails.logger).to receive(:debug)

          expect { subject }.to raise_error(Authorization::UnknownPermissionError)

          expect(Rails.logger).to have_received(:debug) do |_, &block|
            expect(block.call).to include(""Used permission \""#{action}\"" that is not defined."")
          end
        end
      end
    end

    describe '.contextual_permissions' do
      subject { described_class.contextual_permissions(action, context, raise_on_unknown:) }

      let(:raise_on_unknown) { false }
      let(:context) { nil }

      let(:global_permission) { OpenProject::AccessControl.permission(:manage_user) }
      let(:project_permission) { OpenProject::AccessControl.permission(:manage_members) }
      let(:project_and_work_package_permission) { OpenProject::AccessControl.permission(:view_work_packages) }

      let(:returned_permissions) do
        [
          global_permission,
          project_permission,
          project_and_work_package_permission
        ]
      end

      before do
        allow(described_class).to receive(:permissions_for).and_return(returned_permissions)
      end

      context 'with global context' do
        let(:context) { :global }

        context 'when a global permission is part of the returned permissions' do
          it 'returns only the global permission' do
            expect(subject).to eq([global_permission])
          end
        end

        context 'when no global permission is part of the returned permissions' do
          let(:returned_permissions) { [project_permission, project_and_work_package_permission] }

          it 'raises an IllegalPermissionContextError' do
            expect { subject }.to raise_error(Authorization::IllegalPermissionContextError)
          end
        end
      end

      context 'with project context' do
        let(:context) { :project }

        context 'when a project permission is part of the returned permissions' do
          it 'returns only the project permissions' do
            expect(subject).to eq([project_permission, project_and_work_package_permission])
          end
        end

        context 'when no project permission is part of the returned permissions' do
          let(:returned_permissions) { [global_permission] }

          it 'raises an IllegalPermissionContextError' do
            expect { subject }.to raise_error(Authorization::IllegalPermissionContextError)
          end
        end
      end

      context 'with work package context' do
        let(:context) { :work_package }

        context 'when a work package permission is part of the returned permissions' do
          it 'returns only the work package permission' do
            expect(subject).to eq([project_and_work_package_permission])
          end
        end

        context 'when no work package permission is part of the returned permissions' do
          let(:returned_permissions) { [global_permission, project_permission] }

          it 'raises an IllegalPermissionContextError' do
            expect { subject }.to raise_error(Authorization::IllegalPermissionContextError)
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
class SetLocalizationService
  attr_reader :user, :http_accept_header

  include Redmine::I18n

  def initialize(user, http_accept_header = nil)
    @user = user
    @http_accept_header = http_accept_header
  end

  ##
  # Sets the locale.
  # The locale is determined with the following priority:
  #
  #   1. The language as configured by the user.
  #   2. The first language defined in the Accept-Language header sent by the browser.
  #   3. OpenProject's default language defined in the settings.

  def call
    lang = user_language || header_language || default_language

    set_language_if_valid(lang)
  end

  private

  def user_language
    find_language_or_prefix(user.language) if user.logged?
  end

  def header_language
    return unless http_accept_header

    accept_lang = parse_qvalues(http_accept_header).first
    find_language_or_prefix accept_lang
  end

  def default_language
    Setting.default_language
  end

  # qvalues http header parser
  # code taken from webrick
  def parse_qvalues(value)
    tmp = []
    if value
      parts = value.split(/,\s*/)
      parts.each do |part|
        match = /\A([^\s,]+?)(?:;\s*q=(\d+(?:\.\d+)?))?\z/.match(part)
        if match
          val = match[1]
          q = (match[2] || 1).to_f
          tmp.push([val, q])
        end
      end
      tmp = tmp.sort_by { |_val, q| -q }
      tmp.map! { |val, _q| val }
    end

    tmp
  rescue StandardError
    nil
  end

  def find_language_or_prefix(language)
    return nil unless language

    language = language.to_s.downcase
    find_language(language) || find_language(language.split('-').first)
  end
end

```","require 'spec_helper'

RSpec.describe SetLocalizationService do
  let(:user) { build_stubbed(:user, language: user_language) }
  let(:http_accept_header) { ""#{http_accept_language},en-US;q=0.8,en;q=0.6"" }
  let(:instance) { described_class.new(user, http_accept_header) }
  let(:user_language) { :bogus_language }
  let(:http_accept_language) { :http_accept_language }
  let(:default_language) { :default_language }

  before do
    allow(I18n).to receive(:locale=).with(:en)
    allow(instance).to receive(:valid_languages).and_return [user_language,
                                                             http_accept_language,
                                                             default_language]
    allow(Setting).to receive(:default_language).and_return(default_language)
  end

  def expect_locale(locale)
    expect(I18n).to receive(:locale=).with(locale)
  end

  shared_examples_for 'falls back to the header' do
    it 'falls back to the header' do
      expect_locale(http_accept_language)

      instance.call
    end
  end

  shared_examples_for ""falls back to the instane's default language"" do
    it ""falls back to the instance's default language"" do
      expect_locale(default_language)

      instance.call
    end
  end

  context 'for a logged in user' do
    it ""sets the language to the user's selected language"" do
      expect_locale(user_language)

      instance.call
    end

    context 'with a language prefix being valid' do
      let(:prefix) { 'someprefix' }
      let(:user_language) { ""#{prefix}-specific"" }

      before do
        allow(instance).to receive(:valid_languages).and_return [prefix,
                                                                 http_accept_language,
                                                                 default_language]
      end

      it ""sets the language to the valid prefix of the user's selected language"" do
        expect_locale(prefix)

        instance.call
      end
    end

    context 'with the language not being valid' do
      before do
        allow(instance).to receive(:valid_languages).and_return [http_accept_language,
                                                                 default_language]
      end

      it_behaves_like 'falls back to the header'

      context 'with a language prefix being valid' do
        let(:prefix) { 'someprefix' }
        let(:http_accept_header) { ""#{prefix}-specific"" }

        before do
          allow(instance).to receive(:valid_languages).and_return [prefix,
                                                                   default_language]
        end

        it ""sets the language to the valid prefix of the accept header"" do
          expect_locale(prefix)

          instance.call
        end
      end
    end

    context 'with the user not having a language selected' do
      before do
        user.language = nil
      end

      it_behaves_like 'falls back to the header'

      context 'with the header not being valid' do
        before do
          allow(instance).to receive(:valid_languages).and_return [user_language,
                                                                   default_language]
        end

        it_behaves_like ""falls back to the instane's default language""
      end

      context 'with no header set' do
        let(:http_accept_header) { nil }

        it_behaves_like ""falls back to the instane's default language""
      end

      context 'with wildcard header set' do
        let(:http_accept_language) { '*' }

        it_behaves_like ""falls back to the instane's default language""
      end
    end
  end

  context 'for an anonymous user' do
    let(:user) { build_stubbed(:anonymous) }

    it_behaves_like 'falls back to the header'

    context 'with no header set' do
      let(:http_accept_header) { nil }

      it_behaves_like ""falls back to the instane's default language""
    end

    context 'with a wildcard header set' do
      let(:http_accept_language) { '*' }

      it_behaves_like ""falls back to the instane's default language""
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class CreateTypeService < BaseTypeService
  def initialize(user)
    super Type.new, user
  end

  private

  def after_type_save(_params, options)
    # workflow copy
    if options[:copy_workflow_from].present? && (copy_from = ::Type.find_by(id: options[:copy_workflow_from]))
      type.workflows.copy_from_type(copy_from)
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'
require 'services/shared_type_service'

RSpec.describe CreateTypeService do
  let(:type) { instance.type }
  let(:user) { build_stubbed(:admin) }

  let(:instance) { described_class.new(user) }
  let(:service_call) { instance.call({ name: 'foo' }.merge(params), {}) }

  it_behaves_like 'type service'
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

##
# Create journal for the given user and note.
# Does not change the work package itself.

class AddWorkPackageNoteService
  include Contracted
  attr_accessor :user, :work_package

  def initialize(user:, work_package:)
    self.user = user
    self.work_package = work_package
    self.contract_class = WorkPackages::CreateNoteContract
  end

  def call(notes, send_notifications: nil)
    Journal::NotificationConfiguration.with send_notifications do
      work_package.add_journal(user:, notes:)

      success, errors = validate_and_yield(work_package, user) do
        work_package.save_journals
      end

      if success
        # In test environment, because of the difference in the way of handling transactions,
        # the journal needs to be actively loaded without SQL caching in place.
        journal = Journal.connection.uncached do
          work_package.journals.last
        end
      end

      ServiceResult.new(success:, result: journal, errors:)
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe AddWorkPackageNoteService, type: :model do
  let(:user) { build_stubbed(:user) }
  let(:work_package) { build_stubbed(:work_package) }
  let(:instance) do
    described_class.new(user:,
                        work_package:)
  end

  describe '.contract' do
    it 'uses the CreateNoteContract contract' do
      expect(instance.contract_class).to eql WorkPackages::CreateNoteContract
    end
  end

  describe 'call' do
    let(:mock_contract) do
      double(WorkPackages::CreateNoteContract,
             new: mock_contract_instance)
    end
    let(:mock_contract_instance) do
      double(WorkPackages::CreateNoteContract,
             errors: contract_errors,
             validate: valid_contract)
    end
    let(:valid_contract) { true }
    let(:contract_errors) do
      double('contract errors')
    end

    let(:send_notifications) { false }

    before do
      expect(Journal::NotificationConfiguration)
        .to receive(:with)
        .with(send_notifications)
        .and_yield

      allow(instance).to receive(:contract_class).and_return(mock_contract)
      allow(work_package).to receive(:save_journals).and_return true
    end

    subject { instance.call('blubs', send_notifications:) }

    it 'is successful' do
      expect(subject).to be_success
    end

    it 'persists the value' do
      expect(work_package).to receive(:save_journals).and_return true

      subject
    end

    it 'has no errors' do
      expect(subject.errors).to be_empty
    end

    context 'when the contract does not validate' do
      let(:valid_contract) { false }

      it 'is unsuccessful' do
        expect(subject.success?).to be_falsey
      end

      it 'does not persist the changes' do
        expect(work_package).not_to receive(:save_journals)

        subject
      end

      it ""exposes the contract's errors"" do
        errors = double('errors')
        allow(mock_contract_instance).to receive(:errors).and_return(errors)

        subject

        expect(subject.errors).to eql errors
      end
    end

    context 'when the saving is unsuccessful' do
      before do
        expect(work_package).to receive(:save_journals).and_return false
      end

      it 'is unsuccessful' do
        expect(subject).not_to be_success
      end

      it 'leaves the value unchanged' do
        subject

        expect(work_package.journal_notes).to eql 'blubs'
        expect(work_package.journal_user).to eql user
      end

      it ""exposes the work_packages's errors"" do
        errors = double('errors')
        allow(work_package).to receive(:errors).and_return(errors)

        subject

        expect(subject.errors).to eql errors
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class UpdateTypeService < BaseTypeService
  def call(params)
    # forbid renaming if it is a standard type
    if params[:type] && type.is_standard?
      params[:type].delete :name
    end

    super(params, {})
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'
require 'services/shared_type_service'

RSpec.describe UpdateTypeService do
  let(:type) { create(:type) }
  let(:user) { build_stubbed(:admin) }

  let(:instance) { described_class.new(type, user) }
  let(:service_call) { instance.call(params) }

  let(:valid_group) { { 'type' => 'attribute', 'name' => 'foo', 'attributes' => ['date'] } }

  it_behaves_like 'type service'

  describe ""#validate_attribute_groups"" do
    let(:params) { { name: 'blubs blubs' } }

    it 'raises an exception for invalid structure' do
      # Example for invalid structure:
      result = instance.call(attribute_groups: ['foo'])
      expect(result.success?).to be_falsey
      # Example for invalid structure:
      result = instance.call(attribute_groups: [[]])
      expect(result.success?).to be_falsey
      # Example for invalid group name:
      result = instance.call(attribute_groups: [['', ['date']]])
      expect(result.success?).to be_falsey
    end

    it 'fails for duplicate group names' do
      result = instance.call(attribute_groups: [valid_group, valid_group])
      expect(result.success?).to be_falsey
      expect(result.errors[:attribute_groups].first).to include 'used more than once.'
    end

    it 'passes validations for known attributes' do
      expect(type).to receive(:save).and_return(true)
      result = instance.call(attribute_groups: [valid_group])
      expect(result.success?).to be_truthy
    end

    it 'passes validation for defaults' do
      expect(type).to be_valid
    end

    it 'passes validation for reset' do
      # A reset is to save an empty Array
      expect(type).to receive(:save).and_return(true)
      result = instance.call(attribute_groups: [])
      expect(result.success?).to be_truthy
      expect(type).to be_valid
    end

    context 'with an invalid query' do
      let(:params) { { attribute_groups: [{ 'type' => 'query', name: 'some name', query: 'wat' }] } }

      it 'is invalid' do
        expect(service_call.success?).to be_falsey
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class ServiceResult
  SUCCESS = true
  FAILURE = false

  attr_accessor :success,
                :result,
                :errors,
                :dependent_results

  attr_writer :state

  # Creates a successful ServiceResult.
  def self.success(errors: nil,
                   message: nil,
                   message_type: nil,
                   state: nil,
                   dependent_results: [],
                   result: nil)
    new(success: SUCCESS,
        errors:,
        message:,
        message_type:,
        state:,
        dependent_results:,
        result:)
  end

  # Creates a failed ServiceResult.
  def self.failure(errors: nil,
                   message: nil,
                   message_type: nil,
                   state: nil,
                   dependent_results: [],
                   result: nil)
    new(success: FAILURE,
        errors:,
        message:,
        message_type:,
        state:,
        dependent_results:,
        result:)
  end

  def initialize(success: false,
                 errors: nil,
                 message: nil,
                 message_type: nil,
                 state: nil,
                 dependent_results: [],
                 result: nil)
    self.success = success
    self.result = result
    self.state = state

    initialize_errors(errors)
    @message = message
    @message_type = message_type

    self.dependent_results = dependent_results
  end

  alias success? :success

  def failure?
    !success?
  end

  ##
  # Merge another service result into this instance
  # allowing optionally to skip updating its service
  def merge!(other, without_success: false)
    merge_success!(other) unless without_success
    merge_errors!(other)
    merge_dependent!(other)
  end

  ##
  # Print messages to flash
  def apply_flash_message!(flash)
    if message
      flash[message_type] = message
    end
  end

  def all_results
    dependent_results.map(&:result).tap do |results|
      results.unshift result unless result.nil?
    end
  end

  def all_errors
    [errors] + dependent_results.map(&:errors)
  end

  ##
  # Test whether the returned errors respond
  # to the search key
  def includes_error?(attribute, error_key)
    all_errors.any? do |error|
      error.symbols_for(attribute).include?(error_key)
    end
  end

  ##
  # Collect all present errors for the given result
  # and dependent results.
  #
  # Returns a map of the service result to the error object
  def results_with_errors(include_self: true)
    results =
      if include_self
        [self] + dependent_results
      else
        dependent_results
      end

    results.reject { |call| call.errors.empty? }
  end

  def self_and_dependent
    [self] + dependent_results
  end

  def add_dependent!(dependent)
    merge_success!(dependent)

    inner_results = dependent.dependent_results
    dependent.dependent_results = []

    dependent_results << dependent
    self.dependent_results += inner_results
  end

  def on_success(&)
    tap(&) if success?
    self
  end

  def on_failure(&)
    tap(&) if failure?
    self
  end

  def each
    yield result if success?
    self
  end

  def map
    return self if failure?

    dup.tap do |new_result|
      new_result.result = yield result
    end
  end

  def to_a
    if success?
      [result]
    else
      []
    end
  end

  def message
    if @message
      @message
    elsif failure? && errors.is_a?(ActiveModel::Errors)
      errors.full_messages.join("" "")
    end
  end

  def state
    @state ||= ::Shared::ServiceState.build
  end

  private

  def initialize_errors(errors)
    self.errors = errors || new_errors_with_result
  end

  def new_errors_with_result
    ActiveModel::Errors.new(self).tap do |errors|
      errors.merge!(result) if result.try(:errors).present?
    end
  end

  def message_type
    if @message_type
      @message_type.to_sym
    elsif success?
      :notice
    else
      :error
    end
  end

  def merge_success!(other)
    self.success &&= other.success
  end

  def merge_errors!(other)
    errors.merge! other.errors
  end

  def merge_dependent!(other)
    self.dependent_results += other.dependent_results
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe ServiceResult, type: :model do
  let(:instance) { described_class.new }

  describe 'success' do
    it 'is what the service is initialized with' do
      instance = described_class.new success: true

      expect(instance.success).to be_truthy
      expect(instance.success?).to be(true)

      instance = described_class.new success: false

      expect(instance.success).to be_falsey
      expect(instance.success?).to be(false)
    end

    it 'returns what is provided' do
      instance.success = true

      expect(instance.success).to be_truthy
      expect(instance.success?).to be(true)

      instance.success = false

      expect(instance.success).to be_falsey
      expect(instance.success?).to be(false)
    end

    it 'is false by default' do
      expect(instance.success).to be_falsey
      expect(instance.success?).to be(false)
    end
  end

  describe '.success' do
    it 'creates a ServiceResult with success: true' do
      instance = described_class.success
      expect(instance.success).to be_truthy
    end

    it 'accepts the same set of parameters as the initializer' do
      errors = ['errors']
      message = 'message'
      message_type = :message_type
      state = instance_double(Shared::ServiceState)
      dependent_results = ['dependent_results']
      result = instance_double(Object, 'result')

      instance = described_class.success(
        errors:,
        message:,
        message_type:,
        state:,
        dependent_results:,
        result:
      )

      expect(instance.errors).to be(errors)
      expect(instance.message).to be(message)
      expect(instance.state).to be(state)
      expect(instance.dependent_results).to be(dependent_results)
      expect(instance.result).to be(result)
    end
  end

  describe '.failure' do
    it 'creates a ServiceResult with success: false' do
      instance = described_class.failure
      expect(instance.success).to be_falsy
    end

    it 'accepts the same set of parameters as the initializer' do
      errors = ['errors']
      message = 'message'
      message_type = :message_type
      state = instance_double(Shared::ServiceState)
      dependent_results = ['dependent_results']
      result = instance_double(Object, 'result')

      instance = described_class.failure(
        errors:,
        message:,
        message_type:,
        state:,
        dependent_results:,
        result:
      )

      expect(instance.errors).to be(errors)
      expect(instance.message).to be(message)
      expect(instance.state).to be(state)
      expect(instance.dependent_results).to be(dependent_results)
      expect(instance.result).to be(result)
    end
  end

  describe 'errors' do
    let(:errors) { ['errors'] }

    it 'is what has been provided' do
      instance.errors = errors

      expect(instance.errors).to eql errors
    end

    it 'is what the object is initialized with' do
      instance = described_class.new(errors:)

      expect(instance.errors).to eql errors
    end

    it 'is an empty ActiveModel::Errors by default' do
      expect(instance.errors).to be_a ActiveModel::Errors
    end

    context 'when providing errors from user' do
      let(:result) { build(:work_package) }

      it 'creates a new errors instance' do
        instance = described_class.new(result:)
        expect(instance.errors).not_to eq result.errors
      end
    end
  end

  describe 'result' do
    let(:result) { instance_double(Object, 'result') }

    it 'is what the object is initialized with' do
      instance = described_class.new(result:)

      expect(instance.result).to eql result
    end

    it 'is what has been provided' do
      instance.result = result

      expect(instance.result).to eql result
    end

    it 'is nil by default' do
      instance = described_class.new

      expect(instance.result).to be_nil
    end
  end

  describe 'apply_flash_message!' do
    let(:message) { 'some message' }

    subject(:flash) do
      {}.tap { service_result.apply_flash_message!(_1) }
    end

    context 'when successful' do
      let(:service_result) { described_class.success(message:) }

      it { is_expected.to include(notice: message) }
    end

    context 'when failure' do
      let(:service_result) { described_class.failure(message:) }

      it { is_expected.to include(error: message) }
    end

    context 'when setting message_type to :info' do
      let(:service_result) { described_class.success(message:, message_type: :info) }

      it { is_expected.to include(info: message) }
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class ParseSchemaFilterParamsService
  extend ActiveModel::Naming
  extend ActiveModel::Translation

  attr_accessor :user

  def self.i18n_scope
    :activerecord
  end

  def initialize(user:)
    self.user = user
  end

  def call(filter)
    error_message = check_error_in_filter(filter)

    if error_message
      error(error_message)
    else
      pairs = valid_project_type_pairs(filter)

      success(pairs)
    end
  end

  private

  def check_error_in_filter(filter)
    if !filter.first['id']
      :id_filter_required
    elsif filter.first['id']['operator'] != '='
      :unsupported_operator
    elsif filter.first['id']['values'].any? { |id_string| !id_string.match(/\d+-\d+/) }
      :invalid_values
    end
  end

  def parse_ids(filter)
    ids_string = filter.first['id']['values']

    ids_string.map do |id_string|
      id_string.split('-')
    end
  end

  def error(message)
    errors = ActiveModel::Errors.new(self)
    errors.add(:base, message)
    ServiceResult.failure(errors:)
  end

  def success(result)
    ServiceResult.success(result:)
  end

  def valid_project_type_pairs(filter)
    ids = parse_ids(filter)

    projects_map = projects_by_id(ids.map(&:first))
    types_map = types_by_id(ids.map(&:last))

    valid_ids = only_valid_pairs(ids, projects_map, types_map)

    string_pairs_to_object_pairs(valid_ids, projects_map, types_map)
  end

  def projects_by_id(ids)
    Project.visible(user).where(id: ids).group_by(&:id)
  end

  def types_by_id(ids)
    Type.where(id: ids).group_by(&:id)
  end

  def only_valid_pairs(id_pairs, projects_map, types_map)
    id_pairs.reject do |project_id, type_id|
      projects_map[project_id.to_i].nil? || types_map[type_id.to_i].nil?
    end
  end

  def string_pairs_to_object_pairs(string_pairs, projects_map, types_map)
    string_pairs.map do |project_id, type_id|
      [projects_map[project_id.to_i].first, types_map[type_id.to_i].first]
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.

require 'spec_helper'

RSpec.describe ParseSchemaFilterParamsService do
  let(:current_user) { build_stubbed(:user) }
  let(:instance) { described_class.new(user: current_user) }
  let(:project) { build_stubbed(:project) }
  let(:type) { build_stubbed(:type) }

  describe '#call' do
    let(:filter) do
      [{ 'id' => { 'values' => [""#{project.id}-#{type.id}""], 'operator' => '=' } }]
    end
    let(:result) { instance.call(filter) }

    let(:found_projects) { [project] }
    let(:found_types) { [type] }

    before do
      visible_projects = double('visible_projects')

      allow(Project)
        .to receive(:visible)
        .with(current_user)
        .and_return(visible_projects)

      allow(visible_projects)
        .to receive(:where)
        .with(id: [project.id.to_s])
        .and_return(found_projects)

      allow(Type)
        .to receive(:where)
        .with(id: [type.id.to_s])
        .and_return(found_types)
    end

    context 'valid' do
      it 'is a success' do
        expect(result).to be_success
      end

      it 'returns the [project, type] pair' do
        expect(result.result).to match_array [[project, type]]
      end
    end

    context 'for a non existing project' do
      let(:found_projects) { [] }

      it 'is a success' do
        expect(result).to be_success
      end

      it 'returns an empty array' do
        expect(result.result).to match_array []
      end
    end

    context 'for a non existing type' do
      let(:found_types) { [] }

      it 'is a success' do
        expect(result).to be_success
      end

      it 'returns an empty array' do
        expect(result.result).to match_array []
      end
    end

    context 'without the ""="" operator' do
      let(:filter) do
        [{ 'id' => { 'values' => [""#{project.id}-#{type.id}""], 'operator' => '!' } }]
      end

      it 'is a failure' do
        expect(result).not_to be_success
      end

      it 'returns an empty array' do
        expect(result.result).to be_nil
      end

      it 'returns an error message' do
        expect(result.errors.messages[:base]).to match_array ['The operator is not supported.']
      end
    end

    context 'with an invalid value' do
      let(:filter) do
        [{ 'id' => { 'values' => [""bogus-1""], 'operator' => ""="" } }]
      end

      it 'is a failure' do
        expect(result).not_to be_success
      end

      it 'returns an empty array' do
        expect(result.result).to be_nil
      end

      it 'returns an error message' do
        expect(result.errors.messages[:base]).to match_array ['A value is invalid.']
      end
    end

    context 'without an id filter' do
      let(:filter) do
        [{}]
      end

      it 'is a failure' do
        expect(result).not_to be_success
      end

      it 'returns an empty array' do
        expect(result.result).to be_nil
      end

      it 'returns an error message' do
        expect(result.errors.messages[:base]).to match_array ['An \'id\' filter is required.']
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

# -- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
# ++
#

class Settings::LanguageUpdateService < Settings::UpdateService
  def after_perform(call)
    force_users_to_use_only_available_languages

    call
  end

  private

  def force_users_to_use_only_available_languages
    User.where.not(language: Setting.available_languages)
        .update_all(language: Setting.default_language)
  end
end

```","# frozen_string_literal: true

# -- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
# ++
#

require 'spec_helper'

RSpec.describe Settings::LanguageUpdateService do
  let(:service) do
    described_class.new(user: build_stubbed(:admin))
  end
  let(:available_languages) { %w[de fr] }

  before do
    allow(service).to receive(:force_users_to_use_only_available_languages)
  end

  it 'sets language of users having a non-available language to the default language' do
    service.call(available_languages:)

    expect(service)
      .to have_received(:force_users_to_use_only_available_languages)
  end

  context 'when the contract is not successfully validated' do
    before do
      allow(service)
        .to receive(:validate_contract)
        .and_return(ServiceResult.failure(message: 'fake error'))
    end

    it 'does not change language of any users' do
      service.call(available_languages:)

      expect(service)
        .not_to have_received(:force_users_to_use_only_available_languages)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2022 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTALITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class Settings::WorkingDaysUpdateService < Settings::UpdateService
  def call(params)
    params = params.to_h.deep_symbolize_keys
    self.non_working_days_params = params.delete(:non_working_days) || []
    self.previous_working_days = Setting[:working_days]
    self.previous_non_working_days = NonWorkingDay.pluck(:date)
    super
  end

  def validate_params(params)
    contract = Settings::WorkingDaysParamsContract.new(model, user, params:)
    ServiceResult.new success: contract.valid?,
                      errors: contract.errors,
                      result: model
  end

  def persist(call)
    results = call
    ActiveRecord::Base.transaction do
      # The order of merging the service is important to preserve
      # the errors model's base object, which is a NonWorkingDay
      results = persist_non_working_days
      results.merge!(super) if results.success?

      raise ActiveRecord::Rollback if results.failure?
    end

    results
  end

  def after_perform(call)
    super.tap do
      WorkPackages::ApplyWorkingDaysChangeJob.perform_later(
        user_id: User.current.id,
        previous_working_days:,
        previous_non_working_days:
      )
    end
  end

  private

  attr_accessor :non_working_days_params, :previous_working_days, :previous_non_working_days

  def persist_non_working_days
    # We don't support update for now
    to_create, to_delete = attributes_to_create_and_delete
    results = destroy_records(to_delete)
    create_results = create_records(to_create)
    results.merge!(create_results)
    results.result = Array(results.result) + Array(create_results.result)
    results
  end

  def attributes_to_create_and_delete
    non_working_days_params.reduce([[], []]) do |results, nwd|
      results.first << nwd if !nwd[:id]
      results.last << nwd[:id] if nwd[:_destroy] && nwd[:id]
      results
    end
  end

  def create_records(attributes)
    wrap_result(attributes.map { |attrs| NonWorkingDay.create(attrs) })
  end

  def destroy_records(ids)
    records = NonWorkingDay.where(id: ids)
    # In case the transaction fails we also mark the records for destruction,
    # this way we can display them correctly on the frontend.
    records.each(&:mark_for_destruction)
    wrap_result records.destroy_all
  end

  def wrap_result(result)
    model = NonWorkingDay.new
    errors = model.errors.tap do |err|
      result.each do |r|
        err.merge!(r.errors)
      end
    end
    success = model.errors.empty?

    ServiceResult.new(success:, errors:, result:)
  end
end

```","#  OpenProject is an open source project management software.
#  Copyright (C) 2010-2022 the OpenProject GmbH
#
#  This program is free software; you can redistribute it and/or
#  modify it under the terms of the GNU General Public License version 3.
#
#  OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
#  Copyright (C) 2006-2013 Jean-Philippe Lang
#  Copyright (C) 2010-2013 the ChiliProject Team
#
#  This program is free software; you can redistribute it and/or
#  modify it under the terms of the GNU General Public License
#  as published by the Free Software Foundation; either version 2
#  of the License, or (at your option) any later version.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
#  See COPYRIGHT and LICENSE files for more details.

require 'spec_helper'
require_relative 'shared/shared_call_examples'

RSpec.describe Settings::WorkingDaysUpdateService do
  let(:instance) do
    described_class.new(user:)
  end
  let(:user) { build_stubbed(:user) }
  let(:contract) do
    instance_double(Settings::UpdateContract,
                    validate: contract_success,
                    errors: instance_double(ActiveModel::Error))
  end
  let(:contract_success) { true }
  let(:params_contract) do
    instance_double(Settings::WorkingDaysParamsContract,
                    valid?: params_contract_success,
                    errors: instance_double(ActiveModel::Error))
  end
  let(:params_contract_success) { true }
  let(:setting_name) { :a_setting_name }
  let(:new_setting_value) { 'a_new_setting_value' }
  let(:previous_setting_value) { 'the_previous_setting_value' }
  let(:setting_params) { { setting_name => new_setting_value } }
  let(:non_working_days_params) { {} }
  let(:params) { setting_params.merge(non_working_days: non_working_days_params) }

  before do
    # stub a setting definition
    allow(Setting)
      .to receive(:[])
          .and_call_original
    allow(Setting)
      .to receive(:[]).with(setting_name)
          .and_return(previous_setting_value)
    allow(Setting)
      .to receive(:[]=)

    # stub contract
    allow(Settings::UpdateContract)
      .to receive(:new)
          .and_return(contract)
    allow(Settings::WorkingDaysParamsContract)
      .to receive(:new)
          .and_return(params_contract)
  end

  describe '#call' do
    subject { instance.call(params) }

    shared_examples 'successful working days settings call' do
      include_examples 'successful call'

      it 'calls the WorkPackages::ApplyWorkingDaysChangeJob' do
        previous_working_days = Setting[:working_days]
        previous_non_working_days = NonWorkingDay.pluck(:date)

        allow(WorkPackages::ApplyWorkingDaysChangeJob).to receive(:perform_later)

        subject

        expect(WorkPackages::ApplyWorkingDaysChangeJob)
          .to have_received(:perform_later)
          .with(user_id: user.id, previous_working_days:, previous_non_working_days:)
      end
    end

    shared_examples 'unsuccessful working days settings call' do
      include_examples 'unsuccessful call'

      it 'does not persists the non working days' do
        expect { subject }.not_to change(NonWorkingDay, :count)
      end

      it 'does not calls the WorkPackages::ApplyWorkingDaysChangeJob' do
        allow(WorkPackages::ApplyWorkingDaysChangeJob).to receive(:perform_later)
        subject

        expect(WorkPackages::ApplyWorkingDaysChangeJob).not_to have_received(:perform_later)
      end
    end

    include_examples 'successful working days settings call'

    context 'when non working days are present' do
      let!(:existing_nwd) { create(:non_working_day, name: 'Existing NWD') }
      let!(:nwd_to_delete) { create(:non_working_day, name: 'NWD to delete') }
      let(:non_working_days_params) do
        [
          { 'name' => 'Christmas Eve', 'date' => '2022-12-24' },
          { 'name' => 'NYE', 'date' => '2022-12-31' },
          { 'id' => existing_nwd.id },
          { 'id' => nwd_to_delete.id, '_destroy' => true }
        ]
      end

      include_examples 'successful working days settings call'

      it 'persists (create/delete) the non working days' do
        expect { subject }.to change(NonWorkingDay, :count).by(1)

        expect { nwd_to_delete.reload }.to raise_error(ActiveRecord::RecordNotFound)

        expect(NonWorkingDay.all).to contain_exactly(
          have_attributes(name: 'Christmas Eve', date: Date.parse('2022-12-24')),
          have_attributes(name: 'NYE', date: Date.parse('2022-12-31')),
          have_attributes(existing_nwd.slice(:id, :name, :date))
        )
      end

      context 'when there are duplicates' do
        context 'with both within the params' do
          let(:non_working_days_params) do
            [
              { 'name' => 'Christmas Eve', 'date' => '2022-12-24' },
              { 'name' => 'Christmas Eve', 'date' => '2022-12-24' }
            ]
          end

          include_examples 'unsuccessful working days settings call'
        end

        context 'with one saved in the database' do
          let(:non_working_days_params) do
            [existing_nwd.slice(:name, :date)]
          end

          include_examples 'unsuccessful working days settings call'

          context 'when deleting and re-creating the duplicate non-working day' do
            let(:non_working_days_params) do
              [
                nwd_to_delete.slice(:id, :name, :date).merge('_destroy' => true),
                nwd_to_delete.slice(:name, :date)
              ]
            end

            include_examples 'successful working days settings call'

            it 'persists (create/delete) the non working days' do
              expect { subject }.not_to change(NonWorkingDay, :count)
              expect { nwd_to_delete.reload }.to raise_error(ActiveRecord::RecordNotFound)

              # The nwd_to_delete is being re-created after the deletion.
              expect(NonWorkingDay.all).to contain_exactly(
                have_attributes(existing_nwd.slice(:name, :date)),
                have_attributes(nwd_to_delete.slice(:name, :date))
              )
            end
          end

          context 'with duplicate params when deleting and re-creating non-working days' do
            let(:non_working_days_params) do
              [
                existing_nwd.slice(:id, :name, :date).merge('_destroy' => true),
                existing_nwd.slice(:name, :date),
                existing_nwd.slice(:name, :date)
              ]
            end

            include_examples 'unsuccessful working days settings call'

            it 'returns the unchanged results including the ones marked for destruction' do
              result = subject.result

              expect(result).to contain_exactly(
                have_attributes(existing_nwd.slice(:id, :name, :date)),
                have_attributes(existing_nwd.slice(:name, :date).merge(id: nil)),
                have_attributes(existing_nwd.slice(:name, :date).merge(id: nil))
              )

              expect(result.find { |r| r.id == existing_nwd.id }).to be_marked_for_destruction
            end
          end
        end
      end
    end

    context 'when the params contract is not successfully validated' do
      let(:params_contract_success) { false }

      include_examples 'unsuccessful working days settings call'
    end

    context 'when the contract is not successfully validated' do
      let(:contract_success) { false }

      include_examples 'unsuccessful working days settings call'

      context 'when non working days are present' do
        let(:non_working_days_params) do
          [
            { 'name' => 'Christmas Eve', 'date' => '2022-12-24' },
            { 'name' => 'NYE', 'date' => '2022-12-31' }
          ]
        end

        include_examples 'unsuccessful working days settings call'
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class Settings::UpdateService < BaseServices::BaseContracted
  def initialize(user:)
    super user:,
          contract_class: Settings::UpdateContract
  end

  def persist(call)
    params.each do |name, value|
      set_setting_value(name, value)
    end
    call
  end

  private

  def set_setting_value(name, value)
    Setting[name] = derive_value(value)
  end

  def derive_value(value)
    case value
    when Array, Hash
      # remove blank values in array, hash settings
      value.compact_blank!
    else
      value.strip
    end
  end
end

```","#  OpenProject is an open source project management software.
#  Copyright (C) 2010-2022 the OpenProject GmbH
#
#  This program is free software; you can redistribute it and/or
#  modify it under the terms of the GNU General Public License version 3.
#
#  OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
#  Copyright (C) 2006-2013 Jean-Philippe Lang
#  Copyright (C) 2010-2013 the ChiliProject Team
#
#  This program is free software; you can redistribute it and/or
#  modify it under the terms of the GNU General Public License
#  as published by the Free Software Foundation; either version 2
#  of the License, or (at your option) any later version.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
#  See COPYRIGHT and LICENSE files for more details.

require 'spec_helper'
require_relative 'shared/shared_call_examples'
require_relative 'shared/shared_setup_context'


RSpec.describe Settings::UpdateService do
  include_context 'with update service setup'

  describe '#call' do
    subject { instance.call(params) }

    include_examples 'successful call'

    context 'when the contract is not successfully validated' do
      let(:contract_success) { false }

      include_examples 'unsuccessful call'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module PlaceholderUsers
  class SetAttributesService < ::BaseServices::SetAttributes
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe PlaceholderUsers::SetAttributesService, type: :model do
  let(:current_user) { build_stubbed(:user) }

  let(:contract_instance) do
    contract = double('contract_instance')
    allow(contract)
      .to receive(:validate)
      .and_return(contract_valid)
    allow(contract)
      .to receive(:errors)
      .and_return(contract_errors)
    contract
  end

  let(:contract_errors) { double('contract_errors') }
  let(:contract_valid) { true }
  let(:model_valid) { true }

  let(:instance) do
    described_class.new(user: current_user,
                        model: model_instance,
                        contract_class:,
                        contract_options: {})
  end
  let(:model_instance) { PlaceholderUser.new }
  let(:contract_class) do
    allow(PlaceholderUsers::CreateContract)
      .to receive(:new)
      .and_return(contract_instance)

    PlaceholderUsers::CreateContract
  end

  let(:params) { {} }

  before do
    allow(model_instance)
      .to receive(:valid?)
      .and_return(model_valid)
  end

  subject { instance.call(params) }

  it 'returns the instance as the result' do
    expect(subject.result)
      .to eql model_instance
  end

  it 'is a success' do
    expect(subject)
      .to be_success
  end

  context 'with params' do
    let(:params) do
      {
        name: 'Foobar'
      }
    end

    it 'assigns the params' do
      subject

      expect(model_instance.name).to eq 'Foobar'
      expect(model_instance.lastname).to eq 'Foobar'
    end
  end

  context 'with an invalid contract' do
    let(:contract_valid) { false }
    let(:expect_time_instance_save) do
      expect(model_instance)
        .not_to receive(:save)
    end

    it 'returns failure' do
      expect(subject)
        .not_to be_success
    end

    it ""returns the contract's errors"" do
      expect(subject.errors)
        .to eql(contract_errors)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class PlaceholderUsers::UpdateService < BaseServices::Update
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'
require 'services/base_services/behaves_like_update_service'

RSpec.describe PlaceholderUsers::UpdateService, type: :model do
  it_behaves_like 'BaseServices update service'
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class PlaceholderUsers::CreateService < BaseServices::Create
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'
require 'services/base_services/behaves_like_create_service'

RSpec.describe PlaceholderUsers::CreateService, type: :model do
  it_behaves_like 'BaseServices create service'
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class PlaceholderUsers::DeleteService < BaseServices::Delete
  def destroy(placeholder)
    placeholder.locked!
    ::Principals::DeleteJob.perform_later(placeholder)

    true
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe PlaceholderUsers::DeleteService, type: :model do
  let(:placeholder_user) { build_stubbed(:placeholder_user) }
  let(:project) { build_stubbed(:project) }

  let(:instance) { described_class.new(model: placeholder_user, user: actor) }

  subject { instance.call }

  shared_examples 'deletes the user' do
    it do
      expect(placeholder_user).to receive(:locked!)
      expect(Principals::DeleteJob).to receive(:perform_later).with(placeholder_user)
      expect(subject).to be_success
    end
  end

  shared_examples 'does not delete the user' do
    it do
      expect(placeholder_user).not_to receive(:locked!)
      expect(Principals::DeleteJob).not_to receive(:perform_later)
      expect(subject).not_to be_success
    end
  end

  context 'with admin user' do
    let(:actor) { build_stubbed(:admin) }

    it_behaves_like 'deletes the user'
  end

  context 'with global user' do
    let(:actor) { build_stubbed(:user) }

    before do
      mock_permissions_for(actor) do |mock|
        mock.allow_globally :manage_placeholder_user
      end
    end

    it_behaves_like 'deletes the user'
  end

  context 'with unprivileged system user' do
    let(:actor) { User.system }

    before do
      allow(actor).to receive(:admin?).and_return false
    end

    it_behaves_like 'does not delete the user'
  end

  context 'with privileged system user' do
    let(:actor) { User.system }

    it_behaves_like 'deletes the user' do
      around do |example|
        actor.run_given { example.run }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

# TODO: This is but a stub
module Messages
  class SetAttributesService < ::BaseServices::SetAttributes
    include Attachments::SetReplacements

    private

    def set_default_attributes(*)
      set_default_author
    end

    def set_default_author
      model.change_by_system do
        model.author = user
      end
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Messages::SetAttributesService, type: :model do
  let(:user) { build_stubbed(:user) }
  let(:forum) { build_stubbed(:forum) }
  let(:contract_instance) do
    contract = double('contract_instance')
    allow(contract)
      .to receive(:validate)
      .and_return(contract_valid)
    allow(contract)
      .to receive(:errors)
      .and_return(contract_errors)
    contract
  end

  let(:contract_errors) { double('contract_errors') }
  let(:contract_valid) { true }
  let(:time_entry_valid) { true }

  let(:instance) do
    described_class.new(user:,
                        model: message_instance,
                        contract_class:,
                        contract_options: {})
  end
  let(:message_instance) { Message.new }
  let(:contract_class) do
    allow(Messages::CreateContract)
      .to receive(:new)
      .with(message_instance, user, options: {})
      .and_return(contract_instance)

    Messages::CreateContract
  end

  let(:params) { {} }

  before do
    allow(message_instance)
      .to receive(:valid?)
      .and_return(time_entry_valid)
  end

  subject { instance.call(params) }

  it 'returns the message instance as the result' do
    expect(subject.result)
      .to eql message_instance
  end

  it 'is a success' do
    expect(subject)
      .to be_success
  end

  it ""has the service's user assigned as author"" do
    subject

    expect(message_instance.author)
      .to eql user
  end

  it 'notes the author to be system changed' do
    subject

    expect(message_instance.changed_by_system['author_id'])
      .to eql [nil, user.id]
  end

  context 'with params' do
    let(:params) do
      {
        forum:
      }
    end

    let(:expected) do
      {
        author_id: user.id,
        forum_id: forum.id
      }.with_indifferent_access
    end

    it 'assigns the params' do
      subject

      attributes_of_interest = message_instance
                                 .attributes
                                 .slice(*expected.keys)

      expect(attributes_of_interest)
        .to eql(expected)
    end
  end

  context 'with an invalid contract' do
    let(:contract_valid) { false }
    let(:expect_time_instance_save) do
      expect(message_instance)
        .not_to receive(:save)
    end

    it 'returns failure' do
      expect(subject)
        .not_to be_success
    end

    it ""returns the contract's errors"" do
      expect(subject.errors)
        .to eql(contract_errors)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class Messages::UpdateService < BaseServices::Update
  include Attachments::ReplaceAttachments
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'
require 'services/base_services/behaves_like_update_service'

RSpec.describe Messages::UpdateService, type: :model do
  it_behaves_like 'BaseServices update service'
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class Messages::CreateService < BaseServices::Create
  include Attachments::ReplaceAttachments
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'
require 'services/base_services/behaves_like_create_service'

RSpec.describe Messages::CreateService, type: :model do
  it_behaves_like 'BaseServices create service'
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class Relations::UpdateService < Relations::BaseService
  attr_accessor :model

  def initialize(user:, model:)
    super(user:)
    self.model = model
    self.contract_class = Relations::UpdateContract
  end

  def perform(attributes)
    in_user_context(send_notifications: attributes[:send_notifications]) do
      update_relation model, attributes
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Relations::UpdateService do
  let(:work_package1_start_date) { nil }
  let(:work_package1_due_date) { Date.today }
  let(:work_package2_start_date) { nil }
  let(:work_package2_due_date) { nil }

  let(:follows_relation) { false }
  let(:delay) { 3 }

  let(:work_package1) do
    build_stubbed(:work_package,
                  due_date: work_package1_due_date,
                  start_date: work_package1_start_date)
  end
  let(:work_package2) do
    build_stubbed(:work_package,
                  due_date: work_package2_due_date,
                  start_date: work_package2_start_date)
  end
  let(:instance) do
    described_class.new(user:, model: relation)
  end
  let(:relation) do
    relation = build_stubbed(:relation)

    allow(relation)
      .to receive(:follows?)
      .and_return(follows_relation)

    relation
  end
  let(:attributes) do
    {
      to: work_package1,
      from: work_package2,
      delay:
    }
  end

  let(:user) { build_stubbed(:user) }
  let(:model_valid) { true }
  let(:contract_valid) { true }
  let(:contract) { double('contract') }
  let(:symbols_for_base) { [] }

  subject do
    instance.call(attributes:)
  end

  before do
    allow(relation)
      .to receive(:save)
      .and_return(model_valid)

    allow(Relations::UpdateContract)
      .to receive(:new)
      .with(relation, user, options: {})
      .and_return(contract)
    allow(contract)
      .to receive(:validate)
      .and_return(contract_valid)
  end

  context 'when all valid and it is a follows relation' do
    let(:set_schedule_service) { double('set schedule service') }
    let(:set_schedule_work_package2_result) do
      ServiceResult.success result: work_package2, errors: work_package2.errors
    end
    let(:set_schedule_result) do
      sr = ServiceResult.success result: work_package2, errors: work_package2.errors
      sr.dependent_results << set_schedule_work_package2_result
      sr
    end

    let(:follows_relation) { true }

    before do
      expect(WorkPackages::SetScheduleService)
        .to receive(:new)
        .with(user:, work_package: work_package1)
        .and_return(set_schedule_service)

      expect(set_schedule_service)
        .to receive(:call)
        .and_return(set_schedule_result)

      allow(work_package2)
        .to receive(:changed?)
        .and_return(true)

      expect(work_package2)
        .to receive(:save)
        .and_return(true)

      allow(set_schedule_result)
        .to receive(:success=)
    end

    it 'is successful' do
      expect(subject)
        .to be_success
    end

    it 'returns the relation' do
      expect(subject.result)
        .to eql relation
    end

    it 'has a dependent result for the from-work package' do
      expect(subject.dependent_results)
        .to match_array [set_schedule_work_package2_result]
    end
  end

  context 'when all is valid and it is not a follows relation' do
    it 'is successful' do
      expect(subject)
        .to be_success
    end

    it 'returns the relation' do
      expect(subject.result)
        .to eql relation
    end
  end

  context 'when the contract is invalid' do
    let(:contract_valid) { false }
    let(:contract_errors) { double('contract_errors') }

    before do
      allow(contract)
        .to receive(:errors)
        .and_return(contract_errors)
      allow(contract_errors)
        .to receive(:symbols_for)
        .with(:base)
        .and_return(symbols_for_base)
    end

    it 'is unsuccessful' do
      expect(subject)
        .to be_failure
    end

    it ""returns the contract's errors"" do
      expect(subject.errors)
        .to eql contract_errors
    end
  end

  context 'when the model is invalid' do
    let(:model_valid) { false }
    let(:model_errors) { double('model_errors') }

    before do
      allow(relation)
        .to receive(:errors)
        .and_return(model_errors)
      allow(model_errors)
        .to receive(:symbols_for)
        .with(:base)
        .and_return(symbols_for_base)
    end

    it 'is unsuccessful' do
      expect(subject)
        .to be_failure
    end

    it ""returns the model's errors"" do
      expect(subject.errors)
        .to eql model_errors
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class Relations::CreateService < Relations::BaseService
  def initialize(user:)
    super
    self.contract_class = Relations::CreateContract
  end

  def perform(send_notifications: nil, **attributes)
    in_user_context(send_notifications:) do
      update_relation ::Relation.new, attributes
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Relations::CreateService do
  let(:work_package1_start_date) { nil }
  let(:work_package1_due_date) { Date.today }
  let(:work_package2_start_date) { nil }
  let(:work_package2_due_date) { nil }

  let(:follows_relation) { false }
  let(:delay) { 3 }

  let(:work_package1) do
    build_stubbed(:work_package,
                  due_date: work_package1_due_date,
                  start_date: work_package1_start_date)
  end
  let(:work_package2) do
    build_stubbed(:work_package,
                  due_date: work_package2_due_date,
                  start_date: work_package2_start_date)
  end
  let(:instance) do
    described_class.new(user:)
  end
  let(:relation) do
    relation = Relation.new attributes

    allow(relation)
      .to receive(:follows?)
      .and_return(follows_relation)

    relation
  end
  let(:attributes) do
    {
      to: work_package1,
      from: work_package2,
      delay:
    }
  end

  let(:user) { build_stubbed(:user) }
  let(:model_valid) { true }
  let(:contract_valid) { true }
  let(:contract) { double('contract') }
  let(:symbols_for_base) { [] }

  subject do
    instance.call(attributes)
  end

  before do
    allow(Relation)
      .to receive(:new)
            .and_return(relation)

    allow(relation)
      .to receive(:save)
      .and_return(model_valid)

    allow(Relations::CreateContract)
      .to receive(:new)
      .with(relation, user, options: {})
      .and_return(contract)
    allow(contract)
      .to receive(:validate)
      .and_return(contract_valid)
  end

  context 'if all valid and it is a follows relation' do
    let(:set_schedule_service) { double('set schedule service') }
    let(:set_schedule_work_package2_result) do
      ServiceResult.success result: work_package2, errors: work_package2.errors
    end
    let(:set_schedule_result) do
      sr = ServiceResult.success result: work_package2, errors: work_package2.errors
      sr.dependent_results << set_schedule_work_package2_result
      sr
    end

    let(:follows_relation) { true }

    before do
      expect(WorkPackages::SetScheduleService)
        .to receive(:new)
        .with(user:, work_package: work_package1)
        .and_return(set_schedule_service)

      expect(set_schedule_service)
        .to receive(:call)
        .and_return(set_schedule_result)

      allow(work_package2)
        .to receive(:changed?)
        .and_return(true)

      expect(work_package2)
        .to receive(:save)
        .and_return(true)

      allow(set_schedule_result)
        .to receive(:success=)
    end

    it 'is successful' do
      expect(subject)
        .to be_success
    end

    it 'returns the relation' do
      expect(subject.result)
        .to eql relation
    end

    it 'has a dependent result for the from-work package' do
      expect(subject.dependent_results)
        .to contain_exactly(set_schedule_work_package2_result)
    end
  end

  context 'if all is valid and it is not a follows relation' do
    it 'is successful' do
      expect(subject)
        .to be_success
    end

    it 'returns the relation' do
      expect(subject.result)
        .to eql relation
    end
  end

  context 'if the contract is invalid' do
    let(:contract_valid) { false }
    let(:contract_errors) { double('contract_errors') }

    before do
      allow(contract)
        .to receive(:errors)
        .and_return(contract_errors)
      allow(contract_errors)
        .to receive(:symbols_for)
        .with(:base)
        .and_return(symbols_for_base)
    end

    it 'is unsuccessful' do
      expect(subject)
        .to be_failure
    end

    it ""returns the contract's errors"" do
      expect(subject.errors)
        .to eql contract_errors
    end
  end

  context 'if the model is invalid' do
    let(:model_valid) { false }
    let(:model_errors) { double('model_errors') }

    before do
      allow(relation)
        .to receive(:errors)
        .and_return(model_errors)
      allow(model_errors)
        .to receive(:symbols_for)
        .with(:base)
        .and_return(symbols_for_base)
    end

    it 'is unsuccessful' do
      expect(subject)
        .to be_failure
    end

    it ""returns the model's errors"" do
      expect(subject.errors)
        .to eql model_errors
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class WorkPackages::SetAttributesService < BaseServices::SetAttributes
  include Attachments::SetReplacements

  private

  def set_attributes(attributes)
    file_links_ids = attributes.delete(:file_links_ids)
    model.file_links = Storages::FileLink.where(id: file_links_ids) if file_links_ids

    set_attachments_attributes(attributes)
    set_static_attributes(attributes)

    model.change_by_system do
      set_calculated_attributes(attributes)
    end

    set_custom_attributes(attributes)
  end

  def set_static_attributes(attributes)
    assignable_attributes = attributes.select do |key, _|
      !CustomField.custom_field_attribute?(key) && work_package.respond_to?(key)
    end

    work_package.attributes = assignable_attributes
  end

  def set_calculated_attributes(attributes)
    if work_package.new_record?
      set_default_attributes(attributes)
      unify_milestone_dates
    else
      update_dates
    end
    shift_dates_to_soonest_working_days
    update_duration
    update_derivable
    update_project_dependent_attributes
    reassign_invalid_status_if_type_changed
    set_templated_description
  end

  def derivable_attribute
    derivable_attribute_by_others_presence || derivable_attribute_by_others_absence
  end

  # Returns a field derivable by the presence of the two others, or +nil+ if
  # none was found.
  #
  # Matching is done in the order :duration, :due_date, :start_date. The first
  # one to match is returned.
  #
  # If +ignore_non_working_days+ has been changed, try deriving +due_date+ and
  # +start_date+ before +duration+.
  def derivable_attribute_by_others_presence
    fields =
      if work_package.ignore_non_working_days_changed?
        %i[due_date start_date duration]
      else
        %i[duration due_date start_date]
      end
    fields.find { |field| derivable_by_others_presence?(field) }
  end

  # Returns true if given +field+ is derivable from the presence of the two
  # others.
  #
  # A field is derivable if it has not been set explicitly while the other two
  # fields are set.
  def derivable_by_others_presence?(field)
    others = %i[start_date due_date duration].without(field)
    attribute_not_set_in_params?(field) && all_present?(*others)
  end

  # Returns a field derivable by the absence of one of the two others, or +nil+
  # if none was found.
  #
  # Matching is done in the order :duration, :due_date, :start_date. The first
  # one to match is returned.
  def derivable_attribute_by_others_absence
    %i[duration due_date start_date].find { |field| derivable_by_others_absence?(field) }
  end

  # Returns true if given +field+ is derivable from the absence of one of the
  # two others.
  #
  # A field is derivable if it has not been set explicitly while the other two
  # fields have one set and one nil.
  #
  # Note: if both other fields are nil, then the field is not derivable
  def derivable_by_others_absence?(field)
    others = %i[start_date due_date duration].without(field)
    attribute_not_set_in_params?(field) && only_one_present?(*others)
  end

  def attribute_not_set_in_params?(field)
    !params.has_key?(field)
  end

  def all_present?(*fields)
    work_package.values_at(*fields).all?(&:present?)
  end

  def only_one_present?(*fields)
    work_package.values_at(*fields).one?(&:present?)
  end

  # rubocop:disable Metrics/AbcSize
  def update_derivable
    case derivable_attribute
    when :duration
      work_package.duration =
        if work_package.milestone?
          1
        else
          days.duration(work_package.start_date, work_package.due_date)
        end
    when :due_date
      work_package.due_date = days.due_date(work_package.start_date, work_package.duration)
    when :start_date
      work_package.start_date = days.start_date(work_package.due_date, work_package.duration)
    end
  end
  # rubocop:enable Metrics/AbcSize

  def set_default_attributes(attributes)
    set_default_priority
    set_default_author
    set_default_status
    set_default_start_date(attributes)
    set_default_due_date(attributes)
  end

  def non_or_default_description?
    work_package.description.blank? || false
  end

  def set_default_author
    work_package.author ||= user
  end

  def set_default_status
    work_package.status ||= Status.default
  end

  def set_default_priority
    work_package.priority ||= IssuePriority.active.default
  end

  def set_default_start_date(attributes)
    return if attributes.has_key?(:start_date)

    work_package.start_date ||= if parent_start_earlier_than_due?
                                  work_package.parent.start_date
                                elsif Setting.work_package_startdate_is_adddate?
                                  Time.zone.today
                                end
  end

  def set_default_due_date(attributes)
    return if attributes.has_key?(:due_date)

    work_package.due_date ||= if parent_due_later_than_start?
                                work_package.parent.due_date
                              end
  end

  def set_templated_description
    # We only set this if the work package is new
    return unless work_package.new_record?

    # And the type was changed
    return unless work_package.type_id_changed?

    # And the new type has a default text
    default_description = work_package.type&.description
    return if default_description.blank?

    # And the current description matches ANY current default text
    return unless work_package.description.blank? || default_description?

    work_package.description = default_description
  end

  def default_description?
    Type
      .pluck(:description)
      .compact
      .map(&method(:normalize_whitespace))
      .include?(normalize_whitespace(work_package.description))
  end

  def normalize_whitespace(string)
    string.gsub(/\s/, ' ').squeeze(' ')
  end

  def set_custom_attributes(attributes)
    assignable_attributes = attributes.select do |key, _|
      CustomField.custom_field_attribute?(key) && work_package.respond_to?(key)
    end

    work_package.attributes = assignable_attributes

    initialize_unset_custom_values
  end

  def custom_field_context_changed?
    work_package.type_id_changed? || work_package.project_id_changed?
  end

  def work_package_now_milestone?
    work_package.type_id_changed? && work_package.milestone?
  end

  def update_project_dependent_attributes
    return unless work_package.project_id_changed? && work_package.project_id

    model.change_by_system do
      set_version_to_nil
      reassign_category
      set_parent_to_nil

      reassign_type unless work_package.type_id_changed?
    end
  end

  def update_dates
    unify_milestone_dates

    min_start = new_start_date

    return unless min_start

    work_package.due_date = new_due_date(min_start)
    work_package.start_date = min_start
  end

  def unify_milestone_dates
    return unless work_package_now_milestone?

    unified_date = work_package.due_date || work_package.start_date
    work_package.start_date = work_package.due_date = unified_date
  end

  def shift_dates_to_soonest_working_days
    return if work_package.ignore_non_working_days?

    work_package.start_date = days.soonest_working_day(work_package.start_date)
    work_package.due_date = days.soonest_working_day(work_package.due_date)
  end

  def update_duration
    work_package.duration = 1 if work_package.milestone?
  end

  def set_version_to_nil
    if work_package.version &&
       work_package.project &&
       work_package.project.shared_versions.exclude?(work_package.version)
      work_package.version = nil
    end
  end

  def set_parent_to_nil
    if !Setting.cross_project_work_package_relations? &&
      !work_package.parent_changed?

      work_package.parent = nil
    end
  end

  def reassign_category
    # work_package is moved to another project
    # reassign to the category with same name if any
    if work_package.category.present?
      category = work_package.project.categories.find_by(name: work_package.category.name)

      work_package.category = category
    end
  end

  def reassign_type
    available_types = work_package.project.types.order(:position)

    return if available_types.include?(work_package.type) && work_package.type

    work_package.type = available_types.first

    reassign_status assignable_statuses
  end

  def reassign_status(available_statuses)
    return if available_statuses.include?(work_package.status) || work_package.status.is_a?(Status::InexistentStatus)

    new_status = available_statuses.detect(&:is_default) || available_statuses.first || Status.default
    work_package.status = new_status if new_status.present?
  end

  def reassign_invalid_status_if_type_changed
    # Checks that the issue can not be moved to a type with the status unchanged
    # and the target type does not have this status
    if work_package.type_id_changed?
      reassign_status work_package.type.statuses(include_default: true)
    end
  end

  # Take over any default custom values
  # for new custom fields
  def initialize_unset_custom_values
    work_package.set_default_values! if custom_field_context_changed?
  end

  def new_start_date
    current_start_date = work_package.start_date || work_package.due_date

    return unless current_start_date && work_package.schedule_automatically?

    min_start = new_start_date_from_parent || new_start_date_from_self
    min_start = days.soonest_working_day(min_start)

    if min_start && (min_start > current_start_date || work_package.schedule_manually_changed?)
      min_start
    end
  end

  def new_start_date_from_parent
    return unless work_package.parent_id_changed? &&
                  work_package.parent

    work_package.parent.soonest_start
  end

  def new_start_date_from_self
    return unless work_package.schedule_manually_changed?

    [min_child_date, work_package.soonest_start].compact.max
  end

  def new_due_date(min_start)
    duration = children_duration || work_package.duration
    days.due_date(min_start, duration)
  end

  def work_package
    model
  end

  def assignable_statuses
    instantiate_contract(work_package, user).assignable_statuses(include_default: true)
  end

  def min_child_date
    children_dates.min
  end

  def children_duration
    max = max_child_date

    return unless max

    days.duration(min_child_date, max_child_date)
  end

  def days
    WorkPackages::Shared::Days.for(work_package)
  end

  def max_child_date
    children_dates.max
  end

  def children_dates
    @children_dates ||= work_package.children.pluck(:start_date, :due_date).flatten.compact
  end

  def parent_start_earlier_than_due?
    start = work_package.parent&.start_date
    due = work_package.due_date || work_package.parent&.due_date

    (start && !due) || ((due && start) && (start < due))
  end

  def parent_due_later_than_start?
    due = work_package.parent&.due_date
    start = work_package.start_date || work_package.parent&.start_date

    (due && !start) || ((due && start) && (due > start))
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe WorkPackages::SetAttributesService,
               type: :model do
  let(:today) { Time.zone.today }
  let(:user) { build_stubbed(:user) }
  let(:project) do
    p = build_stubbed(:project)
    allow(p).to receive(:shared_versions).and_return([])

    p
  end
  let(:work_package) do
    wp = build_stubbed(:work_package, project:)
    wp.type = initial_type
    wp.send(:clear_changes_information)

    wp
  end
  let(:new_work_package) do
    WorkPackage.new
  end
  let(:initial_type) { build_stubbed(:type) }
  let(:milestone_type) { build_stubbed(:type_milestone) }
  let(:statuses) { [] }
  let(:contract_class) { WorkPackages::UpdateContract }
  let(:mock_contract) do
    class_double(contract_class,
                 new: mock_contract_instance)
  end
  let(:mock_contract_instance) do
    instance_double(contract_class,
                    assignable_statuses: statuses,
                    errors: contract_errors,
                    validate: contract_valid)
  end
  let(:contract_valid) { true }
  let(:contract_errors) do
    instance_double(ActiveModel::Errors)
  end
  let(:instance) do
    described_class.new(user:,
                        model: work_package,
                        contract_class: mock_contract)
  end

  shared_examples_for 'service call' do
    subject do
      allow(work_package)
        .to receive(:save)

      instance.call(call_attributes)
    end

    it 'is successful' do
      expect(subject).to be_success
    end

    it 'sets the value' do
      next if !defined?(expected_attributes) || expected_attributes.blank?

      subject

      expected_attributes.each do |attribute, key|
        expect(work_package.send(attribute)).to eql key
      end
    end

    it 'does not persist the work_package' do
      subject

      expect(work_package)
        .not_to have_received(:save)
    end

    it 'has no errors' do
      expect(subject.errors).to be_empty
    end

    context 'when the contract does not validate' do
      let(:contract_valid) { false }

      it 'is unsuccessful' do
        expect(subject).not_to be_success
      end

      it 'does not persist the changes' do
        subject

        expect(work_package)
          .not_to have_received(:save)
      end

      it ""exposes the contract's errors"" do
        subject

        expect(subject.errors).to eql mock_contract_instance.errors
      end
    end
  end

  context 'when updating subject before calling the service' do
    let(:call_attributes) { {} }
    let(:expected_attributes) { { subject: 'blubs blubs' } }

    before do
      work_package.attributes = expected_attributes
    end

    it_behaves_like 'service call'
  end

  context 'when updating subject via attributes' do
    let(:call_attributes) { expected_attributes }
    let(:expected_attributes) { { subject: 'blubs blubs' } }

    it_behaves_like 'service call'
  end

  context 'for status' do
    let(:default_status) { build_stubbed(:default_status) }
    let(:other_status) { build_stubbed(:status) }
    let(:new_statuses) { [other_status, default_status] }

    before do
      allow(Status)
        .to receive(:default)
              .and_return(default_status)
    end

    context 'with no value set before for a new work package' do
      let(:call_attributes) { {} }
      let(:expected_attributes) { { status: default_status } }
      let(:work_package) { new_work_package }

      before do
        work_package.status = nil
      end

      it_behaves_like 'service call'
    end

    context 'with an invalid value that is not part of the type.statuses for a new work package' do
      let(:invalid_status) { create(:status) }
      let(:type) { create(:type) }
      let(:call_attributes) { { status: invalid_status, type: } }
      let(:expected_attributes) { { status: default_status, type: } }
      let(:work_package) { new_work_package }

      it_behaves_like 'service call'
    end

    context 'with valid value and without a type present for a new work package' do
      let(:status) { create(:status) }
      let(:call_attributes) { { status:, type: nil } }
      let(:expected_attributes) { { status: } }
      let(:work_package) { new_work_package }

      it_behaves_like 'service call'
    end

    context 'with a valid value that is part of the type.statuses for a new work package' do
      let(:type) { create(:type) }
      let(:status) { create(:status, workflow_for_type: type) }
      let(:call_attributes) { { status:, type: } }
      let(:expected_attributes) { { status:, type: } }
      let(:work_package) { new_work_package }

      it_behaves_like 'service call'
    end

    context 'with no value set on existing work package' do
      let(:call_attributes) { {} }
      let(:expected_attributes) { {} }

      before do
        work_package.status = nil
      end

      it_behaves_like 'service call' do
        it 'stays nil' do
          subject

          expect(work_package.status)
            .to be_nil
        end
      end
    end

    context 'when updating status before calling the service' do
      let(:call_attributes) { {} }
      let(:expected_attributes) { { status: other_status } }

      before do
        work_package.attributes = expected_attributes
      end

      it_behaves_like 'service call'
    end

    context 'when updating status via attributes' do
      let(:call_attributes) { expected_attributes }
      let(:expected_attributes) { { status: other_status } }

      it_behaves_like 'service call'
    end
  end

  context 'for author' do
    let(:other_user) { build_stubbed(:user) }

    context 'with no value set before for a new work package' do
      let(:call_attributes) { {} }
      let(:expected_attributes) { {} }
      let(:work_package) { new_work_package }

      it_behaves_like 'service call' do
        it ""sets the service's author"" do
          subject

          expect(work_package.author)
            .to eql user
        end

        it 'notes the author to be system changed' do
          subject

          expect(work_package.changed_by_system['author_id'])
            .to eql [nil, user.id]
        end
      end
    end

    context 'with no value set on existing work package' do
      let(:call_attributes) { {} }
      let(:expected_attributes) { {} }

      before do
        work_package.author = nil
      end

      it_behaves_like 'service call' do
        it 'stays nil' do
          subject

          expect(work_package.author)
            .to be_nil
        end
      end
    end

    context 'when updating author before calling the service' do
      let(:call_attributes) { {} }
      let(:expected_attributes) { { author: other_user } }

      before do
        work_package.attributes = expected_attributes
      end

      it_behaves_like 'service call'
    end

    context 'when updating author via attributes' do
      let(:call_attributes) { expected_attributes }
      let(:expected_attributes) { { author: other_user } }

      it_behaves_like 'service call'
    end
  end

  context 'with the actual contract' do
    let(:invalid_wp) do
      build(:work_package, subject: '').tap do |wp|
        wp.save!(validate: false)
      end
    end
    let(:user) { build_stubbed(:admin) }
    let(:instance) do
      described_class.new(user:,
                          model: invalid_wp,
                          contract_class:)
    end

    context 'with a currently invalid subject' do
      let(:call_attributes) { expected_attributes }
      let(:expected_attributes) { { subject: 'ABC' } }
      let(:contract_valid) { true }

      subject { instance.call(call_attributes) }

      it 'is successful' do
        expect(subject).to be_success
        expect(subject.errors).to be_empty
      end
    end
  end

  context 'for start_date & due_date & duration' do
    context 'with a parent' do
      let(:expected_attributes) { {} }
      let(:work_package) { new_work_package }
      let(:parent) do
        build_stubbed(:work_package,
                      start_date: parent_start_date,
                      due_date: parent_due_date)
      end
      let(:parent_start_date) { Time.zone.today - 5.days }
      let(:parent_due_date) { Time.zone.today + 10.days }

      context 'with the parent having dates and not providing own dates' do
        let(:call_attributes) { { parent: } }

        it_behaves_like 'service call' do
          it ""sets the start_date to the parent`s start_date"" do
            subject

            expect(work_package.start_date)
              .to eql parent_start_date
          end

          it ""sets the due_date to the parent`s due_date"" do
            subject

            expect(work_package.due_date)
              .to eql parent_due_date
          end
        end
      end

      context 'with the parent having dates and not providing own dates and with the parent`s' \
              'soonest_start being before the start_date (e.g. because the parent is manually scheduled)' do
        let(:call_attributes) { { parent: } }

        before do
          allow(parent)
            .to receive(:soonest_start)
                  .and_return(parent_start_date + 3.days)
        end

        it_behaves_like 'service call' do
          it ""sets the start_date to the parent`s start_date"" do
            subject

            expect(work_package.start_date)
              .to eql parent_start_date
          end

          it ""sets the due_date to the parent`s due_date"" do
            subject

            expect(work_package.due_date)
              .to eql parent_due_date
          end
        end
      end

      context 'with the parent having start date (no due) and not providing own dates' do
        let(:call_attributes) { { parent: } }
        let(:parent_due_date) { nil }

        it_behaves_like 'service call' do
          it ""sets the start_date to the parent`s start_date"" do
            subject

            expect(work_package.start_date)
              .to eql parent_start_date
          end

          it ""sets the due_date to nil"" do
            subject

            expect(work_package.due_date)
              .to be_nil
          end
        end
      end

      context 'with the parent having due date (no start) and not providing own dates' do
        let(:call_attributes) { { parent: } }
        let(:parent_start_date) { nil }

        it_behaves_like 'service call' do
          it ""sets the start_date to nil"" do
            subject

            expect(work_package.start_date)
              .to be_nil
          end

          it ""sets the due_date to the parent`s due_date"" do
            subject

            expect(work_package.due_date)
              .to eql parent_due_date
          end
        end
      end

      context 'with the parent having dates but providing own dates' do
        let(:call_attributes) { { parent:, start_date: Time.zone.today, due_date: Time.zone.today + 1.day } }

        it_behaves_like 'service call' do
          it ""sets the start_date to the provided date"" do
            subject

            expect(work_package.start_date)
              .to eql Time.zone.today
          end

          it ""sets the due_date to the provided date"" do
            subject

            expect(work_package.due_date)
              .to eql Time.zone.today + 1.day
          end
        end
      end

      context 'with the parent having dates but providing own start_date' do
        let(:call_attributes) { { parent:, start_date: Time.zone.today } }

        it_behaves_like 'service call' do
          it ""sets the start_date to the provided date"" do
            subject

            expect(work_package.start_date)
              .to eql Time.zone.today
          end

          it ""sets the due_date to the parent's due_date"" do
            subject

            expect(work_package.due_date)
              .to eql parent_due_date
          end
        end
      end

      context 'with the parent having dates but providing own due_date' do
        let(:call_attributes) { { parent:, due_date: Time.zone.today + 4.days } }

        it_behaves_like 'service call' do
          it ""sets the start_date to the parent's start date"" do
            subject

            expect(work_package.start_date)
              .to eql parent_start_date
          end

          it ""sets the due_date to the provided date"" do
            subject

            expect(work_package.due_date)
              .to eql Time.zone.today + 4.days
          end
        end
      end

      context 'with the parent having dates but providing own empty start_date' do
        let(:call_attributes) { { parent:, start_date: nil } }

        it_behaves_like 'service call' do
          it ""sets the start_date to nil"" do
            subject

            expect(work_package.start_date)
              .to be_nil
          end

          it ""sets the due_date to the parent's due_date"" do
            subject

            expect(work_package.due_date)
              .to eql parent_due_date
          end
        end
      end

      context 'with the parent having dates but providing own empty due_date' do
        let(:call_attributes) { { parent:, due_date: nil } }

        it_behaves_like 'service call' do
          it ""sets the start_date to the parent's start date"" do
            subject

            expect(work_package.start_date)
              .to eql parent_start_date
          end

          it ""sets the due_date to nil"" do
            subject

            expect(work_package.due_date)
              .to be_nil
          end
        end
      end

      context 'with the parent having dates but providing a start date that is before parent`s due date`' do
        let(:call_attributes) { { parent:, start_date: parent_due_date - 4.days } }

        it_behaves_like 'service call' do
          it ""sets the start_date to the provided date"" do
            subject

            expect(work_package.start_date)
              .to eql parent_due_date - 4.days
          end

          it ""sets the due_date to the parent's due_date"" do
            subject

            expect(work_package.due_date)
              .to eql parent_due_date
          end
        end
      end

      context 'with the parent having dates but providing a start date that is after the parent`s due date`' do
        let(:call_attributes) { { parent:, start_date: parent_due_date + 1.day } }

        it_behaves_like 'service call' do
          it ""sets the start_date to the provided date"" do
            subject

            expect(work_package.start_date)
              .to eql parent_due_date + 1.day
          end

          it ""leaves the due date empty"" do
            subject

            expect(work_package.due_date)
              .to be_nil
          end
        end
      end

      context 'with the parent having dates but providing a due date that is before the parent`s start date`' do
        let(:call_attributes) { { parent:, due_date: parent_start_date - 3.days } }

        it_behaves_like 'service call' do
          it ""leaves the start date empty"" do
            subject

            expect(work_package.start_date)
              .to be_nil
          end

          it ""set the due date to the provided date"" do
            subject

            expect(work_package.due_date)
              .to eql parent_start_date - 3.days
          end
        end
      end

      context 'with providing a parent_id that is invalid' do
        let(:call_attributes) { { parent_id: -1 } }
        let(:work_package) { build_stubbed(:work_package, start_date: Time.zone.today, due_date: Time.zone.today + 2.days) }

        it_behaves_like 'service call' do
          it ""sets the start_date to the parent`s start_date"" do
            subject

            expect(work_package.start_date)
              .to eql Time.zone.today
          end

          it ""sets the due_date to the parent`s due_date"" do
            subject

            expect(work_package.due_date)
              .to eql Time.zone.today + 2.days
          end
        end
      end
    end

    context 'with no value set for a new work package and with default setting active',
            with_settings: { work_package_startdate_is_adddate: true } do
      let(:call_attributes) { {} }
      let(:expected_attributes) { {} }
      let(:work_package) { new_work_package }

      it_behaves_like 'service call' do
        it ""sets the start date to today"" do
          subject

          expect(work_package.start_date)
            .to eql Time.zone.today
        end

        it ""sets the duration to nil"" do
          subject

          expect(work_package.duration)
            .to be_nil
        end

        context 'when the work package type is milestone' do
          before do
            work_package.type = milestone_type
          end

          it ""sets the duration to 1"" do
            subject

            expect(work_package.duration)
              .to eq 1
          end
        end
      end
    end

    context 'with a value set for a new work package and with default setting active',
            with_settings: { work_package_startdate_is_adddate: true } do
      let(:call_attributes) { { start_date: Time.zone.today + 1.day } }
      let(:expected_attributes) { {} }
      let(:work_package) { new_work_package }

      it_behaves_like 'service call' do
        it 'stays that value' do
          subject

          expect(work_package.start_date)
            .to eq(Time.zone.today + 1.day)
        end

        it ""sets the duration to nil"" do
          subject

          expect(work_package.duration)
            .to be_nil
        end

        context 'when the work package type is milestone' do
          before do
            work_package.type = milestone_type
          end

          it ""sets the duration to 1"" do
            subject

            expect(work_package.duration)
              .to eq 1
          end
        end
      end
    end

    context 'with date values set to the same date on a new work package' do
      let(:call_attributes) { { start_date: Time.zone.today, due_date: Time.zone.today } }
      let(:expected_attributes) { {} }
      let(:work_package) { new_work_package }

      it_behaves_like 'service call' do
        it 'sets the start date value' do
          subject

          expect(work_package.start_date)
            .to eq(Time.zone.today)
        end

        it 'sets the due date value' do
          subject

          expect(work_package.due_date)
            .to eq(Time.zone.today)
        end

        it ""sets the duration to 1"" do
          subject

          expect(work_package.duration)
            .to eq 1
        end
      end
    end

    context 'with date values set on a new work package' do
      let(:call_attributes) { { start_date: Time.zone.today, due_date: Time.zone.today + 5.days } }
      let(:expected_attributes) { {} }
      let(:work_package) { new_work_package }

      it_behaves_like 'service call' do
        it 'sets the start date value' do
          subject

          expect(work_package.start_date)
            .to eq(Time.zone.today)
        end

        it 'sets the due date value' do
          subject

          expect(work_package.due_date)
            .to eq(Time.zone.today + 5.days)
        end

        it ""sets the duration to 6"" do
          subject

          expect(work_package.duration)
            .to eq 6
        end
      end
    end

    context 'with start date changed' do
      let(:work_package) { build_stubbed(:work_package, start_date: Time.zone.today, due_date: Time.zone.today + 5.days) }
      let(:call_attributes) { { start_date: Time.zone.today + 1.day } }
      let(:expected_attributes) { {} }

      it_behaves_like 'service call' do
        it 'sets the start date value' do
          subject

          expect(work_package.start_date)
            .to eq(Time.zone.today + 1.day)
        end

        it 'keeps the due date value' do
          subject

          expect(work_package.due_date)
            .to eq(Time.zone.today + 5.days)
        end

        it ""updates the duration"" do
          subject

          expect(work_package.duration)
            .to eq 5
        end
      end
    end

    context 'with due date changed' do
      let(:work_package) { build_stubbed(:work_package, start_date: Time.zone.today, due_date: Time.zone.today + 5.days) }
      let(:call_attributes) { { due_date: Time.zone.today + 1.day } }
      let(:expected_attributes) { {} }

      it_behaves_like 'service call' do
        it 'keeps the start date value' do
          subject

          expect(work_package.start_date)
            .to eq(Time.zone.today)
        end

        it 'sets the due date value' do
          subject

          expect(work_package.due_date)
            .to eq(Time.zone.today + 1.day)
        end

        it ""updates the duration"" do
          subject

          expect(work_package.duration)
            .to eq 2
        end
      end
    end

    context 'with start date nilled' do
      let(:traits) { [] }
      let(:work_package) do
        build_stubbed(:work_package, *traits, start_date: Time.zone.today, due_date: Time.zone.today + 5.days)
      end
      let(:call_attributes) { { start_date: nil } }
      let(:expected_attributes) { {} }

      it_behaves_like 'service call' do
        it 'sets the start date to nil' do
          subject

          expect(work_package.start_date)
            .to be_nil
        end

        it 'keeps the due date value' do
          subject

          expect(work_package.due_date)
            .to eq(Time.zone.today + 5.days)
        end

        it ""sets the duration to nil"" do
          subject

          expect(work_package.duration)
            .to be_nil
        end

        context 'when the work package type is milestone' do
          let(:traits) { [:is_milestone] }

          it ""sets the duration to 1"" do
            subject

            expect(work_package.duration)
              .to eq 1
          end
        end
      end
    end

    context 'with due date nilled' do
      let(:traits) { [] }
      let(:work_package) do
        build_stubbed(:work_package, *traits, start_date: Time.zone.today, due_date: Time.zone.today + 5.days)
      end
      let(:call_attributes) { { due_date: nil } }
      let(:expected_attributes) { {} }

      it_behaves_like 'service call' do
        it 'keeps the start date' do
          subject

          expect(work_package.start_date)
            .to eq(Time.zone.today)
        end

        it 'nils the due date' do
          subject

          expect(work_package.due_date)
            .to be_nil
        end

        it ""sets the duration to nil"" do
          subject

          expect(work_package.duration)
            .to be_nil
        end

        context 'when the work package type is milestone' do
          let(:traits) { [:is_milestone] }

          it ""sets the duration to 1"" do
            subject

            expect(work_package.duration)
              .to eq 1
          end
        end
      end
    end

    context 'when deriving one value from the two others' do
      # rubocop:disable Layout/ExtraSpacing, Layout/SpaceInsideArrayPercentLiteral, Layout/SpaceInsidePercentLiteralDelimiters, Layout/LineLength
      all_possible_scenarios = [
        { initial: %i[start_date  due_date  duration], set: %i[], expected: {} },
        { initial: %i[start_date                    ], set: %i[], expected: {} },
        { initial: %i[            due_date          ], set: %i[], expected: {} },
        { initial: %i[                      duration], set: %i[], expected: {} },
        { initial: %i[                              ], set: %i[], expected: {} },

        { initial: %i[start_date  due_date  duration], set: %i[start_date], expected: { change: :duration } },
        { initial: %i[start_date                    ], set: %i[start_date], expected: {} },
        { initial: %i[            due_date          ], set: %i[start_date], expected: { change: :duration } },
        { initial: %i[                      duration], set: %i[start_date], expected: { change: :due_date } },
        { initial: %i[                              ], set: %i[start_date], expected: {} },

        { initial: %i[start_date  due_date  duration], nilled: %i[start_date], expected: { nilify: :duration } },
        { initial: %i[start_date                    ], nilled: %i[start_date], expected: {} },
        { initial: %i[            due_date          ], nilled: %i[start_date], expected: {} },
        { initial: %i[                      duration], nilled: %i[start_date], expected: {} },
        { initial: %i[                              ], nilled: %i[start_date], expected: {} },

        { initial: %i[start_date  due_date  duration], set: %i[due_date], expected: { change: :duration } },
        { initial: %i[start_date                    ], set: %i[due_date], expected: { change: :duration } },
        { initial: %i[            due_date          ], set: %i[due_date], expected: {} },
        { initial: %i[                      duration], set: %i[due_date], expected: { change: :start_date } },
        { initial: %i[                              ], set: %i[due_date], expected: {} },

        { initial: %i[start_date  due_date  duration], nilled: %i[due_date], expected: { nilify: :duration } },
        { initial: %i[start_date                    ], nilled: %i[due_date], expected: {} },
        { initial: %i[            due_date          ], nilled: %i[due_date], expected: {} },
        { initial: %i[                      duration], nilled: %i[due_date], expected: {} },
        { initial: %i[                              ], nilled: %i[due_date], expected: {} },

        { initial: %i[start_date  due_date  duration], set: %i[duration], expected: { change: :due_date } },
        { initial: %i[start_date                    ], set: %i[duration], expected: { change: :due_date } },
        { initial: %i[            due_date          ], set: %i[duration], expected: { change: :start_date } },
        { initial: %i[                      duration], set: %i[duration], expected: {} },
        { initial: %i[                              ], set: %i[duration], expected: {} },

        { initial: %i[start_date  due_date  duration], nilled: %i[duration], expected: { nilify: :due_date } },
        { initial: %i[start_date                    ], nilled: %i[duration], expected: {} },
        { initial: %i[            due_date          ], nilled: %i[duration], expected: {} },
        { initial: %i[                      duration], nilled: %i[duration], expected: {} },
        { initial: %i[                              ], nilled: %i[duration], expected: {} },

        { initial: %i[start_date  due_date  duration], set: %i[start_date due_date], expected: { change: :duration } },
        { initial: %i[start_date                    ], set: %i[start_date due_date], expected: { change: :duration } },
        { initial: %i[            due_date          ], set: %i[start_date due_date], expected: { change: :duration } },
        { initial: %i[                      duration], set: %i[start_date due_date], expected: { change: :duration } },
        { initial: %i[                              ], set: %i[start_date due_date], expected: { change: :duration } },

        { initial: %i[start_date  due_date  duration], set: %i[start_date], nilled: %i[due_date], expected: { nilify: :duration } },
        { initial: %i[start_date                    ], set: %i[start_date], nilled: %i[due_date], expected: {} },
        { initial: %i[            due_date          ], set: %i[start_date], nilled: %i[due_date], expected: {} },
        { initial: %i[                      duration], set: %i[start_date], nilled: %i[due_date], expected: { nilify: :duration, same: :due_date } },
        { initial: %i[                              ], set: %i[start_date], nilled: %i[due_date], expected: {} },

        { initial: %i[start_date  due_date  duration], set: %i[due_date], nilled: %i[start_date], expected: { nilify: :duration } },
        { initial: %i[start_date                    ], set: %i[due_date], nilled: %i[start_date], expected: {} },
        { initial: %i[            due_date          ], set: %i[due_date], nilled: %i[start_date], expected: {} },
        { initial: %i[                      duration], set: %i[due_date], nilled: %i[start_date], expected: { nilify: :duration, same: :start_date } },
        { initial: %i[                              ], set: %i[due_date], nilled: %i[start_date], expected: {} },

        { initial: %i[start_date  due_date  duration], nilled: %i[start_date due_date], expected: {} },
        { initial: %i[start_date                    ], nilled: %i[start_date due_date], expected: {} },
        { initial: %i[            due_date          ], nilled: %i[start_date due_date], expected: {} },
        { initial: %i[                      duration], nilled: %i[start_date due_date], expected: {} },
        { initial: %i[                              ], nilled: %i[start_date due_date], expected: {} },

        { initial: %i[start_date  due_date  duration], set: %i[start_date duration], expected: { change: :due_date } },
        { initial: %i[start_date                    ], set: %i[start_date duration], expected: { change: :due_date } },
        { initial: %i[            due_date          ], set: %i[start_date duration], expected: { change: :due_date } },
        { initial: %i[                      duration], set: %i[start_date duration], expected: { change: :due_date } },
        { initial: %i[                              ], set: %i[start_date duration], expected: { change: :due_date } },

        { initial: %i[start_date  due_date  duration], set: %i[start_date], nilled: %i[duration], expected: { nilify: :due_date } },
        { initial: %i[start_date                    ], set: %i[start_date], nilled: %i[duration], expected: {} },
        { initial: %i[            due_date          ], set: %i[start_date], nilled: %i[duration], expected: { nilify: :due_date, same: :duration } },
        { initial: %i[                      duration], set: %i[start_date], nilled: %i[duration], expected: {} },
        { initial: %i[                              ], set: %i[start_date], nilled: %i[duration], expected: {} },

        { initial: %i[start_date  due_date  duration], set: %i[duration], nilled: %i[start_date], expected: { nilify: :due_date } },
        { initial: %i[start_date                    ], set: %i[duration], nilled: %i[start_date], expected: {} },
        { initial: %i[            due_date          ], set: %i[duration], nilled: %i[start_date], expected: { nilify: :due_date, same: :start_date } },
        { initial: %i[                      duration], set: %i[duration], nilled: %i[start_date], expected: {} },
        { initial: %i[                              ], set: %i[duration], nilled: %i[start_date], expected: {} },

        { initial: %i[start_date  due_date  duration], nilled: %i[start_date duration], expected: {} },
        { initial: %i[start_date                    ], nilled: %i[start_date duration], expected: {} },
        { initial: %i[            due_date          ], nilled: %i[start_date duration], expected: {} },
        { initial: %i[                      duration], nilled: %i[start_date duration], expected: {} },
        { initial: %i[                              ], nilled: %i[start_date duration], expected: {} },

        { initial: %i[start_date  due_date  duration], set: %i[due_date duration], expected: { change: :start_date } },
        { initial: %i[start_date                    ], set: %i[due_date duration], expected: { change: :start_date } },
        { initial: %i[            due_date          ], set: %i[due_date duration], expected: { change: :start_date } },
        { initial: %i[                      duration], set: %i[due_date duration], expected: { change: :start_date } },
        { initial: %i[                              ], set: %i[due_date duration], expected: { change: :start_date } },

        { initial: %i[start_date  due_date  duration], set: %i[due_date], nilled: %i[duration], expected: { nilify: :start_date } },
        { initial: %i[start_date                    ], set: %i[due_date], nilled: %i[duration], expected: { nilify: :start_date, same: :duration } },
        { initial: %i[            due_date          ], set: %i[due_date], nilled: %i[duration], expected: {} },
        { initial: %i[                      duration], set: %i[due_date], nilled: %i[duration], expected: {} },
        { initial: %i[                              ], set: %i[due_date], nilled: %i[duration], expected: {} },

        { initial: %i[start_date  due_date  duration], set: %i[duration], nilled: %i[due_date], expected: { nilify: :start_date } },
        { initial: %i[start_date                    ], set: %i[duration], nilled: %i[due_date], expected: { nilify: :start_date, same: :due_date } },
        { initial: %i[            due_date          ], set: %i[duration], nilled: %i[due_date], expected: {} },
        { initial: %i[                      duration], set: %i[duration], nilled: %i[due_date], expected: {} },
        { initial: %i[                              ], set: %i[duration], nilled: %i[due_date], expected: {} },

        { initial: %i[start_date  due_date  duration], nilled: %i[due_date duration], expected: {} },
        { initial: %i[start_date                    ], nilled: %i[due_date duration], expected: {} },
        { initial: %i[            due_date          ], nilled: %i[due_date duration], expected: {} },
        { initial: %i[                      duration], nilled: %i[due_date duration], expected: {} },
        { initial: %i[                              ], nilled: %i[due_date duration], expected: {} },

        { initial: %i[start_date  due_date  duration], set: %i[start_date due_date duration], expected: {} },
        { initial: %i[start_date                    ], set: %i[start_date due_date duration], expected: {} },
        { initial: %i[            due_date          ], set: %i[start_date due_date duration], expected: {} },
        { initial: %i[                      duration], set: %i[start_date due_date duration], expected: {} },
        { initial: %i[                              ], set: %i[start_date due_date duration], expected: {} }
      ]
      # rubocop:enable Layout/ExtraSpacing, Layout/SpaceInsideArrayPercentLiteral, Layout/SpaceInsidePercentLiteralDelimiters, Layout/LineLength

      let(:initial_attributes) { { start_date: today, due_date: today + 49.days, duration: 50 } }
      let(:set_attributes) { { start_date: today + 10.days, due_date: today + 12.days, duration: 3 } }
      let(:nil_attributes) { { start_date: nil, due_date: nil, duration: nil } }

      all_possible_scenarios.each do |scenario|
        initial = scenario[:initial]
        set = scenario[:set] || []
        nilled = scenario[:nilled] || []
        expected = scenario[:expected]
        expected_change = expected[:change]
        expected_same = expected[:same]
        expected_nilify = expected[:nilify]
        unchanged = %i[start_date due_date duration] - set - nilled - expected.values + [expected_same].compact

        context_description = []
        context_description << ""with initial values for #{initial.inspect}"" if initial.any?
        context_description << ""without any initial values"" if initial.none?
        context_description << ""with #{set.inspect} set"" if set.any?
        context_description << ""with #{nilled.inspect} nilled"" if nilled.any?
        context_description << ""without any attributes set"" if set.none? && nilled.none?

        context context_description.join("", and "") do
          let(:work_package_attributes) { nil_attributes.merge(initial_attributes.slice(*initial)) }
          let(:work_package) { build_stubbed(:work_package, work_package_attributes) }
          let(:call_attributes) { nil_attributes.slice(*nilled).merge(set_attributes.slice(*set)) }

          it_behaves_like 'service call' do
            if expected_change
              it ""changes #{expected_change.inspect}"" do
                expect { subject }
                  .to change(work_package, expected_change)
              end
            end

            if expected_nilify
              it ""sets #{expected_nilify.inspect} to nil"" do
                expect { subject }
                  .to change(work_package, expected_nilify).to(nil)
              end
            end

            if unchanged.any?
              it ""does not change #{unchanged.map(&:inspect).join(' and ')}"" do
                expect { subject }
                  .not_to change { work_package.slice(*unchanged) }
              end
            end
          end
        end
      end
    end

    context 'with non-working days' do
      shared_let(:working_days) { week_with_saturday_and_sunday_as_weekend }
      let(:monday) { Time.zone.today.beginning_of_week }
      let(:tuesday) { monday + 1.day }
      let(:wednesday) { monday + 2.days }
      let(:friday) { monday + 4.days }
      let(:sunday) { monday + 6.days }
      let(:next_monday) { monday + 7.days }
      let(:next_tuesday) { monday + 8.days }

      context 'when start date changes' do
        let(:work_package) do
          build_stubbed(:work_package, start_date: monday, due_date: next_monday)
        end
        let(:call_attributes) { { start_date: wednesday } }

        it_behaves_like 'service call' do
          it ""updates the duration without including non-working days"" do
            expect { subject }
              .to change(work_package, :duration)
              .from(6)
              .to(4)
          end
        end
      end

      context 'when due date changes' do
        let(:work_package) do
          build_stubbed(:work_package, start_date: monday, due_date: next_monday)
        end
        let(:call_attributes) { { due_date: monday + 14.days } }

        it_behaves_like 'service call' do
          it ""updates the duration without including non-working days"" do
            expect { subject }
              .to change(work_package, :duration)
              .from(6)
              .to(11)
          end
        end
      end

      context 'when duration changes' do
        let(:work_package) do
          build_stubbed(:work_package, start_date: monday, due_date: next_monday)
        end
        let(:call_attributes) { { duration: ""13"" } }

        it_behaves_like 'service call' do
          it ""updates the due date from start date and duration and skips the non-working days"" do
            expect { subject }
              .to change(work_package, :due_date)
              .from(next_monday)
              .to(monday + 16.days)
          end
        end
      end

      context 'when duration and end_date both change' do
        let(:work_package) do
          build_stubbed(:work_package, start_date: monday, due_date: next_monday)
        end
        let(:call_attributes) { { due_date: next_tuesday, duration: 4 } }

        it_behaves_like 'service call' do
          it ""updates the start date and skips the non-working days"" do
            expect { subject }
              .to change(work_package, :start_date)
              .from(monday)
              .to(monday.next_occurring(:thursday))
          end
        end
      end

      context 'when ""ignore non-working days"" is switched to true' do
        let(:work_package) do
          build_stubbed(:work_package, start_date: monday, due_date: next_monday, ignore_non_working_days: false)
        end
        let(:call_attributes) { { ignore_non_working_days: true } }

        it_behaves_like 'service call' do
          it ""updates the due date from start date and duration to include the non-working days"" do
            # start_date and duration are checked too to ensure they did not change
            expect { subject }
              .to change { work_package.slice(:start_date, :due_date, :duration) }
              .from(start_date: monday, due_date: next_monday, duration: 6)
              .to(start_date: monday, due_date: next_monday - 2.days, duration: 6)
          end
        end
      end

      context 'when ""ignore non-working days"" is switched to false' do
        let(:work_package) do
          build_stubbed(:work_package, start_date: monday, due_date: next_monday, ignore_non_working_days: true)
        end
        let(:call_attributes) { { ignore_non_working_days: false } }

        it_behaves_like 'service call' do
          it ""updates the due date from start date and duration to skip the non-working days"" do
            # start_date and duration are checked too to ensure they did not change
            expect { subject }
              .to change { work_package.slice(:start_date, :due_date, :duration) }
              .from(start_date: monday, due_date: next_monday, duration: 8)
              .to(start_date: monday, due_date: next_monday + 2.days, duration: 8)
          end
        end
      end

      context 'when ""ignore non-working days"" is switched to false and ""start date"" is on a non-working day' do
        let(:work_package) do
          build_stubbed(:work_package, start_date: monday - 1.day, due_date: friday, ignore_non_working_days: true)
        end
        let(:call_attributes) { { ignore_non_working_days: false } }

        it_behaves_like 'service call' do
          it ""updates the start date to be on next working day, and due date to accommodate duration"" do
            expect { subject }
              .to change { work_package.slice(:start_date, :due_date, :duration) }
              .from(start_date: monday - 1.day, due_date: friday, duration: 6)
              .to(start_date: monday, due_date: next_monday, duration: 6)
          end
        end

        context 'with a new work package' do
          let(:work_package) do
            build(:work_package, start_date: monday - 1.day, due_date: friday, ignore_non_working_days: true)
          end
          let(:call_attributes) { { ignore_non_working_days: false, duration: 6 } }

          it_behaves_like 'service call' do
            it ""updates the start date to be on next working day, and due date to accommodate duration"" do
              expect { subject }
                .to change { work_package.slice(:start_date, :due_date, :duration) }
                .from(start_date: monday - 1.day, due_date: friday, duration: 6)
                .to(start_date: monday, due_date: next_monday, duration: 6)
            end
          end
        end
      end

      context 'when ""ignore non-working days"" is switched to false and ""finish date"" is on a non-working day' do
        let(:work_package) do
          build_stubbed(:work_package, start_date: nil, due_date: sunday, ignore_non_working_days: true)
        end
        let(:call_attributes) { { ignore_non_working_days: false } }

        it_behaves_like 'service call' do
          it ""updates the finish date to be on next working day"" do
            expect { subject }
              .to change { work_package.slice(:start_date, :due_date, :duration) }
              .from(start_date: nil, due_date: sunday, duration: nil)
              .to(start_date: nil, due_date: next_monday, duration: nil)
          end
        end
      end

      context 'when ""ignore non-working days"" is changed AND ""finish date"" is cleared' do
        let(:work_package) do
          build_stubbed(:work_package, start_date: monday, due_date: next_monday, ignore_non_working_days: true)
        end
        let(:call_attributes) { { ignore_non_working_days: false, due_date: nil } }

        it_behaves_like 'service call' do
          it ""does not recompute the due date and nilifies the due date and the duration instead"" do
            expect { subject }
              .to change { work_package.slice(:start_date, :due_date, :duration) }
              .from(start_date: monday, due_date: next_monday, duration: 8)
              .to(start_date: monday, due_date: nil, duration: nil)
          end
        end
      end

      context 'when ""ignore non-working days"" is changed AND ""finish date"" is set to another date' do
        let(:work_package) do
          build_stubbed(:work_package, start_date: monday, due_date: next_monday, ignore_non_working_days: true)
        end
        let(:call_attributes) { { due_date: wednesday, ignore_non_working_days: false } }

        it_behaves_like 'service call' do
          it ""updates the start date from due date and duration to skip the non-working days"" do
            expect { subject }
              .to change { work_package.slice(:start_date, :due_date, :duration) }
              .from(start_date: monday, due_date: next_monday, duration: 8)
              .to(start_date: wednesday - 9.days, due_date: wednesday, duration: 8)
          end
        end
      end

      context 'when ""ignore non-working days"" is changed AND ""start date"" and ""finish date"" are set to other dates' do
        let(:work_package) do
          build_stubbed(:work_package, start_date: monday, due_date: next_monday, ignore_non_working_days: true)
        end
        let(:call_attributes) { { start_date: friday, due_date: next_tuesday, ignore_non_working_days: false } }

        it_behaves_like 'service call' do
          it ""updates the duration from start date and due date"" do
            expect { subject }
              .to change { work_package.slice(:start_date, :due_date, :duration) }
              .from(start_date: monday, due_date: next_monday, duration: 8)
              .to(start_date: friday, due_date: next_tuesday, duration: 3)
          end
        end
      end
    end
  end

  context 'for priority' do
    let(:default_priority) { build_stubbed(:priority) }
    let(:other_priority) { build_stubbed(:priority) }

    before do
      scope = class_double(IssuePriority)

      allow(IssuePriority)
        .to receive(:active)
              .and_return(scope)
      allow(scope)
        .to receive(:default)
              .and_return(default_priority)
    end

    context 'with no value set before for a new work package' do
      let(:call_attributes) { {} }
      let(:expected_attributes) { {} }
      let(:work_package) { new_work_package }

      before do
        work_package.priority = nil
      end

      it_behaves_like 'service call' do
        it ""sets the default priority"" do
          subject

          expect(work_package.priority)
            .to eql default_priority
        end
      end
    end

    context 'when updating priority before calling the service' do
      let(:call_attributes) { {} }
      let(:expected_attributes) { { priority: other_priority } }

      before do
        work_package.attributes = expected_attributes
      end

      it_behaves_like 'service call'
    end

    context 'when updating priority via attributes' do
      let(:call_attributes) { expected_attributes }
      let(:expected_attributes) { { priority: other_priority } }

      it_behaves_like 'service call'
    end
  end

  context 'when switching the type' do
    let(:target_type) { build_stubbed(:type, is_milestone:) }
    let(:work_package) do
      build_stubbed(:work_package, start_date: Time.zone.today - 6.days, due_date: Time.zone.today)
    end

    context 'to a non-milestone type' do
      let(:is_milestone) { false }

      it 'keeps the start date' do
        instance.call(type: target_type)

        expect(work_package.start_date)
          .to eql Time.zone.today - 6.days
      end

      it 'keeps the due date' do
        instance.call(type: target_type)

        expect(work_package.due_date)
          .to eql Time.zone.today
      end

      it 'keeps duration' do
        instance.call(type: target_type)

        expect(work_package.duration).to be 7
      end
    end

    context 'to a milestone type' do
      let(:is_milestone) { true }

      context 'with both dates set' do
        it 'sets the start date to the due date' do
          instance.call(type: target_type)

          expect(work_package.start_date).to eq work_package.due_date
        end

        it 'keeps the due date' do
          instance.call(type: target_type)

          expect(work_package.due_date).to eql Time.zone.today
        end

        it 'sets the duration to 1 (to be changed to 0 later on)' do
          instance.call(type: target_type)

          expect(work_package.duration).to eq 1
        end
      end

      context 'with only the start date set' do
        let(:work_package) do
          build_stubbed(:work_package, start_date: Time.zone.today - 6.days)
        end

        it 'keeps the start date' do
          instance.call(type: target_type)

          expect(work_package.start_date).to eql Time.zone.today - 6.days
        end

        it 'set the due date to the start date' do
          instance.call(type: target_type)

          expect(work_package.due_date).to eql work_package.start_date
        end

        it 'keeps the duration at 1 (to be changed to 0 later on)' do
          instance.call(type: target_type)

          expect(work_package.duration).to eq 1
        end

        context 'with a new work package' do
          let(:work_package) do
            build(:work_package, start_date: Time.zone.today - 6.days)
          end
          let(:call_attributes) { { type: target_type, start_date: Time.zone.today - 6.days, due_date: nil, duration: nil } }

          before do
            instance.call(call_attributes)
          end

          it 'keeps the start date' do
            expect(work_package.start_date).to eq Time.zone.today - 6.days
          end

          it 'set the due date to the start date' do
            expect(work_package.due_date).to eq work_package.start_date
          end

          it 'keeps the duration at 1 (to be changed to 0 later on)' do
            expect(work_package.duration).to eq 1
          end
        end
      end
    end
  end

  context 'when switching the project' do
    let(:new_project) { build_stubbed(:project) }
    let(:version) { build_stubbed(:version) }
    let(:category) { build_stubbed(:category) }
    let(:new_category) { build_stubbed(:category, name: category.name) }
    let(:new_statuses) { [work_package.status] }
    let(:new_versions) { [] }
    let(:type) { work_package.type }
    let(:new_types) { [type] }
    let(:default_type) { build_stubbed(:type_standard) }
    let(:other_type) { build_stubbed(:type) }
    let(:yet_another_type) { build_stubbed(:type) }

    let(:call_attributes) { {} }
    let(:new_project_categories) do
      instance_double(ActiveRecord::Relation).tap do |categories_stub|
        allow(new_project)
          .to receive(:categories)
                .and_return(categories_stub)
      end
    end

    before do
      allow(new_project)
        .to receive(:shared_versions)
              .and_return(new_versions)
      allow(new_project_categories)
        .to receive(:find_by)
              .with(name: category.name)
              .and_return nil
      allow(new_project)
        .to receive(:types)
              .and_return(new_types)
      allow(new_types)
        .to receive(:order)
              .with(:position)
              .and_return(new_types)
    end

    shared_examples_for 'updating the project' do
      context 'for version' do
        before do
          work_package.version = version
        end

        context 'when not shared in new project' do
          it 'sets to nil' do
            subject

            expect(work_package.version)
              .to be_nil
          end
        end

        context 'when shared in the new project' do
          let(:new_versions) { [version] }

          it 'keeps the version' do
            subject

            expect(work_package.version)
              .to eql version
          end
        end
      end

      context 'for category' do
        before do
          work_package.category = category
        end

        context 'when no category of same name in new project' do
          it 'sets to nil' do
            subject

            expect(work_package.category)
              .to be_nil
          end
        end

        context 'when category of same name in new project' do
          before do
            allow(new_project_categories)
              .to receive(:find_by)
                    .with(name: category.name)
                    .and_return new_category
          end

          it 'uses the equally named category' do
            subject

            expect(work_package.category)
              .to eql new_category
          end

          it 'adds change to system changes' do
            subject

            expect(work_package.changed_by_system['category_id'])
              .to eql [nil, new_category.id]
          end
        end
      end

      context 'for type' do
        context 'when current type exists in new project' do
          it 'leaves the type' do
            subject

            expect(work_package.type)
              .to eql type
          end
        end

        context 'when a default type exists in new project' do
          let(:new_types) { [other_type, default_type] }

          it 'uses the first type (by position)' do
            subject

            expect(work_package.type)
              .to eql other_type
          end

          it 'adds change to system changes' do
            subject

            expect(work_package.changed_by_system['type_id'])
              .to eql [initial_type.id, other_type.id]
          end
        end

        context 'when no default type exists in new project' do
          let(:new_types) { [other_type, yet_another_type] }

          it 'uses the first type (by position)' do
            subject

            expect(work_package.type)
              .to eql other_type
          end

          it 'adds change to system changes' do
            subject

            expect(work_package.changed_by_system['type_id'])
              .to eql [initial_type.id, other_type.id]
          end
        end

        context 'when also setting a new type via attributes' do
          let(:expected_attributes) { { project: new_project, type: yet_another_type } }

          it 'sets the desired type' do
            subject

            expect(work_package.type)
              .to eql yet_another_type
          end

          it 'does not set the change to system changes' do
            subject

            expect(work_package.changed_by_system)
              .not_to include('type_id')
          end
        end
      end

      context 'for parent' do
        let(:parent_work_package) { build_stubbed(:work_package, project:) }
        let(:work_package) do
          build_stubbed(:work_package, project:, type: initial_type, parent: parent_work_package)
        end

        context 'with cross project relations allowed', with_settings: { cross_project_work_package_relations: true } do
          it 'keeps the parent' do
            expect(subject)
              .to be_success

            expect(work_package.parent)
              .to eql(parent_work_package)
          end
        end

        context 'with cross project relations disabled', with_settings: { cross_project_work_package_relations: false } do
          it 'deletes the parent' do
            expect(subject)
              .to be_success

            expect(work_package.parent)
              .to be_nil
          end
        end
      end
    end

    context 'when updating project before calling the service' do
      let(:call_attributes) { {} }
      let(:expected_attributes) { { project: new_project } }

      before do
        work_package.attributes = expected_attributes
      end

      it_behaves_like 'service call' do
        it_behaves_like 'updating the project'
      end
    end

    context 'when updating project via attributes' do
      let(:call_attributes) { expected_attributes }
      let(:expected_attributes) { { project: new_project } }

      it_behaves_like 'service call' do
        it_behaves_like 'updating the project'
      end
    end
  end

  context 'for custom fields' do
    subject { instance.call(call_attributes) }

    context 'for non existing fields' do
      let(:call_attributes) { { custom_field_891: '1' } } # rubocop:disable Naming/VariableNumber

      before do
        subject
      end

      it 'is successful' do
        expect(subject).to be_success
      end
    end
  end

  context 'when switching back to automatic scheduling' do
    let(:work_package) do
      wp = build_stubbed(:work_package,
                         project:,
                         ignore_non_working_days: true,
                         schedule_manually: true,
                         start_date: Time.zone.today,
                         due_date: Time.zone.today + 5.days)
      wp.type = build_stubbed(:type)
      wp.send(:clear_changes_information)

      allow(wp)
        .to receive(:soonest_start)
              .and_return(soonest_start)

      wp
    end
    let(:call_attributes) { { schedule_manually: false } }
    let(:expected_attributes) { {} }
    let(:soonest_start) { Time.zone.today + 1.day }

    context 'when the soonest start date is later than the current start date' do
      let(:soonest_start) { Time.zone.today + 3.days }

      it_behaves_like 'service call' do
        it 'sets the start date to the soonest possible start date' do
          subject

          expect(work_package.start_date).to eql(Time.zone.today + 3.days)
          expect(work_package.due_date).to eql(Time.zone.today + 8.days)
        end
      end
    end

    context 'when the soonest start date is a non-working day' do
      shared_let(:working_days) { week_with_saturday_and_sunday_as_weekend }
      let(:saturday) { Time.zone.today.beginning_of_week.next_occurring(:saturday) }
      let(:next_monday) { saturday.next_occurring(:monday) }
      let(:soonest_start) { saturday }

      before do
        work_package.ignore_non_working_days = false
      end

      it_behaves_like 'service call' do
        it 'sets the start date to the soonest possible start date being a working day' do
          subject

          expect(work_package).to have_attributes(
            start_date: next_monday,
            due_date: next_monday + 7.days
          )
        end
      end
    end

    context 'when the soonest start date is before the current start date' do
      let(:soonest_start) { Time.zone.today - 3.days }

      it_behaves_like 'service call' do
        it 'sets the start date to the soonest possible start date' do
          subject

          expect(work_package.start_date).to eql(soonest_start)
          expect(work_package.due_date).to eql(Time.zone.today + 2.days)
        end
      end
    end

    context 'when the soonest start date is nil' do
      let(:soonest_start) { nil }

      it_behaves_like 'service call' do
        it 'sets the start date to the soonest possible start date' do
          subject

          expect(work_package.start_date).to eql(Time.zone.today)
          expect(work_package.due_date).to eql(Time.zone.today + 5.days)
        end
      end
    end

    context 'when the work package also has a child' do
      let(:child) do
        build_stubbed(:work_package,
                      start_date: child_start_date,
                      due_date: child_due_date)
      end
      let(:child_start_date) { Time.zone.today + 2.days }
      let(:child_due_date) { Time.zone.today + 10.days }

      before do
        allow(work_package)
          .to receive(:children)
                .and_return([child])
      end

      context 'when the child`s start date is after soonest_start' do
        it_behaves_like 'service call' do
          it 'sets the dates to the child dates' do
            subject

            expect(work_package.start_date).to eql(Time.zone.today + 2.days)
            expect(work_package.due_date).to eql(Time.zone.today + 10.days)
          end
        end
      end

      context 'when the child`s start date is before soonest_start' do
        let(:soonest_start) { Time.zone.today + 3.days }

        it_behaves_like 'service call' do
          it 'sets the dates to soonest date and to the duration of the child' do
            subject

            expect(work_package.start_date).to eql(Time.zone.today + 3.days)
            expect(work_package.due_date).to eql(Time.zone.today + 11.days)
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class WorkPackages::SetScheduleService
  attr_accessor :user, :work_packages, :initiated_by

  def initialize(user:, work_package:, initiated_by: nil)
    self.user = user
    self.work_packages = Array(work_package)
    self.initiated_by = initiated_by
  end

  def call(changed_attributes = %i(start_date due_date))
    altered = []

    if %i(parent parent_id).intersect?(changed_attributes)
      altered += schedule_by_parent
    end

    if %i(start_date due_date parent parent_id).intersect?(changed_attributes)
      altered += schedule_following
    end

    result = ServiceResult.success(result: work_packages.first)

    altered.each do |wp|
      result.add_dependent!(ServiceResult.success(result: wp))
    end

    result
  end

  private

  # rubocop:disable Metrics/AbcSize
  def schedule_by_parent
    work_packages
      .select { |wp| wp.start_date.nil? && wp.parent }
      .each do |wp|
        days = WorkPackages::Shared::Days.for(wp)
        wp.start_date = days.soonest_working_day(wp.parent.soonest_start)
        if wp.due_date || wp.duration
          wp.due_date = [
            wp.start_date,
            days.due_date(wp.start_date, wp.duration),
            wp.due_date
          ].compact.max
          assign_cause_for_journaling(wp, :parent)
        end
      end
  end
  # rubocop:enable Metrics/AbcSize

  # Finds all work packages that need to be rescheduled because of a
  # rescheduling of the service's work package and reschedules them.
  #
  # The order of the rescheduling is important as successors' dates are
  # calculated based on their predecessors' dates and ancestors' dates based on
  # their children's dates.
  #
  # Thus, the work packages following (having a follows relation, direct or
  # transitively) the service's work package are first all loaded, and then
  # sorted by their need to be scheduled before one another:
  #
  # - predecessors are scheduled before their successors
  # - children/descendants are scheduled before their parents/ancestors
  #
  # Manually scheduled work packages are not encountered at this point as they
  # are filtered out when fetching the work packages eligible for rescheduling.
  def schedule_following
    altered = []

    WorkPackages::ScheduleDependency.new(work_packages).in_schedule_order do |scheduled, dependency|
      reschedule(scheduled, dependency)

      altered << scheduled if scheduled.changed?
    end

    altered
  end

  # Schedules work packages based on either
  #  - their descendants if they are parents
  #  - their predecessors (or predecessors of their ancestors) if they are
  #    leaves
  def reschedule(scheduled, dependency)
    if dependency.has_descendants?
      reschedule_by_descendants(scheduled, dependency)
    else
      reschedule_by_predecessors(scheduled, dependency)
    end
  end

  # Inherits the start/due_date from the descendants of this work package.
  #
  # Only parent work packages are scheduled like this. start_date receives the
  # minimum of the dates (start_date and due_date) of the descendants due_date
  # receives the maximum of the dates (start_date and due_date) of the
  # descendants
  def reschedule_by_descendants(scheduled, dependency)
    set_dates(scheduled, dependency.start_date, dependency.due_date)
    assign_cause_for_journaling(scheduled, :children)
  end

  # Calculates the dates of a work package based on its follows relations.
  #
  # The start date of a work package is constrained by its direct and indirect
  # predecessors, as it must start strictly after all predecessors finish.
  #
  # The follows relations of ancestors are considered to be equal to own follows
  # relations as they inhibit moving a work package just the same. Only leaf
  # work packages are calculated like this.
  #
  # work package is moved to a later date:
  #   - following work packages are moved forward only to ensure they start
  #     after their predecessor's finish date. They may not need to move at all
  #     when there a time buffer between a follower and its predecessors
  #     (predecessors can also be acquired transitively by ancestors)
  #
  # work package moved to an earlier date:
  #   - following work packages do not move at all.
  def reschedule_by_predecessors(scheduled, dependency)
    return unless dependency.soonest_start_date

    new_start_date = [scheduled.start_date, dependency.soonest_start_date].compact.max
    new_due_date = determine_due_date(scheduled, new_start_date)
    set_dates(scheduled, new_start_date, new_due_date)
    assign_cause_for_journaling(scheduled, :predecessor)
  end

  def determine_due_date(work_package, start_date)
    # due date is set only if the moving work package already has one or has a
    # duration. If not, due date is nil (and duration will be nil too).
    return unless work_package.due_date || work_package.duration

    due_date =
      if work_package.duration
        days(work_package).due_date(start_date, work_package.duration)
      else
        work_package.due_date
      end

    # if due date is before start date, then start is used as due date.
    [start_date, due_date].max
  end

  def set_dates(work_package, start_date, due_date)
    work_package.start_date = start_date
    work_package.due_date = due_date
    work_package.duration = days(work_package).duration(start_date, due_date)
  end

  def days(work_package)
    WorkPackages::Shared::Days.for(work_package)
  end

  def assign_cause_for_journaling(work_package, relation)
    return {} if initiated_by.nil?
    return {} unless work_package.changes.keys.intersect?(%w(start_date due_date duration))

    if initiated_by.is_a?(WorkPackage)
      assign_cause_initiated_by_work_package(work_package, relation)
    elsif initiated_by.is_a?(Journal::WorkingDayUpdate)
      assign_cause_initiated_by_changed_working_days(work_package)
    end
  end

  def assign_cause_initiated_by_work_package(work_package, _relation)
    # For now we only track a generic cause, and not a specialized reason depending on the relation
    #
    # type_mapping = {
    #   parent: 'work_package_parent_changed_times',
    #   children: 'work_package_children_changed_times',
    #   predecessor: 'work_package_predecessor_changed_times',
    #   related: 'work_package_related_changed_times'
    # }
    # work_package.journal_cause = { ""type"" => type_mapping[relation], ""work_package_id"" => initiated_by.id }

    work_package.journal_cause = {
      ""type"" => ""work_package_related_changed_times"",
      ""work_package_id"" => initiated_by.id
    }
  end

  def assign_cause_initiated_by_changed_working_days(work_package)
    work_package.journal_cause = {
      ""type"" => 'working_days_changed',
      ""changed_days"" => initiated_by.to_h
    }
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe WorkPackages::SetScheduleService do
  create_shared_association_defaults_for_work_package_factory

  let(:work_package) do
    create(:work_package,
           subject: 'subject',
           start_date: work_package_start_date,
           due_date: work_package_due_date)
  end
  let(:work_package_due_date) { Time.zone.today }
  let(:work_package_start_date) { nil }
  let(:initiating_work_package) { work_package }
  let(:instance) do
    described_class.new(user:, work_package:, initiated_by: initiating_work_package)
  end
  let!(:following) { [] }

  let(:follower1_start_date) { Time.zone.today + 1.day }
  let(:follower1_due_date) { Time.zone.today + 3.days }
  let(:follower1_delay) { 0 }
  let(:following_work_package1) do
    create_follower(follower1_start_date,
                    follower1_due_date,
                    { work_package => follower1_delay })
  end
  let(:follower2_start_date) { Time.zone.today + 4.days }
  let(:follower2_due_date) { Time.zone.today + 8.days }
  let(:follower2_delay) { 0 }
  let(:following_work_package2) do
    create_follower(follower2_start_date,
                    follower2_due_date,
                    { following_work_package1 => follower2_delay })
  end
  let(:follower3_start_date) { Time.zone.today + 9.days }
  let(:follower3_due_date) { Time.zone.today + 10.days }
  let(:follower3_delay) { 0 }
  let(:following_work_package3) do
    create_follower(follower3_start_date,
                    follower3_due_date,
                    { following_work_package2 => follower3_delay })
  end

  let(:parent_follower1_start_date) { follower1_start_date }
  let(:parent_follower1_due_date) { follower1_due_date }

  let(:parent_following_work_package1) do
    create_parent(following_work_package1)
  end

  let(:follower_sibling_work_package) do
    create_follower(follower1_due_date + 2.days,
                    follower1_due_date + 4.days,
                    {},
                    parent: parent_following_work_package1)
  end

  let(:attributes) { [:start_date] }

  def create_follower(start_date, due_date, predecessors, parent: nil)
    work_package = create(:work_package,
                          subject: ""follower of #{predecessors.keys.map(&:subject).to_sentence}"",
                          start_date:,
                          due_date:,
                          parent:)

    predecessors.map do |predecessor, delay|
      create(:follows_relation,
             delay:,
             from: work_package,
             to: predecessor)
    end

    work_package
  end

  def create_parent(child, start_date: child.start_date, due_date: child.due_date)
    create(:work_package,
           subject: ""parent of #{child.subject}"",
           start_date:,
           due_date:).tap do |parent|
             child.parent = parent
             child.save
           end
  end

  def create_child(parent, start_date, due_date)
    create(:work_package,
           subject: ""child of #{parent.subject}"",
           start_date:,
           due_date:,
           parent:)
  end

  subject { instance.call(attributes) }

  shared_examples_for 'reschedules' do
    before do
      subject
    end

    it 'is success' do
      expect(subject)
        .to be_success
    end

    it 'updates the following work packages' do
      expected.each do |wp, (start_date, due_date)|
        expected_cause_type = ""work_package_related_changed_times""
        result = subject.all_results.find { |result_wp| result_wp.id == wp.id }
        expect(result)
          .to be_present,
              ""Expected work package ##{wp.id} '#{wp.subject}' to be rescheduled""

        expect(result.journal_cause['work_package_id'])
          .to eql(initiating_work_package.id),
              ""Expected work package change to ##{wp.id} to have been caused by ##{initiating_work_package.id}.""

        expect(result.journal_cause['type'])
        .to eql(""work_package_related_changed_times""),
            ""Expected work package change to ##{wp.id} to have been caused because ##{expected_cause_type}.""

        expect(result.start_date)
          .to eql(start_date),
              ""Expected work package ##{wp.id} '#{wp.subject}' "" \
              ""to have start date #{start_date.inspect}, got #{result.start_date.inspect}""
        expect(result.due_date)
          .to eql(due_date),
              ""Expected work package ##{wp.id} '#{wp.subject}' "" \
              ""to have due date #{due_date.inspect}, got #{result.due_date.inspect}""

        duration = WorkPackages::Shared::AllDays.new.duration(start_date, due_date)

        expect(result.duration)
          .to eql(duration),
              ""Expected work package ##{wp.id} '#{wp.subject}' "" \
              ""to have duration #{duration.inspect}, got #{result.duration.inspect}""
      end
    end

    it 'returns only the original and the changed work packages' do
      expect(subject.all_results)
        .to match_array expected.keys + [work_package]
    end
  end

  shared_examples_for 'does not reschedule' do
    before do
      subject
    end

    it 'is success' do
      expect(subject)
        .to be_success
    end

    it 'does not change any other work packages' do
      expect(subject.all_results)
        .to contain_exactly(work_package)
    end

    it 'does not assign a journal cause' do
      subject.all_results.each do |work_package|
        expect(work_package.journal_cause).to be_blank
      end
    end
  end

  context 'without relation' do
    it 'is success' do
      expect(subject)
        .to be_success
    end
  end

  context 'with a single successor' do
    let!(:following) do
      [following_work_package1]
    end

    context 'when moving forward' do
      before do
        work_package.due_date = Time.zone.today + 5.days
      end

      it_behaves_like 'reschedules' do
        let(:expected) do
          { following_work_package1 => [Time.zone.today + 6.days, Time.zone.today + 8.days] }
        end
      end
    end

    context 'when moving forward with the follower having no due date' do
      let(:follower1_due_date) { nil }

      before do
        work_package.due_date = Time.zone.today + 5.days
      end

      it_behaves_like 'reschedules' do
        let(:expected) do
          { following_work_package1 => [Time.zone.today + 6.days, nil] }
        end
      end
    end

    context 'when moving forward with the follower having no start date' do
      let(:follower1_start_date) { nil }

      before do
        work_package.due_date = Time.zone.today + 5.days
      end

      it_behaves_like 'reschedules' do
        let(:expected) do
          { following_work_package1 => [Time.zone.today + 6.days, Time.zone.today + 6.days] }
        end
      end
    end

    context 'when moving forward with the follower having some space left' do
      let(:follower1_start_date) { Time.zone.today + 3.days }
      let(:follower1_due_date) { Time.zone.today + 5.days }

      before do
        work_package.due_date = Time.zone.today + 5.days
      end

      it_behaves_like 'reschedules' do
        let(:expected) do
          { following_work_package1 => [Time.zone.today + 6.days, Time.zone.today + 8.days] }
        end
      end
    end

    context 'when moving forward with the follower having enough space left to not be moved at all' do
      let(:follower1_start_date) { Time.zone.today + 10.days }
      let(:follower1_due_date) { Time.zone.today + 12.days }

      before do
        work_package.due_date = Time.zone.today + 5.days
      end

      it_behaves_like 'does not reschedule'
    end

    context 'when moving forward with the follower having some space left and a delay' do
      let(:follower1_start_date) { Time.zone.today + 5.days }
      let(:follower1_due_date) { Time.zone.today + 7.days }
      let(:follower1_delay) { 3 }

      before do
        work_package.due_date = Time.zone.today + 5.days
      end

      it_behaves_like 'reschedules' do
        let(:expected) do
          { following_work_package1 => [Time.zone.today + 9.days, Time.zone.today + 11.days] }
        end
      end
    end

    context 'when moving forward with the follower not needing to be moved' do
      let(:follower1_start_date) { Time.zone.today + 6.days }
      let(:follower1_due_date) { Time.zone.today + 8.days }

      before do
        work_package.due_date = Time.zone.today + 5.days
      end

      it_behaves_like 'does not reschedule'
    end

    context 'when moving backwards' do
      before do
        work_package.due_date = Time.zone.today - 5.days
      end

      it_behaves_like 'does not reschedule'
    end

    context 'when moving backwards with space between' do
      let(:follower1_start_date) { Time.zone.today + 3.days }
      let(:follower1_due_date) { Time.zone.today + 5.days }

      before do
        work_package.due_date = Time.zone.today - 5.days
      end

      it_behaves_like 'does not reschedule'
    end

    context 'when moving backwards with the follower having no start date (which should not happen) \
             and the due date after the scheduled to date' do
      let(:follower1_start_date) { nil }

      before do
        work_package.due_date = Time.zone.today - 5.days
      end

      it_behaves_like 'reschedules' do
        let(:expected) do
          { following_work_package1 => [Time.zone.today - 4.days, follower1_due_date] }
        end
      end
    end

    context 'when moving forward with the follower having no start date (which should not happen) \
             and the due date before the scheduled to date' do
      let(:follower1_start_date) { nil }

      before do
        work_package.due_date = follower1_due_date + 5.days
      end

      it_behaves_like 'reschedules' do
        let(:expected) do
          { following_work_package1 => [follower1_due_date + 6.days, follower1_due_date + 6.days] }
        end
      end
    end

    context 'when removing the dates on the predecessor' do
      before do
        work_package.start_date = work_package.due_date = nil
      end

      # The follower will keep its dates
      it_behaves_like 'does not reschedule'

      context 'when the follower has no start date but a due date' do
        let(:follower1_start_date) { nil }
        let(:follower1_due_date) { Time.zone.today + 15.days }

        it_behaves_like 'does not reschedule'
      end
    end

    context 'when not moving and the successor not having start & due date (e.g. creating relation)' do
      let(:follower1_start_date) { nil }
      let(:follower1_due_date) { nil }

      it_behaves_like 'reschedules' do
        let(:expected) do
          { following_work_package1 => [work_package.due_date + 1.day, nil] }
        end
      end
    end

    context 'when not moving and the successor having due before predecessor due date (e.g. creating relation)' do
      let(:follower1_start_date) { nil }
      let(:follower1_due_date) { work_package_due_date - 5.days }

      it_behaves_like 'reschedules' do
        let(:expected) do
          { following_work_package1 => [work_package.due_date + 1.day, work_package.due_date + 1.day] }
        end
      end
    end

    context 'when not moving and the successor having start before predecessor due date (e.g. creating relation)' do
      let(:follower1_start_date) { work_package_due_date - 5.days }
      let(:follower1_due_date) { nil }

      it_behaves_like 'reschedules' do
        let(:expected) do
          { following_work_package1 => [work_package.due_date + 1.day, nil] }
        end
      end
    end

    context 'when not moving and the successor having start and due before predecessor due date (e.g. creating relation)' do
      let(:follower1_start_date) { work_package_due_date - 5.days }
      let(:follower1_due_date) { work_package_due_date - 2.days }

      it_behaves_like 'reschedules' do
        let(:expected) do
          { following_work_package1 => [work_package.due_date + 1.day, work_package.due_date + 4.days] }
        end
      end
    end

    context 'when not having dates and the successor not having start & due date (e.g. creating relation)' do
      let(:work_package_due_date) { nil }
      let(:follower1_start_date) { nil }
      let(:follower1_due_date) { nil }

      it_behaves_like 'does not reschedule'
    end

    context 'with the successor having another predecessor which has no dates' do
      let(:following_work_package1) do
        create_follower(follower1_start_date,
                        follower1_due_date,
                        { work_package => follower1_delay,
                          another_successor => 0 })
      end
      let(:another_successor) do
        create(:work_package,
               start_date: nil,
               due_date: nil)
      end

      context 'when moving forward' do
        before do
          work_package.due_date = Time.zone.today + 5.days
        end

        it_behaves_like 'reschedules' do
          let(:expected) do
            { following_work_package1 => [Time.zone.today + 6.days, Time.zone.today + 8.days] }
          end
        end
      end

      context 'when moving backwards' do
        before do
          work_package.due_date = Time.zone.today - 5.days
        end

        it_behaves_like 'does not reschedule'
      end
    end
  end

  context 'with only a parent' do
    let!(:parent_work_package) do
      create(:work_package).tap do |parent|
        work_package.parent = parent
        work_package.save
      end
    end
    let(:work_package_start_date) { Time.zone.today - 5.days }

    it_behaves_like 'reschedules' do
      let(:expected) do
        { parent_work_package => [work_package_start_date, work_package_due_date] }
      end
    end
  end

  context 'with a parent having a follower' do
    let(:work_package_start_date) { Time.zone.today }
    let(:work_package_due_date) { Time.zone.today + 5.days }
    let!(:parent_work_package) do
      create(:work_package,
             subject: ""parent of #{work_package.subject}"",
             start_date: Time.zone.today,
             due_date: Time.zone.today + 1.day).tap do |parent|
        work_package.parent = parent
        work_package.save
      end
    end
    let!(:follower_of_parent_work_package) do
      create_follower(Time.zone.today + 4.days,
                      Time.zone.today + 6.days,
                      { parent_work_package => 0 })
    end

    it_behaves_like 'reschedules' do
      let(:expected) do
        { parent_work_package => [work_package_start_date, work_package_due_date],
          follower_of_parent_work_package => [work_package_due_date + 1.day, work_package_due_date + 3.days] }
      end
    end

    # There is a bug in the scheduling that happens if the dependencies
    # array order is: [sibling child, follower of parent, parent]
    #
    # In this case, as the follower of parent only knows about direct
    # dependencies (and not about the transitive dependencies of children of
    # predecessor), it will be made the first in the order, based on the
    # current algorithm. And as the parent depends on its child, it will
    # come after it.
    #
    # Based on the algorithm when this test was written, the resulting
    # scheduling order will be [follower of parent, sibling child, parent],
    # which is wrong: if follower of parent is rescheduled first, then it
    # will not change because its predecessor, the parent, has not been
    # scheduled yet.
    #
    # The expected and right order is [sibling child, parent, follower of
    # parent].
    #
    # That's why the WorkPackage.for_scheduling call is mocked to customize
    # the order of the returned work_packages to reproduce this bug.
    context 'with also a sibling follower with same parent' do
      let!(:sibling_follower_of_work_package) do
        create_follower(Time.zone.today + 2.days,
                        Time.zone.today + 3.days,
                        { work_package => 0 },
                        parent: parent_work_package)
      end

      before do
        allow(WorkPackage)
          .to receive(:for_scheduling)
          .and_wrap_original do |method, *args|
            wanted_order = [sibling_follower_of_work_package, follower_of_parent_work_package, parent_work_package]
            method.call(*args).in_order_of(:id, wanted_order.map(&:id))
          end
      end

      it_behaves_like 'reschedules' do
        let(:expected) do
          { sibling_follower_of_work_package => [work_package_due_date + 1.day, work_package_due_date + 2.days],
            parent_work_package => [work_package_start_date, work_package_due_date + 2.days],
            follower_of_parent_work_package => [work_package_due_date + 3.days, work_package_due_date + 5.days] }
        end
      end
    end
  end

  context 'with a single successor having a parent' do
    let!(:following) do
      [following_work_package1,
       parent_following_work_package1]
    end

    context 'when moving forward' do
      before do
        work_package.due_date = Time.zone.today + 5.days
      end

      it_behaves_like 'reschedules' do
        let(:expected) do
          { following_work_package1 => [Time.zone.today + 6.days, Time.zone.today + 8.days],
            parent_following_work_package1 => [Time.zone.today + 6.days, Time.zone.today + 8.days] }
        end
      end
    end

    context 'when moving forward with the parent having another child not being moved' do
      let(:parent_follower1_start_date) { follower1_start_date }
      let(:parent_follower1_due_date) { follower1_due_date + 4.days }

      let!(:following) do
        [following_work_package1,
         parent_following_work_package1,
         follower_sibling_work_package]
      end

      before do
        work_package.due_date = Time.zone.today + 5.days
      end

      it_behaves_like 'reschedules' do
        let(:expected) do
          { following_work_package1 => [Time.zone.today + 6.days, Time.zone.today + 8.days],
            parent_following_work_package1 => [Time.zone.today + 5.days, Time.zone.today + 8.days] }
        end
      end
    end

    context 'when moving backwards' do
      before do
        work_package.due_date = Time.zone.today - 5.days
      end

      it_behaves_like 'does not reschedule'
    end
  end

  context 'with a single successor having a child' do
    let(:child_start_date) { follower1_start_date }
    let(:child_due_date) { follower1_due_date }

    let(:child_work_package) { create_child(following_work_package1, child_start_date, child_due_date) }

    let!(:following) do
      [following_work_package1,
       child_work_package]
    end

    context 'when moving forward' do
      before do
        work_package.due_date = Time.zone.today + 5.days
      end

      it_behaves_like 'reschedules' do
        let(:expected) do
          { following_work_package1 => [Time.zone.today + 6.days, Time.zone.today + 8.days],
            child_work_package => [Time.zone.today + 6.days, Time.zone.today + 8.days] }
        end
      end
    end
  end

  context 'with a single successor having two children' do
    let(:follower1_start_date) { work_package_due_date + 1.day }
    let(:follower1_due_date) { work_package_due_date + 10.days }
    let(:child1_start_date) { follower1_start_date }
    let(:child1_due_date) { follower1_start_date + 3.days }
    let(:child2_start_date) { follower1_start_date + 8.days }
    let(:child2_due_date) { follower1_due_date }

    let(:child1_work_package) { create_child(following_work_package1, child1_start_date, child1_due_date) }
    let(:child2_work_package) { create_child(following_work_package1, child2_start_date, child2_due_date) }

    let!(:following) do
      [following_work_package1,
       child1_work_package,
       child2_work_package]
    end

    context 'with unchanged dates (e.g. when creating a follows relation) and successor starting 1 day after scheduled' do
      it_behaves_like 'does not reschedule'
    end

    context 'with unchanged dates (e.g. when creating a follows relation) and successor starting 3 days after scheduled' do
      let(:follower1_start_date) { work_package_due_date + 3.days }
      let(:follower1_due_date) { follower1_start_date + 10.days }
      let(:child1_start_date) { follower1_start_date }
      let(:child1_due_date) { follower1_start_date + 6.days }
      let(:child2_start_date) { follower1_start_date + 8.days }
      let(:child2_due_date) { follower1_due_date }

      it_behaves_like 'does not reschedule'
    end

    context 'with unchanged dates (e.g. when creating a follows relation) and successor\'s first child needs to be rescheduled' do
      let(:follower1_start_date) { work_package_due_date - 3.days }
      let(:follower1_due_date) { work_package_due_date + 10.days }
      let(:child1_start_date) { follower1_start_date }
      let(:child1_due_date) { follower1_start_date + 6.days }
      let(:child2_start_date) { follower1_start_date + 8.days }
      let(:child2_due_date) { follower1_due_date }

      # following parent is reduced in length as the children allow to be executed at the same time
      it_behaves_like 'reschedules' do
        let(:expected) do
          { following_work_package1 => [work_package_due_date + 1.day, follower1_due_date],
            child1_work_package => [work_package_due_date + 1.day, follower1_start_date + 10.days] }
        end
      end
    end

    context 'with unchanged dates (e.g. when creating a follows relation) and successor\s children need to be rescheduled' do
      let(:follower1_start_date) { work_package_due_date - 8.days }
      let(:follower1_due_date) { work_package_due_date + 10.days }
      let(:child1_start_date) { follower1_start_date }
      let(:child1_due_date) { follower1_start_date + 4.days }
      let(:child2_start_date) { follower1_start_date + 6.days }
      let(:child2_due_date) { follower1_due_date }

      # following parent is reduced in length and children are rescheduled
      it_behaves_like 'reschedules' do
        let(:expected) do
          { following_work_package1 => [work_package_due_date + 1.day, follower1_start_date + 21.days],
            child1_work_package => [work_package_due_date + 1.day, child1_due_date + 9.days],
            child2_work_package => [work_package_due_date + 1.day, follower1_start_date + 21.days] }
        end
      end
    end
  end

  context 'with a chain of successors' do
    let(:follower1_start_date) { Time.zone.today + 1.day }
    let(:follower1_due_date) { Time.zone.today + 3.days }
    let(:follower2_start_date) { Time.zone.today + 4.days }
    let(:follower2_due_date) { Time.zone.today + 8.days }
    let(:follower3_start_date) { Time.zone.today + 9.days }
    let(:follower3_due_date) { Time.zone.today + 10.days }

    let!(:following) do
      [following_work_package1,
       following_work_package2,
       following_work_package3]
    end

    context 'when moving forward' do
      before do
        work_package.due_date = Time.zone.today + 5.days
      end

      it_behaves_like 'reschedules' do
        let(:expected) do
          { following_work_package1 => [Time.zone.today + 6.days, Time.zone.today + 8.days],
            following_work_package2 => [Time.zone.today + 9.days, Time.zone.today + 13.days],
            following_work_package3 => [Time.zone.today + 14.days, Time.zone.today + 15.days] }
        end
      end
    end

    context 'when moving forward with some space between the followers' do
      let(:follower1_start_date) { Time.zone.today + 1.day }
      let(:follower1_due_date) { Time.zone.today + 3.days }
      let(:follower2_start_date) { Time.zone.today + 7.days }
      let(:follower2_due_date) { Time.zone.today + 10.days }
      let(:follower3_start_date) { Time.zone.today + 17.days }
      let(:follower3_due_date) { Time.zone.today + 18.days }

      before do
        work_package.due_date = Time.zone.today + 5.days
      end

      it_behaves_like 'reschedules' do
        let(:expected) do
          { following_work_package1 => [Time.zone.today + 6.days, Time.zone.today + 8.days],
            following_work_package2 => [Time.zone.today + 9.days, Time.zone.today + 12.days] }
        end
      end
    end

    context 'when moving backwards' do
      before do
        work_package.due_date = Time.zone.today - 5.days
      end

      it_behaves_like 'does not reschedule'
    end
  end

  context 'with a chain of successors with two paths leading to the same work package in the end' do
    let(:follower3_start_date) { Time.zone.today + 4.days }
    let(:follower3_due_date) { Time.zone.today + 7.days }
    let(:follower3_delay) { 0 }
    let(:following_work_package3) do
      create_follower(follower3_start_date,
                      follower3_due_date,
                      { work_package => follower3_delay })
    end
    let(:follower4_start_date) { Time.zone.today + 9.days }
    let(:follower4_due_date) { Time.zone.today + 10.days }
    let(:follower4_delay2) { 0 }
    let(:follower4_delay3) { 0 }
    let(:following_work_package4) do
      create_follower(follower4_start_date,
                      follower4_due_date,
                      { following_work_package2 => follower4_delay2, following_work_package3 => follower4_delay3 })
    end
    let!(:following) do
      [following_work_package1,
       following_work_package2,
       following_work_package3,
       following_work_package4]
    end

    context 'when moving forward' do
      before do
        work_package.due_date = Time.zone.today + 5.days
      end

      it_behaves_like 'reschedules' do
        let(:expected) do
          { following_work_package1 => [Time.zone.today + 6.days, Time.zone.today + 8.days],
            following_work_package2 => [Time.zone.today + 9.days, Time.zone.today + 13.days],
            following_work_package3 => [Time.zone.today + 6.days, Time.zone.today + 9.days],
            following_work_package4 => [Time.zone.today + 14.days, Time.zone.today + 15.days] }
        end
      end
    end

    context 'when moving backwards' do
      before do
        work_package.due_date = Time.zone.today - 5.days
      end

      it_behaves_like 'does not reschedule'
    end
  end

  context 'when setting the parent' do
    let(:new_parent_work_package) { create(:work_package) }
    let(:attributes) { [:parent] }

    before do
      allow(new_parent_work_package)
        .to receive(:soonest_start)
              .and_return(soonest_date)
      allow(work_package)
        .to receive(:parent)
              .and_return(new_parent_work_package)
    end

    context ""with the parent being restricted in its ability to be moved"" do
      let(:soonest_date) { Time.zone.today + 3.days }

      it 'sets the start date and due date to the earliest possible date' do
        subject

        expect(work_package.start_date).to eql(Time.zone.today + 3.days)
        expect(work_package.due_date).to eql(Time.zone.today + 3.days)
      end

      it 'does not change the due date if after the newly set start date' do
        work_package.due_date = Time.zone.today + 5.days
        subject

        expect(work_package.start_date).to eql(Time.zone.today + 3.days)
        expect(work_package.due_date).to eql(Time.zone.today + 5.days)
      end
    end

    context 'with the parent being restricted but work package already having dates set' do
      let(:soonest_date) { Time.zone.today + 3.days }

      before do
        work_package.start_date = Time.zone.today + 4.days
        work_package.due_date = Time.zone.today + 5.days
      end

      it 'sets the dates to provided dates' do
        subject

        expect(work_package.start_date).to eql(Time.zone.today + 4.days)
        expect(work_package.due_date).to eql(Time.zone.today + 5.days)
      end
    end

    context 'with the parent being restricted but the attributes define an earlier date' do
      let(:soonest_date) { Time.zone.today + 3.days }

      before do
        work_package.start_date = Time.zone.today + 1.day
        work_package.due_date = Time.zone.today + 2.days
      end

      # This would be invalid but the dates should be set nevertheless
      # so we can have a correct error handling.
      it 'sets the dates to provided dates' do
        subject

        expect(work_package.start_date).to eql(Time.zone.today + 1.day)
        expect(work_package.due_date).to eql(Time.zone.today + 2.days)
      end
    end
  end

  context 'with deep hierarchy of work packages' do
    before do
      work_package.due_date = Time.zone.today - 5.days
    end

    def create_hierarchy(parent, nb_children_by_levels)
      nb_children, *remaining_levels = nb_children_by_levels
      children = create_list(:work_package, nb_children, parent:)
      if remaining_levels.any?
        children.each do |child|
          create_hierarchy(child, remaining_levels)
        end
      end
    end

    it 'does not fail with a SystemStackError (regression #43894)' do
      parent = create(:work_package, start_date: Date.current, due_date: Date.current)
      hierarchy = [1, 1, 1, 1, 2, 4, 4, 4]
      create_hierarchy(parent, hierarchy)

      # The bug triggers when moving work package is in the middle of the
      # hierarchy
      work_package.parent = parent.children.first.children.first.children.first
      work_package.save

      expect { instance.call(attributes) }
        .not_to raise_error
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class WorkPackages::UpdateAncestorsService
  attr_accessor :user,
                :work_package

  def initialize(user:, work_package:)
    self.user = user
    self.work_package = work_package
  end

  def call(attributes)
    modified = update_current_and_former_ancestors(attributes)

    set_journal_note(modified)

    # Do not send notification for parent updates
    success = Journal::NotificationConfiguration.with(false) do
      modified.all? { |wp| wp.save(validate: false) }
    end

    result = ServiceResult.new(success:, result: work_package)

    modified.each do |wp|
      result.add_dependent!(ServiceResult.new(success: !wp.changed?, result: wp))
    end

    result
  end

  private

  def update_current_and_former_ancestors(attributes)
    WorkPackages::UpdateAncestors::Loader
      .new(work_package, (%i(parent_id parent) & attributes).any?)
      .select do |ancestor, loader|
        inherit_attributes(ancestor, loader, attributes)

        ancestor.changed?
      end
  end

  def inherit_attributes(ancestor, loader, attributes)
    return unless attributes_justify_inheritance?(attributes)

    # Estimated hours need to be calculated before the done_ratio below.
    # The aggregation only depends on estimated hours.
    derive_estimated_hours(ancestor, loader) if inherit?(attributes, :estimated_hours)

    # Progress (done_ratio or also: percentDone) depends on both
    # the completion of sub-WPs, as well as the estimated hours
    # as a weight factor. So changes in estimated hours also have
    # to trigger a recalculation of done_ratio.
    inherit_done_ratio(ancestor, loader) if inherit?(attributes, :done_ratio) || inherit?(attributes, :estimated_hours)

    inherit_ignore_non_working_days(ancestor, loader) if inherit?(attributes, :ignore_non_working_days)
  end

  def inherit?(attributes, attribute)
    ([attribute, :parent, :parent_id] & attributes).any?
  end

  def set_journal_note(work_packages)
    work_packages.each do |wp|
      wp.journal_notes = I18n.t('work_package.updated_automatically_by_child_changes', child: ""##{work_package.id}"")
    end
  end

  def inherit_done_ratio(ancestor, loader)
    return if WorkPackage.done_ratio_disabled?

    return if WorkPackage.use_status_for_done_ratio? && ancestor.status && ancestor.status.default_done_ratio

    # done ratio = weighted average ratio of leaves
    ancestor.done_ratio = (aggregate_done_ratio(ancestor, loader) || 0).round
  end

  # Sets the ignore_non_working_days to true if any ancestor has its value set to true.
  # If there is no value returned from the descendants, that means that the work package in
  # question no longer has a descendant. But since we are in the service going up the ancestor chain,
  # such a work package is the former parent. The property of such a work package is reset to `false`.
  def inherit_ignore_non_working_days(work_package, loader)
    return if work_package.schedule_manually

    descendant_value = ignore_non_working_days_of_descendants(work_package, loader)

    if descendant_value.nil?
      descendant_value = work_package.ignore_non_working_days
    end

    work_package.ignore_non_working_days = descendant_value
  end

  ##
  # done ratio = weighted average ratio of leaves
  def aggregate_done_ratio(work_package, loader)
    leaves = loader.leaves_of(work_package)

    leaves_count = leaves.size

    if leaves_count.positive?
      average = average_estimated_hours(leaves)
      progress = done_ratio_sum(leaves, average) / (average * leaves_count)

      progress.round(2)
    end
  end

  def average_estimated_hours(leaves)
    # 0 and nil shall be considered the same for estimated hours
    sum = all_estimated_hours(leaves).sum.to_f
    count = all_estimated_hours(leaves).count

    count = 1 if count.zero?

    average = sum / count

    average.zero? ? 1 : average
  end

  def done_ratio_sum(leaves, average_estimated_hours)
    # Do not take into account estimated_hours when it is either nil or set to 0.0
    summands = leaves.map do |leaf|
      estimated_hours = if leaf.estimated_hours.to_f.positive?
                          leaf.estimated_hours
                        else
                          average_estimated_hours
                        end

      done_ratio = if leaf.closed?
                     100
                   else
                     leaf.done_ratio || 0
                   end

      estimated_hours * done_ratio
    end

    summands.sum
  end

  def derive_estimated_hours(work_package, loader)
    descendants = loader.descendants_of(work_package)

    work_package.derived_estimated_hours = not_zero(all_estimated_hours(descendants).sum.to_f)
  end

  def not_zero(value)
    value unless value.zero?
  end

  def all_estimated_hours(work_packages)
    work_packages
      .map(&:estimated_hours)
      .reject { |hours| hours.to_f.zero? }
  end

  def attributes_justify_inheritance?(attributes)
    (%i(estimated_hours done_ratio parent parent_id status status_id ignore_non_working_days) & attributes).any?
  end

  def ignore_non_working_days_of_descendants(ancestor, loader)
    children = loader
                 .children_of(ancestor)
                 .reject(&:schedule_manually)

    if children.any?
      children.any?(&:ignore_non_working_days)
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe WorkPackages::UpdateAncestorsService, type: :model do
  shared_association_default(:author, factory_name: :user) { create(:user) }
  shared_association_default(:project_with_types) { create(:project_with_types) }
  shared_association_default(:priority) { create(:priority) }
  shared_association_default(:open_status, factory_name: :status) { create(:status) }
  shared_let(:closed_status) { create(:closed_status) }
  shared_let(:user) { create(:user) }

  let(:estimated_hours) { [nil, nil, nil] }
  let(:done_ratios) { [0, 0, 0] }
  let(:statuses) { %i(open open open) }
  let(:aggregate_done_ratio) { 0.0 }
  let(:ignore_non_working_days) { [false, false, false] }

  describe 'done_ratio/estimated_hours propagation' do
    context 'for the new ancestor chain' do
      shared_examples 'attributes of parent having children' do
        before do
          children
        end

        it 'updated one work package - the parent' do
          expect(subject.dependent_results.map(&:result))
          .to contain_exactly(parent)
        end

        it 'has the expected aggregate done ratio' do
          expect(subject.dependent_results.first.result.done_ratio)
          .to eq aggregate_done_ratio
        end

        it 'has the expected derived estimated_hours' do
          expect(subject.dependent_results.first.result.derived_estimated_hours)
          .to eq aggregate_estimated_hours
        end

        it 'is a success' do
          expect(subject)
          .to be_success
        end
      end

      let(:children) do
        (statuses.size - 1).downto(0).map do |i|
          create(:work_package,
                 parent:,
                 status: statuses[i] == :open ? open_status : closed_status,
                 estimated_hours: estimated_hours[i],
                 done_ratio: done_ratios[i],
                 ignore_non_working_days:)
        end
      end

      shared_let(:parent) { create(:work_package, status: open_status) }

      subject do
        # In the call we only use estimated_hours (instead of also adding
        # done_ratio) in order to test that changes in estimated hours
        # trigger a recalculation of done_ration, because estimated hours
        # act as weights in this calculation.
        described_class
          .new(user:,
               work_package: children.first)
          .call(%i(estimated_hours))
      end

      context 'with no estimated hours and no progress' do
        let(:statuses) { %i(open open open) }

        it 'is a success' do
          expect(subject)
          .to be_success
        end

        it 'does not update the parent' do
          expect(subject.dependent_results)
          .to be_empty
        end
      end

      context 'with 1 out of 3 tasks having estimated hours and 2 out of 3 tasks done' do
        let(:statuses) do
          %i(open closed closed)
        end

        it_behaves_like 'attributes of parent having children' do
          let(:estimated_hours) do
            [0.0, 2.0, 0.0]
          end

          # 66.67 rounded - previous wrong result: 133
          let(:aggregate_done_ratio) do
            67
          end
          let(:aggregate_estimated_hours) do
            2.0
          end
        end

        context 'with mixed nil and 0 values for estimated hours' do
          it_behaves_like 'attributes of parent having children' do
            let(:estimated_hours) do
              [nil, 2.0, 0.0]
            end

            # 66.67 rounded - previous wrong result: 100
            let(:aggregate_done_ratio) do
              67
            end
            let(:aggregate_estimated_hours) do
              2.0
            end
          end
        end
      end

      context 'with some values same for done ratio' do
        it_behaves_like 'attributes of parent having children' do
          let(:done_ratios) { [20, 20, 50] }
          let(:estimated_hours) { [nil, nil, nil] }

          let(:aggregate_done_ratio) { 30 }
          let(:aggregate_estimated_hours) { nil }
        end
      end

      context 'with no estimated hours and 1.5 of the tasks done' do
        it_behaves_like 'attributes of parent having children' do
          let(:done_ratios) { [0, 50, 100] }

          let(:aggregate_done_ratio) { 50 }
          let(:aggregate_estimated_hours) { nil }
        end
      end

      context 'with estimated hours being 1, 2 and 5' do
        let(:estimated_hours) { [1, 2, 5] }

        context 'with the last 2 tasks at 100% progress' do
          it_behaves_like 'attributes of parent having children' do
            let(:done_ratios) { [0, 100, 100] }

            # (2 + 5 = 7) / 8 estimated hours done
            let(:aggregate_done_ratio) { 88 } # 87.5 rounded
            let(:aggregate_estimated_hours) { estimated_hours.sum }
          end
        end

        context 'with the last 2 tasks closed (therefore at 100%)' do
          it_behaves_like 'attributes of parent having children' do
            let(:statuses) { %i(open closed closed) }

            # (2 + 5 = 7) / 8 estimated hours done
            let(:aggregate_done_ratio) { 88 } # 87.5 rounded
            let(:aggregate_estimated_hours) { estimated_hours.sum }
          end
        end

        context 'with mixed done ratios, statuses' do
          it_behaves_like 'attributes of parent having children' do
            let(:done_ratios) { [50, 75, 42] }
            let(:statuses) { %i(open open closed) }

            #  50%       75%        100% (42 ignored)
            # (0.5 * 1 + 0.75 * 2 + 1 * 5 [since closed] = 7)
            # (0.5 + 1.5 + 5 = 7) / 8 estimated hours done
            let(:aggregate_done_ratio) { 88 } # 87.5 rounded
            let(:aggregate_estimated_hours) { estimated_hours.sum }
          end
        end
      end

      context 'with everything playing together' do
        it_behaves_like 'attributes of parent having children' do
          let(:statuses) { %i(open open closed open) }
          let(:done_ratios) { [0, 0, 0, 50] }
          let(:estimated_hours) { [0.0, 3.0, nil, 7.0] }

          # (0 * 5 + 0 * 3 + 1 * 5 + 0.5 * 7 = 8.5) / 20 est. hours done
          let(:aggregate_done_ratio) { 43 } # 42.5 rounded
          let(:aggregate_estimated_hours) { 10.0 }
        end
      end
    end

    context 'for the previous ancestors' do
      shared_let(:sibling_status) { open_status }
      shared_let(:sibling_done_ratio) { 50 }
      shared_let(:sibling_estimated_hours) { 7.0 }

      shared_let(:grandparent) do
        create(:work_package)
      end
      shared_let(:parent) do
        create(:work_package,
               parent: grandparent)
      end
      shared_let(:sibling) do
        create(:work_package,
               parent:,
               status: sibling_status,
               estimated_hours: sibling_estimated_hours,
               done_ratio: sibling_done_ratio)
      end

      shared_let(:work_package) do
        create(:work_package,
               parent:)
      end

      subject do
        work_package.parent = nil
        work_package.save!

        described_class
          .new(user:,
               work_package:)
          .call(%i(parent))
      end

      before do
        subject
      end

      it 'is successful' do
        expect(subject)
          .to be_success
      end

      it 'returns the former ancestors in the dependent results' do
        expect(subject.dependent_results.map(&:result))
          .to contain_exactly(parent, grandparent)
      end

      it 'updates the done_ratio of the former parent' do
        expect(parent.reload(select: :done_ratio).done_ratio)
          .to eql sibling_done_ratio
      end

      it 'updates the estimated_hours of the former parent' do
        expect(parent.reload(select: :derived_estimated_hours).derived_estimated_hours)
          .to eql sibling_estimated_hours
      end

      it 'updates the done_ratio of the former grandparent' do
        expect(grandparent.reload(select: :done_ratio).done_ratio)
          .to eql sibling_done_ratio
      end

      it 'updates the estimated_hours of the former grandparent' do
        expect(grandparent.reload(select: :derived_estimated_hours).derived_estimated_hours)
          .to eql sibling_estimated_hours
      end
    end

    context 'for new ancestors' do
      shared_let(:status) { open_status }
      shared_let(:done_ratio) { 50 }
      shared_let(:estimated_hours) { 7.0 }

      shared_let(:grandparent) do
        create(:work_package)
      end
      shared_let(:parent) do
        create(:work_package,
               parent: grandparent)
      end
      shared_let(:work_package) do
        create(:work_package,
               status:,
               estimated_hours:,
               done_ratio:)
      end

      shared_examples_for 'updates the attributes within the new hierarchy' do
        before do
          subject
        end

        it 'is successful' do
          expect(subject)
            .to be_success
        end

        it 'returns the new ancestors in the dependent results' do
          expect(subject.dependent_results.map(&:result))
            .to contain_exactly(parent, grandparent)
        end

        it 'updates the done_ratio of the new parent' do
          expect(parent.reload(select: :done_ratio).done_ratio)
            .to eql done_ratio
        end

        it 'updates the estimated_hours of the new parent' do
          expect(parent.reload(select: :derived_estimated_hours).derived_estimated_hours)
            .to eql estimated_hours
        end

        it 'updates the done_ratio of the new grandparent' do
          expect(grandparent.reload(select: :done_ratio).done_ratio)
            .to eql done_ratio
        end

        it 'updates the estimated_hours of the new grandparent' do
          expect(grandparent.reload(select: :derived_estimated_hours).derived_estimated_hours)
            .to eql estimated_hours
        end
      end

      context 'if setting the parent' do
        subject do
          work_package.parent = parent
          work_package.save!
          work_package.parent_id_was

          described_class
            .new(user:,
                 work_package:)
            .call(%i(parent))
        end

        it_behaves_like 'updates the attributes within the new hierarchy'
      end

      context 'if setting the parent_id' do
        subject do
          work_package.parent_id = parent.id
          work_package.save!
          work_package.parent_id_was

          described_class
            .new(user:,
                 work_package:)
            .call(%i(parent_id))
        end

        it_behaves_like 'updates the attributes within the new hierarchy'
      end
    end

    context 'with old and new parent having a common ancestor' do
      shared_let(:status) { open_status }
      shared_let(:done_ratio) { 50 }
      shared_let(:estimated_hours) { 7.0 }

      shared_let(:grandparent) do
        create(:work_package,
               derived_estimated_hours: estimated_hours,
               done_ratio:)
      end
      shared_let(:old_parent) do
        create(:work_package,
               parent: grandparent,
               derived_estimated_hours: estimated_hours,
               done_ratio:)
      end
      shared_let(:new_parent) do
        create(:work_package,
               parent: grandparent)
      end
      shared_let(:work_package) do
        create(:work_package,
               parent: old_parent,
               status:,
               estimated_hours:,
               done_ratio:)
      end

      subject do
        work_package.parent = new_parent
        # In this test case, derived_estimated_hours and done_ratio will not
        # inherently change on grandparent. However, if work_package has siblings
        # then changing its parent could cause derived_estimated_hours and/or
        # done_ratio on grandparent to inherently change. To verify that
        # grandparent can be properly updated in that case without making this
        # test dependent on the implementation details of the
        # derived_estimated_hours and done_ratio calculations, force
        # derived_estimated_hours and done_ratio to change at the same time as the
        # parent.
        work_package.estimated_hours = (estimated_hours + 1)
        work_package.done_ratio = (done_ratio + 1)
        work_package.save!

        described_class
          .new(user:,
               work_package:)
          .call(%i(parent))
      end

      before do
        subject
      end

      it 'is successful' do
        expect(subject)
          .to be_success
      end

      it 'returns both the former and new ancestors in the dependent results without duplicates' do
        expect(subject.dependent_results.map(&:result))
          .to contain_exactly(new_parent, grandparent, old_parent)
      end

      it 'updates the done_ratio of the former parent' do
        expect(old_parent.reload(select: :done_ratio).done_ratio)
          .to be 0
      end

      it 'updates the estimated_hours of the former parent' do
        expect(old_parent.reload(select: :derived_estimated_hours).derived_estimated_hours)
          .to be_nil
      end
    end
  end

  describe 'ignore_non_working_days propagation' do
    shared_let(:grandgrandparent) do
      create(:work_package,
             subject: 'grandgrandparent')
    end
    shared_let(:grandparent) do
      create(:work_package,
             subject: 'grandparent',
             parent: grandgrandparent)
    end
    shared_let(:parent) do
      create(:work_package,
             subject: 'parent',
             parent: grandparent)
    end
    shared_let(:sibling) do
      create(:work_package,
             subject: 'sibling',
             parent:)
    end
    shared_let(:work_package) do
      create(:work_package)
    end

    subject do
      work_package.parent = new_parent
      work_package.save!

      described_class
        .new(user:,
             work_package:)
        .call(%i(parent))
    end

    let(:new_parent) { parent }

    context 'for the previous ancestors (parent removed)' do
      let(:new_parent) { nil }

      before do
        work_package.parent = parent
        work_package.save

        [grandgrandparent, grandparent, parent, work_package].each do |wp|
          wp.update_column(:ignore_non_working_days, true)
        end

        [sibling].each do |wp|
          wp.update_column(:ignore_non_working_days, false)
        end
      end

      it 'is successful' do
        expect(subject)
          .to be_success
      end

      it 'returns the former ancestors in the dependent results' do
        expect(subject.dependent_results.map(&:result))
          .to contain_exactly(parent, grandparent, grandgrandparent)
      end

      it 'sets the ignore_non_working_days property of the former ancestor chain to the value of the
          only remaining child (former sibling)' do
        subject

        expect(parent.reload.ignore_non_working_days)
          .to be_falsey

        expect(grandparent.reload.ignore_non_working_days)
          .to be_falsey

        expect(grandgrandparent.reload.ignore_non_working_days)
          .to be_falsey

        expect(sibling.reload.ignore_non_working_days)
          .to be_falsey
      end
    end

    context 'for the new ancestors where the grandparent is on manual scheduling' do
      before do
        [grandgrandparent, work_package].each do |wp|
          wp.update_column(:ignore_non_working_days, true)
        end

        [grandparent, parent, sibling].each do |wp|
          wp.update_column(:ignore_non_working_days, false)
        end

        [grandparent].each do |wp|
          wp.update_column(:schedule_manually, true)
        end
      end

      it 'is successful' do
        expect(subject)
          .to be_success
      end

      it 'returns the former ancestors in the dependent results' do
        expect(subject.dependent_results.map(&:result))
          .to contain_exactly(parent)
      end

      it 'sets the ignore_non_working_days property of the new ancestors' do
        subject

        expect(parent.reload.ignore_non_working_days)
          .to be_truthy

        expect(grandparent.reload.ignore_non_working_days)
          .to be_falsey

        expect(grandgrandparent.reload.ignore_non_working_days)
          .to be_truthy

        expect(sibling.reload.ignore_non_working_days)
          .to be_falsey
      end
    end

    context 'for the new ancestors where the parent is on manual scheduling' do
      before do
        [grandgrandparent, grandparent, work_package].each do |wp|
          wp.update_column(:ignore_non_working_days, true)
        end

        [parent, sibling].each do |wp|
          wp.update_column(:ignore_non_working_days, false)
        end

        [parent].each do |wp|
          wp.update_column(:schedule_manually, true)
        end
      end

      it 'is successful' do
        expect(subject)
          .to be_success
      end

      it 'returns the former ancestors in the dependent results' do
        expect(subject.dependent_results.map(&:result))
          .to be_empty
      end

      it 'sets the ignore_non_working_days property of the new ancestors' do
        subject

        expect(parent.reload.ignore_non_working_days)
          .to be_falsey

        expect(grandparent.reload.ignore_non_working_days)
          .to be_truthy

        expect(grandgrandparent.reload.ignore_non_working_days)
          .to be_truthy

        expect(sibling.reload.ignore_non_working_days)
          .to be_falsey
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class WorkPackages::UpdateService < BaseServices::Update
  include ::WorkPackages::Shared::UpdateAncestors
  include Attachments::ReplaceAttachments

  attr_accessor :cause_of_update

  def initialize(user:, model:, contract_class: nil, contract_options: {}, cause_of_update: nil)
    super(user:, model:, contract_class:, contract_options:)
    self.cause_of_update = cause_of_update || model
  end

  private

  def after_perform(service_call)
    update_related_work_packages(service_call)
    cleanup(service_call.result)

    service_call
  end

  def update_related_work_packages(service_call)
    update_ancestors([service_call.result]).each do |ancestor_service_call|
      ancestor_service_call.dependent_results.each do |ancestor_dependent_service_call|
        service_call.add_dependent!(ancestor_dependent_service_call)
      end
    end

    update_related(service_call.result).each do |related_service_call|
      service_call.add_dependent!(related_service_call)
    end
  end

  def update_related(work_package)
    consolidated_calls(update_descendants(work_package) + reschedule_related(work_package))
      .each { |dependent_call| dependent_call.result.save(validate: false) }
  end

  def update_descendants(work_package)
    if work_package.saved_change_to_project_id?
      attributes = { project: work_package.project }

      work_package.descendants.map do |descendant|
        set_descendant_attributes(attributes, descendant)
      end
    else
      []
    end
  end

  def set_descendant_attributes(attributes, descendant)
    WorkPackages::SetAttributesService
      .new(user:,
           model: descendant,
           contract_class: WorkPackages::UpdateDependentContract)
      .call(attributes)
  end

  def cleanup(work_package)
    if work_package.saved_change_to_project_id?
      moved_work_packages = [work_package] + work_package.descendants
      delete_relations(moved_work_packages)
      move_time_entries(moved_work_packages, work_package.project_id)
      move_work_package_memberships(moved_work_packages, work_package.project_id)
    end
    if work_package.saved_change_to_type_id?
      reset_custom_values(work_package)
    end
  end

  def delete_relations(work_packages)
    unless Setting.cross_project_work_package_relations?
      Relation
        .of_work_package(work_packages)
        .destroy_all
    end
  end

  def move_time_entries(work_packages, project_id)
    TimeEntry
      .on_work_packages(work_packages)
      .update_all(project_id:)
  end

  def move_work_package_memberships(work_packages, project_id)
    Member
      .where(entity: work_packages)
      .update_all(project_id:)
  end

  def reset_custom_values(work_package)
    work_package.reset_custom_values!
  end

  def reschedule_related(work_package)
    rescheduled = if work_package.saved_change_to_parent_id? && work_package.parent_id_before_last_save
                    reschedule_former_siblings(work_package).dependent_results
                  else
                    []
                  end

    rescheduled + reschedule(work_package, [work_package]).dependent_results
  end

  def reschedule_former_siblings(work_package)
    reschedule(work_package, WorkPackage.where(parent_id: work_package.parent_id_before_last_save))
  end

  def reschedule(work_package, work_packages)
    WorkPackages::SetScheduleService
      .new(user:, work_package: work_packages, initiated_by: cause_of_update)
      .call(work_package.saved_changes.keys.map(&:to_sym))
  end

  # When multiple services change a work package, we still only want one update to the database due to:
  # * performance
  # * having only one journal entry
  # * stale object errors
  # we thus consolidate the results so that one instance contains the changes made by all the services.
  def consolidated_calls(service_calls)
    service_calls
      .group_by { |sc| sc.result.id }
      .map do |(_, same_work_package_calls)|
      same_work_package_calls.pop.tap do |master|
        same_work_package_calls.each do |sc|
          master.result.attributes = sc.result.changes.transform_values(&:last)
        end
      end
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'
require 'services/base_services/behaves_like_update_service'

RSpec.describe WorkPackages::UpdateService, type: :model do
  # This is now only a very basic test testing the structure of the service.
  # The domain tests are in the update_service_integration_spec.rb
  it_behaves_like 'BaseServices update service' do
    before do
      allow(set_attributes_errors)
        .to receive(:merge!)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class WorkPackages::DeleteService < BaseServices::Delete
  include ::WorkPackages::Shared::UpdateAncestors

  private

  def persist(service_result)
    descendants = model.descendants.to_a

    result = super

    if result.success?
      update_ancestors_all_attributes(result.all_results).each do |ancestor_result|
        result.merge!(ancestor_result)
      end

      destroy_descendants(descendants, result)
      delete_associated(model)
    end

    result
  end

  def destroy(work_package)
    work_package.destroy
  rescue ActiveRecord::StaleObjectError
    destroy(work_package.reload)
  end

  def destroy_descendants(descendants, result)
    descendants.each do |descendant|
      result.add_dependent!(ServiceResult.new(success: destroy(descendant), result: descendant))
    end
  end

  def delete_associated(model)
    delete_notifications_resource(model.id)
  end

  def delete_notifications_resource(id)
    Notification
      .where(resource_type: :WorkPackage, resource_id: id)
      .delete_all
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe WorkPackages::DeleteService do
  let(:user) do
    build_stubbed(:user)
  end
  let(:work_package) do
    build_stubbed(:work_package, type: build_stubbed(:type))
  end
  let(:instance) do
    described_class
      .new(user:,
           model: work_package)
  end
  let(:destroyed_result) { true }
  let(:destroy_allowed) { true }

  subject { instance.call }

  before do
    allow(work_package).to receive(:reload).and_return(work_package)
    expect(work_package).to receive(:destroy).and_return(destroyed_result)
    allow(work_package).to receive(:destroyed?).and_return(destroyed_result)

    mock_permissions_for(user) do |mock|
      mock.allow_in_project :delete_work_packages, project: work_package.project
    end
  end

  it 'destroys the work package' do
    subject
  end

  it 'is successful' do
    expect(subject)
      .to be_success
  end

  it 'returns the destroyed work package' do
    expect(subject.result)
      .to eql work_package
  end

  it 'returns an empty errors array' do
    expect(subject.errors)
      .to be_empty
  end

  context 'when the work package could not be destroyed' do
    let(:destroyed_result) { false }

    it 'is no success' do
      expect(subject)
        .not_to be_success
    end
  end

  context 'with ancestors' do
    let(:parent) do
      build_stubbed(:work_package)
    end
    let(:grandparent) do
      build_stubbed(:work_package)
    end
    let(:expect_inherited_attributes_service_calls) do
      inherited_service_instance = double(WorkPackages::UpdateAncestorsService)

      service_result = ServiceResult.success(result: work_package)

      service_result.dependent_results += [ServiceResult.success(result: parent),
                                           ServiceResult.success(result: grandparent)]

      expect(WorkPackages::UpdateAncestorsService)
        .to receive(:new)
        .with(user:,
              work_package:)
        .and_return(inherited_service_instance)

      expect(inherited_service_instance)
        .to receive(:call)
        .with(work_package.attributes.keys.map(&:to_sym))
        .and_return(service_result)
    end
    let(:expect_no_inherited_attributes_service_calls) do
      expect(WorkPackages::UpdateAncestorsService)
        .not_to receive(:new)
    end

    it 'calls the inherit attributes service for each ancestor' do
      expect_inherited_attributes_service_calls

      subject
    end

    context 'when the work package could not be destroyed' do
      let(:destroyed_result) { false }

      it 'does not call inherited attributes service' do
        expect_no_inherited_attributes_service_calls

        subject
      end
    end
  end

  context 'with descendants' do
    let(:child) do
      build_stubbed(:work_package)
    end
    let(:grandchild) do
      build_stubbed(:work_package)
    end
    let(:descendants) do
      [child, grandchild]
    end

    before do
      allow(work_package)
        .to receive(:descendants)
        .and_return(descendants)

      descendants.each do |descendant|
        allow(descendant)
          .to receive(:destroy)
      end
    end

    it 'destroys the descendants' do
      descendants.each do |descendant|
        expect(descendant)
          .to receive(:destroy)
      end

      subject
    end

    it 'returns the descendants as part of the result' do
      subject

      expect(subject.all_results)
        .to match_array [work_package] + descendants
    end

    context 'if the work package could not be destroyed' do
      let(:destroyed_result) { false }

      it 'does not destroy the descendants' do
        descendants.each do |descendant|
          expect(descendant)
            .not_to receive(:destroy)
        end

        subject
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class WorkPackages::ScheduleDependency::Dependency
  def initialize(work_package, schedule_dependency)
    self.work_package = work_package
    self.schedule_dependency = schedule_dependency
  end

  attr_accessor :work_package,
                :schedule_dependency

  # Returns the work package ids that this work package directly depends on to
  # determine its own dates. This is used for the order of the dates
  # computations.
  #
  # The dates of a work package depend on its descendants and predecessors
  # dates.
  def dependent_ids
    @dependent_ids ||= (descendants + moving_predecessors).map(&:id).uniq
  end

  def moving_predecessors
    @moving_predecessors ||= follows_relations
      .map(&:to)
      .filter { |predecessor| schedule_dependency.moving?(predecessor) }
  end

  def soonest_start_date
    @soonest_start_date ||=
      follows_relations
        .filter_map(&:successor_soonest_start)
        .max
  end

  def start_date
    descendants_dates.min
  end

  def due_date
    descendants_dates.max
  end

  def has_descendants?
    descendants.any?
  end

  private

  def descendants
    schedule_dependency.descendants(work_package)
  end

  def follows_relations
    schedule_dependency.follows_relations(work_package)
  end

  def descendants_dates
    descendants.filter_map(&:due_date) + descendants.filter_map(&:start_date)
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'rails_helper'

# Scenario: a work package has been moved on the calendar. The moved work
# package has children, parents, followers, and/or predecessors. The
# +ScheduleDependency+ created for the moved work package will have one
# +Dependency+ instance per work package that may need to change due to the
# move. These dependencies are the subjects under test.
RSpec.describe WorkPackages::ScheduleDependency::Dependency do
  subject(:dependency) { dependency_for(work_package_used_in_dependency) }

  create_shared_association_defaults_for_work_package_factory

  shared_let(:work_package) { create(:work_package, subject: 'moved') }

  let(:schedule_dependency) { WorkPackages::ScheduleDependency.new(work_package) }

  def dependency_for(work_package)
    dependency = schedule_dependency.dependencies[work_package]
    if dependency.nil?
      available = schedule_dependency.dependencies.keys.map(&:subject).map(&:inspect).to_sentence
      raise ArgumentError, ""Unable to find dependency for work package #{work_package.subject.inspect}; "" \
                           ""ScheduleDependency instance has dependencies for work packages #{available}""
    end

    dependency
  end

  def create_predecessor_of(work_package, **attributes)
    create(:work_package, subject: ""predecessor of #{work_package.subject}"", **attributes).tap do |predecessor|
      create(:follows_relation, from: work_package, to: predecessor)
    end
  end

  def create_follower_of(work_package, **attributes)
    create(:work_package, subject: ""follower of #{work_package.subject}"", **attributes).tap do |follower|
      create(:follows_relation, from: follower, to: work_package)
    end
  end

  def create_parent_of(work_package)
    create(:work_package, subject: ""parent of #{work_package.subject}"").tap do |parent|
      work_package.update(parent:)
    end
  end

  def create_child_of(work_package)
    create(:work_package, subject: ""child of #{work_package.subject}"", parent: work_package)
  end

  describe '#dependent_ids' do
    context 'when the work_package has a follower' do
      let!(:follower) { create_follower_of(work_package) }

      context 'for dependency of the follower' do
        let(:work_package_used_in_dependency) { follower }

        it 'returns an array with the work package id' do
          expect(subject.dependent_ids).to eq([work_package.id])
        end
      end
    end

    context 'when the work_package has a parent' do
      let!(:parent) { create_parent_of(work_package) }

      context 'for dependency of the parent' do
        let(:work_package_used_in_dependency) { parent }

        it 'returns an array with the work package id' do
          expect(subject.dependent_ids).to eq([work_package.id])
        end
      end
    end

    context 'when the work_package has a follower which has a child' do
      let!(:follower) { create_follower_of(work_package) }
      let!(:follower_child) { create_child_of(follower) }

      context 'for dependency of the child' do
        let(:work_package_used_in_dependency) { follower_child }

        it 'returns an array with the work_package id' do
          expect(subject.dependent_ids).to eq([work_package.id])
        end
      end

      context 'for dependency of the follower' do
        let(:work_package_used_in_dependency) { follower }

        it 'returns an array with the work_package id and the follower child id' do
          expect(subject.dependent_ids).to contain_exactly(work_package.id, follower_child.id)
        end
      end
    end

    context 'when the work_package has multiple parents and followers' do
      let!(:first_follower) { create_follower_of(work_package) }
      let!(:second_follower) { create_follower_of(work_package) }
      let!(:first_follower_parent) { create_parent_of(first_follower) }
      let!(:first_follower_grandparent) { create_parent_of(first_follower_parent) }

      context 'for dependency of the first follower parent' do
        let(:work_package_used_in_dependency) { first_follower_parent }

        it 'returns an array with the work_package and the first follower ids' do
          expect(subject.dependent_ids).to contain_exactly(work_package.id, first_follower.id)
        end
      end

      context 'for dependency of the first follower grandparent' do
        let(:work_package_used_in_dependency) { first_follower_grandparent }

        it 'returns an array with the work_package, the first follower, and the first follower parent ids' do
          expect(subject.dependent_ids).to contain_exactly(work_package.id, first_follower.id, first_follower_parent.id)
        end
      end

      context 'for dependency of the second follower' do
        let(:work_package_used_in_dependency) { second_follower }

        it 'returns an array with the work_package id' do
          expect(subject.dependent_ids).to contain_exactly(work_package.id)
        end
      end
    end

    context 'with more complex relations' do
      context 'when has two consecutive followers' do
        let!(:follower) { create_follower_of(work_package) }
        let!(:follower_follower) { create_follower_of(follower) }

        context 'for dependency of the first follower' do
          let(:work_package_used_in_dependency) { follower }

          it 'returns an array with the work_package id' do
            expect(subject.dependent_ids).to contain_exactly(work_package.id)
          end
        end

        context 'for dependency of the second follower' do
          let(:work_package_used_in_dependency) { follower_follower }

          it 'returns an array with only the first follower id' do
            expect(subject.dependent_ids).to contain_exactly(follower.id)
          end
        end
      end

      context 'when has a follower which has a predecessor' do
        let!(:follower) { create_follower_of(work_package) }
        let!(:follower_predecessor) { create_predecessor_of(follower) }

        context 'for dependency of the follower' do
          let(:work_package_used_in_dependency) { follower }

          it 'returns an array with the work_package id' do
            expect(subject.dependent_ids).to contain_exactly(work_package.id)
          end
        end
      end

      context 'when has a predecessor which has a parent and a child' do
        let!(:follower) { create_follower_of(work_package) }
        let!(:follower_parent) { create_parent_of(follower) }
        let!(:follower_child) { create_child_of(follower) }

        context 'for dependency of the follower child' do
          let(:work_package_used_in_dependency) { follower_child }

          it 'returns an array with the work_package id' do
            expect(subject.dependent_ids).to contain_exactly(work_package.id)
          end
        end

        context 'for dependency of the follower parent' do
          let(:work_package_used_in_dependency) { follower_parent }

          it 'returns an array with the work_package, the follower, and the follower child ids' do
            expect(subject.dependent_ids).to contain_exactly(work_package.id, follower.id, follower_child.id)
          end
        end
      end
    end
  end

  describe '#soonest_start_date' do
    let(:work_package_used_in_dependency) { work_package }

    before do
      work_package.update(due_date: Time.zone.today)
    end

    context 'with a moved predecessor' do
      it 'returns the soonest start date from the predecessors' do
        follower = create_follower_of(work_package)
        expect(dependency_for(follower).soonest_start_date).to eq(work_package.due_date + 1.day)
      end
    end

    context 'with an unmoved predecessor' do
      it 'returns the soonest start date from the predecessors' do
        follower = create_follower_of(work_package)
        unmoved_follower_predecessor = create_predecessor_of(follower, due_date: Time.zone.today + 4.days)
        expect(dependency_for(follower).soonest_start_date).to eq(unmoved_follower_predecessor.due_date + 1.day)
      end
    end

    context 'with non working days' do
      let!(:tomorrow_we_do_not_work!) { create(:non_working_day, date: Time.zone.tomorrow) }

      it 'returns the soonest start date being a working day' do
        follower = create_follower_of(work_package)
        expect(dependency_for(follower).soonest_start_date).to eq(work_package.due_date + 2.days)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module WorkPackages
  module Shared
    class WorkingDays
      # Returns number of working days between two dates, excluding weekend days
      # and non working days.
      def duration(start_date, due_date)
        return nil unless start_date && due_date

        (start_date..due_date).count { working?(_1) }
      end

      def start_date(due_date, duration)
        assert_strictly_positive_duration(duration)
        return nil unless due_date && duration

        start_date = latest_working_day(due_date)
        until duration <= 1 && working?(start_date)
          start_date -= 1
          duration -= 1 if working?(start_date)
        end
        start_date
      end

      def due_date(start_date, duration)
        assert_strictly_positive_duration(duration)
        return nil unless start_date && duration

        due_date = soonest_working_day(start_date)
        until duration <= 1 && working?(due_date)
          due_date += 1
          duration -= 1 if working?(due_date)
        end
        due_date
      end

      def soonest_working_day(date, delay: nil)
        return unless date

        delay ||= 0

        while delay > 0
          delay -= 1 if working?(date)
          date += 1
        end

        until working?(date)
          date += 1
        end

        date
      end

      def working?(date)
        working_week_day?(date) && working_specific_date?(date)
      end

      def non_working?(date)
        !working?(date)
      end

      private

      def assert_strictly_positive_duration(duration)
        raise ArgumentError, 'duration must be strictly positive' if duration.is_a?(Integer) && duration <= 0
      end

      def latest_working_day(date)
        return unless date

        until working?(date)
          date -= 1
        end
        date
      end

      def working_week_day?(date)
        assert_some_working_week_days_exist
        working_week_days[date.wday]
      end

      def working_specific_date?(date)
        non_working_dates.exclude?(date)
      end

      def assert_some_working_week_days_exist
        return if @working_week_days_exist

        if working_week_days.all? { |working| working == false }
          raise 'cannot have all week days as non-working days'
        end

        @working_week_days_exist = true
      end

      def working_week_days
        return @working_week_days if defined?(@working_week_days)

        # WeekDay day of the week is stored as ISO, meaning Monday is 1 and Sunday is 7.
        # Ruby Date#wday value for Sunday is 0 and it goes until 6 Saturday.
        # To accommodate both versions 0-6, 1-7, an array of 8 elements is created
        # where array[0] = array[7] = value for Sunday
        #
        # Since Setting.working_days can be empty, the initial array is
        # built with all days considered working (value is `true`)

        @working_week_days = [true] * 8

        WeekDay.all.each do |week_day|
          @working_week_days[week_day.day] = week_day.working
        end

        @working_week_days[0] = @working_week_days[7] # value for Sunday is present at index 0 AND index 7
        @working_week_days
      end

      def non_working_dates
        @non_working_dates ||= RequestStore.fetch(:work_package_non_working_dates) { Set.new(NonWorkingDay.pluck(:date)) }
      end
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'rails_helper'
require_relative 'shared_examples_days'

RSpec.describe WorkPackages::Shared::WorkingDays do
  subject { described_class.new }

  friday_2022_07_29 = Date.new(2022, 7, 29)
  saturday_2022_07_30 = Date.new(2022, 7, 30)
  sunday_2022_07_31 = Date.new(2022, 7, 31)
  monday_2022_08_01 = Date.new(2022, 8, 1)
  wednesday_2022_08_03 = Date.new(2022, 8, 3)

  describe '#duration' do
    it 'returns the duration for a given start date and due date' do
      expect(subject.duration(sunday_2022_07_31, sunday_2022_07_31 + 6)).to eq(7)
    end

    context 'without any week days created' do
      it 'considers all days as working days and returns the number of days between two dates, inclusive' do
        expect(subject.duration(sunday_2022_07_31, sunday_2022_07_31 + 6)).to eq(7)
        expect(subject.duration(sunday_2022_07_31, sunday_2022_07_31 + 50)).to eq(51)
      end
    end

    context 'with weekend days (Saturday and Sunday)', :weekend_saturday_sunday do
      include_examples 'it returns duration', 0, sunday_2022_07_31, sunday_2022_07_31
      include_examples 'it returns duration', 5, sunday_2022_07_31, Date.new(2022, 8, 5)
      include_examples 'it returns duration', 5, sunday_2022_07_31, Date.new(2022, 8, 6)
      include_examples 'it returns duration', 5, sunday_2022_07_31, Date.new(2022, 8, 7)
      include_examples 'it returns duration', 6, sunday_2022_07_31, Date.new(2022, 8, 8)
      include_examples 'it returns duration', 7, sunday_2022_07_31, Date.new(2022, 8, 9)

      include_examples 'it returns duration', 1, monday_2022_08_01, monday_2022_08_01
      include_examples 'it returns duration', 5, monday_2022_08_01, Date.new(2022, 8, 5)
      include_examples 'it returns duration', 5, monday_2022_08_01, Date.new(2022, 8, 6)
      include_examples 'it returns duration', 5, monday_2022_08_01, Date.new(2022, 8, 7)
      include_examples 'it returns duration', 6, monday_2022_08_01, Date.new(2022, 8, 8)
      include_examples 'it returns duration', 7, monday_2022_08_01, Date.new(2022, 8, 9)

      include_examples 'it returns duration', 3, wednesday_2022_08_03, Date.new(2022, 8, 5)
      include_examples 'it returns duration', 3, wednesday_2022_08_03, Date.new(2022, 8, 6)
      include_examples 'it returns duration', 3, wednesday_2022_08_03, Date.new(2022, 8, 7)
      include_examples 'it returns duration', 4, wednesday_2022_08_03, Date.new(2022, 8, 8)
      include_examples 'it returns duration', 5, wednesday_2022_08_03, Date.new(2022, 8, 9)
    end

    context 'with some non working days (Christmas 2022-12-25 and new year\'s day 2023-01-01)', :christmas_2022_new_year_2023 do
      include_examples 'it returns duration', 0, Date.new(2022, 12, 25), Date.new(2022, 12, 25)
      include_examples 'it returns duration', 1, Date.new(2022, 12, 24), Date.new(2022, 12, 25)
      include_examples 'it returns duration', 8, Date.new(2022, 12, 24), Date.new(2023, 1, 2)
    end

    context 'without start date' do
      it 'returns nil' do
        expect(subject.duration(nil, sunday_2022_07_31)).to be_nil
      end
    end

    context 'without due date' do
      it 'returns nil' do
        expect(subject.duration(sunday_2022_07_31, nil)).to be_nil
      end
    end
  end

  describe '#start_date' do
    it 'returns the start date for a due date and a duration' do
      expect(subject.start_date(monday_2022_08_01, 1)).to eq(monday_2022_08_01)
    end

    it 'raises an error if duration is 0 or negative' do
      expect { subject.start_date(monday_2022_08_01, 0) }
        .to raise_error ArgumentError, 'duration must be strictly positive'
      expect { subject.start_date(monday_2022_08_01, -10) }
        .to raise_error ArgumentError, 'duration must be strictly positive'
    end

    it 'returns nil if due_date is nil' do
      expect(subject.start_date(nil, 1)).to be_nil
    end

    it 'returns nil if duration is nil' do
      expect(subject.start_date(monday_2022_08_01, nil)).to be_nil
    end

    context 'without any week days created' do
      it 'returns the due date considering all days as working days' do
        expect(subject.start_date(monday_2022_08_01, 1)).to eq(monday_2022_08_01)
        expect(subject.start_date(monday_2022_08_01, 7)).to eq(monday_2022_08_01 - 6) # Tuesday of previous week
      end
    end

    context 'with weekend days (Saturday and Sunday)', :weekend_saturday_sunday do
      include_examples 'start_date', due_date: monday_2022_08_01, duration: 1, expected: monday_2022_08_01
      include_examples 'start_date', due_date: monday_2022_08_01, duration: 5, expected: monday_2022_08_01 - 6.days
      include_examples 'start_date', due_date: wednesday_2022_08_03, duration: 10, expected: wednesday_2022_08_03 - 13.days

      # contrived one... But can happen when date is coming from an external entity, like soonest start.
      include_examples 'start_date', due_date: saturday_2022_07_30, duration: 1, expected: friday_2022_07_29
      include_examples 'start_date', due_date: saturday_2022_07_30, duration: 2, expected: friday_2022_07_29 - 1.day
      include_examples 'start_date', due_date: saturday_2022_07_30, duration: 6, expected: friday_2022_07_29 - 7.days
    end

    context 'with some non working days (Christmas 2022-12-25 and new year\'s day 2023-01-01)', :christmas_2022_new_year_2023 do
      include_examples 'start_date', due_date: Date.new(2022, 12, 26), duration: 2, expected: Date.new(2022, 12, 24)
      include_examples 'start_date', due_date: Date.new(2023, 1, 2), duration: 8, expected: Date.new(2022, 12, 24)
    end
  end

  describe '#due_date' do
    it 'returns the due date for a start date and a duration' do
      expect(subject.due_date(monday_2022_08_01, 1)).to eq(monday_2022_08_01)
    end

    it 'raises an error if duration is 0 or negative' do
      expect { subject.due_date(monday_2022_08_01, 0) }
        .to raise_error ArgumentError, 'duration must be strictly positive'
      expect { subject.due_date(monday_2022_08_01, -10) }
        .to raise_error ArgumentError, 'duration must be strictly positive'
    end

    it 'returns nil if start_date is nil' do
      expect(subject.due_date(nil, 1)).to be_nil
    end

    it 'returns nil if duration is nil' do
      expect(subject.due_date(monday_2022_08_01, nil)).to be_nil
    end

    context 'without any week days created' do
      it 'returns the due date considering all days as working days' do
        expect(subject.due_date(monday_2022_08_01, 1)).to eq(monday_2022_08_01)
        expect(subject.due_date(monday_2022_08_01, 7)).to eq(monday_2022_08_01 + 6) # Sunday of same week
      end
    end

    context 'with weekend days (Saturday and Sunday)', :weekend_saturday_sunday do
      include_examples 'due_date', start_date: monday_2022_08_01, duration: 1, expected: monday_2022_08_01
      include_examples 'due_date', start_date: monday_2022_08_01, duration: 5, expected: monday_2022_08_01 + 4.days
      include_examples 'due_date', start_date: wednesday_2022_08_03, duration: 10, expected: wednesday_2022_08_03 + 13.days

      # contrived one... But can happen when date is coming from an external entity, like soonest start.
      include_examples 'due_date', start_date: saturday_2022_07_30, duration: 1, expected: monday_2022_08_01
      include_examples 'due_date', start_date: saturday_2022_07_30, duration: 2, expected: monday_2022_08_01 + 1.day
      include_examples 'due_date', start_date: saturday_2022_07_30, duration: 6, expected: monday_2022_08_01 + 7.days
    end

    context 'with some non working days (Christmas 2022-12-25 and new year\'s day 2023-01-01)', :christmas_2022_new_year_2023 do
      include_examples 'due_date', start_date: Date.new(2022, 12, 24), duration: 2, expected: Date.new(2022, 12, 26)
      include_examples 'due_date', start_date: Date.new(2022, 12, 24), duration: 8, expected: Date.new(2023, 1, 2)
    end
  end

  describe '#soonest_working_day' do
    it 'returns the soonest working day from the given day' do
      expect(subject.soonest_working_day(sunday_2022_07_31)).to eq(sunday_2022_07_31)
    end

    it 'returns nil if given date is nil' do
      expect(subject.soonest_working_day(nil)).to be_nil
    end

    context 'with delay' do
      it 'returns the soonest working day from the given day, after a configurable delay of working days' do
        expect(subject.soonest_working_day(sunday_2022_07_31, delay: nil)).to eq(sunday_2022_07_31)
        expect(subject.soonest_working_day(sunday_2022_07_31, delay: 0)).to eq(sunday_2022_07_31)
        expect(subject.soonest_working_day(sunday_2022_07_31, delay: 1)).to eq(monday_2022_08_01)
      end

      it 'works with big delay value like 100_000' do
        # First implementation was recursive and failed with SystemStackError: stack level too deep
        expect { subject.soonest_working_day(sunday_2022_07_31, delay: 100_000) }
          .not_to raise_error
      end
    end

    context 'with weekend days (Saturday and Sunday)', :weekend_saturday_sunday do
      include_examples 'soonest working day', date: friday_2022_07_29, expected: friday_2022_07_29
      include_examples 'soonest working day', date: saturday_2022_07_30, expected: monday_2022_08_01
      include_examples 'soonest working day', date: sunday_2022_07_31, expected: monday_2022_08_01
      include_examples 'soonest working day', date: monday_2022_08_01, expected: monday_2022_08_01

      context 'with delay' do
        include_examples 'soonest working day with delay', date: friday_2022_07_29, delay: 0, expected: friday_2022_07_29
        include_examples 'soonest working day with delay', date: saturday_2022_07_30, delay: 0, expected: monday_2022_08_01
        include_examples 'soonest working day with delay', date: sunday_2022_07_31, delay: 0, expected: monday_2022_08_01
        include_examples 'soonest working day with delay', date: monday_2022_08_01, delay: 0, expected: monday_2022_08_01

        include_examples 'soonest working day with delay', date: friday_2022_07_29, delay: 1, expected: monday_2022_08_01
        include_examples 'soonest working day with delay', date: saturday_2022_07_30, delay: 1, expected: Date.new(2022, 8, 2)
        include_examples 'soonest working day with delay', date: sunday_2022_07_31, delay: 1, expected: Date.new(2022, 8, 2)
        include_examples 'soonest working day with delay', date: monday_2022_08_01, delay: 1, expected: Date.new(2022, 8, 2)

        include_examples 'soonest working day with delay', date: friday_2022_07_29, delay: 8, expected: Date.new(2022, 8, 10)
      end
    end

    context 'with some non working days (Christmas 2022-12-25 and new year\'s day 2023-01-01)', :christmas_2022_new_year_2023 do
      include_examples 'soonest working day', date: Date.new(2022, 12, 25), expected: Date.new(2022, 12, 26)
      include_examples 'soonest working day', date: Date.new(2022, 12, 31), expected: Date.new(2022, 12, 31)
      include_examples 'soonest working day', date: Date.new(2023, 1, 1), expected: Date.new(2023, 1, 2)

      context 'with delay' do
        include_examples 'soonest working day with delay', date: Date.new(2022, 12, 24), delay: 7, expected: Date.new(2023, 1, 2)
      end
    end

    context 'with no working days', :no_working_days do
      it 'prevents looping infinitely by raising a runtime error' do
        expect { subject.soonest_working_day(sunday_2022_07_31) }
          .to raise_error(RuntimeError, 'cannot have all week days as non-working days')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module WorkPackages
  module Shared
    class AllDays
      # Returns number of days between two dates, inclusive.
      def duration(start_date, due_date)
        return nil unless start_date && due_date

        (start_date..due_date).count
      end

      def start_date(due_date, duration)
        return nil unless due_date && duration
        raise ArgumentError, 'duration must be strictly positive' if duration.is_a?(Integer) && duration <= 0

        due_date - duration + 1
      end

      def due_date(start_date, duration)
        return nil unless start_date && duration
        raise ArgumentError, 'duration must be strictly positive' if duration.is_a?(Integer) && duration <= 0

        start_date + duration - 1
      end

      def soonest_working_day(date, delay: nil)
        delay ||= 0
        date + delay.days if date
      end

      def working?(_date)
        true
      end
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'rails_helper'
require_relative 'shared_examples_days'

RSpec.describe WorkPackages::Shared::AllDays do
  subject { described_class.new }

  sunday_2022_07_31 = Date.new(2022, 7, 31)

  describe '#duration' do
    context 'without any week days created' do
      it 'considers all days as working days and returns the number of days between two dates, inclusive' do
        expect(subject.duration(sunday_2022_07_31, sunday_2022_07_31 + 6)).to eq(7)
        expect(subject.duration(sunday_2022_07_31, sunday_2022_07_31 + 50)).to eq(51)
      end
    end

    context 'with weekend days (Saturday and Sunday)', :weekend_saturday_sunday do
      it 'considers all days as working days and returns the number of days between two dates, inclusive' do
        expect(subject.duration(sunday_2022_07_31, sunday_2022_07_31 + 6)).to eq(7)
        expect(subject.duration(sunday_2022_07_31, sunday_2022_07_31 + 50)).to eq(51)
      end
    end

    context 'with some non working days (Christmas 2022-12-25 and new year\'s day 2023-01-01)', :christmas_2022_new_year_2023 do
      include_examples 'it returns duration', 365, Date.new(2022, 1, 1), Date.new(2022, 12, 31)
      include_examples 'it returns duration', 365 * 2, Date.new(2022, 1, 1), Date.new(2023, 12, 31)
    end

    context 'without start date' do
      it 'returns nil' do
        expect(subject.duration(nil, sunday_2022_07_31)).to be_nil
      end
    end

    context 'without due date' do
      it 'returns nil' do
        expect(subject.duration(sunday_2022_07_31, nil)).to be_nil
      end
    end
  end

  describe '#start_date' do
    it 'returns the start date for a due date and a duration' do
      expect(subject.start_date(sunday_2022_07_31, 1)).to eq(sunday_2022_07_31)
      expect(subject.start_date(sunday_2022_07_31 + 9.days, 10)).to eq(sunday_2022_07_31)
    end

    it 'raises an error if duration is 0 or negative' do
      expect { subject.start_date(sunday_2022_07_31, 0) }
        .to raise_error ArgumentError, 'duration must be strictly positive'
      expect { subject.start_date(sunday_2022_07_31, -10) }
        .to raise_error ArgumentError, 'duration must be strictly positive'
    end

    it 'returns nil if due_date is nil' do
      expect(subject.start_date(nil, 1)).to be_nil
    end

    it 'returns nil if duration is nil' do
      expect(subject.start_date(sunday_2022_07_31, nil)).to be_nil
    end

    context 'with weekend days (Saturday and Sunday)', :weekend_saturday_sunday do
      include_examples 'start_date', due_date: sunday_2022_07_31, duration: 1, expected: sunday_2022_07_31
      include_examples 'start_date', due_date: sunday_2022_07_31, duration: 5, expected: sunday_2022_07_31 - 4.days
      include_examples 'start_date', due_date: sunday_2022_07_31, duration: 10, expected: sunday_2022_07_31 - 9.days
    end

    context 'with some non working days (Christmas 2022-12-25 and new year\'s day 2023-01-01)', :christmas_2022_new_year_2023 do
      include_examples 'start_date', due_date: Date.new(2022, 12, 31), duration: 365, expected: Date.new(2022, 1, 1)
      include_examples 'start_date', due_date: Date.new(2023, 12, 31), duration: 365 * 2, expected: Date.new(2022, 1, 1)
    end
  end

  describe '#due_date' do
    it 'returns the due date for a start date and a duration' do
      expect(subject.due_date(sunday_2022_07_31, 1)).to eq(sunday_2022_07_31)
      expect(subject.due_date(sunday_2022_07_31, 10)).to eq(sunday_2022_07_31 + 9.days)
    end

    it 'raises an error if duration is 0 or negative' do
      expect { subject.due_date(sunday_2022_07_31, 0) }
        .to raise_error ArgumentError, 'duration must be strictly positive'
      expect { subject.due_date(sunday_2022_07_31, -10) }
        .to raise_error ArgumentError, 'duration must be strictly positive'
    end

    it 'returns nil if start_date is nil' do
      expect(subject.due_date(nil, 1)).to be_nil
    end

    it 'returns nil if duration is nil' do
      expect(subject.due_date(sunday_2022_07_31, nil)).to be_nil
    end

    context 'with weekend days (Saturday and Sunday)', :weekend_saturday_sunday do
      include_examples 'due_date', start_date: sunday_2022_07_31, duration: 1, expected: sunday_2022_07_31
      include_examples 'due_date', start_date: sunday_2022_07_31, duration: 5, expected: sunday_2022_07_31 + 4.days
      include_examples 'due_date', start_date: sunday_2022_07_31, duration: 10, expected: sunday_2022_07_31 + 9.days
    end

    context 'with some non working days (Christmas 2022-12-25 and new year\'s day 2023-01-01)', :christmas_2022_new_year_2023 do
      include_examples 'due_date', start_date: Date.new(2022, 1, 1), duration: 365, expected: Date.new(2022, 12, 31)
      include_examples 'due_date', start_date: Date.new(2022, 1, 1), duration: 365 * 2, expected: Date.new(2023, 12, 31)
    end
  end

  describe '#soonest_working_day' do
    it 'returns the given day' do
      expect(subject.soonest_working_day(sunday_2022_07_31)).to eq(sunday_2022_07_31)
    end

    it 'returns nil if given date is nil' do
      expect(subject.soonest_working_day(nil)).to be_nil
    end

    context 'with delay' do
      it 'returns the soonest working day from the given day, after a configurable delay of working days' do
        expect(subject.soonest_working_day(sunday_2022_07_31, delay: nil)).to eq(sunday_2022_07_31)
        expect(subject.soonest_working_day(sunday_2022_07_31, delay: 0)).to eq(sunday_2022_07_31)
        expect(subject.soonest_working_day(sunday_2022_07_31, delay: 1)).to eq(Date.new(2022, 8, 1))
      end
    end

    context 'with weekend days (Saturday and Sunday)', :weekend_saturday_sunday do
      it 'returns the given day' do
        expect(subject.soonest_working_day(sunday_2022_07_31)).to eq(sunday_2022_07_31)
      end

      context 'with delay' do
        include_examples 'soonest working day with delay', date: Date.new(2022, 1, 1), delay: 30, expected: Date.new(2022, 1, 31)
      end
    end

    context 'with some non working days (Christmas 2022-12-25 and new year\'s day 2023-01-01)', :christmas_2022_new_year_2023 do
      it 'returns the given day' do
        expect(subject.soonest_working_day(Date.new(2022, 12, 25))).to eq(Date.new(2022, 12, 25))
      end

      context 'with delay' do
        include_examples 'soonest working day with delay', date: Date.new(2022, 12, 24), delay: 7,
                                                           expected: Date.new(2022, 12, 31)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module WorkPackages
  module Shared
    module Days
      module_function

      # Returns the right day computation instance for the given instance.
      def for(work_package)
        work_package.ignore_non_working_days ? AllDays.new : WorkingDays.new
      end
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'rails_helper'

RSpec.describe WorkPackages::Shared::Days do
  subject { described_class.new }

  describe '.for' do
    context 'for a work_package ignoring non working days' do
      let(:work_package) { build_stubbed(:work_package, ignore_non_working_days: true) }

      it 'returns an AllDays instance' do
        expect(described_class.for(work_package)).to be_an_instance_of(WorkPackages::Shared::AllDays)
      end
    end

    context 'for a work_package respecting non working days' do
      let(:work_package) { build_stubbed(:work_package) }

      it 'returns a WorkingDays instance' do
        expect(described_class.for(work_package)).to be_an_instance_of(WorkPackages::Shared::WorkingDays)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#  OpenProject is an open source project management software.
#  Copyright (C) 2022 the OpenProject GmbH
#
#  This program is free software; you can redistribute it and/or
#  modify it under the terms of the GNU General Public License version 3.
#
#  OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
#  Copyright (C) 2006-2013 Jean-Philippe Lang
#  Copyright (C) 2010-2013 the ChiliProject Team
#
#  This program is free software; you can redistribute it and/or
#  modify it under the terms of the GNU General Public License
#  as published by the Free Software Foundation; either version 2
#  of the License, or (at your option) any later version.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
#  See COPYRIGHT and LICENSE files for more details.

class WorkPackages::UpdateAncestors::Loader
  def initialize(work_package, include_former_ancestors)
    self.work_package = work_package
    self.include_former_ancestors = include_former_ancestors
  end

  def select
    ancestors.select do |ancestor|
      yield ancestor, self
    end
  end

  def descendants_of(queried_work_package)
    @descendants ||= Hash.new do |hash, wp|
      hash[wp] = replaced_related_of(wp, :descendants)
    end

    @descendants[queried_work_package]
  end

  def leaves_of(queried_work_package)
    @leaves ||= Hash.new do |hash, wp|
      hash[wp] = replaced_related_of(wp, :leaves) do |leaf|
        # Mimic work package by implementing the closed? interface
        leaf.send(:'closed?=', leaf.is_closed)
      end
    end

    @leaves[queried_work_package]
  end

  def children_of(queried_work_package)
    @children ||= Hash.new do |hash, wp|
      hash[wp] = descendants_of(wp).select { |d| d.parent_id == wp.id }
    end

    @children[queried_work_package]
  end

  private

  attr_accessor :work_package,
                :include_former_ancestors

  # Contains both the new as well as the former ancestors in ascending order from the leaves up (breadth first).
  def ancestors
    @ancestors ||= if include_former_ancestors
                     former_ancestors.reverse.inject(current_ancestors) do |ancestors, former_ancestor|
                       index = ancestors.index { |ancestor| ancestor.id == former_ancestor.parent_id }
                       ancestors.insert(index || current_ancestors.length, former_ancestor)
                       ancestors
                     end
                   else
                     current_ancestors
                   end
  end

  # Replace descendants/leaves by ancestors if they are the same.
  # This can e.g. be the case in scenario of
  # grandparent
  #      |
  #    parent
  #      |
  # work_package
  #
  # when grandparent used to be the direct parent of work_package (the work_package moved down the hierarchy).
  # Then grandparent and parent are already in ancestors.
  # Parent might be modified during the UpdateAncestorsService run,
  # and the descendants of grandparent need to have the updated value.
  def replaced_related_of(queried_work_package, relation_type)
    related_of(queried_work_package, relation_type).map do |leaf|
      if work_package.id == leaf.id
        work_package
      elsif (ancestor = ancestors.detect { |a| a.id == leaf.id })
        ancestor
      else
        yield leaf if block_given?
        leaf
      end
    end
  end

  def related_of(queried_work_package, relation_type)
    scope = queried_work_package
              .send(relation_type)
              .where.not(id: queried_work_package.id)

    if send(""#{relation_type}_joins"")
      scope = scope.joins(send(""#{relation_type}_joins""))
    end

    scope
      .pluck(*send(""selected_#{relation_type}_attributes""))
      .map { |p| LoaderStruct.new(send(""selected_#{relation_type}_attributes"").zip(p).to_h) }
  end

  # Returns the current ancestors sorted by distance (called generations in the table)
  # so the order is parent, grandparent, ..., root.
  def current_ancestors
    @current_ancestors ||= work_package.ancestors.includes(:status).where.not(id: former_ancestors.map(&:id)).to_a
  end

  # Returns the former ancestors sorted by distance (called generations in the table)
  # so the order is former parent, former grandparent, ..., former root.
  def former_ancestors
    @former_ancestors ||= if previous_parent_id && include_former_ancestors
                            parent = WorkPackage.find(previous_parent_id)

                            [parent] + parent.ancestors
                          else
                            []
                          end
  end

  def selected_descendants_attributes
    # By having the id in here, we can avoid DISTINCT queries squashing duplicate values
    %i(id estimated_hours parent_id schedule_manually ignore_non_working_days)
  end

  def descendants_joins
    nil
  end

  def selected_leaves_attributes
    %i(id done_ratio derived_estimated_hours estimated_hours is_closed)
  end

  def leaves_joins
    :status
  end

  ##
  # Get the previous parent ID
  # This could either be +parent_id_was+ if parent was changed
  # (when work_package was saved/destroyed)
  # Or the set parent before saving
  def previous_parent_id
    if work_package.parent_id.nil? && work_package.parent_id_was
      work_package.parent_id_was
    else
      previous_change_parent_id
    end
  end

  def previous_change_parent_id
    previous = work_package.previous_changes

    previous_parent_changes = (previous[:parent_id] || previous[:parent])

    previous_parent_changes ? previous_parent_changes.first : nil
  end

  class LoaderStruct < Hashie::Mash; end
  LoaderStruct.disable_warnings
end

```","#  OpenProject is an open source project management software.
#  Copyright (C) 2010-2022 the OpenProject GmbH
#
#  This program is free software; you can redistribute it and/or
#  modify it under the terms of the GNU General Public License version 3.
#
#  OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
#  Copyright (C) 2006-2013 Jean-Philippe Lang
#  Copyright (C) 2010-2013 the ChiliProject Team
#
#  This program is free software; you can redistribute it and/or
#  modify it under the terms of the GNU General Public License
#  as published by the Free Software Foundation; either version 2
#  of the License, or (at your option) any later version.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
#  See COPYRIGHT and LICENSE files for more details.

require 'spec_helper'

RSpec.describe WorkPackages::UpdateAncestors::Loader, type: :model do
  shared_let(:grandgrandparent) do
    create(:work_package)
  end
  shared_let(:grandparent_sibling) do
    create(:work_package,
           parent: grandgrandparent)
  end
  shared_let(:grandparent) do
    create(:work_package,
           parent: grandgrandparent)
  end
  shared_let(:parent) do
    create(:work_package,
           parent: grandparent)
  end
  shared_let(:sibling) do
    create(:work_package,
           parent:)
  end
  shared_let(:work_package) do
    create(:work_package,
           parent:)
  end
  shared_let(:child) do
    create(:work_package,
           parent: work_package)
  end

  let(:include_former_ancestors) { true }

  let(:instance) do
    described_class
      .new(work_package, include_former_ancestors)
  end

  describe '#select' do
    subject do
      work_package.parent = new_parent
      work_package.save!

      instance
    end

    context 'when switching the hierarchy' do
      let!(:new_grandgrandparent) do
        create(:work_package,
               subject: 'new grandgrandparent')
      end
      let!(:new_grandparent) do
        create(:work_package,
               parent: new_grandgrandparent,
               subject: 'new grandparent')
      end
      let!(:new_parent) do
        create(:work_package,
               subject: 'new parent',
               parent: new_grandparent)
      end
      let!(:new_sibling) do
        create(:work_package,
               subject: 'new sibling',
               parent: new_parent)
      end

      it 'iterates over both current and former ancestors' do
        expect(subject.select { |ancestor| ancestor })
          .to eql [new_parent, new_grandparent, new_grandgrandparent, parent, grandparent, grandgrandparent]
      end
    end

    context 'when switching the hierarchy and not including the former ancestors' do
      let!(:new_grandgrandparent) do
        create(:work_package,
               subject: 'new grandgrandparent')
      end
      let!(:new_grandparent) do
        create(:work_package,
               parent: new_grandgrandparent,
               subject: 'new grandparent')
      end
      let!(:new_parent) do
        create(:work_package,
               subject: 'new parent',
               parent: new_grandparent)
      end
      let!(:new_sibling) do
        create(:work_package,
               subject: 'new sibling',
               parent: new_parent)
      end

      let(:include_former_ancestors) { false }

      it 'iterates over the current ancestors' do
        expect(subject.select { |ancestor| ancestor })
          .to eql [new_parent, new_grandparent, new_grandgrandparent]
      end
    end

    context 'when removing the parent' do
      let(:new_parent) { nil }

      it 'iterates over the former ancestors' do
        expect(subject.select { |ancestor| ancestor })
          .to eql [parent, grandparent, grandgrandparent]
      end
    end

    context 'when removing the parent and not including the former ancestors' do
      let(:new_parent) { nil }
      let(:include_former_ancestors) { false }

      it 'loads nothing' do
        expect(subject.select { |ancestor| ancestor })
          .to be_empty
      end
    end

    context 'when changing the parent within the same hierarchy upwards' do
      let(:new_parent) { grandgrandparent }

      it 'iterates over the former ancestors' do
        expect(subject.select { |ancestor| ancestor })
          .to eql [parent, grandparent, grandgrandparent]
      end
    end

    context 'when changing the parent within the same hierarchy upwards and not loading former ancestors' do
      let(:new_parent) { grandgrandparent }
      let(:include_former_ancestors) { false }

      it 'iterates over the current ancestors' do
        expect(subject.select { |ancestor| ancestor })
          .to eql [grandgrandparent]
      end
    end

    context 'when changing the parent within the same hierarchy sideways' do
      let(:new_parent) { sibling }

      it 'iterates over the current ancestors' do
        expect(subject.select { |ancestor| ancestor })
          .to eql [sibling, parent, grandparent, grandgrandparent]
      end
    end

    context 'when changing the parent within the same hierarchy sideways and not loading former ancestors' do
      let(:new_parent) { sibling }
      let(:include_former_ancestors) { false }

      it 'iterates over the current ancestors' do
        expect(subject.select { |ancestor| ancestor })
          .to eql [sibling, parent, grandparent, grandgrandparent]
      end
    end

    context 'when changing the parent within the same hierarchy sideways but to a different level' do
      let(:new_parent) { grandparent_sibling }

      it 'iterates over the former and the current ancestors' do
        expect(subject.select { |ancestor| ancestor })
          .to eql [grandparent_sibling, parent, grandparent, grandgrandparent]
      end
    end

    context 'when changing the parent within the same hierarchy sideways but to a different level and not loading ancestors' do
      let(:new_parent) { grandparent_sibling }
      let(:include_former_ancestors) { false }

      it 'iterates over the former and the current ancestors' do
        expect(subject.select { |ancestor| ancestor })
          .to eql [grandparent_sibling, grandgrandparent]
      end
    end
  end

  describe '#descendants_of' do
    def descendants_of_hash(hashed_work_package)
      { ""estimated_hours"" => nil,
        ""id"" => hashed_work_package.id,
        ""ignore_non_working_days"" => false,
        ""parent_id"" => hashed_work_package.parent_id,
        ""remaining_hours"" => nil,
        ""schedule_manually"" => false }
    end

    context 'for the work_package' do
      it 'is its child (as a hash)' do
        expect(instance.descendants_of(work_package))
          .to match_array([descendants_of_hash(child)])
      end
    end

    context 'for the parent' do
      it 'is the work package, its child (as a hash) and its sibling (as a hash)' do
        expect(instance.descendants_of(parent))
          .to match_array([descendants_of_hash(child),
                           work_package,
                           descendants_of_hash(sibling)])
      end
    end

    context 'for the grandparent' do
      it 'is the parent, the work package, its child (as a hash) and its sibling (as a hash)' do
        expect(instance.descendants_of(grandparent))
          .to match_array([parent,
                           work_package,
                           descendants_of_hash(child),
                           descendants_of_hash(sibling)])
      end
    end

    context 'for the grandgrandparent (the root)' do
      it 'is the complete tree, partly as a hash and partly as the preloaded work packages' do
        expect(instance.descendants_of(grandgrandparent))
          .to match_array([descendants_of_hash(grandparent_sibling),
                           grandparent,
                           parent,
                           work_package,
                           descendants_of_hash(child),
                           descendants_of_hash(sibling)])
      end
    end
  end

  describe '#children_of' do
    def children_of_hash(hashed_work_package)
      { ""estimated_hours"" => nil,
        ""id"" => hashed_work_package.id,
        ""ignore_non_working_days"" => false,
        ""parent_id"" => hashed_work_package.parent_id,
        ""remaining_hours"" => nil,
        ""schedule_manually"" => false }
    end

    context 'for the work_package' do
      it 'is its child (as a hash)' do
        expect(instance.children_of(work_package))
          .to match_array([children_of_hash(child)])
      end
    end

    context 'for the parent' do
      it 'is the work package and its sibling (as a hash)' do
        expect(instance.children_of(parent))
          .to match_array([work_package,
                           children_of_hash(sibling)])
      end
    end

    context 'for the grandparent' do
      it 'is the parent' do
        expect(instance.children_of(grandparent))
          .to match_array([parent])
      end
    end

    context 'for the grandgrandparent' do
      it 'is the grandparent and its sibling (as a hash)' do
        expect(instance.children_of(grandgrandparent))
          .to match_array([children_of_hash(grandparent_sibling),
                           grandparent])
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module Projects
  class SetAttributesService < ::BaseServices::SetAttributes
    private

    def set_attributes(params)
      ret = super(params.except(:status_code))

      set_status_code(params[:status_code]) if status_code_provided?(params)

      ret
    end

    def set_default_attributes(attributes)
      attribute_keys = attributes.keys.map(&:to_s)

      set_default_public(attribute_keys.include?('public'))
      set_default_module_names(attribute_keys.include?('enabled_module_names'))
      set_default_types(attribute_keys.include?('types') || attribute_keys.include?('type_ids'))
      set_default_active_work_package_custom_fields(attribute_keys.include?('work_package_custom_fields'))
    end

    def set_default_public(provided)
      model.public = Setting.default_projects_public? unless provided
    end

    def set_default_module_names(provided)
      model.enabled_module_names = Setting.default_projects_modules if !provided && model.enabled_module_names.empty?
    end

    def set_default_types(provided)
      model.types = ::Type.default if !provided && model.types.empty?
    end

    def set_default_active_work_package_custom_fields(provided)
      return if provided

      model.work_package_custom_fields = WorkPackageCustomField
        .joins(:types)
        .where(types: { id: model.type_ids })
        .distinct
    end

    def status_code_provided?(params)
      params.key?(:status_code)
    end

    def set_status_code(status_code)
      if faulty_code?(status_code)
        # set an arbitrary status code first to get rails internal into correct state
        model.status_code = first_not_set_code
        # hack into rails internals to set faulty code
        code_attributes = model.instance_variable_get(:@attributes)['status_code']
        code_attributes.instance_variable_set(:@value_before_type_cast, status_code)
        code_attributes.instance_variable_set(:@value, status_code)
      else
        model.status_code = status_code
      end
    end

    def faulty_code?(status_code)
      status_code && Project.status_codes.keys.exclude?(status_code.to_s)
    end

    def first_not_set_code
      (Project.status_codes.keys - [model.status_code]).first
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Projects::SetAttributesService, type: :model do
  let(:user) { build_stubbed(:user) }
  let(:contract_class) do
    contract = class_double(Projects::CreateContract)

    allow(contract)
      .to receive(:new)
      .with(project, user, options: {})
      .and_return(contract_instance)

    contract
  end
  let(:contract_instance) do
    instance_double(Projects::CreateContract, validate: contract_valid, errors: contract_errors)
  end
  let(:contract_valid) { true }
  let(:contract_errors) do
    instance_double(ActiveModel::Errors)
  end
  let(:project_valid) { true }
  let(:instance) do
    described_class.new(user:,
                        model: project,
                        contract_class:)
  end
  let(:call_attributes) { {} }
  let(:project) do
    build_stubbed(:project)
  end

  describe 'call' do
    let(:call_attributes) do
      {}
    end

    before do
      allow(project)
        .to receive(:valid?)
        .and_return(project_valid)

      allow(contract_instance)
        .to receive(:validate)
        .and_return(contract_valid)
    end

    subject { instance.call(call_attributes) }

    it 'is successful' do
      expect(subject).to be_success
    end

    it 'calls validation' do
      subject

      expect(contract_instance)
        .to have_received(:validate)
    end

    it 'sets the attributes' do
      subject

      expect(project.attributes.slice(*project.changed).symbolize_keys)
        .to eql call_attributes
    end

    it 'does not persist the project' do
      allow(project)
        .to receive(:save)

      subject

      expect(project)
        .not_to have_received(:save)
    end

    shared_examples 'setting status attributes' do
      let(:status_explanation) { 'A magic dwells in each beginning.' }

      it 'sets the project status code' do
        expect(subject.result.status_code)
          .to eq status_code
      end

      it 'sets the project status explanation' do
        expect(subject.result.status_explanation)
          .to eq status_explanation
      end
    end

    context 'for a new record' do
      let(:project) do
        Project.new
      end

      describe 'identifier default value' do
        context 'with an identifier provided' do
          let(:call_attributes) do
            {
              identifier: 'lorem'
            }
          end

          it 'does not alter the identifier' do
            expect(subject.result.identifier)
              .to eql 'lorem'
          end
        end

        context 'with no identifier provided' do
          it 'stays nil' do
            allow(Project)
              .to receive(:next_identifier)
              .and_return('ipsum')

            expect(subject.result.identifier)
              .to be_nil
          end
        end
      end

      describe 'public default value', with_settings: { default_projects_public: true } do
        context 'with a value for is_public provided' do
          let(:call_attributes) do
            {
              public: false
            }
          end

          it 'does not alter the public value' do
            expect(subject.result)
              .not_to be_public
          end
        end

        context 'with no value for public provided' do
          it 'sets uses the default value' do
            expect(subject.result)
              .to be_public
          end
        end
      end

      describe 'enabled_module_names default value', with_settings: { default_projects_modules: ['lorem', 'ipsum'] } do
        context 'with a value for enabled_module_names provided' do
          let(:call_attributes) do
            {
              enabled_module_names: %w(some other)
            }
          end

          it 'does not alter the enabled modules' do
            expect(subject.result.enabled_module_names)
              .to match_array %w(some other)
          end
        end

        context 'with no value for enabled_module_names provided' do
          it 'sets a default enabled modules' do
            expect(subject.result.enabled_module_names)
              .to match_array %w(lorem ipsum)
          end
        end

        context 'with the enabled modules being set before' do
          before do
            project.enabled_module_names = %w(some other)
          end

          it 'does not alter the enabled modules' do
            expect(subject.result.enabled_module_names)
              .to match_array %w(some other)
          end
        end
      end

      describe 'types default value' do
        let(:other_types) do
          [build_stubbed(:type)]
        end
        let(:default_types) do
          [build_stubbed(:type)]
        end

        before do
          allow(Type)
            .to receive(:default)
                  .and_return default_types
        end

        shared_examples ""setting custom field defaults"" do
          context 'with custom fields' do
            let!(:custom_field) { create(:text_wp_custom_field, types:) }
            let!(:custom_field_with_no_type) { create(:text_wp_custom_field) }

            it 'activates the type\'s custom fields' do
              expect(subject.result.work_package_custom_fields)
                .to eq([custom_field])
            end
          end
        end

        context 'with a value for types provided' do
          let(:call_attributes) do
            {
              types: other_types
            }
          end

          it 'does not alter the types' do
            expect(subject.result.types)
              .to match_array other_types
          end

          include_examples ""setting custom field defaults"" do
            let(:other_types) { [create(:type)] }
            let(:types) { other_types }
          end
        end

        context 'with no value for types provided' do
          it 'sets the default types' do
            expect(subject.result.types)
              .to match_array default_types
          end

          include_examples ""setting custom field defaults"" do
            let(:default_types) { [create(:type)] }
            let(:types) { default_types }
          end
        end

        context 'with the types being set before' do
          let(:types) { [build(:type, name: 'lorem')] }

          before do
            project.types = types
          end

          it 'does not alter the types modules' do
            expect(subject.result.types.map(&:name))
              .to match_array %w(lorem)
          end

          include_examples ""setting custom field defaults"" do
            let(:types) { [create(:type, name: 'lorem')] }
          end
        end
      end

      describe 'project status' do
        context 'with valid status attributes' do
          let(:status_code) { 'on_track' }
          let(:call_attributes) do
            {
              status_code:,
              status_explanation:
            }
          end

          include_examples 'setting status attributes'
        end

        context 'with an invalid status code provided' do
          let(:status_code) { 'wrong' }
          let(:call_attributes) do
            {
              status_code:,
              status_explanation:
            }
          end

          include_examples 'setting status attributes'
        end
      end
    end

    context 'for an existing project' do
      describe 'project status' do
        let(:project) do
          build_stubbed(:project, :with_status)
        end

        context 'with a value provided' do
          let(:status_code) { 'at_risk' }
          let(:status_explanation) { 'Still some magic there.' }
          let(:call_attributes) do
            {
              status_code:,
              status_explanation:
            }
          end

          include_examples 'setting status attributes'
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module Projects
  class ArchiveService < ::BaseServices::BaseContracted
    include Contracted
    include Projects::Concerns::UpdateDemoData

    def initialize(user:, model:, contract_class: Projects::ArchiveContract)
      super(user:, contract_class:)
      self.model = model
    end

    private

    def persist(service_call)
      archive_project(model) and model.active_subprojects.each do |subproject|
        archive_project(subproject)
      end

      service_call
    end

    def after_perform(service_call)
      OpenProject::Notifications.send(OpenProject::Events::PROJECT_ARCHIVED, project: model)
      service_call
    end

    def archive_project(project)
      # We do not care for validations but want the timestamps to be updated
      project.update_attribute(:active, false)
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Projects::ArchiveService do
  let(:project) { create(:project) }
  let(:subproject1) { create(:project) }
  let(:subproject2) { create(:project) }
  let(:subproject3) { create(:project) }
  let(:user) { create(:admin) }
  let(:instance) { described_class.new(user:, model: project) }

  it 'sends the notification' do
    allow(OpenProject::Notifications).to receive(:send)

    expect(instance.call).to be_truthy

    expect(OpenProject::Notifications)
      .to(have_received(:send)
            .with(OpenProject::Events::PROJECT_ARCHIVED, project:))
    expect(OpenProject::Notifications)
      .to(have_received(:send)
            .with(OpenProject::Events::PROJECT_ARCHIVED, project:))
  end

  context 'with project without any subprojects' do
    it 'archives the project' do
      expect(project.reload).not_to be_archived

      expect(instance.call).to be_truthy
      expect(project.reload).to be_archived
    end
  end

  context 'with project having subprojects' do
    before do
      project.update(children: [subproject1, subproject2, subproject3])
      project.reload
    end

    shared_examples 'when archiving a project' do
      it 'archives the project' do
        # Baseline verification.
        expect(project.reload).not_to be_archived

        # Action.
        expect(instance.call).to be_truthy

        # Endline verification.
        expect(project.reload).to be_archived
      end

      it 'archives all the subprojects' do
        # Baseline verification.
        expect(subproject1.reload).not_to be_archived
        expect(subproject2.reload).not_to be_archived
        expect(subproject3.reload).not_to be_archived

        # Action.
        expect(instance.call).to be_truthy

        # Endline verification.
        expect(subproject1.reload).to be_archived
        expect(subproject2.reload).to be_archived
        expect(subproject3.reload).to be_archived
      end
    end

    include_examples 'when archiving a project'

    context 'with deep nesting' do
      before do
        project.update(children: [subproject1])
        subproject1.update(children: [subproject2])
        subproject2.update(children: [subproject3])
        project.reload
        subproject1.reload
      end

      include_examples 'when archiving a project'
    end
  end

  context 'with project having an archived subproject' do
    let(:subproject1) { create(:project, active: false) }

    before do
      project.update(children: [subproject1, subproject2, subproject3])
      project.reload
    end

    context 'while archiving the project' do
      it 'does not change timestamp of the already archived subproject' do
        expect(subproject1.reload).to be_archived
        before_timestamp = subproject1.updated_at

        expect(instance.call).to be_truthy

        after_timestamp = subproject1.reload.updated_at
        expect(before_timestamp).to eq(after_timestamp)
      end

      it 'changes timestamp of the active subproject' do
        expect(subproject2.reload).not_to be_archived
        before_timestamp = subproject2.updated_at

        expect(instance.call).to be_truthy

        after_timestamp = subproject2.reload.updated_at
        expect(before_timestamp).not_to eq(after_timestamp)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module Projects
  class UnarchiveService < ::BaseServices::BaseContracted
    include Contracted
    include Projects::Concerns::UpdateDemoData

    def initialize(user:, model:, contract_class: Projects::UnarchiveContract)
      super(user:, contract_class:)
      self.model = model
    end

    private

    def persist(service_call)
      activate_project(model)

      service_call
    end

    def after_perform(service_call)
      OpenProject::Notifications.send(OpenProject::Events::PROJECT_UNARCHIVED, project: model)
      service_call
    end

    def activate_project(project)
      # We do not care for validations but want the timestamps to be updated
      project.update_attribute(:active, true)
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Projects::UnarchiveService do
  let(:project) { create(:project, active: false) }
  let(:user) { create(:admin) }
  let(:instance) { described_class.new(user:, model: project) }

  it 'unarchives and sends the notification' do
    allow(OpenProject::Notifications).to receive(:send)
    expect(project.active).to be(false)

    expect(instance.call).to be_truthy

    expect(project.active).to be(true)
    expect(OpenProject::Notifications)
      .to(have_received(:send)
            .with(OpenProject::Events::PROJECT_UNARCHIVED, project:))
    expect(OpenProject::Notifications)
      .to(have_received(:send)
            .with(OpenProject::Events::PROJECT_UNARCHIVED, project:))
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module Projects
  class UpdateService < ::BaseServices::Update
    private

    attr_accessor :memoized_changes

    def set_attributes(params)
      ret = super

      # Because awesome_nested_set reloads the model after saving, we cannot rely
      # on saved_changes.
      self.memoized_changes = model.changes

      ret
    end

    def after_perform(service_call)
      touch_on_custom_values_update
      notify_on_identifier_renamed
      send_update_notification
      update_wp_versions_on_parent_change
      handle_archiving

      service_call
    end

    def touch_on_custom_values_update
      model.touch if only_custom_values_updated?
    end

    def notify_on_identifier_renamed
      return unless memoized_changes['identifier']

      OpenProject::Notifications.send(OpenProject::Events::PROJECT_RENAMED, project: model)
    end

    def send_update_notification
      OpenProject::Notifications.send(OpenProject::Events::PROJECT_UPDATED, project: model)
    end

    def only_custom_values_updated?
      !model.saved_changes? && model.custom_values.any?(&:saved_changes?)
    end

    def update_wp_versions_on_parent_change
      return unless memoized_changes['parent_id']

      WorkPackage.update_versions_from_hierarchy_change(model)
    end

    def handle_archiving
      return unless model.saved_change_to_active?

      service_class =
        if model.active?
          # was unarchived
          Projects::UnarchiveService
        else
          # was archived
          Projects::ArchiveService
        end

      # EmptyContract is used because archive/unarchive conditions have
      # already been checked in Projects::UpdateContract
      service = service_class.new(user:, model:, contract_class: EmptyContract)
      service.call
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'
require 'services/base_services/behaves_like_update_service'

RSpec.describe Projects::UpdateService, type: :model do
  it_behaves_like 'BaseServices update service' do
    let!(:model_instance) do
      build_stubbed(:project, :with_status)
    end

    it 'sends an update notification' do
      expect(OpenProject::Notifications)
        .to(receive(:send))
        .with(OpenProject::Events::PROJECT_UPDATED, project: model_instance)

      subject
    end

    context 'if the identifier is altered' do
      let(:call_attributes) { { identifier: 'Some identifier' } }

      before do
        allow(model_instance)
          .to(receive(:changes))
          .and_return('identifier' => %w(lorem ipsum))
      end

      it 'sends the notification' do
        expect(OpenProject::Notifications)
          .to(receive(:send))
          .with(OpenProject::Events::PROJECT_UPDATED, project: model_instance)
        expect(OpenProject::Notifications)
          .to(receive(:send))
          .with(OpenProject::Events::PROJECT_RENAMED, project: model_instance)

        subject
      end
    end

    context 'if the parent is altered' do
      before do
        allow(model_instance)
          .to(receive(:changes))
          .and_return('parent_id' => [nil, 5])
      end

      it 'updates the versions associated with the work packages' do
        expect(WorkPackage)
          .to(receive(:update_versions_from_hierarchy_change))
          .with(model_instance)

        subject
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

##
# Schedules the deletion of a project if allowed. As the deletion can be
# a lengthy process, the project is archived first
#
module Projects
  class ScheduleDeletionService < ::BaseServices::BaseContracted
    def initialize(user:, model:, contract_class: ::Projects::DeleteContract)
      super(user:, contract_class:)
      self.model = model
    end

    private

    def before_perform(_params, service_result)
      return service_result if model.archived?

      Projects::ArchiveService
        .new(user:, model:)
        .call
    end

    def persist(call)
      DeleteProjectJob.perform_later(user:, project: model)
      call
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Projects::ScheduleDeletionService, type: :model do
  let(:contract_class) do
    contract = double('contract_class', '<=': true)

    allow(contract)
      .to receive(:new)
      .with(project, user, options: {})
      .and_return(contract_instance)

    contract
  end
  let(:contract_instance) do
    double('contract_instance', validate: contract_valid, errors: contract_errors)
  end
  let(:contract_valid) { true }
  let(:contract_errors) do
    double('contract_errors')
  end
  let(:project_valid) { true }
  let(:project) { build_stubbed(:project) }
  let(:instance) do
    described_class.new(user:,
                        model: project,
                        contract_class:)
  end
  let(:archive_success) do
    true
  end
  let(:archive_errors) do
    double('archive_errors')
  end
  let(:archive_result) do
    ServiceResult.new result: project,
                      success: archive_success,
                      errors: archive_errors
  end
  let!(:archive_service) do
    service = double('archive_service_instance')

    allow(Projects::ArchiveService)
      .to receive(:new)
      .with(user:,
            model: project)
      .and_return(service)

    allow(service)
      .to receive(:call)
      .and_return(archive_result)

    service
  end
  let(:user) { build_stubbed(:admin) }

  subject { instance.call }

  before do
    allow(Projects::DeleteProjectJob)
      .to receive(:perform_later)
  end

  context 'if contract and archiving are successful' do
    it 'archives the project and creates a delayed job' do
      expect(subject).to be_success

      expect(archive_service)
        .to have_received(:call)

      expect(Projects::DeleteProjectJob)
        .to have_received(:perform_later)
        .with(user:, project:)
    end
  end

  context 'if project is archived already' do
    let(:project) { build_stubbed(:project, active: false) }

    it 'does not call archive service' do
      expect(subject).to be_success

      expect(archive_service)
        .not_to have_received(:call)

      expect(Projects::DeleteProjectJob)
        .to have_received(:perform_later)
        .with(user:, project:)
    end
  end

  context 'if contract fails' do
    let(:contract_valid) { false }

    it 'is failure' do
      expect(subject).to be_failure
    end

    it 'returns the contract errors' do
      expect(subject.errors)
        .to eql contract_errors
    end

    it 'does not schedule a job' do
      expect(Projects::DeleteProjectJob)
        .not_to receive(:new)

      subject
    end
  end

  context 'if archiving fails' do
    let(:archive_success) { false }

    it 'is failure' do
      expect(subject).to be_failure
    end

    it 'returns the contract errors' do
      expect(subject.errors)
        .to eql archive_errors
    end

    it 'does not schedule a job' do
      expect(Projects::DeleteProjectJob)
        .not_to receive(:new)

      subject
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module Projects
  class CreateService < ::BaseServices::Create
    include Projects::Concerns::NewProjectService
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'
require 'services/base_services/behaves_like_create_service'

RSpec.describe Projects::CreateService, type: :model do
  it_behaves_like 'BaseServices create service' do
    let(:new_project_role) { build_stubbed(:project_role) }
    let(:create_member_instance) { instance_double(Members::CreateService) }

    before do
      allow(ProjectRole)
        .to(receive(:in_new_project))
        .and_return(new_project_role)

      allow(Members::CreateService)
        .to(receive(:new))
        .with(user:, contract_class: EmptyContract)
        .and_return(create_member_instance)

      allow(create_member_instance)
        .to(receive(:call))
    end

    it 'adds the current user to the project' do
      subject

      expect(create_member_instance)
        .to have_received(:call)
        .with(principal: user,
              project: model_instance,
              roles: [new_project_role])
    end

    context 'current user is admin' do
      it 'does not add the user to the project' do
        allow(user)
          .to(receive(:admin?))
          .and_return(true)

        subject

        expect(create_member_instance)
          .not_to(have_received(:call))
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module Projects
  class DeleteService < ::BaseServices::Delete
    include Projects::Concerns::UpdateDemoData

    ##
    # Reference to the dependent projects that we're deleting
    attr_accessor :dependent_projects

    def initialize(user:, model:, contract_class: nil, contract_options: {})
      self.dependent_projects = model.descendants.to_a # Store an Array instead of a Project::ActiveRecord_Relation

      super
    end

    def call(*)
      super.tap do |service_call|
        notify(service_call.success?)
      end
    end

    private

    def before_perform(*)
      OpenProject::Notifications.send(:project_deletion_imminent, project: @project_to_destroy)

      delete_all_members
      destroy_all_work_packages
      destroy_all_storages

      super
    end

    # Deletes all project's members
    def delete_all_members
      MemberRole
        .includes(:member)
        .where(members: { project_id: model.id })
        .delete_all

      Member.where(project_id: model.id).destroy_all
    end

    def destroy_all_work_packages
      model.work_packages.each do |wp|
        wp.reload
        wp.destroy
      rescue ActiveRecord::RecordNotFound
        # Everything fine, we wanted to delete it anyway
      end
    end

    def destroy_all_storages
      model.project_storages.map do |project_storage|
        Storages::ProjectStorages::DeleteService.new(user:, model: project_storage).call
      end
    end

    def notify(success)
      if success
        ProjectMailer.delete_project_completed(model, user:, dependent_projects:).deliver_now
      else
        ProjectMailer.delete_project_failed(model, user:).deliver_now
      end
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Projects::DeleteService, type: :model do
  shared_let(:user) { create(:admin) }
  let(:project) { create(:project) }

  let(:instance) { described_class.new(user:, model: project) }

  subject { instance.call }

  context 'if authorized' do
    context 'when destroy succeeds' do
      it 'destroys the projects' do
        allow(project).to receive(:archive)
        allow(Projects::DeleteProjectJob).to receive(:new)

        expect { subject }.to change(Project, :count).by(-1)
        expect(project).not_to have_received(:archive)
        expect(Projects::DeleteProjectJob)
          .not_to have_received(:new)
      end

      context 'when the file storages are involved', webmock: true do
        it 'removes any remote storages defined for the project' do
          storage = create(:nextcloud_storage)
          project_storage = create(:project_storage, project:, storage:)
          work_package = create(:work_package, project:)
          create(:file_link, container: work_package, storage:)
          delete_folder_url =
            ""#{storage.host}/remote.php/dav/files/#{storage.username}/#{project_storage.project_folder_path.chop}/""

          stub_request(:delete, delete_folder_url).to_return(status: 204, body: nil, headers: {})

          expect { subject }.to change(Storages::ProjectStorage, :count).by(-1)
        end
      end

      it 'sends a success mail' do
        expect(subject).to be_success
        ActionMailer::Base.deliveries.last.tap do |mail|
          expect(mail.subject).to eq(I18n.t('projects.delete.completed', name: project.name))
          text_part = mail.text_part.to_s
          html_part = mail.html_part.to_s

          expect(text_part).to include(project.name)
          expect(html_part).to include(project.name)
        end
      end

      context 'with a hierarchy of projects' do
        let!(:children) { create_list(:project, 2, parent: project) }
        let!(:grand_children) { create_list(:project, 2, parent: children.first) }
        let(:all_children) { children + grand_children }

        before do
          project.reload
        end

        it 'destroys the projects' do
          expect { subject }.to change(Project, :count).by(-5)
        end

        it 'sends a success mail mentioning all the child projects' do
          expect { subject }.to change(ActionMailer::Base.deliveries, :size).by(1)

          ActionMailer::Base.deliveries.last.tap do |mail|
            expect(mail.subject).to eq(I18n.t('projects.delete.completed', name: project.name))
            text_part = mail.text_part.to_s
            html_part = mail.html_part.to_s

            all_children.each do |child|
              expect(text_part).to include(child.name)
              expect(html_part).to include(child.name)
            end
          end
        end
      end
    end

    it 'sends a message on destroy failure' do
      expect(project).to receive(:destroy).and_return false

      expect(ProjectMailer)
        .to receive_message_chain(:delete_project_failed, :deliver_now)

      expect(Projects::DeleteProjectJob)
        .not_to receive(:new)

      expect(subject).to be_failure
    end
  end

  context 'if not authorized' do
    let(:user) { build_stubbed(:user) }

    it 'returns an error' do
      allow(Projects::DeleteProjectJob).to receive(:new)

      expect(subject).to be_failure
      expect(Projects::DeleteProjectJob).not_to have_received(:new)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module Projects
  class GanttQueryGeneratorService
    DEFAULT_GANTT_QUERY ||=
      {
        c: %w[type id subject status],
        tll: '{""left"":""startDate"",""right"":""dueDate"",""farRight"":null}',
        tzl: ""auto"",
        tv: true,
        hi: false,
        g: ""project""
      }.to_json.freeze

    attr_reader :selected_project_ids

    class << self
      ##
      # Returns the current query or the default one if none was saved
      def current_query
        Setting.project_gantt_query.presence || default_gantt_query
      end

      def default_gantt_query
        default_with_filter = JSON
                              .parse(Projects::GanttQueryGeneratorService::DEFAULT_GANTT_QUERY)

        milestone_ids = Type.milestone.pluck(:id).map(&:to_s)
        if milestone_ids.any?
          default_with_filter.merge!('f' => [{ 'n' => 'type', 'o' => '=', 'v' => milestone_ids }])
        end

        JSON.dump(default_with_filter)
      end
    end

    def initialize(selected_project_ids)
      @selected_project_ids = selected_project_ids
    end

    def call
      # Read the raw query_props from the settings (filters and columns still serialized)
      params = params_from_settings.dup

      # Delete the parent filter
      params['f'] =
        if params['f']
          params['f'].reject { |filter| filter['n'] == 'project' }
        else
          []
        end

      # Ensure grouped by project
      params['g'] = 'project'
      params['hi'] = false

      # Ensure timeline visible
      params['tv'] = true

      # Add the parent filter
      params['f'] << { 'n' => 'project', 'o' => '=', 'v' => selected_project_ids }

      params.to_json
    end

    private

    def params_from_settings
      JSON.parse(self.class.current_query)
    rescue JSON::JSONError => e
      Rails.logger.error ""Failed to read project gantt view, resetting to default. Error was: #{e.message}""
      Setting.project_gantt_query = self.class.default_gantt_query

      JSON.parse(self.class.default_gantt_query)
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Projects::GanttQueryGeneratorService, type: :model do
  let(:selected) { %w[1 2 3] }
  let(:instance) { described_class.new selected }
  let(:subject) { instance.call }
  let(:json) { JSON.parse(subject) }
  let(:milestone_ids) { [123, 234] }
  let(:default_json) do
    scope = double('scope')
    allow(Type)
      .to receive(:milestone)
      .and_return(scope)

    allow(scope)
      .to receive(:pluck)
      .with(:id)
      .and_return(milestone_ids)

    JSON
      .parse(Projects::GanttQueryGeneratorService::DEFAULT_GANTT_QUERY)
      .merge('f' => [{ 'n' => 'type', 'o' => '=', 'v' => milestone_ids.map(&:to_s) }])
  end

  def build_project_filter(ids)
    { 'n' => 'project', 'o' => '=', 'v' => ids }
  end

  context 'with empty setting' do
    before do
      Setting.project_gantt_query = ''
    end

    it 'uses the default' do
      expected = default_json.deep_dup
      expected['f'] << build_project_filter(selected)
      expect(json).to eq(expected)
    end

    context 'without configured milestones' do
      let(:milestone_ids) { [] }

      it 'uses the default but without the type filter' do
        expected = default_json
                     .deep_dup
                     .merge('f' => [build_project_filter(selected)])
        expect(json).to eq(expected)
      end
    end
  end

  context 'with existing filter' do
    it 'overrides the filter' do
      Setting.project_gantt_query = default_json.deep_dup.merge('f' => [build_project_filter(%w[other values])]).to_json

      expected = default_json.deep_dup.merge('f' => [build_project_filter(selected)])
      expect(json).to eq(expected)
    end
  end

  context 'with invalid json' do
    it 'returns the default' do
      Setting.project_gantt_query = 'invalid!1234'

      expected = default_json.deep_dup
      expected['f'] << build_project_filter(selected)
      expect(json).to eq(expected)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class Queries::UpdateService < BaseServices::Update; end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'
require 'services/base_services/behaves_like_update_service'

RSpec.describe Queries::UpdateService do
  it_behaves_like 'BaseServices update service'
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class Queries::CreateService < BaseServices::Create; end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Queries::CreateService do
  let(:user) { build_stubbed(:admin) }

  let(:instance) { described_class.new(user:) }

  subject { instance.call(params).result }

  describe 'ordered work packages' do
    let!(:work_package) { create(:work_package) }
    let(:params) do
      {
        name: 'My query',
        ordered_work_packages: {
          work_package.id => 0,
          9999 => 1
        }
      }
    end

    it 'removes items for which work packages do not exist' do
      expect(subject).to be_valid
      expect(subject.ordered_work_packages.length).to eq 1
      expect(subject.ordered_work_packages.first.work_package_id).to eq work_package.id
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module CustomFields
  class SetAttributesService < ::BaseServices::SetAttributes
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe CustomFields::SetAttributesService, type: :model do
  let(:user) { build_stubbed(:user) }
  let(:contract_instance) do
    contract = double('contract_instance')
    allow(contract)
      .to receive(:validate)
      .and_return(contract_valid)
    allow(contract)
      .to receive(:errors)
      .and_return(contract_errors)
    contract
  end

  let(:contract_errors) { double('contract_errors') }
  let(:contract_valid) { true }
  let(:cf_valid) { true }

  let(:instance) do
    described_class.new(user:,
                        model: cf_instance,
                        contract_class:,
                        contract_options: {})
  end
  let(:cf_instance) { ProjectCustomField.new }
  let(:contract_class) do
    allow(CustomFields::CreateContract)
      .to receive(:new)
      .with(cf_instance, user, options: {})
    .and_return(contract_instance)

    CustomFields::CreateContract
  end

  let(:params) { {} }

  before do
    allow(cf_instance)
      .to receive(:valid?)
      .and_return(cf_valid)
  end

  subject { instance.call(params) }

  it 'returns the cf instance as the result' do
    expect(subject.result)
      .to eql cf_instance
  end

  it 'is a success' do
    expect(subject)
      .to be_success
  end

  context 'with params' do
    let(:params) do
      {
        name: 'Foobar'
      }
    end

    let(:expected) do
      {
        name: 'Foobar'
      }.with_indifferent_access
    end

    it 'assigns the params' do
      subject

      attributes_of_interest = cf_instance
                                 .attributes
                                 .slice(*expected.keys)

      expect(attributes_of_interest)
        .to eql(expected)
    end
  end

  context 'with an invalid contract' do
    let(:contract_valid) { false }
    let(:expect_time_instance_save) do
      expect(cf_instance)
        .not_to receive(:save)
    end

    it 'returns failure' do
      expect(subject)
        .not_to be_success
    end

    it ""returns the contract's errors"" do
      expect(subject.errors)
        .to eql(contract_errors)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module CustomFields
  class UpdateService < ::BaseServices::Update
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'
require 'services/base_services/behaves_like_update_service'

RSpec.describe CustomFields::UpdateService, type: :model do
  it_behaves_like 'BaseServices update service'
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module CustomFields
  class CreateService < ::BaseServices::Create
    def self.careful_new_custom_field(type)
      if /.+CustomField\z/.match?(type.to_s)
        klass = type.to_s.constantize
        klass.new if klass.ancestors.include? CustomField
      end
    rescue NameError => e
      Rails.logger.error ""#{e.message}:\n#{e.backtrace.join(""\n"")}""
      nil
    end

    def perform(params)
      super
    rescue StandardError => e
      ServiceResult.failure(message: e.message)
    end

    def instance(params)
      cf = self.class.careful_new_custom_field(params[:type])
      raise ArgumentError.new(""Invalid CF type"") unless cf

      cf
    end

    def after_perform(call)
      cf = call.result

      if cf.is_a?(ProjectCustomField)
        add_cf_to_visible_columns(cf)
      end

      call
    end

    private

    def add_cf_to_visible_columns(custom_field)
      Setting.enabled_projects_columns = (Setting.enabled_projects_columns + [custom_field.column_name]).uniq
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'
require 'services/base_services/behaves_like_create_service'

RSpec.describe CustomFields::CreateService, type: :model do
  it_behaves_like 'BaseServices create service' do
    context 'when creating a project cf' do
      let(:model_instance) { build_stubbed(:project_custom_field) }

      it 'modifies the settings on successful call' do
        subject
        expect(Setting.enabled_projects_columns).to include(model_instance.column_name)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module Roles
  class SetAttributesService < ::BaseServices::SetAttributes
    def set_attributes(params)
      super(params)

      if model.is_a?(ProjectRole)
        model.permissions += OpenProject::AccessControl.public_permissions.map(&:name)
      end
    end

    def set_default_attributes(*)
      model.permissions = ProjectRole.non_member.permissions if model.permissions.blank? && model.is_a?(ProjectRole)
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Roles::SetAttributesService, type: :model do
  let(:current_user) { build_stubbed(:admin) }

  let(:contract_instance) do
    contract = instance_double(Roles::CreateContract, 'contract_instance')
    allow(contract).to receive(:validate).and_return(contract_valid)
    allow(contract).to receive(:errors).and_return(contract_errors)
    contract
  end

  let(:contract_errors) { instance_double(ActiveModel::Errors, 'contract_errors') }
  let(:contract_valid) { true }
  let(:model_valid) { true }

  let(:instance) do
    described_class.new(user: current_user, model: model_instance, contract_class:, contract_options: {})
  end
  let(:model_instance) { ProjectRole.new }
  let(:contract_class) do
    allow(Roles::CreateContract).to receive(:new).and_return(contract_instance)

    Roles::CreateContract
  end

  let(:params) { {} }
  let(:permissions) { %i[view_work_packages view_wiki_pages] }

  before do
    allow(model_instance).to receive(:valid?).and_return(model_valid)
  end

  subject { instance.call(params) }

  it 'returns the instance as the result' do
    expect(subject.result).to eql model_instance
  end

  it 'is a success' do
    expect(subject).to be_success
  end

  context 'with params' do
    let(:params) do
      {
        permissions:
      }
    end

    before do
      create(:non_member, permissions: %i[view_meetings view_wiki_pages])
      subject
    end

    context 'with a ProjectRole' do
      it 'assigns the params with the public permissions' do
        expect(model_instance.permissions).to match_array(OpenProject::AccessControl.public_permissions.map(&:name) + permissions)
      end

      context 'when no permissions are given' do
        let(:permissions) { [] }

        it 'assigns the permissions the non member role has' do
          expect(model_instance.permissions).to match_array(ProjectRole.non_member.permissions) # public permissions are included via the factory
        end
      end
    end

    context 'with a GlobalRole' do
      let(:model_instance) { GlobalRole.new }

      it 'assigns the params' do
        expect(model_instance.permissions).to match_array(permissions)
      end

      context 'when no permissions are given' do
        let(:permissions) { [] }

        it 'assigns nothing' do
          expect(model_instance.permissions).to be_empty
        end
      end
    end

    context 'with a WorkPackageRole' do
      let(:model_instance) { WorkPackageRole.new }

      it 'assigns the params' do
        expect(model_instance.permissions).to match_array(permissions)
      end

      context 'when no permissions are given' do
        let(:permissions) { [] }

        it 'assigns nothing' do
          expect(model_instance.permissions).to be_empty
        end
      end
    end
  end

  context 'with an invalid contract' do
    let(:contract_valid) { false }

    it 'returns failure' do
      expect(subject).not_to be_success
    end

    it ""returns the contract's errors"" do
      expect(subject.errors)
        .to eql(contract_errors)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class Roles::UpdateService < BaseServices::Update
  private

  def before_perform(params, service_call)
    @permissions_old = service_call.result.permissions
    super
  end

  def after_perform(call)
    permissions_new = call.result.permissions
    permissions_diff = (@permissions_old - permissions_new) | (permissions_new - @permissions_old)
    OpenProject::Notifications.send(
      OpenProject::Events::ROLE_UPDATED,
      permissions_diff:
    )
    call
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'
require 'services/base_services/behaves_like_update_service'

RSpec.describe Roles::UpdateService, type: :model do
  it_behaves_like 'BaseServices update service' do
    let(:factory) { :project_role }
  end

  it 'sends an update notification' do
    allow(OpenProject::Notifications).to receive(:send)

    existing_permissions = %i[view_files view_work_packages
                              view_calender] + OpenProject::AccessControl.public_permissions.map(&:name)
    added_permissions = %i[write_files view_wiki_pages]
    role = create(:project_role, permissions: existing_permissions)

    params = { permissions: existing_permissions + added_permissions }

    described_class.new(user: create(:user), model: role).call(params)

    expect(OpenProject::Notifications).to have_received(:send).with(
      OpenProject::Events::ROLE_UPDATED,
      permissions_diff: added_permissions
    )
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class Roles::DeleteService < BaseServices::Delete
  def persist(service_result)
    # after destroy permissions can not be reached
    @permissions = model.permissions
    super(service_result)
  end

  protected

  def after_perform(service_call)
    super(service_call).tap do |_call|
      ::OpenProject::Notifications.send(
        ::OpenProject::Events::ROLE_DESTROYED,
        permissions: @permissions
      )
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'
require 'services/base_services/behaves_like_delete_service'

RSpec.describe Roles::DeleteService, type: :model do
  it_behaves_like 'BaseServices delete service' do
    let(:factory) { :project_role }
  end

  it 'sends a delete notification' do
    allow(OpenProject::Notifications).to(receive(:send))

    existing_permissions = %i[view_files view_work_packages view_calender]
    role = create(:project_role, permissions: existing_permissions)

    result = described_class
      .new(user: create(:user, admin: true), model: role)
      .call(permissions: existing_permissions)
    expect(result).to be_success
    expect(OpenProject::Notifications).to have_received(:send).with(
      OpenProject::Events::ROLE_DESTROYED,
      permissions: existing_permissions + OpenProject::AccessControl.public_permissions.map(&:name)
    )
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module Groups
  class SetAttributesService < ::BaseServices::SetAttributes
    private

    def set_attributes(params)
      set_users(params) if params.key?(:user_ids)
      super
    end

    # We do not want to persist the associated users (members) in a
    # SetAttributesService. Therefore we are building the association here.
    #
    # Note that due to the way we handle members, via a specific AddUsersService
    # the group should no longer simply be saved after group_users have been added.
    def set_users(params)
      user_ids = (params.delete(:user_ids) || []).map(&:to_i)

      existing_user_ids = model.group_users.map(&:user_id)
      build_new_users user_ids - existing_user_ids
      mark_outdated_users existing_user_ids - user_ids
    end

    def build_new_users(new_user_ids)
      new_user_ids.each do |id|
        model.group_users.build(user_id: id)
      end
    end

    def mark_outdated_users(removed_user_ids)
      removed_user_ids.each do |id|
        model.group_users.find { |gu| gu.user_id == id }.mark_for_destruction
      end
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Groups::SetAttributesService, type: :model do
  subject(:service_call) { instance.call(call_attributes) }

  let(:user) { build_stubbed(:user) }
  let(:contract_class) do
    contract = double('contract_class')

    allow(contract)
      .to receive(:new)
      .with(group, user, options: {})
      .and_return(contract_instance)

    contract
  end
  let(:contract_instance) do
    instance_double(ModelContract, validate: contract_valid, errors: contract_errors)
  end
  let(:contract_valid) { true }
  let(:contract_errors) do
    instance_double(ActiveRecord::ActiveRecordError)
  end
  let(:group_valid) { true }
  let(:instance) do
    described_class.new(user:,
                        model: group,
                        contract_class:)
  end
  let(:call_attributes) { {} }
  let(:group) do
    build_stubbed(:group) do |g|
      # To later check that it has not been called
      allow(g)
        .to receive(:save)
    end
  end

  describe 'call' do
    let(:call_attributes) do
      {
        name: 'The name'
      }
    end

    before do
      allow(group)
        .to receive(:valid?)
        .and_return(group_valid)

      allow(contract_instance)
        .to receive(:validate)
        .and_return(contract_valid)
    end

    it 'is successful' do
      expect(service_call)
        .to be_success
    end

    it 'sets the attributes' do
      service_call

      expect(group.lastname)
        .to eql call_attributes[:name]
    end

    it 'does not persist the group' do
      service_call

      expect(group)
        .not_to have_received(:save)
    end

    context 'with no changes to the users' do
      let(:call_attributes) do
        {
          name: 'My new group name'
        }
      end
      let(:first_user) { build_stubbed(:user) }
      let(:second_user) { build_stubbed(:user) }
      let(:first_group_user) { build_stubbed(:group_user, user: first_user) }
      let(:second_group_user) { build_stubbed(:group_user, user: second_user) }

      let(:group) do
        build_stubbed(:group, group_users: [first_group_user, second_group_user])
      end

      let(:updated_group) do
        service_call.result
      end

      it 'does not change the users (Regression #38017)' do
        expect(updated_group.name).to eq 'My new group name'
        expect(updated_group.group_users.map(&:user_id))
          .to eql [first_user.id, second_user.id]

        expect(updated_group.group_users.any?(&:marked_for_destruction?)).to be false
      end
    end

    context 'with changes to the users do' do
      let(:first_user) { build_stubbed(:user) }
      let(:second_user) { build_stubbed(:user) }
      let(:third_user) { build_stubbed(:user) }

      let(:call_attributes) do
        {
          user_ids: [second_user.id, third_user.id]
        }
      end

      shared_examples_for 'updates the users' do
        let(:first_group_user) { build_stubbed(:group_user, user: first_user) }
        let(:second_group_user) { build_stubbed(:group_user, user: second_user) }

        let(:group) do
          build_stubbed(:group, group_users: [first_group_user, second_group_user])
        end

        it 'adds the new users' do
          expect(service_call.result.group_users.map(&:user_id))
            .to eql [first_user.id, second_user.id, third_user.id]
        end

        it 'does not persist the new association' do
          expect(service_call.result.group_users.find { |gu| gu.user_id == third_user.id })
            .to be_new_record
        end

        it 'keeps the association already existing before' do
          expect(service_call.result.group_users.find { |gu| gu.user_id == second_user.id })
            .not_to be_marked_for_destruction
        end

        it 'marks not mentioned users to be removed' do
          expect(service_call.result.group_users.find { |gu| gu.user_id == first_user.id })
            .to be_marked_for_destruction
        end
      end

      context 'with a persisted record and integer values' do
        let(:call_attributes) do
          {
            user_ids: [second_user.id, third_user.id]
          }
        end

        it_behaves_like 'updates the users'
      end

      context 'with a persisted record and string values' do
        let(:call_attributes) do
          {
            user_ids: [second_user.id.to_s, third_user.id.to_s]
          }
        end

        it_behaves_like 'updates the users'
      end

      context 'with a new record' do
        let(:group) do
          Group.new
        end

        it 'sets the user' do
          expect(service_call.result.group_users.map(&:user_id))
            .to eql [second_user.id, third_user.id]
        end

        it 'does not persist the association' do
          expect(service_call.result.group_users.all(&:new_record?))
            .to be_truthy
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class Groups::UpdateService < BaseServices::Update
  protected

  def persist(call)
    removed_users = groups_removed_users(call.result)
    member_roles = member_roles_to_prune(removed_users)
    project_ids = member_roles.pluck(:project_id)
    member_role_ids = member_roles.pluck(:id)

    call = super

    remove_member_roles(member_role_ids)
    cleanup_members(removed_users, project_ids)

    call
  end

  def after_perform(call)
    new_user_ids = call.result.group_users.select(&:saved_changes?).map(&:user_id)

    if new_user_ids.any?
      db_call = ::Groups::AddUsersService
                  .new(call.result, current_user: user)
                  .call(ids: new_user_ids)

      call.add_dependent!(db_call)
    end

    call
  end

  def groups_removed_users(group)
    group.group_users.select(&:marked_for_destruction?).filter_map(&:user)
  end

  def remove_member_roles(member_role_ids)
    ::Groups::CleanupInheritedRolesService
      .new(model, current_user: user)
      .call(member_role_ids:)
  end

  def member_roles_to_prune(users)
    return MemberRole.none if users.empty?

    MemberRole
      .includes(member: :member_roles)
      .where(inherited_from: model.members.joins(:member_roles).select('member_roles.id'))
      .where(members: { user_id: users.map(&:id) })
  end

  def cleanup_members(users, project_ids)
    Members::CleanupService
      .new(users, project_ids)
      .call
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'
require 'services/base_services/behaves_like_update_service'

RSpec.describe Groups::UpdateService, type: :model do
  it_behaves_like 'BaseServices update service' do
    let(:add_service_result) do
      ServiceResult.success
    end
    let!(:add_users_service) do
      add_service = instance_double(Groups::AddUsersService)

      allow(Groups::AddUsersService)
        .to receive(:new)
        .with(model_instance, current_user: user)
        .and_return(add_service)

      allow(add_service)
        .to receive(:call)
        .and_return(add_service_result)

      add_service
    end

    context 'with newly created group_users' do
      let(:old_group_user) { build_stubbed(:group_user, user_id: 3) }
      let(:new_group_user) do
        build_stubbed(:group_user, user_id: 5).tap do |gu|
          allow(gu)
            .to receive(:saved_changes?)
            .and_return(true)
        end
      end
      let(:group_users) { [old_group_user, new_group_user] }

      before do
        allow(model_instance)
          .to receive(:group_users)
          .and_return(group_users)
      end

      context 'with the AddUsersService being successful' do
        it 'is successful' do
          expect(instance_call).to be_success
        end

        it 'calls the AddUsersService' do
          instance_call

          expect(add_users_service)
            .to have_received(:call)
            .with(ids: [new_group_user.user_id])
        end
      end

      context 'with the AddUsersService being unsuccessful' do
        let(:add_service_result) do
          ServiceResult.failure
        end

        it 'is failure' do
          expect(instance_call).to be_failure
        end

        it 'calls the AddUsersService' do
          instance_call

          expect(add_users_service)
            .to have_received(:call)
            .with(ids: [new_group_user.user_id])
        end
      end

      context 'without any new group_users' do
        let(:group_users) { [old_group_user] }

        it 'is successful' do
          expect(instance_call).to be_success
        end

        it 'does not call the AddUsersService' do
          instance_call

          expect(add_users_service)
            .not_to have_received(:call)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module UserPreferences
  class UpdateService < ::BaseServices::Update
    protected

    attr_accessor :notifications

    def validate_params(params)
      contract = ParamsContract.new(model, user, params:)

      ServiceResult.new success: contract.valid?,
                        errors: contract.errors,
                        result: model
    end

    def before_perform(params, _service_result)
      self.notifications = params&.delete(:notification_settings)

      super
    end

    def after_perform(service_call)
      return service_call if notifications.nil?

      inserted = persist_notifications
      remove_other_notifications(inserted)

      service_call
    end

    def persist_notifications
      global, project = notifications
                          .map { |item| item.merge(user_id: model.user_id) }
                          .partition { |setting| setting[:project_id].nil? }

      global_ids = upsert_notifications(global, %i[user_id], 'project_id IS NULL')
      project_ids = upsert_notifications(project, %i[user_id project_id], 'project_id IS NOT NULL')

      global_ids + project_ids
    end

    def remove_other_notifications(ids)
      NotificationSetting
        .where(user_id: model.user_id)
        .where.not(id: ids)
        .delete_all
    end

    ##
    # Upsert notification while respecting the partial index on notification_settings
    # depending on the project presence
    #
    # @param notifications The array of notification hashes to upsert
    # @param conflict_target The uniqueness constraint to upsert within
    # @param index_predicate The partial index condition on the project
    def upsert_notifications(notifications, conflict_target, index_predicate)
      return [] if notifications.empty?

      NotificationSetting
        .import(
          notifications,
          on_duplicate_key_update: {
            conflict_target:,
            index_predicate:,
            columns: %i[watched
                        assignee
                        responsible
                        shared
                        mentioned
                        start_date
                        due_date
                        overdue
                        work_package_commented
                        work_package_created
                        work_package_processed
                        work_package_prioritized
                        work_package_scheduled
                        news_added
                        news_commented
                        document_added
                        forum_messages
                        wiki_page_added
                        wiki_page_updated
                        membership_added
                        membership_updated]
          },
          validate: false
        ).ids
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'
require 'services/base_services/behaves_like_update_service'

RSpec.describe UserPreferences::UpdateService, type: :model do
  it_behaves_like 'BaseServices update service' do
    let(:params_success) { true }
    let(:params_errors) { ActiveModel::Errors.new({}) }
    let(:params_contract) do
      instance_double(UserPreferences::ParamsContract, valid?: params_success, errors: params_errors)
    end

    before do
      allow(UserPreferences::ParamsContract).to receive(:new).and_return(params_contract)
    end

    context 'when the params contract is invalid' do
      let(:params_success) { false }

      it 'returns that error' do
        expect(subject).to be_failure
        expect(subject.errors).to eq(params_errors)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module Users
  class SetAttributesService < ::BaseServices::SetAttributes
    include ::HookHelper

    private

    attr_accessor :pref

    def set_attributes(params)
      self.pref = params.delete(:pref)

      super(params)
    end

    def validate_and_result
      super.tap do |result|
        result.merge!(set_preferences) if pref.present?
      end
    end

    def set_default_attributes(params)
      # Assign values other than mail to new_user when invited
      assign_name_attributes_from_mail(params) if model.invited? && model.valid_attribute?(:mail)
      assign_default_language

      model.notification_settings.build unless model.notification_settings.any?
    end

    def set_preferences
      ::UserPreferences::SetAttributesService
        .new(user:, model: model.pref, contract_class: ::UserPreferences::UpdateContract)
        .call(pref)
    end

    # rubocop:disable Metrics/AbcSize
    def assign_name_attributes_from_mail(params)
      placeholder = placeholder_name(params[:mail])

      model.login = model.login.presence || params[:mail]
      model.firstname = model.firstname.presence || placeholder.first
      model.lastname = model.lastname.presence || placeholder.last
    end
    # rubocop:enable Metrics/AbcSize

    def assign_default_language
      model.language = model.language.presence || Setting.default_language
    end

    ##
    # Creates a placeholder name for the user based on their email address.
    # For the unlikely case that the local or domain part of the email address
    # are longer than 30 characters they will be trimmed to 27 characters and an
    # ellipsis will be appended.
    def placeholder_name(email)
      first, last = email.split('@').map { |name| trim_name(name) }

      [first, ""@#{last}""]
    end

    def trim_name(name)
      if name.size > 30
        ""#{name[0..26]}...""
      else
        name
      end
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Users::SetAttributesService, type: :model do
  subject(:call) { instance.call(params) }

  let(:current_user) { build_stubbed(:user) }

  let(:contract_instance) do
    contract = double('contract_instance')
    allow(contract)
      .to receive(:validate)
            .and_return(contract_valid)
    allow(contract)
      .to receive(:errors)
            .and_return(contract_errors)
    contract
  end

  let(:contract_errors) { double('contract_errors') }
  let(:contract_valid) { true }
  let(:model_valid) { true }

  let(:instance) do
    described_class.new(user: current_user,
                        model: model_instance,
                        contract_class:,
                        contract_options: {})
  end
  let(:model_instance) { User.new }
  let(:contract_class) do
    allow(Users::CreateContract)
      .to receive(:new)
            .and_return(contract_instance)

    Users::CreateContract
  end

  let(:params) { {} }

  before do
    allow(model_instance)
      .to receive(:valid?)
            .and_return(model_valid)
  end

  context 'for a new record' do
    let(:model_instance) do
      User.new
    end

    it 'is successful' do
      expect(call)
        .to be_success
    end

    it 'returns the instance as the result' do
      expect(call.result)
        .to eql model_instance
    end

    it 'initializes the notification settings' do
      expect(call.result.notification_settings.length)
        .to be 1

      expect(call.result.notification_settings)
        .to(all(be_a(NotificationSetting).and(be_new_record)))
    end

    it 'sets the default language', with_settings: { default_language: 'de' } do
      call

      expect(model_instance.language)
        .to eql 'de'
    end

    context 'with params' do
      let(:params) do
        {
          firstname: 'Foo',
          lastname: 'Bar'
        }
      end

      it 'assigns the params' do
        call

        expect(model_instance.firstname).to eq 'Foo'
        expect(model_instance.lastname).to eq 'Bar'
      end
    end

    context 'with attributes for the user`s preferences' do
      let(:params) do
        {
          pref: {
            auto_hide_popups: true
          }
        }
      end

      it 'initializes the user`s preferences with those attributes' do
        expect(call.result.pref)
          .to be_auto_hide_popups
      end
    end
  end

  context 'with an invalid contract' do
    let(:contract_valid) { false }
    let(:expect_time_instance_save) do
      expect(model_instance)
        .not_to receive(:save)
    end

    it 'returns failure' do
      expect(subject)
        .not_to be_success
    end

    it ""returns the contract's errors"" do
      expect(call.errors)
        .to eql(contract_errors)
    end
  end

  describe '.placeholder_name' do
    it 'given an email it uses the local part as first and the domain as the last name' do
      email = 'xxxhunterxxx@openproject.com'
      first, last = instance.send(:placeholder_name, email)

      expect(first).to eq 'xxxhunterxxx'
      expect(last).to eq '@openproject.com'
    end

    it 'trims names if they are too long (> 30 characters)' do
      email = 'hallowurstsalatgetraenkebuechse@veryopensuchproject.openproject.com'
      first, last = instance.send(:placeholder_name, email)

      expect(first).to eq 'hallowurstsalatgetraenkebue...'
      expect(last).to eq '@veryopensuchproject.openpro...'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module Users
  class LogoutService
    attr_accessor :controller, :cookies

    def initialize(controller:)
      self.controller = controller
      self.cookies = controller.send(:cookies)
    end

    def call!(user)
      OpenProject.logger.info { ""Logging out ##{user.id}"" }

      if OpenProject::Configuration.drop_old_sessions_on_logout?
        remove_all_autologin_tokens! user
        remove_all_sessions! user
      else
        remove_matching_autologin_token! user
      end

      controller.reset_session

      User.current = User.anonymous
    end

    private

    def remove_all_sessions!(user)
      ::Sessions::UserSession.for_user(user.id).delete_all
    end

    def remove_all_autologin_tokens!(user)
      cookies.delete(OpenProject::Configuration.autologin_cookie_name)
      Token::AutoLogin.where(user_id: user.id).delete_all
    end

    def remove_matching_autologin_token!(user)
      value = cookies.delete(OpenProject::Configuration.autologin_cookie_name)
      return if value.blank?

      Token::AutoLogin
        .where(user:)
        .find_by_plaintext_value(value)&.destroy
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Users::LogoutService, type: :model do
  shared_let(:user) { create(:user) }
  let(:request) { {} }
  let(:browser) do
    instance_double(Browser::Safari,
                    name: 'Safari',
                    version: '13.2',
                    platform: instance_double(Browser::Platform::Linux, name: 'Linux'))
  end
  let(:cookies) { {} }
  let(:controller) { instance_double(ApplicationController, browser:, cookies:) }

  let(:instance) { described_class.new(controller:) }

  subject { instance.call!(user) }

  before do
    allow(controller).to(receive(:reset_session))
  end

  describe 'User.current' do
    it 'resets it' do
      User.current = user

      subject

      expect(User.current).to eq User.anonymous
    end
  end

  describe 'delete other sessions on destroy' do
    let!(:sessions) { create_list(:user_session, 2, user:) }
    let!(:other_session) { create(:user_session) }

    context 'when config is enabled',
            with_config: { drop_old_sessions_on_logout: true } do
      it 'destroys both sessions' do
        expect(Sessions::UserSession.count).to eq(3)
        expect(Sessions::UserSession.for_user(user).count).to eq(2)

        subject

        expect(Sessions::UserSession.count).to eq(1)
        expect(Sessions::UserSession.for_user(user).count).to eq(0)
      end

      describe 'autologin cookie' do
        let!(:token) { create(:autologin_token, user:) }
        let!(:other_token) { create(:autologin_token, user:) }

        it 'removes all autologin tokens' do
          cookies[OpenProject::Configuration.autologin_cookie_name] = token.plain_value

          subject

          expect(cookies[OpenProject::Configuration.autologin_cookie_name]).to be_nil
          expect { token.reload }.to raise_error(ActiveRecord::RecordNotFound)
          expect { other_token.reload }.to raise_error(ActiveRecord::RecordNotFound)
          expect(Token::AutoLogin.where(user_id: user.id)).to be_empty
        end
      end
    end

    context 'when config is disabled',
            with_config: { drop_old_sessions_on_logout: false } do
      it 'destroys none of the existing sessions' do
        expect(Sessions::UserSession.count).to eq(3)
        expect(Sessions::UserSession.for_user(user).count).to eq(2)

        subject

        expect(Sessions::UserSession.count).to eq(3)
        expect(Sessions::UserSession.for_user(user).count).to eq(2)
      end


      describe 'autologin cookie' do
        let!(:token) { create(:autologin_token, user:) }
        let!(:other_token) { create(:autologin_token, user:) }

        it 'removes the matching autologin cookie and token' do
          cookies[OpenProject::Configuration.autologin_cookie_name] = token.plain_value

          subject

          expect(cookies[OpenProject::Configuration.autologin_cookie_name]).to be_nil
          expect { token.reload }.to raise_error(ActiveRecord::RecordNotFound)
          expect(Token::AutoLogin.where(user_id: user.id).all).to contain_exactly other_token
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module Users
  class UpdateService < ::BaseServices::Update
    include ::HookHelper

    protected

    def before_perform(params, _service_result)
      call_hook :service_update_user_before_save,
                params:,
                user: model

      super
    end

    def persist(service_result)
      service_result = super(service_result)

      if service_result.success?
        service_result.success = model.pref.save
      end

      service_result
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.

require 'spec_helper'
require 'services/base_services/behaves_like_update_service'

RSpec.describe Users::UpdateService do
  it_behaves_like 'BaseServices update service' do
    # The user service also tries to save the preferences
    before do
      allow(model_instance.pref).to receive(:save).and_return(true)
    end
  end

  describe 'updating attributes' do
    let(:instance) { described_class.new(model: update_user, user: current_user) }
    let(:current_user) { create(:admin) }
    let(:update_user) { create(:user, mail: 'correct@example.org') }

    subject { instance.call(attributes:) }

    context 'when invalid' do
      let(:attributes) { { mail: 'invalid' } }

      it 'fails to update' do
        expect(subject).not_to be_success

        update_user.reload
        expect(update_user.mail).to eq('correct@example.org')

        expect(subject.errors.symbols_for(:mail)).to match_array(%i[email])
      end
    end

    context 'when valid' do
      let(:attributes) { { mail: 'new@example.org' } }

      it 'updates the user' do
        expect(subject).to be_success

        update_user.reload
        expect(update_user.mail).to eq('new@example.org')
      end

      context 'if current_user is no admin' do
        let(:current_user) { build_stubbed(:user) }

        it 'is unsuccessful' do
          expect(subject).not_to be_success
        end
      end
    end

    context 'when valid status' do
      let(:attributes) { { status: Principal.statuses[:locked] } }

      it 'updates the user' do
        expect(subject).to be_success

        update_user.reload
        expect(update_user).to be_locked
      end

      context 'if current_user is no admin' do
        let(:current_user) { build_stubbed(:user) }

        it 'is unsuccessful' do
          expect(subject).not_to be_success
        end
      end
    end

    describe 'updating prefs' do
      let(:attributes) { {} }

      before do
        allow(update_user).to receive(:save).and_return(user_save_result)
      end

      context 'if the user was updated calls the prefs' do
        let(:user_save_result) { true }

        before do
          expect(update_user.pref).to receive(:save).and_return(pref_save_result)
        end

        context 'and the prefs can be saved' do
          let(:pref_save_result) { true }

          it 'returns a successful call' do
            expect(subject).to be_success
          end
        end

        context 'and the prefs can not be saved' do
          let(:pref_save_result) { false }

          it 'returns an erroneous call' do
            expect(subject).not_to be_success
          end
        end
      end

      context 'if the user was not saved' do
        let(:user_save_result) { false }

        it 'does not call #prefs.save' do
          expect(update_user.pref).not_to receive(:save)
          expect(subject).not_to be_success
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module Users
  class ChangePasswordService
    attr_accessor :current_user, :session

    def initialize(current_user:, session:)
      @current_user = current_user
      @session = session
    end

    def call(params)
      User.execute_as current_user do
        current_user.password = params[:new_password]
        current_user.password_confirmation = params[:new_password_confirmation]
        current_user.force_password_change = false
        current_user.activate if current_user.invited?

        if current_user.save
          invalidate_recovery_tokens
          invalidate_invitation_tokens

          log_success
          ::ServiceResult.new success: true,
                              result: current_user,
                              **invalidate_session_result
        else
          log_failure
          ::ServiceResult.new success: false,
                              result: current_user,
                              message: I18n.t(:error_password_change_failed),
                              errors: current_user.errors
        end
      end
    end

    private

    def invalidate_recovery_tokens
      Token::Recovery.where(user: current_user).delete_all
    end

    def invalidate_invitation_tokens
      Token::Invitation.where(user: current_user).delete_all
    end

    def invalidate_session_result
      update_message = I18n.t(:notice_account_password_updated)

      if ::Sessions::DropOtherSessionsService.call(current_user, session)
        expiry_message = I18n.t(:notice_account_other_session_expired)
        { message_type: :info, message: ""#{update_message} #{expiry_message}"" }
      else
        { message: update_message }
      end
    end

    def log_success
      Rails.logger.info do
        ""User #{current_user.login} changed password successfully.""
      end
    end

    def log_failure
      Rails.logger.info do
        ""User #{current_user.login} failed password change: #{current_user.errors.full_messages.join(', ')}.""
      end
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.

require 'spec_helper'

RSpec.describe Users::ChangePasswordService do
  let(:user) do
    create(:invited_user,
           password: old_password,
           password_confirmation: old_password)
  end
  let(:old_password) { 'AdminAdmin42' }
  let(:new_password) { 'SoreThroat33' }
  let(:session) { ActionController::TestSession.new }
  let(:instance) { described_class.new current_user: user, session: }

  let(:result) do
    instance.call new_password:, new_password_confirmation: new_password
  end

  it 'is successful' do
    expect(result).to be_success
  end

  it ""changes the user's password"" do
    result
    expect(user.check_password?(old_password)).to be false
    expect(user.check_password?(new_password)).to be true
  end

  describe 'activating the user' do
    context 'when the user is ""invited""' do
      it 'activates the user' do
        result
        expect(user).to be_active
      end
    end

    context 'when the user is not ""invited""' do
      let(:user) do
        create(:locked_user,
               password: old_password,
               password_confirmation: old_password)
      end

      it 'does not activate the user' do
        result
        expect(user).not_to be_active
      end
    end
  end

  context 'with existing invitation tokens' do
    let!(:invitation_token) { create(:invitation_token, user:) }

    it 'invalidates the existing token' do
      expect(result).to be_success
      expect(Token::Invitation.where(user:)).to be_empty
    end
  end

  context 'with existing password recovery tokens' do
    let!(:recovery_token) { create(:recovery_token, user:) }

    it 'invalidates the existing tokens' do
      expect(result).to be_success
      expect(Token::Recovery.where(user:)).to be_empty
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module Users
  class RegisterUserService
    attr_reader :user

    def initialize(user)
      @user = user
    end

    def call
      %i[
        ensure_user_limit_not_reached!
        register_invited_user
        register_ldap_user
        ensure_provider_not_limited!
        register_omniauth_user
        ensure_registration_allowed!
        register_by_email_activation
        register_automatically
        register_manually
        fail_activation
      ].each do |m|
        result = send(m)
        return result if result.is_a?(ServiceResult)
      end
    rescue StandardError => e
      Rails.logger.error { ""User #{user.login} failed to activate #{e}."" }
      ServiceResult.failure(result: user, message: I18n.t(:notice_activation_failed))
    end

    private

    ##
    # Check whether the associated single sign-on providers
    # allows for automatic activation of new users
    def ensure_provider_not_limited!
      if limited_provider?(user) && Setting::SelfRegistration.disabled?
        name = provider_name(user)
        ServiceResult.failure(result: user, message: I18n.t('account.error_self_registration_limited_provider', name:))
      end
    end

    ##
    # Check whether the system allows registration
    # for non-invited users
    def ensure_registration_allowed!
      if Setting::SelfRegistration.disabled?
        ServiceResult.failure(result: user, message: I18n.t('account.error_self_registration_disabled'))
      end
    end

    ##
    # Ensure the user limit is not reached
    def ensure_user_limit_not_reached!
      if OpenProject::Enterprise.user_limit_reached?
        OpenProject::Enterprise.send_activation_limit_notification_about user
        ServiceResult.failure(result: user, message: I18n.t(:error_enterprise_activation_user_limit))
      end
    end

    ##
    # Try to register an invited user
    # bypassing regular restrictions
    def register_invited_user
      return unless user.invited?

      user.activate

      with_saved_user_result(success_message: I18n.t(:notice_account_registered_and_logged_in)) do
        Rails.logger.info { ""User #{user.login} was successfully activated after invitation."" }
      end
    end

    ##
    # Try to register a user with an auth source connection
    # bypassing regular account registration restrictions
    def register_ldap_user
      return if user.ldap_auth_source_id.blank?

      user.activate

      with_saved_user_result(success_message: I18n.t(:notice_account_registered_and_logged_in)) do
        Rails.logger.info { ""User #{user.login} was successfully activated with LDAP association after invitation."" }
      end
    end

    ##
    # Try to register a user with an existsing omniauth connection
    # bypassing regular account registration restrictions
    def register_omniauth_user
      return if skip_omniauth_user?
      return if limited_provider?(user)

      user.activate

      with_saved_user_result(success_message: I18n.t(:notice_account_registered_and_logged_in)) do
        Rails.logger.info { ""User #{user.login} was successfully activated after arriving from omniauth."" }
      end
    end

    def skip_omniauth_user?
      user.identity_url.blank?
    end

    def limited_provider?(user)
      provider = provider_name(user)
      return false if provider.blank?

      OpenProject::Plugins::AuthPlugin.limit_self_registration?(provider:)
    end

    def provider_name(user)
      user.authentication_provider&.downcase
    end

    def register_by_email_activation
      return unless Setting::SelfRegistration.by_email?

      user.register

      with_saved_user_result(success_message: I18n.t(:notice_account_register_done)) do
        token = Token::Invitation.create!(user:)
        UserMailer.user_signed_up(token).deliver_later
        Rails.logger.info { ""Scheduled email activation mail for #{user.login}"" }
      end
    end

    # Automatically register a user
    #
    # Pass a block for behavior when a user fails to save
    def register_automatically
      return unless Setting::SelfRegistration.automatic?

      user.activate

      with_saved_user_result do
        Rails.logger.info { ""User #{user.login} was successfully activated."" }
      end
    end

    def register_manually
      user.register

      with_saved_user_result(success_message: I18n.t(:notice_account_pending)) do
        # Sends an email to the administrators
        admins = User.admin.active
        admins.each do |admin|
          UserMailer.account_activation_requested(admin, user).deliver_later
        end

        Rails.logger.info { ""User #{user.login} was successfully created and is pending admin activation."" }
      end
    end

    def fail_activation
      Rails.logger.error { ""User #{user.login} could not be activated, all options were exhausted."" }
      ServiceResult.failure(message: I18n.t(:notice_activation_failed))
    end

    ##
    # Try to save result, return it in case of errors
    # and add a user error to make sure we can render the account registration form
    def with_saved_user_result(success_message: I18n.t(:notice_account_activated))
      if user.save
        yield if block_given?
        return ServiceResult.success(result: user, message: success_message)
      end

      ServiceResult.failure.tap do |call|
        # Avoid using the errors from the user
        call.result = user
        call.errors.add(:base, I18n.t(:notice_activation_failed), error: :failed_to_activate)
      end
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.

require 'spec_helper'

RSpec.describe Users::RegisterUserService do
  let(:user) { build(:user) }
  let(:instance) { described_class.new(user) }
  let(:call) { instance.call }

  def with_all_registration_options(except: [])
    Setting::SelfRegistration.values.each do |name, value|
      next if Array(except).include? name

      allow(Setting).to receive(:self_registration).and_return(value)
      yield name
    end
  end

  describe '#register_invited_user' do
    it 'tries to activate that user regardless of settings' do
      with_all_registration_options do |_type|
        user = User.new(status: Principal.statuses[:invited])
        instance = described_class.new(user)

        expect(user).to receive(:activate)
        expect(user).to receive(:save).and_return true

        call = instance.call
        expect(call).to be_success
        expect(call.result).to eq user
        expect(call.message).to eq I18n.t(:notice_account_registered_and_logged_in)
      end
    end
  end

  describe '#register_ldap_user' do
    it 'tries to activate that user regardless of settings' do
      with_all_registration_options do |_type|
        user = User.new(status: Principal.statuses[:registered])
        instance = described_class.new(user)

        allow(user).to receive(:ldap_auth_source_id).and_return 1234
        expect(user).to receive(:activate)
        expect(user).to receive(:save).and_return true

        call = instance.call
        expect(call).to be_success
        expect(call.result).to eq user
        expect(call.message).to eq I18n.t(:notice_account_registered_and_logged_in)
      end
    end
  end

  describe '#register_omniauth_user' do
    let(:user) { User.new(status: Principal.statuses[:registered], identity_url: 'azure:1234') }
    let(:instance) { described_class.new(user) }

    before do
      allow(user).to receive(:activate)
      allow(user).to receive(:save).and_return true

      # required so that the azure provider is visible (ee feature)
      allow(EnterpriseToken).to receive(:show_banners?).and_return false
    end

    it 'tries to activate that user regardless of settings' do
      with_all_registration_options do |_type|
        call = instance.call
        expect(call).to be_success
        expect(call.result).to eq user
        expect(call.message).to eq I18n.t(:notice_account_registered_and_logged_in)
      end
    end

    context 'with limit_self_registration enabled and self_registration disabled',
            with_settings: {
              self_registration: 0,
              plugin_openproject_openid_connect: {
                providers: {
                  azure: { identifier: ""foo"", secret: ""bar"", limit_self_registration: true }
                }
              }
            } do
      it 'fails to activate due to disabled self registration' do
        call = instance.call
        expect(call).not_to be_success
        expect(call.result).to eq user
        expect(call.message).to eq I18n.t('account.error_self_registration_limited_provider', name: 'azure')
      end
    end

    context 'with limit_self_registration enabled and self_registration manual',
            with_settings: {
              self_registration: 2,
              plugin_openproject_openid_connect: {
                providers: {
                  azure: { identifier: ""foo"", secret: ""bar"", limit_self_registration: true }
                }
              }
            } do
      it 'registers the user, but does not activate it' do
        call = instance.call
        expect(call).to be_success
        expect(call.result).to eq user
        expect(user).to be_registered
        expect(user).not_to have_received(:activate)
        expect(call.message).to eq I18n.t(:notice_account_pending)
      end
    end

    context 'with limit_self_registration enabled and self_registration email',
            with_settings: {
              self_registration: 1,
              plugin_openproject_openid_connect: {
                providers: {
                  azure: { identifier: ""foo"", secret: ""bar"", limit_self_registration: true }
                }
              }
            } do
      it 'registers the user, but does not activate it' do
        call = instance.call
        expect(call).to be_success
        expect(call.result).to eq user
        expect(user).to be_registered
        expect(user).not_to have_received(:activate)
        expect(call.message).to eq I18n.t(:notice_account_register_done)
      end
    end

    context 'with limit_self_registration enabled and self_registration automatic',
            with_settings: {
              self_registration: 3,
              plugin_openproject_openid_connect: {
                providers: {
                  azure: { identifier: ""foo"", secret: ""bar"", limit_self_registration: true }
                }
              }
            } do
      it 'activates the user' do
        call = instance.call
        expect(call).to be_success
        expect(call.result).to eq user
        expect(user).to have_received(:activate)
        expect(call.message).to eq I18n.t(:notice_account_activated)
      end
    end
  end

  describe '#ensure_registration_allowed!' do
    it 'returns an error for disabled' do
      allow(Setting).to receive(:self_registration).and_return(0)

      user = User.new
      instance = described_class.new(user)

      expect(user).not_to receive(:activate)
      expect(user).not_to receive(:save)

      call = instance.call

      expect(call.result).to eq user
      expect(call.message).to eq I18n.t('account.error_self_registration_disabled')
    end

    it 'does not return an error for all cases except disabled' do
      with_all_registration_options(except: :disabled) do |_type|
        user = User.new
        instance = described_class.new(user)

        # Assuming the next returns a result
        expect(instance)
          .to(receive(:ensure_user_limit_not_reached!))
          .and_return(ServiceResult.failure(result: user, message: 'test stop'))

        expect(user).not_to receive(:activate)
        expect(user).not_to receive(:save)

        call = instance.call
        expect(call.result).to eq user
        expect(call.message).to eq 'test stop'
      end
    end
  end

  describe 'ensure_user_limit_not_reached!',
           with_settings: { self_registration: 1 } do
    before do
      expect(OpenProject::Enterprise)
        .to(receive(:user_limit_reached?))
        .and_return(limit_reached)
    end

    context 'when limited' do
      let(:limit_reached) { true }

      it 'returns an error at that step' do
        expect(call).to be_failure
        expect(call.result).to eq user
        expect(call.message).to eq I18n.t(:error_enterprise_activation_user_limit)
      end
    end

    context 'when not limited' do
      let(:limit_reached) { false }

      it 'returns no error' do
        # Assuming the next returns a result
        expect(instance)
          .to(receive(:register_by_email_activation))
          .and_return(ServiceResult.failure(result: user, message: 'test stop'))

        call = instance.call
        expect(call.result).to eq user
        expect(call.message).to eq 'test stop'
      end
    end
  end

  describe '#register_by_email_activation' do
    it 'activates the user with mail' do
      allow(Setting).to receive(:self_registration).and_return(1)

      user = User.new
      instance = described_class.new(user)

      expect(user).to receive(:register)
      expect(user).to receive(:save).and_return true
      expect(UserMailer).to receive_message_chain(:user_signed_up, :deliver_later)
      expect(Token::Invitation).to receive(:create!).with(user:)

      call = instance.call

      expect(call).to be_success
      expect(call.result).to eq user
      expect(call.message).to eq I18n.t(:notice_account_register_done)
    end

    it 'does not return an error for all cases except disabled' do
      with_all_registration_options(except: %i[disabled activation_by_email]) do
        user = User.new
        instance = described_class.new(user)

        # Assuming the next returns a result
        expect(instance)
          .to(receive(:register_automatically))
          .and_return(ServiceResult.failure(result: user, message: 'test stop'))

        expect(user).not_to receive(:activate)
        expect(user).not_to receive(:save)

        call = instance.call
        expect(call.result).to eq user
        expect(call.message).to eq 'test stop'
      end
    end
  end

  describe '#register_automatically' do
    it 'activates the user with mail' do
      allow(Setting).to receive(:self_registration).and_return(3)

      user = User.new
      instance = described_class.new(user)

      expect(user).to receive(:activate)
      expect(user).to receive(:save).and_return true

      call = instance.call

      expect(call).to be_success
      expect(call.result).to eq user
      expect(call.message).to eq I18n.t(:notice_account_activated)
    end

    it 'does not return an error if manual' do
      allow(Setting).to receive(:self_registration).and_return(2)

      user = User.new
      instance = described_class.new(user)

      # Assuming the next returns a result
      expect(instance)
        .to(receive(:register_manually))
        .and_return(ServiceResult.failure(result: user, message: 'test stop'))

      expect(user).not_to receive(:activate)
      expect(user).not_to receive(:save)

      call = instance.call
      expect(call.result).to eq user
      expect(call.message).to eq 'test stop'
    end
  end

  describe '#register_manually' do
    let(:admin_stub) { build_stubbed(:admin) }

    it 'activates the user with mail' do
      allow(User).to receive_message_chain(:admin, :active).and_return([admin_stub])
      allow(Setting).to receive(:self_registration).and_return(2)

      user = User.new
      instance = described_class.new(user)

      expect(user).to receive(:register).and_call_original
      expect(user).not_to receive(:activate)
      expect(user).to receive(:save).and_return true

      mail_stub = double('Mail', deliver_later: true)
      expect(UserMailer)
        .to(receive(:account_activation_requested))
        .with(admin_stub, user)
        .and_return(mail_stub)

      call = instance.call

      expect(call).to be_success
      expect(call.result).to eq user
      expect(user).to be_registered
      expect(call.message).to eq I18n.t(:notice_account_pending)
    end
  end

  describe 'error handling' do
    it 'turns it into a service result' do
      allow(instance).to receive(:ensure_registration_allowed!).and_raise 'FOO!'
      expect(call).to be_failure

      # Does not include the internal error message itself
      expect(call.message).to eq I18n.t(:notice_activation_failed)
    end
  end

  describe '#with_saved_user_result' do
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'work_packages/create_contract'
require 'concerns/user_invitation'

module Users
  class CreateService < ::BaseServices::Create
    private

    def persist(call)
      new_user = call.result

      return super(call) unless new_user.invited?

      # As we're basing on the user's mail, this parameter is required
      # before we're able to validate the contract or user
      return fail_with_missing_email(new_user) if new_user.mail.blank?

      invite_user!(new_user)
    end

    def fail_with_missing_email(new_user)
      ServiceResult.failure(result: new_user).tap do |result|
        result.errors.add :mail, :blank
      end
    end

    def invite_user!(new_user)
      invited = ::UserInvitation.invite_user! new_user
      new_user.errors.add :base, I18n.t(:error_can_not_invite_user) unless invited.is_a? User

      ServiceResult.new(success: new_user.errors.empty?, result: invited)
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.

require 'spec_helper'
require 'services/base_services/behaves_like_create_service'

RSpec.describe Users::CreateService do
  it_behaves_like 'BaseServices create service' do
    context 'when the user being invited' do
      let(:model_instance) { build(:invited_user) }

      context 'and the mail is present' do
        let(:model_instance) { build(:invited_user, mail: 'foo@example.com') }

        it 'will call UserInvitation' do
          expect(UserInvitation).to receive(:invite_user!).with(model_instance).and_return(model_instance)
          expect(subject).to be_success
        end
      end

      context 'and the user has no names set' do
        let(:model_instance) { build(:invited_user, firstname: nil, lastname: nil, mail: 'foo@example.com') }

        it 'will call UserInvitation' do
          expect(UserInvitation).to receive(:invite_user!).with(model_instance).and_return(model_instance)
          expect(subject).to be_success
        end
      end

      context 'and the mail is empty' do
        let(:model_instance) { build(:invited_user, mail: nil) }

        it 'will call not call UserInvitation' do
          expect(UserInvitation).not_to receive(:invite_user!)
          expect(subject).not_to be_success
          expect(subject.errors.details[:mail]).to eq [{ error: :blank }]
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

##
# Implements the deletion of a user.
module Users
  class DeleteService < ::BaseServices::Delete
    ##
    # Deletes the given user if allowed.
    #
    # @return True if the user deletion has been initiated, false otherwise.
    def destroy(user_object)
      # as destroying users is a lengthy process we handle it in the background
      # and lock the account now so that no action can be performed with it
      # don't use ""locked!"" handle as it will raise on invalid users
      user_object.update_column(:status, User.statuses[:locked])
      ::Principals::DeleteJob.perform_later(user_object)

      logout! if self_delete?

      true
    end

    private

    def self_delete?
      user == model
    end

    def logout!
      User.current = nil
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Users::DeleteService, type: :model do
  let(:input_user) { build_stubbed(:user) }
  let(:project) { build_stubbed(:project) }

  let(:instance) { described_class.new(model: input_user, user: actor) }

  subject { instance.call }

  shared_examples 'deletes the user' do
    it do
      allow(input_user).to receive(:update_column).with(:status, 3)
      expect(Principals::DeleteJob).to receive(:perform_later).with(input_user)
      expect(subject).to be_success
      expect(input_user).to have_received(:update_column).with(:status, 3)
    end
  end

  shared_examples 'does not delete the user' do
    it do
      allow(input_user).to receive(:update_column).with(:status, 3)
      expect(Principals::DeleteJob).not_to receive(:perform_later)
      expect(subject).not_to be_success
      expect(input_user).not_to have_received(:update_column).with(:status, 3)
    end
  end

  context 'if deletion by admins allowed', with_settings: { users_deletable_by_admins: true } do
    context 'with admin user' do
      let(:actor) { build_stubbed(:admin) }

      it_behaves_like 'deletes the user'
    end

    context 'with unprivileged system user' do
      let(:actor) { User.system }

      before do
        allow(actor).to receive(:admin?).and_return false
      end

      it_behaves_like 'does not delete the user'
    end

    context 'with privileged system user' do
      let(:actor) { User.system }

      it_behaves_like 'deletes the user'
    end
  end

  context 'if deletion by admins NOT allowed', with_settings: { users_deletable_by_admins: false } do
    context 'with admin user' do
      let(:actor) { build_stubbed(:admin) }

      it_behaves_like 'does not delete the user'
    end

    context 'with system user' do
      let(:actor) { User.system }

      it_behaves_like 'does not delete the user'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module Users
  class LoginService
    attr_accessor :controller, :request, :browser, :user, :cookies

    delegate :session, to: :controller

    def initialize(user:, controller:, request:)
      self.user = user
      self.controller = controller
      self.request = request
      self.browser = controller.send(:browser)
      self.cookies = controller.send(:cookies)
    end

    def call!
      autologin_requested = session.delete(:autologin_requested)
      retain_session_values do
        reset_session!

        User.current = user

        set_autologin_cookie if autologin_requested

        successful_login
      end
    end

    private

    def set_autologin_cookie
      return unless Setting::Autologin.enabled?

      # generate a key and set cookie if autologin
      expires_on =  Setting.autologin.days.from_now.beginning_of_day
      token = Token::AutoLogin.create(user:, data: session_identification, expires_on:)
      cookie_options = {
        value: token.plain_value,
        # The autologin expiry is checked on validating the token
        # but still expire the cookie to avoid unnecessary retries
        expires: expires_on,
        path: OpenProject::Configuration['autologin_cookie_path'],
        secure: OpenProject::Configuration.https?,
        httponly: true
      }
      cookies[OpenProject::Configuration['autologin_cookie_name']] = cookie_options
    end

    def successful_login
      user.log_successful_login

      context = { user:, request:, session: }
      OpenProject::Hook.call_hook(:user_logged_in, context)
    end

    def reset_session!
      ::Sessions::DropAllSessionsService.call(user) if drop_old_sessions?
      controller.reset_session
    end

    def retain_session_values
      # retain flash values
      flash_values = controller.flash.to_h

      # retain session values
      retained_session = retained_session_values || {}

      yield

      flash_values.each { |k, v| controller.flash[k] = v }

      session.merge!(retained_session)
      session.merge!(session_identification)
      apply_default_values(session)
    end

    def apply_default_values(session)
      session[:user_id] = user.id
      session[:updated_at] = Time.zone.now
    end

    def session_identification
      {
        platform: browser.platform&.name,
        browser: browser.name,
        browser_version: browser.version
      }
    end

    def retained_session_values
      provider_name = session[:omniauth_provider]
      return unless provider_name

      provider = ::OpenProject::Plugins::AuthPlugin.find_provider_by_name(provider_name)
      return unless provider && provider[:retain_from_session]

      retained_keys = provider[:retain_from_session] + ['omniauth_provider']
      controller.session.to_h.slice(*retained_keys)
    end

    ##
    # We can only drop old sessions if they're stored in the database
    # and enabled by configuration.
    def drop_old_sessions?
      OpenProject::Configuration.drop_old_sessions_on_login?
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Users::LoginService, type: :model do
  shared_let(:input_user) { create(:user) }
  let(:request) { {} }
  let(:session) { {} }
  let(:browser) do
    instance_double(Browser::Safari,
                    name: 'Safari',
                    version: '13.2',
                    platform: instance_double(Browser::Platform::Linux, name: 'Linux'))
  end
  let(:cookies) { {} }
  let(:flash) { ActionDispatch::Flash::FlashHash.new }
  let(:controller) { instance_double(ApplicationController, browser:, cookies:, session:, flash:) }

  let(:instance) { described_class.new(user: input_user, controller:, request:) }

  subject { instance.call! }

  before do
    allow(controller)
      .to(receive(:reset_session)) do
      session.clear
      flash.clear
    end

    allow(input_user)
      .to receive(:log_successful_login)
  end

  describe 'session' do
    context 'with an SSO provider' do
      let(:sso_provider) do
        {
          name: 'saml',
          retain_from_session: %i[foo bar]
        }
      end

      before do
        allow(OpenProject::Plugins::AuthPlugin)
          .to(receive(:find_provider_by_name))
          .with('provider_name')
          .and_return sso_provider
      end

      context 'if provider retains session values' do
        let(:retained_values) { %i[foo bar] }

        it 'retains present session values' do
          session[:omniauth_provider] = 'provider_name'
          session[:foo] = 'foo value'
          session[:what] = 'should be cleared'

          subject

          expect(session[:foo]).to be_present
          expect(session[:what]).to be_nil
          expect(session[:user_id]).to eq input_user.id
        end
      end

      it 'retains present flash values' do
        flash[:notice] = 'bar' # rubocop:disable Rails/I18nLocaleTexts

        subject

        expect(controller.flash[:notice]).to eq 'bar'
      end
    end
  end

  describe 'autologin cookie' do
    before do
      session[:autologin_requested] = true if autologin_requested
    end

    shared_examples 'does not set autologin cookie' do
      it 'does not set a cookie' do
        subject

        expect(Token::AutoLogin.exists?(user: input_user)).to be false
        expect(cookies[OpenProject::Configuration['autologin_cookie_name']]).to be_nil
      end
    end

    context 'when not requested and disabled', with_settings: { autologin: 0 } do
      let(:autologin_requested) { false }

      it_behaves_like 'does not set autologin cookie'
    end

    context 'when not requested and enabled', with_settings: { autologin: 1 } do
      let(:autologin_requested) { false }

      it_behaves_like 'does not set autologin cookie'
    end

    context 'when requested, but disabled', with_settings: { autologin: 0 } do
      let(:autologin_requested) { true }

      it_behaves_like 'does not set autologin cookie'
    end

    context 'when requested and enabled', with_settings: { autologin: 1 } do
      let(:autologin_requested) { true }

      it 'sets a cookie' do
        subject

        tokens = Token::AutoLogin.where(user: input_user)
        expect(tokens.count).to eq 1
        expect(tokens.first.user_id).to eq input_user.id

        autologin_cookie = cookies[OpenProject::Configuration['autologin_cookie_name']]
        expect(autologin_cookie).to be_present
        expect(autologin_cookie[:value]).to be_present
        expect(autologin_cookie[:expires]).to eq (Time.zone.today + 1.day).beginning_of_day
        expect(autologin_cookie[:path]).to eq '/'
        expect(autologin_cookie[:httponly]).to be true
        expect(autologin_cookie[:secure]).to eq Setting.https?
        expect(Token::AutoLogin.find_by_plaintext_value(autologin_cookie[:value])).to eq tokens.first
      end
    end

    context 'when requested and enabled with https',
            with_config: { https: true },
            with_settings: { autologin: 1 } do
      let(:autologin_requested) { true }

      it 'sets a secure cookie' do
        subject

        autologin_cookie = cookies[OpenProject::Configuration['autologin_cookie_name']]
        expect(autologin_cookie[:secure]).to be true
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class CustomActions::UpdateWorkPackageService
  include Shared::BlockService
  include Contracted

  attr_accessor :user,
                :action

  def initialize(action:, user:)
    self.action = action
    self.user = user
    self.contract_class = ::WorkPackages::UpdateContract
  end

  def call(work_package:, &block)
    apply_actions(work_package, action.actions)

    result = ::WorkPackages::UpdateService
             .new(user:,
                  model: work_package)
             .call

    block_with_result(result, &block)
  end

  private

  def apply_actions(work_package, actions)
    changes_before = work_package.changes.dup

    apply_actions_sorted(work_package, actions)

    success, errors = validate(work_package, user)
    unless success
      retry_apply_actions(work_package, actions, errors, changes_before)
    end
  end

  def retry_apply_actions(work_package, actions, errors, changes_before)
    new_actions = without_invalid_actions(actions, errors)

    if new_actions.any? && actions.length != new_actions.length
      work_package.restore_attributes(work_package.changes.keys - changes_before.keys)

      apply_actions(work_package, new_actions)
    end
  end

  def without_invalid_actions(actions, errors)
    invalid_keys = errors.attribute_names.map { |k| append_id(k) }

    actions.reject { |a| invalid_keys.include?(append_id(a.key)) }
  end

  def apply_actions_sorted(work_package, actions)
    actions
      .sort_by(&:priority)
      .each { |a| a.apply(work_package) }
  end

  def append_id(sym)
    ""#{sym.to_s.chomp('_id')}_id""
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe CustomActions::UpdateWorkPackageService do
  let(:custom_action) do
    action = build_stubbed(:custom_action)

    allow(action)
      .to receive(:actions)
      .and_return([alter_action1, alter_action2])

    action
  end
  let(:alter_action1) do
    action = double('custom actions action 1', key: 'abc', priority: 100)

    allow(action)
      .to receive(:apply)
      .with(work_package) do
      work_package.subject = ''
    end

    action
  end
  let(:alter_action2) do
    action = double('custom actions action 2', key: 'def', priority: 10)

    allow(action)
      .to receive(:apply)
      .with(work_package) do
      work_package.status_id = 100
    end

    action
  end
  let(:user) { build_stubbed(:user) }
  let(:instance) { described_class.new(action: custom_action, user:) }
  let(:update_service_call_implementation) do
    -> do
      result
    end
  end
  let!(:update_wp_service) do
    wp_service_instance = instance_double(WorkPackages::UpdateService)

    allow(WorkPackages::UpdateService)
      .to receive(:new)
      .with(user:, model: work_package)
      .and_return(wp_service_instance)

    allow(wp_service_instance)
      .to receive(:call) do
      update_service_call_implementation.()
    end

    wp_service_instance
  end
  let(:work_package) { build_stubbed(:work_package) }
  let(:result) do
    ServiceResult.success(result: work_package)
  end
  let(:validation_result) { true }
  let!(:contract) do
    contract = double('contract')

    allow(WorkPackages::UpdateContract)
      .to receive(:new)
      .with(work_package, user, options: {})
      .and_return(contract)

    allow(contract)
      .to receive(:validate)
      .and_return(validation_result)

    contract
  end

  describe '#call' do
    let(:call) do
      instance.call(work_package:)
    end
    let(:subject) { call }

    it 'returns the update wp service result' do
      expect(call)
        .to eql result
    end

    it 'yields the result' do
      yielded = false

      proc = Proc.new do |call|
        yielded = call
      end

      instance.call(work_package:, &proc)

      expect(yielded)
        .to be_success
    end

    it 'calls each registered action with the work package' do
      [alter_action1, alter_action2].each do |alter_action|
        expect(alter_action)
          .to receive(:apply)
          .with(work_package)
      end

      call
    end

    it 'calls the registered actions based on their priority' do
      call_order = []

      [alter_action1, alter_action2].each do |alter_action|
        allow(alter_action)
          .to receive(:apply)
          .with(work_package) do
          call_order << alter_action
        end
      end

      call

      expect(call_order)
        .to eql [alter_action2, alter_action1]
    end

    context 'on validation error' do
      before do
        allow(contract)
          .to receive(:validate) do
          work_package.subject.present?
        end

        allow(contract)
          .to receive(:errors)
          .and_return(instance_double(ActiveModel::Errors, attribute_names: [alter_action1.key]))

        work_package.lock_version = 200

        subject
      end

      let(:update_service_call_implementation) do
        -> do
          # check that the work package retains only the valid changes
          # when passing it to the update service
          expect(work_package.subject)
            .not_to eql ''

          expect(work_package.status_id)
            .to be 100

          expect(work_package.lock_version)
            .to be 200

          result
        end
      end

      it 'is successful' do
        expect(subject)
          .to be_success
      end
    end

    context 'on unfixable validation error' do
      let(:result) do
        ServiceResult.failure(result: work_package)
      end
      let(:update_service_call_implementation) do
        -> do
          # check that the work package has all the changes
          # of the actions when passing it to the update service
          expect(work_package.subject)
            .to be_blank

          expect(work_package.status_id)
            .to be 100

          expect(work_package.lock_version)
            .to be 200

          result
        end
      end

      before do
        allow(contract)
          .to receive(:validate)
          .and_return(false)

        allow(contract)
          .to receive(:errors)
          .and_return(instance_double(ActiveModel::Errors, attribute_names: [:base]))

        work_package.lock_version = 200

        subject
      end

      it 'is failure' do
        expect(subject)
          .to be_failure
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class CustomActions::UpdateService < CustomActions::BaseService
  attr_accessor :user,
                :action

  def initialize(action:, user:)
    self.action = action
    self.user = user
  end

  def call(attributes:, &block)
    super(attributes:, action:, &block)
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe CustomActions::UpdateService do
  let(:action) do
    action = build_stubbed(:custom_action)

    allow(action)
      .to receive(:save)
      .and_return(save_success)

    action
  end
  let(:user) { build_stubbed(:user) }
  let(:save_success) { true }
  let(:contract_success) { true }
  let(:contract_errors) { double('contract errors') }
  let(:instance) do
    contract
    described_class.new(action:, user:)
  end
  let(:contract) do
    contract_instance = double('contract instance')

    allow(CustomActions::CuContract)
      .to receive(:new)
      .with(action)
      .and_return(contract_instance)

    allow(contract_instance)
      .to receive(:validate)
      .and_return(contract_success)
    allow(contract_instance)
      .to receive(:errors)
      .and_return(contract_errors)

    contract_instance
  end

  describe '#call' do
    it 'is successful' do
      expect(instance.call(attributes: {}))
        .to be_success
    end

    it 'is has the action in the result' do
      expect(instance.call(attributes: {}).result)
        .to eql action
    end

    it 'yields the result' do
      yielded = false

      proc = Proc.new do |call|
        yielded = call
      end

      instance.call(attributes: {}, &proc)

      expect(yielded)
        .to be_success
    end

    context 'unsuccessful saving' do
      let(:save_success) { false }

      it 'yields the result' do
        yielded = false

        proc = Proc.new do |call|
          yielded = call
        end

        instance.call(attributes: {}, &proc)

        expect(yielded)
          .to be_failure
      end
    end

    context 'unsuccessful contract' do
      let(:contract_success) { false }

      it 'yields the result' do
        yielded = false

        proc = Proc.new do |call|
          yielded = call
        end

        instance.call(attributes: {}, &proc)

        expect(yielded)
          .to be_failure
      end
    end

    it 'sets the name of the action' do
      expect(instance.call(attributes: { name: 'new name' }).result.name)
        .to eql 'new name'
    end

    it 'updates the actions' do
      action.actions = [CustomActions::Actions::AssignedTo.new('1'),
                        CustomActions::Actions::Status.new('3')]

      new_actions = instance
                    .call(attributes: { actions: { assigned_to: ['2'], priority: ['3'] } })
                    .result
                    .actions
                    .map { |a| [a.key, a.values] }

      expect(new_actions)
        .to match_array [[:assigned_to, [2]], [:priority, [3]]]
    end

    it 'handles unknown actions' do
      new_actions = instance
                    .call(attributes: { actions: { some_bogus_name: ['3'] } })
                    .result
                    .actions
                    .map { |a| [a.key, a.values] }

      expect(new_actions)
        .to match_array [[:inexistent, ['3']]]
    end

    it 'updates the conditions' do
      old_status = create(:status)
      new_status = create(:status)

      action.conditions = [CustomActions::Conditions::Status.new(old_status.id)]

      new_conditions = instance
                       .call(attributes: { conditions: { status: new_status.id } })
                       .result
                       .conditions
                       .map { |a| [a.key, a.values] }

      expect(new_conditions)
        .to match_array [[:status, [new_status.id]]]
    end

    it 'handles unknown conditions' do
      new_conditions = instance
                       .call(attributes: { conditions: { some_bogus_name: ['3'] } })
                       .result
                       .conditions
                       .map { |a| [a.key, a.values] }

      expect(new_conditions)
        .to match_array [[:inexistent, [3]]]
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module API
  class ParserStruct < ::Hashie::Mash
    ##
    # Hashie::Mash extends from Hash
    # and by default does not allow overriding any enumerable methods.
    #
    # This clashes with names (e.g. +group_by+) occurring when parsing in the API.
    # Undefining the method allows to set and get the parsed value without conflicts.
    undef_method :group_by
  end
end

```","#  OpenProject is an open source project management software.
#  Copyright (C) 2010-2022 the OpenProject GmbH
#
#  This program is free software; you can redistribute it and/or
#  modify it under the terms of the GNU General Public License version 3.
#
#  OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
#  Copyright (C) 2006-2013 Jean-Philippe Lang
#  Copyright (C) 2010-2013 the ChiliProject Team
#
#  This program is free software; you can redistribute it and/or
#  modify it under the terms of the GNU General Public License
#  as published by the Free Software Foundation; either version 2
#  of the License, or (at your option) any later version.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
#  See COPYRIGHT and LICENSE files for more details.

require 'spec_helper'

RSpec.describe API::ParserStruct do
  let(:instance) { described_class.new }

  describe 'assigning a value and method creation' do
    # Dynamically creating a method can be misused when allowing
    # those method are generated based on client input.
    # See ""Symbol denial of service"" at
    # https://ruby-doc.org/stdlib-3.0.0/libdoc/ostruct/rdoc/OpenStruct.html#class-OpenStruct-label-Caveats.
    it 'does not dynamically create a method' do
      instance.some_method = 'string'

      expect(instance.methods.grep(/some_method/))
        .to be_empty
    end
  end

  describe 'assigning an value and getting a hash' do
    it 'works for [value]=' do
      instance.some_value = 'string'

      expect(instance.to_h)
        .to eql('some_value' => 'string')
    end

    it 'works for [value]_id=' do
      instance.some_value_id = 5

      expect(instance.to_h)
        .to eql('some_value_id' => 5)
    end

    it 'works for group_by=' do
      instance.group_by = 8

      expect(instance.to_h)
        .to eql('group_by' => 8)
    end
  end

  describe 'assigning an value and getting by hash key' do
    it 'works for [value]=' do
      instance.some_value = 'string'

      expect(instance[:some_value])
        .to eq('string')
    end

    it 'works for [value]_id=' do
      instance.some_value_id = 5

      expect(instance[:some_value_id])
        .to eq(5)
    end

    it 'works for group_by=' do
      instance.group_by = 8

      expect(instance[:group_by])
        .to eq(8)
    end
  end

  describe 'instantiating with a hash and fetching the value' do
    let(:instance) do
      described_class
        .new({ 'some_value' => 'string', 'some_value_id' => 5, 'group_by' => 8 })
    end

    it 'allows fetching the value' do
      expect(instance.to_h)
        .to eql({ 'some_value' => 'string', 'some_value_id' => 5, 'group_by' => 8 })
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module API
  module V3
    class WorkPackageCollectionFromQueryService
      include Utilities::PathHelper
      include ::API::Utilities::UrlPropsParsingHelper

      def initialize(query, user, scope: nil)
        self.query = query
        self.current_user = user
        self.scope = scope
      end

      def call(params = {}, valid_subset: false)
        update = UpdateQueryFromV3ParamsService
                 .new(query, current_user)
                 .call(params, valid_subset:)

        if update.success?
          representer = results_to_representer(params)

          ServiceResult.success(result: representer)
        else
          update
        end
      end

      private

      def results_to_representer(params)
        results_scope = query.results.work_packages

        if scope
          results_scope = results_scope.where(id: scope.select(:id))
        end

        collection_representer(results_scope,
                               params:,
                               project: query.project,
                               groups: generate_groups,
                               sums: generate_total_sums)
      end

      attr_accessor :query,
                    :current_user,
                    :scope

      def representer
        ::API::V3::WorkPackages::WorkPackageCollectionRepresenter
      end

      def calculate_resulting_params(provided_params)
        calculate_default_params
          .merge(provided_params.slice('offset', 'pageSize').symbolize_keys)
          .tap do |params|
          if query.manually_sorted?
            params[:query_id] = query.id
            params[:offset] = 1
            # Force the setting value in all cases except when 0 is requested explicitly. Fetching with pageSize = 0
            # is done for performance reasons to simply get the query without the results.
            params[:pageSize] = pageSizeParam(params) == 0 ? pageSizeParam(params) : Setting.forced_single_page_size
          else
            params[:offset] = to_i_or_nil(params[:offset])
            params[:pageSize] = pageSizeParam(params)
          end

          params[:select] = nested_from_csv(provided_params['select']) if provided_params['select']
        end
      end

      def calculate_default_params
        ::API::V3::Queries::QueryParamsRepresenter
          .new(query)
          .to_h
      end

      def generate_groups
        return unless query.grouped?

        results = query.results
        sums = generate_group_sums

        results.work_package_count_by_group.map do |group, count|
          ::API::V3::WorkPackages::WorkPackageAggregationGroup.new(
            group, count, query:, sums: sums[group], current_user:
          )
        end
      end

      def generate_total_sums
        return unless query.display_sums?

        format_query_sums query.results.all_total_sums
      end

      def generate_group_sums
        return {} unless query.display_sums?

        query.results.all_group_sums.transform_values do |v|
          format_query_sums(v)
        end
      end

      def format_query_sums(sums)
        API::ParserStruct.new(format_column_keys(sums).merge(available_custom_fields: WorkPackageCustomField.summable.to_a))
      end

      def format_column_keys(hash_by_column)
        hash_by_column.map do |column, value|
          match = /cf_(\d+)/.match(column.name.to_s)

          column_name = if match
                          ""custom_field_#{match[1]}""
                        else
                          column.name.to_s
                        end

          [column_name, value]
        end.to_h
      end

      def collection_representer(work_packages, params:, project:, groups:, sums:)
        resulting_params = calculate_resulting_params(params)

        if resulting_params[:select]
          ::API::V3::Utilities::SqlRepresenterWalker
            .new(work_packages,
                 current_user:,
                 self_path: self_link(project),
                 url_query: resulting_params)
            .walk(::API::V3::WorkPackages::WorkPackageSqlCollectionRepresenter)
        else
          ::API::V3::WorkPackages::WorkPackageCollectionRepresenter.new(
            work_packages,
            self_link: self_link(project),
            project:,
            query_params: resulting_params,
            page: resulting_params[:offset],
            per_page: resulting_params[:pageSize],
            groups:,
            total_sums: sums,
            embed_schemas: true,
            current_user:,
            timestamps: query.timestamps,
            query:
          )
        end
      end

      def to_i_or_nil(value)
        value ? value.to_i : nil
      end

      def pageSizeParam(params)
        to_i_or_nil(params[:pageSize])
      end

      def self_link(project)
        if project
          api_v3_paths.work_packages_by_project(project.id)
        else
          api_v3_paths.work_packages
        end
      end

      def convert_to_v3(attribute)
        ::API::Utilities::PropertyNameConverter.from_ar_name(attribute).to_sym
      end
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe API::V3::WorkPackageCollectionFromQueryService,
               type: :model do
  include API::V3::Utilities::PathHelper

  let(:query) do
    build_stubbed(:query).tap do |query|
      allow(query)
        .to receive(:results)
        .and_return(results)

      allow(query)
        .to receive(:manually_sorted?)
        .and_return(query_manually_sorted)
    end
  end
  let(:query_manually_sorted) { false }

  let(:results) do
    results = double('results')

    allow(results)
      .to receive(:work_packages)
      .and_return([work_package])

    allow(results)
      .to receive(:all_total_sums)
      .and_return(OpenStruct.new(name: :estimated_hours) => 0.0)

    allow(results)
      .to receive(:work_package_count_by_group)
      .and_return(1 => 5, 2 => 10)

    allow(results)
      .to receive(:all_group_sums)
      .and_return(1 => { OpenStruct.new(name: :status_id) => 50 },
                  2 => { OpenStruct.new(name: :status_id) => 100 })

    allow(results)
      .to receive(:query)
      .and_return(double('query'))

    results
  end

  let(:user) { build_stubbed(:user) }
  let(:project) { build_stubbed(:project) }
  let(:mock_wp_representer) do
    Struct.new(:work_packages,
               :self_link,
               :query_params,
               :project,
               :groups,
               :total_sums,
               :page,
               :per_page,
               :embed_schemas,
               :current_user,
               :timestamps,
               :query) do
      def initialize(work_packages,
                     self_link:,
                     query_params:,
                     project:,
                     groups:,
                     total_sums:,
                     page:,
                     per_page:,
                     embed_schemas:,
                     current_user:,
                     timestamps:,
                     query:)
        super(work_packages,
              self_link,
              query_params,
              project,
              groups,
              total_sums,
              page,
              per_page,
              embed_schemas,
              current_user,
              timestamps,
              query)
      end
    end
  end

  let(:mock_aggregation_representer) do
    Struct.new(:group,
               :count,
               :query,
               :sums,
               :current_user) do
      def initialize(group,
                     count,
                     query:,
                     sums:,
                     current_user:)
        super(group,
              count,
              query,
              sums,
              current_user)
      end
    end
  end

  let(:params) { {} }

  let(:mock_update_query_service) do
    mock = double('UpdateQueryFromV3ParamsService')

    allow(mock)
      .to receive(:call)
      .with(params, valid_subset: false)
      .and_return(mock_update_query_service_response)

    mock
  end

  let(:mock_update_query_service_response) do
    ServiceResult.new(success: update_query_service_success,
                      errors: update_query_service_errors,
                      result: update_query_service_result)
  end

  let(:update_query_service_success) { true }
  let(:update_query_service_errors) { nil }
  let(:update_query_service_result) { query }

  let(:work_package) { build_stubbed(:work_package) }

  let(:instance) { described_class.new(query, user) }

  describe '#call' do
    subject { instance.call(params) }

    before do
      stub_const('::API::V3::WorkPackages::WorkPackageCollectionRepresenter', mock_wp_representer)
      stub_const('::API::V3::WorkPackages::WorkPackageAggregationGroup', mock_aggregation_representer)

      allow(API::V3::UpdateQueryFromV3ParamsService)
        .to receive(:new)
        .with(query, user)
        .and_return(mock_update_query_service)
    end

    it 'is successful' do
      expect(subject).to be_success
    end

    context 'result' do
      subject { instance.call(params).result }

      it 'is a WorkPackageCollectionRepresenter' do
        expect(subject)
          .to be_a(API::V3::WorkPackages::WorkPackageCollectionRepresenter)
      end

      context 'work_packages' do
        it ""has the query's work_package results set"" do
          expect(subject.work_packages)
            .to contain_exactly(work_package)
        end
      end

      context 'current_user' do
        it 'has the provided user set' do
          expect(subject.current_user)
            .to eq(user)
        end
      end

      context 'project' do
        it 'has the queries project set' do
          expect(subject.project)
            .to eq(query.project)
        end
      end

      context 'self_link' do
        context 'if the project is nil' do
          let(:query) { build_stubbed(:query, project: nil) }

          it 'is the global work_package link' do
            expect(subject.self_link)
              .to eq(api_v3_paths.work_packages)
          end
        end

        context 'if the project is set' do
          let(:query) { build_stubbed(:query, project:) }

          it 'is the global work_package link' do
            expect(subject.self_link)
              .to eq(api_v3_paths.work_packages_by_project(project.id))
          end
        end
      end

      context 'embed_schemas' do
        it 'is true' do
          expect(subject.embed_schemas)
            .to be_truthy
        end
      end

      context 'when timestamps are given' do
        let(:timestamps) { [Timestamp.parse(""P-1Y""), Timestamp.parse(""oneWeekAgo@12:00+00:00""), Timestamp.now] }
        let(:query) { build_stubbed(:query, timestamps:) }

        it 'has the query timestamps' do
          expect(subject.timestamps)
            .to match_array(timestamps)
        end
      end

      context 'when a _query object is given' do
        it 'has the query' do
          expect(subject.query)
            .to eq(query)
        end
      end

      context 'total_sums' do
        context 'with query.display_sums? being false' do
          it 'is nil' do
            query.display_sums = false

            expect(subject.total_sums)
              .to be_nil
          end
        end

        context 'with query.display_sums? being true' do
          it 'has a struct containing the sums and the available custom fields' do
            query.display_sums = true

            custom_fields = [build_stubbed(:text_wp_custom_field),
                             build_stubbed(:integer_wp_custom_field)]

            allow(WorkPackageCustomField)
              .to receive(:summable)
              .and_return(custom_fields)

            expected = API::ParserStruct.new(estimated_hours: 0.0, available_custom_fields: custom_fields)

            expect(subject.total_sums)
              .to eq(expected)
          end
        end
      end

      context 'groups' do
        context 'with query.grouped? being false' do
          it 'is nil' do
            query.group_by = nil

            expect(subject.groups)
              .to be_nil
          end
        end

        context 'with query.group_by being empty' do
          it 'is nil' do
            query.group_by = ''

            expect(subject.groups)
              .to be_nil
          end
        end

        context 'with query.grouped? being true' do
          it 'has the groups' do
            query.group_by = 'status'

            expect(subject.groups[0].group)
              .to eq(1)
            expect(subject.groups[0].count)
              .to eq(5)
            expect(subject.groups[1].group)
              .to eq(2)
            expect(subject.groups[1].count)
              .to eq(10)
          end
        end
      end

      context 'query (in the url)' do
        context 'when displaying sums' do
          it 'is represented' do
            query.display_sums = true

            expect(subject.query_params[:showSums])
              .to be(true)
          end
        end

        context 'when displaying hierarchies' do
          it 'is represented' do
            query.show_hierarchies = true

            expect(subject.query_params[:showHierarchies])
              .to be(true)
          end
        end

        context 'when grouping' do
          it 'is represented' do
            query.group_by = 'status_id'

            expect(subject.query_params[:groupBy])
              .to eq('status_id')
          end
        end

        context 'when sorting' do
          it 'is represented' do
            query.sort_criteria = [['status_id', 'desc']]

            expected_sort = JSON::dump [['status', 'desc']]

            expect(subject.query_params[:sortBy])
              .to eq(expected_sort)
          end
        end

        context 'filters' do
          it 'is represented' do
            query.add_filter('status_id', '=', ['1', '2'])
            query.add_filter('subproject_id', '=', ['3', '4'])

            expected_filters = JSON::dump([
                                            { status: { operator: '=', values: ['1', '2'] } },
                                            { subprojectId: { operator: '=', values: ['3', '4'] } }
                                          ])

            expect(subject.query_params[:filters])
              .to eq(expected_filters)
          end

          it 'represents no filters' do
            expected_filters = JSON::dump([])

            expect(subject.query_params[:filters])
              .to eq(expected_filters)
          end
        end
      end

      context 'offset' do
        it 'is 1 as default' do
          expect(subject.query_params[:offset])
            .to be(1)
        end

        context 'with a provided value' do
          # It is imporant for the keys to be strings
          # as that is what will come from the client
          let(:params) { { 'offset' => 3 } }

          it 'is that value' do
            expect(subject.query_params[:offset])
              .to be(3)
          end
        end
      end

      context 'pageSize' do
        before do
          allow(Setting)
            .to receive(:per_page_options_array)
            .and_return([25, 50])
        end

        it 'is nil' do
          expect(subject.query_params[:pageSize])
            .to be(25)
        end

        context 'with a provided value' do
          # It is imporant for the keys to be strings
          # as that is what will come from the client
          let(:params) { { 'pageSize' => 100 } }

          it 'is that value' do
            expect(subject.query_params[:pageSize])
              .to be(100)
          end
        end

        context 'with the query sorted manually', with_settings: { forced_single_page_size: 42 } do
          let(:query_manually_sorted) { true }

          it 'is the setting value' do
            expect(subject.query_params[:pageSize])
              .to be(42)
          end

          context 'with a provided value' do
            let(:params) { { 'pageSize' => 100 } }

            it 'is the setting value' do
              expect(subject.query_params[:pageSize])
                .to be(42)
            end
          end

          context 'with a provided value of 0' do
            let(:params) { { 'pageSize' => 0 } }

            it 'is the provided value' do
              expect(subject.query_params[:pageSize])
                .to be(0)
            end
          end
        end
      end
    end

    context 'when the update query service fails' do
      let(:update_query_service_success) { false }
      let(:update_query_service_errors) { double('errors') }
      let(:update_query_service_result) { nil }

      it 'returns the update service response' do
        expect(subject)
          .to eql(mock_update_query_service_response)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module API
  module V3
    class UpdateQueryFromV3ParamsService
      def initialize(query, user)
        self.query = query
        self.current_user = user
      end

      def call(params, valid_subset: false)
        parsed = ::API::V3::ParseQueryParamsService
                 .new
                 .call(params)

        if parsed.success?
          ::UpdateQueryFromParamsService
            .new(query, current_user)
            .call(parsed.result, valid_subset:)
        else
          parsed
        end
      end

      attr_accessor :query,
                    :current_user
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe API::V3::UpdateQueryFromV3ParamsService,
               type: :model do
  let(:user) { build_stubbed(:user) }
  let(:query) { build_stubbed(:query) }

  let(:params) { double('params') }
  let(:parsed_params) { double('parsed_params') }

  let(:mock_parse_query_service) do
    mock = double('ParseQueryParamsService')

    allow(mock)
      .to receive(:call)
      .with(params)
      .and_return(mock_parse_query_service_response)

    mock
  end

  let(:mock_parse_query_service_response) do
    ServiceResult.new(success: mock_parse_query_service_success,
                      errors: mock_parse_query_service_errors,
                      result: mock_parse_query_service_result)
  end

  let(:mock_parse_query_service_success) { true }
  let(:mock_parse_query_service_errors) { nil }
  let(:mock_parse_query_service_result) { parsed_params }

  let(:mock_update_query_service) do
    mock = double('UpdateQueryFromParamsService')

    allow(mock)
      .to receive(:call)
      .with(parsed_params, valid_subset: false)
      .and_return(mock_update_query_service_response)

    mock
  end

  let(:mock_update_query_service_response) do
    ServiceResult.new(success: mock_update_query_service_success,
                      errors: mock_update_query_service_errors,
                      result: mock_update_query_service_result)
  end

  let(:mock_update_query_service_success) { true }
  let(:mock_update_query_service_errors) { nil }
  let(:mock_update_query_service_result) { query }

  let(:instance) { described_class.new(query, user) }

  before do
    allow(UpdateQueryFromParamsService)
      .to receive(:new)
      .with(query, user)
      .and_return(mock_update_query_service)
    allow(API::V3::ParseQueryParamsService)
      .to receive(:new)
      .with(no_args)
      .and_return(mock_parse_query_service)
  end

  describe '#call' do
    subject { instance.call(params) }

    it 'returns the update result' do
      expect(subject)
        .to eql(mock_update_query_service_response)
    end

    context 'when parsing fails' do
      let(:mock_parse_query_service_success) { false }
      let(:mock_parse_query_service_errors) { double 'error' }
      let(:mock_parse_query_service_result) { nil }

      it 'returns the parse result' do
        expect(subject)
          .to eql(mock_parse_query_service_response)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module API
  module V3
    class WorkPackageCollectionFromQueryParamsService
      def initialize(user, scope: nil)
        self.current_user = user
        self.scope = scope
      end

      def call(params = {})
        query = Query.new_default(project: params[:project])

        WorkPackageCollectionFromQueryService
          .new(query, current_user, scope:)
          .call(params, valid_subset: params['valid_subset'].present?)
      end

      private

      attr_accessor :current_user,
                    :scope
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe API::V3::WorkPackageCollectionFromQueryParamsService,
               type: :model do
  include API::V3::Utilities::PathHelper

  let(:mock_wp_collection_from_query_service) do
    mock = double('WorkPackageCollectionFromQueryService')

    allow(mock)
      .to receive(:call)
      .and_return(mock_wp_collection_service_response)

    mock
  end

  let(:mock_wp_collection_service_response) do
    ServiceResult.new(success: mock_wp_collection_service_success,
                      errors: mock_wp_collection_service_errors,
                      result: mock_wp_collection_service_result)
  end

  let(:mock_wp_collection_service_success) { true }
  let(:mock_wp_collection_service_errors) { nil }
  let(:mock_wp_collection_service_result) { double('result') }

  let(:query) { build_stubbed(:query) }
  let(:project) { build_stubbed(:project) }
  let(:user) { build_stubbed(:user) }

  let(:instance) { described_class.new(user) }

  before do
    stub_const('::API::V3::WorkPackageCollectionFromQueryService',
               mock_wp_collection_from_query_service)

    allow(API::V3::WorkPackageCollectionFromQueryService)
      .to receive(:new)
      .with(query, user, scope: nil)
      .and_return(mock_wp_collection_from_query_service)
  end

  describe '#call' do
    let(:params) { { project: } }

    subject { instance.call(params) }

    before do
      allow(Query)
        .to receive(:new_default)
        .with(project:)
        .and_return(query)
    end

    it 'is successful' do
      expect(subject)
        .to eql(mock_wp_collection_service_response)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module API
  module V3
    class ParseQueryParamsService
      KEYS_GROUP_BY = %i(group_by groupBy g).freeze
      KEYS_COLUMNS = %i(columns c column_names columns[]).freeze

      def call(params)
        json_parsed = json_parsed_params(params)
        return json_parsed if json_parsed.failure?

        parsed = parsed_params(params)
        return parsed if parsed.failure?

        result = without_empty(parsed.result.merge(json_parsed.result), determine_allowed_empty(params))

        ServiceResult.success(result:)
      end

      private

      def json_parsed_params(params)
        parsed = {
          filters: filters_from_params(params),
          sort_by: sort_by_from_params(params),
          timeline_labels: timeline_labels_from_params(params)
        }

        ServiceResult.success result: parsed
      rescue ::JSON::ParserError => e
        result = ServiceResult.failure
        result.errors.add(:base, e.message)
        result
      end

      # rubocop:disable Metrics/AbcSize
      def parsed_params(params)
        ServiceResult.success result: {
          group_by: group_by_from_params(params),
          columns: columns_from_params(params),
          display_sums: boolearize(params[:showSums]),
          timeline_visible: boolearize(params[:timelineVisible]),
          timeline_zoom_level: params[:timelineZoomLevel],
          highlighting_mode: params[:highlightingMode],
          highlighted_attributes: highlighted_attributes_from_params(params),
          display_representation: params[:displayRepresentation],
          show_hierarchies: boolearize(params[:showHierarchies]),
          include_subprojects: boolearize(params[:includeSubprojects]),
          timestamps: Timestamp.parse_multiple(params[:timestamps])
        }
      rescue ArgumentError => e
        result = ServiceResult.failure
        result.errors.add(:base, e.message)
        result
      end
      # rubocop:enable Metrics/AbcSize

      def determine_allowed_empty(params)
        allow_empty = params.keys
        allow_empty << :group_by if group_by_empty?(params)

        allow_empty
      end

      # Group will be set to nil if parameter exists but set to empty string ('')
      def group_by_from_params(params)
        return nil unless params_exist?(params, KEYS_GROUP_BY)

        attribute = params_value(params, KEYS_GROUP_BY)
        if attribute.present?
          convert_attribute attribute
        end
      end

      def sort_by_from_params(params)
        return unless params[:sortBy]

        parse_sorting_from_json(params[:sortBy])
      end

      def timeline_labels_from_params(params)
        return unless params[:timelineLabels]

        JSON.parse(params[:timelineLabels])
      end

      # Expected format looks like:
      # [
      #   {
      #     ""filtered_field_name"": {
      #       ""operator"": ""a name for a filter operation"",
      #       ""values"": [""values"", ""for the"", ""operation""]
      #     }
      #   },
      #   { /* more filters if needed */}
      # ]
      def filters_from_params(params)
        filters = params[:filters] || params[:filter]
        return unless filters

        filters = JSON.parse filters if filters.is_a? String

        filters.map do |filter|
          filter_from_params(filter)
        end
      end

      def filter_from_params(filter)
        attribute = filter.keys.first # there should only be one attribute per filter
        operator =  filter[attribute]['operator']
        values = Array(filter[attribute]['values'])
        ar_attribute = convert_filter_attribute attribute, append_id: true

        { field: ar_attribute,
          operator:,
          values: }
      end

      def columns_from_params(params)
        columns = params_value(params, KEYS_COLUMNS)

        return unless columns

        columns.map do |column|
          convert_attribute(column)
        end
      end

      def highlighted_attributes_from_params(params)
        highlighted_attributes = Array(params[:highlightedAttributes].presence)

        return if highlighted_attributes.blank?

        highlighted_attributes.map do |href|
          attr = href.split('/').last
          convert_attribute(attr)
        end
      end

      def boolearize(value)
        case value
        when 'true'
          true
        when 'false'
          false
        end
      end

      ##
      # Maps given field names coming from the frontend to the actual names
      # as expected by the query. This works slightly different to what happens
      # in #column_names_from_params. For instance while they column name is
      # :type the expected field name is :type_id.
      #
      # Examples:
      #   * status => status_id
      #   * progresssDone => done_ratio
      #   * assigned => assigned_to
      #   * customField1 => cf_1
      #
      # @param field_names [Array] Field names as read from the params.
      # @return [Array] Returns a list of fixed field names. The list may contain nil values
      #                 for fields which could not be found.
      def fix_field_array(field_names)
        return [] if field_names.nil?

        field_names
          .map { |name| convert_attribute name, append_id: true }
      end

      def parse_sorting_from_json(json)
        JSON.parse(json).map do |order|
          attribute, direction = case order
                                 when Array
                                   [order.first, order.last]
                                 when String
                                   order.split(':')
                                 end

          [convert_attribute(attribute), direction]
        end
      end

      def convert_attribute(attribute, append_id: false)
        ::API::Utilities::WpPropertyNameConverter.to_ar_name(attribute,
                                                             refer_to_ids: append_id)
      end

      def convert_filter_attribute(attribute, append_id: false)
        ::API::Utilities::QueryFiltersNameConverter.to_ar_name(attribute,
                                                               refer_to_ids: append_id)
      end

      def params_exist?(params, symbols)
        unsafe_params(params).detect { |k, _| symbols.include? k.to_sym }
      end

      def params_value(params, symbols)
        params.slice(*symbols).first&.last
      end

      ##
      # Access the parameters as a hash, which has been deprecated
      def unsafe_params(params)
        if params.is_a? ActionController::Parameters
          params.to_unsafe_h
        else
          params
        end
      end

      def without_empty(hash, exceptions)
        exceptions = exceptions.map(&:to_sym)
        hash.select { |k, v| v.present? || v == false || exceptions.include?(k) }
      end

      def group_by_empty?(params)
        params_exist?(params, KEYS_GROUP_BY) &&
          params_value(params, KEYS_GROUP_BY).blank?
      end
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe API::V3::ParseQueryParamsService,
               type: :model do
  let(:instance) { described_class.new }
  let(:params) { {} }

  describe '#call' do
    subject { instance.call(params) }

    shared_examples_for 'transforms' do
      it 'is success' do
        expect(subject)
          .to be_success
      end

      it 'is transformed' do
        expect(subject.result)
          .to eql(expected)
      end
    end

    context 'with group by' do
      context 'as groupBy' do
        it_behaves_like 'transforms' do
          let(:params) { { groupBy: 'status' } }
          let(:expected) { { group_by: 'status' } }
        end
      end

      context 'as group_by' do
        it_behaves_like 'transforms' do
          let(:params) { { group_by: 'status' } }
          let(:expected) { { group_by: 'status' } }
        end
      end

      context 'as ""g""' do
        it_behaves_like 'transforms' do
          let(:params) { { g: 'status' } }
          let(:expected) { { group_by: 'status' } }
        end
      end

      context 'set to empty string' do
        it_behaves_like 'transforms' do
          let(:params) { { g: '' } }
          let(:expected) { { group_by: nil } }
        end

        it_behaves_like 'transforms' do
          let(:params) { { group_by: '' } }
          let(:expected) { { group_by: nil } }
        end

        it_behaves_like 'transforms' do
          let(:params) { { groupBy: '' } }
          let(:expected) { { group_by: nil } }
        end
      end

      context 'not given' do
        let(:params) { { bla: 'foo' } }

        it 'does not set group_by' do
          expect(subject).to be_success
          expect(subject.result).not_to have_key(:group_by)
        end
      end

      context 'with an attribute called differently in v3' do
        it_behaves_like 'transforms' do
          let(:params) { { groupBy: 'assignee' } }
          let(:expected) { { group_by: 'assigned_to' } }
        end
      end
    end

    context 'with columns' do
      context 'as columns' do
        it_behaves_like 'transforms' do
          let(:params) { { columns: %w(status assignee) } }
          let(:expected) { { columns: %w(status assigned_to) } }
        end
      end

      context 'as ""c""' do
        it_behaves_like 'transforms' do
          let(:params) { { c: %w(status assignee) } }
          let(:expected) { { columns: %w(status assigned_to) } }
        end
      end

      context 'as column_names' do
        it_behaves_like 'transforms' do
          let(:params) { { column_names: %w(status assignee) } }
          let(:expected) { { columns: %w(status assigned_to) } }
        end
      end
    end

    context 'with highlighted_attributes' do
      it_behaves_like 'transforms' do
        let(:params) { { highlightedAttributes: %w(status type priority dueDate) } }
        # Please note, that dueDate is expected to get translated to due_date.
        let(:expected) { { highlighted_attributes: %w(status type priority due_date) } }
      end

      it_behaves_like 'transforms' do
        let(:params) { { highlightedAttributes: %w(/api/v3/columns/status /api/v3/columns/type) } }
        # Please note, that dueDate is expected to get translated to due_date.
        let(:expected) { { highlighted_attributes: %w(status type) } }
      end
    end

    context 'without highlighted_attributes' do
      it_behaves_like 'transforms' do
        let(:params) { { highlightedAttributes: nil } }
        let(:expected) { {} }
      end
    end

    context 'with display_representation' do
      it_behaves_like 'transforms' do
        let(:params) { { displayRepresentation: 'cards' } }
        let(:expected) { { display_representation: 'cards' } }
      end
    end

    context 'without display_representation' do
      it_behaves_like 'transforms' do
        let(:params) { { displayRepresentation: nil } }
        let(:expected) { {} }
      end
    end

    context 'with sort' do
      context 'as sortBy in comma separated value' do
        it_behaves_like 'transforms' do
          let(:params) { { sortBy: JSON::dump([%w(status desc)]) } }
          let(:expected) { { sort_by: [%w(status desc)] } }
        end
      end

      context 'as sortBy in colon concatenated value' do
        it_behaves_like 'transforms' do
          let(:params) { { sortBy: JSON::dump(['status:desc']) } }
          let(:expected) { { sort_by: [%w(status desc)] } }
        end
      end

      context 'with an invalid JSON' do
        let(:params) { { sortBy: 'faulty' + JSON::dump(['status:desc']) } }

        it 'is not success' do
          expect(subject)
            .not_to be_success
        end

        it 'returns the error' do
          message = 'unexpected token at \'faulty[""status:desc""]\''

          expect(subject.errors.messages[:base].length)
            .to be(1)
          expect(subject.errors.messages[:base][0])
            .to end_with(message)
        end
      end
    end

    context 'with filters' do
      context 'as filters in dumped json' do
        context 'with a filter named internally' do
          it_behaves_like 'transforms' do
            let(:params) do
              { filters: JSON::dump([{ 'status_id' => { 'operator' => '=',
                                                        'values' => %w(1 2) } }]) }
            end
            let(:expected) do
              { filters: [{ field: 'status_id', operator: '=', values: %w(1 2) }] }
            end
          end
        end

        context 'with a filter named according to v3' do
          it_behaves_like 'transforms' do
            let(:params) do
              { filters: JSON::dump([{ 'status' => { 'operator' => '=',
                                                     'values' => %w(1 2) } }]) }
            end
            let(:expected) do
              { filters: [{ field: 'status_id', operator: '=', values: %w(1 2) }] }
            end
          end

          it_behaves_like 'transforms' do
            let(:params) do
              { filters: JSON::dump([{ 'subprojectId' => { 'operator' => '=',
                                                           'values' => %w(1 2) } }]) }
            end
            let(:expected) do
              { filters: [{ field: 'subproject_id', operator: '=', values: %w(1 2) }] }
            end
          end

          it_behaves_like 'transforms' do
            let(:params) do
              { filters: JSON::dump([{ 'watcher' => { 'operator' => '=',
                                                      'values' => %w(1 2) } }]) }
            end
            let(:expected) do
              { filters: [{ field: 'watcher_id', operator: '=', values: %w(1 2) }] }
            end
          end

          it_behaves_like 'transforms' do
            let(:params) do
              { filters: JSON::dump([{ 'custom_field_1' => { 'operator' => '=',
                                                             'values' => %w(1 2) } }]) }
            end
            let(:expected) do
              { filters: [{ field: 'cf_1', operator: '=', values: %w(1 2) }] }
            end
          end
        end

        context 'with an invalid JSON' do
          let(:params) do
            { filters: 'faulty' + JSON::dump([{ 'status' => { 'operator' => '=',
                                                              'values' => %w(1 2) } }]) }
          end

          it 'is not success' do
            expect(subject)
              .not_to be_success
          end

          it 'returns the error' do
            message = 'unexpected token at ' +
                      ""'faulty[{\""status\"":{\""operator\"":\""=\"",\""values\"":[\""1\"",\""2\""]}}]'""

            expect(subject.errors.messages[:base].length)
              .to be(1)
            expect(subject.errors.messages[:base][0])
              .to end_with(message)
          end
        end

        context 'with an empty array (in JSON)' do
          it_behaves_like 'transforms' do
            let(:params) do
              { filters: JSON::dump([]) }
            end
            let(:expected) do
              { filters: [] }
            end
          end
        end
      end
    end

    context 'with showSums' do
      it_behaves_like 'transforms' do
        let(:params) { { showSums: 'true' } }
        let(:expected) { { display_sums: true } }
      end

      it_behaves_like 'transforms' do
        let(:params) { { showSums: 'false' } }
        let(:expected) { { display_sums: false } }
      end
    end

    context 'with timelineLabels' do
      let(:input) { { left: 'a', right: 'b', farRight: 'c' } }

      it_behaves_like 'transforms' do
        let(:params) { { timelineLabels: input.to_json } }
        let(:expected) { { timeline_labels: input.stringify_keys } }
      end
    end

    context 'with includeSubprojects' do
      it_behaves_like 'transforms' do
        let(:params) { { includeSubprojects: 'true' } }
        let(:expected) { { include_subprojects: true } }
      end

      it_behaves_like 'transforms' do
        let(:params) { { includeSubprojects: 'false' } }
        let(:expected) { { include_subprojects: false } }
      end
    end

    context 'with timestamps' do
      it_behaves_like 'transforms' do
        let(:params) { { timestamps: """" } }
        let(:expected) { { timestamps: [] } }
      end

      it_behaves_like 'transforms' do
        let(:params) { { timestamps: ""P-0Y"" } }
        let(:expected) { { timestamps: [Timestamp.parse(""P-0Y"")] } }
      end

      it_behaves_like 'transforms' do
        let(:params) { { timestamps: ""2022-10-29T23:01:23Z, P-0Y"" } }
        let(:expected) { { timestamps: [Timestamp.parse(""2022-10-29T23:01:23Z""), Timestamp.parse(""P-0Y"")] } }
      end

      it_behaves_like 'transforms' do
        let(:params) { { timestamps: ""-1y, now"" } }
        let(:expected) { { timestamps: [Timestamp.new(""P-1Y""), Timestamp.new(""PT0S"")] } }
      end

      it_behaves_like 'transforms' do
        let(:params) { { timestamps: ""oneMonthAgo@11:00+00:00, now"" } }
        let(:expected) { { timestamps: [Timestamp.parse(""oneMonthAgo@11:00+00:00""), Timestamp.new(""PT0S"")] } }
      end

      it_behaves_like 'transforms' do
        let(:params) { { timestamps: ""oneMonthAgo@11:00+00:00, oneWeekAgo@12:00+10:00"" } }
        let(:expected) { { timestamps: [Timestamp.parse(""oneMonthAgo@11:00+00:00""), Timestamp.parse(""oneWeekAgo@12:00+10:00"")] } }
      end

      describe ""for invalid parameters"" do
        let(:params) { { timestamps: ""foo,bar"" } }

        it 'is not success' do
          expect(subject).not_to be_success
        end

        it 'returns the error' do
          expect(subject.errors.messages[:base].length).to be(1)
          expect(subject.errors.messages[:base][0]).to include ""\""foo\""""
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

# Handles setting the attributes of a wiki page.
# The wiki page is treated as one single entity although the data layer separates
# between the page and the content.
#
# In the long run, those two should probably be unified on the data layer as well.
#
# Attributes for both the page as well as for the content are accepted.
class WikiPages::SetAttributesService < BaseServices::SetAttributes
  include Attachments::SetReplacements

  private

  def set_default_attributes(_params)
    model.extend(OpenProject::ChangedBySystem)

    model.change_by_system do
      model.author = user
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe WikiPages::SetAttributesService, type: :model do
  let(:user) { build_stubbed(:user) }
  let(:contract_class) do
    contract = double('contract_class')

    allow(contract)
      .to receive(:new)
      .with(wiki_page, user, options: {})
      .and_return(contract_instance)

    contract
  end
  let(:contract_instance) do
    double('contract_instance', validate: contract_valid, errors: contract_errors)
  end
  let(:contract_valid) { true }
  let(:contract_errors) do
    double('contract_errors')
  end
  let(:wiki_page_valid) { true }
  let(:instance) do
    described_class.new(user:,
                        model: wiki_page,
                        contract_class:)
  end
  let(:call_attributes) { {} }
  let(:wiki_page) do
    build_stubbed(:wiki_page)
  end

  describe 'call' do
    let(:call_attributes) do
      {
        text: 'some new text',
        title: 'a new title',
        slug: 'a new slug',
        journal_notes: 'the journal notes'
      }
    end

    before do
      allow(wiki_page)
        .to receive(:valid?)
        .and_return(wiki_page_valid)

      expect(contract_instance)
        .to receive(:validate)
        .and_return(contract_valid)
    end

    subject { instance.call(call_attributes) }

    it 'is successful' do
      expect(subject).to be_success
    end

    context 'for an existing wiki page' do
      it 'sets the attributes' do
        subject

        expect(wiki_page.attributes.slice(*wiki_page.changed).symbolize_keys)
          .to eql call_attributes.slice(:title, :slug, :text)

        expect(wiki_page.journal_notes)
          .to eql call_attributes[:journal_notes]
      end

      it 'does not persist the wiki_page' do
        expect(wiki_page)
          .not_to receive(:save)

        subject
      end
    end

    context 'for a new wiki page' do
      let(:wiki_page) do
        WikiPage.new
      end

      it 'sets the attributes with the user being the author' do
        subject

        expect(wiki_page.attributes.slice(*wiki_page.changed).symbolize_keys)
          .to eql call_attributes.slice(:title, :slug, :text).merge(author_id: user.id)

        expect(wiki_page.journal_notes)
          .to eql call_attributes[:journal_notes]
      end

      it 'marks the author to be system changed' do
        subject

        expect(wiki_page.changed_by_system['author_id'])
          .to eql [nil, user.id]
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

# See also: create_service.rb for comments
class OAuthClients::SetAttributesService < BaseServices::SetAttributes
  private

  def set_attributes(params)
    super(replace_client_secret_with_nil(params))
  end

  def replace_client_secret_with_nil(params)
    cloned_param = params.clone

    if cloned_param[:client_secret] == ''
      cloned_param.merge!(client_secret: nil)
    end

    cloned_param
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe OAuthClients::SetAttributesService, type: :model do
  let(:current_user) { build_stubbed(:admin) }

  let(:contract_instance) do
    contract = instance_double(OAuthClients::CreateContract, 'contract_instance')
    allow(contract)
      .to receive(:validate)
      .and_return(contract_valid)
    allow(contract)
      .to receive(:errors)
      .and_return(contract_errors)
    contract
  end

  let(:contract_errors) { instance_double(ActiveModel::Errors, 'contract_errors') }
  let(:contract_valid) { true }
  let(:model_valid) { true }

  let(:instance) do
    described_class.new(user: current_user, model: model_instance, contract_class:, contract_options: {})
  end
  let(:model_instance) { OAuthClient.new }
  let(:contract_class) do
    allow(OAuthClients::CreateContract)
      .to receive(:new)
      .and_return(contract_instance)

    OAuthClients::CreateContract
  end

  let(:params) { {} }

  before do
    allow(model_instance)
      .to receive(:valid?)
      .and_return(model_valid)
  end

  subject { instance.call(params) }

  it 'returns the instance as the result' do
    expect(subject.result)
      .to eql model_instance
  end

  it 'is a success' do
    expect(subject)
      .to be_success
  end

  context 'with params' do
    let(:params) do
      {
        client_id: '0123456789-client_id',
        client_secret: '1234567890-client_secret'
      }
    end

    before do
      subject
    end

    it 'assigns the params' do
      expect(model_instance.client_id).to eq '0123456789-client_id'
      expect(model_instance.client_secret).to eq '1234567890-client_secret'
    end
  end

  context 'with an invalid contract' do
    let(:contract_valid) { false }

    it 'returns failure' do
      expect(subject).not_to be_success
    end

    it ""returns the contract's errors"" do
      expect(subject.errors)
        .to eql(contract_errors)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true

#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require ""rack/oauth2""
require ""uri/http""

module OAuthClients
  class ConnectionManager
    # Nextcloud API endpoint to check if Bearer token is valid
    TOKEN_IS_FRESH_DURATION = 10.seconds.freeze

    def initialize(user:, configuration:)
      @user = user
      @oauth_client = configuration.oauth_client
      @config = configuration
    end

    # Main method to initiate the OAuth2 flow called by a ""client"" component
    # that wants to access OAuth2 protected resources.
    # Returns an OAuthClientToken object or a String in case a renew is required.
    # @param state (OAuth2 RFC) encapsulates the state of the calling page (URL + params) to return
    # @param scope (OAuth2 RFC) specifies the resources to access. Nextcloud only has one global scope.
    # @return ServiceResult with ServiceResult.result being either an OAuthClientToken or a redirection URL
    def get_access_token(state: nil)
      # Check for an already existing token from last call
      token = get_existing_token
      return ServiceResult.success(result: token) if token.present?

      # Return the Nextcloud OAuth authorization URI that a user needs to open to grant access and eventually obtain
      # a token.
      @redirect_url = get_authorization_uri(state:)

      ServiceResult.failure(result: @redirect_url)
    end

    # rubocop:disable Metrics/AbcSize

    # The bearer/access token has expired or is due for renew for other reasons.
    # Talk to OAuth2 Authorization Server to exchange the renew_token for a new bearer token.
    def refresh_token
      OAuthClientToken.transaction do
        oauth_client_token = OAuthClientToken.lock('FOR UPDATE').find_by(user_id: @user, oauth_client_id: @oauth_client.id)

        if oauth_client_token.present?
          if (Time.current - oauth_client_token.updated_at) > TOKEN_IS_FRESH_DURATION
            service_result = request_new_token(refresh_token: oauth_client_token.refresh_token)

            if service_result.success?
              update_oauth_client_token(oauth_client_token, service_result.result)
            else
              service_result
            end
          else
            ServiceResult.success(result: oauth_client_token)
          end
        else
          storage_error = ::Storages::StorageError.new(
            code: :error,
            log_message: I18n.t('oauth_client.errors.refresh_token_called_without_existing_token')
          )
          ServiceResult.failure(result: :error, errors: storage_error)
        end
      end
    end

    # rubocop:enable Metrics/AbcSize

    # Returns the URI of the ""authorize"" endpoint of the OAuth2 Authorization Server.
    # @param state (OAuth2 RFC) is a nonce referencing a cookie containing the calling page (URL + params) to which to
    # return to at the end of the whole flow.
    # @param scope (OAuth2 RFC) specifies the resources to access. Nextcloud has only one global scope.
    def get_authorization_uri(state: nil)
      client = rack_oauth_client # Configure and start the rack-oauth2 client
      client.authorization_uri(scope: @config.scope, state:)
    end

    # rubocop:disable Metrics/AbcSize

    # Called by callback_page with a cryptographic ""code"" that indicates
    # that the user has successfully authorized the OAuth2 Authorization Server.
    # We now are going to exchange this code to a token (bearer+refresh)
    def code_to_token(code)
      # Return a Rack::OAuth2::AccessToken::Bearer or an error string
      service_result = request_new_token(authorization_code: code)
      return service_result unless service_result.success?

      # Check for existing OAuthClientToken and update,
      # or create a new one from Rack::OAuth::AccessToken::Bearer
      oauth_client_token = get_existing_token
      if oauth_client_token.present?
        update_oauth_client_token(oauth_client_token, service_result.result)
      else
        rack_access_token = service_result.result
        oauth_client_token =
          OAuthClientToken.create(
            user: @user,
            oauth_client: @oauth_client,
            origin_user_id: rack_access_token.raw_attributes[:user_id], # ID of user at OAuth2 Authorization Server
            access_token: rack_access_token.access_token,
            token_type: rack_access_token.token_type, # :bearer
            refresh_token: rack_access_token.refresh_token,
            expires_in: rack_access_token.raw_attributes[:expires_in],
            scope: rack_access_token.scope
          )
        OpenProject::Notifications.send(
          OpenProject::Events::OAUTH_CLIENT_TOKEN_CREATED,
          integration_type: @oauth_client.integration_type
        )
      end

      ServiceResult.success(result: oauth_client_token)
    end

    # rubocop:enable Metrics/AbcSize

    # Called by StorageRepresenter to inquire about the status of the OAuth2
    # authentication server.
    # Returns :connected/:authorization_failed or :error for a general error.
    # We have decided to distinguish between only these 3 cases, because the
    # front-end (and a normal user) probably wouldn't know how to deal with
    # other options.
    def authorization_state
      oauth_client_token = get_existing_token
      return :failed_authorization unless oauth_client_token

      state = @config.authorization_state_check(oauth_client_token.access_token)
      case state
      when :success
        :connected
      when :refresh_needed
        service_result = refresh_token
        if service_result.success?
          :connected
        elsif service_result.errors.data.payload[:error] == 'invalid_request'
          :failed_authorization
        else
          :error
        end
      else
        state
      end
    rescue StandardError
      :error
    end

    # @returns ServiceResult with result to be :error or any type of object with data
    def request_with_token_refresh(oauth_client_token)
      # `yield` needs to returns a ServiceResult:
      #   success: result= any object with data
      #   failure: result= :error or :unauthorized
      yield_service_result = yield(oauth_client_token)

      if yield_service_result.failure? && yield_service_result.result == :unauthorized
        refresh_service_result = refresh_token
        return refresh_service_result if refresh_service_result.failure?

        oauth_client_token.reload
        yield_service_result = yield(oauth_client_token) # Should contain result=<data> in case of success
      end

      yield_service_result
    end

    private

    # Check if a OAuthClientToken already exists and return nil otherwise.
    # Don't handle the case of an expired token.
    def get_existing_token
      # Check if we've got a token in the database and return nil otherwise.
      OAuthClientToken.find_by(user_id: @user, oauth_client_id: @oauth_client.id)
    end

    def request_new_token(options = {})
      rack_access_token = rack_oauth_client(options).access_token!(:body)

      ServiceResult.success(result: rack_access_token)
    rescue Rack::OAuth2::Client::Error => e
      service_result_with_error(:bad_request, e.response, i18n_rack_oauth2_error_message(e))
    rescue Faraday::TimeoutError, Faraday::ConnectionFailed, Faraday::ParsingError, Faraday::SSLError => e
      service_result_with_error(
        :internal_server_error,
        e,
        ""#{I18n.t('oauth_client.errors.oauth_returned_http_error')}: #{e.class}: #{e.message.to_html}""
      )
    rescue StandardError => e
      service_result_with_error(
        :error,
        e,
        ""#{I18n.t('oauth_client.errors.oauth_returned_standard_error')}: #{e.class}: #{e.message.to_html}""
      )
    end

    def i18n_rack_oauth2_error_message(rack_oauth2_client_exception)
      i18n_key = ""oauth_client.errors.rack_oauth2.#{rack_oauth2_client_exception.message}""
      if I18n.exists? i18n_key
        I18n.t(i18n_key)
      else
        ""#{I18n.t('oauth_client.errors.oauth_returned_error')}: #{rack_oauth2_client_exception.message.to_html}""
      end
    end

    # Return a fully configured RackOAuth2Client.
    # This client does all the heavy lifting with the OAuth2 protocol.
    def rack_oauth_client(options = {})
      rack_oauth_client = @config.basic_rack_oauth_client

      # Write options, for example authorization_code and refresh_token
      rack_oauth_client.refresh_token = options[:refresh_token] if options[:refresh_token]
      rack_oauth_client.authorization_code = options[:authorization_code] if options[:authorization_code]

      rack_oauth_client
    end

    # Update an OpenProject token based on updated values from a
    # Rack::OAuth2::AccessToken::Bearer after a OAuth2 refresh operation
    def update_oauth_client_token(oauth_client_token, rack_oauth2_access_token)
      success = oauth_client_token.update(
        access_token: rack_oauth2_access_token.access_token,
        refresh_token: rack_oauth2_access_token.refresh_token,
        expires_in: rack_oauth2_access_token.expires_in
      )

      if success
        ServiceResult.success(result: oauth_client_token)
      else
        result = ServiceResult.failure
        result.errors.add(:base, I18n.t('oauth_client.errors.refresh_token_updated_failed'))
        result.add_dependent!(ServiceResult.failure(errors: oauth_client_token.errors))
        result
      end
    end

    def service_result_with_error(code, data, log_message = nil)
      error_data = ::Storages::StorageErrorData.new(source: self, payload: data)
      ServiceResult.failure(result: code,
                            errors: ::Storages::StorageError.new(code:, data: error_data, log_message:))
    end
  end
end

```","# frozen_string_literal: true

#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe OAuthClients::ConnectionManager, :webmock, type: :model do
  using Storages::Peripherals::ServiceResultRefinements

  let(:user) { create(:user) }

  let(:host) { ""https://example.org"" }
  let(:storage) { create(:nextcloud_storage, :with_oauth_client, host: ""#{host}/"") }
  let(:oauth_client) { storage.oauth_client }
  let(:configuration) { storage.oauth_configuration }

  let(:scope) { [:all] } # OAuth2 resources to access, specific to provider
  let(:oauth_client_token) { create(:oauth_client_token, oauth_client:, user:) }

  let(:instance) { described_class.new(user:, configuration:) }

  # The get_authorization_uri method returns the OAuth2 authorization URI as a string. That URI is the starting point for
  # a user to grant OpenProject access to Nextcloud.
  describe '#get_authorization_uri' do
    let(:scope) { nil }
    let(:state) { nil }

    subject { instance.get_authorization_uri(state:) }

    context 'with empty state and scope' do
      shared_examples_for 'returns the authorization URI relative to the host' do
        it 'returns the authorization URI' do
          expect(subject).to be_a String
          expect(subject).to include oauth_client.integration.host
          expect(subject).not_to include ""scope""
          expect(subject).not_to include ""state""
        end
      end

      context 'when Nextcloud is installed in the server root' do
        it_behaves_like 'returns the authorization URI relative to the host'
      end

      context 'when Nextcloud is installed in a sub-directory' do
        let(:host) { ""https://example.org/nextcloud"" }

        it_behaves_like 'returns the authorization URI relative to the host'
      end
    end

    context 'with state but empty scope' do
      let(:state) { ""https://example.com/page"" }

      it 'returns the redirect URL' do
        expect(subject).to be_a String
        expect(subject).to include oauth_client.integration.host
        expect(subject).not_to include ""scope""
        expect(subject).to include ""&state=https""
      end
    end

    context 'with multiple scopes but empty state' do
      let(:scope) { %i(email profile) }

      it 'returns the redirect URL' do
        allow(configuration).to receive(:scope).and_return(scope)

        expect(subject).to be_a String
        expect(subject).to include oauth_client.integration.host
        expect(subject).not_to include ""state""
        expect(subject).to include ""&scope=email%20profile""
      end
    end
  end

  # The first step in the OAuth2 flow is to produce a URL for the
  # user to authenticate and authorize access at the OAuth2 provider
  # (Nextcloud).
  describe '#get_access_token' do
    subject { instance.get_access_token }

    context 'with no OAuthClientToken present' do
      it 'returns a redirection URL' do
        expect(subject.success).to be_falsy
        expect(subject.result).to be_a String
        # Details of string are tested above in section #get_authorization_uri
      end
    end

    context 'with no OAuthClientToken present and state parameters' do
      subject { instance.get_access_token(state: ""some_state"") }

      it 'returns the redirect URL' do
        allow(configuration).to receive(:scope).and_return(%w[email])

        expect(subject.success).to be_falsy
        expect(subject.result).to be_a String
        expect(subject.result).to include oauth_client.integration.host
        expect(subject.result).to include ""&state=some_state""
        expect(subject.result).to include ""&scope=email""
      end
    end

    context 'with an OAuthClientToken present' do
      before do
        oauth_client_token
      end

      it 'returns the OAuthClientToken' do
        expect(subject).to be_truthy
        expect(subject.result).to be_a OAuthClientToken # The one and only...
        expect(subject.result).to eql oauth_client_token
      end
    end
  end

  # In the second step the Authorization Server (Nextcloud) redirects
  # to a ""callback"" endpoint on the OAuth2 client (OpenProject):
  # https://<openproject-server>/oauth_clients/8/callback?state=&code=7kRGJ...jG3KZ
  # This callback code basically just calls `code_to_token(code)`.
  # The callback endpoint calls `code_to_token(code)` with the code
  # received and exchanges the code for a bearer+refresh token
  # using a HTTP request.
  describe '#code_to_token', :webmock do
    let(:code) { ""7kRGJ...jG3KZ"" }

    subject { instance.code_to_token(code) }

    context 'with happy path' do
      before do
        # Simulate a successful authorization returning the tokens
        response_body = {
          access_token: ""yjTDZ...RYvRH"",
          token_type: ""Bearer"",
          expires_in: 3600,
          refresh_token: ""UwFp...1FROJ"",
          user_id: ""admin""
        }.to_json
        stub_request(:any, File.join(host, '/index.php/apps/oauth2/api/v1/token'))
          .to_return(status: 200, body: response_body, headers: { ""content-type"" => ""application/json; charset=utf-8"" })
      end

      it 'returns a valid ClientToken object and issues an appropriate event' do
        expect(OpenProject::Notifications)
          .to(receive(:send))
          .with(OpenProject::Events::OAUTH_CLIENT_TOKEN_CREATED, integration_type: ""Storages::Storage"")
        expect(subject.success).to be_truthy
        expect(subject.result).to be_a OAuthClientToken
      end
    end

    context 'with known error' do
      before do
        stub_request(:post, File.join(host, '/index.php/apps/oauth2/api/v1/token'))
          .to_return(status: 400,
                     body: { error: error_message }.to_json,
                     headers: { ""content-type"" => ""application/json; charset=utf-8"" })
      end

      shared_examples 'OAuth2 error response' do
        it 'returns a specific error message' do
          expect(subject.success).to be_falsy
          expect(subject.result).to eq(:bad_request)
          expect(subject.error_payload[:error]).to eq(error_message)
        end
      end

      context 'when ""invalid_request""' do
        let(:error_message) { 'invalid_request' }

        it_behaves_like 'OAuth2 error response'
      end

      context 'when ""invalid_grant""' do
        let(:error_message) { 'invalid_grant' }

        it_behaves_like 'OAuth2 error response'
      end
    end

    context 'with unknown reply' do
      before do
        stub_request(:post, File.join(host, '/index.php/apps/oauth2/api/v1/token'))
          .to_return(status: 400,
                     body: { error: ""invalid_requesttt"" }.to_json,
                     headers: { ""content-type"" => ""application/json; charset=utf-8"" })
      end

      it 'returns an error wrapping the unknown response' do
        expect(subject.success).to be_falsy
        expect(subject.result).to eq(:bad_request)
        expect(subject.error_payload[:error]).to eq('invalid_requesttt')
        expect(subject.error_source).to be_a(described_class)
        expect(subject.errors.log_message).to include I18n.t('oauth_client.errors.oauth_returned_error')
      end
    end

    context 'with reply including JSON syntax error' do
      before do
        stub_request(:post, File.join(host, '/index.php/apps/oauth2/api/v1/token'))
          .to_return(
            status: 400,
            headers: { 'Content-Type' => 'application/json; charset=utf-8' },
            body: ""some: very, invalid> <json}""
          )
      end

      it 'returns an error wrapping the parsing error' do
        expect(subject.success).to be_falsy
        expect(subject.result).to eq(:internal_server_error)
        expect(subject.error_payload.class).to be(Faraday::ParsingError)
        expect(subject.error_source).to be_a(described_class)
        expect(subject.errors.log_message).to include I18n.t('oauth_client.errors.oauth_returned_http_error')
      end
    end

    context 'with 500 reply without body' do
      before do
        stub_request(:post, File.join(host, '/index.php/apps/oauth2/api/v1/token'))
          .to_return(status: 500)
      end

      it 'returns an error wrapping the empty error' do
        expect(subject.success).to be_falsy
        expect(subject.result).to eq(:bad_request)
        expect(subject.error_payload[:error]).to eq('Unknown')
      end
    end

    context 'when something is wrong with connection' do
      before do
        stub_request(:post, File.join(host, '/index.php/apps/oauth2/api/v1/token')).to_raise(Faraday::ConnectionFailed)
      end

      it 'returns an error wrapping the server error' do
        expect(subject.success).to be_falsy
        expect(subject.result).to eq(:internal_server_error)
        expect(subject.error_payload.class).to be(Faraday::ConnectionFailed)
        expect(subject.error_source).to be_a(described_class)
        expect(subject.errors.log_message).to include I18n.t('oauth_client.errors.oauth_returned_http_error')
      end
    end

    context 'when something is wrong with SSL' do
      before do
        stub_request(:post, File.join(host, '/index.php/apps/oauth2/api/v1/token')).to_raise(Faraday::SSLError)
      end

      it 'returns an error wrapping the server error' do
        expect(subject.success).to be_falsy
        expect(subject.result).to eq(:internal_server_error)
        expect(subject.error_payload.class).to be(Faraday::SSLError)
        expect(subject.error_source).to be_a(described_class)
        expect(subject.errors.log_message).to include I18n.t('oauth_client.errors.oauth_returned_http_error')
      end
    end

    context 'with timeout returns internal error' do
      before do
        stub_request(:post, File.join(host, '/index.php/apps/oauth2/api/v1/token')).to_timeout
      end

      it 'returns an error wrapping the server timeout' do
        expect(subject.success).to be_falsy
        expect(subject.result).to eq(:internal_server_error)
        expect(subject.error_payload.class).to be(Faraday::ConnectionFailed)
        expect(subject.error_source).to be_a(described_class)
        expect(subject.errors.log_message).to include I18n.t('oauth_client.errors.oauth_returned_http_error')
      end
    end
  end

  describe '#refresh_token' do
    subject { instance.refresh_token }

    context 'without existing OAuthClientToken' do
      it 'returns an error message' do
        expect(subject.success).to be_falsy
        expect(subject.result).to eq(:error)
        expect(subject.errors.log_message)
          .to include I18n.t('oauth_client.errors.refresh_token_called_without_existing_token')
      end
    end

    context 'with existing OAuthClientToken' do
      before { oauth_client_token }

      context 'when token is stale' do
        before do
          oauth_client_token.update_columns(updated_at: 1.day.ago)
        end

        context 'with successful response from OAuth2 provider (happy path)' do
          before do
            # Simulate a successful authorization returning the tokens
            response_body = {
              access_token: ""xyjTDZ...RYvRH"",
              token_type: ""Bearer"",
              expires_in: 3601,
              refresh_token: ""xUwFp...1FROJ"",
              user_id: ""admin""
            }.to_json
            stub_request(:any, File.join(host, '/index.php/apps/oauth2/api/v1/token'))
              .to_return(status: 200, body: response_body, headers: { ""content-type"" => ""application/json; charset=utf-8"" })
          end

          it 'returns a valid ClientToken object', :webmock do
            expect(subject.success).to be_truthy
            expect(subject.result).to be_a OAuthClientToken
            expect(subject.result.access_token).to eq(""xyjTDZ...RYvRH"")

            expect(subject.result.expires_in).to be(3601)
          end
        end

        context 'with invalid access_token data' do
          before do
            # Simulate a token too long
            response_body = {
              access_token: nil, # will fail model validation
              token_type: ""Bearer"",
              expires_in: 3601,
              refresh_token: ""xUwFp...1FROJ"",
              user_id: ""admin""
            }.to_json
            stub_request(:any, File.join(host, '/index.php/apps/oauth2/api/v1/token'))
              .to_return(status: 200, body: response_body, headers: { ""content-type"" => ""application/json; charset=utf-8"" })
          end

          it 'returns dependent error from model validation', :webmock do
            expect(subject.success).to be_falsy
            expect(subject.result).to eq(:error)
            expect(subject.error_payload.class).to be(AttrRequired::AttrMissing)
            expect(subject.error_payload.message).to include(""'access_token' required."")
          end
        end

        context 'with server error from OAuth2 provider' do
          before do
            stub_request(:any, File.join(host, '/index.php/apps/oauth2/api/v1/token'))
              .to_return(status: 400,
                         body: { error: ""invalid_request"" }.to_json,
                         headers: { ""content-type"" => ""application/json; charset=utf-8"" })
          end

          it 'returns a server error', :webmock do
            expect(subject.success).to be_falsy
            expect(subject.result).to eq(:bad_request)
            expect(subject.error_payload[:error]).to eq('invalid_request')
          end
        end

        context 'with successful response but invalid data' do
          before do
            # Simulate timeout
            stub_request(:any, File.join(host, '/index.php/apps/oauth2/api/v1/token'))
              .to_timeout
          end

          it 'returns an error wrapping a timeout', :webmock do
            expect(subject.success).to be_falsy
            expect(subject.result).to eq(:internal_server_error)
            expect(subject.error_payload.class).to be(Faraday::ConnectionFailed)
            expect(subject.error_source).to be_a(described_class)
            expect(subject.errors.log_message).to include('Faraday::ConnectionFailed: execution expired')
          end
        end

        context 'with parallel requests for refresh', :aggregate_failures do
          after do
            Storages::Storage.destroy_all
            User.destroy_all
            OAuthClientToken.destroy_all
            OAuthClient.destroy_all
          end

          it 'requests token only once and other thread uses new token' do
            response_body1 = {
              access_token: ""xyjTDZ...RYvRH"",
              token_type: ""Bearer"",
              expires_in: 3601,
              refresh_token: ""xUwFp...1FROJ"",
              user_id: ""admin""
            }
            response_body2 = response_body1.dup
            response_body2[:access_token] = ""differ...RYvRH""
            request_url = File.join(host, '/index.php/apps/oauth2/api/v1/token')
            stub_request(:any, request_url).to_return(
              { status: 200, body: response_body1.to_json, headers: { ""content-type"" => ""application/json; charset=utf-8"" } },
              { status: 200, body: response_body2.to_json, headers: { ""content-type"" => ""application/json; charset=utf-8"" } }
            )

            result1 = nil
            result2 = nil
            thread1 = Thread.new do
              ApplicationRecord.connection_pool.with_connection do
                result1 = described_class.new(user:, configuration: storage.oauth_configuration).refresh_token.result
              end
            end
            thread2 = Thread.new do
              ApplicationRecord.connection_pool.with_connection do
                result2 = described_class.new(user:, configuration: storage.oauth_configuration).refresh_token.result
              end
            end
            thread1.join
            thread2.join

            expect(result1.access_token).to eq(response_body1[:access_token])
            expect(result2.access_token).to eq(response_body1[:access_token])
            expect(WebMock).to have_requested(:any, request_url).once
          end

          it 'requests token refresh twice if enough time passes between requests' do
            stub_const(""OAuthClients::ConnectionManager::TOKEN_IS_FRESH_DURATION"", 2.seconds)
            response_body1 = {
              access_token: ""xyjTDZ...RYvRH"",
              token_type: ""Bearer"",
              expires_in: 3601,
              refresh_token: ""xUwFp...1FROJ"",
              user_id: ""admin""
            }
            response_body2 = response_body1.dup
            response_body2[:access_token] = ""differ...RYvRH""
            request_url = File.join(host, '/index.php/apps/oauth2/api/v1/token')
            headers = { ""content-type"" => ""application/json; charset=utf-8"" }
            stub_request(:any, request_url)
              .to_return(status: 200, body: response_body1.to_json, headers:).then
              .to_return(status: 200, body: response_body2.to_json, headers:)

            result1 = nil
            result2 = nil
            thread1 = Thread.new do
              ApplicationRecord.connection_pool.with_connection do
                sleep(3)
                result1 = described_class.new(user:, configuration: storage.oauth_configuration).refresh_token.result
              end
            end
            thread2 = Thread.new do
              ApplicationRecord.connection_pool.with_connection do
                result2 = described_class.new(user:, configuration: storage.oauth_configuration).refresh_token.result
              end
            end
            thread1.join
            thread2.join

            expect([result1.access_token,
                    result2.access_token]).to contain_exactly(response_body1[:access_token], response_body2[:access_token])
            expect(WebMock).to have_requested(:any, request_url).twice
          end
        end
      end

      context 'when token is fresh' do
        it 'does not send refresh request and respond with existing token', :webmock do
          expect(subject.success).to be_truthy
          expect(subject.result).to eq(oauth_client_token)
          expect { subject }.not_to change(oauth_client_token, :access_token)
        end
      end
    end
  end

  describe '#authorization_state' do
    subject { instance.authorization_state }

    context 'without access token present' do
      it 'returns :failed_authorization' do
        expect(subject).to eq :failed_authorization
      end
    end

    context 'with access token present', :webmock do
      before do
        oauth_client_token
      end

      context 'with access token valid' do
        context 'without other errors or exceptions' do
          before do
            allow(configuration).to receive(:authorization_state_check).and_return(:success)
          end

          it 'returns :connected' do
            expect(subject).to eq :connected
          end
        end

        context 'with some other error or exception' do
          before do
            allow(configuration).to receive(:authorization_state_check).and_return(:error)
          end

          it 'returns :error' do
            expect(subject).to eq :error
          end
        end
      end

      context 'with outdated access token' do
        let(:new_oauth_client_token) { create(:oauth_client_token) }
        let(:refresh_service_result) { ServiceResult.success }

        before do
          allow(configuration).to receive(:authorization_state_check).and_return(:refresh_needed)
          allow(instance).to receive(:refresh_token).and_return(refresh_service_result)
        end

        context 'with valid refresh token' do
          it 'refreshes the access token and returns :connected' do
            expect(subject).to eq :connected
            expect(instance).to have_received(:refresh_token)
          end
        end

        context 'with invalid refresh token' do
          let(:refresh_service_result) do
            data = Storages::StorageErrorData.new(source: nil, payload: { error: 'invalid_request' })
            ServiceResult.failure(result: :bad_request,
                                  errors: Storages::StorageError.new(code: :bad_request, data:))
          end

          it 'refreshes the access token and returns :failed_authorization' do
            expect(subject).to eq :failed_authorization
            expect(instance).to have_received(:refresh_token)
          end
        end

        context 'with some other error while refreshing access token' do
          let(:refresh_service_result) { ServiceResult.failure }

          it 'returns :error' do
            expect(subject).to eq :error
            expect(instance).to have_received(:refresh_token)
          end
        end
      end
    end

    context 'with both invalid access token and refresh token', :webmock do
      it 'returns :failed_authorization' do
        expect(subject).to eq :failed_authorization
      end
    end
  end

  describe '#request_with_token_refresh' do
    let(:yield_service_result) { ServiceResult.success }
    let(:refresh_service_result) { ServiceResult.success }

    subject do
      instance.request_with_token_refresh(oauth_client_token) { yield_service_result }
    end

    before do
      allow(instance).to receive(:refresh_token).and_return(refresh_service_result)
      allow(oauth_client_token).to receive(:reload)
    end

    context 'with yield returning :success' do
      it 'returns a ServiceResult with success, without refreshing the token' do
        expect(subject.success).to be_truthy
        expect(instance).not_to have_received(:refresh_token)
        expect(oauth_client_token).not_to have_received(:reload)
      end
    end

    context 'with yield returning :error' do
      let(:yield_service_result) { ServiceResult.failure(result: :error) }

      it 'returns a ServiceResult with success, without refreshing the token' do
        expect(subject.success).to be_falsy
        expect(subject.result).to be :error
        expect(instance).not_to have_received(:refresh_token)
        expect(oauth_client_token).not_to have_received(:reload)
      end
    end

    context 'with yield returning :unauthorized and the refresh returning a with a success' do
      let(:yield_service_result) { ServiceResult.failure(result: :unauthorized) }

      it 'returns a ServiceResult with success, without refresh' do
        expect(subject.success).to be_falsy
        expect(subject.result).to be :unauthorized
        expect(instance).to have_received(:refresh_token)
        expect(oauth_client_token).to have_received(:reload)
      end
    end

    context 'with yield returning :unauthorized and the refresh returning with a :failure' do
      let(:yield_service_result) { ServiceResult.failure(result: :unauthorized) }
      let(:refresh_service_result) do
        data = Storages::StorageErrorData.new(source: nil, payload: { error: 'invalid_request' })
        ServiceResult.failure(result: :error,
                              errors: Storages::StorageError.new(code: :error, data:))
      end

      it 'returns a ServiceResult with success, without refresh' do
        expect(subject.success).to be_falsy
        expect(subject.result).to be :error
        expect(instance).to have_received(:refresh_token)
        expect(oauth_client_token).not_to have_received(:reload)
      end
    end

    context 'with yield returning :unauthorized first time and :success the second time' do
      let(:yield_double_object) { Object.new }
      let(:yield_service_result1) { ServiceResult.failure(result: :unauthorized) }
      let(:yield_service_result2) { ServiceResult.success }
      let(:refresh_service_result) { ServiceResult.success }

      subject do
        instance.request_with_token_refresh(oauth_client_token) { yield_double_object.yield_twice_method }
      end

      before do
        allow(instance).to receive(:refresh_token).and_return refresh_service_result
        allow(yield_double_object)
          .to receive(:yield_twice_method)
                .and_return(
                  yield_service_result1,
                  yield_service_result2
                )
      end

      it 'returns a ServiceResult with success, without refresh' do
        expect(subject.success).to be_truthy
        expect(subject).to be yield_service_result2
        expect(instance).to have_received(:refresh_token)
        expect(oauth_client_token).to have_received(:reload)
        expect(yield_double_object).to have_received(:yield_twice_method).twice
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require ""rack/oauth2""
require ""uri/http""

module OAuthClients
  class RedirectUriFromStateService
    def initialize(state:, cookies:)
      @state = state
      @cookies = cookies
    end

    def call
      redirect_uri = oauth_state_cookie

      if redirect_uri.present? && ::API::V3::Utilities::PathHelper::ApiV3Path::same_origin?(redirect_uri)
        ServiceResult.success(result: redirect_uri)
      else
        ServiceResult.failure
      end
    end

    private

    def oauth_state_cookie
      return nil if @state.blank?

      state_cookie = @cookies[""oauth_state_#{@state}""]
      return nil if state_cookie.blank?

      state_value = MultiJson.load(@cookies[""oauth_state_#{@state}""], symbolize_keys: true)
      state_value[:href]
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'
require 'webmock/rspec'

RSpec.describe OAuthClients::RedirectUriFromStateService, type: :model do
  let(:state) { 'asdf123425' }
  let(:redirect_uri) { File.join(API::V3::Utilities::PathHelper::ApiV3Path::root_url, 'foo/bar') }
  let(:cookies) { { ""oauth_state_#{state}"": { href: redirect_uri }.to_json }.with_indifferent_access }
  let(:instance) { described_class.new(state:, cookies:) }

  describe '#call' do
    subject { instance.call }

    shared_examples 'failed service result' do
      it 'return a failed service result' do
        expect(subject).to be_failure
      end
    end

    context 'when cookie found' do
      context 'when redirect_uri has same origin' do
        it 'returns the redirect URL value from the cookie' do
          expect(subject).to be_success
        end
      end

      context 'when redirect_uri does not share same origin' do
        let(:redirect_uri) { 'https://some-other-origin.com/bla' }

        it_behaves_like 'failed service result'
      end
    end

    context 'when no cookie present' do
      let(:cookies) { {} }

      it_behaves_like 'failed service result'
    end

    context 'when no state present' do
      let(:state) { nil }

      it_behaves_like 'failed service result'
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

# The logic for creating storage was extracted from the controller and put into
# a service: https://dev.to/joker666/ruby-on-rails-pattern-service-objects-b19
# Purpose: create and persist a Storages::Storage record
# Used by: Storages::Admin::StoragesController#create, could also be used by the
# API in the future.
# The comments here are also valid for the other *_service.rb files
module OAuthClients
  class CreateService < ::BaseServices::Create
    protected

    def before_perform(params, _service_result)
      OAuthClient.where(integration: params[:integration]).delete_all

      super
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'
require 'services/base_services/behaves_like_create_service'

RSpec.describe OAuthClients::CreateService, type: :model do
  it_behaves_like 'BaseServices create service' do
    let(:factory) { :oauth_client }

    context 'if another oauth client for the given integration exists' do
      let(:storage) { create(:nextcloud_storage) }
      let!(:existing_client) { create(:oauth_client, integration: storage) }
      let!(:model_instance) { build_stubbed(:oauth_client, integration: storage) }
      let(:call_attributes) { { name: 'Death Star', integration: storage } }

      it 'overwrites the existing oauth client' do
        # Test setup still returns success, but `subject` must be initialized
        expect(subject).to be_success
        expect(OAuthClient.where(id: existing_client.id)).not_to exist
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

# See also: create_service.rb for comments
module OAuthClients
  class DeleteService < ::BaseServices::Delete
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'
require 'services/base_services/behaves_like_delete_service'

RSpec.describe OAuthClients::DeleteService, type: :model do
  it_behaves_like 'BaseServices delete service' do
    let(:factory) { :oauth_client }
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module Members
  class SetAttributesService < ::BaseServices::SetAttributes
    include Members::Concerns::RoleAssignment
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Members::SetAttributesService, type: :model do
  let(:user) { build_stubbed(:user) }
  let(:contract_class) do
    contract = double('contract_class')

    allow(contract)
      .to receive(:new)
      .with(member, user, options: {})
      .and_return(contract_instance)

    contract
  end
  let(:contract_instance) do
    double('contract_instance', validate: contract_valid, errors: contract_errors)
  end
  let(:contract_valid) { true }
  let(:contract_errors) do
    double('contract_errors')
  end
  let(:member_valid) { true }
  let(:instance) do
    described_class.new(user:,
                        model: member,
                        contract_class:)
  end
  let(:call_attributes) { {} }
  let(:member) do
    build_stubbed(:member)
  end

  describe 'call' do
    let(:call_attributes) do
      {
        project_id: 5,
        user_id: 3
      }
    end

    before do
      allow(member)
        .to receive(:valid?)
        .and_return(member_valid)

      expect(contract_instance)
        .to receive(:validate)
        .and_return(contract_valid)
    end

    subject { instance.call(call_attributes) }

    it 'is successful' do
      expect(subject.success?).to be_truthy
    end

    it 'sets the attributes' do
      subject

      expect(member.attributes.slice(*member.changed).symbolize_keys)
        .to eql call_attributes
    end

    it 'does not persist the member' do
      expect(member)
        .not_to receive(:save)

      subject
    end

    context 'with changes to the roles do' do
      let(:first_role) { build_stubbed(:project_role) }
      let(:second_role) { build_stubbed(:project_role) }
      let(:third_role) { build_stubbed(:project_role) }

      let(:call_attributes) do
        {
          role_ids: [second_role.id, third_role.id]
        }
      end

      context 'with a persisted record' do
        let(:member) do
          build_stubbed(:member, roles: [first_role, second_role])
        end

        it 'adds the new role and marks the other for destruction' do
          expect(subject.result.member_roles.map(&:role_id)).to contain_exactly(first_role.id, second_role.id, third_role.id)
          expect(subject.result.member_roles.detect { _1.role_id == first_role.id }).to be_marked_for_destruction
        end
      end

      context 'with a new record' do
        let(:member) do
          Member.new
        end

        it 'adds the new role' do
          expect(subject.result.member_roles.map(&:role_id)).to contain_exactly(second_role.id, third_role.id)
        end

        context 'with role_ids not all being present' do
          let(:call_attributes) do
            {
              role_ids: [nil, '', second_role.id, third_role.id]
            }
          end

          it 'ignores the empty values' do
            expect(subject.result.member_roles.map(&:role_id)).to contain_exactly(second_role.id, third_role.id)
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class Members::UpdateService < BaseServices::Update
  include Members::Concerns::CleanedUp
  include Members::Concerns::NotificationSender

  around_call :post_process

  private

  def post_process
    service_call = yield

    return unless service_call.success?

    member = service_call.result

    if member.principal.is_a?(Group)
      update_group_roles(member)
    else
      send_notification(member)
    end
  end

  def update_group_roles(member)
    Groups::UpdateRolesService
      .new(member.principal, current_user: user, contract_class: EmptyContract)
      .call(member:, send_notifications: send_notifications?, message: notification_message)
  end

  def event_type
    OpenProject::Events::MEMBER_UPDATED
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'
require 'services/base_services/behaves_like_update_service'

RSpec.describe Members::UpdateService, type: :model do
  it_behaves_like 'BaseServices update service' do
    let(:call_attributes) do
      {
        role_ids: [""2""],
        notification_message: ""Wish you where **here**."",
        send_notifications: false
      }
    end

    before do
      allow(OpenProject::Notifications)
        .to receive(:send)
    end

    describe 'if successful' do
      it 'sends a notification' do
        subject

        expect(OpenProject::Notifications)
          .to have_received(:send)
          .with(OpenProject::Events::MEMBER_UPDATED,
                member: model_instance,
                message: call_attributes[:notification_message],
                send_notifications: call_attributes[:send_notifications])
      end
    end

    context 'if the SetAttributeService is unsuccessful' do
      let(:set_attributes_success) { false }

      it 'sends no notifications' do
        subject

        expect(OpenProject::Notifications)
          .not_to have_received(:send)
      end
    end

    context 'when the member is invalid' do
      let(:model_save_result) { false }

      it 'sends no notifications' do
        subject

        expect(OpenProject::Notifications)
          .not_to have_received(:send)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class Members::CreateService < BaseServices::Create
  include Members::Concerns::NotificationSender

  around_call :post_process

  def post_process
    service_call = yield

    return unless service_call.success?

    member = service_call.result

    add_group_memberships(member)
    send_notification(member)
  end

  protected

  def add_group_memberships(member)
    return unless member.principal.is_a?(Group)

    Groups::CreateInheritedRolesService
      .new(member.principal, current_user: user, contract_class: EmptyContract)
      .call(user_ids: member.principal.user_ids, send_notifications: false, project_ids: [member.project_id])
  end

  def event_type
    OpenProject::Events::MEMBER_CREATED
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'
require 'services/base_services/behaves_like_create_service'

RSpec.describe Members::CreateService, type: :model do
  let(:user1) { build_stubbed(:user) }
  let(:user2) { build_stubbed(:user) }
  let(:group) do
    build_stubbed(:group).tap do |g|
      allow(g)
        .to receive(:user_ids)
              .and_return([user1.id, user2.id])
    end
  end
  let!(:inherited_roles_service) do
    instance_double(Groups::CreateInheritedRolesService).tap do |inherited_roles_service|
      allow(Groups::CreateInheritedRolesService)
        .to receive(:new)
              .and_return(inherited_roles_service)

      allow(inherited_roles_service)
        .to receive(:call)
    end
  end
  let!(:notifications) do
    allow(OpenProject::Notifications)
      .to receive(:send)
  end

  it_behaves_like 'BaseServices create service' do
    let(:call_attributes) do
      {
        project_id: ""1"",
        user_id: ""2"",
        role_ids: [""2""],
        notification_message: ""Wish you where **here**."",
        send_notifications: true
      }
    end

    describe 'if successful' do
      it 'sends a notification' do
        subject

        expect(OpenProject::Notifications)
          .to have_received(:send)
                .with(OpenProject::Events::MEMBER_CREATED,
                      member: model_instance,
                      message: call_attributes[:notification_message],
                      send_notifications: true)
      end

      describe 'for a group' do
        let!(:model_instance) { build_stubbed(:member, principal: group) }

        it ""generates the members and roles for the group's users"" do
          subject

          expect(Groups::CreateInheritedRolesService)
            .to have_received(:new)
                  .with(group,
                        current_user: user,
                        contract_class: EmptyContract)

          expect(inherited_roles_service)
            .to have_received(:call)
                  .with(user_ids: group.user_ids,
                        project_ids: [model_instance.project_id],
                        send_notifications: false)
        end
      end
    end

    context 'if the SetAttributeService is unsuccessful' do
      let(:set_attributes_success) { false }

      it 'sends no notification' do
        subject

        expect(OpenProject::Notifications)
          .not_to have_received(:send)
      end

      describe 'for a group' do
        let!(:model_instance) { build_stubbed(:member, principal: group) }

        it ""does not create any inherited roles"" do
          subject

          expect(Groups::CreateInheritedRolesService)
            .not_to have_received(:new)
        end
      end
    end

    context 'when the member is invalid' do
      let(:model_save_result) { false }

      it 'sends no notification' do
        subject

        expect(OpenProject::Notifications)
          .not_to have_received(:send)
      end

      context 'for a group' do
        let!(:model_instance) { build_stubbed(:member, principal: group) }

        it ""does not create any inherited roles"" do
          subject

          expect(Groups::CreateInheritedRolesService)
            .not_to have_received(:new)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class Members::DeleteService < BaseServices::Delete
  include Members::Concerns::CleanedUp

  protected

  def after_perform(service_call)
    super(service_call).tap do |call|
      member = call.result

      cleanup_for_group(member)
      send_notification(member)
    end
  end

  def send_notification(member)
    ::OpenProject::Notifications.send(OpenProject::Events::MEMBER_DESTROYED,
                                      member:)
  end

  def cleanup_for_group(member)
    return unless member.principal.is_a?(Group)

    Groups::CleanupInheritedRolesService
      .new(member.principal, current_user: user, contract_class: EmptyContract)
      .call
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'
require 'services/base_services/behaves_like_delete_service'

RSpec.describe Members::DeleteService, type: :model do
  it_behaves_like 'BaseServices delete service' do
    let(:principal) { user }
    before do
      model_instance.principal = principal

      allow(OpenProject::Notifications)
        .to receive(:send)
    end

    let!(:cleanup_service_instance) do
      instance = instance_double(Members::CleanupService, call: nil)

      allow(Members::CleanupService)
        .to receive(:new)
        .with(principal, model_instance.project_id)
        .and_return(instance)

      instance
    end

    describe '#call' do
      context 'when contract validates and the model is destroyed successfully' do
        it 'calls the cleanup service' do
          service_call

          expect(cleanup_service_instance)
            .to have_received(:call)
        end

        it 'sends a notification' do
          service_call

          expect(OpenProject::Notifications)
            .to have_received(:send)
            .with(OpenProject::Events::MEMBER_DESTROYED, member: model_instance)
        end

        context 'when the model`s principal is a group' do
          let(:principal) { build_stubbed(:group) }
          let!(:cleanup_inherited_roles_service_instance) do
            instance = instance_double(Groups::CleanupInheritedRolesService, call: nil)

            allow(Groups::CleanupInheritedRolesService)
              .to receive(:new)
              .with(principal,
                    current_user: user,
                    contract_class: EmptyContract)
              .and_return(instance)

            instance
          end

          it 'calls the cleanup inherited roles service' do
            service_call

            expect(cleanup_inherited_roles_service_instance)
              .to have_received(:call)
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# -- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2010-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
# ++

module WorkPackageMembers
  class SetAttributesService < ::BaseServices::SetAttributes
    prepend WorkPackageMembers::Concerns::RoleAssignment

    private

    def set_attributes(params)
      super

      model.change_by_system do
        model.project = model.entity&.project
      end
    end
  end
end

```","# -- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2010-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
# ++

require 'spec_helper'

RSpec.describe WorkPackageMembers::SetAttributesService, type: :model do
  let(:user) { build_stubbed(:user) }
  let(:work_package) { build_stubbed(:work_package) }
  let(:member) do
    new_member
  end
  let(:new_member) { Member.new }
  let(:existing_member) { build_stubbed(:work_package_member) }

  let(:contract_class) do
    allow(WorkPackageMembers::CreateContract)
      .to receive(:new)
            .with(member, user, options: {})
            .and_return(contract_instance)

    WorkPackageMembers::CreateContract
  end
  let(:contract_instance) do
    instance_double(WorkPackageMembers::CreateContract, validate: contract_valid, errors: contract_errors)
  end
  let(:contract_valid) { true }
  let(:contract_errors) do
    instance_double(ActiveModel::Errors)
  end
  let(:instance) do
    described_class.new(user:,
                        model: member,
                        contract_class:)
  end

  describe 'call' do
    let(:call_attributes) do
      {
        user_id: 3,
        entity: work_package
      }
    end

    before do
      allow(contract_instance)
        .to receive(:validate)
              .and_return(contract_valid)

      allow(member)
        .to receive(:save)
              .and_return true
    end

    subject { instance.call(call_attributes) }

    it 'is successful' do
      expect(subject).to be_success
    end

    it 'does not persist the member' do
      subject

      expect(member)
        .not_to have_received(:save)
    end

    context 'for a new record' do
      it 'sets the attributes and also takes the project_id from the work package' do
        subject

        expect(member.attributes.slice(*member.changed).symbolize_keys)
          .to eql(user_id: 3, entity_id: work_package.id, entity_type: 'WorkPackage', project_id: work_package.project_id)
      end

      it 'marks the project_id to be changed by the system' do
        subject

        expect(member.changed_by_system)
          .to eql('project_id' => [nil, member.project_id])
      end
    end

    # Changing the entity should not really happen in reality but if it does, this is what happens.
    context 'for a persisted record' do
      let(:member) { existing_member }

      it 'sets the attributes and also takes the project_id from the work package' do
        subject

        expect(member.attributes.slice(*member.changed).symbolize_keys)
          .to eql(user_id: 3, entity_id: work_package.id, project_id: work_package.project_id)
      end

      it 'marks the project_id to be changed by the system' do
        subject

        expect(member.changed_by_system)
          .to eql('project_id' => [member.project_id_was, member.project_id])
      end
    end

    context 'if the contract is invalid' do
      let(:contract_valid) { false }

      it 'is unsuccessful' do
        expect(subject).not_to be_success
      end

      it 'returns the errors of the contract' do
        expect(subject.errors).to eql contract_errors
      end

      it 'does not persist the member' do
        subject

        expect(member)
          .not_to have_received(:save)
      end
    end

    context 'with changes to the roles' do
      let(:first_role) { build_stubbed(:project_role) }
      let(:second_role) { build_stubbed(:project_role) }
      let(:third_role) { build_stubbed(:project_role) }

      let(:call_attributes) do
        {
          role_ids: [second_role.id, third_role.id]
        }
      end

      context 'with a persisted record' do
        let(:member) do
          build_stubbed(:work_package_member, roles: [first_role, second_role])
        end

        it 'adds the new role and marks the other for destruction' do
          expect(subject.result.member_roles.map(&:role_id)).to contain_exactly(first_role.id, second_role.id, third_role.id)
          expect(subject.result.member_roles.detect { _1.role_id == first_role.id }).to be_marked_for_destruction
        end

        context 'when a role being assigned is already inherited via a group' do
          let(:member) do
            build_stubbed(:work_package_member, roles: [first_role, second_role, third_role])
          end

          before do
            allow(member.member_roles.detect { _1.role_id == third_role.id })
              .to receive(:inherited_from)
                    .and_return(true)
          end

          it 'still adds the role and marks the ones not added for destruction' do
            membership = subject.result

            expect(membership.member_roles.map(&:role_id))
              .to contain_exactly(first_role.id,
                                  second_role.id,
                                  third_role.id, # One is inherited
                                  third_role.id) # The other one isn't

            expect(membership.member_roles.select(&:marked_for_destruction?).map(&:role_id))
              .to contain_exactly(first_role.id)
          end
        end
      end

      context 'with a new record' do
        let(:member) do
          Member.new
        end

        it 'adds the new role' do
          expect(subject.result.member_roles.map(&:role_id)).to contain_exactly(second_role.id, third_role.id)
        end

        context 'with role_ids not all being present' do
          let(:call_attributes) do
            {
              role_ids: [nil, '', second_role.id, third_role.id]
            }
          end

          it 'ignores the empty values' do
            expect(subject.result.member_roles.map(&:role_id)).to contain_exactly(second_role.id, third_role.id)
          end
        end
      end

      context 'with attempting to sent `roles`' do
        let(:call_attributes) do
          {
            roles: [second_role, third_role]
          }
        end

        context 'with a new record' do
          let(:member) do
            Member.new
          end

          it 'sets the new role' do
            expect(subject.result.roles).to contain_exactly(second_role, third_role)
          end
        end

        context 'with a persisted record' do
          let(:member) do
            build_stubbed(:work_package_member, roles: [second_role])
          end

          it 'raises an error' do
            expect { subject }
              .to raise_error(ArgumentError)
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# -- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2010-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
# ++

class WorkPackageMembers::CreateOrUpdateService
  def initialize(user:, contract_class: nil, contract_options: {})
    self.user = user
    self.contract_class = contract_class
    self.contract_options = contract_options
  end

  def call(entity:, user_id:, **)
    actual_service(entity, user_id)
      .call(entity:, user_id:, **)
  end

  private

  attr_accessor :user, :contract_class, :contract_options

  def actual_service(entity, user_id)
    if (member = Member.find_by(entity:, principal: user_id))
      WorkPackageMembers::UpdateService
        .new(user:, model: member, contract_class:, contract_options:)
    else
      WorkPackageMembers::CreateService
        .new(user:, contract_class:, contract_options:)
    end
  end
end

```","# frozen_string_literal: true

# -- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
# ++

require 'spec_helper'

RSpec.describe WorkPackageMembers::CreateOrUpdateService do
  let(:user) { build_stubbed(:user) }
  let(:role) { build_stubbed(:view_work_package_role) }
  let(:work_package) { build_stubbed(:work_package) }
  let(:instance) { described_class.new(user:) }

  let(:params) { { user_id: user, roles: [role], entity: work_package } }
  let(:service_result) { instance_double(ServiceResult) }

  subject(:service_call) { instance.call(**params) }

  before do
    allow(Member)
      .to receive(:find_by)
            .with(entity: work_package, principal: user)
            .and_return(existing_member)
  end

  context 'when the user has no work_package_member for that work package' do
    let(:create_instance) { instance_double(WorkPackageMembers::CreateService) }
    let(:existing_member) { nil }

    it 'calls the WorkPackageMembers::CreateService' do
      allow(WorkPackageMembers::CreateService).to receive(:new).and_return(create_instance)
      allow(create_instance).to receive(:call).and_return(service_result)

      service_call

      expect(create_instance)
        .to have_received(:call)
              .with(**params)
    end
  end

  context 'when the user already has a work_package_member for that work package' do
    let(:update_instance) { instance_double(WorkPackageMembers::UpdateService) }
    let(:existing_member) { build_stubbed(:work_package_member) }

    it 'calls the WorkPackageMembers::UpdateService' do
      allow(WorkPackageMembers::UpdateService).to receive(:new).and_return(update_instance)
      allow(update_instance).to receive(:call).and_return(service_result)

      service_call

      expect(update_instance)
        .to have_received(:call)
              .with(**params)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# -- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2010-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
# ++

class WorkPackageMembers::UpdateService < BaseServices::Update
  include Members::Concerns::CleanedUp

  protected

  def after_perform(service_call)
    return service_call unless service_call.success?

    work_package_member = service_call.result

    update_group_roles(work_package_member) if work_package_member.principal.is_a?(Group)

    service_call
  end

  def update_group_roles(work_package_member)
    Groups::UpdateRolesService
      .new(work_package_member.principal,
           current_user: user,
           contract_class: EmptyContract)
      .call(member: work_package_member,
            send_notifications: false,
            message: nil)
  end
end

```","# frozen_string_literal: true

# -- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
# ++

require 'spec_helper'
require 'services/base_services/behaves_like_update_service'

RSpec.describe WorkPackageMembers::UpdateService do
  let!(:groups_update_roles_service) do
    instance_double(Groups::UpdateRolesService).tap do |service_double|
      allow(Groups::UpdateRolesService)
        .to receive(:new)
              .and_return(service_double)

      allow(service_double)
        .to receive(:call)
    end
  end

  it_behaves_like 'BaseServices update service' do
    let(:model_class) { Member }
    let!(:model_instance) { build_stubbed(:work_package_member, principal:) }
    let(:principal) { build_stubbed(:user) }
    let(:role) { build_stubbed(:view_work_package_role) }
    let(:call_attributes) { { roles: [role] } }

    context 'when successful' do
      context 'when the member being updates is a User' do
        it ""doesn't attempt any group member post-processing"" do
          instance_call

          expect(Groups::UpdateRolesService)
            .not_to have_received(:new)
        end
      end

      context 'when the member being updated is a Group' do
        let(:principal) { build_stubbed(:group) }

        it ""updates the group member's roles"" do
          instance_call

          expect(Groups::UpdateRolesService)
            .to have_received(:new)
                  .with(principal,
                        current_user: user,
                        contract_class: EmptyContract)

          expect(groups_update_roles_service)
            .to have_received(:call)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# -- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2010-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
# ++

class WorkPackageMembers::CreateService < BaseServices::Create
  private

  def instance_class
    Member
  end

  def after_perform(service_call)
    return service_call unless service_call.success?

    work_package_member = service_call.result

    add_group_memberships(work_package_member)
    send_notification(work_package_member)

    service_call
  end

  def add_group_memberships(work_package_member)
    return unless work_package_member.principal.is_a?(Group)

    Groups::CreateInheritedRolesService
      .new(work_package_member.principal,
           current_user: user,
           contract_class: EmptyContract)
      .call(user_ids: work_package_member.principal.user_ids,
            send_notifications: false,
            project_ids: [work_package_member.project_id])
  end

  def send_notification(work_package_member)
    OpenProject::Notifications.send(OpenProject::Events::WORK_PACKAGE_SHARED,
                                    work_package_member:,
                                    send_notifications: true)
  end
end

```","# frozen_string_literal: true

# -- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
# ++

require 'spec_helper'
require 'services/base_services/behaves_like_create_service'

RSpec.describe WorkPackageMembers::CreateService, type: :model do
  subject(:service_call) { instance.call(call_attributes) }

  let(:instance) { described_class.new(user:) }
  let(:user) { build_stubbed(:user) }

  let(:richard) { build_stubbed(:user) }
  let(:dinesh) { build_stubbed(:user) }
  let(:gilfoyle) { build_stubbed(:user) }
  let(:cool_group) do
    build_stubbed(:group).tap do |group|
      allow(group)
        .to receive(:user_ids)
              .and_return([dinesh.id, gilfoyle.id])
    end
  end

  let(:role) { build_stubbed(:view_work_package_role) }
  let(:work_package) { build_stubbed(:work_package) }

  let!(:inherited_roles_service) do
    instance_double(Groups::CreateInheritedRolesService).tap do |inherited_roles_service|
      allow(Groups::CreateInheritedRolesService)
        .to receive(:new)
              .and_return(inherited_roles_service)

      allow(inherited_roles_service)
        .to receive(:call)
    end
  end

  def stub_notifications
    allow(OpenProject::Notifications)
      .to receive(:send)
  end

  before { stub_notifications }

  it_behaves_like 'BaseServices create service' do
    let(:model_class) { Member }
    let(:principal) { richard }
    let(:call_attributes) { { principal:, roles: [role], entity: work_package, project: work_package.project } }

    context 'when successful' do
      it 'sends a notification' do
        service_call

        expect(OpenProject::Notifications)
          .to have_received(:send)
                .with(OpenProject::Events::WORK_PACKAGE_SHARED,
                      work_package_member: model_instance,
                      send_notifications: true)
      end

      context 'for a User' do
        it 'does not create any inherited roles' do
          service_call

          expect(Groups::CreateInheritedRolesService)
            .not_to have_received(:new)
        end
      end

      context 'for a Group' do
        let(:principal) { cool_group }
        let(:model_instance) { build_stubbed(:member, principal:) }

        it ""generates the work package memberships and roles for the group's users"" do
          service_call

          expect(Groups::CreateInheritedRolesService)
            .to have_received(:new)
                  .with(principal,
                        current_user: user,
                        contract_class: EmptyContract)

          expect(inherited_roles_service)
            .to have_received(:call)
                  .with(user_ids: principal.user_ids,
                        project_ids: [model_instance.project_id],
                        send_notifications: false)
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
# -- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2010-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
# ++

class WorkPackageMembers::DeleteService < BaseServices::Delete
  include Members::Concerns::CleanedUp

  protected

  def after_perform(service_call)
    super(service_call).tap do |call|
      work_package_member = call.result

      cleanup_for_group(work_package_member)
    end
  end

  def cleanup_for_group(work_package_member)
    return unless work_package_member.principal.is_a?(Group)

    Groups::CleanupInheritedRolesService
      .new(work_package_member.principal, current_user: user, contract_class: EmptyContract)
      .call
  end
end

```","# frozen_string_literal: true

# -- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2010-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
# ++

require 'spec_helper'
require 'services/base_services/behaves_like_delete_service'

RSpec.describe WorkPackageMembers::DeleteService, type: :model do
  it_behaves_like 'BaseServices delete service' do
    let(:model_class) { Member }
    let(:model_instance) { build_stubbed(:work_package_member, principal:) }
    let(:principal) { user }

    let!(:cleanup_service_instance) do
      instance_double(Members::CleanupService, call: nil).tap do |service_double|
        allow(Members::CleanupService)
          .to receive(:new)
                .with(principal, model_instance.project_id)
                .and_return(service_double)
      end
    end

    describe '#call' do
      context 'when contract validates and the model is destroyed successfully' do
        it 'calls the cleanup service' do
          service_call

          expect(cleanup_service_instance)
            .to have_received(:call)
        end

        context ""when the model's principal is a group"" do
          let(:principal) { build_stubbed(:group) }
          let!(:cleanup_inherited_roles_service_instance) do
            instance_double(Groups::CleanupInheritedRolesService, call: nil).tap do |service_double|
              allow(Groups::CleanupInheritedRolesService)
                .to receive(:new)
                      .with(principal,
                            current_user: user,
                            contract_class: EmptyContract)
                      .and_return(service_double)
            end
          end

          it ""calls the cleanup inherited roles service"" do
            service_call

            expect(cleanup_inherited_roles_service_instance)
              .to have_received(:call)
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

##
# Implements the creation of a local repository.
class SCM::CreateManagedRepositoryService < SCM::BaseRepositoryService
  ##
  # Checks if a given repository may be created and managed locally.
  # Registers an job to create the repository on disk.
  #
  # @return True if the repository creation request has been initiated, false otherwise.
  def call
    if repository.managed? && repository.manageable?

      ##
      # We want to move this functionality in a Delayed Job,
      # but this heavily interferes with the error handling of the whole
      # repository management process.
      # Instead, this will be refactored into a single service wrapper for
      # creating and deleting repositories, which provides transactional DB access
      # as well as filesystem access.
      if repository.class.manages_remote?
        SCM::CreateRemoteRepositoryJob.perform_now(repository)
      else
        SCM::CreateLocalRepositoryJob.ensure_not_existing!(repository)
        SCM::CreateLocalRepositoryJob.perform_later(repository)
      end
      return true
    end

    false
  rescue Errno::EACCES
    @rejected = I18n.t('repositories.errors.path_permission_failed',
                       path: repository.root_url)
    false
  rescue SystemCallError => e
    @rejected = I18n.t('repositories.errors.filesystem_access_failed',
                       message: e.message)
    false
  rescue OpenProject::SCM::Exceptions::SCMError => e
    @rejected = e.message
    false
  end

  ##
  # Returns the error symbol
  def localized_rejected_reason
    @rejected ||= I18n.t('repositories.errors.not_manageable')
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.

require 'spec_helper'

RSpec.describe SCM::CreateManagedRepositoryService, skip_if_command_unavailable: 'svnadmin' do
  let(:user) { build(:user) }
  let(:config) { {} }
  let(:project) { build(:project) }

  let(:repository) { build(:repository_subversion) }

  subject(:service) { SCM::CreateManagedRepositoryService.new(repository) }

  before do
    allow(OpenProject::Configuration).to receive(:[]).and_call_original
    allow(OpenProject::Configuration).to receive(:[]).with('scm').and_return(config)
  end

  shared_examples 'does not create a filesystem repository' do
    it 'does not create a filesystem repository' do
      expect(repository.managed?).to be false
      expect(service.call).to be false
    end
  end

  context 'with no managed configuration' do
    it_behaves_like 'does not create a filesystem repository'
  end

  context 'with managed repository' do
    # Must not .create a managed repository, or it will call this service itself!
    let(:repository) do
      repo = Repository::Subversion.new(scm_type: :managed)
      repo.project = project
      repo
    end

    context 'but no managed config' do
      it 'does not create a filesystem repository' do
        expect(repository.managed?).to be true
        expect(service.call).to be false
      end
    end
  end

  context 'with managed local config' do
    include_context 'with tmpdir'
    let(:config) do
      {
        subversion: { manages: File.join(tmpdir, 'svn') },
        git: { manages: File.join(tmpdir, 'git') }
      }
    end

    let(:repository) do
      repo = Repository::Subversion.new(scm_type: :managed)
      repo.project = project
      repo.configure(:managed, nil)

      # Ignore default creation
      allow(repo).to receive(:create_managed_repository)
      repo.save!
      repo
    end

    before do
      allow_any_instance_of(SCM::CreateLocalRepositoryJob)
        .to receive(:repository).and_return(repository)
      allow_any_instance_of(SCM::CreateRemoteRepositoryJob)
        .to receive(:repository).and_return(repository)
    end

    it 'creates the repository' do
      expect(service.call).to be true
      perform_enqueued_jobs
      expect(File.directory?(repository.root_url)).to be true
    end

    context 'with pre-existing path on filesystem' do
      before do
        allow(File).to receive(:directory?).and_return(true)
      end

      it 'does not create the repository' do
        expect(service.call).to be false
        expect(service.localized_rejected_reason)
          .to eq(I18n.t('repositories.errors.exists_on_filesystem'))
      end
    end

    context 'with a permission error occurring in the Job' do
      before do
        allow(SCM::CreateLocalRepositoryJob)
          .to receive(:new).and_raise(Errno::EACCES)
      end

      it 'returns the correct error' do
        expect(service.call).to be false
        expect(service.localized_rejected_reason)
          .to eq(I18n.t('repositories.errors.path_permission_failed',
                        path: repository.root_url))
      end
    end

    context 'with an OS error occurring in the Job' do
      before do
        allow(SCM::CreateLocalRepositoryJob)
          .to receive(:new).and_raise(Errno::ENOENT)
      end

      it 'returns the correct error' do
        expect(service.call).to be false
        expect(service.localized_rejected_reason)
          .to include('An error occurred while accessing the repository in the filesystem')
      end
    end
  end

  context 'with managed remote config', webmock: true do
    let(:url) { 'http://myreposerver.example.com/api/' }
    let(:config) do
      {
        subversion: { manages: url }
      }
    end

    let(:repository) do
      repo = build(:repository_subversion, scm_type: :managed)
      repo.project = project
      repo.configure(:managed, nil)
      repo
    end

    it 'detects the remote config' do
      expect(repository.class.managed_remote.to_s).to eq(url)
      expect(repository.class).to be_manages_remote
    end

    context 'with a remote callback' do
      let(:returned_url) { 'file:///tmp/some/url/to/repo' }
      let(:root_url) { '/tmp/some/url/to/repo' }

      before do
        stub_request(:post, url)
          .to_return(
            status: 200,
            body: { url: returned_url, path: root_url }.to_json
          )
      end

      shared_examples 'calls the callback' do
        before do
          # Avoid setting up a second call to the remote during save
          # since we only templated the repository, not created one!
          expect(repository).to receive(:save).and_return(true)
        end

        it do
          expect(SCM::CreateRemoteRepositoryJob)
            .to receive(:new).and_call_original

          expect(service.call).to be true
          expect(repository.root_url).to eq(root_url)
          expect(repository.url).to eq(returned_url)

          expect(WebMock)
            .to have_requested(:post, url)
            .with(body: hash_including(action: 'create'))
        end
      end

      context 'with http' do
        it_behaves_like 'calls the callback'
      end

      context 'with https' do
        let(:url) { 'https://myreposerver.example.com/api/' }
        let(:config) do
          {
            subversion: { manages: url, insecure: }
          }
        end

        let(:instance) { SCM::CreateRemoteRepositoryJob.new }
        let(:job_call) { instance.perform(repository) }

        context 'with insecure option' do
          let(:insecure) { true }

          it_behaves_like 'calls the callback'
          it 'uses the insecure option' do
            job_call
            expect(instance.send(:configured_verification)).to eq(OpenSSL::SSL::VERIFY_NONE)
          end
        end

        context 'without insecure option' do
          let(:insecure) { false }

          it 'uses the insecure option' do
            job_call
            expect(instance.send(:configured_verification)).to eq(OpenSSL::SSL::VERIFY_PEER)
          end
        end
      end
    end

    context 'with a faulty remote callback' do
      before do
        stub_request(:post, url)
          .to_return(status: 400, body: { success: false, message: 'An error occurred' }.to_json)
      end

      it 'calls the callback' do
        expect(SCM::CreateRemoteRepositoryJob)
          .to receive(:new).and_call_original

        expect(service.call).to be false
        expect(service.localized_rejected_reason)
          .to eq(""Calling the managed remote failed with message 'An error occurred' (Code: 400)"")
        expect(WebMock)
          .to have_requested(:post, url)
                .with(body: hash_including(action: 'create'))
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

##
# Implements a repository service for building checkout instructions if supported
class SCM::CheckoutInstructionsService
  attr_reader :repository, :user, :path

  def initialize(repository, path: nil, user: User.current)
    @repository = repository
    @user = user
    @path = path
  end

  ##
  # Retrieve the checkout URL using the repository vendor information
  # It may additionally set a path parameter, if the repository supports subtree checkout
  def checkout_url(with_path = false)
    repository.scm.checkout_url(repository,
                                checkout_base_url,
                                with_path ? URI.encode_www_form_component(@path) : nil)
  end

  ##
  # Returns the checkout command from SCM adapter
  # (e.g., `git clone`)
  def checkout_command
    repository.scm.checkout_command
  end

  ##
  # Returns the checkout base URL as defined in settings.
  def checkout_base_url
    checkout_settings['base_url']
  end

  ##
  # Returns the instructions defined in the settings.
  def instructions
    checkout_settings['text'].presence ||
      I18n.t(""repositories.checkout.default_instructions.#{repository.vendor}"")
  end

  ##
  # Returns true when the checkout URL may target a subtree of the repository.
  def subtree_checkout?
    repository.scm.subtree_checkout?
  end

  ##
  # Determines whether the checkout URL may be built, i.e. all information is available
  # This is the case when the base_url is set or the vendor doesn't use base URLs.
  def checkout_url_buildable?
    !repository.class.requires_checkout_base_url? || checkout_base_url.present?
  end

  ##
  # Returns whether the repository supports showing checkout information
  # and has been configured for it.
  def available?
    checkout_enabled? &&
      repository.supports_checkout_info? &&
      checkout_url_buildable?
  end

  def checkout_enabled?
    checkout_settings['enabled'].to_i > 0
  end

  def supported_but_not_enabled?
    repository.supports_checkout_info? && !checkout_enabled?
  end

  ##
  # Determines whether permissions for the given repository
  # are available.
  def manages_permissions?
    repository.managed?
  end

  ##
  # Returns one of the following permission symbols for the given user
  #
  # - :readwrite: When user is allowed to read and commit (:commit_access)
  # - :read: When user is allowed to checkout the repository, but not commit (:browse_repository)
  # - :none: Otherwise
  #
  # Note that this information is only applicable when the repository is managed,
  # because otherwise OpenProject does not control the repository permissions.
  # Use +manages_permissions?+ to check whether this is the case.
  #
  def permission
    project = repository.project
    if user.allowed_in_project?(:commit_access, project)
      :readwrite
    elsif user.allowed_in_project?(:browse_repository, project)
      :read
    else
      :none
    end
  end

  ##
  # Returns whether the given user may checkout the repository
  #
  # Note that this information is only applicable when the repository is managed,
  # because otherwise OpenProject does not control the repository permissions.
  # Use +manages_permissions?+ to check whether this is the case.
  def may_checkout?
    %i[readwrite read].include?(permission)
  end

  ##
  # Returns whether the given user may commit to the repository
  #
  # Note that this information is only applicable when the repository is managed,
  # because otherwise OpenProject does not control the repository permissions.
  # Use +manages_permissions?+ to check whether this is the case.
  def may_commit?
    permission == :readwrite
  end

  private

  def checkout_settings
    @settings ||= begin
      hash = Setting.repository_checkout_data[repository.vendor.to_s]
      hash.presence || {}
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.

require 'spec_helper'

RSpec.describe SCM::CheckoutInstructionsService do
  let(:user) { build(:user) }
  let(:project) { build(:project) }

  let(:url) { 'file:///tmp/some/svn/repo' }
  let(:repository) do
    build(:repository_subversion,
          url:,
          project:)
  end

  let(:base_url) { 'http://example.org/svn/' }
  let(:path) { nil }
  let(:text) { 'foo' }
  let(:checkout_hash) do
    {
      'git' => { 'enabled' => '0' },
      'subversion' => { 'enabled' => '1',
                        'text' => text,
                        'base_url' => base_url }
    }
  end

  subject(:service) { SCM::CheckoutInstructionsService.new(repository, user:, path:) }

  before do
    allow(Setting).to receive(:repository_checkout_data).and_return(checkout_hash)
  end

  describe '#checkout_url' do
    shared_examples 'builds the correct URL' do
      it 'builds the correct URL' do
        expect(service.checkout_url)
          .to eq(URI(""http://example.org/svn/#{project.identifier}""))
      end

      shared_examples 'valid checkout URL' do
        it do
          expect(service.checkout_url(path))
            .to eq(URI(""http://example.org/svn/#{project.identifier}/#{expected_path}""))
        end
      end

      it_behaves_like 'valid checkout URL' do
        let(:path) { 'foo/bar' }
        let(:expected_path) { path }
      end

      it_behaves_like 'valid checkout URL' do
        let(:path) { 'foo/bar with spaces' }
        let(:expected_path) { 'foo/bar%20with%20spaces' }
      end

      it_behaves_like 'valid checkout URL' do
        let(:path) { 'foo/bar with §\""!??```' }
        let(:expected_path) { 'foo/%C2%A7%22!??%60%60%60' }
      end
    end
  end

  describe '#checkout_command' do
    it 'returns the SCM vendor command' do
      expect(service.checkout_command).to eq('svn checkout')
    end
  end

  describe '#instructions' do
    it 'returns the setting when defined' do
      expect(service.instructions).to eq('foo')
    end

    context 'no setting defined' do
      let(:text) { nil }

      it 'returns the default translated instructions' do
        expect(service.instructions)
          .to eq(I18n.t('repositories.checkout.default_instructions.subversion'))
      end
    end
  end

  describe '#settings' do
    it 'svn is available for checkout' do
      expect(service.available?).to be true
      expect(service.checkout_enabled?).to be true
    end

    it 'has the correct settings' do
      expect(Setting.repository_checkout_data['subversion']['enabled']).to eq('1')
      expect(service.instructions).to eq('foo')
      expect(service.checkout_base_url).to eq(base_url)
    end

    context 'missing checkout base URL' do
      let(:base_url) { '' }

      it 'is not available for checkout even when enabled' do
        expect(service.checkout_base_url).to eq(base_url)
        expect(service.checkout_enabled?).to be true
        expect(service.available?).to be false
      end
    end

    context 'disabled repository' do
      let(:repository) { build(:repository_git) }

      it 'git is not available for checkout' do
        expect(service.available?).to be false
        expect(service.checkout_enabled?).to be false
      end
    end
  end

  describe '#permission' do
    context 'with no managed repository' do
      it 'is not applicable' do
        expect(service.manages_permissions?).to be false
      end
    end

    context 'with managed repository' do
      before do
        allow(repository).to receive(:managed?).and_return(true)
      end

      it 'is applicable' do
        expect(service.manages_permissions?).to be true
      end

      it 'returns readwrite permission when user has commit_access permission' do
        mock_permissions_for(user) do |mock|
          mock.allow_in_project :commit_access, project:
        end

        expect(service.permission).to eq(:readwrite)
      end

      it 'returns read permission when user has browse_repository permission' do
        mock_permissions_for(user) do |mock|
          mock.allow_in_project :browse_repository, project:
        end

        expect(service.permission).to eq(:read)
      end

      it 'returns none permission when user has no permission' do
        mock_permissions_for(user, &:forbid_everything)

        expect(service.permission).to eq(:none)
      end

      it 'returns the correct permissions for commit access' do
        mock_permissions_for(user) do |mock|
          mock.allow_in_project :commit_access, project:
        end

        expect(service.may_commit?).to be true
        expect(service.may_checkout?).to be true
      end

      it 'returns the correct permissions for read access' do
        mock_permissions_for(user) do |mock|
          mock.allow_in_project :browse_repository, project:
        end

        expect(service.may_commit?).to be false
        expect(service.may_checkout?).to be true
      end

      it 'returns the correct permissions for no access' do
        mock_permissions_for(user, &:forbid_everything)

        expect(service.may_commit?).to be false
        expect(service.may_checkout?).to be false
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

##
# Implements a repository factory for building temporary and permanent repositories.
class SCM::RepositoryFactoryService
  attr_reader :project, :params, :repository

  def initialize(project, params)
    @project = project
    @params = params
  end

  ##
  # Build a full repository from a given scm_type
  # and persists it.
  #
  # @return [Boolean] true iff the repository was built
  def build_and_save
    build_guarded do
      repository = build_with_type(params.fetch(:scm_type).to_sym)
      if repository.save
        repository
      else
        raise OpenProject::SCM::Exceptions::RepositoryBuildError.new(
          repository.errors.full_messages.join(""\n"")
        )
      end
    end
  end

  ##
  # Build a temporary repository used only for determining available settings and types
  # of that particular vendor.
  #
  # @return [Boolean] true iff the repository was built
  def build_temporary
    build_guarded do
      build_with_type(nil)
    end
  end

  def build_error
    I18n.t('repositories.errors.build_failed', reason: @build_failed_msg)
  end

  private

  ##
  # Helper to actually build the repository and return it.
  # May raise +OpenProject::SCM::Exceptions::RepositoryBuildError+ internally.
  #
  # @param [Symbol] scm_type Type to build the repository with. May be nil
  #                          during temporary build
  def build_with_type(scm_type)
    Repository.build(
      project,
      params.fetch(:scm_vendor).to_sym,
      params.fetch(:repository, {}),
      scm_type
    )
  end

  def build_guarded
    @repository = yield
    @repository.present?
  rescue OpenProject::SCM::Exceptions::RepositoryBuildError => e
    @build_failed_msg = e.message
    nil
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.

require 'spec_helper'

RSpec.describe SCM::RepositoryFactoryService do
  let(:user) { build(:user) }
  let(:project) { build(:project) }

  let(:enabled_scms) { ['subversion', 'git'] }

  let(:params_hash) { {} }
  let(:params) { ActionController::Parameters.new params_hash }

  subject(:service) { SCM::RepositoryFactoryService.new(project, params) }

  before do
    allow(Setting).to receive(:enabled_scm).and_return(enabled_scms)
  end

  context 'with empty hash' do
    it 'does not build a repository' do
      expect { service.build_temporary }
        .to raise_error KeyError
      expect(service.repository).to be_nil
    end
  end

  context 'with valid vendor' do
    let(:params_hash) do
      { scm_vendor: 'subversion' }
    end

    it 'allows temporary build repository' do
      expect(service.build_temporary).to be true
      expect(service.repository).not_to be_nil
    end

    it 'does not allow to persist a repository' do
      expect { service.build_and_save }
        .to raise_error(ActionController::ParameterMissing)

      expect(service.repository).to be_nil
    end
  end

  context 'with invalid vendor' do
    let(:params_hash) do
      { scm_vendor: 'not_subversion', scm_type: 'foo' }
    end

    it 'does not allow to temporary build repository' do
      expect { service.build_temporary }.not_to raise_error

      expect(service.repository).to be_nil
      expect(service.build_error).to include('The SCM vendor not_subversion is disabled')
    end

    it 'does not allow to persist a repository' do
      expect { service.build_temporary }.not_to raise_error

      expect(service.repository).to be_nil
      expect(service.build_error).to include('The SCM vendor not_subversion is disabled')
    end
  end

  context 'with vendor and type' do
    let(:params_hash) do
      { scm_vendor: 'subversion', scm_type: 'existing' }
    end

    it 'does not allow to persist a repository without URL' do
      expect(service.build_and_save).not_to be true

      expect(service.repository).to be_nil
      expect(service.build_error).to include(""URL can't be blank"")
    end
  end

  context 'with invalid hash' do
    let(:params_hash) do
      {
        scm_vendor: 'subversion', scm_type: 'existing',
        repository: { url: '/tmp/foo.svn' }
      }
    end

    it 'does not allow to persist a repository URL' do
      expect(service.build_and_save).not_to be true

      expect(service.repository).to be_nil
      expect(service.build_error).to include('URL is invalid')
    end
  end

  context 'with valid hash' do
    let(:params_hash) do
      {
        scm_vendor: 'subversion', scm_type: 'existing',
        repository: { url: 'file:///tmp/foo.svn' }
      }
    end

    it 'allows to persist a repository without URL' do
      expect(service.build_and_save).to be true
      expect(service.repository).to be_a(Repository::Subversion)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

##
# Implements the asynchronous deletion of a local repository.
class SCM::DeleteManagedRepositoryService < SCM::BaseRepositoryService
  ##
  # Checks if a given repository may be deleted
  # Registers an asynchronous job to delete the repository on disk.
  #
  def call
    return false unless repository.managed?

    if repository.class.manages_remote?
      SCM::DeleteRemoteRepositoryJob.perform_now(repository)
      true
    else
      delete_local_repository
    end
  rescue OpenProject::SCM::Exceptions::SCMError => e
    @rejected = e.message
    false
  end

  def delete_local_repository
    # Create necessary changes to repository to mark
    # it as managed by OP, but delete asynchronously.
    managed_path = repository.root_url

    if File.directory?(managed_path)
      ##
      # We want to move this functionality in a Delayed Job,
      # but this heavily interferes with the error handling of the whole
      # repository management process.
      # Instead, this will be refactored into a single service wrapper for
      # creating and deleting repositories, which provides transactional DB access
      # as well as filesystem access.
      SCM::DeleteLocalRepositoryJob.perform_now(managed_path)
    end

    true
  rescue SystemCallError => e
    @rejected = I18n.t('repositories.errors.managed_delete_local',
                       path: repository.root_url,
                       error_message: e.message)
    false
  end

  ##
  # Returns the error symbol
  def localized_rejected_reason
    @rejected ||= I18n.t('repositories.errors.managed_delete')
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.

require 'spec_helper'

RSpec.describe SCM::DeleteManagedRepositoryService, skip_if_command_unavailable: 'svnadmin' do
  let(:user) { build(:user) }
  let(:config) { {} }
  let(:project) { build(:project) }

  let(:repository) { build(:repository_subversion) }

  subject(:service) { SCM::DeleteManagedRepositoryService.new(repository) }

  before do
    allow(OpenProject::Configuration).to receive(:[]).and_call_original
    allow(OpenProject::Configuration).to receive(:[]).with('scm').and_return(config)
    allow(Setting).to receive(:enabled_scm).and_return(['subversion', 'git'])
  end

  shared_examples 'does not delete the repository' do
    it 'does not delete the repository' do
      expect(repository.managed?).to be false
      expect(service.call).to be false
    end
  end

  context 'with no managed configuration' do
    it_behaves_like 'does not delete the repository'
  end

  context 'with managed repository, but no config' do
    let(:repository) { build(:repository_subversion, scm_type: :managed) }

    it 'does allow to delete the repository' do
      expect(repository.managed?).to be true
      expect(service.call).to be true
    end
  end

  context 'with managed repository and managed config' do
    include_context 'with tmpdir'
    let(:config) do
      {
        subversion: { manages: File.join(tmpdir, 'svn') },
        git: { manages: File.join(tmpdir, 'git') }
      }
    end

    let(:repository) do
      repo = Repository::Subversion.new(scm_type: :managed)
      repo.project = project
      repo.configure(:managed, nil)

      repo.save!
      perform_enqueued_jobs
      repo
    end

    it 'deletes the repository' do
      expect(File.directory?(repository.root_url)).to be true
      expect(service.call).to be true
      expect(File.directory?(repository.root_url)).to be false
    end

    it 'does not raise an exception upon permission errors' do
      expect(File.directory?(repository.root_url)).to be true
      expect(SCM::DeleteLocalRepositoryJob)
        .to receive(:new).and_raise(Errno::EACCES)

      expect(service.call).to be false
    end

    context 'and parent project' do
      let(:parent) { create(:project) }
      let(:project) { create(:project, parent:) }
      let(:repo_path) do
        Pathname.new(File.join(tmpdir, 'svn', project.identifier))
      end

      it 'does not delete anything but the repository itself' do
        expect(service.call).to be true

        path = Pathname.new(repository.root_url)
        expect(path).to eq(repo_path)

        expect(path.exist?).to be false
        expect(path.parent.exist?).to be true
        expect(path.parent.to_s).to eq(repository.class.managed_root)
      end
    end
  end

  context 'with managed remote config', webmock: true do
    let(:url) { 'http://myreposerver.example.com/api/' }
    let(:config) do
      {
        subversion: { manages: url }
      }
    end

    let(:repository) do
      repo = Repository::Subversion.new(scm_type: :managed)
      repo.project = project
      repo.configure(:managed, nil)

      repo
    end

    context 'with a valid remote' do
      before do
        stub_request(:post, url).to_return(status: 200, body: {}.to_json)
      end

      it 'calls the callback' do
        expect(SCM::DeleteRemoteRepositoryJob)
          .to receive(:perform_now)
          .and_call_original

        expect(service.call).to be true
        expect(WebMock)
          .to have_requested(:post, url)
          .with(body: hash_including(identifier: repository.repository_identifier,
                                     action: 'delete'))
      end
    end

    context 'with a remote callback returning an error' do
      before do
        stub_request(:post, url)
          .to_return(status: 400, body: { success: false, message: 'An error occurred' }.to_json)
      end

      it 'calls the callback' do
        expect(SCM::DeleteRemoteRepositoryJob)
          .to receive(:perform_now)
          .and_call_original

        expect(service.call).to be false

        expect(service.localized_rejected_reason)
          .to eq(""Calling the managed remote failed with message 'An error occurred' (Code: 400)"")
        expect(WebMock)
          .to have_requested(:post, url)
                .with(body: hash_including(action: 'delete'))
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class Authorization::EnterpriseService
  attr_accessor :token

  GUARDED_ACTIONS = %i(
    baseline_comparison
    board_view
    conditional_highlighting
    custom_actions
    custom_fields_in_projects_list
    date_alerts
    define_custom_style
    edit_attribute_groups
    grid_widget_wp_graph
    ldap_groups
    openid_providers
    placeholder_users
    readonly_work_packages
    team_planner_view
    two_factor_authentication
    work_package_query_relation_columns
    work_package_sharing
  ).freeze

  def initialize(token)
    self.token = token
  end

  # Return a true ServiceResult if the token contains this particular action.
  def call(action)
    allowed =
      if token.nil? || token.token_object.nil? || token.expired?
        false
      else
        process(action)
      end

    result(allowed)
  end

  private

  def process(action)
    # Every non-expired token
    GUARDED_ACTIONS.include?(action.to_sym)
  end

  def result(bool)
    ServiceResult.new(success: bool, result: bool)
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Authorization::EnterpriseService do
  let(:token_object) do
    token = OpenProject::Token.new
    token.subscriber = 'Foobar'
    token.mail = 'foo@example.org'
    token.starts_at = Date.today
    token.expires_at = nil

    token
  end
  let(:token) { double('EnterpriseToken', token_object:) }
  let(:instance) { described_class.new(token) }
  let(:result) { instance.call(action) }
  let(:action) { :an_action }

  describe '#initialize' do
    it 'has the token' do
      expect(instance.token).to eql token
    end
  end

  describe 'expiry' do
    before do
      allow(token).to receive(:expired?).and_return(expired)
    end

    context 'when expired' do
      let(:expired) { true }

      it 'returns a false result' do
        expect(result).to be_a ServiceResult
        expect(result.result).to be_falsey
        expect(result.success?).to be_falsey
      end
    end

    context 'when active' do
      let(:expired) { false }

      context 'invalid action' do
        it 'returns false' do
          expect(result.result).to be_falsey
        end
      end

      %i(baseline_comparison
         board_view
         conditional_highlighting
         custom_actions
         custom_fields_in_projects_list
         date_alerts
         define_custom_style
         edit_attribute_groups
         grid_widget_wp_graph
         ldap_groups
         openid_providers
         placeholder_users
         readonly_work_packages
         team_planner_view
         two_factor_authentication
         work_package_query_relation_columns
         work_package_sharing).each do |guarded_action|
        context ""guarded action #{guarded_action}"" do
          let(:action) { guarded_action }

          it 'returns a true result' do
            expect(result).to be_a ServiceResult
            expect(result.result).to be_truthy
            expect(result.success?).to be_truthy
          end
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class Authorization::QueryTransformation
  attr_accessor :on, :name, :after, :before, :block

  def initialize(on,
                 name,
                 after,
                 before,
                 block)

    self.on = on
    self.name = name
    self.after = after
    self.before = before
    self.block = block
  end

  def apply(*args)
    block.call(*args)
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Authorization::QueryTransformation do
  let(:on) { 'on' }
  let(:name) { 'name' }
  let(:after) { 'after' }
  let(:before) { 'before' }
  let(:block) { ->(*args) { args } }

  let(:instance) do
    described_class.new on,
                        name,
                        after,
                        before,
                        block
  end

  context 'initialSetup' do
    it 'sets on' do
      expect(instance.on).to eql on
    end

    it 'sets name' do
      expect(instance.name).to eql name
    end

    it 'sets after' do
      expect(instance.after).to eql after
    end

    it 'sets before' do
      expect(instance.before).to eql before
    end

    it 'sets block' do
      expect(instance.block).to eql block
    end
  end

  context 'apply' do
    it 'calls the block' do
      expect(instance.apply(1, 2, 3)).to match_array [1, 2, 3]
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class Authorization::UserProjectRolesQuery < Authorization::UserRolesQuery
  transformations.register :all, :project_where_projection do |statement, user, _|
    statement.where(users_table[:id].eq(user.id))
  end

  transformations.register users_members_join, :project_id_limit do |statement, _, project|
    statement
      .and(members_table[:project_id].eq(project.id))
      .and(members_table[:entity_type].eq(nil))
      .and(members_table[:entity_id].eq(nil))
  end

  transformations.register roles_member_roles_join, :builtin_role do |statement, user, project|
    if project.public?
      builtin_role = if user.logged?
                       Role::BUILTIN_NON_MEMBER
                     else
                       Role::BUILTIN_ANONYMOUS
                     end

      builtin_role_condition = members_table[:id]
                               .eq(nil)
                               .and(roles_table[:builtin]
                                    .eq(builtin_role))

      statement = statement.or(builtin_role_condition)
    end

    statement
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Authorization::UserProjectRolesQuery do
  let(:user) { build(:user) }
  let(:anonymous) { build(:anonymous) }
  let(:project) { build(:project, public: false) }
  let(:project2) { build(:project, public: false) }
  let(:public_project) { build(:project, public: true) }
  let(:work_package) { build(:work_package, project:) }
  let(:role) { build(:project_role) }
  let(:role2) { build(:project_role) }
  let(:wp_role) { build(:work_package_role) }
  let(:anonymous_role) { build(:anonymous_role) }
  let(:non_member) { build(:non_member) }
  let(:member) { build(:member, project:, roles: [role], principal: user) }
  let(:member2) { build(:member, project: project2, roles: [role2], principal: user) }
  let(:wp_member) { build(:member, project:, roles: [wp_role], principal: user, entity: work_package) }

  describe '.query' do
    before do
      non_member.save!
      anonymous_role.save!
      user.save!
    end

    it 'is a user relation' do
      expect(described_class.query(user, project)).to be_a ActiveRecord::Relation
    end

    context 'with the user being a member in the project' do
      before do
        member.save!
      end

      it 'is the project roles' do
        expect(described_class.query(user, project)).to match [role]
      end
    end

    context 'without the user being member in the project' do
      context 'with the project being private' do
        it 'is empty' do
          expect(described_class.query(user, project)).to be_empty
        end
      end

      context 'with the project being public' do
        it 'is the non member role' do
          expect(described_class.query(user, public_project)).to contain_exactly(non_member)
        end
      end
    end

    context 'with the user being anonymous' do
      context 'with the project being public' do
        it 'is empty' do
          expect(described_class.query(anonymous, public_project)).to contain_exactly(anonymous_role)
        end
      end

      context 'without the project being public' do
        it 'is empty' do
          expect(described_class.query(anonymous, project)).to be_empty
        end
      end
    end

    context 'with the user being a member in two projects' do
      before do
        member.save!
        member2.save!
      end

      it 'returns only the roles from the requested project' do
        expect(described_class.query(user, project)).to contain_exactly(role)
      end
    end

    context 'with the user being a member of a work package of the project' do
      before { wp_member.save! }

      context 'and not being a member of the project itself' do
        it { expect(described_class.query(user, project)).to be_empty }
      end

      context 'and being a member of the project as well' do
        before { member.save! }

        it { expect(described_class.query(user, project)).to contain_exactly(role) }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class Authorization::UserAllowedQuery < Authorization::AbstractUserQuery
  self.model = User

  transformations.register :all,
                           :member_roles_join do |statement|
    statement.outer_join(member_roles_table)
             .on(members_member_roles_join)
  end

  transformations.register :all,
                           :where_projection do |statement, action, project|
    statement = statement.group(users_table[:id])

    # No action allowed on archived projects
    # No action allowed on disabled modules
    if project.active? && project.allows_to?(action)
      has_role = roles_table[:id].not_eq(nil)
      has_permission = role_permissions_table[:id].not_eq(nil)

      has_role_and_permission = if OpenProject::AccessControl.permission(action).public?
                                  has_role
                                else
                                  has_role.and(has_permission)
                                end

      is_admin = if OpenProject::AccessControl.grant_to_admin?(action)
                   users_table[:admin].eq(true)
                 else
                   Arel::Nodes::Equality.new(1, 0)
                 end

      statement.where(has_role_and_permission.or(is_admin))
    else
      statement.where(Arel::Nodes::Equality.new(1, 0))
    end
  end

  transformations.register users_members_join,
                           :project_id_limit do |statement, _, project|
    statement.and(members_table[:project_id].eq(project.id))
  end

  transformations.register :all,
                           :roles_join,
                           after: [:member_roles_join] do |statement, _, project|
    statement.outer_join(roles_table)
             .on(roles_member_roles_join(project))
  end

  transformations.register :all,
                           :role_permissions_join,
                           after: [:roles_join] do |statement, action|
    if OpenProject::AccessControl.permission(action).public?
      statement
    else
      statement.outer_join(role_permissions_table)
               .on(roles_table[:id]
                   .eq(role_permissions_table[:role_id])
                   .and(role_permissions_table[:permission].eq(action.to_s)))
    end
  end

  def self.roles_member_roles_join(project)
    id_equal = roles_table[:id].eq(member_roles_table[:role_id])

    if project.public?
      member_or_public_project_condition(id_equal)
    else
      id_equal
    end
  end

  def self.no_membership_and_non_member_role_condition
    roles_table
      .grouping(member_roles_table[:role_id]
                .eq(nil)
                .and(roles_table[:builtin].eq(Role::BUILTIN_NON_MEMBER)))
  end

  def self.anonymous_user_condition
    users_table[:type]
      .eq('AnonymousUser')
      .and(roles_table[:builtin].eq(Role::BUILTIN_ANONYMOUS))
  end

  def self.member_or_public_project_condition(id_equal)
    roles_table
      .grouping(users_table[:type]
                .eq('User')
                .and(id_equal.or(no_membership_and_non_member_role_condition)))
      .or(anonymous_user_condition)
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Authorization::UserAllowedQuery do
  describe '.query' do
    let(:user) { member.principal }
    let(:anonymous) { build(:anonymous) }
    let(:project) { build(:project, public: false) }
    let(:project2) { build(:project, public: false) }
    let(:role) { build(:project_role) }
    let(:role2) { build(:project_role) }
    let(:anonymous_role) { build(:anonymous_role) }
    let(:non_member_role) { build(:non_member) }
    let(:member) do
      build(:member, project:,
                     roles: [role])
    end

    let(:action) { :view_work_packages }
    let(:other_action) { :another }
    let(:public_action) { :view_project }

    before do
      user.save!
      anonymous.save!
      anonymous_role.save!
      non_member_role.save!
    end

    it 'is an AR relation' do
      expect(described_class.query(action, project)).to be_a ActiveRecord::Relation
    end

    context 'w/o the project being public
             w/ the user being member in the project
             w/ the role having the necessary permission' do
      before do
        role.add_permission! action
        role.save!

        member.save!
      end

      it 'returns the user' do
        expect(described_class.query(action, project)).to match_array [user]
      end
    end

    context 'w/o the project being public
             w/o the user being member in the project
             w/ the user being admin' do
      before do
        user.update_attribute(:admin, true)
      end

      it 'returns the user' do
        expect(described_class.query(action, project)).to match_array [user]
      end
    end

    context 'w/o the project being public
             w/ the user being member in the project
             w/o the role having the necessary permission' do
      before do
        role.save!
        member.save!
      end

      it 'is empty' do
        expect(described_class.query(action, project)).to be_empty
      end
    end

    context 'w/o the project being public
             w/o the user being member in the project
             w/ the role having the necessary permission' do
      before do
        role.add_permission! action
        role.save!
      end

      it 'returns the user' do
        expect(described_class.query(action, project)).to be_empty
      end
    end

    context 'w/o the project being public
             w/o the user being member in the project
             w/ the user being member in a different project
             w/ the role having the permission' do
      before do
        role.add_permission! action
        role.save!

        member.project = project2
        member.save!
      end

      it 'is empty' do
        expect(described_class.query(action, project)).to be_empty
      end
    end

    context 'w/ the project being public
             w/o the user being member in the project
             w/ the user being member in a different project
             w/ the role having the permission' do
      before do
        role.add_permission! action
        role.save!

        project.public = true
        project.save!

        member.project = project2
        member.save!
      end

      it 'is empty' do
        expect(described_class.query(action, project)).to be_empty
      end
    end

    context 'w/ the project being public
             w/o the user being member in the project
             w/ the non member role having the necessary permission' do
      before do
        project.public = true

        non_member = ProjectRole.non_member
        non_member.add_permission! action
        non_member.save

        project.save!
      end

      it 'returns the user' do
        expect(described_class.query(action, project)).to match_array [user]
      end
    end

    context 'w/ the project being public
             w/o the user being member in the project
             w/ the anonymous role having the necessary permission' do
      before do
        project.public = true

        anonymous_role = ProjectRole.anonymous
        anonymous_role.add_permission! action
        anonymous_role.save

        project.save!
      end

      it 'returns the anonymous user' do
        expect(described_class.query(action, project)).to match_array([anonymous])
      end
    end

    context 'w/ the project being public
             w/o the user being member in the project
             w/ the non member role having another permission' do
      before do
        project.public = true

        non_member = ProjectRole.non_member
        non_member.add_permission! other_action
        non_member.save

        project.save!
      end

      it 'is empty' do
        expect(described_class.query(action, project)).to be_empty
      end
    end

    context 'w/ the project being private
             w/o the user being member in the project
             w/ the non member role having the permission' do
      before do
        non_member = ProjectRole.non_member
        non_member.add_permission! action
        non_member.save

        project.save!
      end

      it 'is empty' do
        expect(described_class.query(action, project)).to be_empty
      end
    end

    context 'w/ the project being public
             w/ the user being member in the project
             w/o the role having the necessary permission
             w/ the non member role having the permission' do
      before do
        project.public = true
        project.save

        role.add_permission! other_action
        member.save!

        non_member = ProjectRole.non_member
        non_member.add_permission! action
        non_member.save
      end

      it 'is empty' do
        expect(described_class.query(action, project)).to be_empty
      end
    end

    context 'w/o the project being public
             w/ the user being member in the project
             w/o the role having the permission
             w/ the permission being public' do
      before do
        member.save!
      end

      it 'returns the user' do
        expect(described_class.query(public_action, project)).to match_array [user]
      end
    end

    context 'w/ the project being public
             w/o the user being member in the project
             w/o the role having the permission
             w/ the permission being public' do
      before do
        project.public = true
        project.save
      end

      it 'returns the user and anonymous' do
        expect(described_class.query(public_action, project)).to match_array [user, anonymous]
      end
    end

    context 'w/ the user being member in the project
             w/ asking for a certain permission
             w/ the permission belonging to a module
             w/o the module being active' do
      let(:permission) do
        OpenProject::AccessControl.permissions.find { |p| p.project_module.present? }
      end

      before do
        project.enabled_module_names = []

        role.add_permission! permission.name
        member.save!
      end

      it 'is empty' do
        expect(described_class.query(permission.name, project)).to eq []
      end
    end

    context 'w/ the user being member in the project
             w/ asking for a certain permission
             w/ the permission belonging to a module
             w/ the module being active' do
      let(:permission) do
        OpenProject::AccessControl.permissions.find { |p| p.project_module.present? }
      end

      before do
        project.enabled_module_names = [permission.project_module]

        role.add_permission! permission.name
        member.save!
      end

      it 'returns the user' do
        expect(described_class.query(permission.name, project)).to eq [user]
      end
    end

    context 'w/ the user being member in the project
             w/ asking for a certain permission
             w/ the user having the permission in the project
             w/o the project being active' do
      before do
        role.add_permission! action
        member.save!

        project.update(active: false)
      end

      it 'is empty' do
        expect(described_class.query(action, project)).to eq []
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class Authorization::QueryTransformations
  def for?(on)
    !!transformations[transformation_key(on)]
  end

  def for(on)
    transformations[transformation_key(on)]
  end

  def register(on,
               name,
               after: [],
               before: [],
               &block)

    transformation = ::Authorization::QueryTransformation.new(on, name, after, before, block)

    add_transformation(transformation)
    sort_transformations(on)
  end

  def copy
    the_new = self.class.new

    the_new.transformations = transformations.deep_dup
    the_new.transformation_order = transformation_order.deep_dup

    the_new
  end

  protected

  attr_accessor :transformations,
                :transformation_order

  private

  def transformation_key(on)
    if on.respond_to?(:to_sql)
      on.to_sql
    else
      on
    end
  end

  def transformations
    @transformations ||= {}
  end

  def transformation_order
    @transformation_order ||= ::Authorization::QueryTransformationsOrder.new
  end

  def add_transformation(transformation)
    transformations[transformation_key(transformation.on)] ||= []

    transformations[transformation_key(transformation.on)] << transformation

    transformation_order << transformation
  end

  def sort_transformations(on)
    desired_order = transformation_order.full_order

    transformations[transformation_key(on)].sort_by! { |x| desired_order.index x.name }
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Authorization::QueryTransformations do
  let(:instance) { described_class.new }

  context 'registering a transformation' do
    before do
      instance.register(:on, :name) do |*args|
        args
      end
    end

    describe '#for?' do
      it 'is true for the registered name' do
        expect(instance.for?(:on)).to be_truthy
      end

      it 'is false for another name' do
        expect(instance.for?(:other_name)).to be_falsey
      end
    end

    describe '#for' do
      it 'returns an array of transformations for the registered name' do
        expect(instance.for(:on).length).to be 1

        expect(instance.for(:on)[0].on).to be :on
        expect(instance.for(:on)[0].name).to be :name
        expect(instance.for(:on)[0].block.call(1, 2, 3)).to match_array [1, 2, 3]
      end

      it 'is nil for another name' do
        expect(instance.for(:other_name)).to be_nil
      end
    end
  end

  context 'registering two transformations depending via after' do
    before do
      instance.register(:on, :transformation1, after: [:transformation2]) do |*args|
        args
      end

      instance.register(:on, :transformation2) do |*args|
        args.join(', ')
      end
    end

    describe '#for?' do
      it 'is true for the registered name' do
        expect(instance.for?(:on)).to be_truthy
      end

      it 'is false for another name' do
        expect(instance.for?(:other_name)).to be_falsey
      end
    end

    describe '#for' do
      it 'returns an array of transformations for the registered name' do
        expect(instance.for(:on).length).to be 2

        expect(instance.for(:on)[0].on).to be :on
        expect(instance.for(:on)[0].name).to be :transformation2
        expect(instance.for(:on)[0].block.call(1, 2, 3)).to eql '1, 2, 3'

        expect(instance.for(:on)[1].on).to be :on
        expect(instance.for(:on)[1].name).to be :transformation1
        expect(instance.for(:on)[1].block.call(1, 2, 3)).to match_array [1, 2, 3]
      end
    end
  end

  context 'registering two transformations depending via before' do
    before do
      instance.register(:on, :transformation1) do |*args|
        args
      end

      instance.register(:on, :transformation2, before: [:transformation1]) do |*args|
        args.join(', ')
      end
    end

    describe '#for?' do
      it 'is true for the registered name' do
        expect(instance.for?(:on)).to be_truthy
      end

      it 'is false for another name' do
        expect(instance.for?(:other_name)).to be_falsey
      end
    end

    describe '#for' do
      it 'returns an array of transformations for the registered name' do
        expect(instance.for(:on).length).to be 2

        expect(instance.for(:on)[0].on).to be :on
        expect(instance.for(:on)[0].name).to be :transformation2
        expect(instance.for(:on)[0].block.call(1, 2, 3)).to eql '1, 2, 3'

        expect(instance.for(:on)[1].on).to be :on
        expect(instance.for(:on)[1].name).to be :transformation1
        expect(instance.for(:on)[1].block.call(1, 2, 3)).to match_array [1, 2, 3]
      end
    end
  end

  context 'registering two mutually dependent transformations' do
    it 'fails' do
      instance.register(:on, :transformation1, before: [:transformation2]) do |*args|
        args
      end

      expected_order = %i[transformation1 transformation2]

      expect do
        instance.register(:on, :transformation2, before: [:transformation1]) do |*args|
          args.join(', ')
        end
      end.to raise_error ""Cannot sort #{expected_order} into the list of transformations""
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
module Authorization
  class UserPermissibleService
    attr_accessor :user

    def initialize(user)
      @user = user
    end

    def allowed_globally?(permission)
      perms = contextual_permissions(permission, :global)
      return false unless authorizable_user?
      return true if admin_and_all_granted_to_admin?(perms)

      cached_permissions(nil).intersect?(perms.map(&:name))
    end

    def allowed_in_project?(permission, projects_to_check)
      perms = contextual_permissions(permission, :project)
      return false if projects_to_check.blank?
      return false unless authorizable_user?

      projects = Array(projects_to_check)

      projects.all? do |project|
        allowed_in_single_project?(perms, project)
      end
    end

    def allowed_in_any_project?(permission)
      perms = contextual_permissions(permission, :project)
      return false unless authorizable_user?
      return true if admin_and_all_granted_to_admin?(perms)

      Project.allowed_to(user, perms).exists?
    end

    def allowed_in_entity?(permission, entities_to_check, entity_class)
      return false if entities_to_check.blank?
      return false unless authorizable_user?

      perms = contextual_permissions(permission, context_name(entity_class))

      entities = Array(entities_to_check)

      entities.all? do |entity|
        allowed_in_single_entity?(perms, entity)
      end
    end

    def allowed_in_any_entity?(permission, entity_class, in_project: nil)
      perms = contextual_permissions(permission, context_name(entity_class))
      return false unless authorizable_user?
      return true if admin_and_all_granted_to_admin?(perms)

      # entity_class.allowed_to will also check whether the user has the permission via a membership in the project.
      # ^-- still a problem in some cases
      allowed_scope = entity_class.allowed_to(user, perms)

      if in_project
        allowed_in_single_project?(perms, in_project) || allowed_scope.exists?(project: in_project)
      else
        allowed_in_any_project?(perms) || allowed_scope.exists?
      end
    end

    private

    def cached_permissions(context)
      @cached_permissions ||= Hash.new do |hash, context_key|
        hash[context_key] = user.all_permissions_for(context_key)
      end

      @cached_permissions[context]
    end

    def allowed_in_single_project?(permissions, project)
      return false if project.nil?
      return false unless project.active? || project.being_archived?

      permissions_filtered_for_project = permissions_by_enabled_project_modules(project, permissions)

      return false if permissions_filtered_for_project.empty?
      return true if admin_and_all_granted_to_admin?(permissions)

      cached_permissions(project).intersect?(permissions_filtered_for_project)
    end

    def allowed_in_single_entity?(permissions, entity)
      return false if entity.nil?
      return false if entity.project.nil?
      return false unless entity.project.active? || entity.project.being_archived?

      permissions_filtered_for_project = permissions_by_enabled_project_modules(entity.project, permissions)

      return false if permissions_filtered_for_project.empty?
      return true if admin_and_all_granted_to_admin?(permissions)

      # The combination of this is better then doing
      # EntityClass.allowed_to(user, permission).exists?.
      # Because this way, all permissions for that context are fetched and cached.
      allowed_in_single_project?(permissions, entity.project) ||
        cached_permissions(entity).intersect?(permissions_filtered_for_project)
    end

    def admin_and_all_granted_to_admin?(permissions)
      user.admin? && permissions.all?(&:grant_to_admin?)
    end

    def authorizable_user?
      !user.locked? || user.is_a?(SystemUser)
    end

    def permissions_by_enabled_project_modules(project, permissions)
      project
        .allowed_permissions
        .intersection(permissions.map(&:name))
        .map { |perm| perm.name.to_sym }
    end

    def contextual_permissions(permission, context)
      Authorization.contextual_permissions(permission, context, raise_on_unknown: true)
    end

    def context_name(entity_class)
      entity_class.model_name.element.to_sym
    end
  end
end

```","require 'rails_helper'

RSpec.describe Authorization::UserPermissibleService do
  shared_let(:user) { create(:user) }
  shared_let(:anonymous_user) { create(:anonymous) }
  shared_let(:project) { create(:project) }
  shared_let(:work_package) { create(:work_package, project:) }
  shared_let(:non_member_role) { create(:non_member, permissions: [:view_news]) }
  shared_let(:anonymous_role) { create(:anonymous_role, permissions: [:view_meetings]) }

  let(:queried_user) { user }

  subject(:service) { described_class.new(queried_user) }

  # The specs in this file do not cover all the various cases yet. Thus,
  # we rely on the Authorization.roles scope and the Project/WorkPackage.allowed_to scopes
  # to be called which is speced precisely.
  shared_examples_for 'the Authorization.roles scope used' do
    before do
      allow(Authorization)
        .to receive(:roles)
              .and_call_original
    end

    it 'calls the Authorization.roles scope once (cached for the second request)' do
      subject
      subject

      expect(Authorization)
        .to have_received(:roles)
              .once
              .with(queried_user, context)
    end
  end

  shared_examples_for 'the Project.allowed_to scope used' do
    before do
      allow(Project)
        .to receive(:allowed_to)
              .and_call_original
    end

    it 'calls the Project.allowed_to scope' do
      subject

      expect(Project)
        .to have_received(:allowed_to) do |user, perm|
        expect(user).to eq(queried_user)
        expect(perm[0]).to be_a(OpenProject::AccessControl::Permission)
        expect(perm[0].name).to eq permission
      end
    end
  end

  shared_examples_for 'the WorkPackage.allowed_to scope used' do
    before do
      allow(WorkPackage)
        .to receive(:allowed_to)
              .and_call_original
    end

    it 'calls the WorkPackage.allowed_to scope' do
      subject

      expect(WorkPackage)
        .to have_received(:allowed_to) do |user, perm|
        expect(user).to eq(queried_user)
        expect(perm[0]).to be_a(OpenProject::AccessControl::Permission)
        expect(perm[0].name).to eq permission
      end
    end
  end

  describe '#allowed_globally?' do
    context 'when asking for a permission that is not defined' do
      let(:permission) { :not_defined }

      it 'raises an error' do
        expect { subject.allowed_globally?(permission) }.to raise_error(Authorization::UnknownPermissionError)
      end
    end

    context 'when asking for a permission that is defined' do
      let(:permission) { :create_user }

      context 'and the user is a regular user' do
        context 'without a role granting the permission' do
          it { is_expected.not_to be_allowed_globally(permission) }
        end

        context 'with a role granting the permission' do
          let(:global_role) { create(:global_role, permissions: [permission]) }
          let!(:member) { create(:global_member, user:, roles: [global_role]) }

          it { is_expected.to be_allowed_globally(permission) }

          context 'and the account is locked' do
            before { user.locked! }

            it { is_expected.not_to be_allowed_globally(permission) }
          end
        end
      end

      context 'and the user is an admin' do
        let(:user) { create(:admin) }

        it { is_expected.to be_allowed_globally(permission) }

        context 'and the account is locked' do
          before { user.locked! }

          it { is_expected.not_to be_allowed_globally(permission) }
        end
      end

      it_behaves_like 'the Authorization.roles scope used' do
        let(:context) { nil }
        subject { service.allowed_globally?(permission) }
      end
    end
  end

  describe '#allowed_in_project?' do
    context 'when asking for a permission that is not defined' do
      let(:permission) { :not_defined }

      it 'raises an error' do
        expect { subject.allowed_in_project?(permission, project) }.to raise_error(Authorization::UnknownPermissionError)
      end
    end

    context 'when asking for a permission that is defined' do
      let(:permission) { :view_work_packages }

      it_behaves_like 'the Authorization.roles scope used' do
        let(:context) { project }
        subject { service.allowed_in_project?(permission, project) }
      end

      context 'and the user is not a member of any work package or project' do
        it { is_expected.not_to be_allowed_in_project(permission, project) }

        context 'and the project is public' do
          before { project.update(public: true) }

          context 'when requesting a permission that is not granted to the non-member role' do
            it { is_expected.not_to be_allowed_in_project(permission, project) }
          end

          context 'when requesting a permission that is granted to the non-member role' do
            let(:permission) { :view_news }

            it { is_expected.to be_allowed_in_project(permission, project) }
          end

          context 'when an anonymous user is requesting a permission that is granted to the anonymous role' do
            let(:queried_user) { anonymous_user }
            let(:permission) { :view_meetings }

            it { is_expected.to be_allowed_in_project(permission, project) }
          end
        end
      end

      context 'and the user is a member of a project' do
        let(:role) { create(:project_role, permissions: [permission]) }
        let!(:project_member) { create(:member, user:, project:, roles: [role]) }

        it { is_expected.to be_allowed_in_project(permission, project) }

        context 'with the project being archived' do
          before { project.update(active: false) }

          it { is_expected.not_to be_allowed_in_project(permission, project) }
        end
      end

      context 'and the user is a member of a work package' do
        let(:role) { create(:work_package_role, permissions: [permission]) }
        let!(:wp_member) { create(:work_package_member, user:, project:, entity: work_package, roles: [role]) }

        it { is_expected.not_to be_allowed_in_project(permission, project) }
      end
    end
  end

  describe '#allowed_in_any_project?' do
    context 'when asking for a permission that is not defined' do
      let(:permission) { :not_defined }

      it 'raises an error' do
        expect { subject.allowed_in_any_project?(permission) }.to raise_error(Authorization::UnknownPermissionError)
      end
    end

    context 'when asking for a permission that is defined' do
      let(:permission) { :view_work_packages }

      context 'and the user is not a member of any work package or project' do
        it { is_expected.not_to be_allowed_in_any_project(permission) }

        context 'and the project is public' do
          before { project.update_column(:public, true) }

          context 'and a permission is requested that is not granted to the non-member role' do
            it { is_expected.not_to be_allowed_in_any_project(permission) }
          end

          context 'and a permission is requested that is granted to the non-member role' do
            let(:permission) { :view_news }

            it { is_expected.to be_allowed_in_any_project(permission) }
          end

          context 'and the user is the anonymous user' do
            let(:queried_user) { anonymous_user }
            let(:permission) { :view_meetings }

            it { is_expected.to be_allowed_in_any_project(permission) }
          end

          context 'and the project is archived' do
            before { project.update_column(:active, false) }

            it { is_expected.not_to be_allowed_in_any_project(permission) }
          end
        end
      end

      context 'and the user is a member of a project' do
        let(:role) { create(:project_role, permissions: [permission]) }
        let!(:project_member) { create(:member, user:, project:, roles: [role]) }

        it { is_expected.to be_allowed_in_any_project(permission) }

        context 'and the project is archived' do
          before { project.update_column(:active, false) }

          it { is_expected.not_to be_allowed_in_any_project(permission) }
        end
      end

      context 'and the user is a member of a work package' do
        let(:role) { create(:work_package_role, permissions: [permission]) }
        let!(:wp_member) { create(:work_package_member, user:, project:, entity: work_package, roles: [role]) }

        it { is_expected.not_to be_allowed_in_any_project(permission) }

        context 'and the project is public' do
          before { project.update_column(:public, true) }

          context 'and a permission is requested that is not granted to the non-member role' do
            it { is_expected.not_to be_allowed_in_any_project(permission) }
          end

          context 'and a permission is requested that is granted to the non-member role' do
            let(:permission) { :view_news }

            it { is_expected.to be_allowed_in_any_project(permission) }
          end

          context 'and the project is archived' do
            before { project.update_column(:active, false) }

            it { is_expected.not_to be_allowed_in_any_project(permission) }
          end
        end
      end

      it_behaves_like 'the Project.allowed_to scope used' do
        subject { service.allowed_in_any_project?(permission) }
      end
    end
  end

  describe '#allowed_in_entity?' do
    context 'when asking for a permission that is not defined' do
      let(:permission) { :not_defined }

      it 'raises an error' do
        expect do
          subject.allowed_in_entity?(permission, work_package, WorkPackage)
        end.to raise_error(Authorization::UnknownPermissionError)
      end
    end

    context 'when asking for a permission that is defined' do
      let(:permission) { :view_work_packages }

      context 'and the user is not a member of the project or the work package' do
        it { is_expected.not_to be_allowed_in_entity(permission, work_package, WorkPackage) }
      end

      context 'and the user is a member of the project' do
        let(:role) { create(:project_role, permissions: [permission]) }
        let!(:project_member) { create(:member, user:, project:, roles: [role]) }

        it { is_expected.to be_allowed_in_entity(permission, work_package, WorkPackage) }

        context 'with the project being archived' do
          before { project.update(active: false) }

          it { is_expected.not_to be_allowed_in_entity(permission, work_package, WorkPackage) }
        end

        context 'without the module enabled in the project' do
          before { project.enabled_module_names = project.enabled_modules - [:work_package_tracking] }

          it { is_expected.not_to be_allowed_in_entity(permission, work_package, WorkPackage) }
        end

        it_behaves_like 'the Authorization.roles scope used' do
          let(:context) { project }
          subject { service.allowed_in_entity?(permission, work_package, WorkPackage) }
        end
      end

      context 'and the user is a member of the work package' do
        let(:role) { create(:work_package_role, permissions: [permission]) }
        let!(:wp_member) { create(:work_package_member, user:, project:, entity: work_package, roles: [role]) }

        it { is_expected.to be_allowed_in_entity(permission, work_package, WorkPackage) }

        context 'with the project being archived' do
          before { project.update(active: false) }

          it { is_expected.not_to be_allowed_in_entity(permission, work_package, WorkPackage) }
        end

        it_behaves_like 'the Authorization.roles scope used' do
          let(:context) { work_package }
          subject { service.allowed_in_entity?(permission, work_package, WorkPackage) }
        end
      end

      context 'and user is member in the project (not granting the permission) and the work package (granting the permission)' do
        let(:permission) { :edit_work_packages }

        let(:role) { create(:project_role, permissions: [:view_work_packages]) }
        let!(:project_member) { create(:member, user:, project:, roles: [role]) }

        let(:wp_role) { create(:work_package_role, permissions: [permission]) }
        let!(:wp_member) { create(:work_package_member, user:, project:, entity: work_package, roles: [wp_role]) }

        it { is_expected.to be_allowed_in_entity(permission, work_package, WorkPackage) }

        it_behaves_like 'the Authorization.roles scope used' do
          let(:context) { work_package }
          subject { service.allowed_in_entity?(permission, work_package, WorkPackage) }
        end
      end
    end
  end

  describe '#allowed_in_any_entity?' do
    context 'when asking for a permission that is not defined' do
      let(:permission) { :not_defined }

      it 'raises an error' do
        expect { subject.allowed_in_any_entity?(permission, WorkPackage) }.to raise_error(Authorization::UnknownPermissionError)
      end
    end

    context 'when asking for a permission that is defined' do
      let(:permission) { :view_work_packages }

      context 'and the user is not a member of any work package or project' do
        it { is_expected.not_to be_allowed_in_any_entity(permission, WorkPackage) }
      end

      context 'and the user is a member of a project' do
        let(:role) { create(:project_role, permissions: [permission]) }
        let!(:project_member) { create(:member, user:, project:, roles: [role]) }

        it { is_expected.to be_allowed_in_any_entity(permission, WorkPackage) }

        context 'when specifying the same project' do
          it { is_expected.to be_allowed_in_any_entity(permission, WorkPackage, in_project: project) }
        end

        context 'when specifying a different project' do
          let(:other_project) { create(:project) }

          it { is_expected.not_to be_allowed_in_any_entity(permission, WorkPackage, in_project: other_project) }
        end
      end

      context 'and the user is a member of a work package' do
        let(:role) { create(:work_package_role, permissions: [permission]) }
        let!(:wp_member) { create(:work_package_member, user:, project:, entity: work_package, roles: [role]) }

        it { is_expected.to be_allowed_in_any_entity(permission, WorkPackage) }
      end

      it_behaves_like 'the WorkPackage.allowed_to scope used' do
        subject { service.allowed_in_any_entity?(permission, WorkPackage) }
      end

      it_behaves_like 'the WorkPackage.allowed_to scope used' do
        subject { service.allowed_in_any_entity?(permission, WorkPackage, in_project: project) }
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class Authorization::UserEntityRolesQuery < Authorization::UserRolesQuery
  transformations.register :all, :user_restriction do |statement, user, _|
    statement.where(users_table[:id].eq(user.id))
  end

  transformations.register users_members_join, :entity_restriction do |statement, _, entity|
    statement = statement
      .and(members_table[:entity_type].eq(entity.class.to_s))
      .and(members_table[:entity_id].eq(entity.id))

    statement = statement.and(members_table[:project_id].eq(entity.project_id)) if entity.respond_to?(:project_id)

    statement
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Authorization::UserEntityRolesQuery do
  let(:user) { build(:user) }
  let(:project) { build(:project, public: false) }
  let(:work_package) { build(:work_package, project:) }
  let(:work_package2) { build(:work_package, project:) }
  let(:role) { build(:project_role) }
  let(:wp_role) { build(:work_package_role) }
  let(:other_wp_role) { build(:work_package_role) }
  let(:non_member) { build(:non_member) }
  let(:member) { build(:member, project:, roles: [wp_role], principal: user, entity: work_package) }
  let(:project_member) { build(:member, project:, roles: [role], principal: user) }
  let(:other_member) { build(:member, project:, roles: [other_wp_role], principal: user, entity: work_package2) }

  describe '.query' do
    before do
      non_member.save!
      user.save!
    end

    it 'is a relation' do
      expect(described_class.query(user, work_package)).to be_a ActiveRecord::Relation
    end

    context 'with the user being a member of the work package' do
      before do
        member.save!
      end

      it 'returns the work package role' do
        expect(described_class.query(user, work_package)).to contain_exactly(wp_role)
      end

      context 'when the user also has a membership with a different role on another work package' do
        before do
          other_member.save!
        end

        it 'does not include the second role' do
          expect(described_class.query(user, work_package)).not_to include(other_wp_role)
        end
      end

      context 'when the user also has a membership with a different role on the project' do
        before do
          project_member.save!
        end

        it 'does not include the second role' do
          expect(described_class.query(user, work_package)).not_to include(role)
        end
      end
    end

    context 'without the user being member in the work package' do
      it 'is empty' do
        expect(described_class.query(user, work_package)).to be_empty
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class Authorization::UserAllowedService
  attr_accessor :user

  def initialize(user, role_cache: Users::ProjectRoleCache.new(user))
    self.user = user
    self.project_role_cache = role_cache
  end

  # Return true if the user is allowed to do the specified action on a specific context
  # Action can be:
  # * a parameter-like Hash (eg. { controller: '/projects', action: 'edit' })
  # * a permission Symbol (eg. :edit_project)
  # Context can be:
  # * a project : returns true if user is allowed to do the specified action on this project
  # * a group of projects : returns true if user is allowed on every project
  # * an entity that a user can become a member of specifically (listed in Member::ALLOWED_ENTITIES) :
  #   * returns true if user is allowed to do the specified action on the given item or
  #   * returns ture if user is allowed to do the specified action on the project the entity belongs to
  # * nil with +global+ set to +true+ : check if user has at least one role allowed for this action,
  #   or falls back to Non Member / Anonymous permissions depending if the user is logged
  def call(action, context, global: false)
    if supported_context?(context, global:)
      allowed_to?(action, context, global:)
    else
      false
    end
  end

  def preload_projects_allowed_to(action)
    project_authorization_cache.cache(action)
  end

  private

  attr_accessor :project_role_cache

  def allowed_to?(action, context, global: false)
    action = normalize_action(action)

    if context.nil? && global
      allowed_to_globally?(action)
    elsif context.is_a? Project
      allowed_to_in_project?(action, context)
    elsif supported_entity?(context)
      allowed_to_in_entity?(action, context)
    elsif context.respond_to?(:to_a)
      allowed_to_in_all_projects?(action, context)
    else
      false
    end
  end

  def allowed_to_in_entity?(action, entity)
    # Inactive users are never authorized
    return false unless authorizable_user?

    # Short circuit: When the user is already allowed to execute the action baed
    # on the project, there's no need to do a check on the entity
    return true if entity.respond_to?(:project) && allowed_to_in_project?(action, entity.project)

    # Admin users are authorized for anything else
    # unless the permission is explicitly flagged not to be granted to admins.
    return true if granted_to_admin?(action)

    has_authorized_role?(action, entity)
  end

  def allowed_to_in_project?(action, project)
    return false if project.nil?

    if project_authorization_cache.cached?(action)
      return project_authorization_cache.allowed?(action, project)
    end

    # No action allowed on archived projects
    return false unless project.active? || project.being_archived?
    # No action allowed on disabled modules
    return false unless project.allows_to?(action)
    # Inactive users are never authorized
    return false unless authorizable_user?
    # Admin users are authorized for anything else
    # unless the permission is explicitly flagged not to be granted to admins.
    return true if granted_to_admin?(action)

    has_authorized_role?(action, project)
  end

  # Authorize if user is authorized on every element of the array
  def allowed_to_in_all_projects?(action, projects)
    projects.present? && Array(projects).all? do |project|
      allowed_to?(action, project)
    end
  end

  # Is the user allowed to do the specified action on any project?
  # See allowed_to? for the action parameter description.
  def allowed_to_globally?(action)
    # Inactive users are never authorized
    return false unless authorizable_user?
    # Admin users are always authorized
    return true if granted_to_admin?(action)

    has_authorized_role?(action)
  end

  ##
  # Only users that are not locked may be granted actions
  # with the exception of a temporary-granted system user
  def authorizable_user?
    !user.locked? || user.is_a?(SystemUser)
  end

  # Admin users are granted every permission unless the
  # permission explicitly disables it.
  def granted_to_admin?(action)
    user.admin? && OpenProject::AccessControl.grant_to_admin?(action)
  end

  def has_authorized_role?(action, context = nil)
    project_role_cache
      .fetch(context)
      .any? do |role|
      role.allowed_to?(action)
    end
  end

  def project_authorization_cache
    @project_authorization_cache ||= Users::ProjectAuthorizationCache.new(user)
  end

  def normalize_action(action)
    if action.is_a?(Hash) && action[:controller] && action[:controller].to_s.starts_with?('/')
      action = action.dup
      action[:controller] = action[:controller][1..]
    end

    action
  end

  def supported_context?(context, global:)
    (context.nil? && global) ||
      context.is_a?(Project) ||
      supported_entity?(context) ||
      (!context.nil? && context.respond_to?(:to_a))
  end

  def supported_entity?(entity)
    Member.can_be_member_of?(entity)
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

# TODO: Fix tests here

RSpec.describe Authorization::UserAllowedService do
  let(:user) { build_stubbed(:user) }
  let(:instance) { described_class.new(user) }
  let(:action) { :an_action }
  let(:action_hash) { { controller: '/controller', action: 'action' } }
  let(:project) { build_stubbed(:project) }
  let(:other_project) { build_stubbed(:project) }
  let(:role) { build_stubbed(:project_role) }
  let(:user_roles_in_project) do
    array = [role]
    allow(array)
      .to receive(:eager_load)
      .and_return(array)

    array
  end
  let(:role_grants_action) { true }
  let(:project_allows_to) { true }

  subject { instance.call(action, context) }

  describe '#initialize' do
    it 'has the user' do
      expect(instance.user).to eql user
    end
  end

  shared_examples_for 'allowed to checked' do
    before do
      Array(context).each do |project|
        project.active = true

        allow(project).to receive(:allows_to?).with(action).and_return(project_allows_to)
        allow(Authorization).to receive(:roles).with(user, project).and_return(user_roles_in_project)
      end

      allow(role).to receive(:allowed_to?).with(action).and_return(role_grants_action)
    end

    context 'with the user having a granting role' do
      it 'is true' do
        expect(subject).to be_truthy
      end

      it 'does not call the db twice for a project' do
        Array(context).each do |project|
          allow(Authorization).to receive(:roles).with(user, project).and_return(user_roles_in_project)
        end

        subject
        subject

        Array(context).each do |project|
          expect(Authorization)
            .to have_received(:roles)
            .once
            .with(user, project)
        end
      end

      context 'but the user not being active' do
        before do
          user.lock
        end

        it 'returns false', :aggregate_failures do
          expect(instance.call(action, nil, global: true)).not_to be_truthy
        end
      end
    end

    context 'with the user having a nongranting role' do
      let(:role_grants_action) { false }

      it 'is false' do
        expect(subject).to be_falsey
      end
    end

    context 'with the user being admin
             with the user not having a granting role' do
      let(:user_roles_in_project) { [] }

      before do
        user.admin = true
      end

      it 'is true' do
        expect(subject).to be_truthy
      end
    end

    context 'with the project not being active' do
      before do
        Array(context).each do |project|
          project.active = false
          project.clear_changes_information
        end
      end

      it 'is false' do
        expect(subject).to be_falsey
      end

      it 'is false even if the user is admin' do
        user.admin = true

        expect(subject).to be_falsey
      end
    end

    context 'with the project being archived' do
      before do
        Array(context).each do |project|
          project.active = false
        end
      end

      it 'is true' do
        expect(subject).to be_truthy
      end
    end

    context 'with the project not having the action enabled' do
      let(:project_allows_to) { false }

      it 'is false' do
        expect(subject).to be_falsey
      end

      it 'is false even if the user is admin' do
        user.admin = true

        expect(subject).to be_falsey
      end
    end

    context 'with having precached the results' do
      before do
        auth_cache = double('auth_cache')

        allow(Users::ProjectAuthorizationCache)
          .to receive(:new)
          .and_return(auth_cache)

        allow(auth_cache)
          .to receive(:cache)
          .with(action)

        allow(auth_cache)
          .to receive(:cached?)
          .with(action)
          .and_return(true)

        Array(context).each do |project|
          allow(auth_cache)
            .to receive(:allowed?)
            .with(action, project)
            .and_return(true)
        end

        instance.preload_projects_allowed_to(action)
      end

      it 'is true' do
        expect(subject).to be_truthy
      end

      it 'does not call the db' do
        subject

        expect(Authorization)
          .not_to have_received(:roles)
      end
    end
  end

  describe '#call' do
    context 'for a project' do
      let(:context) { project }

      it_behaves_like 'allowed to checked'
    end

    context 'for an array of projects' do
      let(:context) { [project, other_project] }

      it_behaves_like 'allowed to checked'

      it 'is false' do
        expect(instance.call(action, [])).to be_falsey
      end

      context 'with one project not allowing an action' do
        before do
          allow(project)
            .to receive(:allows_to?)
            .with(action)
            .and_return(false)
        end

        it 'is false' do
          expect(instance.call(action, [project, other_project])).to be_falsey
        end
      end
    end

    context 'for a relation of projects' do
      let(:context) { double('relation', class: ActiveRecord::Relation, to_a: [project]) }

      it_behaves_like 'allowed to checked'
    end

    context 'for anything else' do
      let(:context) { nil }

      it 'is false' do
        expect(subject).to be_falsey
      end
    end

    context 'for a global check' do
      context 'with the user being admin' do
        before do
          user.admin = true
        end

        it 'is true' do
          expect(instance.call(action, nil, global: true)).to be_truthy
        end
      end

      context 'with the user having a granting role' do
        before do
          allow(Authorization).to receive(:roles).with(user, nil).and_return(user_roles_in_project)
          allow(role).to receive(:allowed_to?).with(action).and_return(true)
        end

        context 'but the user not being active' do
          before do
            user.lock
          end

          it 'is unsuccessful', :aggregate_failures do
            expect(instance.call(action, nil, global: true)).not_to be_truthy
          end
        end

        it 'is successful', :aggregate_failures do
          expect(instance.call(action, nil, global: true)).to be_truthy
        end
      end

      context 'with the user not having a granting role' do
        before do
          allow(Authorization).to receive(:roles).with(user, nil).and_return(user_roles_in_project)
          allow(role).to receive(:allowed_to?).with(action).and_return(false)
        end

        it 'is false' do
          expect(instance.call(action, nil, global: true)).to be_falsey
        end
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class Authorization::UserGlobalRolesQuery < Authorization::UserRolesQuery
  transformations.register roles_member_roles_join,
                           :builtin_role do |statement, user|
    builtin_role = if user.logged?
                     Role::BUILTIN_NON_MEMBER
                   else
                     Role::BUILTIN_ANONYMOUS
                   end

    builtin_role_condition = roles_table[:builtin].eq(builtin_role)

    statement.or(builtin_role_condition)
  end

  transformations.register :all, :global_group_where_projection do |statement, user|
    statement.group(roles_table[:id])
             .where(users_table[:id].eq(user.id))
  end

  transformations.register users_members_join, :entity_restriction do |statement, _|
    statement
      .and(members_table[:entity_type].eq(nil))
      .and(members_table[:entity_id].eq(nil))
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Authorization::UserGlobalRolesQuery do
  let(:user) { build(:user) }
  let(:anonymous) { build(:anonymous) }
  let(:project) { build(:project, public: false) }
  let(:project2) { build(:project, public: false) }
  let(:public_project) { build(:project, public: true) }
  let(:role) { build(:project_role) }
  let(:role2) { build(:project_role) }
  let(:anonymous_role) { build(:anonymous_role) }
  let(:non_member) { build(:non_member) }
  let(:member) do
    build(:member, project:,
                   roles: [role],
                   principal: user)
  end
  let(:member2) do
    build(:member, project: project2,
                   roles: [role2],
                   principal: user)
  end
  let(:global_permission) { OpenProject::AccessControl.permissions.find(&:global?) }
  let(:global_role) do
    build(:global_role,
          permissions: [global_permission.name])
  end
  let(:global_member) do
    build(:global_member,
          principal: user,
          roles: [global_role])
  end
  let(:work_package_permission) { [:edit_work_packages] }
  let(:work_package_editor_role) { create(:work_package_role, permissions: work_package_permission) }
  let(:work_package) { create(:work_package, project:) }
  let(:work_package_member) do
    build(:member, entity: work_package, project: work_package.project, roles: [work_package_editor_role], principal: user)
  end

  describe '.query' do
    before do
      non_member.save!
      anonymous_role.save!
      user.save!
    end

    it 'is a user relation' do
      expect(described_class.query(user, project)).to be_a ActiveRecord::Relation
    end

    context 'with the user being a member in a project' do
      before do
        member.save!
      end

      it 'is the member and non member role' do
        expect(described_class.query(user)).to contain_exactly(role, non_member)
      end
    end

    context 'with the user being a member in two projects' do
      before do
        member.save!
        member2.save!
      end

      it 'is both member and the non member role' do
        expect(described_class.query(user)).to contain_exactly(role, role2, non_member)
      end
    end

    context 'without the user being a member in a project' do
      it 'is the non member role' do
        expect(described_class.query(user)).to contain_exactly(non_member)
      end
    end

    context 'with the user being anonymous' do
      it 'is the anonymous role' do
        expect(described_class.query(anonymous)).to contain_exactly(anonymous_role)
      end
    end

    context 'with the user having a global role' do
      before do
        global_member.save!
      end

      it 'is the global role and non member role' do
        expect(described_class.query(user)).to contain_exactly(global_role, non_member)
      end
    end

    context 'with the user having a global role and a member role' do
      before do
        member.save!
        global_member.save!
      end

      it 'is the global role, member role and non member role' do
        expect(described_class.query(user)).to contain_exactly(global_role, role, non_member)
      end
    end

    context 'with the user having a global role, a member role and a work package role' do
      before do
        member.save!
        global_member.save!
        work_package_member.save!
      end

      it 'is the global role, member role and non member role' do
        expect(described_class.query(user)).to contain_exactly(global_role, role, non_member)
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module Authentication
  class OmniauthService
    include Contracted

    attr_accessor :auth_hash,
                  :strategy,
                  :controller,
                  :contract,
                  :user_attributes,
                  :identity_url,
                  :user

    delegate :session, to: :controller

    def initialize(strategy:, auth_hash:, controller:)
      self.strategy = strategy
      self.auth_hash = auth_hash
      self.controller = controller
      self.contract = ::Authentication::OmniauthAuthHashContract.new(auth_hash)
    end

    def call(additional_user_params = nil)
      inspect_response(Logger::DEBUG)

      unless contract.validate
        result = ServiceResult.failure(errors: contract.errors)
        Rails.logger.error do
          ""[OmniAuth strategy #{strategy.name}] Failed to process omniauth response for #{auth_uid}: #{result.message}""
        end
        inspect_response(Logger::ERROR)

        return result
      end

      # Create or update the user from omniauth
      # and assign non-nil parameters from the registration form - if any
      assignable_params = (additional_user_params || {}).reject { |_, v| v.nil? }
      update_user_from_omniauth!(assignable_params)

      # If we have a new or invited user, we still need to register them
      call = activate_user!

      # Update the admin flag when present successful
      call = update_admin_flag(call) if call.success?

      # The user should be logged in now
      tap_service_result call
    end

    private

    ##
    # Inspect the response object, trying to find out what got returned
    def inspect_response(log_level)
      case strategy
      when ::OmniAuth::Strategies::SAML
        ::OpenProject::AuthSaml::Inspector.inspect_response(auth_hash) do |message|
          Rails.logger.add log_level, message
        end
      else
        Rails.logger.add(log_level) do
          ""[OmniAuth strategy #{strategy.name}] Returning from omniauth with hash "" \
            ""#{auth_hash&.to_hash.inspect} Valid? #{auth_hash&.valid?}""
        end
      end
    rescue StandardError => e
      OpenProject.logger.error ""[OmniAuth strategy #{strategy&.name}] Failed to inspect OmniAuth response: #{e.message}""
    end

    ##
    # After login flow
    def tap_service_result(call)
      if call.success? && user.active?
        OpenProject::Hook.call_hook :omniauth_user_authorized, { auth_hash:, controller: }
        # Call deprecated login hook
        OpenProject::OmniAuth::Authorization.after_login! user, auth_hash, self
      end

      call
    end

    ##
    # After validating the omniauth hash
    # and the authorization is successful,
    #
    # login the user by locating or creating it
    def update_user_from_omniauth!(additional_user_params)
      # Find or create the user from the auth hash
      self.user_attributes = build_omniauth_hash_to_user_attributes.merge(additional_user_params)
      self.identity_url = user_attributes[:identity_url]
      self.user = lookup_or_initialize_user

      # Assign or update the user with the omniauth attributes
      update_attributes
    end

    ##
    # Try to find or create the user
    # in the following order:
    #
    # 1. Look for an active invitation token
    # 2. Look for an existing user for the current identity_url
    # 3. Look for an existing user that we can remap (IF remapping is allowed)
    # 4. Try to register a new user and activate according to settings
    def lookup_or_initialize_user
      find_invited_user ||
        find_existing_user ||
        remap_existing_user ||
        initialize_new_user
    end

    ##
    # Return an invited user, if there is a token
    def find_invited_user
      return unless session.include?(:invitation_token)

      tok = Token::Invitation.find_by value: session[:invitation_token]
      return unless tok

      tok.user.tap do |user|
        user.identity_url = user_attributes[:identity_url]
        tok.destroy
        session.delete :invitation_token
      end
    end

    ##
    # Find an existing user by the identity url
    def find_existing_user
      User.find_by(identity_url:)
    end

    ##
    # Allow to map existing users with an Omniauth source if the login
    # already exists, and no existing auth source or omniauth provider is
    # linked
    def remap_existing_user
      return unless Setting.oauth_allow_remapping_of_existing_users?

      User.not_builtin.find_by_login(user_attributes[:login]) # rubocop:disable Rails/DynamicFindBy
    end

    ##
    # Create the new user and try to activate it
    # according to settings and system limits
    def initialize_new_user
      User.new(identity_url: user_attributes[:identity_url])
    end

    ##
    # Update or assign the user attributes
    def update_attributes
      if user.new_record? || user.invited?
        user.register unless user.invited?

        ::Users::SetAttributesService
          .new(user: User.system, model: user, contract_class: ::Users::UpdateContract)
          .call(user_attributes)
      else
        # Update the user, but do not change the admin flag
        # as this call is not validated.
        # we do this separately in +update_admin_flag+
        ::Users::UpdateService
          .new(user: User.system, model: user)
          .call(user_attributes.except(:admin))
      end
    end

    def update_admin_flag(call)
      return call unless user_attributes.key?(:admin)

      new_admin = ActiveRecord::Type::Boolean.new.cast(user_attributes[:admin])
      return call if user.admin == new_admin

      ::Users::UpdateService
        .new(user: User.system, model: user)
        .call(admin: new_admin)
        .on_failure { |res| update_admin_flag_failure(res) }
        .on_success { update_admin_flag_success(new_admin) }
    end

    def update_admin_flag_success(new_admin)
      if new_admin
        OpenProject.logger.info { ""[OmniAuth strategy #{strategy.name}] Granted user##{update.result.id} admin permissions"" }
      else
        OpenProject.logger.info { ""[OmniAuth strategy #{strategy.name}] Revoked user##{update.result.id} admin permissions"" }
      end
    end

    def update_admin_flag_failure(call)
      OpenProject.logger.error do
        ""[OmniAuth strategy #{strategy.name}] Failed to update admin user permissions: #{call.message}""
      end
    end

    def activate_user!
      if activatable?
        ::Users::RegisterUserService
          .new(user)
          .call
      else
        ServiceResult.success(result: user)
      end
    end

    ##
    # Determines if the given user is activatable on the fly, that is:
    #
    # 1. The user has just been initialized by us
    # 2. The user has been invited
    # 3. The user had been registered manually (e.g., through a previous self-registration setting)
    def activatable?
      user.new_record? || user.invited? || user.registered?
    end

    ##
    # Maps the omniauth attribute hash
    # to our internal user attributes
    def build_omniauth_hash_to_user_attributes
      info = auth_hash[:info]

      attribute_map = {
        login: info[:login] || info[:email],
        mail: info[:email],
        firstname: info[:first_name] || info[:name],
        lastname: info[:last_name],
        identity_url: identity_url_from_omniauth,
      }

      # Map the admin attribute if provided in an attribute mapping
      attribute_map[:admin] = ActiveRecord::Type::Boolean.new.cast(info[:admin]) if info.key?(:admin)

      # Allow strategies to override mapping
      if strategy.respond_to?(:omniauth_hash_to_user_attributes)
        attribute_map.merge!(strategy.omniauth_hash_to_user_attributes(auth_hash))
      end

      # Remove any nil values to avoid
      # overriding existing attributes
      attribute_map.reject! { |_, value| value.nil? || value == '' }

      Rails.logger.debug { ""Mapped auth_hash user attributes #{attribute_map.inspect}"" }
      attribute_map
    end

    ##
    # Allow strategies to map a value for uid instead
    # of always taking the global UID.
    # For SAML, the global UID may change with every session
    # (in case of transient nameIds)
    def identity_url_from_omniauth
      identifier = auth_hash[:info][:uid] || auth_hash[:uid]
      ""#{auth_hash[:provider]}:#{identifier}""
    end

    ##
    # Try to provide some context of the auth_hash in case of errors
    def auth_uid
      hash = (auth_hash || {})
      hash.dig(:info, :uid) || hash.dig(:uid) || 'unknown'
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.

require 'spec_helper'

RSpec.describe Authentication::OmniauthService do
  let(:strategy) { double('Omniauth Strategy', name: 'saml') }
  let(:additional_info) do
    {}
  end
  let(:auth_hash) do
    OmniAuth::AuthHash.new(
      provider: 'google',
      uid: '123545',
      info: {
        name: 'foo',
        email: auth_email,
        first_name: 'foo',
        last_name: 'bar'
      }.merge(additional_info)
    )
  end
  let(:auth_email) { 'foo@bar.com' }
  let(:controller) { double('Controller', session: session_stub) }
  let(:session_stub) { [] }

  let(:instance) { described_class.new(strategy:, auth_hash:, controller:) }
  let(:user_attributes) { instance.send :build_omniauth_hash_to_user_attributes }

  describe '#contract' do
    before do
      allow(instance.contract)
        .to(receive(:validate))
        .and_return(valid)
    end

    context 'if valid' do
      let(:valid) { true }

      it 'calls the registration service' do
        expect(Users::RegisterUserService)
          .to(receive(:new))
          .with(kind_of(User))
          .and_call_original

        instance.call
      end
    end

    context 'if invalid' do
      let(:valid) { false }

      it 'does not call the registration service' do
        expect(Users::RegisterUserService)
          .not_to(receive(:new))

        expect(instance.contract)
          .to(receive(:errors))
          .and_return(['foo'])

        call = instance.call
        expect(call).to be_failure
        expect(call.errors).to eq ['foo']
      end
    end
  end

  describe 'activation of users' do
    let(:call) { instance.call }

    context 'with an active found user' do
      shared_let(:user) { create(:user, login: 'foo@bar.com', identity_url: 'google:123545') }

      it 'does not call register user service and logs in the user' do
        allow(Users::RegisterUserService).to receive(:new)

        expect(OpenProject::OmniAuth::Authorization)
          .to(receive(:after_login!))
          .with(user, auth_hash, instance)

        expect(call).to be_success
        expect(call.result).to eq user
        expect(call.result.firstname).to eq 'foo'
        expect(call.result.lastname).to eq 'bar'
        expect(call.result.mail).to eq 'foo@bar.com'

        expect(Users::RegisterUserService).not_to have_received(:new)
      end

      context 'if the user is to become admin' do
        let(:additional_info) { { admin: true } }

        it 'updates the user' do
          expect(user).not_to be_admin
          expect(call).to be_success
          expect(call.result).to eq user
          expect(call.result).to be_admin
        end

        context 'if the user cannot be updated for some reason' do
          let(:stub) { instance_double(Users::UpdateService) }

          it 'fails the request' do
            allow(Users::UpdateService).to receive(:new).and_return(stub)
            allow(stub).to receive(:call).and_return(ServiceResult.failure(message: 'Oh noes!'))

            expect(call).not_to be_success
            expect(call.result).to be_nil
            expect(user.reload).not_to be_admin
          end
        end
      end

      context 'if the user is the last admin and is about to be revoked' do
        let(:additional_info) { { admin: false } }

        it 'does not revoke admin status' do
          user.update!(admin: true)
          expect(user).to be_admin

          expect(call).not_to be_success
          expect(call.result).to eq user
          expect(user.reload).to be_admin
          expect(call.errors.details[:base]).to contain_exactly({ error: :one_must_be_active })
        end
      end

      context 'if the user is not the last admin and is about to be revoked' do
        let!(:other_admin) { create(:admin) }
        let(:additional_info) { { admin: false } }

        it 'revokes admin status' do
          user.update!(admin: true)
          expect(user).to be_admin

          expect(call).to be_success
          expect(call.result).to eq user
          expect(user.reload).not_to be_admin
        end
      end
    end

    context 'without remapping allowed',
            with_settings: { oauth_allow_remapping_of_existing_users?: false } do
      let!(:user) { create(:user, login: 'foo@bar.com') }

      it 'does not look for the user by login' do
        allow(Users::RegisterUserService).to receive(:new).and_call_original

        expect(call).not_to be_success
        expect(call.result.firstname).to eq 'foo'
        expect(call.result.lastname).to eq 'bar'
        expect(call.result.mail).to eq 'foo@bar.com'
        expect(call.result).not_to eq user
        expect(call.result).to be_new_record
        expect(call.result.errors[:login]).to eq ['has already been taken.']

        expect(Users::RegisterUserService).to have_received(:new)
      end
    end

    context 'with an active user remapped',
            with_settings: { oauth_allow_remapping_of_existing_users?: true } do
      let!(:user) { create(:user, identity_url: 'foo', login: auth_email.downcase) }

      shared_examples_for 'a successful remapping of foo' do
        before do
          allow(Users::RegisterUserService).to receive(:new)
          allow(OpenProject::OmniAuth::Authorization)
            .to(receive(:after_login!))
            .with(user, auth_hash, instance)
        end

        it 'does not call register user service and logs in the user' do
          aggregate_failures 'Service call' do
            expect(call).to be_success
            expect(call.result).to eq user
            expect(call.result.firstname).to eq 'foo'
            expect(call.result.lastname).to eq 'bar'
            expect(call.result.login).to eq auth_email
            expect(call.result.mail).to eq auth_email
          end

          user.reload

          aggregate_failures 'User attributes' do
            expect(user.firstname).to eq 'foo'
            expect(user.lastname).to eq 'bar'
            expect(user.identity_url).to eq 'google:123545'
          end

          aggregate_failures 'Message expectations' do
            expect(OpenProject::OmniAuth::Authorization)
              .to(have_received(:after_login!))

            expect(Users::RegisterUserService).not_to have_received(:new)
          end
        end
      end

      context 'with an all lower case login on the IdP side' do
        it_behaves_like 'a successful remapping of foo'
      end

      context 'with a partially upper case login on the IdP side' do
        let(:auth_email) { 'FoO@Bar.COM' }

        it_behaves_like 'a successful remapping of foo'
      end
    end

    describe 'assuming registration/activation worked' do
      let(:register_call) { ServiceResult.new(success: register_success, message: register_message) }
      let(:register_success) { true }
      let(:register_message) { 'It worked!' }

      before do
        expect(Users::RegisterUserService).to receive_message_chain(:new, :call).and_return(register_call)
      end

      describe 'with a new user' do
        it 'calls the register service' do
          expect(call).to be_success

          # The user might get activated in the register service
          expect(instance.user).not_to be_active
          expect(instance.user).to be_new_record

          # Expect notifications to be present (Regression #38066)
          expect(instance.user.notification_settings).not_to be_empty
        end
      end
    end

    describe 'assuming registration/activation failed' do
      let(:register_success) { false }
      let(:register_message) { 'Oh noes :(' }
    end
  end

  describe '#identity_url_from_omniauth' do
    let(:auth_hash) { { provider: 'developer', uid: 'veryuniqueid', info: {} } }

    subject { instance.send(:identity_url_from_omniauth) }

    it 'returns the correct identity_url' do
      expect(subject).to eql('developer:veryuniqueid')
    end

    context 'with uid mapped from info' do
      let(:auth_hash) { { provider: 'developer', uid: 'veryuniqueid', info: { uid: 'internal' } } }

      it 'returns the correct identity_url' do
        expect(subject).to eql('developer:internal')
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module Backups
  class CreateService < ::BaseServices::Create
    def initialize(user:, backup_token:, include_attachments: true, contract_class: ::Backups::CreateContract)
      super user:, contract_class:, contract_options: { backup_token: }

      @include_attachments = include_attachments
    end

    def include_attachments?
      @include_attachments
    end

    def after_perform(call)
      if call.success?
        BackupJob.perform_later(
          backup: call.result,
          user:,
          include_attachments: include_attachments?
        )
      end

      call
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'
require 'services/base_services/behaves_like_create_service'

RSpec.describe Backups::CreateService, type: :model do
  let(:user) { create(:admin) }
  let(:service) { described_class.new user:, backup_token: backup_token.plain_value }
  let(:backup_token) { create(:backup_token, user:) }

  it_behaves_like 'BaseServices create service' do
    let(:instance) { service }
    let(:backup_token) { build_stubbed(:backup_token, user:) }
    let(:contract_options) { { backup_token: backup_token.plain_value } }
  end

  context ""with right permissions"" do
    context ""with no further options"" do
      it ""enqueues a BackupJob which includes attachments"" do
        expect { service.call }.to have_enqueued_job(BackupJob).with do |args|
          expect(args[""include_attachments""]).to be true
        end
      end
    end

    context ""with include_attachments: false"" do
      let(:service) do
        described_class.new user:, backup_token: backup_token.plain_value, include_attachments: false
      end

      it ""enqueues a BackupJob which does not include attachments"" do
        expect(BackupJob)
          .to receive(:perform_later)
          .with(hash_including(include_attachments: false, user:))

        expect(service.call).to be_success
      end
    end
  end

  context ""with missing permission"" do
    let(:user) { create(:user) }

    it ""does not enqueue a BackupJob"" do
      expect { expect(service.call).to be_failure }.not_to have_enqueued_job(BackupJob)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module Notifications
  class SetAttributesService < ::BaseServices::SetAttributes
    private

    def set_default_attributes(params)
      super

      set_default_project unless model.project
    end

    ##
    # Try to determine the project context from the journal (if any)
    # or the resource if it has a project set
    def set_default_project
      model.project = model.journal&.project || model.resource.try(:project)
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Notifications::SetAttributesService, type: :model do
  let(:user) { build_stubbed(:user) }
  let(:contract_class) do
    contract = double('contract_class')

    allow(contract)
      .to receive(:new)
            .with(event, user, options: {})
            .and_return(contract_instance)

    contract
  end
  let(:contract_instance) do
    double('contract_instance', validate: contract_valid, errors: contract_errors)
  end
  let(:contract_valid) { true }
  let(:contract_errors) do
    double('contract_errors')
  end
  let(:member_valid) { true }
  let(:instance) do
    described_class.new(user:,
                        model: event,
                        contract_class:)
  end
  let(:call_attributes) { {} }
  let(:project) { build_stubbed(:project) }
  let(:reason) { :mentioned }
  let(:journal) { build_stubbed(:journal, journable:, data: journal_data) }
  let(:journable) { nil }
  let(:journal_data) { nil }
  let(:event_subject) { 'I find it important' }
  let(:recipient_id) { 1 }

  describe 'call' do
    let(:call_attributes) do
      {
        recipient_id:,
        reason:,
        resource: journable,
        journal:,
        subject: event_subject,
        project:
      }
    end

    subject { instance.call(call_attributes) }

    context 'for a new record' do
      let(:event) do
        Notification.new
      end

      it 'is successful' do
        expect(subject)
        .to be_success
      end

      it 'sets the attributes add adds default values' do
        subject

        expect(event.attributes.compact.symbolize_keys)
          .to eql({
                    project_id: project.id,
                    reason: 'mentioned',
                    journal_id: journal.id,
                    recipient_id: 1,
                    subject: event_subject,
                    read_ian: false,
                    mail_reminder_sent: false
                  })
      end

      context 'with only the minimal set of attributes for a notification' do
        let(:journable) do
          build_stubbed(:work_package, project:).tap do |wp|
            allow(wp)
              .to receive(:to_s)
              .and_return(""wp to s"")
          end
        end
        let(:journal_data) do
          build_stubbed(:journal_work_package_journal, project:)
        end
        let(:call_attributes) do
          {
            recipient_id:,
            reason:,
            journal:,
            resource: journable
          }
        end

        it 'sets the attributes and adds default values that are deduced' do
          subject

          expect(event.attributes.compact.symbolize_keys)
            .to eql({
                      project_id: project.id,
                      reason: 'mentioned',
                      resource_id: journable.id,
                      resource_type: 'WorkPackage',
                      journal_id: journal.id,
                      recipient_id: 1,
                      read_ian: false,
                      mail_reminder_sent: false
                    })
        end
      end

      it 'does not persist the notification' do
        expect(event)
          .not_to receive(:save)

        subject
      end
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

module Notifications
  class MailService
    include WithMarkedNotifications

    def initialize(notification)
      self.notification = notification
    end

    def call
      return unless supported?
      return if ian_read?

      with_marked_notifications(notification.id) do
        strategy.send_mail(notification)
      end
    end

    private

    attr_accessor :notification

    def ian_read?
      notification.read_ian
    end

    def strategy
      @strategy ||= if self.class.const_defined?(""#{strategy_model}Strategy"")
                      ""#{self.class}::#{strategy_model}Strategy"".constantize
                    end
    end

    def strategy_model
      journal&.journable_type || resource&.class
    end

    def journal
      notification.journal
    end

    def resource
      notification.resource
    end

    def supported?
      strategy.present?
    end

    def notification_marked_attribute
      :mail_alert_sent
    end
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'

RSpec.describe Notifications::MailService, type: :model do
  require_relative './mentioned_journals_shared'

  subject(:call) { instance.call }

  let(:recipient) do
    build_stubbed(:user,
                  preference: build_stubbed(:user_preference,
                                            settings: {
                                              immediate_reminders: {
                                                mentioned: immediate_reminders_mentioned
                                              }
                                            }))
  end
  let(:actor) do
    build_stubbed(:user)
  end
  let(:instance) { described_class.new(notification) }
  let(:immediate_reminders_mentioned) { true }

  context 'with a work package journal notification' do
    let(:journal) do
      build_stubbed(:work_package_journal).tap do |j|
        allow(j)
          .to receive(:initial?)
                .and_return(journal_initial)
      end
    end
    let(:read_ian) { false }
    let(:reason) { :mentioned }
    let(:notification) do
      build_stubbed(:notification,
                    journal:,
                    recipient:,
                    actor:,
                    reason:,
                    read_ian:)
    end
    let(:journal_initial) { false }

    let(:mail) do
      mail = instance_double(ActionMailer::MessageDelivery)

      allow(WorkPackageMailer)
        .to receive(:mentioned)
              .and_return(mail)

      allow(mail)
        .to receive(:deliver_later)

      mail
    end

    before do
      mail
    end

    shared_examples_for 'sends a mentioned mail' do
      it 'sends a mail' do
        call

        expect(WorkPackageMailer)
          .to have_received(:mentioned)
                .with(recipient,
                      journal)

        expect(mail)
          .to have_received(:deliver_later)
      end
    end

    shared_examples_for 'sends no mentioned mail' do
      it 'sends no mail' do
        call

        expect(WorkPackageMailer)
          .not_to have_received(:mentioned)
      end
    end

    context 'with the notification mentioning the user' do
      it_behaves_like 'sends a mentioned mail'
    end

    context 'with the notification not mentioning the user' do
      let(:reason) { false }

      it_behaves_like 'sends no mentioned mail'
    end

    context 'with the notification mentioning the user but with the recipient having deactivated the mail' do
      let(:immediate_reminders_mentioned) { false }

      it_behaves_like 'sends no mentioned mail'
    end
  end

  context 'with a wiki_content journal notification' do
    let(:journal) do
      build_stubbed(:wiki_page_journal,
                    journable: build_stubbed(:wiki_page)).tap do |j|
        allow(j)
          .to receive(:initial?)
                .and_return(journal_initial)
      end
    end
    let(:read_ian) { false }
    let(:notification) do
      build_stubbed(:notification,
                    journal:,
                    recipient:,
                    actor:,
                    read_ian:)
    end
    let(:mail) do
      mail = instance_double(ActionMailer::MessageDelivery)

      allow(UserMailer)
        .to receive(:wiki_page_added)
              .and_return(mail)

      allow(UserMailer)
        .to receive(:wiki_page_updated)
              .and_return(mail)

      allow(mail)
        .to receive(:deliver_now)

      mail
    end
    let(:journal_initial) { false }

    before do
      mail
    end

    context 'with the notification being for an initial journal' do
      let(:journal_initial) { true }

      it 'sends a mail' do
        call

        expect(UserMailer)
          .to have_received(:wiki_page_added)
                .with(recipient,
                      journal.journable)

        expect(mail)
          .to have_received(:deliver_now)
      end
    end

    context 'with the notification being for an update journal' do
      let(:journal_initial) { false }

      it 'sends a mail' do
        call

        expect(UserMailer)
          .to have_received(:wiki_page_updated)
                .with(recipient,
                      journal.journable)

        expect(mail)
          .to have_received(:deliver_now)
      end
    end

    context 'with the notification read in app already' do
      let(:read_ian) { true }

      it 'sends no mail' do
        call

        expect(UserMailer)
          .not_to have_received(:wiki_page_added)
        expect(UserMailer)
          .not_to have_received(:wiki_page_updated)
      end
    end
  end

  context 'with a news journal notification' do
    let(:journal) do
      build_stubbed(:news_journal,
                    journable: build_stubbed(:news)).tap do |j|
        allow(j)
          .to receive(:initial?)
                .and_return(journal_initial)
      end
    end
    let(:notification) do
      build_stubbed(:notification,
                    journal:,
                    recipient:,
                    actor:)
    end
    let(:mail) do
      mail = instance_double(ActionMailer::MessageDelivery)

      allow(UserMailer)
        .to receive(:news_added)
              .and_return(mail)

      allow(mail)
        .to receive(:deliver_now)

      mail
    end
    let(:journal_initial) { false }

    before do
      mail
    end

    context 'with the notification being for an initial journal' do
      let(:journal_initial) { true }

      it 'sends a mail' do
        call

        expect(UserMailer)
          .to have_received(:news_added)
                .with(recipient,
                      journal.journable)

        expect(mail)
          .to have_received(:deliver_now)
      end
    end

    # This case should not happen as no notification is created in this case that would
    # trigger the NotificationJob. But as this might change, this test case is in place.
    context 'with the notification being for an update journal' do
      let(:journal_initial) { false }

      it 'sends no mail' do
        call

        expect(UserMailer)
          .not_to have_received(:news_added)
      end
    end
  end

  context 'with a message journal notification' do
    let(:journal) do
      build_stubbed(:message_journal,
                    journable: build_stubbed(:message))
    end
    let(:read_ian) { false }
    let(:notification) do
      build_stubbed(:notification,
                    journal:,
                    resource: journal.journable,
                    recipient:,
                    actor:,
                    read_ian:)
    end
    let(:mail) do
      mail = instance_double(ActionMailer::MessageDelivery)

      allow(UserMailer)
        .to receive(:message_posted)
              .and_return(mail)

      allow(mail)
        .to receive(:deliver_now)

      mail
    end

    before do
      mail
    end

    it 'sends a mail' do
      call

      expect(UserMailer)
        .to have_received(:message_posted)
              .with(recipient,
                    journal.journable)

      expect(mail)
        .to have_received(:deliver_now)
    end

    context 'with the notification read in app already' do
      let(:read_ian) { true }

      it 'sends no mail' do
        call

        expect(UserMailer)
          .not_to have_received(:message_posted)
      end
    end
  end

  context 'with a different journal notification' do
    let(:journal) do
      build_stubbed(:journal,
                    journable: build_stubbed(:work_package))
    end
    let(:notification) do
      build_stubbed(:notification,
                    journal:,
                    recipient:,
                    actor:)
    end

    # did that before
    it 'does nothing' do
      expect { call }
        .not_to raise_error(ArgumentError)
    end

    it 'does not send a mail' do
      expect { call }
        .not_to change(ActionMailer::Base.deliveries, :count)
    end
  end
end
"
"Write RSpec test file for following ruby class
```ruby
#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

class Notifications::CreateService < BaseServices::Create
  protected

  def persist(service_result)
    super
  rescue ActiveRecord::InvalidForeignKey
    service_result.success = false
    service_result.errors.add(:journal_id, :does_not_exist)
    service_result
  end
end

```","#-- copyright
# OpenProject is an open source project management software.
# Copyright (C) 2012-2023 the OpenProject GmbH
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License version 3.
#
# OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
# Copyright (C) 2006-2013 Jean-Philippe Lang
# Copyright (C) 2010-2013 the ChiliProject Team
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#
# See COPYRIGHT and LICENSE files for more details.
#++

require 'spec_helper'
require 'services/base_services/behaves_like_create_service'

RSpec.describe Notifications::CreateService, type: :model do
  it_behaves_like 'BaseServices create service'
end
"
"In the context of a Ruby programming project, there is a module named 'Dictionary'. This module is defined to have a class method called `table_name_prefix`. The purpose of this module seems to be to provide a prefix for database table names related to the Dictionary. In simpler terms, it's used in the Rails environment where Active Record automatically appends the name of the model to tables (i.e., ""dictionary_users"" rather than just ""users"") if the class method `table_name_prefix` is defined in a module named 'Dictionary'.
","module Dictionary
  def self.table_name_prefix
    'dictionary_'
  end
end
"
"In the context of this Ruby code, a standalone instruction would be:

""The Lock class represents a lock object for {CloudUser} and {Application}s that it owns. It has three read-only attributes `apps`, `user`, and `locked` representing the list of applications locked, the owner user, and whether the user is locked respectively. The class also includes Mongoid::Document which allows interaction with a MongoDB database.

The Lock class has two methods for creating or deleting locks on users: `create_lock(user)` and `delete_lock(user)`.

There are two other methods, `lock_user(user, app, timeout=1800)` and `unlock_user(user, app)` that attempt to lock or unlock a user respectively. These methods also check for existing locks on the same application owned by the same user before proceeding with the operation.

There are two additional methods, `lock_application(application, timeout=1800)` and `unlock_application(application)`, that attempt to lock or unlock an application respectively. These methods also retrieve the owner of the application from its domain before attempting to lock or unlock it.""

Please note: The actual implementation details might be too complex for a standalone instruction as they involve Mongoid::Document interaction with a MongoDB database and object-oriented concepts in Ruby. However, this brief explanation should provide an understanding of what the code does.
","# Represents a lock object for a {CloudUser} and {Application}s that it owns
# @!attribute [r] apps
#   @return List of {Application}s that are locked
# @!attribute [r] user
#   @return {CloudUser} owner of the lock
# @!attribute [r] locked
#   @return [Boolean] representing if the user is locked
class Lock
  include Mongoid::Document

  belongs_to :user, class_name: CloudUser.name
  field :locked, type: Boolean, default: false
  field :timeout, type: Integer, default: 0
  field :app_ids, type: Hash, default: {}

  index({:user_id => 1})
  create_indexes

  # Attempts to lock the {CloudUser}. Once locked, no other threads can obtain a lock on the {CloudUser} or any owned {Application}s.
  # This lock is denied if any of the {Application}s owned by the {CloudUser} are currently locked.
  #
  # == Parameters:
  # user::
  #   The {CloudUser} to attempt to lock
  #
  # == Returns:
  # True if the lock was successful.

  def self.create_lock(user)
    lock = Lock.find_or_create_by( :user_id => user._id )
  end

  def self.delete_lock(user)
    lock = Lock.delete( :user_id => user._id )
  end

  # Attempts to lock the {CloudUser}.
  # NOTE: User lock is available only for user apps with application lock.
  def self.lock_user(user, app, timeout=1800)
    begin
      now = Time.now.to_i
      lock = Lock.find_or_create_by( :user_id => user._id )
      query = {:user_id => user._id, ""$or"" => [{:locked => false}, {:timeout.lt => now}], ""app_ids.#{app._id}"" => { ""$exists"" => true }}
      updates = {""$set"" => { locked: true, timeout: (now + timeout) }}
      lock = Lock.where(query).find_and_modify(updates, new: true)
      return (not lock.nil?)
    rescue Moped::Errors::OperationFailure
      return false
    end
  end

  # Attempts to unlock the {CloudUser}.
  #
  # == Parameters:
  # user::
  #   The {CloudUser} to attempt to unlock
  #
  # == Returns:
  # True if the unlock was successful.
  def self.unlock_user(user, app)
    begin
      query = {:user_id => user._id, :locked => true, ""app_ids.#{app._id}"" => { ""$exists"" => true }}
      updates = {""$set"" => { ""locked"" => false }}
      lock = Lock.where(query).find_and_modify(updates, new: true)
      return (not lock.nil?)
    rescue Moped::Errors::OperationFailure
      return false
    end
  end

  # Attempts to lock an {Application}. Once locked, no other threads can obtain a lock on the {Application} or the {CloudUser} that owns it.
  # This lock is denied if the owning {CloudUser} is locked or the {Application} has been locked by another thread.
  #
  # == Parameters:
  # application::
  #   The {Application} to attempt to lock
  #
  # == Returns:
  # True if the lock was successful.
  def self.lock_application(application, timeout=1800)
    begin
      # application.domain can be nil if the application is being created immediately after domain creation
      # If the domain is being read from the secondary, it may not be present
      # If domain is nil, try to load the domain from the primary
      # Note: If there is a way to load the domain relationship from the primary, we should do that
      if application.domain.nil?
        user_id = Domain.find_by(_id: application.domain_id).owner_id
      else
        user_id = application.domain.owner_id
      end

      app_id = application._id.to_s
      now = Time.now.to_i
      query = { :user_id => user_id, ""$or"" => [{""app_ids.#{app_id}"" => {""$exists"" => false}}, {""app_ids.#{app_id}"" => {""$lt"" => now}}] }
      updates = {""$set""=> { ""app_ids.#{app_id}"" => (now + timeout) }}
      lock = Lock.where(query).find_and_modify(updates, new: true)
      return (not lock.nil?)
    rescue Moped::Errors::OperationFailure => ex
      Rails.logger.error ""Failed to obtain lock for application #{application.name}: #{ex.message}""
      return false
    end
  end

  # Attempts to unlock an {Application}.
  #
  # == Parameters:
  # application::
  #   The {Application} to attempt to unlock
  #
  # == Returns:
  # True if the unlock was successful.
  def self.unlock_application(application)
    begin
      # application.domain can be nil if the application is being created immediately after domain creation
      # If the domain is being read from the secondary, it may not be present
      # If domain is nil, try to load the domain from the primary
      # Note: If there is a way to load the domain relationship from the primary, we should do that
      if application.domain.nil?
        user_id = Domain.find_by(_id: application.domain_id).owner_id
      else
        user_id = application.domain.owner_id
      end

      app_id = application._id.to_s
      query = {:user_id => user_id, ""app_ids.#{app_id}"" => { ""$exists"" => true }}
      updates = {""$unset""=> {""app_ids.#{app_id}"" => """"}}
      lock = Lock.where(query).find_and_modify(updates, new: true)
      return (not lock.nil?)
    rescue Moped::Errors::OperationFailure => ex
      Rails.logger.error ""Failed to unlock application #{application.name}: #{ex.message}""
      return false
    end
  end
end
"
"In the context of this Ruby code snippet, we have a formula for Homebrew (a package manager for macOS) which is called 'Lean'. This formula is written in Ruby and it's designed to install Lean theorem prover on your Mac.

The tool, Lean, is a dependently typed programming language which supports constructing mathematics at the type level, and is especially suited for formalizing mathematical concepts along with their proofs (a form of computer proof). This formula was developed by contributors to the community around homepage 'https://leanprover-community.github.io/'.

The code snippet begins defining a Ruby class called `Lean`, which inherits from `Formula` provided by Homebrew. The class is designed to manage Lean's installation and upgrade process on your machine.

Here are some of the key attributes and methods used:
- desc ""Theorem prover"": This describes the purpose of this formula i.e., it is a theorem prover tool.
- homepage URL: It points to the official website of Lean where you can find more information about it.
- url ""https://github.com/leanprover-community/lean/archive/v3.42.1.tar.gz"": This is a link leading to the source code archive for version 3.42.1 of Lean.
- sha256: It is a SHA256 hash value generated from the source code archive, ensuring its integrity.
- license ""Apache-2.0"": This identifies the software's license as Apache 2.0.
- livecheck do...end: Lean formula uses 'livecheck' to check if there are any new versions of Lean available and updates them automatically.
- bottle do...end: It defines precompiled binaries for various platforms, making installation faster.
- depends_on ""cmake"" => :build, ...: This snippet lists all the dependencies that must be installed before Lean can run on your machine, including 'cmake' and others.
- conflicts_with...end: It ensures that there is no conflict between this formula and another called 'elan-init'.
- def install: The Ruby method for defining how to install the software package. Here it builds Lean from source code using CMake and installs it into Homebrew's prefix location by invoking a series of commands via system calls.
- test do...end: It provides an example of running some tests on this formula, proving that it correctly installed Lean.

Please note the Ruby syntax is used in this context. You should be familiar with Ruby to understand its usage within this context.
","class Lean < Formula
  desc ""Theorem prover""
  homepage ""https://leanprover-community.github.io/""
  url ""https://github.com/leanprover-community/lean/archive/v3.42.1.tar.gz""
  sha256 ""5b8cbfdea6cf4de5488467297958876aa0b3a79ed5806f7d0f01a0c396beb4e2""
  license ""Apache-2.0""
  head ""https://github.com/leanprover-community/lean.git"", branch: ""master""

  livecheck do
    url :stable
    regex(/^v?(\d+(?:\.\d+)+)$/i)
    strategy :git do |tags, regex|
      tags.map do |tag|
        version = tag[regex, 1]
        next if version == ""9.9.9"" # Omit a problematic version tag

        version
      end
    end
  end

  bottle do
    sha256 cellar: :any,                 arm64_monterey: ""58337f99ae7f334d298267e4f0153334d408a72d7640aeb7834d6fc8499ed0ca""
    sha256 cellar: :any,                 arm64_big_sur:  ""d8dfeaf7e902829013d0109938b910061349a2d16394e48c714a3a1f4b312717""
    sha256 cellar: :any,                 monterey:       ""1e14e749b7b08576bc0dd91f6f6fec6ab97c1c32d79f22a69c5a6b4b41330f95""
    sha256 cellar: :any,                 big_sur:        ""d623ba837328fe54810386ce2385aef9d147784bdf71c43fb749e09bf68546a0""
    sha256 cellar: :any,                 catalina:       ""e16cb80f3a05541ac1d981ff75a6ade15a601931ed8dfa606076ff2b06ac67a9""
    sha256 cellar: :any_skip_relocation, x86_64_linux:   ""4d8d848d08308e6301a5eb4ae8bf6f7155a0936df27270c6a82ba699737c3cca""
  end

  depends_on ""cmake"" => :build
  depends_on ""coreutils""
  depends_on ""gmp""
  depends_on ""jemalloc""
  depends_on macos: :mojave

  on_linux do
    depends_on ""gcc""
  end

  conflicts_with ""elan-init"", because: ""`lean` and `elan-init` install the same binaries""

  fails_with gcc: ""5""

  def install
    args = std_cmake_args + %w[
      -DCMAKE_CXX_FLAGS='-std=c++14'
    ]

    system ""cmake"", ""-S"", ""src"", ""-B"", ""src/build"", *args
    system ""cmake"", ""--build"", ""src/build""
    system ""cmake"", ""--install"", ""src/build""
  end

  test do
    (testpath/""hello.lean"").write <<~EOS
      def id' {α : Type} (x : α) : α := x

      inductive tree (α : Type) : Type
      | node : α → list tree → tree

      example (a b : Prop) : a ∧ b -> b ∧ a :=
      begin
          intro h, cases h,
          split, repeat { assumption }
      end
    EOS
    system bin/""lean"", testpath/""hello.lean""
    system bin/""leanpkg"", ""help""
  end
end
"
"In the context of a Ruby on Rails project, there is a class named `ProjectFeature` that manages permissions for various features related to projects. This class has several properties and methods related to access levels, validation rules, default values, and feature availability based on user roles.

One important property in this class is the constant array 'FEATURES', which includes :issues, :merge_requests, :wiki, :snippets, :builds, :repository, and :pages. This lists all possible features that a project can have.

The `access_level` method returns the access level for a specified feature based on its associated attribute. For example, if we call `project.feature.access_level(:issues)`, it will return the current access level of issues for this project.

There are several validation methods that check the validity of these access levels against each other and repository-wide settings. One method is 'repository_children_level' which checks whether a feature’s visibility level isn’t higher than the repository’s visibility level.

The class also has `default_value_for` methods for setting default values for all features, except :pages. The access levels are set to ENABLED by default and `nil` is not allowed. This ensures that each feature will have a defined access level when initialized.

A method named 'feature_available?' checks if a certain feature is available to a given user based on their role in the project. It firstly, checks whether this feature is enabled for this particular user by checking the Feature flag. Then it verifies the user's permissions with `get_permission` helper function using the provided access level of that feature.

The class includes several methods to check if a certain feature (like :wiki, :builds etc.) is enabled or disabled based on their visibility levels in project settings.

Finally, there are 'public_pages?' method which checks if Pages feature for a given project can be accessed by public users. It considers the access level of the pages and whether the project itself is public.

These methods provide an interface to manage and validate features' visibility levels within a project. They ensure that only authorized individuals have access to certain features, ensuring data security and privacy in a collaborative environment like GitLab.

Remember this class is part of ActiveRecord::Base and therefore works with Active Record ORM (Object-Relational Mapping). It enables us to interact with the database via Ruby code by creating classes for each table we want to interact with, here it's ProjectFeature related to 'project_features' in the database.
","# frozen_string_literal: true

class ProjectFeature < ActiveRecord::Base
  # == Project features permissions
  #
  # Grants access level to project tools
  #
  # Tools can be enabled only for users, everyone or disabled
  # Access control is made only for non private projects
  #
  # levels:
  #
  # Disabled: not enabled for anyone
  # Private:  enabled only for team members
  # Enabled:  enabled for everyone able to access the project
  # Public:   enabled for everyone (only allowed for pages)
  #

  # Permission levels
  DISABLED = 0
  PRIVATE  = 10
  ENABLED  = 20
  PUBLIC   = 30

  FEATURES = %i(issues merge_requests wiki snippets builds repository pages).freeze
  PRIVATE_FEATURES_MIN_ACCESS_LEVEL = { merge_requests: Gitlab::Access::REPORTER }.freeze

  class << self
    def access_level_attribute(feature)
      feature = ensure_feature!(feature)

      ""#{feature}_access_level"".to_sym
    end

    def quoted_access_level_column(feature)
      attribute = connection.quote_column_name(access_level_attribute(feature))
      table = connection.quote_table_name(table_name)

      ""#{table}.#{attribute}""
    end

    def required_minimum_access_level(feature)
      feature = ensure_feature!(feature)

      PRIVATE_FEATURES_MIN_ACCESS_LEVEL.fetch(feature, Gitlab::Access::GUEST)
    end

    private

    def ensure_feature!(feature)
      feature = feature.model_name.plural.to_sym if feature.respond_to?(:model_name)
      raise ArgumentError, ""invalid project feature: #{feature}"" unless FEATURES.include?(feature)

      feature
    end
  end

  # Default scopes force us to unscope here since a service may need to check
  # permissions for a project in pending_delete
  # http://stackoverflow.com/questions/1540645/how-to-disable-default-scope-for-a-belongs-to
  belongs_to :project, -> { unscope(where: :pending_delete) }

  validates :project, presence: true

  validate :repository_children_level
  validate :allowed_access_levels

  default_value_for :builds_access_level,         value: ENABLED, allows_nil: false
  default_value_for :issues_access_level,         value: ENABLED, allows_nil: false
  default_value_for :merge_requests_access_level, value: ENABLED, allows_nil: false
  default_value_for :snippets_access_level,       value: ENABLED, allows_nil: false
  default_value_for :wiki_access_level,           value: ENABLED, allows_nil: false
  default_value_for :repository_access_level,     value: ENABLED, allows_nil: false

  def feature_available?(feature, user)
    # This feature might not be behind a feature flag at all, so default to true
    return false unless ::Feature.enabled?(feature, user, default_enabled: true)

    get_permission(user, access_level(feature))
  end

  def access_level(feature)
    public_send(ProjectFeature.access_level_attribute(feature)) # rubocop:disable GitlabSecurity/PublicSend
  end

  def builds_enabled?
    builds_access_level > DISABLED
  end

  def wiki_enabled?
    wiki_access_level > DISABLED
  end

  def merge_requests_enabled?
    merge_requests_access_level > DISABLED
  end

  def issues_enabled?
    issues_access_level > DISABLED
  end

  def pages_enabled?
    pages_access_level > DISABLED
  end

  def public_pages?
    return true unless Gitlab.config.pages.access_control

    pages_access_level == PUBLIC || pages_access_level == ENABLED && project.public?
  end

  private

  # Validates builds and merge requests access level
  # which cannot be higher than repository access level
  def repository_children_level
    validator = lambda do |field|
      level = public_send(field) || ProjectFeature::ENABLED # rubocop:disable GitlabSecurity/PublicSend
      not_allowed = level > repository_access_level
      self.errors.add(field, ""cannot have higher visibility level than repository access level"") if not_allowed
    end

    %i(merge_requests_access_level builds_access_level).each(&validator)
  end

  # Validates access level for other than pages cannot be PUBLIC
  def allowed_access_levels
    validator = lambda do |field|
      level = public_send(field) || ProjectFeature::ENABLED # rubocop:disable GitlabSecurity/PublicSend
      not_allowed = level > ProjectFeature::ENABLED
      self.errors.add(field, ""cannot have public visibility level"") if not_allowed
    end

    (FEATURES - %i(pages)).each {|f| validator.call(""#{f}_access_level"")}
  end

  def get_permission(user, level)
    case level
    when DISABLED
      false
    when PRIVATE
      user && (project.team.member?(user) || user.full_private_access?)
    when ENABLED
      true
    when PUBLIC
      true
    else
      true
    end
  end
end
"
"In the context of a Ruby on Rails application testing, the code provided is for testing user model behavior. The tests are written using ActiveSupport::TestCase which comes with Rails and allows us to write test cases in an organized manner.

The 'setup' method creates a new instance variable `@user` with various attributes like name, email, password etc., that we use throughout the tests.

Following are few of the test cases:
1. The first test 'should be valid', asserts that when the user record is created and assigned values to its fields, it should be considered as a valid instance by the application's validation rules specified in User model.
2. In next two tests, we check if name and email are not left blank which is necessary for all users in database. If these are empty, then that user record should not be accepted/invalid.
3. Then there are test cases checking the validity of an email address format by providing various valid and invalid emails addresses.
4. Test 'password should be present (nonblank)' checks if a password field is left blank or contains only spaces. If it does, then user record shouldn't be considered as valid.
5. Lastly, test 'authenticated? should return false for a user with nil digest', verifies that the method `authenticated?` in User model returns false when provided an empty string, which is used to check if remember digest of a user is present or not.
","# frozen_string_literal: true

require 'test_helper'

class UserTest < ActiveSupport::TestCase
  def setup
    @user = User.new(name: 'Example User', email: 'user@example.com',
                     password: 'foobar', password_confirmation: 'foobar')
  end

  test 'should be valid' do
    assert @user.valid?
  end

  test 'name should be present' do
    @user.name = '     '
    assert_not @user.valid?
  end

  test 'email should be present' do
    @user.email = '     '
    assert_not @user.valid?
  end

  test 'email validation should accept valid addresses' do
    valid_addresses = %w[user@example.com USER@foo.COM A_US-ER@foo.bar.org
                         first.last@foo.jp alice+bob@baz.cn]
    valid_addresses.each do |valid_address|
      @user.email = valid_address
      assert @user.valid?, ""#{valid_address.inspect} should be valid""
    end
  end

  test 'email validation should reject invalid addresses' do
    invalid_addresses = %w[user@example,com user_at_foo.org user.name@example.
                           foo@bar_baz.com foo@bar+baz.com]
    invalid_addresses.each do |invalid_address|
      @user.email = invalid_address
      assert_not @user.valid?, ""#{invalid_address.inspect} should be invalid""
    end
  end

  test 'email addresses should be unique' do
    duplicate_user = @user.dup
    @user.save
    assert_not duplicate_user.valid?
  end

  test 'email addresses should be unique (case sensitive)' do
    duplicate_user = @user.dup
    duplicate_user.email = @user.email.upcase
    @user.save
    assert_not duplicate_user.valid?
  end

  test 'email addresses should be saved as lower-case' do
    mixed_case_email = 'Foo@ExAMPle.CoM'
    @user.email = mixed_case_email
    @user.save
    assert_equal mixed_case_email.downcase, @user.reload.email
  end

  test 'password should be present (nonblank)' do
    @user.password = @user.password_confirmation = ' ' * 6
    assert_not @user.valid?
  end

  test 'password should have a minimum length' do
    @user.password = @user.password_confirmation = 'a' * 5
    assert_not @user.valid?
  end

  test 'authenticated? should return false for a user with nil digest' do
    assert_not @user.authenticated?('')
  end
end
"
"In the context of a Linux shell script, this code is setting up Kubernetes in Docker using DNS. The script checks for an environment variable `RUN_SKYDNS` which determines whether to run Skydns or not.

The 'if' condition sets the variable `DNS_ARGUMENTS` based on whether `RUN_SKYDNS` is set to ""yes"" or ""no"".

If `RUN_SKYDNS` equals ""yes"", it launches kube2sky and Skydns as Docker containers. These are running in the host network namespace, so they can communicate with each other on port 53 (the default DNS port). The scripts wait until Kubernetes is ready by checking if the localhost node can be found using `kubectl get nodes` command inside a loop and waiting for 5 seconds before trying again.

If `RUN_SKYDNS` equals ""no"", it runs an empty 'true' command to do nothing, effectively skipping launching kube2sky and Skydns.

At the end of the script, the working directory is reset back to its previous state by using the `cd ${PWD}` line. This ensures that subsequent commands run from this shell are not affected by the current script's execution.

Note: It's assumed that Docker and Kubernetes have been set up in the environment where this code is being executed, as the script uses a 'docker exec' command to interact with the hyperkube container which runs Kubernetes within a Docker container.
","#!/bin/bash

# Running skydns based on instructions at: https://testdatamanagement.wordpress.com/2015/09/01/running-kubernetes-in-docker-with-dns-on-a-single-node/

PWD=`pwd`
BASEDIR=`readlink -e $(dirname ${0})`
cd ${BASEDIR}

KUBECTL='docker exec hyperkube /hyperkube kubectl'

#RUN_SKYDNS=""yes""
RUN_SKYDNS=""no""

# DNS_ARGUMENTS needs to be passed when Kubernetes is setup.
if [ ""${RUN_SKYDNS}"" = ""yes"" ]; then
	DNS_ARGUMENTS=""--cluster-dns=10.0.0.10 --cluster-domain=cluster.local""
else
	DNS_ARGUMENTS=""""
fi

wait_until_k8s_ready() {
	# Wait until kubernetes is up and fully responsive
	while :
	do
		${KUBECTL} get nodes 2>/dev/null | grep -q '127.0.0.1'
		if [ ""${?}"" = ""0"" ]; then
			break
		else
			echo ""sleeping for 5 seconds (waiting for kubernetes to start)""
			sleep 5
		fi
	done
	echo ""kubernetes nodes:""
	${KUBECTL} get nodes
}


if [ ""${RUN_SKYDNS}"" = ""yes"" ]; then
	wait_until_k8s_ready

	echo ""Launch kube2sky...""
	docker run -d --net=host gcr.io/google_containers/kube2sky:1.11 --kube_master_url=http://127.0.0.1:8080 --domain=cluster.local

	echo """"

	echo ""Launch SkyDNS...""
	docker run -d --net=host gcr.io/google_containers/skydns:2015-03-11-001 --machines=http://localhost:4001 --addr=0.0.0.0:53 --domain=cluster.local
else
	true
fi

cd ${PWD}
"
"In the context of a script that runs Kubernetes commands, this Ruby code does the following:
1. It is running a bash shell script which copies an existing kubeconfig file from `/etc/kubernetes/admin.conf` to `/root/kube-admin.conf` using the cp command with '-i' option for interactive confirmation before overwriting if the target file already exists.
2. After copying, it runs 'kubectl --kubeconfig /root/kube-admin.conf $*'. The '$*' is a special shell variable that represents all arguments passed to the script. It allows passing any number of options or commands to kubectl with no additional code required by the user.
","#!/bin/bash
# cp -i /etc/kubernetes/admin.conf /root/kube-admin.conf
kubectl --kubeconfig /root/kube-admin.conf $*
"
"In the context of this given Ruby code, it is a script designed to run as an entrypoint for Docker containers. This means that whenever we start or run our container using this script, certain actions will be taken based on different scenarios.

Here's the key phrase from the code:
""$1"" = ""/opt/logstash/bin/logstash"". In the context of shell scripting and Docker containers, ""$1"", ""$2"", etc., are variables that represent arguments passed to a script when it is invoked. Here, we're checking if the first argument (the command that was run) matches ""/opt/logstash/bin/logstash"". If so, then the code executes ""/opt/logstash/bin/logstash agent -f /opt/logstash.conf"". This sets up Logstash to process logs in accordance with the configuration file located at '/opt/conf/logstash.conf'.

If the first argument does not match ""/opt/logstash/bin/logstash"", then it executes whatever command was passed as an argument (""$@"" represents all arguments). This is useful for allowing scripts to run different commands or actions depending on how they were invoked, providing a degree of flexibility.
","#!/bin/bash
set -e

if [ ""$1"" = ""/opt/logstash/bin/logstash"" ]; then
    exec ""$1"" agent -f /opt/conf/logstash.conf
else
    exec ""$@""
fi"
"In the context of a Ruby script, there are two functions defined:

1. The `seqWatch()` function is responsible for watching files named *.diag in the given directory (recursive) and generating corresponding PNG file when a change occurs. It takes an optional parameter which sets the folder to watch (defaulting to the current working directory if not specified). If no folder is provided, it prints a message setting the folder to the current working directory. The function uses inotifywait command line utility to monitor for changes on filesystem events and then executes seqdiag command-line utility as per file type being watched.

2. The `seqInit()` function is used to initialize a seqdiag file with preferences defined in seqdiag.init. It takes one parameter which sets the path of the file to be created (must provide an absolute path). If the directory for the new file does not exist, it creates the directories leading up to the filename. Then, it copies the seqdiag.init from a predefined location (TOOLING) to the newly created file.
","#---------#
# Seqdiag #
#---------#

# Watches for files named *.diag in the given directory (recursive) and generates the
# corresponding PNG file.
# $1: the folder to watch (Default: pwd)
# shellcheck disable=SC2034
seqWatch() {
  local folder=""$1""

  [[ -n ""$folder"" ]] || {
    printfc 'Folder not defined, it was set to pwd\n' ""$YELLOW""
    folder=""$(pwd)"";
  }

  inotifywait -rm ""$folder"" -e close_write |
  while read path action file; do
    if [[ ""$file"" =~ .*\.diag$ ]]; then
      seqdiag ""$path$file"" --no-transparency -a
    fi
  done
}

# Inits a seqdiag file with the preferences defined in seqdiag.init.
# Uses: $TOOLING
# $1: the file to be created (absolute path)
seqInit() {
  local filePath=""${1?Missing path to file}""

  mkdir -p ""$(dirname ""$filePath"")""
  cp ""$TOOLING/bashrc/Utils/seqdiag.init"" ""$(basename ""$filePath"")""
}
"
"In the context of Bash scripting, this code is removing all blank lines from clipboard content. The command `pbpaste` retrieves the contents copied to the system's pasteboard; then it uses `awk '!/^[ ]*$/'` to filter out empty lines; and finally, `pbcopy` stores these filtered lines back into the pasteboard.

The script is run in a terminal and requires user interaction by manually copying text into the clipboard before running the command (using pbpaste), performing some operation with that copied content, then copying it back to the clipboard again (using pbcopy). This workflow doesn't involve any specific Ruby code.
","#!/bin/bash
# Author: Eason Yi
# Date: 2017-05-17

pbpaste|awk '!/^[ ]*$/'|pbcopy|pbpaste
"
"The given Ruby code contains data about time zone descriptions for different countries. It is a deprecated version, as the file has been replaced by zone1970.tab (see its comments). The first column of the file contains country codes, while the second contains coordinates and TZ columns contain information on corresponding time zones.

Each row stands for an area that is the intersection of a region identified by a country code and of a zone where civil clocks have agreed since 1970; this is a narrower definition than that of zone1970.tab. The data in this file is intended as a backward-compatibility aid for older programs, but new programs should use zone1970.tab instead.

The comments column provides additional information about the time zones represented by each row, including any deprecated version identifiers and other information on the status of implementation and testing of these timezones in various applications.

This table is intended as an aid for users, to help them select appropriate time zone data entries suitable for their practical needs. It should not be used to take or endorse any position on legal or territorial claims.
","# tz zone descriptions (deprecated version)
#
# This file is in the public domain, so clarified as of
# 2009-05-17 by Arthur David Olson.
#
# From Paul Eggert (2014-07-31):
# This file is intended as a backward-compatibility aid for older programs.
# New programs should use zone1970.tab.  This file is like zone1970.tab (see
# zone1970.tab's comments), but with the following additional restrictions:
#
# 1.  This file contains only ASCII characters.
# 2.  The first data column contains exactly one country code.
#
# Because of (2), each row stands for an area that is the intersection
# of a region identified by a country code and of a zone where civil
# clocks have agreed since 1970; this is a narrower definition than
# that of zone1970.tab.
#
# This table is intended as an aid for users, to help them select time
# zone data entries appropriate for their practical needs.  It is not
# intended to take or endorse any position on legal or territorial claims.
#
#country-
#code	coordinates	TZ			comments
AD	+4230+00131	Europe/Andorra
AE	+2518+05518	Asia/Dubai
AF	+3431+06912	Asia/Kabul
AG	+1703-06148	America/Antigua
AI	+1812-06304	America/Anguilla
AL	+4120+01950	Europe/Tirane
AM	+4011+04430	Asia/Yerevan
AO	-0848+01314	Africa/Luanda
AQ	-7750+16636	Antarctica/McMurdo	New Zealand time - McMurdo, South Pole
AQ	-6617+11031	Antarctica/Casey	Casey
AQ	-6835+07758	Antarctica/Davis	Davis
AQ	-6640+14001	Antarctica/DumontDUrville	Dumont-d'Urville
AQ	-6736+06253	Antarctica/Mawson	Mawson
AQ	-6448-06406	Antarctica/Palmer	Palmer
AQ	-6734-06808	Antarctica/Rothera	Rothera
AQ	-690022+0393524	Antarctica/Syowa	Syowa
AQ	-720041+0023206	Antarctica/Troll	Troll
AQ	-7824+10654	Antarctica/Vostok	Vostok
AR	-3436-05827	America/Argentina/Buenos_Aires	Buenos Aires (BA, CF)
AR	-3124-06411	America/Argentina/Cordoba	Argentina (most areas: CB, CC, CN, ER, FM, MN, SE, SF)
AR	-2447-06525	America/Argentina/Salta	Salta (SA, LP, NQ, RN)
AR	-2411-06518	America/Argentina/Jujuy	Jujuy (JY)
AR	-2649-06513	America/Argentina/Tucuman	Tucuman (TM)
AR	-2828-06547	America/Argentina/Catamarca	Catamarca (CT); Chubut (CH)
AR	-2926-06651	America/Argentina/La_Rioja	La Rioja (LR)
AR	-3132-06831	America/Argentina/San_Juan	San Juan (SJ)
AR	-3253-06849	America/Argentina/Mendoza	Mendoza (MZ)
AR	-3319-06621	America/Argentina/San_Luis	San Luis (SL)
AR	-5138-06913	America/Argentina/Rio_Gallegos	Santa Cruz (SC)
AR	-5448-06818	America/Argentina/Ushuaia	Tierra del Fuego (TF)
AS	-1416-17042	Pacific/Pago_Pago
AT	+4813+01620	Europe/Vienna
AU	-3133+15905	Australia/Lord_Howe	Lord Howe Island
AU	-5430+15857	Antarctica/Macquarie	Macquarie Island
AU	-4253+14719	Australia/Hobart	Tasmania (most areas)
AU	-3956+14352	Australia/Currie	Tasmania (King Island)
AU	-3749+14458	Australia/Melbourne	Victoria
AU	-3352+15113	Australia/Sydney	New South Wales (most areas)
AU	-3157+14127	Australia/Broken_Hill	New South Wales (Yancowinna)
AU	-2728+15302	Australia/Brisbane	Queensland (most areas)
AU	-2016+14900	Australia/Lindeman	Queensland (Whitsunday Islands)
AU	-3455+13835	Australia/Adelaide	South Australia
AU	-1228+13050	Australia/Darwin	Northern Territory
AU	-3157+11551	Australia/Perth	Western Australia (most areas)
AU	-3143+12852	Australia/Eucla	Western Australia (Eucla)
AW	+1230-06958	America/Aruba
AX	+6006+01957	Europe/Mariehamn
AZ	+4023+04951	Asia/Baku
BA	+4352+01825	Europe/Sarajevo
BB	+1306-05937	America/Barbados
BD	+2343+09025	Asia/Dhaka
BE	+5050+00420	Europe/Brussels
BF	+1222-00131	Africa/Ouagadougou
BG	+4241+02319	Europe/Sofia
BH	+2623+05035	Asia/Bahrain
BI	-0323+02922	Africa/Bujumbura
BJ	+0629+00237	Africa/Porto-Novo
BL	+1753-06251	America/St_Barthelemy
BM	+3217-06446	Atlantic/Bermuda
BN	+0456+11455	Asia/Brunei
BO	-1630-06809	America/La_Paz
BQ	+120903-0681636	America/Kralendijk
BR	-0351-03225	America/Noronha	Atlantic islands
BR	-0127-04829	America/Belem	Para (east); Amapa
BR	-0343-03830	America/Fortaleza	Brazil (northeast: MA, PI, CE, RN, PB)
BR	-0803-03454	America/Recife	Pernambuco
BR	-0712-04812	America/Araguaina	Tocantins
BR	-0940-03543	America/Maceio	Alagoas, Sergipe
BR	-1259-03831	America/Bahia	Bahia
BR	-2332-04637	America/Sao_Paulo	Brazil (southeast: GO, DF, MG, ES, RJ, SP, PR, SC, RS)
BR	-2027-05437	America/Campo_Grande	Mato Grosso do Sul
BR	-1535-05605	America/Cuiaba	Mato Grosso
BR	-0226-05452	America/Santarem	Para (west)
BR	-0846-06354	America/Porto_Velho	Rondonia
BR	+0249-06040	America/Boa_Vista	Roraima
BR	-0308-06001	America/Manaus	Amazonas (east)
BR	-0640-06952	America/Eirunepe	Amazonas (west)
BR	-0958-06748	America/Rio_Branco	Acre
BS	+2505-07721	America/Nassau
BT	+2728+08939	Asia/Thimphu
BW	-2439+02555	Africa/Gaborone
BY	+5354+02734	Europe/Minsk
BZ	+1730-08812	America/Belize
CA	+4734-05243	America/St_Johns	Newfoundland; Labrador (southeast)
CA	+4439-06336	America/Halifax	Atlantic - NS (most areas); PE
CA	+4612-05957	America/Glace_Bay	Atlantic - NS (Cape Breton)
CA	+4606-06447	America/Moncton	Atlantic - New Brunswick
CA	+5320-06025	America/Goose_Bay	Atlantic - Labrador (most areas)
CA	+5125-05707	America/Blanc-Sablon	AST - QC (Lower North Shore)
CA	+4339-07923	America/Toronto	Eastern - ON, QC (most areas)
CA	+4901-08816	America/Nipigon	Eastern - ON, QC (no DST 1967-73)
CA	+4823-08915	America/Thunder_Bay	Eastern - ON (Thunder Bay)
CA	+6344-06828	America/Iqaluit	Eastern - NU (most east areas)
CA	+6608-06544	America/Pangnirtung	Eastern - NU (Pangnirtung)
CA	+484531-0913718	America/Atikokan	EST - ON (Atikokan); NU (Coral H)
CA	+4953-09709	America/Winnipeg	Central - ON (west); Manitoba
CA	+4843-09434	America/Rainy_River	Central - ON (Rainy R, Ft Frances)
CA	+744144-0944945	America/Resolute	Central - NU (Resolute)
CA	+624900-0920459	America/Rankin_Inlet	Central - NU (central)
CA	+5024-10439	America/Regina	CST - SK (most areas)
CA	+5017-10750	America/Swift_Current	CST - SK (midwest)
CA	+5333-11328	America/Edmonton	Mountain - AB; BC (E); SK (W)
CA	+690650-1050310	America/Cambridge_Bay	Mountain - NU (west)
CA	+6227-11421	America/Yellowknife	Mountain - NT (central)
CA	+682059-1334300	America/Inuvik	Mountain - NT (west)
CA	+4906-11631	America/Creston	MST - BC (Creston)
CA	+5946-12014	America/Dawson_Creek	MST - BC (Dawson Cr, Ft St John)
CA	+5848-12242	America/Fort_Nelson	MST - BC (Ft Nelson)
CA	+4916-12307	America/Vancouver	Pacific - BC (most areas)
CA	+6043-13503	America/Whitehorse	Pacific - Yukon (south)
CA	+6404-13925	America/Dawson	Pacific - Yukon (north)
CC	-1210+09655	Indian/Cocos
CD	-0418+01518	Africa/Kinshasa	Dem. Rep. of Congo (west)
CD	-1140+02728	Africa/Lubumbashi	Dem. Rep. of Congo (east)
CF	+0422+01835	Africa/Bangui
CG	-0416+01517	Africa/Brazzaville
CH	+4723+00832	Europe/Zurich
CI	+0519-00402	Africa/Abidjan
CK	-2114-15946	Pacific/Rarotonga
CL	-3327-07040	America/Santiago	Chile (most areas)
CL	-2709-10926	Pacific/Easter	Easter Island
CM	+0403+00942	Africa/Douala
CN	+3114+12128	Asia/Shanghai	Beijing Time
CN	+4348+08735	Asia/Urumqi	Xinjiang Time
CO	+0436-07405	America/Bogota
CR	+0956-08405	America/Costa_Rica
CU	+2308-08222	America/Havana
CV	+1455-02331	Atlantic/Cape_Verde
CW	+1211-06900	America/Curacao
CX	-1025+10543	Indian/Christmas
CY	+3510+03322	Asia/Nicosia
CZ	+5005+01426	Europe/Prague
DE	+5230+01322	Europe/Berlin	Germany (most areas)
DE	+4742+00841	Europe/Busingen	Busingen
DJ	+1136+04309	Africa/Djibouti
DK	+5540+01235	Europe/Copenhagen
DM	+1518-06124	America/Dominica
DO	+1828-06954	America/Santo_Domingo
DZ	+3647+00303	Africa/Algiers
EC	-0210-07950	America/Guayaquil	Ecuador (mainland)
EC	-0054-08936	Pacific/Galapagos	Galapagos Islands
EE	+5925+02445	Europe/Tallinn
EG	+3003+03115	Africa/Cairo
EH	+2709-01312	Africa/El_Aaiun
ER	+1520+03853	Africa/Asmara
ES	+4024-00341	Europe/Madrid	Spain (mainland)
ES	+3553-00519	Africa/Ceuta	Ceuta, Melilla
ES	+2806-01524	Atlantic/Canary	Canary Islands
ET	+0902+03842	Africa/Addis_Ababa
FI	+6010+02458	Europe/Helsinki
FJ	-1808+17825	Pacific/Fiji
FK	-5142-05751	Atlantic/Stanley
FM	+0725+15147	Pacific/Chuuk	Chuuk/Truk, Yap
FM	+0658+15813	Pacific/Pohnpei	Pohnpei/Ponape
FM	+0519+16259	Pacific/Kosrae	Kosrae
FO	+6201-00646	Atlantic/Faroe
FR	+4852+00220	Europe/Paris
GA	+0023+00927	Africa/Libreville
GB	+513030-0000731	Europe/London
GD	+1203-06145	America/Grenada
GE	+4143+04449	Asia/Tbilisi
GF	+0456-05220	America/Cayenne
GG	+4927-00232	Europe/Guernsey
GH	+0533-00013	Africa/Accra
GI	+3608-00521	Europe/Gibraltar
GL	+6411-05144	America/Godthab	Greenland (most areas)
GL	+7646-01840	America/Danmarkshavn	National Park (east coast)
GL	+7029-02158	America/Scoresbysund	Scoresbysund/Ittoqqortoormiit
GL	+7634-06847	America/Thule	Thule/Pituffik
GM	+1328-01639	Africa/Banjul
GN	+0931-01343	Africa/Conakry
GP	+1614-06132	America/Guadeloupe
GQ	+0345+00847	Africa/Malabo
GR	+3758+02343	Europe/Athens
GS	-5416-03632	Atlantic/South_Georgia
GT	+1438-09031	America/Guatemala
GU	+1328+14445	Pacific/Guam
GW	+1151-01535	Africa/Bissau
GY	+0648-05810	America/Guyana
HK	+2217+11409	Asia/Hong_Kong
HN	+1406-08713	America/Tegucigalpa
HR	+4548+01558	Europe/Zagreb
HT	+1832-07220	America/Port-au-Prince
HU	+4730+01905	Europe/Budapest
ID	-0610+10648	Asia/Jakarta	Java, Sumatra
ID	-0002+10920	Asia/Pontianak	Borneo (west, central)
ID	-0507+11924	Asia/Makassar	Borneo (east, south); Sulawesi/Celebes, Bali, Nusa Tengarra; Timor (west)
ID	-0232+14042	Asia/Jayapura	New Guinea (West Papua / Irian Jaya); Malukus/Moluccas
IE	+5320-00615	Europe/Dublin
IL	+314650+0351326	Asia/Jerusalem
IM	+5409-00428	Europe/Isle_of_Man
IN	+2232+08822	Asia/Kolkata
IO	-0720+07225	Indian/Chagos
IQ	+3321+04425	Asia/Baghdad
IR	+3540+05126	Asia/Tehran
IS	+6409-02151	Atlantic/Reykjavik
IT	+4154+01229	Europe/Rome
JE	+4912-00207	Europe/Jersey
JM	+175805-0764736	America/Jamaica
JO	+3157+03556	Asia/Amman
JP	+353916+1394441	Asia/Tokyo
KE	-0117+03649	Africa/Nairobi
KG	+4254+07436	Asia/Bishkek
KH	+1133+10455	Asia/Phnom_Penh
KI	+0125+17300	Pacific/Tarawa	Gilbert Islands
KI	-0308-17105	Pacific/Enderbury	Phoenix Islands
KI	+0152-15720	Pacific/Kiritimati	Line Islands
KM	-1141+04316	Indian/Comoro
KN	+1718-06243	America/St_Kitts
KP	+3901+12545	Asia/Pyongyang
KR	+3733+12658	Asia/Seoul
KW	+2920+04759	Asia/Kuwait
KY	+1918-08123	America/Cayman
KZ	+4315+07657	Asia/Almaty	Kazakhstan (most areas)
KZ	+4448+06528	Asia/Qyzylorda	Qyzylorda/Kyzylorda/Kzyl-Orda
KZ	+5017+05710	Asia/Aqtobe	Aqtobe/Aktobe
KZ	+4431+05016	Asia/Aqtau	Atyrau/Atirau/Gur'yev, Mangghystau/Mankistau
KZ	+5113+05121	Asia/Oral	West Kazakhstan
LA	+1758+10236	Asia/Vientiane
LB	+3353+03530	Asia/Beirut
LC	+1401-06100	America/St_Lucia
LI	+4709+00931	Europe/Vaduz
LK	+0656+07951	Asia/Colombo
LR	+0618-01047	Africa/Monrovia
LS	-2928+02730	Africa/Maseru
LT	+5441+02519	Europe/Vilnius
LU	+4936+00609	Europe/Luxembourg
LV	+5657+02406	Europe/Riga
LY	+3254+01311	Africa/Tripoli
MA	+3339-00735	Africa/Casablanca
MC	+4342+00723	Europe/Monaco
MD	+4700+02850	Europe/Chisinau
ME	+4226+01916	Europe/Podgorica
MF	+1804-06305	America/Marigot
MG	-1855+04731	Indian/Antananarivo
MH	+0709+17112	Pacific/Majuro	Marshall Islands (most areas)
MH	+0905+16720	Pacific/Kwajalein	Kwajalein
MK	+4159+02126	Europe/Skopje
ML	+1239-00800	Africa/Bamako
MM	+1647+09610	Asia/Rangoon
MN	+4755+10653	Asia/Ulaanbaatar	Mongolia (most areas)
MN	+4801+09139	Asia/Hovd	Bayan-Olgiy, Govi-Altai, Hovd, Uvs, Zavkhan
MN	+4804+11430	Asia/Choibalsan	Dornod, Sukhbaatar
MO	+2214+11335	Asia/Macau
MP	+1512+14545	Pacific/Saipan
MQ	+1436-06105	America/Martinique
MR	+1806-01557	Africa/Nouakchott
MS	+1643-06213	America/Montserrat
MT	+3554+01431	Europe/Malta
MU	-2010+05730	Indian/Mauritius
MV	+0410+07330	Indian/Maldives
MW	-1547+03500	Africa/Blantyre
MX	+1924-09909	America/Mexico_City	Central Time
MX	+2105-08646	America/Cancun	Eastern Standard Time - Quintana Roo
MX	+2058-08937	America/Merida	Central Time - Campeche, Yucatan
MX	+2540-10019	America/Monterrey	Central Time - Durango; Coahuila, Nuevo Leon, Tamaulipas (most areas)
MX	+2550-09730	America/Matamoros	Central Time US - Coahuila, Nuevo Leon, Tamaulipas (US border)
MX	+2313-10625	America/Mazatlan	Mountain Time - Baja California Sur, Nayarit, Sinaloa
MX	+2838-10605	America/Chihuahua	Mountain Time - Chihuahua (most areas)
MX	+2934-10425	America/Ojinaga	Mountain Time US - Chihuahua (US border)
MX	+2904-11058	America/Hermosillo	Mountain Standard Time - Sonora
MX	+3232-11701	America/Tijuana	Pacific Time US - Baja California
MX	+2048-10515	America/Bahia_Banderas	Central Time - Bahia de Banderas
MY	+0310+10142	Asia/Kuala_Lumpur	Malaysia (peninsula)
MY	+0133+11020	Asia/Kuching	Sabah, Sarawak
MZ	-2558+03235	Africa/Maputo
NA	-2234+01706	Africa/Windhoek
NC	-2216+16627	Pacific/Noumea
NE	+1331+00207	Africa/Niamey
NF	-2903+16758	Pacific/Norfolk
NG	+0627+00324	Africa/Lagos
NI	+1209-08617	America/Managua
NL	+5222+00454	Europe/Amsterdam
NO	+5955+01045	Europe/Oslo
NP	+2743+08519	Asia/Kathmandu
NR	-0031+16655	Pacific/Nauru
NU	-1901-16955	Pacific/Niue
NZ	-3652+17446	Pacific/Auckland	New Zealand (most areas)
NZ	-4357-17633	Pacific/Chatham	Chatham Islands
OM	+2336+05835	Asia/Muscat
PA	+0858-07932	America/Panama
PE	-1203-07703	America/Lima
PF	-1732-14934	Pacific/Tahiti	Society Islands
PF	-0900-13930	Pacific/Marquesas	Marquesas Islands
PF	-2308-13457	Pacific/Gambier	Gambier Islands
PG	-0930+14710	Pacific/Port_Moresby	Papua New Guinea (most areas)
PG	-0613+15534	Pacific/Bougainville	Bougainville
PH	+1435+12100	Asia/Manila
PK	+2452+06703	Asia/Karachi
PL	+5215+02100	Europe/Warsaw
PM	+4703-05620	America/Miquelon
PN	-2504-13005	Pacific/Pitcairn
PR	+182806-0660622	America/Puerto_Rico
PS	+3130+03428	Asia/Gaza	Gaza Strip
PS	+313200+0350542	Asia/Hebron	West Bank
PT	+3843-00908	Europe/Lisbon	Portugal (mainland)
PT	+3238-01654	Atlantic/Madeira	Madeira Islands
PT	+3744-02540	Atlantic/Azores	Azores
PW	+0720+13429	Pacific/Palau
PY	-2516-05740	America/Asuncion
QA	+2517+05132	Asia/Qatar
RE	-2052+05528	Indian/Reunion
RO	+4426+02606	Europe/Bucharest
RS	+4450+02030	Europe/Belgrade
RU	+5443+02030	Europe/Kaliningrad	MSK-01 - Kaliningrad
RU	+554521+0373704	Europe/Moscow	MSK+00 - Moscow area
RU	+4457+03406	Europe/Simferopol	MSK+00 - Crimea
RU	+4844+04425	Europe/Volgograd	MSK+00 - Volgograd, Kirov, Saratov
RU	+4621+04803	Europe/Astrakhan	MSK+01 - Astrakhan
RU	+5312+05009	Europe/Samara	MSK+01 - Samara, Udmurtia
RU	+5420+04824	Europe/Ulyanovsk	MSK+01 - Ulyanovsk
RU	+5651+06036	Asia/Yekaterinburg	MSK+02 - Urals
RU	+5500+07324	Asia/Omsk	MSK+03 - Omsk
RU	+5502+08255	Asia/Novosibirsk	MSK+03 - Novosibirsk, Tomsk
RU	+5322+08345	Asia/Barnaul	MSK+04 - Altai
RU	+5345+08707	Asia/Novokuznetsk	MSK+04 - Kemerovo
RU	+5601+09250	Asia/Krasnoyarsk	MSK+04 - Krasnoyarsk area
RU	+5216+10420	Asia/Irkutsk	MSK+05 - Irkutsk, Buryatia
RU	+5203+11328	Asia/Chita	MSK+05 - Zabaykalsky
RU	+6200+12940	Asia/Yakutsk	MSK+06 - Lena River
RU	+623923+1353314	Asia/Khandyga	MSK+06 - Tomponsky, Ust-Maysky
RU	+4310+13156	Asia/Vladivostok	MSK+07 - Amur River
RU	+4658+14242	Asia/Sakhalin	MSK+07 - Sakhalin Island
RU	+643337+1431336	Asia/Ust-Nera	MSK+07 - Oymyakonsky
RU	+5934+15048	Asia/Magadan	MSK+07 - Magadan
RU	+6728+15343	Asia/Srednekolymsk	MSK+08 - Sakha (E); North Kuril Is
RU	+5301+15839	Asia/Kamchatka	MSK+09 - Kamchatka
RU	+6445+17729	Asia/Anadyr	MSK+09 - Bering Sea
RW	-0157+03004	Africa/Kigali
SA	+2438+04643	Asia/Riyadh
SB	-0932+16012	Pacific/Guadalcanal
SC	-0440+05528	Indian/Mahe
SD	+1536+03232	Africa/Khartoum
SE	+5920+01803	Europe/Stockholm
SG	+0117+10351	Asia/Singapore
SH	-1555-00542	Atlantic/St_Helena
SI	+4603+01431	Europe/Ljubljana
SJ	+7800+01600	Arctic/Longyearbyen
SK	+4809+01707	Europe/Bratislava
SL	+0830-01315	Africa/Freetown
SM	+4355+01228	Europe/San_Marino
SN	+1440-01726	Africa/Dakar
SO	+0204+04522	Africa/Mogadishu
SR	+0550-05510	America/Paramaribo
SS	+0451+03136	Africa/Juba
ST	+0020+00644	Africa/Sao_Tome
SV	+1342-08912	America/El_Salvador
SX	+180305-0630250	America/Lower_Princes
SY	+3330+03618	Asia/Damascus
SZ	-2618+03106	Africa/Mbabane
TC	+2128-07108	America/Grand_Turk
TD	+1207+01503	Africa/Ndjamena
TF	-492110+0701303	Indian/Kerguelen
TG	+0608+00113	Africa/Lome
TH	+1345+10031	Asia/Bangkok
TJ	+3835+06848	Asia/Dushanbe
TK	-0922-17114	Pacific/Fakaofo
TL	-0833+12535	Asia/Dili
TM	+3757+05823	Asia/Ashgabat
TN	+3648+01011	Africa/Tunis
TO	-2110-17510	Pacific/Tongatapu
TR	+4101+02858	Europe/Istanbul
TT	+1039-06131	America/Port_of_Spain
TV	-0831+17913	Pacific/Funafuti
TW	+2503+12130	Asia/Taipei
TZ	-0648+03917	Africa/Dar_es_Salaam
UA	+5026+03031	Europe/Kiev	Ukraine (most areas)
UA	+4837+02218	Europe/Uzhgorod	Ruthenia
UA	+4750+03510	Europe/Zaporozhye	Zaporozh'ye/Zaporizhia; Lugansk/Luhansk (east)
UG	+0019+03225	Africa/Kampala
UM	+1645-16931	Pacific/Johnston	Johnston Atoll
UM	+2813-17722	Pacific/Midway	Midway Islands
UM	+1917+16637	Pacific/Wake	Wake Island
US	+404251-0740023	America/New_York	Eastern (most areas)
US	+421953-0830245	America/Detroit	Eastern - MI (most areas)
US	+381515-0854534	America/Kentucky/Louisville	Eastern - KY (Louisville area)
US	+364947-0845057	America/Kentucky/Monticello	Eastern - KY (Wayne)
US	+394606-0860929	America/Indiana/Indianapolis	Eastern - IN (most areas)
US	+384038-0873143	America/Indiana/Vincennes	Eastern - IN (Da, Du, K, Mn)
US	+410305-0863611	America/Indiana/Winamac	Eastern - IN (Pulaski)
US	+382232-0862041	America/Indiana/Marengo	Eastern - IN (Crawford)
US	+382931-0871643	America/Indiana/Petersburg	Eastern - IN (Pike)
US	+384452-0850402	America/Indiana/Vevay	Eastern - IN (Switzerland)
US	+415100-0873900	America/Chicago	Central (most areas)
US	+375711-0864541	America/Indiana/Tell_City	Central - IN (Perry)
US	+411745-0863730	America/Indiana/Knox	Central - IN (Starke)
US	+450628-0873651	America/Menominee	Central - MI (Wisconsin border)
US	+470659-1011757	America/North_Dakota/Center	Central - ND (Oliver)
US	+465042-1012439	America/North_Dakota/New_Salem	Central - ND (Morton rural)
US	+471551-1014640	America/North_Dakota/Beulah	Central - ND (Mercer)
US	+394421-1045903	America/Denver	Mountain (most areas)
US	+433649-1161209	America/Boise	Mountain - ID (south); OR (east)
US	+332654-1120424	America/Phoenix	MST - Arizona (except Navajo)
US	+340308-1181434	America/Los_Angeles	Pacific
US	+611305-1495401	America/Anchorage	Alaska (most areas)
US	+581807-1342511	America/Juneau	Alaska - Juneau area
US	+571035-1351807	America/Sitka	Alaska - Sitka area
US	+550737-1313435	America/Metlakatla	Alaska - Annette Island
US	+593249-1394338	America/Yakutat	Alaska - Yakutat
US	+643004-1652423	America/Nome	Alaska (west)
US	+515248-1763929	America/Adak	Aleutian Islands
US	+211825-1575130	Pacific/Honolulu	Hawaii
UY	-3453-05611	America/Montevideo
UZ	+3940+06648	Asia/Samarkand	Uzbekistan (west)
UZ	+4120+06918	Asia/Tashkent	Uzbekistan (east)
VA	+415408+0122711	Europe/Vatican
VC	+1309-06114	America/St_Vincent
VE	+1030-06656	America/Caracas
VG	+1827-06437	America/Tortola
VI	+1821-06456	America/St_Thomas
VN	+1045+10640	Asia/Ho_Chi_Minh
VU	-1740+16825	Pacific/Efate
WF	-1318-17610	Pacific/Wallis
WS	-1350-17144	Pacific/Apia
YE	+1245+04512	Asia/Aden
YT	-1247+04514	Indian/Mayotte
ZA	-2615+02800	Africa/Johannesburg
ZM	-1525+02817	Africa/Lusaka
ZW	-1750+03103	Africa/Harare
"
"Instruction:
In the context of a data analysis project, you are using SQL to query and manipulate data. You need to analyze order quantities based on their lead time. You have two queries - one for orders with quantity 360 and another for orders with quantity 361. These queries join two tables from your WideWorldImportersDW database: 'Fact.Order' and 'Dimension.Stock Item'. The '[Fact].[Order]' table includes information about each order, while the '[Dimension].[Stock Item]' provides details about stock items in these orders.

The first query retrieves the [Order Key], [Lead Time Days], and [Quantity] from rows where the [Quantity] is 360. This is done by using an INNER JOIN to combine rows based on matching 'Stock Item Key's between both tables, and then filtering for orders with quantity 360.

The second query does the same but filters for orders with a quantity of 361 instead.

Remember that these queries are parameterized using SQL stored procedures (sp_executesql). The parameters @param1 are set to values of 360 and 361 respectively, controlling which data is returned by each query. This ensures the reusability of the code for different quantities without having to rewrite or modify it directly.
","USE [WideWorldImportersDW]
GO
ALTER DATABASE CURRENT SET COMPATIBILITY_LEVEL = 140
GO

EXEC sp_executesql
N'SELECT  [fo].[Order Key], [si].[Lead Time Days], [fo].[Quantity]
FROM    [Fact].[Order] AS [fo]
INNER JOIN [Dimension].[Stock Item] AS [si]
       ON [fo].[Stock Item Key] = [si].[Stock Item Key]
WHERE   [fo].[Quantity] =@param1',
N'@param1 int',
@param1 = 360
GO

EXEC sp_executesql
N'SELECT  [fo].[Order Key], [si].[Lead Time Days], [fo].[Quantity]
FROM    [Fact].[Order] AS [fo]
INNER JOIN [Dimension].[Stock Item] AS [si]
       ON [fo].[Stock Item Key] = [si].[Stock Item Key]
WHERE   [fo].[Quantity] =@param1',
N'@param1 int',
@param1 = 361
GO
"
"In the context of setting up a database schema for storing plugin-specific key-value pairs, you would run these SQL commands.

The first command creates a table named 'pluginkeyvaluestore' if it doesn't already exist. This table has three columns: 'pluginid', 'pkey', and 'pvalue'. All of them are set to be VARCHAR type with specific lengths, 'pluginid' is limited to 190 characters, while 'pkey' is restricted to a maximum length of 50 characters. The column 'pvalue' can hold binary data represented by bytea type. The combination of the two first columns ('pluginid', and 'pkey') forms the primary key for this table.

The second command alters the 'pluginkeyvaluestore' table to add a new column named 'expireat'. If it doesn't exist already, this new column is set as bigint type with a default value of 0. This would be used to store the expiry time for each key-value pair in some sort of timestamp format (bigint being understood as number of milliseconds since Unix epoch).

The third block of code checks if the 'expireat' column has its default set to 0. If it does, it alters this default value to be NULL instead, indicating that keys do not expire by default. The condition is checked with a DO $$BEGIN...END statement wrapped around, which ensures that this logic only runs once and in the absence of any errors.
","CREATE TABLE IF NOT EXISTS pluginkeyvaluestore (
    pluginid VARCHAR(190) NOT NULL,
    pkey VARCHAR(50) NOT NULL,
    pvalue bytea,
    PRIMARY KEY (pluginid, pkey)
);

ALTER TABLE pluginkeyvaluestore ADD COLUMN IF NOT EXISTS expireat bigint DEFAULT 0;

DO $$BEGIN
    IF (
        SELECT column_default::bigint
        FROM information_schema.columns
        WHERE table_schema='public'
        AND table_name='pluginkeyvaluestore'
        AND column_name='expireat'
    ) = 0 THEN
        ALTER TABLE pluginkeyvaluestore ALTER COLUMN expireat SET DEFAULT NULL;
    END IF;
END$$;
"
"In the context of a MySQL database, this SQL script is establishing a table called `datos personales`. This table contains information about individuals and their related data in fields such as first name (`nom`), last names (`pri_ape` and `seg_ape`), CURP (Colombian Unified Register of Population), group (`grup`), shift (`turno`), school name (`nom_esc`), and a code for the educational institution (`cct`). The database engine used is InnoDB, which supports transactions, row-level locking, and foreign key support.
","-- phpMyAdmin SQL Dump
-- version 4.6.5.2
-- https://www.phpmyadmin.net/
--
-- Servidor: 127.0.0.1
-- Tiempo de generación: 08-11-2017 a las 23:42:52
-- Versión del servidor: 10.1.21-MariaDB
-- Versión de PHP: 5.6.30

SET SQL_MODE = ""NO_AUTO_VALUE_ON_ZERO"";
SET time_zone = ""+00:00"";


/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
/*!40101 SET NAMES utf8mb4 */;

--
-- Base de datos: `cartilla_educacion`
--

-- --------------------------------------------------------

--
-- Estructura de tabla para la tabla `Datos personales`
--

CREATE TABLE `datos personales` (
  `pri_ape` varchar(24) NOT NULL,
  `seg_ape` varchar(24) NOT NULL,
  `nom` varchar(35) NOT NULL,
  `curp` varchar(18) NOT NULL,
  `grup` varchar(10) NOT NULL,
  `turno` varchar(15) NOT NULL,
  `nom_esc` varchar(60) NOT NULL,
  `cct` varchar(10) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
"
"In the context of a database schema, this SQL code represents a stored procedure named ""spCustomers_GetAll"". This procedure is designed to retrieve all records from the 'Customers' table in the database.

Here's what each part does:
1. The keyword `CREATE PROCEDURE` tells SQL Server we are creating a new stored procedure.
2. `[dbo].[spCustomers_GetAll]` is the name of our new stored procedure. Here 'dbo' represents the default schema in your database and 'spCustomers_GetAll' is the name of the procedure.
3. The keyword `AS` signals the start of a block of code that will be run when this stored procedure is called.
4. Inside this block, we have one command: `BEGIN...END` which contains two commands - SET NOCOUNT ON and SELECT statement.
5. `SET NOCOUNT ON;` tells SQL Server to suppress messages like '(1 row affected)', which are not useful when creating stored procedures.
6. The final line is the SELECT query that fetches all fields from the table Customers. It specifically pulls out [CustomerId], [FirstName], [LastName] etc., assuming these columns exist in your database schema.

Note: Without knowing more about the rest of your SQL script, it's hard to provide a full understanding. This instruction is based on this snippet provided.
","CREATE PROCEDURE [dbo].[spCustomers_GetAll]
AS
BEGIN
	SET NOCOUNT ON;

	SELECT [CustomerId], [FirstName], [LastName], [FullName], [Address], [Phone], [Email], [PayCentreId], [UploadReceipts]
	FROM [dbo].[Customers]
END
"
"In the context of this Ruby code, there are several classes defined.

1. The `Status` class is used to parse a specific HTML page on a networked device, likely an access point in a Wi-Fi network controlled by OpenWRT. It looks for specific divs containing information about wireless networks (WLAN) and routing tables. This data is then processed into instances of the `WLAN_Config` class.

2. The `Table_Iter` base class provides an iterator method, `table_iter()`, which returns rows from a table in the parsed HTML as sequences of text. It's used by two subclasses: `OLSR_Connections` and `OLSR_Routes`, that parse specific tables on those pages into dictionaries.

3. The `OLSR_Connections` class parses the OLSR (Optimized Link State Routing) connections table for each neighbor and their quality of service data.

4. The `OLSR_Routes` class parses the routes information to identify which interface a gateway belongs to, which is used in the OpenWRT network setup.

5. Finally, the `OpenWRT` class initializes an instance with a site (server address) and a request dictionary. It uses these to populate the request with parsed data about interfaces and IP addresses from those pages. This data includes information about the device's version and any wireless networks it is connected to.

Each of these classes has its own methods that are used to parse specific sections of the HTML page into Python objects, making this Ruby code useful for network administration tasks.
","#!/usr/bin/python
# -*- coding: utf-8 -*-
# #*** <License> ************************************************************#
# This module is part of the repository CNDB.
#
# This module is licensed under the terms of the BSD 3-Clause License
# <http://www.c-tanzer.at/license/bsd_3c.html>.
# #*** </License> ***********************************************************#

from   _TFL.pyk           import pyk

from   rsclib.HTML_Parse  import tag, Page_Tree
from   rsclib.autosuper   import autosuper
from   spider.common      import Interface, Inet4, Inet6, unroutable
from   spider.common      import WLAN_Config
from   spider.luci        import Version_Mixin

class Status (Page_Tree, Version_Mixin) :
    url          = 'cgi-bin/luci/freifunk/status/status'
    retries      = 2
    timeout      = 10
    html_charset = 'utf-8' # force utf-8 encoding

    wl_names = dict \
        ( ssid    = 'ssid'
        , _bsiid  = 'bssid'
        , channel = 'channel'
        , mode    = 'mode'
        )

    def parse (self) :
        root  = self.tree.getroot ()
        self.wlans  = []
        self.routes = {}
        for div in root.findall ("".//%s"" % tag (""div"")) :
            id = div.get ('id')
            if id == 'cbi-wireless' :
                wlan_div = div
            elif id == 'cbi-routes' :
                route_div = div
            self.try_get_version (div)
        for d in self.tbl_iter (wlan_div) :
            for k, newkey in pyk.iteritems (self.wl_names) :
                if k in d :
                    d [newkey] = d [k]
            wl = WLAN_Config (** d)
            self.wlans.append (wl)
        for d in self.tbl_iter (route_div) :
            iface = d.get ('iface')
            gw    = d.get ('gateway')
            if iface and gw :
                self.routes [iface] = gw
        self.set_version (root)
    # end def parse

    def tbl_iter (self, div) :
        tbl = div.find ("".//%s"" % tag (""table""))
        assert tbl.get ('class') == 'cbi-section-table'
        d = {}
        for tr in tbl :
            if 'cbi-section-table-row' not in tr.get ('class').split () :
                continue
            for input in tr.findall ("".//%s"" % tag ('input')) :
                name = input.get ('id').split ('.') [-1]
                val  = input.get ('value')
                d [name] = val
            if not d :
                continue
            yield d
    # end def tbl_iter

# end class Status

class Table_Iter (Page_Tree) :

    def table_iter (self) :
        root  = self.tree.getroot ()
        for div in root.findall ("".//%s"" % tag (""div"")) :
            if div.get ('id') == 'maincontent' :
                break
        tbl = div.find ("".//%s"" % tag (""table""))
        if tbl is None :
            return
        for tr in tbl :
            if tr [0].tag == tag ('th') :
                continue
            yield (self.tree.get_text (x) for x in tr)
    # end def table_iter

# end class Table_Iter

class OLSR_Connections (Table_Iter) :
    url          = 'cgi-bin/luci/freifunk/olsr/'
    retries      = 2
    timeout      = 10
    html_charset = 'utf-8' # force utf-8 encoding

    def parse (self) :
        self.neighbors = {}
        for l in self.table_iter () :
            neighbor, ip, lq, nlq, etx = l
            lq, nlq, etx = (float (x) for x in (lq, nlq, etx))
            self.neighbors [neighbor] = [ip, lq, nlq, etx]
    # end def parse

# end class OLSR_Connections

class OLSR_Routes (Table_Iter) :
    url          = 'cgi-bin/luci/freifunk/olsr/routes'
    retries      = 2
    timeout      = 10
    html_charset = 'utf-8' # force utf-8 encoding

    def parse (self) :
        self.iface_by_gw = {}
        for l in self.table_iter () :
            announced, gw, iface, metric, etx = l
            if gw in self.iface_by_gw :
                assert iface == self.iface_by_gw [gw]
            else :
                self.iface_by_gw [gw] = iface
    # end def parse

# end class OLSR_Routes

class OpenWRT (autosuper) :

    def __init__ (self, site, request) :
        self.site    = site
        self.request = request
        if 'interfaces' in self.request or 'ips' in self.request :
            st    = Status           (site = site)
            conn  = OLSR_Connections (site = site)
            route = OLSR_Routes      (site = site)
            self.version = st.version
            assert len (st.wlans) <= 1
            interfaces   = {}
            ips          = {}
            count = 0
            for gw, ifname in pyk.iteritems (route.iface_by_gw) :
                ip, lq, nlq, etx  = conn.neighbors [gw]
                i4 = Inet4 (ip, None, None, iface = ifname)
                ips [i4] = 1
                is_wlan = True
                if lq == nlq == etx == 1.0 :
                    is_wlan = False
                if ifname in interfaces :
                    iface = interfaces [ifname]
                    if not iface.is_wlan and is_wlan :
                        iface.is_wlan   = True
                        iface.wlan_info = st.wlans [0]
                else :
                    iface = Interface (count, ifname, None)
                    iface.is_wlan = is_wlan
                    if is_wlan :
                        iface.wlan_info = st.wlans [0]
                    count += 1
                    interfaces [ifname] = iface
                if i4 not in iface.inet4 :
                    iface.append_inet4 (i4)
            wl_if = None
            for iface in pyk.itervalues (interfaces) :
                if iface.is_wlan :
                    if wl_if :
                        m = ""Duplicate wlan: %s/%s"" % (iface.name, wl_if.name)
                        raise ValueError (m)
                    wl_if = iface
            # check own ip
            n  = 'unknown'
            i4 = Inet4 (self.request ['ip'], None, None, iface = n)
            if i4 not in ips :
                assert n not in interfaces
                iface = interfaces [n] = Interface (count, n, None)
                iface.append_inet4 (i4)
                iface.is_wlan = False
                if not wl_if and st.wlans :
                    iface.is_wlan   = True
                    iface.wlan_info = st.wlans [0]
                ips [i4] = True

            self.request ['ips']        = ips
            self.request ['interfaces'] = interfaces
            self.request ['version']    = st.version
    # end def __init__

# end class OpenWRT
"
"In the context of an image deduplication system, this code is designed to remove or keep duplicate images. It does so by comparing their wavelet hashes which are calculated based on the content (similarity in features) of the image rather than their physical size or location. The comparison threshold `DIFF_THRES` and limit `LIMIT` determine when an image should be removed or not.

The function `calc_hash(img)` calculates a wavelet hash for each image. This is essentially a unique fingerprint of the image content that can help differentiate between similar images. The function `compare(hash1, hash2)` calculates the difference between two hashes indicating how dissimilar (in terms of number of 'differences') they are from one another.

The function `limit(img, std_hash, count)` determines whether an image should be removed or not based on its similarity to a standard image and the total count of similar images seen so far. It also updates the comparison standard (std_hash) when necessary.

The function `resize(img)` resizes an image if it's height exceeds 1000 pixels, preserving the aspect ratio while making sure the new dimensions are multiples of 1000.

Finally, the function `set_standard(images, filename)` sets a new standard for comparison and updates information about this new standard (filename, hash of image content, count of similar images). This is used when starting to process a new set of images or after an existing one has been fully processed.

Please note that all these functions are meant to be used in the main part of your program where they interact with user input and output as well as handle reading/writing from/to disk based on that interaction.
","# UCF Senior Design 2017-18
# Group 38

from PIL import Image
import cv2
import imagehash
import math
import numpy as np

DIFF_THRES = 20
LIMIT = 2
RESIZE = 1000


def calc_hash(img):
    """"""
    Calculate the wavelet hash of the image
        img: (ndarray) image file
    """"""
    # resize image if height > 1000
    img = resize(img)
    return imagehash.whash(Image.fromarray(img))


def compare(hash1, hash2):
    """"""
    Calculate the difference between two images
        hash1: (array) first wavelet hash
        hash2: (array) second wavelet hash
    """"""
    return hash1 - hash2


def limit(img, std_hash, count):
    """"""
    Determine whether image should be removed from image dictionary in main.py
        img: (ndarray) image file
        std_hash: (array) wavelet hash of comparison standard
        count: (int) global count of images similar to comparison standard
    """"""
    # calculate hash for given image
    cmp_hash = calc_hash(img)

    # compare to standard
    diff = compare(std_hash, cmp_hash)

    # image is similar to standard
    if diff <= DIFF_THRES:
        # if there are 3 similar images already, remove image
        if count >= LIMIT:
            return 'remove'

    # non-similar image found
    else:
        # update comparison standard
        return 'update_std'

    # else continue reading images with same standard
    return 'continue'


def resize(img):
    """"""
    Resize an image
        img: (ndarray) RGB color image
    """"""
    # get dimensions of image
    width = np.shape(img)[1]
    height = np.shape(img)[0]

    # if height of image is greater than 1000, resize it to 1000
    if width > RESIZE:
        # keep resize proportional
        scale = RESIZE / width
        resized_img = cv2.resize(
            img, (RESIZE, math.floor(height / scale)), cv2.INTER_AREA)
        # return resized image
        return resized_img

    # if height of image is less than 1000, return image unresized
    return img


def set_standard(images, filename):
    """"""
    Set new comparison standard and update information
        images: (dictionary) dictionary containing all the image data
        filename: (String) name of the image file
    """"""
    return filename, calc_hash(images[filename]), 0
"
"In the context of a Ruby program, this code is a command-line interface (CLI) application that runs the `main` function from the 'cli' module. This function serves as the entry point for executing various commands related to the Kubeflow Pipelines system.

The license at the top of the script specifies that it is subject to the Apache 2.0 License, meaning it can be used and modified under certain conditions. The specifics are found in the link provided: http://www.apache.org/licenses/LICENSE-2.0

A TODO comment suggests additional commands could be added or improvements made. Specifically, more functionality to compile Kubeflow Pipelines (a tool for creating and managing machine learning workflows), as well as tools for experiment management are suggested.

At the end of the script, it checks if the file is being run directly by checking `__name__ == '__main__'`. If true, it executes `main()`, which should be defined elsewhere in the codebase to handle command line arguments and invoke appropriate functions based on those arguments.
","# Copyright 2018 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the ""License"");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an ""AS IS"" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from .cli.cli import main

# TODO(hongyes): add more commands:
# kfp compile (migrate from dsl-compile)
# kfp experiment (manage experiments)

if __name__ == '__main__':
    main()
"
"In the context of a Python project that uses PyQt5, QtGui and QtCore for GUI creation and manipulation. It also involves handling time-related data in Unix timestamp format. The code is creating a class `Room_Item` which is a widget displaying details about a room: name, description, creation date, member count, etc. This class is inherited from two base classes - QWidget for GUI widgets and Ui_Form (a pre-generated UI file), and it has methods to set the text of different labels in this form based on some input data (room_data). The room_data is expected to be a dictionary with keys like 'naturalName', 'description', etc. For instance, self.data['naturalName'] provides the natural name of the room.
","import time

from PyQt5 import QtGui, QtCore

from ui.room_item import Ui_Form
from PyQt5.QtWidgets import QWidget

class Room_Item(QWidget,Ui_Form):
    def __init__(self,parent=None,room_data=None):
        super(Room_Item,self).__init__(parent)
        self.setupUi(self)
        self.data = room_data
        self.setRoomInfo()

    def setRoomInfo(self):
        self.room_name.setText('{}({})'.format(self.data['naturalName'], self.data['roomName']))
        self.description.setText(""<a style='color:#BCBCBC'>{}</a>"".format(self.data['description']))
        timeStamp = int(self.data['creationDate']) / 1000
        timeArray = time.localtime(timeStamp)
        otherStyleTime = time.strftime(""%Y-%m-%d"", timeArray)
        self.create_time.setText(""<a style='color:#BCBCBC'>{}</a>"".format(otherStyleTime))
        members = len(self.data['owners']) + len(self.data['admins']) + len(self.data['members'])
        memberCounter = ""<a style='color:#BCBCBC'>{}/{}</a>"".format(members, ('∞' if self.data['maxUsers']==0 else self.data['maxUsers']))
        self.member.setText(memberCounter)"
"In the context of a graphical user interface application, we have an App class written in Python using the Toga library. The App is designed to run on Windows operating systems and manages the main window of the application.

The App class includes several methods that handle creation, menu creation, exception handling, and various actions related to the app's lifecycle such as setting up a context for the UI, handling exceptions in separate threads, running the app until exit, opening documents, showing about dialogs, etc.

Key attributes of the App class include:
- _is_exiting: A boolean attribute indicating whether the application is exiting or not.
- native: The WinForms Application object from Toga library for managing windows and UI elements.
- interface: An instance of the main app interface that this App represents.

The MainWindow class is a subclass of Window, which in turn has an implementation based on WinForms.MainWindow. It's designed to manage window closing procedures and includes a method called winforms_FormClosing which cancels window close event if application exit fails.

Besides these classes, there are other specific app types like DocumentApp that inherit from the App class with added functionalities for managing documents specifically. In this case, an additional 'Open...' command is created in their _create_app_commands method for opening files as a document. This code could be adapted for different contexts based on the requirements and platform it runs on.
","import asyncio
import re
import sys
import traceback

import toga
from toga import Key
from .keys import toga_to_winforms_key

from .libs import Threading, WinForms, shcore, user32, win_version
from .libs.proactor import WinformsProactorEventLoop
from .window import Window


class MainWindow(Window):
    def winforms_FormClosing(self, sender, event):
        if not self.interface.app._impl._is_exiting:
            event.Cancel = not self.interface.app.exit()


class App:
    _MAIN_WINDOW_CLASS = MainWindow

    def __init__(self, interface):
        self.interface = interface
        self.interface._impl = self

        # Winforms app exit is tightly bound to the close of the MainWindow.
        # The FormClosing message on MainWindow calls app.exit(), which
        # will then trigger the ""on_exit"" handler (which might abort the
        # close). However, if app.exit() succeeds, it will request the
        # Main Window to close... which calls app.exit().
        # So - we have a flag that is only ever sent once a request has been
        # made to exit the native app. This flag can be used to shortcut any
        # window-level close handling.
        self._is_exiting = False

        self.loop = WinformsProactorEventLoop()
        asyncio.set_event_loop(self.loop)

    def create(self):
        self.native = WinForms.Application
        self.app_context = WinForms.ApplicationContext()

        # Check the version of windows and make sure we are setting the DPI mode
        # with the most up to date API
        # Windows Versioning Check Sources : https://www.lifewire.com/windows-version-numbers-2625171
        # and https://docs.microsoft.com/en-us/windows/release-information/
        if win_version.Major >= 6:  # Checks for Windows Vista or later
            # Represents Windows 8.1 up to Windows 10 before Build 1703 which should use
            # SetProcessDpiAwareness(True)
            if ((win_version.Major == 6 and win_version.Minor == 3) or
                    (win_version.Major == 10 and win_version.Build < 15063)):
                shcore.SetProcessDpiAwareness(True)
            # Represents Windows 10 Build 1703 and beyond which should use
            # SetProcessDpiAwarenessContext(-2)
            elif win_version.Major == 10 and win_version.Build >= 15063:
                user32.SetProcessDpiAwarenessContext(-2)
            # Any other version of windows should use SetProcessDPIAware()
            else:
                user32.SetProcessDPIAware()

        self.native.EnableVisualStyles()
        self.native.SetCompatibleTextRenderingDefault(False)

        self.interface.commands.add(
            toga.Command(
                lambda _: self.interface.about(),
                'About {}'.format(self.interface.name),
                group=toga.Group.HELP
            ),
            toga.Command(None, 'Preferences', group=toga.Group.FILE),
            # Quit should always be the last item, in a section on it's own
            toga.Command(
                lambda _: self.interface.exit(),
                'Exit ' + self.interface.name,
                shortcut=Key.MOD_1 + 'q',
                group=toga.Group.FILE,
                section=sys.maxsize
            ),
            toga.Command(
                lambda _: self.interface.visit_homepage(),
                'Visit homepage',
                enabled=self.interface.home_page is not None,
                group=toga.Group.HELP
            )
        )
        self._create_app_commands()

        # Call user code to populate the main window
        self.interface.startup()
        self.create_menus()
        self.interface.icon.bind(self.interface.factory)
        self.interface.main_window._impl.set_app(self)

    def create_menus(self):
        self._menu_items = {}
        self._menu_groups = {}

        toga.Group.FILE.order = 0
        menubar = WinForms.MenuStrip()
        submenu = None
        for cmd in self.interface.commands:
            if cmd == toga.GROUP_BREAK:
                submenu = None
            elif cmd == toga.SECTION_BREAK:
                submenu.DropDownItems.Add('-')
            else:
                submenu = self._submenu(cmd.group, menubar)

                item = WinForms.ToolStripMenuItem(cmd.label)

                if cmd.action:
                    item.Click += cmd._impl.as_handler()
                item.Enabled = cmd.enabled

                if cmd.shortcut is not None:
                    shortcut_keys = toga_to_winforms_key(cmd.shortcut)
                    item.ShortcutKeys = shortcut_keys
                    item.ShowShortcutKeys = True

                cmd._impl.native.append(item)

                self._menu_items[item] = cmd
                submenu.DropDownItems.Add(item)

        self.interface.main_window._impl.native.Controls.Add(menubar)
        self.interface.main_window._impl.native.MainMenuStrip = menubar
        self.interface.main_window.content.refresh()

    def _submenu(self, group, menubar):
        try:
            return self._menu_groups[group]
        except KeyError:
            if group is None:
                submenu = menubar
            else:
                parent_menu = self._submenu(group.parent, menubar)

                submenu = WinForms.ToolStripMenuItem(group.label)

                # Top level menus are added in a different way to submenus
                if group.parent is None:
                    parent_menu.Items.Add(submenu)
                else:
                    parent_menu.DropDownItems.Add(submenu)

            self._menu_groups[group] = submenu
        return submenu

    def _create_app_commands(self):
        # No extra menus
        pass

    def open_document(self, fileURL):
        '''Add a new document to this app.'''
        print(""STUB: If you want to handle opening documents, implement App.open_document(fileURL)"")

    def winforms_thread_exception(self, sender, winforms_exc):
        # The PythonException returned by Winforms doesn't give us
        # easy access to the underlying Python stacktrace; so we
        # reconstruct it from the string message.
        # The Python message is helpfully included in square brackets,
        # as the context for the first line in the .net stack trace.
        # So, look for the closing bracket and the start of the Python.net
        # stack trace. Then, reconstruct the line breaks internal to the
        # remaining string.
        print(""Traceback (most recent call last):"")
        py_exc = winforms_exc.get_Exception()
        full_stack_trace = py_exc.StackTrace
        regex = re.compile(
            r""^\[(?:'(.*?)', )*(?:'(.*?)')\]   (?:.*?) Python\.Runtime"",
            re.DOTALL | re.UNICODE
        )

        stacktrace_relevant_lines = regex.findall(full_stack_trace)
        if len(stacktrace_relevant_lines) == 0:
            self.print_stack_trace(full_stack_trace)
        else:
            for lines in stacktrace_relevant_lines:
                for line in lines:
                    self.print_stack_trace(line)
        print(py_exc.Message)

    @classmethod
    def print_stack_trace(cls, stack_trace_line):
        for level in stack_trace_line.split(""', '""):
            for line in level.split(""\\n""):
                if line:
                    print(line)

    def run_app(self):
        try:
            self.create()

            self.native.ThreadException += self.winforms_thread_exception

            self.loop.run_forever(self.app_context)
        except:  # NOQA
            traceback.print_exc()

    def main_loop(self):
        thread = Threading.Thread(Threading.ThreadStart(self.run_app))
        thread.SetApartmentState(Threading.ApartmentState.STA)
        thread.Start()
        thread.Join()

    def show_about_dialog(self):
        message_parts = []
        if self.interface.name is not None:
            if self.interface.version is not None:
                message_parts.append(
                    ""{name} v{version}"".format(
                        name=self.interface.name,
                        version=self.interface.version,
                    )
                )
            else:
                message_parts.append(
                    ""{name}"".format(name=self.interface.name)
                )
        elif self.interface.version is not None:
            message_parts.append(
                ""v{version}"".format(version=self.interface.version)
            )

        if self.interface.author is not None:
            message_parts.append(
                ""Author: {author}"".format(author=self.interface.author)
            )
        if self.interface.description is not None:
            message_parts.append(
                ""\n{description}"".format(
                    description=self.interface.description
                )
            )
        self.interface.main_window.info_dialog(
            'About {}'.format(self.interface.name), ""\n"".join(message_parts)
        )

    def exit(self):
        self._is_exiting = True
        self.native.Exit()

    def set_main_window(self, window):
        self.app_context.MainForm = window._impl.native

    def set_on_exit(self, value):
        pass

    def current_window(self):
        self.interface.factory.not_implemented('App.current_window()')

    def enter_full_screen(self, windows):
        self.interface.factory.not_implemented('App.enter_full_screen()')

    def exit_full_screen(self, windows):
        self.interface.factory.not_implemented('App.exit_full_screen()')

    def set_cursor(self, value):
        self.interface.factory.not_implemented('App.set_cursor()')

    def show_cursor(self):
        self.interface.factory.not_implemented('App.show_cursor()')

    def hide_cursor(self):
        self.interface.factory.not_implemented('App.hide_cursor()')

    def add_background_task(self, handler):
        self.loop.call_soon(handler, self)


class DocumentApp(App):
    def _create_app_commands(self):
        self.interface.commands.add(
            toga.Command(
                lambda w: self.open_file,
                label='Open...',
                shortcut=Key.MOD_1 + 'o',
                group=toga.Group.FILE,
                section=0
            ),
        )

    def open_document(self, fileURL):
        """"""Open a new document in this app.

        Args:
            fileURL (str): The URL/path to the file to add as a document.
        """"""
        self.interface.factory.not_implemented('DocumentApp.open_document()')
"